X-Git-Url: http://git.phpeclipse.com

diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/SourceTypeBinding.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/SourceTypeBinding.java
index 266a332..51345a4 100644
--- a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/SourceTypeBinding.java
+++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/SourceTypeBinding.java
@@ -25,431 +25,450 @@ import net.sourceforge.phpdt.internal.compiler.ast.TypeReference;
 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
 
-
 public class SourceTypeBinding extends ReferenceBinding {
 	public ReferenceBinding superclass;
+
 	public ReferenceBinding[] superInterfaces;
+
 	public FieldBinding[] fields;
+
 	public MethodBinding[] methods;
+
 	public ReferenceBinding[] memberTypes;
 
 	public ClassScope scope;
 
-	// Synthetics are separated into 4 categories: methods, super methods, fields, class literals and changed declaring class bindings
+	// Synthetics are separated into 4 categories: methods, super methods,
+	// fields, class literals and changed declaring class bindings
 	public final static int METHOD = 0;
+
 	public final static int FIELD = 1;
+
 	public final static int CLASS_LITERAL = 2;
+
 	public final static int CHANGED_DECLARING_CLASS = 3;
 
 	Hashtable[] synthetics;
 
-protected SourceTypeBinding() {
-}
-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;
-
-//	computeId();
-}
-private void addDefaultAbstractMethod(MethodBinding abstractMethod) {
-	MethodBinding defaultAbstract = new MethodBinding(
-		abstractMethod.modifiers | AccDefaultAbstract,
-		abstractMethod.selector,
-		abstractMethod.returnType,
-		abstractMethod.parameters,
-		abstractMethod.thrownExceptions,
-		this);
-
-	MethodBinding[] temp = new MethodBinding[methods.length + 1];
-	System.arraycopy(methods, 0, temp, 0, methods.length);
-	temp[methods.length] = defaultAbstract;
-	methods = temp;
-}
-public void addDefaultAbstractMethods() {
-	if ((tagBits & KnowsDefaultAbstractMethods) != 0) return;
+	protected SourceTypeBinding() {
+	}
 
-	tagBits |= KnowsDefaultAbstractMethods;
+	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;
 
-	if (isClass() && isAbstract()) {
-//		if (fPackage.environment.options.targetJDK >= CompilerOptions.JDK1_2) return; // no longer added for post 1.2 targets
+		// computeId();
+	}
 
-		ReferenceBinding[][] interfacesToVisit = new ReferenceBinding[5][];
-		int lastPosition = 0;
-		interfacesToVisit[lastPosition] = superInterfaces();
+	private void addDefaultAbstractMethod(MethodBinding abstractMethod) {
+		MethodBinding defaultAbstract = new MethodBinding(
+				abstractMethod.modifiers | AccDefaultAbstract,
+				abstractMethod.selector, abstractMethod.returnType,
+				abstractMethod.parameters, abstractMethod.thrownExceptions,
+				this);
+
+		MethodBinding[] temp = new MethodBinding[methods.length + 1];
+		System.arraycopy(methods, 0, temp, 0, methods.length);
+		temp[methods.length] = defaultAbstract;
+		methods = temp;
+	}
 
-		for (int i = 0; i <= lastPosition; i++) {
-			ReferenceBinding[] interfaces = interfacesToVisit[i];
-			for (int j = 0, length = interfaces.length; j < length; j++) {
-				ReferenceBinding superType = interfaces[j];
-				if (superType.isValidBinding()) {
-					MethodBinding[] methods = superType.methods();
-					for (int m = methods.length; --m >= 0;) {
-						MethodBinding method = methods[m];
-						if (!implementsMethod(method))
-							addDefaultAbstractMethod(method);
-					}
+	public void addDefaultAbstractMethods() {
+		if ((tagBits & KnowsDefaultAbstractMethods) != 0)
+			return;
+
+		tagBits |= KnowsDefaultAbstractMethods;
+
+		if (isClass() && isAbstract()) {
+			// if (fPackage.environment.options.targetJDK >=
+			// CompilerOptions.JDK1_2) return; // no longer added for post 1.2
+			// targets
+
+			ReferenceBinding[][] interfacesToVisit = new ReferenceBinding[5][];
+			int lastPosition = 0;
+			interfacesToVisit[lastPosition] = superInterfaces();
+
+			for (int i = 0; i <= lastPosition; i++) {
+				ReferenceBinding[] interfaces = interfacesToVisit[i];
+				for (int j = 0, length = interfaces.length; j < length; j++) {
+					ReferenceBinding superType = interfaces[j];
+					if (superType.isValidBinding()) {
+						MethodBinding[] methods = superType.methods();
+						for (int m = methods.length; --m >= 0;) {
+							MethodBinding method = methods[m];
+							if (!implementsMethod(method))
+								addDefaultAbstractMethod(method);
+						}
 
-					ReferenceBinding[] itsInterfaces = superType.superInterfaces();
-					if (itsInterfaces != NoSuperInterfaces) {
-						if (++lastPosition == interfacesToVisit.length)
-							System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[lastPosition * 2][], 0, lastPosition);
-						interfacesToVisit[lastPosition] = itsInterfaces;
+						ReferenceBinding[] itsInterfaces = superType
+								.superInterfaces();
+						if (itsInterfaces != NoSuperInterfaces) {
+							if (++lastPosition == interfacesToVisit.length)
+								System
+										.arraycopy(
+												interfacesToVisit,
+												0,
+												interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
+												0, lastPosition);
+							interfacesToVisit[lastPosition] = itsInterfaces;
+						}
 					}
 				}
 			}
 		}
 	}
-}
-/* Add a new synthetic field for <actualOuterLocalVariable>.
-*	Answer the new field or the existing field if one already existed.
-*/
 
-public FieldBinding addSyntheticField(LocalVariableBinding actualOuterLocalVariable) {
-	if (synthetics == null) {
-		synthetics = new Hashtable[4];
-	}
-	if (synthetics[FIELD] == null) {
-		synthetics[FIELD] = new Hashtable(5);
-	}
+	/*
+	 * Add a new synthetic field for <actualOuterLocalVariable>. Answer the new
+	 * field or the existing field if one already existed.
+	 */
+
+	public FieldBinding addSyntheticField(
+			LocalVariableBinding actualOuterLocalVariable) {
+		if (synthetics == null) {
+			synthetics = new Hashtable[4];
+		}
+		if (synthetics[FIELD] == null) {
+			synthetics[FIELD] = new Hashtable(5);
+		}
+
+		FieldBinding synthField = (FieldBinding) synthetics[FIELD]
+				.get(actualOuterLocalVariable);
+		if (synthField == null) {
+			synthField = new SyntheticFieldBinding(CharOperation.concat(
+					SyntheticArgumentBinding.OuterLocalPrefix,
+					actualOuterLocalVariable.name),
+					actualOuterLocalVariable.type, AccPrivate | AccFinal,// |
+																			// AccSynthetic,
+					this, Constant.NotAConstant, synthetics[FIELD].size());
+			synthetics[FIELD].put(actualOuterLocalVariable, synthField);
+		}
 
-	FieldBinding synthField = (FieldBinding) synthetics[FIELD].get(actualOuterLocalVariable);
-	if (synthField == null) {
-		synthField = new SyntheticFieldBinding(
-			CharOperation.concat(SyntheticArgumentBinding.OuterLocalPrefix, actualOuterLocalVariable.name),
-			actualOuterLocalVariable.type,
-			AccPrivate | AccFinal ,//| AccSynthetic,
-			this,
-			Constant.NotAConstant,
-			synthetics[FIELD].size());
-		synthetics[FIELD].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)) != null) {
+				TypeDeclaration typeDecl = 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(
+								SyntheticArgumentBinding.OuterLocalPrefix,
+								actualOuterLocalVariable.name,
+								("$" + String.valueOf(index++)).toCharArray()); //$NON-NLS-1$
+						needRecheck = true;
+						break;
+					}
+				}
+			}
+		} while (needRecheck);
+		return synthField;
 	}
 
