[pkg-eucalyptus-commits] r230 - gwt/trunk/debian/patches
Chris Halls
halls at alioth.debian.org
Wed Jul 4 12:09:16 UTC 2012
Author: halls
Date: 2012-07-04 12:09:15 +0000 (Wed, 04 Jul 2012)
New Revision: 230
Modified:
gwt/trunk/debian/patches/build-with-jdt37
Log:
Remove SourceTypeBinding.java
For extra points, the patch as seen at upstream r10869 should be reapplied,
but my (quick) interpretation is this is more of a performance issue and
the packaging should work with the original version
Modified: gwt/trunk/debian/patches/build-with-jdt37
===================================================================
--- gwt/trunk/debian/patches/build-with-jdt37 2012-07-04 12:09:07 UTC (rev 229)
+++ gwt/trunk/debian/patches/build-with-jdt37 2012-07-04 12:09:15 UTC (rev 230)
@@ -4,40 +4,1680 @@
Bug-Debian: http://bugs.debian.org/629733
--- a/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
-+++ b/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
-@@ -26,6 +26,7 @@
- import org.eclipse.jdt.internal.compiler.impl.Constant;
- import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
- import org.eclipse.jdt.internal.compiler.util.Util;
-+import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
-
- import java.util.Hashtable;
- import java.util.Iterator;
-@@ -1202,13 +1203,14 @@
- }
- boolean isEnumSpecialMethod = isEnum() && (CharOperation.equals(selector,TypeConstants.VALUEOF) || CharOperation.equals(selector,TypeConstants.VALUES));
- // report duplicate
-+ int severity = ProblemSeverities.Error;
- if (methodDecl == null) {
- methodDecl = method.sourceMethod(); // cannot be retrieved after binding is lost & may still be null if method is special
- if (methodDecl != null && methodDecl.binding != null) { // ensure its a valid user defined method
- if (isEnumSpecialMethod) {
- this.scope.problemReporter().duplicateEnumSpecialMethod(this, methodDecl);
- } else {
++++ /dev/null
+@@ -1,1672 +0,0 @@
+-/*******************************************************************************
+- * Copyright (c) 2000, 2008 IBM Corporation and others.
+- * All rights reserved. This program and the accompanying materials
+- * are made available under the terms of the Eclipse Public License v1.0
+- * which accompanies this distribution, and is available at
+- * http://www.eclipse.org/legal/epl-v10.html
+- *
+- * Contributors:
+- * IBM Corporation - initial API and implementation
+- *******************************************************************************/
+-package org.eclipse.jdt.internal.compiler.lookup;
+-
+-import com.google.gwt.dev.util.collect.HashMap;
+-
+-import org.eclipse.jdt.core.compiler.CharOperation;
+-import org.eclipse.jdt.internal.compiler.ast.ASTNode;
+-import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
+-import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
+-import org.eclipse.jdt.internal.compiler.ast.Argument;
+-import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
+-import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
+-import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
+-import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
+-import org.eclipse.jdt.internal.compiler.ast.TypeReference;
+-import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
+-import org.eclipse.jdt.internal.compiler.impl.Constant;
+-import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
+-import org.eclipse.jdt.internal.compiler.util.Util;
+-
+-import java.util.Hashtable;
+-import java.util.Iterator;
+-
+-public class SourceTypeBinding extends ReferenceBinding {
+- public ReferenceBinding superclass;
+- public ReferenceBinding[] superInterfaces;
+- private FieldBinding[] fields;
+- private MethodBinding[] methods;
+- public ReferenceBinding[] memberTypes;
+- public TypeVariableBinding[] typeVariables;
+-
+- public ClassScope scope;
+-
+- // Synthetics are separated into 5 categories: methods, super methods, fields, class literals, changed declaring type bindings and bridge methods
+- // if a new category is added, also increment MAX_SYNTHETICS
+- private final static int METHOD_EMUL = 0;
+- private final static int FIELD_EMUL = 1;
+- private final static int CLASS_LITERAL_EMUL = 2;
+- private final static int RECEIVER_TYPE_EMUL = 3;
+-
+- private final static int MAX_SYNTHETICS = 4;
+-
+- HashMap[] synthetics;
+- char[] genericReferenceTypeSignature;
+-
+- private SimpleLookupTable storedAnnotations = null; // keys are this ReferenceBinding & its fields and methods, value is an AnnotationHolder
+-
+-public SourceTypeBinding(char[][] compoundName, PackageBinding fPackage, ClassScope scope) {
+- this.compoundName = compoundName;
+- this.fPackage = fPackage;
+- this.fileName = scope.referenceCompilationUnit().getFileName();
+- this.modifiers = scope.referenceContext.modifiers;
+- this.sourceName = scope.referenceContext.name;
+- this.scope = scope;
+-
+- // expect the fields & methods to be initialized correctly later
+- this.fields = Binding.UNINITIALIZED_FIELDS;
+- this.methods = Binding.UNINITIALIZED_METHODS;
+-
+- computeId();
+-}
+-
+-private void addDefaultAbstractMethods() {
+- if ((this.tagBits & TagBits.KnowsDefaultAbstractMethods) != 0) return;
+-
+- this.tagBits |= TagBits.KnowsDefaultAbstractMethods;
+- if (isClass() && isAbstract()) {
+- if (this.scope.compilerOptions().targetJDK >= ClassFileConstants.JDK1_2)
+- return; // no longer added for post 1.2 targets
+-
+- ReferenceBinding[] itsInterfaces = superInterfaces();
+- if (itsInterfaces != Binding.NO_SUPERINTERFACES) {
+- MethodBinding[] defaultAbstracts = null;
+- int defaultAbstractsCount = 0;
+- ReferenceBinding[] interfacesToVisit = itsInterfaces;
+- int nextPosition = interfacesToVisit.length;
+- for (int i = 0; i < nextPosition; i++) {
+- ReferenceBinding superType = interfacesToVisit[i];
+- if (superType.isValidBinding()) {
+- MethodBinding[] superMethods = superType.methods();
+- nextAbstractMethod: for (int m = superMethods.length; --m >= 0;) {
+- MethodBinding method = superMethods[m];
+- // explicitly implemented ?
+- if (implementsMethod(method))
+- continue nextAbstractMethod;
+- if (defaultAbstractsCount == 0) {
+- defaultAbstracts = new MethodBinding[5];
+- } else {
+- // already added as default abstract ?
+- for (int k = 0; k < defaultAbstractsCount; k++) {
+- MethodBinding alreadyAdded = defaultAbstracts[k];
+- if (CharOperation.equals(alreadyAdded.selector, method.selector) && alreadyAdded.areParametersEqual(method))
+- continue nextAbstractMethod;
+- }
+- }
+- MethodBinding defaultAbstract = new MethodBinding(
+- method.modifiers | ExtraCompilerModifiers.AccDefaultAbstract | ClassFileConstants.AccSynthetic,
+- method.selector,
+- method.returnType,
+- method.parameters,
+- method.thrownExceptions,
+- this);
+- if (defaultAbstractsCount == defaultAbstracts.length)
+- System.arraycopy(defaultAbstracts, 0, defaultAbstracts = new MethodBinding[2 * defaultAbstractsCount], 0, defaultAbstractsCount);
+- defaultAbstracts[defaultAbstractsCount++] = defaultAbstract;
+- }
+-
+- if ((itsInterfaces = superType.superInterfaces()) != Binding.NO_SUPERINTERFACES) {
+- int itsLength = itsInterfaces.length;
+- if (nextPosition + itsLength >= interfacesToVisit.length)
+- System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
+- nextInterface : for (int a = 0; a < itsLength; a++) {
+- ReferenceBinding next = itsInterfaces[a];
+- for (int b = 0; b < nextPosition; b++)
+- if (next == interfacesToVisit[b]) continue nextInterface;
+- interfacesToVisit[nextPosition++] = next;
+- }
+- }
+- }
+- }
+- if (defaultAbstractsCount > 0) {
+- int length = this.methods.length;
+- System.arraycopy(this.methods, 0, this.methods = new MethodBinding[length + defaultAbstractsCount], 0, length);
+- System.arraycopy(defaultAbstracts, 0, this.methods, length, defaultAbstractsCount);
+- // re-sort methods
+- length = length + defaultAbstractsCount;
+- if (length > 1)
+- ReferenceBinding.sortMethods(this.methods, 0, length);
+- // this.tagBits |= TagBits.AreMethodsSorted; -- already set in #methods()
+- }
+- }
+- }
+-}
+-/* Add a new synthetic field for <actualOuterLocalVariable>.
+-* Answer the new field or the existing field if one already existed.
+-*/
+-public FieldBinding addSyntheticFieldForInnerclass(LocalVariableBinding actualOuterLocalVariable) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.FIELD_EMUL] == null)
+- this.synthetics[SourceTypeBinding.FIELD_EMUL] = new HashMap();
+-
+- FieldBinding synthField = (FieldBinding) this.synthetics[SourceTypeBinding.FIELD_EMUL].get(actualOuterLocalVariable);
+- if (synthField == null) {
+- synthField = new SyntheticFieldBinding(
+- CharOperation.concat(TypeConstants.SYNTHETIC_OUTER_LOCAL_PREFIX, actualOuterLocalVariable.name),
+- actualOuterLocalVariable.type,
+- ClassFileConstants.AccPrivate | ClassFileConstants.AccFinal | ClassFileConstants.AccSynthetic,
+- this,
+- Constant.NotAConstant,
+- this.synthetics[SourceTypeBinding.FIELD_EMUL].size());
+- this.synthetics[SourceTypeBinding.FIELD_EMUL].put(actualOuterLocalVariable, synthField);
+- }
+-
+- // ensure there is not already such a field defined by the user
+- boolean needRecheck;
+- int index = 1;
+- do {
+- needRecheck = false;
+- FieldBinding existingField;
+- if ((existingField = this.getField(synthField.name, true /*resolve*/)) != null) {
+- TypeDeclaration typeDecl = this.scope.referenceContext;
+- for (int i = 0, max = typeDecl.fields.length; i < max; i++) {
+- FieldDeclaration fieldDecl = typeDecl.fields[i];
+- if (fieldDecl.binding == existingField) {
+- synthField.name = CharOperation.concat(
+- TypeConstants.SYNTHETIC_OUTER_LOCAL_PREFIX,
+- actualOuterLocalVariable.name,
+- ("$" + String.valueOf(index++)).toCharArray()); //$NON-NLS-1$
+- needRecheck = true;
+- break;
+- }
+- }
+- }
+- } while (needRecheck);
+- return synthField;
+-}
+-/* Add a new synthetic field for <enclosingType>.
+-* Answer the new field or the existing field if one already existed.
+-*/
+-public FieldBinding addSyntheticFieldForInnerclass(ReferenceBinding enclosingType) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.FIELD_EMUL] == null)
+- this.synthetics[SourceTypeBinding.FIELD_EMUL] = new HashMap();
+-
+- FieldBinding synthField = (FieldBinding) this.synthetics[SourceTypeBinding.FIELD_EMUL].get(enclosingType);
+- if (synthField == null) {
+- synthField = new SyntheticFieldBinding(
+- CharOperation.concat(
+- TypeConstants.SYNTHETIC_ENCLOSING_INSTANCE_PREFIX,
+- String.valueOf(enclosingType.depth()).toCharArray()),
+- enclosingType,
+- ClassFileConstants.AccDefault | ClassFileConstants.AccFinal | ClassFileConstants.AccSynthetic,
+- this,
+- Constant.NotAConstant,
+- this.synthetics[SourceTypeBinding.FIELD_EMUL].size());
+- this.synthetics[SourceTypeBinding.FIELD_EMUL].put(enclosingType, synthField);
+- }
+- // ensure there is not already such a field defined by the user
+- boolean needRecheck;
+- do {
+- needRecheck = false;
+- FieldBinding existingField;
+- if ((existingField = this.getField(synthField.name, true /*resolve*/)) != null) {
+- TypeDeclaration typeDecl = this.scope.referenceContext;
+- for (int i = 0, max = typeDecl.fields.length; i < max; i++) {
+- FieldDeclaration fieldDecl = typeDecl.fields[i];
+- if (fieldDecl.binding == existingField) {
+- if (this.scope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_5) {
+- synthField.name = CharOperation.concat(
+- synthField.name,
+- "$".toCharArray()); //$NON-NLS-1$
+- needRecheck = true;
+- } else {
+- this.scope.problemReporter().duplicateFieldInType(this, fieldDecl);
+- }
+- break;
+- }
+- }
+- }
+- } while (needRecheck);
+- return synthField;
+-}
+-/* Add a new synthetic field for a class literal access.
+-* Answer the new field or the existing field if one already existed.
+-*/
+-public FieldBinding addSyntheticFieldForClassLiteral(TypeBinding targetType, BlockScope blockScope) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL] == null)
+- this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL] = new HashMap();
+-
+- // use a different table than FIELDS, given there might be a collision between emulation of X.this$0 and X.class.
+- FieldBinding synthField = (FieldBinding) this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL].get(targetType);
+- if (synthField == null) {
+- synthField = new SyntheticFieldBinding(
+- CharOperation.concat(
+- TypeConstants.SYNTHETIC_CLASS,
+- String.valueOf(this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL].size()).toCharArray()),
+- blockScope.getJavaLangClass(),
+- ClassFileConstants.AccDefault | ClassFileConstants.AccStatic | ClassFileConstants.AccSynthetic,
+- this,
+- Constant.NotAConstant,
+- this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL].size());
+- this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL].put(targetType, synthField);
+- }
+- // ensure there is not already such a field defined by the user
+- FieldBinding existingField;
+- if ((existingField = this.getField(synthField.name, true /*resolve*/)) != null) {
+- TypeDeclaration typeDecl = blockScope.referenceType();
+- for (int i = 0, max = typeDecl.fields.length; i < max; i++) {
+- FieldDeclaration fieldDecl = typeDecl.fields[i];
+- if (fieldDecl.binding == existingField) {
+- blockScope.problemReporter().duplicateFieldInType(this, fieldDecl);
+- break;
+- }
+- }
+- }
+- return synthField;
+-}
+-/* Add a new synthetic field for the emulation of the assert statement.
+-* Answer the new field or the existing field if one already existed.
+-*/
+-public FieldBinding addSyntheticFieldForAssert(BlockScope blockScope) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.FIELD_EMUL] == null)
+- this.synthetics[SourceTypeBinding.FIELD_EMUL] = new HashMap();
+-
+- FieldBinding synthField = (FieldBinding) this.synthetics[SourceTypeBinding.FIELD_EMUL].get("assertionEmulation"); //$NON-NLS-1$
+- if (synthField == null) {
+- synthField = new SyntheticFieldBinding(
+- TypeConstants.SYNTHETIC_ASSERT_DISABLED,
+- TypeBinding.BOOLEAN,
+- ClassFileConstants.AccDefault | ClassFileConstants.AccStatic | ClassFileConstants.AccSynthetic | ClassFileConstants.AccFinal,
+- this,
+- Constant.NotAConstant,
+- this.synthetics[SourceTypeBinding.FIELD_EMUL].size());
+- this.synthetics[SourceTypeBinding.FIELD_EMUL].put("assertionEmulation", synthField); //$NON-NLS-1$
+- }
+- // ensure there is not already such a field defined by the user
+- // ensure there is not already such a field defined by the user
+- boolean needRecheck;
+- int index = 0;
+- do {
+- needRecheck = false;
+- FieldBinding existingField;
+- if ((existingField = this.getField(synthField.name, true /*resolve*/)) != null) {
+- TypeDeclaration typeDecl = this.scope.referenceContext;
+- for (int i = 0, max = typeDecl.fields.length; i < max; i++) {
+- FieldDeclaration fieldDecl = typeDecl.fields[i];
+- if (fieldDecl.binding == existingField) {
+- synthField.name = CharOperation.concat(
+- TypeConstants.SYNTHETIC_ASSERT_DISABLED,
+- ("_" + String.valueOf(index++)).toCharArray()); //$NON-NLS-1$
+- needRecheck = true;
+- break;
+- }
+- }
+- }
+- } while (needRecheck);
+- return synthField;
+-}
+-/* Add a new synthetic field for recording all enum constant values
+-* Answer the new field or the existing field if one already existed.
+-*/
+-public FieldBinding addSyntheticFieldForEnumValues() {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.FIELD_EMUL] == null)
+- this.synthetics[SourceTypeBinding.FIELD_EMUL] = new HashMap();
+-
+- FieldBinding synthField = (FieldBinding) this.synthetics[SourceTypeBinding.FIELD_EMUL].get("enumConstantValues"); //$NON-NLS-1$
+- if (synthField == null) {
+- synthField = new SyntheticFieldBinding(
+- TypeConstants.SYNTHETIC_ENUM_VALUES,
+- this.scope.createArrayType(this,1),
+- ClassFileConstants.AccPrivate | ClassFileConstants.AccStatic | ClassFileConstants.AccSynthetic | ClassFileConstants.AccFinal,
+- this,
+- Constant.NotAConstant,
+- this.synthetics[SourceTypeBinding.FIELD_EMUL].size());
+- this.synthetics[SourceTypeBinding.FIELD_EMUL].put("enumConstantValues", synthField); //$NON-NLS-1$
+- }
+- // ensure there is not already such a field defined by the user
+- // ensure there is not already such a field defined by the user
+- boolean needRecheck;
+- int index = 0;
+- do {
+- needRecheck = false;
+- FieldBinding existingField;
+- if ((existingField = this.getField(synthField.name, true /*resolve*/)) != null) {
+- TypeDeclaration typeDecl = this.scope.referenceContext;
+- for (int i = 0, max = typeDecl.fields.length; i < max; i++) {
+- FieldDeclaration fieldDecl = typeDecl.fields[i];
+- if (fieldDecl.binding == existingField) {
+- synthField.name = CharOperation.concat(
+- TypeConstants.SYNTHETIC_ENUM_VALUES,
+- ("_" + String.valueOf(index++)).toCharArray()); //$NON-NLS-1$
+- needRecheck = true;
+- break;
+- }
+- }
+- }
+- } while (needRecheck);
+- return synthField;
+-}
+-/* Add a new synthetic access method for read/write access to <targetField>.
+- Answer the new method or the existing method if one already existed.
+-*/
+-public SyntheticMethodBinding addSyntheticMethod(FieldBinding targetField, boolean isReadAccess) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.METHOD_EMUL] == null)
+- this.synthetics[SourceTypeBinding.METHOD_EMUL] = new HashMap();
+-
+- SyntheticMethodBinding accessMethod = null;
+- SyntheticMethodBinding[] accessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(targetField);
+- if (accessors == null) {
+- accessMethod = new SyntheticMethodBinding(targetField, isReadAccess, false, this);
+- this.synthetics[SourceTypeBinding.METHOD_EMUL].put(targetField, accessors = new SyntheticMethodBinding[2]);
+- accessors[isReadAccess ? 0 : 1] = accessMethod;
+- } else {
+- if ((accessMethod = accessors[isReadAccess ? 0 : 1]) == null) {
+- accessMethod = new SyntheticMethodBinding(targetField, isReadAccess, false, this);
+- accessors[isReadAccess ? 0 : 1] = accessMethod;
+- }
+- }
+- return accessMethod;
+-}
+-/* Add a new synthetic method the enum type. Selector can either be 'values' or 'valueOf'.
+- * char[] constants from TypeConstants must be used: TypeConstants.VALUES/VALUEOF
+-*/
+-public SyntheticMethodBinding addSyntheticEnumMethod(char[] selector) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.METHOD_EMUL] == null)
+- this.synthetics[SourceTypeBinding.METHOD_EMUL] = new HashMap();
+-
+- SyntheticMethodBinding accessMethod = null;
+- SyntheticMethodBinding[] accessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(selector);
+- if (accessors == null) {
+- accessMethod = new SyntheticMethodBinding(this, selector);
+- this.synthetics[SourceTypeBinding.METHOD_EMUL].put(selector, accessors = new SyntheticMethodBinding[2]);
+- accessors[0] = accessMethod;
+- } else {
+- if ((accessMethod = accessors[0]) == null) {
+- accessMethod = new SyntheticMethodBinding(this, selector);
+- accessors[0] = accessMethod;
+- }
+- }
+- return accessMethod;
+-}
+-/*
+- * Add a synthetic field to handle the cache of the switch translation table for the corresponding enum type
+- */
+-public SyntheticFieldBinding addSyntheticFieldForSwitchEnum(char[] fieldName, String key) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.FIELD_EMUL] == null)
+- this.synthetics[SourceTypeBinding.FIELD_EMUL] = new HashMap();
+-
+- SyntheticFieldBinding synthField = (SyntheticFieldBinding) this.synthetics[SourceTypeBinding.FIELD_EMUL].get(key);
+- if (synthField == null) {
+- synthField = new SyntheticFieldBinding(
+- fieldName,
+- this.scope.createArrayType(TypeBinding.INT,1),
+- ClassFileConstants.AccPrivate | ClassFileConstants.AccStatic | ClassFileConstants.AccSynthetic,
+- this,
+- Constant.NotAConstant,
+- this.synthetics[SourceTypeBinding.FIELD_EMUL].size());
+- this.synthetics[SourceTypeBinding.FIELD_EMUL].put(key, synthField);
+- }
+- // ensure there is not already such a field defined by the user
+- boolean needRecheck;
+- int index = 0;
+- do {
+- needRecheck = false;
+- FieldBinding existingField;
+- if ((existingField = this.getField(synthField.name, true /*resolve*/)) != null) {
+- TypeDeclaration typeDecl = this.scope.referenceContext;
+- for (int i = 0, max = typeDecl.fields.length; i < max; i++) {
+- FieldDeclaration fieldDecl = typeDecl.fields[i];
+- if (fieldDecl.binding == existingField) {
+- synthField.name = CharOperation.concat(
+- fieldName,
+- ("_" + String.valueOf(index++)).toCharArray()); //$NON-NLS-1$
+- needRecheck = true;
+- break;
+- }
+- }
+- }
+- } while (needRecheck);
+- return synthField;
+-}
+-/* Add a new synthetic method the enum type. Selector can either be 'values' or 'valueOf'.
+- * char[] constants from TypeConstants must be used: TypeConstants.VALUES/VALUEOF
+-*/
+-public SyntheticMethodBinding addSyntheticMethodForSwitchEnum(TypeBinding enumBinding) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.METHOD_EMUL] == null)
+- this.synthetics[SourceTypeBinding.METHOD_EMUL] = new HashMap();
+-
+- SyntheticMethodBinding accessMethod = null;
+- char[] selector = CharOperation.concat(TypeConstants.SYNTHETIC_SWITCH_ENUM_TABLE, enumBinding.constantPoolName());
+- CharOperation.replace(selector, '/', '$');
+- final String key = new String(selector);
+- SyntheticMethodBinding[] accessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(key);
+- // first add the corresponding synthetic field
+- if (accessors == null) {
+- // then create the synthetic method
+- final SyntheticFieldBinding fieldBinding = this.addSyntheticFieldForSwitchEnum(selector, key);
+- accessMethod = new SyntheticMethodBinding(fieldBinding, this, enumBinding, selector);
+- this.synthetics[SourceTypeBinding.METHOD_EMUL].put(key, accessors = new SyntheticMethodBinding[2]);
+- accessors[0] = accessMethod;
+- } else {
+- if ((accessMethod = accessors[0]) == null) {
+- final SyntheticFieldBinding fieldBinding = this.addSyntheticFieldForSwitchEnum(selector, key);
+- accessMethod = new SyntheticMethodBinding(fieldBinding, this, enumBinding, selector);
+- accessors[0] = accessMethod;
+- }
+- }
+- return accessMethod;
+-}
+-/* Add a new synthetic access method for access to <targetMethod>.
+- * Must distinguish access method used for super access from others (need to use invokespecial bytecode)
+- Answer the new method or the existing method if one already existed.
+-*/
+-public SyntheticMethodBinding addSyntheticMethod(MethodBinding targetMethod, boolean isSuperAccess) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.METHOD_EMUL] == null)
+- this.synthetics[SourceTypeBinding.METHOD_EMUL] = new HashMap();
+-
+- SyntheticMethodBinding accessMethod = null;
+- SyntheticMethodBinding[] accessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(targetMethod);
+- if (accessors == null) {
+- accessMethod = new SyntheticMethodBinding(targetMethod, isSuperAccess, this);
+- this.synthetics[SourceTypeBinding.METHOD_EMUL].put(targetMethod, accessors = new SyntheticMethodBinding[2]);
+- accessors[isSuperAccess ? 0 : 1] = accessMethod;
+- } else {
+- if ((accessMethod = accessors[isSuperAccess ? 0 : 1]) == null) {
+- accessMethod = new SyntheticMethodBinding(targetMethod, isSuperAccess, this);
+- accessors[isSuperAccess ? 0 : 1] = accessMethod;
+- }
+- }
+- return accessMethod;
+-}
+-/*
+- * Record the fact that bridge methods need to be generated to override certain inherited methods
+- */
+-public SyntheticMethodBinding addSyntheticBridgeMethod(MethodBinding inheritedMethodToBridge, MethodBinding targetMethod) {
+- if (isInterface()) return null; // only classes & enums get bridge methods
+- // targetMethod may be inherited
+- if (inheritedMethodToBridge.returnType.erasure() == targetMethod.returnType.erasure()
+- && inheritedMethodToBridge.areParameterErasuresEqual(targetMethod)) {
+- return null; // do not need bridge method
+- }
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.METHOD_EMUL] == null) {
+- this.synthetics[SourceTypeBinding.METHOD_EMUL] = new HashMap();
+- } else {
+- // check to see if there is another equivalent inheritedMethod already added
+- Iterator synthMethods = this.synthetics[SourceTypeBinding.METHOD_EMUL].keySet().iterator();
+- while (synthMethods.hasNext()) {
+- Object synthetic = synthMethods.next();
+- if (synthetic instanceof MethodBinding) {
+- MethodBinding method = (MethodBinding) synthetic;
+- if (CharOperation.equals(inheritedMethodToBridge.selector, method.selector)
+- && inheritedMethodToBridge.returnType.erasure() == method.returnType.erasure()
+- && inheritedMethodToBridge.areParameterErasuresEqual(method)) {
+- return null;
+- }
+- }
+- }
+- }
+-
+- SyntheticMethodBinding accessMethod = null;
+- SyntheticMethodBinding[] accessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(inheritedMethodToBridge);
+- if (accessors == null) {
+- accessMethod = new SyntheticMethodBinding(inheritedMethodToBridge, targetMethod, this);
+- this.synthetics[SourceTypeBinding.METHOD_EMUL].put(inheritedMethodToBridge, accessors = new SyntheticMethodBinding[2]);
+- accessors[1] = accessMethod;
+- } else {
+- if ((accessMethod = accessors[1]) == null) {
+- accessMethod = new SyntheticMethodBinding(inheritedMethodToBridge, targetMethod, this);
+- accessors[1] = accessMethod;
+- }
+- }
+- return accessMethod;
+-}
+-boolean areFieldsInitialized() {
+- return this.fields != Binding.UNINITIALIZED_FIELDS;
+-}
+-boolean areMethodsInitialized() {
+- return this.methods != Binding.UNINITIALIZED_METHODS;
+-}
+-public int kind() {
+- if (this.typeVariables != Binding.NO_TYPE_VARIABLES) return Binding.GENERIC_TYPE;
+- return Binding.TYPE;
+-}
+-
+-public char[] computeUniqueKey(boolean isLeaf) {
+- char[] uniqueKey = super.computeUniqueKey(isLeaf);
+- if (uniqueKey.length == 2) return uniqueKey; // problem type's unique key is "L;"
+- if (Util.isClassFileName(this.fileName)) return uniqueKey; // no need to insert compilation unit name for a .class file
+-
+- // insert compilation unit name if the type name is not the main type name
+- int end = CharOperation.lastIndexOf('.', this.fileName);
+- if (end != -1) {
+- int start = CharOperation.lastIndexOf('/', this.fileName) + 1;
+- char[] mainTypeName = CharOperation.subarray(this.fileName, start, end);
+- start = CharOperation.lastIndexOf('/', uniqueKey) + 1;
+- if (start == 0)
+- start = 1; // start after L
+- end = CharOperation.indexOf('$', uniqueKey, start);
+- if (end == -1)
+- end = CharOperation.indexOf('<', uniqueKey, start);
+- if (end == -1)
+- end = CharOperation.indexOf(';', uniqueKey, start);
+- char[] topLevelType = CharOperation.subarray(uniqueKey, start, end);
+- if (!CharOperation.equals(topLevelType, mainTypeName)) {
+- StringBuffer buffer = new StringBuffer();
+- buffer.append(uniqueKey, 0, start);
+- buffer.append(mainTypeName);
+- buffer.append('~');
+- buffer.append(topLevelType);
+- buffer.append(uniqueKey, end, uniqueKey.length - end);
+- int length = buffer.length();
+- uniqueKey = new char[length];
+- buffer.getChars(0, length, uniqueKey, 0);
+- return uniqueKey;
+- }
+- }
+- return uniqueKey;
+-}
+-
+-void faultInTypesForFieldsAndMethods() {
+- // check @Deprecated annotation
+- getAnnotationTagBits(); // marks as deprecated by side effect
+- ReferenceBinding enclosingType = this.enclosingType();
+- if (enclosingType != null && enclosingType.isViewedAsDeprecated() && !this.isDeprecated())
+- this.modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
+- fields();
+- methods();
+-
+- for (int i = 0, length = this.memberTypes.length; i < length; i++)
+- ((SourceTypeBinding) this.memberTypes[i]).faultInTypesForFieldsAndMethods();
+-}
+-// NOTE: the type of each field of a source type is resolved when needed
+-public FieldBinding[] fields() {
+- if ((this.tagBits & TagBits.AreFieldsComplete) != 0)
+- return this.fields;
+-
+- int failed = 0;
+- FieldBinding[] resolvedFields = this.fields;
+- try {
+- // lazily sort fields
+- if ((this.tagBits & TagBits.AreFieldsSorted) == 0) {
+- int length = this.fields.length;
+- if (length > 1)
+- ReferenceBinding.sortFields(this.fields, 0, length);
+- this.tagBits |= TagBits.AreFieldsSorted;
+- }
+- for (int i = 0, length = this.fields.length; i < length; i++) {
+- if (resolveTypeFor(this.fields[i]) == null) {
+- // do not alter original field array until resolution is over, due to reentrance (143259)
+- if (resolvedFields == this.fields) {
+- System.arraycopy(this.fields, 0, resolvedFields = new FieldBinding[length], 0, length);
+- }
+- resolvedFields[i] = null;
+- failed++;
+- }
+- }
+- } finally {
+- if (failed > 0) {
+- // ensure fields are consistent reqardless of the error
+- int newSize = resolvedFields.length - failed;
+- if (newSize == 0)
+- return this.fields = Binding.NO_FIELDS;
+-
+- FieldBinding[] newFields = new FieldBinding[newSize];
+- for (int i = 0, j = 0, length = resolvedFields.length; i < length; i++) {
+- if (resolvedFields[i] != null)
+- newFields[j++] = resolvedFields[i];
+- }
+- this.fields = newFields;
+- }
+- }
+- this.tagBits |= TagBits.AreFieldsComplete;
+- return this.fields;
+-}
+-/**
+- * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#genericTypeSignature()
+- */
+-public char[] genericTypeSignature() {
+- if (this.genericReferenceTypeSignature == null)
+- this.genericReferenceTypeSignature = computeGenericTypeSignature(this.typeVariables);
+- return this.genericReferenceTypeSignature;
+-}
+-/**
+- * <param1 ... paramN>superclass superinterface1 ... superinterfaceN
+- * <T:LY<TT;>;U:Ljava/lang/Object;V::Ljava/lang/Runnable;:Ljava/lang/Cloneable;:Ljava/util/Map;>Ljava/lang/Exception;Ljava/lang/Runnable;
+- */
+-public char[] genericSignature() {
+- StringBuffer sig = null;
+- if (this.typeVariables != Binding.NO_TYPE_VARIABLES) {
+- sig = new StringBuffer(10);
+- sig.append('<');
+- for (int i = 0, length = this.typeVariables.length; i < length; i++)
+- sig.append(this.typeVariables[i].genericSignature());
+- sig.append('>');
+- } else {
+- // could still need a signature if any of supertypes is parameterized
+- noSignature: if (this.superclass == null || !this.superclass.isParameterizedType()) {
+- for (int i = 0, length = this.superInterfaces.length; i < length; i++)
+- if (this.superInterfaces[i].isParameterizedType())
+- break noSignature;
+- return null;
+- }
+- sig = new StringBuffer(10);
+- }
+- if (this.superclass != null)
+- sig.append(this.superclass.genericTypeSignature());
+- else // interface scenario only (as Object cannot be generic) - 65953
+- sig.append(this.scope.getJavaLangObject().genericTypeSignature());
+- for (int i = 0, length = this.superInterfaces.length; i < length; i++)
+- sig.append(this.superInterfaces[i].genericTypeSignature());
+- return sig.toString().toCharArray();
+-}
+-
+-/**
+- * Compute the tagbits for standard annotations. For source types, these could require
+- * lazily resolving corresponding annotation nodes, in case of forward references.
+- * @see org.eclipse.jdt.internal.compiler.lookup.Binding#getAnnotationTagBits()
+- */
+-public long getAnnotationTagBits() {
+- if ((this.tagBits & TagBits.AnnotationResolved) == 0 && this.scope != null) {
+- TypeDeclaration typeDecl = this.scope.referenceContext;
+- boolean old = typeDecl.staticInitializerScope.insideTypeAnnotation;
+- try {
+- typeDecl.staticInitializerScope.insideTypeAnnotation = true;
+- ASTNode.resolveAnnotations(typeDecl.staticInitializerScope, typeDecl.annotations, this);
+- } finally {
+- typeDecl.staticInitializerScope.insideTypeAnnotation = old;
+- }
+- if ((this.tagBits & TagBits.AnnotationDeprecated) != 0)
+- this.modifiers |= ClassFileConstants.AccDeprecated;
+- }
+- return this.tagBits;
+-}
+-public MethodBinding[] getDefaultAbstractMethods() {
+- int count = 0;
+- for (int i = this.methods.length; --i >= 0;)
+- if (this.methods[i].isDefaultAbstract())
+- count++;
+- if (count == 0) return Binding.NO_METHODS;
+-
+- MethodBinding[] result = new MethodBinding[count];
+- count = 0;
+- for (int i = this.methods.length; --i >= 0;)
+- if (this.methods[i].isDefaultAbstract())
+- result[count++] = this.methods[i];
+- return result;
+-}
+-// NOTE: the return type, arg & exception types of each method of a source type are resolved when needed
+-public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) {
+- int argCount = argumentTypes.length;
+- if ((this.tagBits & TagBits.AreMethodsComplete) != 0) { // have resolved all arg types & return type of the methods
+- long range;
+- if ((range = ReferenceBinding.binarySearch(TypeConstants.INIT, this.methods)) >= 0) {
+- nextMethod: for (int imethod = (int)range, end = (int)(range >> 32); imethod <= end; imethod++) {
+- MethodBinding method = this.methods[imethod];
+- if (method.parameters.length == argCount) {
+- TypeBinding[] toMatch = method.parameters;
+- for (int iarg = 0; iarg < argCount; iarg++)
+- if (toMatch[iarg] != argumentTypes[iarg])
+- continue nextMethod;
+- return method;
+- }
+- }
+- }
+- } else {
+- // lazily sort methods
+- if ((this.tagBits & TagBits.AreMethodsSorted) == 0) {
+- int length = this.methods.length;
+- if (length > 1)
+- ReferenceBinding.sortMethods(this.methods, 0, length);
+- this.tagBits |= TagBits.AreMethodsSorted;
+- }
+- long range;
+- if ((range = ReferenceBinding.binarySearch(TypeConstants.INIT, this.methods)) >= 0) {
+- nextMethod: for (int imethod = (int)range, end = (int)(range >> 32); imethod <= end; imethod++) {
+- MethodBinding method = this.methods[imethod];
+- if (resolveTypesFor(method) == null || method.returnType == null) {
+- methods();
+- return getExactConstructor(argumentTypes); // try again since the problem methods have been removed
+- }
+- if (method.parameters.length == argCount) {
+- TypeBinding[] toMatch = method.parameters;
+- for (int iarg = 0; iarg < argCount; iarg++)
+- if (toMatch[iarg] != argumentTypes[iarg])
+- continue nextMethod;
+- return method;
+- }
+- }
+- }
+- }
+- return null;
+-}
+-
+-//NOTE: the return type, arg & exception types of each method of a source type are resolved when needed
+-//searches up the hierarchy as long as no potential (but not exact) match was found.
+-public MethodBinding getExactMethod(char[] selector, TypeBinding[] argumentTypes, CompilationUnitScope refScope) {
+- // sender from refScope calls recordTypeReference(this)
+- int argCount = argumentTypes.length;
+- boolean foundNothing = true;
+-
+- if ((this.tagBits & TagBits.AreMethodsComplete) != 0) { // have resolved all arg types & return type of the methods
+- long range;
+- if ((range = ReferenceBinding.binarySearch(selector, this.methods)) >= 0) {
+- nextMethod: for (int imethod = (int)range, end = (int)(range >> 32); imethod <= end; imethod++) {
+- MethodBinding method = this.methods[imethod];
+- foundNothing = false; // inner type lookups must know that a method with this name exists
+- if (method.parameters.length == argCount) {
+- TypeBinding[] toMatch = method.parameters;
+- for (int iarg = 0; iarg < argCount; iarg++)
+- if (toMatch[iarg] != argumentTypes[iarg])
+- continue nextMethod;
+- return method;
+- }
+- }
+- }
+- } else {
+- // lazily sort methods
+- if ((this.tagBits & TagBits.AreMethodsSorted) == 0) {
+- int length = this.methods.length;
+- if (length > 1)
+- ReferenceBinding.sortMethods(this.methods, 0, length);
+- this.tagBits |= TagBits.AreMethodsSorted;
+- }
+-
+- long range;
+- if ((range = ReferenceBinding.binarySearch(selector, this.methods)) >= 0) {
+- // check unresolved method
+- int start = (int) range, end = (int) (range >> 32);
+- for (int imethod = start; imethod <= end; imethod++) {
+- MethodBinding method = this.methods[imethod];
+- if (resolveTypesFor(method) == null || method.returnType == null) {
+- methods();
+- return getExactMethod(selector, argumentTypes, refScope); // try again since the problem methods have been removed
+- }
+- }
+- // check dup collisions
+- boolean isSource15 = this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5;
+- for (int i = start; i <= end; i++) {
+- MethodBinding method1 = this.methods[i];
+- for (int j = end; j > i; j--) {
+- MethodBinding method2 = this.methods[j];
+- boolean paramsMatch = isSource15
+- ? method1.areParameterErasuresEqual(method2)
+- : method1.areParametersEqual(method2);
+- if (paramsMatch) {
+- methods();
+- return getExactMethod(selector, argumentTypes, refScope); // try again since the problem methods have been removed
+- }
+- }
+- }
+- nextMethod: for (int imethod = start; imethod <= end; imethod++) {
+- MethodBinding method = this.methods[imethod];
+- TypeBinding[] toMatch = method.parameters;
+- if (toMatch.length == argCount) {
+- for (int iarg = 0; iarg < argCount; iarg++)
+- if (toMatch[iarg] != argumentTypes[iarg])
+- continue nextMethod;
+- return method;
+- }
+- }
+- }
+- }
+-
+- if (foundNothing) {
+- if (isInterface()) {
+- if (this.superInterfaces.length == 1) {
+- if (refScope != null)
+- refScope.recordTypeReference(this.superInterfaces[0]);
+- return this.superInterfaces[0].getExactMethod(selector, argumentTypes, refScope);
+- }
+- } else if (this.superclass != null) {
+- if (refScope != null)
+- refScope.recordTypeReference(this.superclass);
+- return this.superclass.getExactMethod(selector, argumentTypes, refScope);
+- }
+- }
+- return null;
+-}
+-
+-//NOTE: the type of a field of a source type is resolved when needed
+-public FieldBinding getField(char[] fieldName, boolean needResolve) {
+-
+- if ((this.tagBits & TagBits.AreFieldsComplete) != 0)
+- return ReferenceBinding.binarySearch(fieldName, this.fields);
+-
+- // lazily sort fields
+- if ((this.tagBits & TagBits.AreFieldsSorted) == 0) {
+- int length = this.fields.length;
+- if (length > 1)
+- ReferenceBinding.sortFields(this.fields, 0, length);
+- this.tagBits |= TagBits.AreFieldsSorted;
+- }
+- // always resolve anyway on source types
+- FieldBinding field = ReferenceBinding.binarySearch(fieldName, this.fields);
+- if (field != null) {
+- FieldBinding result = null;
+- try {
+- result = resolveTypeFor(field);
+- return result;
+- } finally {
+- if (result == null) {
+- // ensure fields are consistent reqardless of the error
+- int newSize = this.fields.length - 1;
+- if (newSize == 0) {
+- this.fields = Binding.NO_FIELDS;
+- } else {
+- FieldBinding[] newFields = new FieldBinding[newSize];
+- int index = 0;
+- for (int i = 0, length = this.fields.length; i < length; i++) {
+- FieldBinding f = this.fields[i];
+- if (f == field) continue;
+- newFields[index++] = f;
+- }
+- this.fields = newFields;
+- }
+- }
+- }
+- }
+- return null;
+-}
+-
+-// NOTE: the return type, arg & exception types of each method of a source type are resolved when needed
+-public MethodBinding[] getMethods(char[] selector) {
+- if ((this.tagBits & TagBits.AreMethodsComplete) != 0) {
+- long range;
+- if ((range = ReferenceBinding.binarySearch(selector, this.methods)) >= 0) {
+- int start = (int) range, end = (int) (range >> 32);
+- int length = end - start + 1;
+- MethodBinding[] result;
+- System.arraycopy(this.methods, start, result = new MethodBinding[length], 0, length);
+- return result;
+- } else {
+- return Binding.NO_METHODS;
+- }
+- }
+- // lazily sort methods
+- if ((this.tagBits & TagBits.AreMethodsSorted) == 0) {
+- int length = this.methods.length;
+- if (length > 1)
+- ReferenceBinding.sortMethods(this.methods, 0, length);
+- this.tagBits |= TagBits.AreMethodsSorted;
+- }
+- MethodBinding[] result;
+- long range;
+- if ((range = ReferenceBinding.binarySearch(selector, this.methods)) >= 0) {
+- int start = (int) range, end = (int) (range >> 32);
+- for (int i = start; i <= end; i++) {
+- MethodBinding method = this.methods[i];
+- if (resolveTypesFor(method) == null || method.returnType == null) {
+- methods();
+- return getMethods(selector); // try again since the problem methods have been removed
+- }
+- }
+- int length = end - start + 1;
+- System.arraycopy(this.methods, start, result = new MethodBinding[length], 0, length);
+- } else {
+- return Binding.NO_METHODS;
+- }
+- boolean isSource15 = this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5;
+- for (int i = 0, length = result.length - 1; i < length; i++) {
+- MethodBinding method = result[i];
+- for (int j = length; j > i; j--) {
+- boolean paramsMatch = isSource15
+- ? method.areParameterErasuresEqual(result[j])
+- : method.areParametersEqual(result[j]);
+- if (paramsMatch) {
+- methods();
+- return getMethods(selector); // try again since the duplicate methods have been removed
+- }
+- }
+- }
+- return result;
+-}
+-/* Answer the synthetic field for <actualOuterLocalVariable>
+-* or null if one does not exist.
+-*/
+-public FieldBinding getSyntheticField(LocalVariableBinding actualOuterLocalVariable) {
+- if (this.synthetics == null || this.synthetics[SourceTypeBinding.FIELD_EMUL] == null) return null;
+- return (FieldBinding) this.synthetics[SourceTypeBinding.FIELD_EMUL].get(actualOuterLocalVariable);
+-}
+-/* Answer the synthetic field for <targetEnclosingType>
+-* or null if one does not exist.
+-*/
+-public FieldBinding getSyntheticField(ReferenceBinding targetEnclosingType, boolean onlyExactMatch) {
+-
+- if (this.synthetics == null || this.synthetics[SourceTypeBinding.FIELD_EMUL] == null) return null;
+- FieldBinding field = (FieldBinding) this.synthetics[SourceTypeBinding.FIELD_EMUL].get(targetEnclosingType);
+- if (field != null) return field;
+-
+- // type compatibility : to handle cases such as
+- // class T { class M{}}
+- // class S extends T { class N extends M {}} --> need to use S as a default enclosing instance for the super constructor call in N().
+- if (!onlyExactMatch){
+- Iterator accessFields = this.synthetics[SourceTypeBinding.FIELD_EMUL].values().iterator();
+- while (accessFields.hasNext()) {
+- field = (FieldBinding) accessFields.next();
+- if (CharOperation.prefixEquals(TypeConstants.SYNTHETIC_ENCLOSING_INSTANCE_PREFIX, field.name)
+- && field.type.findSuperTypeOriginatingFrom(targetEnclosingType) != null)
+- return field;
+- }
+- }
+- return null;
+-}
+-/*
+- * Answer the bridge method associated for an inherited methods or null if one does not exist
+- */
+-public SyntheticMethodBinding getSyntheticBridgeMethod(MethodBinding inheritedMethodToBridge) {
+- if (this.synthetics == null) return null;
+- if (this.synthetics[SourceTypeBinding.METHOD_EMUL] == null) return null;
+- SyntheticMethodBinding[] accessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(inheritedMethodToBridge);
+- if (accessors == null) return null;
+- return accessors[1];
+-}
+-
+-/**
+- * @see org.eclipse.jdt.internal.compiler.lookup.Binding#initializeDeprecatedAnnotationTagBits()
+- */
+-public void initializeDeprecatedAnnotationTagBits() {
+- if ((this.tagBits & TagBits.DeprecatedAnnotationResolved) == 0) {
+- TypeDeclaration typeDecl = this.scope.referenceContext;
+- boolean old = typeDecl.staticInitializerScope.insideTypeAnnotation;
+- try {
+- typeDecl.staticInitializerScope.insideTypeAnnotation = true;
+- ASTNode.resolveDeprecatedAnnotations(typeDecl.staticInitializerScope, typeDecl.annotations, this);
+- this.tagBits |= TagBits.DeprecatedAnnotationResolved;
+- } finally {
+- typeDecl.staticInitializerScope.insideTypeAnnotation = old;
+- }
+- if ((this.tagBits & TagBits.AnnotationDeprecated) != 0) {
+- this.modifiers |= ClassFileConstants.AccDeprecated;
+- }
+- }
+-}
+-
+-// ensure the receiver knows its hierarchy & fields/methods so static imports can be resolved correctly
+-// see bug 230026
+-void initializeForStaticImports() {
+- if (this.scope == null) return; // already initialized
+-
+- if (this.superInterfaces == null)
+- this.scope.connectTypeHierarchy();
+- this.scope.buildFields();
+- this.scope.buildMethods();
+-}
+-
+-/**
+- * Returns true if a type is identical to another one,
+- * or for generic types, true if compared to its raw type.
+- */
+-public boolean isEquivalentTo(TypeBinding otherType) {
+-
+- if (this == otherType) return true;
+- if (otherType == null) return false;
+- switch(otherType.kind()) {
+-
+- case Binding.WILDCARD_TYPE :
+- case Binding.INTERSECTION_TYPE:
+- return ((WildcardBinding) otherType).boundCheck(this);
+-
+- case Binding.PARAMETERIZED_TYPE :
+- if ((otherType.tagBits & TagBits.HasDirectWildcard) == 0 && (!this.isMemberType() || !otherType.isMemberType()))
+- return false; // should have been identical
+- ParameterizedTypeBinding otherParamType = (ParameterizedTypeBinding) otherType;
+- if (this != otherParamType.genericType())
+- return false;
+- if (!isStatic()) { // static member types do not compare their enclosing
+- ReferenceBinding enclosing = enclosingType();
+- if (enclosing != null) {
+- ReferenceBinding otherEnclosing = otherParamType.enclosingType();
+- if (otherEnclosing == null) return false;
+- if ((otherEnclosing.tagBits & TagBits.HasDirectWildcard) == 0) {
+- if (enclosing != otherEnclosing) return false;
+- } else {
+- if (!enclosing.isEquivalentTo(otherParamType.enclosingType())) return false;
+- }
+- }
+- }
+- int length = this.typeVariables == null ? 0 : this.typeVariables.length;
+- TypeBinding[] otherArguments = otherParamType.arguments;
+- int otherLength = otherArguments == null ? 0 : otherArguments.length;
+- if (otherLength != length)
+- return false;
+- for (int i = 0; i < length; i++)
+- if (!this.typeVariables[i].isTypeArgumentContainedBy(otherArguments[i]))
+- return false;
+- return true;
+-
+- case Binding.RAW_TYPE :
+- return otherType.erasure() == this;
+- }
+- return false;
+-}
+-public boolean isGenericType() {
+- return this.typeVariables != Binding.NO_TYPE_VARIABLES;
+-}
+-public ReferenceBinding[] memberTypes() {
+- return this.memberTypes;
+-}
+-public FieldBinding getUpdatedFieldBinding(FieldBinding targetField, ReferenceBinding newDeclaringClass) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.RECEIVER_TYPE_EMUL] == null)
+- this.synthetics[SourceTypeBinding.RECEIVER_TYPE_EMUL] = new HashMap();
+-
+- Hashtable fieldMap = (Hashtable) this.synthetics[SourceTypeBinding.RECEIVER_TYPE_EMUL].get(targetField);
+- if (fieldMap == null) {
+- fieldMap = new Hashtable(5);
+- this.synthetics[SourceTypeBinding.RECEIVER_TYPE_EMUL].put(targetField, fieldMap);
+- }
+- FieldBinding updatedField = (FieldBinding) fieldMap.get(newDeclaringClass);
+- if (updatedField == null){
+- updatedField = new FieldBinding(targetField, newDeclaringClass);
+- fieldMap.put(newDeclaringClass, updatedField);
+- }
+- return updatedField;
+-}
+-public MethodBinding getUpdatedMethodBinding(MethodBinding targetMethod, ReferenceBinding newDeclaringClass) {
+- if (this.synthetics == null)
+- this.synthetics = new HashMap[MAX_SYNTHETICS];
+- if (this.synthetics[SourceTypeBinding.RECEIVER_TYPE_EMUL] == null)
+- this.synthetics[SourceTypeBinding.RECEIVER_TYPE_EMUL] = new HashMap();
+-
+- Hashtable methodMap = (Hashtable) this.synthetics[SourceTypeBinding.RECEIVER_TYPE_EMUL].get(targetMethod);
+- if (methodMap == null) {
+- methodMap = new Hashtable(5);
+- this.synthetics[SourceTypeBinding.RECEIVER_TYPE_EMUL].put(targetMethod, methodMap);
+- }
+- MethodBinding updatedMethod = (MethodBinding) methodMap.get(newDeclaringClass);
+- if (updatedMethod == null){
+- updatedMethod = new MethodBinding(targetMethod, newDeclaringClass);
+- methodMap.put(newDeclaringClass, updatedMethod);
+- }
+- return updatedMethod;
+-}
+-public boolean hasMemberTypes() {
+- return this.memberTypes.length > 0;
+-}
+-// NOTE: the return type, arg & exception types of each method of a source type are resolved when needed
+-public MethodBinding[] methods() {
+- if ((this.tagBits & TagBits.AreMethodsComplete) != 0)
+- return this.methods;
+-
+- // lazily sort methods
+- if ((this.tagBits & TagBits.AreMethodsSorted) == 0) {
+- int length = this.methods.length;
+- if (length > 1)
+- ReferenceBinding.sortMethods(this.methods, 0, length);
+- this.tagBits |= TagBits.AreMethodsSorted;
+- }
+-
+- int failed = 0;
+- MethodBinding[] resolvedMethods = this.methods;
+- try {
+- for (int i = 0, length = this.methods.length; i < length; i++) {
+- if (resolveTypesFor(this.methods[i]) == null) {
+- // do not alter original method array until resolution is over, due to reentrance (143259)
+- if (resolvedMethods == this.methods) {
+- System.arraycopy(this.methods, 0, resolvedMethods = new MethodBinding[length], 0, length);
+- }
+- resolvedMethods[i] = null; // unable to resolve parameters
+- failed++;
+- }
+- }
+-
+- // find & report collision cases
+- boolean complyTo15 = this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5;
+- for (int i = 0, length = this.methods.length; i < length; i++) {
+- MethodBinding method = resolvedMethods[i];
+- if (method == null)
+- continue;
+- char[] selector = method.selector;
+- AbstractMethodDeclaration methodDecl = null;
+- nextSibling: for (int j = i + 1; j < length; j++) {
+- MethodBinding method2 = resolvedMethods[j];
+- if (method2 == null)
+- continue nextSibling;
+- if (!CharOperation.equals(selector, method2.selector))
+- break nextSibling; // methods with same selector are contiguous
+-
+- if (complyTo15 && method.returnType != null && method2.returnType != null) {
+- // 8.4.2, for collision to be detected between m1 and m2:
+- // signature(m1) == signature(m2) i.e. same arity, same type parameter count, can be substituted
+- // signature(m1) == erasure(signature(m2)) or erasure(signature(m1)) == signature(m2)
+- TypeBinding[] params1 = method.parameters;
+- TypeBinding[] params2 = method2.parameters;
+- int pLength = params1.length;
+- if (pLength != params2.length)
+- continue nextSibling;
+-
+- TypeVariableBinding[] vars = method.typeVariables;
+- TypeVariableBinding[] vars2 = method2.typeVariables;
+- boolean equalTypeVars = vars == vars2;
+- MethodBinding subMethod = method2;
+- if (!equalTypeVars) {
+- MethodBinding temp = method.computeSubstitutedMethod(method2, this.scope.environment());
+- if (temp != null) {
+- equalTypeVars = true;
+- subMethod = temp;
+- }
+- }
+- boolean equalParams = method.areParametersEqual(subMethod);
+- if (equalParams && equalTypeVars) {
+- // duplicates regardless of return types
+- } else if (method.returnType.erasure() == subMethod.returnType.erasure() && (equalParams || method.areParameterErasuresEqual(method2))) {
+- // name clash for sure if not duplicates, report as duplicates
+- } else if (!equalTypeVars && vars != Binding.NO_TYPE_VARIABLES && vars2 != Binding.NO_TYPE_VARIABLES) {
+- // type variables are different so we can distinguish between methods
+- continue nextSibling;
+- } else if (pLength > 0) {
+- // check to see if the erasure of either method is equal to the other
+- int index = pLength;
+- for (; --index >= 0;) {
+- if (params1[index] != params2[index].erasure())
+- break;
+- if (params1[index] == params2[index]) {
+- TypeBinding type = params1[index].leafComponentType();
+- if (type instanceof SourceTypeBinding && type.typeVariables() != Binding.NO_TYPE_VARIABLES) {
+- index = pLength; // handle comparing identical source types like X<T>... its erasure is itself BUT we need to answer false
+- break;
+- }
+- }
+- }
+- if (index >= 0 && index < pLength) {
+- for (index = pLength; --index >= 0;)
+- if (params1[index].erasure() != params2[index])
+- break;
+- }
+- if (index >= 0)
+- continue nextSibling;
+- }
+- } else if (!method.areParametersEqual(method2)) { // prior to 1.5, parameter identity meant a collision case
+- continue nextSibling;
+- }
+- boolean isEnumSpecialMethod = isEnum() && (CharOperation.equals(selector,TypeConstants.VALUEOF) || CharOperation.equals(selector,TypeConstants.VALUES));
+- // report duplicate
+- if (methodDecl == null) {
+- methodDecl = method.sourceMethod(); // cannot be retrieved after binding is lost & may still be null if method is special
+- if (methodDecl != null && methodDecl.binding != null) { // ensure its a valid user defined method
+- if (isEnumSpecialMethod) {
+- this.scope.problemReporter().duplicateEnumSpecialMethod(this, methodDecl);
+- } else {
- this.scope.problemReporter().duplicateMethodInType(this, methodDecl, method.areParametersEqual(method2));
-+ this.scope.problemReporter().duplicateMethodInType(this, methodDecl, method.areParametersEqual(method2), severity);
- }
- methodDecl.binding = null;
- // do not alter original method array until resolution is over, due to reentrance (143259)
-@@ -1224,7 +1226,7 @@
- if (isEnumSpecialMethod) {
- this.scope.problemReporter().duplicateEnumSpecialMethod(this, method2Decl);
- } else {
+- }
+- methodDecl.binding = null;
+- // do not alter original method array until resolution is over, due to reentrance (143259)
+- if (resolvedMethods == this.methods) {
+- System.arraycopy(this.methods, 0, resolvedMethods = new MethodBinding[length], 0, length);
+- }
+- resolvedMethods[i] = null;
+- failed++;
+- }
+- }
+- AbstractMethodDeclaration method2Decl = method2.sourceMethod();
+- if (method2Decl != null && method2Decl.binding != null) { // ensure its a valid user defined method
+- if (isEnumSpecialMethod) {
+- this.scope.problemReporter().duplicateEnumSpecialMethod(this, method2Decl);
+- } else {
- this.scope.problemReporter().duplicateMethodInType(this, method2Decl, method.areParametersEqual(method2));
-+ this.scope.problemReporter().duplicateMethodInType(this, method2Decl, method.areParametersEqual(method2), severity);
- }
- method2Decl.binding = null;
- // do not alter original method array until resolution is over, due to reentrance (143259)
+- }
+- method2Decl.binding = null;
+- // do not alter original method array until resolution is over, due to reentrance (143259)
+- if (resolvedMethods == this.methods) {
+- System.arraycopy(this.methods, 0, resolvedMethods = new MethodBinding[length], 0, length);
+- }
+- resolvedMethods[j] = null;
+- failed++;
+- }
+- }
+- if (method.returnType == null && methodDecl == null) { // forget method with invalid return type... was kept to detect possible collisions
+- methodDecl = method.sourceMethod();
+- if (methodDecl != null) {
+- methodDecl.binding = null;
+- }
+- // do not alter original method array until resolution is over, due to reentrance (143259)
+- if (resolvedMethods == this.methods) {
+- System.arraycopy(this.methods, 0, resolvedMethods = new MethodBinding[length], 0, length);
+- }
+- resolvedMethods[i] = null;
+- failed++;
+- }
+- }
+- } finally {
+- if (failed > 0) {
+- int newSize = resolvedMethods.length - failed;
+- if (newSize == 0) {
+- this.methods = Binding.NO_METHODS;
+- } else {
+- MethodBinding[] newMethods = new MethodBinding[newSize];
+- for (int i = 0, j = 0, length = resolvedMethods.length; i < length; i++)
+- if (resolvedMethods[i] != null)
+- newMethods[j++] = resolvedMethods[i];
+- this.methods = newMethods;
+- }
+- }
+-
+- // handle forward references to potential default abstract methods
+- addDefaultAbstractMethods();
+- this.tagBits |= TagBits.AreMethodsComplete;
+- }
+- return this.methods;
+-}
+-private FieldBinding resolveTypeFor(FieldBinding field) {
+- if ((field.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
+- return field;
+-
+- if (this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
+- if ((field.getAnnotationTagBits() & TagBits.AnnotationDeprecated) != 0)
+- field.modifiers |= ClassFileConstants.AccDeprecated;
+- }
+- if (isViewedAsDeprecated() && !field.isDeprecated())
+- field.modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
+- if (hasRestrictedAccess())
+- field.modifiers |= ExtraCompilerModifiers.AccRestrictedAccess;
+- FieldDeclaration[] fieldDecls = this.scope.referenceContext.fields;
+- for (int f = 0, length = fieldDecls.length; f < length; f++) {
+- if (fieldDecls[f].binding != field)
+- continue;
+-
+- MethodScope initializationScope = field.isStatic()
+- ? this.scope.referenceContext.staticInitializerScope
+- : this.scope.referenceContext.initializerScope;
+- FieldBinding previousField = initializationScope.initializedField;
+- try {
+- initializationScope.initializedField = field;
+- FieldDeclaration fieldDecl = fieldDecls[f];
+- TypeBinding fieldType =
+- fieldDecl.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT
+- ? initializationScope.environment().convertToRawType(this, false /*do not force conversion of enclosing types*/) // enum constant is implicitly of declaring enum type
+- : fieldDecl.type.resolveType(initializationScope, true /* check bounds*/);
+- field.type = fieldType;
+- field.modifiers &= ~ExtraCompilerModifiers.AccUnresolved;
+- if (fieldType == null) {
+- fieldDecl.binding = null;
+- return null;
+- }
+- if (fieldType == TypeBinding.VOID) {
+- this.scope.problemReporter().variableTypeCannotBeVoid(fieldDecl);
+- fieldDecl.binding = null;
+- return null;
+- }
+- if (fieldType.isArrayType() && ((ArrayBinding) fieldType).leafComponentType == TypeBinding.VOID) {
+- this.scope.problemReporter().variableTypeCannotBeVoidArray(fieldDecl);
+- fieldDecl.binding = null;
+- return null;
+- }
+- if ((fieldType.tagBits & TagBits.HasMissingType) != 0) {
+- field.tagBits |= TagBits.HasMissingType;
+- }
+- TypeBinding leafType = fieldType.leafComponentType();
+- if (leafType instanceof ReferenceBinding && (((ReferenceBinding)leafType).modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0) {
+- field.modifiers |= ExtraCompilerModifiers.AccGenericSignature;
+- }
+- } finally {
+- initializationScope.initializedField = previousField;
+- }
+- return field;
+- }
+- return null; // should never reach this point
+-}
+-public MethodBinding resolveTypesFor(MethodBinding method) {
+- if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
+- return method;
+-
+- if (this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
+- if ((method.getAnnotationTagBits() & TagBits.AnnotationDeprecated) != 0)
+- method.modifiers |= ClassFileConstants.AccDeprecated;
+- }
+- if (isViewedAsDeprecated() && !method.isDeprecated())
+- method.modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
+- if (hasRestrictedAccess())
+- method.modifiers |= ExtraCompilerModifiers.AccRestrictedAccess;
+-
+- AbstractMethodDeclaration methodDecl = method.sourceMethod();
+- if (methodDecl == null) return null; // method could not be resolved in previous iteration
+-
+- TypeParameter[] typeParameters = methodDecl.typeParameters();
+- if (typeParameters != null) {
+- methodDecl.scope.connectTypeVariables(typeParameters, true);
+- // Perform deferred bound checks for type variables (only done after type variable hierarchy is connected)
+- for (int i = 0, paramLength = typeParameters.length; i < paramLength; i++)
+- typeParameters[i].checkBounds(methodDecl.scope);
+- }
+- TypeReference[] exceptionTypes = methodDecl.thrownExceptions;
+- if (exceptionTypes != null) {
+- int size = exceptionTypes.length;
+- method.thrownExceptions = new ReferenceBinding[size];
+- int count = 0;
+- ReferenceBinding resolvedExceptionType;
+- for (int i = 0; i < size; i++) {
+- resolvedExceptionType = (ReferenceBinding) exceptionTypes[i].resolveType(methodDecl.scope, true /* check bounds*/);
+- if (resolvedExceptionType == null)
+- continue;
+- if (resolvedExceptionType.isBoundParameterizedType()) {
+- methodDecl.scope.problemReporter().invalidParameterizedExceptionType(resolvedExceptionType, exceptionTypes[i]);
+- continue;
+- }
+- if (resolvedExceptionType.findSuperTypeOriginatingFrom(TypeIds.T_JavaLangThrowable, true) == null) {
+- if (resolvedExceptionType.isValidBinding()) {
+- methodDecl.scope.problemReporter().cannotThrowType(exceptionTypes[i], resolvedExceptionType);
+- continue;
+- }
+- }
+- if ((resolvedExceptionType.tagBits & TagBits.HasMissingType) != 0) {
+- method.tagBits |= TagBits.HasMissingType;
+- }
+- method.modifiers |= (resolvedExceptionType.modifiers & ExtraCompilerModifiers.AccGenericSignature);
+- method.thrownExceptions[count++] = resolvedExceptionType;
+- }
+- if (count < size)
+- System.arraycopy(method.thrownExceptions, 0, method.thrownExceptions = new ReferenceBinding[count], 0, count);
+- }
+-
+- boolean foundArgProblem = false;
+- Argument[] arguments = methodDecl.arguments;
+- if (arguments != null) {
+- int size = arguments.length;
+- method.parameters = Binding.NO_PARAMETERS;
+- TypeBinding[] newParameters = new TypeBinding[size];
+- for (int i = 0; i < size; i++) {
+- Argument arg = arguments[i];
+- if (arg.annotations != null) {
+- method.tagBits |= TagBits.HasParameterAnnotations;
+- }
+- TypeBinding parameterType = arg.type.resolveType(methodDecl.scope, true /* check bounds*/);
+- if (parameterType == null) {
+- foundArgProblem = true;
+- } else if (parameterType == TypeBinding.VOID) {
+- methodDecl.scope.problemReporter().argumentTypeCannotBeVoid(this, methodDecl, arg);
+- foundArgProblem = true;
+- } else {
+- if ((parameterType.tagBits & TagBits.HasMissingType) != 0) {
+- method.tagBits |= TagBits.HasMissingType;
+- }
+- TypeBinding leafType = parameterType.leafComponentType();
+- if (leafType instanceof ReferenceBinding && (((ReferenceBinding) leafType).modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0)
+- method.modifiers |= ExtraCompilerModifiers.AccGenericSignature;
+- newParameters[i] = parameterType;
+- arg.binding = new LocalVariableBinding(arg, parameterType, arg.modifiers, true);
+- }
+- }
+- // only assign parameters if no problems are found
+- if (!foundArgProblem) {
+- method.parameters = newParameters;
+- }
+- }
+-
+- boolean foundReturnTypeProblem = false;
+- if (!method.isConstructor()) {
+- TypeReference returnType = methodDecl instanceof MethodDeclaration
+- ? ((MethodDeclaration) methodDecl).returnType
+- : null;
+- if (returnType == null) {
+- methodDecl.scope.problemReporter().missingReturnType(methodDecl);
+- method.returnType = null;
+- foundReturnTypeProblem = true;
+- } else {
+- TypeBinding methodType = returnType.resolveType(methodDecl.scope, true /* check bounds*/);
+- if (methodType == null) {
+- foundReturnTypeProblem = true;
+- } else if (methodType.isArrayType() && ((ArrayBinding) methodType).leafComponentType == TypeBinding.VOID) {
+- methodDecl.scope.problemReporter().returnTypeCannotBeVoidArray((MethodDeclaration) methodDecl);
+- foundReturnTypeProblem = true;
+- } else {
+- if ((methodType.tagBits & TagBits.HasMissingType) != 0) {
+- method.tagBits |= TagBits.HasMissingType;
+- }
+- method.returnType = methodType;
+- TypeBinding leafType = methodType.leafComponentType();
+- if (leafType instanceof ReferenceBinding && (((ReferenceBinding) leafType).modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0)
+- method.modifiers |= ExtraCompilerModifiers.AccGenericSignature;
+- }
+- }
+- }
+- if (foundArgProblem) {
+- methodDecl.binding = null;
+- method.parameters = Binding.NO_PARAMETERS; // see 107004
+- // nullify type parameter bindings as well as they have a backpointer to the method binding
+- // (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=81134)
+- if (typeParameters != null)
+- for (int i = 0, length = typeParameters.length; i < length; i++)
+- typeParameters[i].binding = null;
+- return null;
+- }
+- if (foundReturnTypeProblem)
+- return method; // but its still unresolved with a null return type & is still connected to its method declaration
+-
+- method.modifiers &= ~ExtraCompilerModifiers.AccUnresolved;
+- return method;
+-}
+-public AnnotationHolder retrieveAnnotationHolder(Binding binding, boolean forceInitialization) {
+- if (forceInitialization)
+- binding.getAnnotationTagBits(); // ensure annotations are up to date
+- return super.retrieveAnnotationHolder(binding, false);
+-}
+-public void setFields(FieldBinding[] fields) {
+- this.fields = fields;
+-}
+-public void setMethods(MethodBinding[] methods) {
+- this.methods = methods;
+-}
+-public final int sourceEnd() {
+- return this.scope.referenceContext.sourceEnd;
+-}
+-public final int sourceStart() {
+- return this.scope.referenceContext.sourceStart;
+-}
+-SimpleLookupTable storedAnnotations(boolean forceInitialize) {
+- if (forceInitialize && this.storedAnnotations == null && this.scope != null) { // scope null when no annotation cached, and type got processed fully (159631)
+- this.scope.referenceCompilationUnit().compilationResult.hasAnnotations = true;
+- if (!this.scope.environment().globalOptions.storeAnnotations)
+- return null; // not supported during this compile
+- this.storedAnnotations = new SimpleLookupTable(3);
+- }
+- return this.storedAnnotations;
+-}
+-public ReferenceBinding superclass() {
+- return this.superclass;
+-}
+-public ReferenceBinding[] superInterfaces() {
+- return this.superInterfaces;
+-}
+-// TODO (philippe) could be a performance issue since some senders are building the list just to count them
+-public SyntheticMethodBinding[] syntheticMethods() {
+-
+- if (this.synthetics == null || this.synthetics[SourceTypeBinding.METHOD_EMUL] == null || this.synthetics[SourceTypeBinding.METHOD_EMUL].size() == 0) return null;
+-
+- // difficult to compute size up front because of the embedded arrays so assume there is only 1
+- int index = 0;
+- SyntheticMethodBinding[] bindings = new SyntheticMethodBinding[1];
+- Iterator fieldsOrMethods = this.synthetics[SourceTypeBinding.METHOD_EMUL].keySet().iterator();
+- while (fieldsOrMethods.hasNext()) {
+-
+- Object fieldOrMethod = fieldsOrMethods.next();
+-
+- if (fieldOrMethod instanceof MethodBinding) {
+-
+- SyntheticMethodBinding[] methodAccessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(fieldOrMethod);
+- int numberOfAccessors = 0;
+- if (methodAccessors[0] != null) numberOfAccessors++;
+- if (methodAccessors[1] != null) numberOfAccessors++;
+- if (index + numberOfAccessors > bindings.length)
+- System.arraycopy(bindings, 0, (bindings = new SyntheticMethodBinding[index + numberOfAccessors]), 0, index);
+- if (methodAccessors[0] != null)
+- bindings[index++] = methodAccessors[0]; // super access
+- if (methodAccessors[1] != null)
+- bindings[index++] = methodAccessors[1]; // normal access or bridge
+-
+- } else {
+-
+- SyntheticMethodBinding[] fieldAccessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(fieldOrMethod);
+- int numberOfAccessors = 0;
+- if (fieldAccessors[0] != null) numberOfAccessors++;
+- if (fieldAccessors[1] != null) numberOfAccessors++;
+- if (index + numberOfAccessors > bindings.length)
+- System.arraycopy(bindings, 0, (bindings = new SyntheticMethodBinding[index + numberOfAccessors]), 0, index);
+- if (fieldAccessors[0] != null)
+- bindings[index++] = fieldAccessors[0]; // read access
+- if (fieldAccessors[1] != null)
+- bindings[index++] = fieldAccessors[1]; // write access
+- }
+- }
+-
+- // sort them in according to their own indexes
+- int length;
+- SyntheticMethodBinding[] sortedBindings = new SyntheticMethodBinding[length = bindings.length];
+- for (int i = 0; i < length; i++){
+- SyntheticMethodBinding binding = bindings[i];
+- sortedBindings[binding.index] = binding;
+- }
+- return sortedBindings;
+-}
+-/**
+- * Answer the collection of synthetic fields to append into the classfile
+- */
+-public FieldBinding[] syntheticFields() {
+-
+- if (this.synthetics == null) return null;
+-
+- int fieldSize = this.synthetics[SourceTypeBinding.FIELD_EMUL] == null ? 0 : this.synthetics[SourceTypeBinding.FIELD_EMUL].size();
+- int literalSize = this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL] == null ? 0 :this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL].size();
+- int totalSize = fieldSize + literalSize;
+- if (totalSize == 0) return null;
+- FieldBinding[] bindings = new FieldBinding[totalSize];
+-
+- // add innerclass synthetics
+- if (this.synthetics[SourceTypeBinding.FIELD_EMUL] != null){
+- Iterator elements = this.synthetics[SourceTypeBinding.FIELD_EMUL].values().iterator();
+- for (int i = 0; i < fieldSize; i++) {
+- SyntheticFieldBinding synthBinding = (SyntheticFieldBinding) elements.next();
+- bindings[synthBinding.index] = synthBinding;
+- }
+- }
+- // add class literal synthetics
+- if (this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL] != null){
+- Iterator elements = this.synthetics[SourceTypeBinding.CLASS_LITERAL_EMUL].values().iterator();
+- for (int i = 0; i < literalSize; i++) {
+- SyntheticFieldBinding synthBinding = (SyntheticFieldBinding) elements.next();
+- bindings[fieldSize+synthBinding.index] = synthBinding;
+- }
+- }
+- return bindings;
+-}
+-public String toString() {
+- StringBuffer buffer = new StringBuffer(30);
+- buffer.append("(id="); //$NON-NLS-1$
+- if (this.id == TypeIds.NoId)
+- buffer.append("NoId"); //$NON-NLS-1$
+- else
+- buffer.append(this.id);
+- buffer.append(")\n"); //$NON-NLS-1$
+- if (isDeprecated()) buffer.append("deprecated "); //$NON-NLS-1$
+- if (isPublic()) buffer.append("public "); //$NON-NLS-1$
+- if (isProtected()) buffer.append("protected "); //$NON-NLS-1$
+- if (isPrivate()) buffer.append("private "); //$NON-NLS-1$
+- if (isAbstract() && isClass()) buffer.append("abstract "); //$NON-NLS-1$
+- if (isStatic() && isNestedType()) buffer.append("static "); //$NON-NLS-1$
+- if (isFinal()) buffer.append("final "); //$NON-NLS-1$
+-
+- if (isEnum()) buffer.append("enum "); //$NON-NLS-1$
+- else if (isAnnotationType()) buffer.append("@interface "); //$NON-NLS-1$
+- else if (isClass()) buffer.append("class "); //$NON-NLS-1$
+- else buffer.append("interface "); //$NON-NLS-1$
+- buffer.append((this.compoundName != null) ? CharOperation.toString(this.compoundName) : "UNNAMED TYPE"); //$NON-NLS-1$
+-
+- if (this.typeVariables == null) {
+- buffer.append("<NULL TYPE VARIABLES>"); //$NON-NLS-1$
+- } else if (this.typeVariables != Binding.NO_TYPE_VARIABLES) {
+- buffer.append("<"); //$NON-NLS-1$
+- for (int i = 0, length = this.typeVariables.length; i < length; i++) {
+- if (i > 0) buffer.append(", "); //$NON-NLS-1$
+- if (this.typeVariables[i] == null) {
+- buffer.append("NULL TYPE VARIABLE"); //$NON-NLS-1$
+- continue;
+- }
+- char[] varChars = this.typeVariables[i].toString().toCharArray();
+- buffer.append(varChars, 1, varChars.length - 2);
+- }
+- buffer.append(">"); //$NON-NLS-1$
+- }
+- buffer.append("\n\textends "); //$NON-NLS-1$
+- buffer.append((this.superclass != null) ? this.superclass.debugName() : "NULL TYPE"); //$NON-NLS-1$
+-
+- if (this.superInterfaces != null) {
+- if (this.superInterfaces != Binding.NO_SUPERINTERFACES) {
+- buffer.append("\n\timplements : "); //$NON-NLS-1$
+- for (int i = 0, length = this.superInterfaces.length; i < length; i++) {
+- if (i > 0)
+- buffer.append(", "); //$NON-NLS-1$
+- buffer.append((this.superInterfaces[i] != null) ? this.superInterfaces[i].debugName() : "NULL TYPE"); //$NON-NLS-1$
+- }
+- }
+- } else {
+- buffer.append("NULL SUPERINTERFACES"); //$NON-NLS-1$
+- }
+-
+- if (enclosingType() != null) {
+- buffer.append("\n\tenclosing type : "); //$NON-NLS-1$
+- buffer.append(enclosingType().debugName());
+- }
+-
+- if (this.fields != null) {
+- if (this.fields != Binding.NO_FIELDS) {
+- buffer.append("\n/* fields */"); //$NON-NLS-1$
+- for (int i = 0, length = this.fields.length; i < length; i++)
+- buffer.append('\n').append((this.fields[i] != null) ? this.fields[i].toString() : "NULL FIELD"); //$NON-NLS-1$
+- }
+- } else {
+- buffer.append("NULL FIELDS"); //$NON-NLS-1$
+- }
+-
+- if (this.methods != null) {
+- if (this.methods != Binding.NO_METHODS) {
+- buffer.append("\n/* methods */"); //$NON-NLS-1$
+- for (int i = 0, length = this.methods.length; i < length; i++)
+- buffer.append('\n').append((this.methods[i] != null) ? this.methods[i].toString() : "NULL METHOD"); //$NON-NLS-1$
+- }
+- } else {
+- buffer.append("NULL METHODS"); //$NON-NLS-1$
+- }
+-
+- if (this.memberTypes != null) {
+- if (this.memberTypes != Binding.NO_MEMBER_TYPES) {
+- buffer.append("\n/* members */"); //$NON-NLS-1$
+- for (int i = 0, length = this.memberTypes.length; i < length; i++)
+- buffer.append('\n').append((this.memberTypes[i] != null) ? this.memberTypes[i].toString() : "NULL TYPE"); //$NON-NLS-1$
+- }
+- } else {
+- buffer.append("NULL MEMBER TYPES"); //$NON-NLS-1$
+- }
+-
+- buffer.append("\n\n"); //$NON-NLS-1$
+- return buffer.toString();
+-}
+-public TypeVariableBinding[] typeVariables() {
+- return this.typeVariables;
+-}
+-void verifyMethods(MethodVerifier verifier) {
+- verifier.verify(this);
+-
+- for (int i = this.memberTypes.length; --i >= 0;)
+- ((SourceTypeBinding) this.memberTypes[i]).verifyMethods(verifier);
+-}
+-}
--- a/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java
@@ -440,7 +440,12 @@
More information about the pkg-eucalyptus-commits
mailing list