-	// ensure there is not already such a field defined by the user
-	boolean needRecheck;
-	int index = 1;
-	do {
-		needRecheck = false;
+	/*
+	 * Add a new synthetic field for <enclosingType>. Answer the new field or
+	 * the existing field if one already existed.
+	 */
+
+	public FieldBinding addSyntheticField(ReferenceBinding enclosingType) {
+
+		if (synthetics == null) {
+			synthetics = new Hashtable[4];
+		}
+		if (synthetics[FIELD] == null) {
+			synthetics[FIELD] = new Hashtable(5);
+		}
+
+		FieldBinding synthField = (FieldBinding) synthetics[FIELD]
+				.get(enclosingType);
+		if (synthField == null) {
+			synthField = new SyntheticFieldBinding(CharOperation.concat(
+					SyntheticArgumentBinding.EnclosingInstancePrefix, String
+							.valueOf(enclosingType.depth()).toCharArray()),
+					enclosingType, AccDefault | AccFinal,// | AccSynthetic,
+					this, Constant.NotAConstant, synthetics[FIELD].size());
+			synthetics[FIELD].put(enclosingType, synthField);
+		}
+		// ensure there is not already such a field defined by the user
 		FieldBinding existingField;
 		if ((existingField = this.getField(synthField.name)) != null) {
 			TypeDeclaration typeDecl = 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(
-						SyntheticArgumentBinding.OuterLocalPrefix,
-						actualOuterLocalVariable.name,
-						("$" + String.valueOf(index++)).toCharArray()); //$NON-NLS-1$
-					needRecheck = true;
+					scope.problemReporter().duplicateFieldInType(this,
+							fieldDecl);
 					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 addSyntheticField(ReferenceBinding enclosingType) {
-
-	if (synthetics == null) {
-		synthetics = new Hashtable[4];
-	}
-	if (synthetics[FIELD] == null) {
-		synthetics[FIELD] = new Hashtable(5);
+		return synthField;
 	}
 
-	FieldBinding synthField = (FieldBinding) synthetics[FIELD].get(enclosingType);
-	if (synthField == null) {
-		synthField = new SyntheticFieldBinding(
-			CharOperation.concat(
-				SyntheticArgumentBinding.EnclosingInstancePrefix,
-				String.valueOf(enclosingType.depth()).toCharArray()),
-			enclosingType,
-			AccDefault | AccFinal,// | AccSynthetic,
-			this,
-			Constant.NotAConstant,
-			synthetics[FIELD].size());
-		synthetics[FIELD].put(enclosingType, synthField);
-	}
-	// ensure there is not already such a field defined by the user
-	FieldBinding existingField;
-	if ((existingField = this.getField(synthField.name)) != null) {
-		TypeDeclaration typeDecl = scope.referenceContext;
-		for (int i = 0, max = typeDecl.fields.length; i < max; i++) {
-			FieldDeclaration fieldDecl = typeDecl.fields[i];
-			if (fieldDecl.binding == existingField) {
-				scope.problemReporter().duplicateFieldInType(this, fieldDecl);
-				break;
-			}
-		}
-	}
-	return synthField;
-}
-/* Add a new synthetic field for a class literal access.
-*	Answer the new field or the existing field if one already existed.
-*/
+	/*
+	 * Add a new synthetic field for a class literal access. Answer the new
+	 * field or the existing field if one already existed.
+	 */
 
-public FieldBinding addSyntheticField(TypeBinding targetType, BlockScope blockScope) {
-
-	if (synthetics == null) {
-		synthetics = new Hashtable[4];
-	}
-	if (synthetics[CLASS_LITERAL] == null) {
-		synthetics[CLASS_LITERAL] = new Hashtable(5);
-	}
+	public FieldBinding addSyntheticField(TypeBinding targetType,
+			BlockScope blockScope) {
 
-	// use a different table than FIELDS, given there might be a collision between emulation of X.this$0 and X.class.
-	FieldBinding synthField = (FieldBinding) synthetics[CLASS_LITERAL].get(targetType);
-	if (synthField == null) {
-		synthField = new SyntheticFieldBinding(
-			("class$" + synthetics[CLASS_LITERAL].size()).toCharArray(), //$NON-NLS-1$
-			blockScope.getJavaLangClass(),
-			AccDefault | AccStatic,// | AccSynthetic,
-			this,
-			Constant.NotAConstant,
-			synthetics[CLASS_LITERAL].size());
-		synthetics[CLASS_LITERAL].put(targetType, synthField);
-	}
-	// ensure there is not already such a field defined by the user
-	FieldBinding existingField;
-	if ((existingField = this.getField(synthField.name)) != 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;
-			}
+		if (synthetics == null) {
+			synthetics = new Hashtable[4];
+		}
+		if (synthetics[CLASS_LITERAL] == null) {
+			synthetics[CLASS_LITERAL] = new Hashtable(5);
 		}
-	}
-	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 addSyntheticField(AssertStatement assertStatement, BlockScope blockScope) {
-
-	if (synthetics == null) {
-		synthetics = new Hashtable[4];
-	}
-	if (synthetics[FIELD] == null) {
-		synthetics[FIELD] = new Hashtable(5);
-	}
 
-	FieldBinding synthField = (FieldBinding) synthetics[FIELD].get("assertionEmulation"); //$NON-NLS-1$
-	if (synthField == null) {
-		synthField = new SyntheticFieldBinding(
-			"$assertionsDisabled".toCharArray(), //$NON-NLS-1$
-			BooleanBinding,
-			AccDefault | AccStatic | AccFinal,//| AccSynthetic | AccFinal,
-			this,
-			Constant.NotAConstant,
-			synthetics[FIELD].size());
-		synthetics[FIELD].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;
+		// use a different table than FIELDS, given there might be a collision
+		// between emulation of X.this$0 and X.class.
+		FieldBinding synthField = (FieldBinding) synthetics[CLASS_LITERAL]
+				.get(targetType);
+		if (synthField == null) {
+			synthField = new SyntheticFieldBinding(
+					("class$" + synthetics[CLASS_LITERAL].size()).toCharArray(), //$NON-NLS-1$
+					blockScope.getJavaLangClass(), AccDefault | AccStatic,// |
+																			// AccSynthetic,
+					this, Constant.NotAConstant, synthetics[CLASS_LITERAL]
+							.size());
+			synthetics[CLASS_LITERAL].put(targetType, synthField);
+		}
+		// ensure there is not already such a field defined by the user
 		FieldBinding existingField;
 		if ((existingField = this.getField(synthField.name)) != null) {
-			TypeDeclaration typeDecl = scope.referenceContext;
+			TypeDeclaration typeDecl = blockScope.referenceType();
 			for (int i = 0, max = typeDecl.fields.length; i < max; i++) {
 				FieldDeclaration fieldDecl = typeDecl.fields[i];
 				if (fieldDecl.binding == existingField) {
-					synthField.name = CharOperation.concat(
-						"$assertionsDisabled".toCharArray(), //$NON-NLS-1$
-						("_" + String.valueOf(index++)).toCharArray()); //$NON-NLS-1$
-					needRecheck = true;
+					blockScope.problemReporter().duplicateFieldInType(this,
+							fieldDecl);
 					break;
 				}
 			}
 		}
-	} while (needRecheck);
-	return synthField;
-}
+		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.
-*/
+	/*
+	 * 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 addSyntheticField(AssertStatement assertStatement,
+			BlockScope blockScope) {
 
-public SyntheticAccessMethodBinding addSyntheticMethod(FieldBinding targetField, boolean isReadAccess) {
+		if (synthetics == null) {
+			synthetics = new Hashtable[4];
+		}
+		if (synthetics[FIELD] == null) {
+			synthetics[FIELD] = new Hashtable(5);
+		}
 
-	if (synthetics == null) {
-		synthetics = new Hashtable[4];
-	}
-	if (synthetics[METHOD] == null) {
-		synthetics[METHOD] = new Hashtable(5);
+		FieldBinding synthField = (FieldBinding) synthetics[FIELD]
+				.get("assertionEmulation"); //$NON-NLS-1$
+		if (synthField == null) {
+			synthField = new SyntheticFieldBinding(
+					"$assertionsDisabled".toCharArray(), //$NON-NLS-1$
+					BooleanBinding, AccDefault | AccStatic | AccFinal,// |
+																		// AccSynthetic
+																		// |
+																		// AccFinal,
+					this, Constant.NotAConstant, synthetics[FIELD].size());
+			synthetics[FIELD].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)) != null) {
+				TypeDeclaration typeDecl = 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(
+								"$assertionsDisabled".toCharArray(), //$NON-NLS-1$
+								("_" + String.valueOf(index++)).toCharArray()); //$NON-NLS-1$
+						needRecheck = true;
+						break;
+					}
+				}
+			}
+		} while (needRecheck);
+		return synthField;
 	}
 
-	SyntheticAccessMethodBinding accessMethod = null;
-	SyntheticAccessMethodBinding[] accessors = (SyntheticAccessMethodBinding[]) synthetics[METHOD].get(targetField);
-	if (accessors == null) {
-		accessMethod = new SyntheticAccessMethodBinding(targetField, isReadAccess, this);
-		synthetics[METHOD].put(targetField, accessors = new SyntheticAccessMethodBinding[2]);
-		accessors[isReadAccess ? 0 : 1] = accessMethod;
-	} else {
-		if ((accessMethod = accessors[isReadAccess ? 0 : 1]) == null) {
-			accessMethod = new SyntheticAccessMethodBinding(targetField, isReadAccess, this);
+	/*
+	 * 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 SyntheticAccessMethodBinding addSyntheticMethod(
+			FieldBinding targetField, boolean isReadAccess) {
+
+		if (synthetics == null) {
+			synthetics = new Hashtable[4];
+		}
+		if (synthetics[METHOD] == null) {
+			synthetics[METHOD] = new Hashtable(5);
+		}
+
+		SyntheticAccessMethodBinding accessMethod = null;
+		SyntheticAccessMethodBinding[] accessors = (SyntheticAccessMethodBinding[]) synthetics[METHOD]
+				.get(targetField);
+		if (accessors == null) {
+			accessMethod = new SyntheticAccessMethodBinding(targetField,
+					isReadAccess, this);
+			synthetics[METHOD].put(targetField,
+					accessors = new SyntheticAccessMethodBinding[2]);
 			accessors[isReadAccess ? 0 : 1] = accessMethod;
+		} else {
+			if ((accessMethod = accessors[isReadAccess ? 0 : 1]) == null) {
+				accessMethod = new SyntheticAccessMethodBinding(targetField,
+						isReadAccess, this);
+				accessors[isReadAccess ? 0 : 1] = accessMethod;
+			}
 		}
+		return 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 SyntheticAccessMethodBinding addSyntheticMethod(MethodBinding targetMethod, boolean isSuperAccess) {
+	/*
+	 * 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.
+	 */
 
-	if (synthetics == null) {
-		synthetics = new Hashtable[4];
-	}
-	if (synthetics[METHOD] == null) {
-		synthetics[METHOD] = new Hashtable(5);
-	}
+	public SyntheticAccessMethodBinding addSyntheticMethod(
+			MethodBinding targetMethod, boolean isSuperAccess) {
 
-	SyntheticAccessMethodBinding accessMethod = null;
-	SyntheticAccessMethodBinding[] accessors = (SyntheticAccessMethodBinding[]) synthetics[METHOD].get(targetMethod);
-	if (accessors == null) {
-		accessMethod = new SyntheticAccessMethodBinding(targetMethod, isSuperAccess, this);
-		synthetics[METHOD].put(targetMethod, accessors = new SyntheticAccessMethodBinding[2]);
-		accessors[isSuperAccess ? 0 : 1] = accessMethod;
-	} else {
-		if ((accessMethod = accessors[isSuperAccess ? 0 : 1]) == null) {
-			accessMethod = new SyntheticAccessMethodBinding(targetMethod, isSuperAccess, this);
+		if (synthetics == null) {
+			synthetics = new Hashtable[4];
+		}
+		if (synthetics[METHOD] == null) {
+			synthetics[METHOD] = new Hashtable(5);
+		}
+
+		SyntheticAccessMethodBinding accessMethod = null;
+		SyntheticAccessMethodBinding[] accessors = (SyntheticAccessMethodBinding[]) synthetics[METHOD]
+				.get(targetMethod);
+		if (accessors == null) {
+			accessMethod = new SyntheticAccessMethodBinding(targetMethod,
+					isSuperAccess, this);
+			synthetics[METHOD].put(targetMethod,
+					accessors = new SyntheticAccessMethodBinding[2]);
 			accessors[isSuperAccess ? 0 : 1] = accessMethod;
+		} else {
+			if ((accessMethod = accessors[isSuperAccess ? 0 : 1]) == null) {
+				accessMethod = new SyntheticAccessMethodBinding(targetMethod,
+						isSuperAccess, this);
+				accessors[isSuperAccess ? 0 : 1] = accessMethod;
+			}
 		}
+		return accessMethod;
 	}
-	return accessMethod;
-}
 
-public FieldBinding[] availableFields() {
-	return fields();
-}
-public MethodBinding[] availableMethods() {
-	return methods();
-}
-void faultInTypesForFieldsAndMethods() {
-	fields();
-	methods();
+	public FieldBinding[] availableFields() {
+		return fields();
+	}
 
-	for (int i = 0, length = memberTypes.length; i < length; i++)
-		((SourceTypeBinding) memberTypes[i]).faultInTypesForFieldsAndMethods();
-}
-// NOTE: the type of each field of a source type is resolved when needed
+	public MethodBinding[] availableMethods() {
+		return methods();
+	}
+
+	void faultInTypesForFieldsAndMethods() {
+		fields();
+		methods();
 
-public FieldBinding[] fields() {
-	if (fields==null) {
-		fields = new FieldBinding[0];
+		for (int i = 0, length = memberTypes.length; i < length; i++)
+			((SourceTypeBinding) memberTypes[i])
+					.faultInTypesForFieldsAndMethods();
 	}
-	try {
-		int failed = 0;
-		for (int f = 0, max = fields.length; f < max; f++) {
-			if (resolveTypeFor(fields[f]) == null) {
-				fields[f] = null;
-				failed++;
-			}
-		}
-		if (failed > 0) {
-			int newSize = fields.length - failed;
-			if (newSize == 0)
-				return fields = NoFields;
-
-			FieldBinding[] newFields = new FieldBinding[newSize];
-			for (int i = 0, n = 0, max = fields.length; i < max; i++)
-				if (fields[i] != null)
-					newFields[n++] = fields[i];
-			fields = newFields;
+
+	// NOTE: the type of each field of a source type is resolved when needed
+
+	public FieldBinding[] fields() {
+		if (fields == null) {
+			fields = new FieldBinding[0];
 		}
-	} catch(AbortCompilation e){
-		// ensure null fields are removed
-		FieldBinding[] newFields = null;
-		int count = 0;
-		for (int i = 0, max = fields.length; i < max; i++){
-			FieldBinding field = fields[i];
-			if (field == null && newFields == null){
-				System.arraycopy(fields, 0, newFields = new FieldBinding[max], 0, i);
-			} else if (newFields != null && field != null) {
-				newFields[count++] = field;
+		try {
+			int failed = 0;
+			for (int f = 0, max = fields.length; f < max; f++) {
+				if (resolveTypeFor(fields[f]) == null) {
+					fields[f] = null;
+					failed++;
+				}
 			}
-		}
-		if (newFields != null){
-			System.arraycopy(newFields, 0, fields = new FieldBinding[count], 0, count);
-		}
-		throw e;
-	}
-	return fields;
-}
-public MethodBinding[] getDefaultAbstractMethods() {
-	int count = 0;
-	for (int i = methods.length; --i >= 0;)
-		if (methods[i].isDefaultAbstract())
-			count++;
-	if (count == 0) return NoMethods;
-
-	MethodBinding[] result = new MethodBinding[count];
-	count = 0;
-	for (int i = methods.length; --i >= 0;)
-		if (methods[i].isDefaultAbstract())
-			result[count++] = methods[i];
-	return result;
-}
-// NOTE: the return type, arg & exception types of each method of a source type are resolved when needed
+			if (failed > 0) {
+				int newSize = fields.length - failed;
+				if (newSize == 0)
+					return fields = NoFields;
 
-public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) {
-	int argCount = argumentTypes.length;
-
-	if ((modifiers & AccUnresolved) == 0) { // have resolved all arg types & return type of the methods
-		nextMethod : for (int m = methods.length; --m >= 0;) {
-			MethodBinding method = methods[m];
-			if (method.selector == ConstructorDeclaration.ConstantPoolName && method.parameters.length == argCount) {
-				TypeBinding[] toMatch = method.parameters;
-				for (int p = 0; p < argCount; p++)
-					if (toMatch[p] != argumentTypes[p])
-						continue nextMethod;
-				return method;
+				FieldBinding[] newFields = new FieldBinding[newSize];
+				for (int i = 0, n = 0, max = fields.length; i < max; i++)
+					if (fields[i] != null)
+						newFields[n++] = fields[i];
+				fields = newFields;
 			}
-		}
-	} else {
-		MethodBinding[] methods = getMethods(ConstructorDeclaration.ConstantPoolName); // takes care of duplicates & default abstract methods
-		nextMethod : for (int m = methods.length; --m >= 0;) {
-			MethodBinding method = methods[m];
-			TypeBinding[] toMatch = method.parameters;
-			if (toMatch.length == argCount) {
-				for (int p = 0; p < argCount; p++)
-					if (toMatch[p] != argumentTypes[p])
-						continue nextMethod;
-				return method;
+		} catch (AbortCompilation e) {
+			// ensure null fields are removed
+			FieldBinding[] newFields = null;
+			int count = 0;
+			for (int i = 0, max = fields.length; i < max; i++) {
+				FieldBinding field = fields[i];
+				if (field == null && newFields == null) {
+					System.arraycopy(fields, 0,
+							newFields = new FieldBinding[max], 0, i);
+				} else if (newFields != null && field != null) {
+					newFields[count++] = field;
+				}
+			}
+			if (newFields != null) {
+				System.arraycopy(newFields, 0,
+						fields = new FieldBinding[count], 0, count);
 			}
+			throw e;
 		}
+		return fields;
 	}
-	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) {
-	int argCount = argumentTypes.length;
-	int selectorLength = selector.length;
-	boolean foundNothing = true;
-
-	if ((modifiers & AccUnresolved) == 0) { // have resolved all arg types & return type of the methods
-		nextMethod : for (int m = methods.length; --m >= 0;) {
-			MethodBinding method = methods[m];
-			if (method.selector.length == selectorLength && CharOperation.prefixEquals(method.selector, selector)) {
-				foundNothing = false; // inner type lookups must know that a method with this name exists
-				if (method.parameters.length == argCount) {
+
+	public MethodBinding[] getDefaultAbstractMethods() {
+		int count = 0;
+		for (int i = methods.length; --i >= 0;)
+			if (methods[i].isDefaultAbstract())
+				count++;
+		if (count == 0)
+			return NoMethods;
+
+		MethodBinding[] result = new MethodBinding[count];
+		count = 0;
+		for (int i = methods.length; --i >= 0;)
+			if (methods[i].isDefaultAbstract())
+				result[count++] = 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 ((modifiers & AccUnresolved) == 0) { // have resolved all arg types &
+												// return type of the methods
+			nextMethod: for (int m = methods.length; --m >= 0;) {
+				MethodBinding method = methods[m];
+				if (method.selector == ConstructorDeclaration.ConstantPoolName
+						&& method.parameters.length == argCount) {
 					TypeBinding[] toMatch = method.parameters;
 					for (int p = 0; p < argCount; p++)
 						if (toMatch[p] != argumentTypes[p])
@@ -457,608 +476,815 @@ public MethodBinding getExactMethod(char[] selector, TypeBinding[] argumentTypes
 					return method;
 				}
 			}
-		}
-	} else {
-		MethodBinding[] methods = getMethods(selector); // takes care of duplicates & default abstract methods
-		foundNothing = methods == NoMethods;
-		nextMethod : for (int m = methods.length; --m >= 0;) {
-			MethodBinding method = methods[m];
-			TypeBinding[] toMatch = method.parameters;
-			if (toMatch.length == argCount) {
-				for (int p = 0; p < argCount; p++)
-					if (toMatch[p] != argumentTypes[p])
-						continue nextMethod;
-				return method;
+		} else {
+			MethodBinding[] methods = getMethods(ConstructorDeclaration.ConstantPoolName); // takes
+																							// care
+																							// of
+																							// duplicates
+																							// &
+																							// default
+																							// abstract
+																							// methods
+			nextMethod: for (int m = methods.length; --m >= 0;) {
+				MethodBinding method = methods[m];
+				TypeBinding[] toMatch = method.parameters;
+				if (toMatch.length == argCount) {
+					for (int p = 0; p < argCount; p++)
+						if (toMatch[p] != argumentTypes[p])
+							continue nextMethod;
+					return method;
+				}
 			}
 		}
+		return null;
 	}
 
-	if (foundNothing) {
-		if (isInterface()) {
-			 if (superInterfaces.length == 1)
-				return superInterfaces[0].getExactMethod(selector, argumentTypes);
-		} else if (superclass != null) {
-			return superclass.getExactMethod(selector, argumentTypes);
+	// 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) {
+		int argCount = argumentTypes.length;
+		int selectorLength = selector.length;
+		boolean foundNothing = true;
+
+		if ((modifiers & AccUnresolved) == 0) { // have resolved all arg types &
+												// return type of the methods
+			nextMethod: for (int m = methods.length; --m >= 0;) {
+				MethodBinding method = methods[m];
+				if (method.selector.length == selectorLength
+						&& CharOperation
+								.prefixEquals(method.selector, selector)) {
+					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 p = 0; p < argCount; p++)
+							if (toMatch[p] != argumentTypes[p])
+								continue nextMethod;
+						return method;
+					}
+				}
+			}
+		} else {
+			MethodBinding[] methods = getMethods(selector); // takes care of
+															// duplicates &
+															// default abstract
+															// methods
+			foundNothing = methods == NoMethods;
+			nextMethod: for (int m = methods.length; --m >= 0;) {
+				MethodBinding method = methods[m];
+				TypeBinding[] toMatch = method.parameters;
+				if (toMatch.length == argCount) {
+					for (int p = 0; p < argCount; p++)
+						if (toMatch[p] != argumentTypes[p])
+							continue nextMethod;
+					return method;
+				}
+			}
 		}
-	}
-	return null;
-}
-// NOTE: the type of a field of a source type is resolved when needed
-
-public FieldBinding getField(char[] fieldName) {
-	int fieldLength = fieldName.length;
-	for (int f = fields.length; --f >= 0;) {
-		FieldBinding field = fields[f];
-		if (field.name.length == fieldLength && CharOperation.prefixEquals(field.name, fieldName)) {
-			if (resolveTypeFor(field) != null)
-				return field;
-
-			int newSize = fields.length - 1;
-			if (newSize == 0) {
-				fields = NoFields;
-			} else {
-				FieldBinding[] newFields = new FieldBinding[newSize];
-				System.arraycopy(fields, 0, newFields, 0, f);
-				System.arraycopy(fields, f + 1, newFields, f, newSize - f);
-				fields = newFields;
+
+		if (foundNothing) {
+			if (isInterface()) {
+				if (superInterfaces.length == 1)
+					return superInterfaces[0].getExactMethod(selector,
+							argumentTypes);
+			} else if (superclass != null) {
+				return superclass.getExactMethod(selector, argumentTypes);
 			}
-			return null;
 		}
+		return null;
 	}
-	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) {
-	// handle forward references to potential default abstract methods
-	addDefaultAbstractMethods();
+	// NOTE: the type of a field of a source type is resolved when needed
 
-	try{
-		int count = 0;
-		int lastIndex = -1;
-		int selectorLength = selector.length;
-		if ((modifiers & AccUnresolved) == 0) { // have resolved all arg types & return type of the methods
-			for (int m = 0, length = methods.length; m < length; m++) {
-				MethodBinding method = methods[m];
-				if (method.selector.length == selectorLength && CharOperation.prefixEquals(method.selector, selector)) {
-					count++;
-					lastIndex = m;
+	public FieldBinding getField(char[] fieldName) {
+		int fieldLength = fieldName.length;
+		for (int f = fields.length; --f >= 0;) {
+			FieldBinding field = fields[f];
+			if (field.name.length == fieldLength
+					&& CharOperation.prefixEquals(field.name, fieldName)) {
+				if (resolveTypeFor(field) != null)
+					return field;
+
+				int newSize = fields.length - 1;
+				if (newSize == 0) {
+					fields = NoFields;
+				} else {
+					FieldBinding[] newFields = new FieldBinding[newSize];
+					System.arraycopy(fields, 0, newFields, 0, f);
+					System.arraycopy(fields, f + 1, newFields, f, newSize - f);
+					fields = newFields;
 				}
+				return null;
 			}
-		} else {
-			boolean foundProblem = false;
-			int failed = 0;
-			for (int m = 0, length = methods.length; m < length; m++) {
-				MethodBinding method = methods[m];
-				if (method.selector.length == selectorLength && CharOperation.prefixEquals(method.selector, selector)) {
-					if (resolveTypesFor(method) == null) {
-						foundProblem = true;
-						methods[m] = null; // unable to resolve parameters
-						failed++;
-					} else if (method.returnType == null) {
-						foundProblem = true;
-					} else {
+		}
+		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) {
+		// handle forward references to potential default abstract methods
+		addDefaultAbstractMethods();
+
+		try {
+			int count = 0;
+			int lastIndex = -1;
+			int selectorLength = selector.length;
+			if ((modifiers & AccUnresolved) == 0) { // have resolved all arg
+													// types & return type of
+													// the methods
+				for (int m = 0, length = methods.length; m < length; m++) {
+					MethodBinding method = methods[m];
+					if (method.selector.length == selectorLength
+							&& CharOperation.prefixEquals(method.selector,
+									selector)) {
 						count++;
 						lastIndex = m;
 					}
 				}
-			}
-
-			if (foundProblem || count > 1) {
-				for (int m = methods.length; --m >= 0;) {
+			} else {
+				boolean foundProblem = false;
+				int failed = 0;
+				for (int m = 0, length = methods.length; m < length; m++) {
 					MethodBinding method = methods[m];
-					if (method != null && method.selector.length == selectorLength && CharOperation.prefixEquals(method.selector, selector)) {
-						AbstractMethodDeclaration methodDecl = null;
-						for (int i = 0; i < m; i++) {
-							MethodBinding method2 = methods[i];
-							if (method2 != null && CharOperation.equals(method.selector, method2.selector)) {
-								if (method.areParametersEqual(method2)) {
-									if (methodDecl == null) {
-										methodDecl = method.sourceMethod(); // cannot be retrieved after binding is lost
-										scope.problemReporter().duplicateMethodInType(this, methodDecl);
-										methodDecl.binding = null;
-										methods[m] = null;
+					if (method.selector.length == selectorLength
+							&& CharOperation.prefixEquals(method.selector,
+									selector)) {
+						if (resolveTypesFor(method) == null) {
+							foundProblem = true;
+							methods[m] = null; // unable to resolve parameters
+							failed++;
+						} else if (method.returnType == null) {
+							foundProblem = true;
+						} else {
+							count++;
+							lastIndex = m;
+						}
+					}
+				}
+
+				if (foundProblem || count > 1) {
+					for (int m = methods.length; --m >= 0;) {
+						MethodBinding method = methods[m];
+						if (method != null
+								&& method.selector.length == selectorLength
+								&& CharOperation.prefixEquals(method.selector,
+										selector)) {
+							AbstractMethodDeclaration methodDecl = null;
+							for (int i = 0; i < m; i++) {
+								MethodBinding method2 = methods[i];
+								if (method2 != null
+										&& CharOperation.equals(
+												method.selector,
+												method2.selector)) {
+									if (method.areParametersEqual(method2)) {
+										if (methodDecl == null) {
+											methodDecl = method.sourceMethod(); // cannot
+																				// be
+																				// retrieved
+																				// after
+																				// binding
+																				// is
+																				// lost
+											scope.problemReporter()
+													.duplicateMethodInType(
+															this, methodDecl);
+											methodDecl.binding = null;
+											methods[m] = null;
+											failed++;
+										}
+										scope.problemReporter()
+												.duplicateMethodInType(this,
+														method2.sourceMethod());
+										method2.sourceMethod().binding = null;
+										methods[i] = null;
 										failed++;
 									}
-									scope.problemReporter().duplicateMethodInType(this, method2.sourceMethod());
-									method2.sourceMethod().binding = null;
-									methods[i] = null;
-									failed++;
 								}
 							}
-						}
-						if (method.returnType == null && methodDecl == null) { // forget method with invalid return type... was kept to detect possible collisions
-							method.sourceMethod().binding = null;
-							methods[m] = null;
-							failed++;
+							if (method.returnType == null && methodDecl == null) { // forget
+																					// method
+																					// with
+																					// invalid
+																					// return
+																					// type...
+																					// was
+																					// kept
+																					// to
+																					// detect
+																					// possible
+																					// collisions
+								method.sourceMethod().binding = null;
+								methods[m] = null;
+								failed++;
+							}
 						}
 					}
-				}
 
-				if (failed > 0) {
-					int newSize = methods.length - failed;
-					if (newSize == 0)
-						return methods = NoMethods;
-
-					MethodBinding[] newMethods = new MethodBinding[newSize];
-					for (int i = 0, n = 0, max = methods.length; i < max; i++)
-						if (methods[i] != null)
-							newMethods[n++] = methods[i];
-					methods = newMethods;
-					return getMethods(selector); // try again now that the problem methods have been removed
+					if (failed > 0) {
+						int newSize = methods.length - failed;
+						if (newSize == 0)
+							return methods = NoMethods;
+
+						MethodBinding[] newMethods = new MethodBinding[newSize];
+						for (int i = 0, n = 0, max = methods.length; i < max; i++)
+							if (methods[i] != null)
+								newMethods[n++] = methods[i];
+						methods = newMethods;
+						return getMethods(selector); // try again now that
+														// the problem methods
+														// have been removed
+					}
 				}
 			}
-		}
-		if (count == 1)
-			return new MethodBinding[] {methods[lastIndex]};
-		if (count > 1) {
-			MethodBinding[] result = new MethodBinding[count];
-			count = 0;
-			for (int m = 0; m <= lastIndex; m++) {
-				MethodBinding method = methods[m];
-				if (method.selector.length == selectorLength && CharOperation.prefixEquals(method.selector, selector))
-					result[count++] = method;
+			if (count == 1)
+				return new MethodBinding[] { methods[lastIndex] };
+			if (count > 1) {
+				MethodBinding[] result = new MethodBinding[count];
+				count = 0;
+				for (int m = 0; m <= lastIndex; m++) {
+					MethodBinding method = methods[m];
+					if (method.selector.length == selectorLength
+							&& CharOperation.prefixEquals(method.selector,
+									selector))
+						result[count++] = method;
+				}
+				return result;
 			}
-			return result;
-		}
-	} catch(AbortCompilation e){
-		// ensure null methods are removed
-		MethodBinding[] newMethods = null;
-		int count = 0;
-		for (int i = 0, max = methods.length; i < max; i++){
-			MethodBinding method = methods[i];
-			if (method == null && newMethods == null){
-				System.arraycopy(methods, 0, newMethods = new MethodBinding[max], 0, i);
-			} else if (newMethods != null && method != null) {
-				newMethods[count++] = method;
+		} catch (AbortCompilation e) {
+			// ensure null methods are removed
+			MethodBinding[] newMethods = null;
+			int count = 0;
+			for (int i = 0, max = methods.length; i < max; i++) {
+				MethodBinding method = methods[i];
+				if (method == null && newMethods == null) {
+					System.arraycopy(methods, 0,
+							newMethods = new MethodBinding[max], 0, i);
+				} else if (newMethods != null && method != null) {
+					newMethods[count++] = method;
+				}
 			}
+			if (newMethods != null) {
+				System.arraycopy(newMethods, 0,
+						methods = new MethodBinding[count], 0, count);
+			}
+			modifiers ^= AccUnresolved;
+			throw e;
 		}
-		if (newMethods != null){
-			System.arraycopy(newMethods, 0, methods = new MethodBinding[count], 0, count);
-		}
-		modifiers ^= AccUnresolved;
-		throw e;
+		return NoMethods;
 	}
-	return NoMethods;
-}
-/* Answer the synthetic field for <actualOuterLocalVariable>
-*	or null if one does not exist.
-*/
 
-public FieldBinding getSyntheticField(LocalVariableBinding actualOuterLocalVariable) {
+	/*
+	 * Answer the synthetic field for <actualOuterLocalVariable> or null if one
+	 * does not exist.
+	 */
 
-	if (synthetics == null || synthetics[FIELD] == null) return null;
-	return (FieldBinding) synthetics[FIELD].get(actualOuterLocalVariable);
-}
-public ReferenceBinding[] memberTypes() {
-	return memberTypes;
-}
-public FieldBinding getUpdatedFieldBinding(FieldBinding targetField, ReferenceBinding newDeclaringClass) {
+	public FieldBinding getSyntheticField(
+			LocalVariableBinding actualOuterLocalVariable) {
 
-	if (synthetics == null) {
-		synthetics = new Hashtable[4];
-	}
-	if (synthetics[CHANGED_DECLARING_CLASS] == null) {
-		synthetics[CHANGED_DECLARING_CLASS] = new Hashtable(5);
+		if (synthetics == null || synthetics[FIELD] == null)
+			return null;
+		return (FieldBinding) synthetics[FIELD].get(actualOuterLocalVariable);
 	}
 
-	Hashtable fieldMap = (Hashtable) synthetics[CHANGED_DECLARING_CLASS].get(targetField);
-	if (fieldMap == null) {
-		fieldMap = new Hashtable(5);
-		synthetics[CHANGED_DECLARING_CLASS].put(targetField, fieldMap);
-	}
-	FieldBinding updatedField = (FieldBinding) fieldMap.get(newDeclaringClass);
-	if (updatedField == null){
-		updatedField = new FieldBinding(targetField, newDeclaringClass);
-		fieldMap.put(newDeclaringClass, updatedField);
+	public ReferenceBinding[] memberTypes() {
+		return memberTypes;
 	}
-	return updatedField;
-}
 
-public MethodBinding getUpdatedMethodBinding(MethodBinding targetMethod, ReferenceBinding newDeclaringClass) {
+	public FieldBinding getUpdatedFieldBinding(FieldBinding targetField,
+			ReferenceBinding newDeclaringClass) {
 
-	if (synthetics == null) {
-		synthetics = new Hashtable[4];
-	}
-	if (synthetics[CHANGED_DECLARING_CLASS] == null) {
-		synthetics[CHANGED_DECLARING_CLASS] = new Hashtable(5);
+		if (synthetics == null) {
+			synthetics = new Hashtable[4];
+		}
+		if (synthetics[CHANGED_DECLARING_CLASS] == null) {
+			synthetics[CHANGED_DECLARING_CLASS] = new Hashtable(5);
+		}
+
+		Hashtable fieldMap = (Hashtable) synthetics[CHANGED_DECLARING_CLASS]
+				.get(targetField);
+		if (fieldMap == null) {
+			fieldMap = new Hashtable(5);
+			synthetics[CHANGED_DECLARING_CLASS].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) {
 
-	Hashtable methodMap = (Hashtable) synthetics[CHANGED_DECLARING_CLASS].get(targetMethod);
-	if (methodMap == null) {
-		methodMap = new Hashtable(5);
-		synthetics[CHANGED_DECLARING_CLASS].put(targetMethod, methodMap);
-	}
-	MethodBinding updatedMethod = (MethodBinding) methodMap.get(newDeclaringClass);
-	if (updatedMethod == null){
-		updatedMethod = new MethodBinding(targetMethod, newDeclaringClass);
-		methodMap.put(newDeclaringClass, updatedMethod);
+		if (synthetics == null) {
+			synthetics = new Hashtable[4];
+		}
+		if (synthetics[CHANGED_DECLARING_CLASS] == null) {
+			synthetics[CHANGED_DECLARING_CLASS] = new Hashtable(5);
+		}
+
+		Hashtable methodMap = (Hashtable) synthetics[CHANGED_DECLARING_CLASS]
+				.get(targetMethod);
+		if (methodMap == null) {
+			methodMap = new Hashtable(5);
+			synthetics[CHANGED_DECLARING_CLASS].put(targetMethod, methodMap);
+		}
+		MethodBinding updatedMethod = (MethodBinding) methodMap
+				.get(newDeclaringClass);
+		if (updatedMethod == null) {
+			updatedMethod = new MethodBinding(targetMethod, newDeclaringClass);
+			methodMap.put(newDeclaringClass, updatedMethod);
+		}
+		return updatedMethod;
 	}
-	return updatedMethod;
-}
 
-// NOTE: the return type, arg & exception types of each method of a source type are resolved when needed
-public MethodBinding[] methods() {
-	try {
-		if ((modifiers & AccUnresolved) == 0)
-			return methods;
-
-		int failed = 0;
-		for (int m = 0, max = methods.length; m < max; m++) {
-			if (resolveTypesFor(methods[m]) == null) {
-				methods[m] = null; // unable to resolve parameters
-				failed++;
+	// NOTE: the return type, arg & exception types of each method of a source
+	// type are resolved when needed
+	public MethodBinding[] methods() {
+		try {
+			if ((modifiers & AccUnresolved) == 0)
+				return methods;
+
+			int failed = 0;
+			for (int m = 0, max = methods.length; m < max; m++) {
+				if (resolveTypesFor(methods[m]) == null) {
+					methods[m] = null; // unable to resolve parameters
+					failed++;
+				}
 			}
-		}
 
-		for (int m = methods.length; --m >= 0;) {
-			MethodBinding method = methods[m];
-			if (method != null) {
-				AbstractMethodDeclaration methodDecl = null;
-				for (int i = 0; i < m; i++) {
-					MethodBinding method2 = methods[i];
-					if (method2 != null && CharOperation.equals(method.selector, method2.selector)) {
-						if (method.areParametersEqual(method2)) {
-							if (methodDecl == null) {
-								methodDecl = method.sourceMethod(); // cannot be retrieved after binding is lost
-								scope.problemReporter().duplicateMethodInType(this, methodDecl);
-								methodDecl.binding = null;
-								methods[m] = null;
+			for (int m = methods.length; --m >= 0;) {
+				MethodBinding method = methods[m];
+				if (method != null) {
+					AbstractMethodDeclaration methodDecl = null;
+					for (int i = 0; i < m; i++) {
+						MethodBinding method2 = methods[i];
+						if (method2 != null
+								&& CharOperation.equals(method.selector,
+										method2.selector)) {
+							if (method.areParametersEqual(method2)) {
+								if (methodDecl == null) {
+									methodDecl = method.sourceMethod(); // cannot
+																		// be
+																		// retrieved
+																		// after
+																		// binding
+																		// is
+																		// lost
+									scope.problemReporter()
+											.duplicateMethodInType(this,
+													methodDecl);
+									methodDecl.binding = null;
+									methods[m] = null;
+									failed++;
+								}
+								scope.problemReporter().duplicateMethodInType(
+										this, method2.sourceMethod());
+								method2.sourceMethod().binding = null;
+								methods[i] = null;
 								failed++;
 							}
-							scope.problemReporter().duplicateMethodInType(this, method2.sourceMethod());
-							method2.sourceMethod().binding = null;
-							methods[i] = null;
-							failed++;
 						}
 					}
-				}
-				if (method.returnType == null && methodDecl == null) { // forget method with invalid return type... was kept to detect possible collisions
-					method.sourceMethod().binding = null;
-					methods[m] = null;
-					failed++;
+					if (method.returnType == null && methodDecl == null) { // forget
+																			// method
+																			// with
+																			// invalid
+																			// return
+																			// type...
+																			// was
+																			// kept
+																			// to
+																			// detect
+																			// possible
+																			// collisions
+						method.sourceMethod().binding = null;
+						methods[m] = null;
+						failed++;
+					}
 				}
 			}
-		}
 
-		if (failed > 0) {
-			int newSize = methods.length - failed;
-			if (newSize == 0) {
-				methods = NoMethods;
-			} else {
-				MethodBinding[] newMethods = new MethodBinding[newSize];
-				for (int m = 0, n = 0, max = methods.length; m < max; m++)
-					if (methods[m] != null)
-						newMethods[n++] = methods[m];
-				methods = newMethods;
+			if (failed > 0) {
+				int newSize = methods.length - failed;
+				if (newSize == 0) {
+					methods = NoMethods;
+				} else {
+					MethodBinding[] newMethods = new MethodBinding[newSize];
+					for (int m = 0, n = 0, max = methods.length; m < max; m++)
+						if (methods[m] != null)
+							newMethods[n++] = methods[m];
+					methods = newMethods;
+				}
 			}
-		}
 
-		// handle forward references to potential default abstract methods
-		addDefaultAbstractMethods();
-	} catch(AbortCompilation e){
-		// ensure null methods are removed
-		MethodBinding[] newMethods = null;
-		int count = 0;
-		for (int i = 0, max = methods.length; i < max; i++){
-			MethodBinding method = methods[i];
-			if (method == null && newMethods == null){
-				System.arraycopy(methods, 0, newMethods = new MethodBinding[max], 0, i);
-			} else if (newMethods != null && method != null) {
-				newMethods[count++] = method;
+			// handle forward references to potential default abstract methods
+			addDefaultAbstractMethods();
+		} catch (AbortCompilation e) {
+			// ensure null methods are removed
+			MethodBinding[] newMethods = null;
+			int count = 0;
+			for (int i = 0, max = methods.length; i < max; i++) {
+				MethodBinding method = methods[i];
+				if (method == null && newMethods == null) {
+					System.arraycopy(methods, 0,
+							newMethods = new MethodBinding[max], 0, i);
+				} else if (newMethods != null && method != null) {
+					newMethods[count++] = method;
+				}
 			}
-		}
-		if (newMethods != null){
-			System.arraycopy(newMethods, 0, methods = new MethodBinding[count], 0, count);
+			if (newMethods != null) {
+				System.arraycopy(newMethods, 0,
+						methods = new MethodBinding[count], 0, count);
+			}
+			modifiers ^= AccUnresolved;
+			throw e;
 		}
 		modifiers ^= AccUnresolved;
-		throw e;
+		return methods;
 	}
-	modifiers ^= AccUnresolved;
-	return methods;
-}
-private FieldBinding resolveTypeFor(FieldBinding field) {
-	if (field.type != null)
-		return field;
-
-	FieldDeclaration[] fieldDecls = scope.referenceContext.fields;
-	for (int f = 0, length = fieldDecls.length; f < length; f++) {
-		if (fieldDecls[f].binding != field)
-			continue;
-
-		field.type = fieldDecls[f].getTypeBinding(scope);
-		if (!field.type.isValidBinding()) {
-			scope.problemReporter().fieldTypeProblem(this, fieldDecls[f], field.type);
-			//scope.problemReporter().invalidType(fieldDecls[f].type, field.type);
-			fieldDecls[f].binding = null;
-			return null;
-		}
-		if (field.type == VoidBinding) {
-			scope.problemReporter().variableTypeCannotBeVoid(fieldDecls[f]);
-			fieldDecls[f].binding = null;
-			return null;
-		}
-		if (field.type.isArrayType() && ((ArrayBinding) field.type).leafComponentType == VoidBinding) {
-			scope.problemReporter().variableTypeCannotBeVoidArray(fieldDecls[f]);
-			fieldDecls[f].binding = null;
-			return null;
-		}
-		return field;
-	}
-	return null; // should never reach this point
-}
-private MethodBinding resolveTypesFor(MethodBinding method) {
-	if ((method.modifiers & AccUnresolved) == 0)
-		return method;
 
-	AbstractMethodDeclaration methodDecl = method.sourceMethod();
-	TypeReference[] exceptionTypes = methodDecl.thrownExceptions;
-	if (exceptionTypes != null) {
-		int size = exceptionTypes.length;
-		method.thrownExceptions = new ReferenceBinding[size];
-		ReferenceBinding throwable = scope.getJavaLangThrowable();
-		int count = 0;
-		ReferenceBinding resolvedExceptionType;
-		for (int i = 0; i < size; i++) {
-			resolvedExceptionType = (ReferenceBinding) exceptionTypes[i].getTypeBinding(scope);
-			if (!resolvedExceptionType.isValidBinding()) {
-				methodDecl.scope.problemReporter().exceptionTypeProblem(this, methodDecl, exceptionTypes[i], resolvedExceptionType);
-				//methodDecl.scope.problemReporter().invalidType(exceptionTypes[i], resolvedExceptionType);
+	private FieldBinding resolveTypeFor(FieldBinding field) {
+		if (field.type != null)
+			return field;
+
+		FieldDeclaration[] fieldDecls = scope.referenceContext.fields;
+		for (int f = 0, length = fieldDecls.length; f < length; f++) {
+			if (fieldDecls[f].binding != field)
 				continue;
+
+			field.type = fieldDecls[f].getTypeBinding(scope);
+			if (!field.type.isValidBinding()) {
+				scope.problemReporter().fieldTypeProblem(this, fieldDecls[f],
+						field.type);
+				// scope.problemReporter().invalidType(fieldDecls[f].type,
+				// field.type);
+				fieldDecls[f].binding = null;
+				return null;
 			}
-			if (throwable != resolvedExceptionType && !throwable.isSuperclassOf(resolvedExceptionType)) {
-				methodDecl.scope.problemReporter().cannotThrowType(this, methodDecl, exceptionTypes[i], resolvedExceptionType);
-				continue;
+			if (field.type == VoidBinding) {
+				scope.problemReporter().variableTypeCannotBeVoid(fieldDecls[f]);
+				fieldDecls[f].binding = null;
+				return null;
+			}
+			if (field.type.isArrayType()
+					&& ((ArrayBinding) field.type).leafComponentType == VoidBinding) {
+				scope.problemReporter().variableTypeCannotBeVoidArray(
+						fieldDecls[f]);
+				fieldDecls[f].binding = null;
+				return null;
 			}
-			method.thrownExceptions[count++] = resolvedExceptionType;
+			return field;
 		}
-		if (count < size)
-			System.arraycopy(method.thrownExceptions, 0, method.thrownExceptions = new ReferenceBinding[count], 0, count);
+		return null; // should never reach this point
 	}
 
-	boolean foundArgProblem = false;
-	Argument[] arguments = methodDecl.arguments;
-	if (arguments != null) {
-		int size = arguments.length;
-		method.parameters = new TypeBinding[size];
-		for (int i = 0; i < size; i++) {
-			Argument arg = arguments[i];
-			method.parameters[i] = arg.type.getTypeBinding(scope);
-			if (!method.parameters[i].isValidBinding()) {
-				methodDecl.scope.problemReporter().argumentTypeProblem(this, methodDecl, arg, method.parameters[i]);
-				//methodDecl.scope.problemReporter().invalidType(arg, method.parameters[i]);
-				foundArgProblem = true;
-			} else if (method.parameters[i] == VoidBinding) {
-				methodDecl.scope.problemReporter().argumentTypeCannotBeVoid(this, methodDecl, arg);
-				foundArgProblem = true;
-			} else if (method.parameters[i].isArrayType() && ((ArrayBinding) method.parameters[i]).leafComponentType == VoidBinding) {
-				methodDecl.scope.problemReporter().argumentTypeCannotBeVoidArray(this, methodDecl, arg);
-				foundArgProblem = true;
+	private MethodBinding resolveTypesFor(MethodBinding method) {
+		if ((method.modifiers & AccUnresolved) == 0)
+			return method;
+
+		AbstractMethodDeclaration methodDecl = method.sourceMethod();
+		TypeReference[] exceptionTypes = methodDecl.thrownExceptions;
+		if (exceptionTypes != null) {
+			int size = exceptionTypes.length;
+			method.thrownExceptions = new ReferenceBinding[size];
+			ReferenceBinding throwable = scope.getJavaLangThrowable();
+			int count = 0;
+			ReferenceBinding resolvedExceptionType;
+			for (int i = 0; i < size; i++) {
+				resolvedExceptionType = (ReferenceBinding) exceptionTypes[i]
+						.getTypeBinding(scope);
+				if (!resolvedExceptionType.isValidBinding()) {
+					methodDecl.scope.problemReporter().exceptionTypeProblem(
+							this, methodDecl, exceptionTypes[i],
+							resolvedExceptionType);
+					// methodDecl.scope.problemReporter().invalidType(exceptionTypes[i],
+					// resolvedExceptionType);
+					continue;
+				}
+				if (throwable != resolvedExceptionType
+						&& !throwable.isSuperclassOf(resolvedExceptionType)) {
+					methodDecl.scope.problemReporter().cannotThrowType(this,
+							methodDecl, exceptionTypes[i],
+							resolvedExceptionType);
+					continue;
+				}
+				method.thrownExceptions[count++] = resolvedExceptionType;
 			}
+			if (count < size)
+				System.arraycopy(method.thrownExceptions, 0,
+						method.thrownExceptions = new ReferenceBinding[count],
+						0, count);
 		}
-	}
 
-	boolean foundReturnTypeProblem = false;
-	if (!method.isConstructor()) {
-		TypeReference returnType = ((MethodDeclaration) methodDecl).returnType;
-		if (returnType == null) {
-			methodDecl.scope.problemReporter().missingReturnType(methodDecl);
-			method.returnType = null;
-			foundReturnTypeProblem = true;
-		} else {
-			method.returnType = returnType.getTypeBinding(scope);
-			if (!method.returnType.isValidBinding()) {
-				methodDecl.scope.problemReporter().returnTypeProblem(this, (MethodDeclaration) methodDecl, method.returnType);
-				//methodDecl.scope.problemReporter().invalidType(returnType, method.returnType);
-				method.returnType = null;
-				foundReturnTypeProblem = true;
-			} else if (method.returnType.isArrayType() && ((ArrayBinding) method.returnType).leafComponentType == VoidBinding) {
-				methodDecl.scope.problemReporter().returnTypeCannotBeVoidArray(this, (MethodDeclaration) methodDecl);
+		boolean foundArgProblem = false;
+		Argument[] arguments = methodDecl.arguments;
+		if (arguments != null) {
+			int size = arguments.length;
+			method.parameters = new TypeBinding[size];
+			for (int i = 0; i < size; i++) {
+				Argument arg = arguments[i];
+				method.parameters[i] = arg.type.getTypeBinding(scope);
+				if (!method.parameters[i].isValidBinding()) {
+					methodDecl.scope.problemReporter().argumentTypeProblem(
+							this, methodDecl, arg, method.parameters[i]);
+					// methodDecl.scope.problemReporter().invalidType(arg,
+					// method.parameters[i]);
+					foundArgProblem = true;
+				} else if (method.parameters[i] == VoidBinding) {
+					methodDecl.scope.problemReporter()
+							.argumentTypeCannotBeVoid(this, methodDecl, arg);
+					foundArgProblem = true;
+				} else if (method.parameters[i].isArrayType()
+						&& ((ArrayBinding) method.parameters[i]).leafComponentType == VoidBinding) {
+					methodDecl.scope.problemReporter()
+							.argumentTypeCannotBeVoidArray(this, methodDecl,
+									arg);
+					foundArgProblem = true;
+				}
+			}
+		}
+
+		boolean foundReturnTypeProblem = false;
+		if (!method.isConstructor()) {
+			TypeReference returnType = ((MethodDeclaration) methodDecl).returnType;
+			if (returnType == null) {
+				methodDecl.scope.problemReporter()
+						.missingReturnType(methodDecl);
 				method.returnType = null;
 				foundReturnTypeProblem = true;
+			} else {
+				method.returnType = returnType.getTypeBinding(scope);
+				if (!method.returnType.isValidBinding()) {
+					methodDecl.scope.problemReporter().returnTypeProblem(this,
+							(MethodDeclaration) methodDecl, method.returnType);
+					// methodDecl.scope.problemReporter().invalidType(returnType,
+					// method.returnType);
+					method.returnType = null;
+					foundReturnTypeProblem = true;
+				} else if (method.returnType.isArrayType()
+						&& ((ArrayBinding) method.returnType).leafComponentType == VoidBinding) {
+					methodDecl.scope.problemReporter()
+							.returnTypeCannotBeVoidArray(this,
+									(MethodDeclaration) methodDecl);
+					method.returnType = null;
+					foundReturnTypeProblem = true;
+				}
 			}
 		}
+		if (foundArgProblem) {
+			methodDecl.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 ^= AccUnresolved;
+		return method;
 	}
-	if (foundArgProblem) {
-		methodDecl.binding = null;
-		return null;
+
+	public final int sourceEnd() {
+		return scope.referenceContext.sourceEnd;
 	}
-	if (foundReturnTypeProblem)
-		return method; // but its still unresolved with a null return type & is still connected to its method declaration
 
-	method.modifiers ^= AccUnresolved;
-	return method;
-}
-public final int sourceEnd() {
-	return scope.referenceContext.sourceEnd;
-}
-public final int sourceStart() {
-	return scope.referenceContext.sourceStart;
-}
-public ReferenceBinding superclass() {
-	return superclass;
-}
-public ReferenceBinding[] superInterfaces() {
-	return superInterfaces;
-}
-public SyntheticAccessMethodBinding[] syntheticAccessMethods() {
+	public final int sourceStart() {
+		return scope.referenceContext.sourceStart;
+	}
+
+	public ReferenceBinding superclass() {
+		return superclass;
+	}
 
-	if (synthetics == null || synthetics[METHOD] == null || synthetics[METHOD].size() == 0) return null;
+	public ReferenceBinding[] superInterfaces() {
+		return superInterfaces;
+	}
 
-	// difficult to compute size up front because of the embedded arrays so assume there is only 1
-	int index = 0;
-	SyntheticAccessMethodBinding[] bindings = new SyntheticAccessMethodBinding[1];
-	Enumeration fieldsOrMethods = synthetics[METHOD].keys();
-	while (fieldsOrMethods.hasMoreElements()) {
+	public SyntheticAccessMethodBinding[] syntheticAccessMethods() {
 
-		Object fieldOrMethod = fieldsOrMethods.nextElement();
+		if (synthetics == null || synthetics[METHOD] == null
+				|| synthetics[METHOD].size() == 0)
+			return null;
 
-		if (fieldOrMethod instanceof MethodBinding) {
+		// difficult to compute size up front because of the embedded arrays so
+		// assume there is only 1
+		int index = 0;
+		SyntheticAccessMethodBinding[] bindings = new SyntheticAccessMethodBinding[1];
+		Enumeration fieldsOrMethods = synthetics[METHOD].keys();
+		while (fieldsOrMethods.hasMoreElements()) {
+
+			Object fieldOrMethod = fieldsOrMethods.nextElement();
+
+			if (fieldOrMethod instanceof MethodBinding) {
+
+				SyntheticAccessMethodBinding[] methodAccessors = (SyntheticAccessMethodBinding[]) synthetics[METHOD]
+						.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 SyntheticAccessMethodBinding[index
+									+ numberOfAccessors]), 0, index);
+				if (methodAccessors[0] != null)
+					bindings[index++] = methodAccessors[0]; // super access
+				if (methodAccessors[1] != null)
+					bindings[index++] = methodAccessors[1]; // normal access
 
-			SyntheticAccessMethodBinding[] methodAccessors = (SyntheticAccessMethodBinding[]) synthetics[METHOD].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 SyntheticAccessMethodBinding[index + numberOfAccessors]), 0, index);
-			if (methodAccessors[0] != null)
-				bindings[index++] = methodAccessors[0]; // super access
-			if (methodAccessors[1] != null)
-				bindings[index++] = methodAccessors[1]; // normal access
+			} else {
 
-		} else {
+				SyntheticAccessMethodBinding[] fieldAccessors = (SyntheticAccessMethodBinding[]) synthetics[METHOD]
+						.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 SyntheticAccessMethodBinding[index
+									+ numberOfAccessors]), 0, index);
+				if (fieldAccessors[0] != null)
+					bindings[index++] = fieldAccessors[0]; // read access
+				if (fieldAccessors[1] != null)
+					bindings[index++] = fieldAccessors[1]; // write access
+			}
+		}
 
-			SyntheticAccessMethodBinding[] fieldAccessors = (SyntheticAccessMethodBinding[]) synthetics[METHOD].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 SyntheticAccessMethodBinding[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;
+		SyntheticAccessMethodBinding[] sortedBindings = new SyntheticAccessMethodBinding[length = bindings.length];
+		for (int i = 0; i < length; i++) {
+			SyntheticAccessMethodBinding binding = bindings[i];
+			sortedBindings[binding.index] = binding;
 		}
+		return sortedBindings;
 	}
 
-	// sort them in according to their own indexes
-	int length;
-	SyntheticAccessMethodBinding[] sortedBindings = new SyntheticAccessMethodBinding[length = bindings.length];
-	for (int i = 0; i < length; i++){
-		SyntheticAccessMethodBinding binding = bindings[i];
-		sortedBindings[binding.index] = binding;
-	}
-	return sortedBindings;
-}
-/**
- * Answer the collection of synthetic fields to append into the classfile
- */
-public FieldBinding[] syntheticFields() {
-
-	if (synthetics == null) return null;
-
-	int fieldSize = synthetics[FIELD] == null ? 0 : synthetics[FIELD].size();
-	int literalSize = synthetics[CLASS_LITERAL] == null ? 0 :synthetics[CLASS_LITERAL].size();
-	int totalSize = fieldSize + literalSize;
-	if (totalSize == 0) return null;
-	FieldBinding[] bindings = new FieldBinding[totalSize];
-
-	// add innerclass synthetics
-	if (synthetics[FIELD] != null){
-		Enumeration elements = synthetics[FIELD].elements();
-		for (int i = 0; i < fieldSize; i++) {
-			SyntheticFieldBinding synthBinding = (SyntheticFieldBinding) elements.nextElement();
-			bindings[synthBinding.index] = synthBinding;
+	/**
+	 * Answer the collection of synthetic fields to append into the classfile
+	 */
+	public FieldBinding[] syntheticFields() {
+
+		if (synthetics == null)
+			return null;
+
+		int fieldSize = synthetics[FIELD] == null ? 0 : synthetics[FIELD]
+				.size();
+		int literalSize = synthetics[CLASS_LITERAL] == null ? 0
+				: synthetics[CLASS_LITERAL].size();
+		int totalSize = fieldSize + literalSize;
+		if (totalSize == 0)
+			return null;
+		FieldBinding[] bindings = new FieldBinding[totalSize];
+
+		// add innerclass synthetics
+		if (synthetics[FIELD] != null) {
+			Enumeration elements = synthetics[FIELD].elements();
+			for (int i = 0; i < fieldSize; i++) {
+				SyntheticFieldBinding synthBinding = (SyntheticFieldBinding) elements
+						.nextElement();
+				bindings[synthBinding.index] = synthBinding;
+			}
 		}
-	}
-	// add class literal synthetics
-	if (synthetics[CLASS_LITERAL] != null){
-		Enumeration elements = synthetics[CLASS_LITERAL].elements();
-		for (int i = 0; i < literalSize; i++) {
-			SyntheticFieldBinding synthBinding = (SyntheticFieldBinding) elements.nextElement();
-			bindings[fieldSize+synthBinding.index] = synthBinding;
+		// add class literal synthetics
+		if (synthetics[CLASS_LITERAL] != null) {
+			Enumeration elements = synthetics[CLASS_LITERAL].elements();
+			for (int i = 0; i < literalSize; i++) {
+				SyntheticFieldBinding synthBinding = (SyntheticFieldBinding) elements
+						.nextElement();
+				bindings[fieldSize + synthBinding.index] = synthBinding;
+			}
 		}
+		return bindings;
 	}
-	return bindings;
-}
-public String toString() {
-	String s = "(id="+(id == NoId ? "NoId" : (""+id) ) +")\n"; //$NON-NLS-3$ //$NON-NLS-2$ //$NON-NLS-4$ //$NON-NLS-1$
-
-	if (isDeprecated()) s += "deprecated "; //$NON-NLS-1$
-	if (isPublic()) s += "public "; //$NON-NLS-1$
-	if (isProtected()) s += "protected "; //$NON-NLS-1$
-	if (isPrivate()) s += "private "; //$NON-NLS-1$
-	if (isAbstract() && isClass()) s += "abstract "; //$NON-NLS-1$
-	if (isStatic() && isNestedType()) s += "static "; //$NON-NLS-1$
-	if (isFinal()) s += "final "; //$NON-NLS-1$
-
-	s += isInterface() ? "interface " : "class "; //$NON-NLS-1$ //$NON-NLS-2$
-	s += (compoundName != null) ? CharOperation.toString(compoundName) : "UNNAMED TYPE"; //$NON-NLS-1$
-
-	s += "\n\textends "; //$NON-NLS-1$
-	s += (superclass != null) ? superclass.debugName() : "NULL TYPE"; //$NON-NLS-1$
-
-	if (superInterfaces != null) {
-		if (superInterfaces != NoSuperInterfaces) {
-			s += "\n\timplements : "; //$NON-NLS-1$
-			for (int i = 0, length = superInterfaces.length; i < length; i++) {
-				if (i  > 0)
-					s += ", "; //$NON-NLS-1$
-				s += (superInterfaces[i] != null) ? superInterfaces[i].debugName() : "NULL TYPE"; //$NON-NLS-1$
+
+	public String toString() {
+		String s = "(id=" + (id == NoId ? "NoId" : ("" + id)) + ")\n"; //$NON-NLS-3$ //$NON-NLS-2$ //$NON-NLS-4$ //$NON-NLS-1$
+
+		if (isDeprecated())
+			s += "deprecated "; //$NON-NLS-1$
+		if (isPublic())
+			s += "public "; //$NON-NLS-1$
+		if (isProtected())
+			s += "protected "; //$NON-NLS-1$
+		if (isPrivate())
+			s += "private "; //$NON-NLS-1$
+		if (isAbstract() && isClass())
+			s += "abstract "; //$NON-NLS-1$
+		if (isStatic() && isNestedType())
+			s += "static "; //$NON-NLS-1$
+		if (isFinal())
+			s += "final "; //$NON-NLS-1$
+
+		s += isInterface() ? "interface " : "class "; //$NON-NLS-1$ //$NON-NLS-2$
+		s += (compoundName != null) ? CharOperation.toString(compoundName)
+				: "UNNAMED TYPE"; //$NON-NLS-1$
+
+		s += "\n\textends "; //$NON-NLS-1$
+		s += (superclass != null) ? superclass.debugName() : "NULL TYPE"; //$NON-NLS-1$
+
+		if (superInterfaces != null) {
+			if (superInterfaces != NoSuperInterfaces) {
+				s += "\n\timplements : "; //$NON-NLS-1$
+				for (int i = 0, length = superInterfaces.length; i < length; i++) {
+					if (i > 0)
+						s += ", "; //$NON-NLS-1$
+					s += (superInterfaces[i] != null) ? superInterfaces[i]
+							.debugName() : "NULL TYPE"; //$NON-NLS-1$
+				}
 			}
+		} else {
+			s += "NULL SUPERINTERFACES"; //$NON-NLS-1$
 		}
-	} else {
-		s += "NULL SUPERINTERFACES"; //$NON-NLS-1$
-	}
 
-	if (enclosingType() != null) {
-		s += "\n\tenclosing type : "; //$NON-NLS-1$
-		s += enclosingType().debugName();
-	}
+		if (enclosingType() != null) {
+			s += "\n\tenclosing type : "; //$NON-NLS-1$
+			s += enclosingType().debugName();
+		}
 
-	if (fields != null) {
-		if (fields != NoFields) {
-			s += "\n/*   fields   */"; //$NON-NLS-1$
-			for (int i = 0, length = fields.length; i < length; i++)
-				s += (fields[i] != null) ? "\n" + fields[i].toString() : "\nNULL FIELD"; //$NON-NLS-1$ //$NON-NLS-2$
+		if (fields != null) {
+			if (fields != NoFields) {
+				s += "\n/*   fields   */"; //$NON-NLS-1$
+				for (int i = 0, length = fields.length; i < length; i++)
+					s += (fields[i] != null) ? "\n" + fields[i].toString() : "\nNULL FIELD"; //$NON-NLS-1$ //$NON-NLS-2$
+			}
+		} else {
+			s += "NULL FIELDS"; //$NON-NLS-1$
 		}
-	} else {
-		s += "NULL FIELDS"; //$NON-NLS-1$
-	}
 
-	if (methods != null) {
-		if (methods != NoMethods) {
-			s += "\n/*   methods   */"; //$NON-NLS-1$
-			for (int i = 0, length = methods.length; i < length; i++)
-				s += (methods[i] != null) ? "\n" + methods[i].toString() : "\nNULL METHOD"; //$NON-NLS-1$ //$NON-NLS-2$
+		if (methods != null) {
+			if (methods != NoMethods) {
+				s += "\n/*   methods   */"; //$NON-NLS-1$
+				for (int i = 0, length = methods.length; i < length; i++)
+					s += (methods[i] != null) ? "\n" + methods[i].toString() : "\nNULL METHOD"; //$NON-NLS-1$ //$NON-NLS-2$
+			}
+		} else {
+			s += "NULL METHODS"; //$NON-NLS-1$
 		}
-	} else {
-		s += "NULL METHODS"; //$NON-NLS-1$
-	}
 
-	if (memberTypes != null) {
-		if (memberTypes != NoMemberTypes) {
-			s += "\n/*   members   */"; //$NON-NLS-1$
-			for (int i = 0, length = memberTypes.length; i < length; i++)
-				s += (memberTypes[i] != null) ? "\n" + memberTypes[i].toString() : "\nNULL TYPE"; //$NON-NLS-1$ //$NON-NLS-2$
+		if (memberTypes != null) {
+			if (memberTypes != NoMemberTypes) {
+				s += "\n/*   members   */"; //$NON-NLS-1$
+				for (int i = 0, length = memberTypes.length; i < length; i++)
+					s += (memberTypes[i] != null) ? "\n" + memberTypes[i].toString() : "\nNULL TYPE"; //$NON-NLS-1$ //$NON-NLS-2$
+			}
+		} else {
+			s += "NULL MEMBER TYPES"; //$NON-NLS-1$
 		}
-	} else {
-		s += "NULL MEMBER TYPES"; //$NON-NLS-1$
+
+		s += "\n\n\n"; //$NON-NLS-1$
+		return s;
 	}
 
-	s += "\n\n\n"; //$NON-NLS-1$
-	return s;
-}
-void verifyMethods(MethodVerifier verifier) {
-	verifier.verify(this);
+	void verifyMethods(MethodVerifier verifier) {
+		verifier.verify(this);
 
-	for (int i = memberTypes.length; --i >= 0;)
-		 ((SourceTypeBinding) memberTypes[i]).verifyMethods(verifier);
-}
+		for (int i = memberTypes.length; --i >= 0;)
+			((SourceTypeBinding) memberTypes[i]).verifyMethods(verifier);
+	}
+
+	/*
+	 * Answer the synthetic field for <targetEnclosingType> or null if one does
+	 * not exist.
+	 */
 
-/* Answer the synthetic field for <targetEnclosingType>
-*	or null if one does not exist.
-*/
-
-public FieldBinding getSyntheticField(ReferenceBinding targetEnclosingType, boolean onlyExactMatch) {
-
-	if (synthetics == null || synthetics[FIELD] == null) return null;
-	FieldBinding field = (FieldBinding) synthetics[FIELD].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){
-		Enumeration e = synthetics[FIELD].elements();
-		while (e.hasMoreElements()) {
-			field = (FieldBinding) e.nextElement();
-			if (CharOperation.prefixEquals(SyntheticArgumentBinding.EnclosingInstancePrefix, field.name)
-				&& targetEnclosingType.isSuperclassOf((ReferenceBinding) field.type))
+	public FieldBinding getSyntheticField(ReferenceBinding targetEnclosingType,
+			boolean onlyExactMatch) {
+
+		if (synthetics == null || synthetics[FIELD] == null)
+			return null;
+		FieldBinding field = (FieldBinding) synthetics[FIELD]
+				.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) {
+			Enumeration e = synthetics[FIELD].elements();
+			while (e.hasMoreElements()) {
+				field = (FieldBinding) e.nextElement();
+				if (CharOperation.prefixEquals(
+						SyntheticArgumentBinding.EnclosingInstancePrefix,
+						field.name)
+						&& targetEnclosingType
+								.isSuperclassOf((ReferenceBinding) field.type))
 					return field;
+			}
 		}
+		return null;
 	}
-	return null;
-}
 }