[pkg-eucalyptus-commits] r296 - gwt/trunk/debian/patches

Charles Plessy plessy at alioth.debian.org
Sat Nov 3 11:33:51 UTC 2012


Author: plessy
Date: 2012-11-03 11:33:51 +0000 (Sat, 03 Nov 2012)
New Revision: 296

Removed:
   gwt/trunk/debian/patches/build-with-jdt38
Modified:
   gwt/trunk/debian/patches/build-with-jdt35
   gwt/trunk/debian/patches/build-with-jdt37
   gwt/trunk/debian/patches/series
Log:
Refreshing patches (some files patched in 2.4.0 were removed in 2.5.0)


Modified: gwt/trunk/debian/patches/build-with-jdt35
===================================================================
--- gwt/trunk/debian/patches/build-with-jdt35	2012-11-03 11:13:17 UTC (rev 295)
+++ gwt/trunk/debian/patches/build-with-jdt35	2012-11-03 11:33:51 UTC (rev 296)
@@ -9,2159 +9,20 @@
      options.inlineJsrBytecode = true;
      return options;
    }
---- a/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
-+++ /dev/null
-@@ -1,1077 +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 java.util.ArrayList;
--
--import org.eclipse.jdt.core.compiler.CharOperation;
--import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
--import org.eclipse.jdt.internal.compiler.env.*;
--import org.eclipse.jdt.internal.compiler.impl.Constant;
--import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
--import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
--
--/*
--Not all fields defined by this type are initialized when it is created.
--Some are initialized only when needed.
--
--Accessors have been provided for some public fields so all TypeBindings have the same API...
--but access public fields directly whenever possible.
--Non-public fields have accessors which should be used everywhere you expect the field to be initialized.
--
--null is NOT a valid value for a non-public field... it just means the field is not initialized.
--*/
--
--public class BinaryTypeBinding extends ReferenceBinding {
--
--	// all of these fields are ONLY guaranteed to be initialized if accessed using their public accessor method
--	protected ReferenceBinding superclass;
--	protected ReferenceBinding enclosingType;
--	protected ReferenceBinding[] superInterfaces;
--	protected FieldBinding[] fields;
--	protected MethodBinding[] methods;
--	protected MethodBinding[] bridgeMethods = Binding.NO_METHODS;
--	protected ReferenceBinding[] memberTypes;
--	protected TypeVariableBinding[] typeVariables;
--
--	// For the link with the principle structure
--	protected LookupEnvironment environment;
--
--	protected SimpleLookupTable storedAnnotations = null; // keys are this ReferenceBinding & its fields and methods, value is an AnnotationHolder
--
--static Object convertMemberValue(Object binaryValue, LookupEnvironment env, char[][][] missingTypeNames) {
--	if (binaryValue == null) return null;
--	if (binaryValue instanceof Constant)
--		return binaryValue;
--	if (binaryValue instanceof ClassSignature) {
--		TypeBinding typeFromSignature = env.getTypeFromSignature(((ClassSignature) binaryValue).getTypeName(), 0, -1, false, null, missingTypeNames);
--		if (typeFromSignature.isBaseType()) {
--			return typeFromSignature;
--		}
--		return resolveType((ReferenceBinding) typeFromSignature, env, false);
--	}
--	if (binaryValue instanceof IBinaryAnnotation)
--		return createAnnotation((IBinaryAnnotation) binaryValue, env, missingTypeNames);
--	if (binaryValue instanceof EnumConstantSignature) {
--		EnumConstantSignature ref = (EnumConstantSignature) binaryValue;
--		ReferenceBinding enumType = (ReferenceBinding) env.getTypeFromSignature(ref.getTypeName(), 0, -1, false, null, missingTypeNames);
--		enumType = resolveType(enumType, env, false);
--		return enumType.getField(ref.getEnumConstantName(), false);
--	}
--	if (binaryValue instanceof Object[]) {
--		Object[] objects = (Object[]) binaryValue;
--		int length = objects.length;
--		if (length == 0) return objects;
--		Object[] values = new Object[length];
--		for (int i = 0; i < length; i++)
--			values[i] = convertMemberValue(objects[i], env, missingTypeNames);
--		return values;
--	}
--
--	// should never reach here.
--	throw new IllegalStateException();
--}
--static AnnotationBinding createAnnotation(IBinaryAnnotation annotationInfo, LookupEnvironment env, char[][][] missingTypeNames) {
--	IBinaryElementValuePair[] binaryPairs = annotationInfo.getElementValuePairs();
--	int length = binaryPairs == null ? 0 : binaryPairs.length;
--	ElementValuePair[] pairs = length == 0 ? Binding.NO_ELEMENT_VALUE_PAIRS : new ElementValuePair[length];
--	for (int i = 0; i < length; i++)
--		pairs[i] = new ElementValuePair(binaryPairs[i].getName(), convertMemberValue(binaryPairs[i].getValue(), env, missingTypeNames), null);
--
--	char[] typeName = annotationInfo.getTypeName();
--	ReferenceBinding annotationType = env.getTypeFromConstantPoolName(typeName, 1, typeName.length - 1, false, missingTypeNames);
--	return new UnresolvedAnnotationBinding(annotationType, pairs, env);
--}
--public static AnnotationBinding[] createAnnotations(IBinaryAnnotation[] annotationInfos, LookupEnvironment env, char[][][] missingTypeNames) {
--	int length = annotationInfos == null ? 0 : annotationInfos.length;
--	AnnotationBinding[] result = length == 0 ? Binding.NO_ANNOTATIONS : new AnnotationBinding[length];
--	for (int i = 0; i < length; i++)
--		result[i] = createAnnotation(annotationInfos[i], env, missingTypeNames);
--	return result;
--}
--public static ReferenceBinding resolveType(ReferenceBinding type, LookupEnvironment environment, boolean convertGenericToRawType) {
--	if (type instanceof UnresolvedReferenceBinding)
--		return ((UnresolvedReferenceBinding) type).resolve(environment, convertGenericToRawType);
--	switch (type.kind()) {
--		case Binding.PARAMETERIZED_TYPE :
--			return ((ParameterizedTypeBinding) type).resolve();
--		case Binding.WILDCARD_TYPE :
--		case Binding.INTERSECTION_TYPE :
--			return ((WildcardBinding) type).resolve();
--	}
--	if (convertGenericToRawType) // raw reference to generic ?
--		return (ReferenceBinding) environment.convertUnresolvedBinaryToRawType(type);
--	return type;
--}
--public static TypeBinding resolveType(TypeBinding type, LookupEnvironment environment, ParameterizedTypeBinding parameterizedType, int rank) {
--	switch (type.kind()) {
--		
--		case Binding.PARAMETERIZED_TYPE :
--			return ((ParameterizedTypeBinding) type).resolve();
--			
--		case Binding.WILDCARD_TYPE :
--		case Binding.INTERSECTION_TYPE :
--			return ((WildcardBinding) type).resolve();
--			
--		case Binding.ARRAY_TYPE :
--			resolveType(((ArrayBinding) type).leafComponentType, environment, parameterizedType, rank);
--			break;
--			
--		case Binding.TYPE_PARAMETER :
--			((TypeVariableBinding) type).resolve(environment);
--			break;
--						
--		case Binding.GENERIC_TYPE :
--			if (parameterizedType == null) // raw reference to generic ?
--				return environment.convertUnresolvedBinaryToRawType(type);
--			break;
--			
--		default:			
--			if (type instanceof UnresolvedReferenceBinding)
--				return ((UnresolvedReferenceBinding) type).resolve(environment, parameterizedType == null);
--	}
--	return type;
--}
--
--/**
-- * Default empty constructor for subclasses only.
-- */
--protected BinaryTypeBinding() {
--	// only for subclasses
--}
--
--/**
-- * Standard constructor for creating binary type bindings from binary models (classfiles)
-- * @param packageBinding
-- * @param binaryType
-- * @param environment
-- */
--public BinaryTypeBinding(PackageBinding packageBinding, IBinaryType binaryType, LookupEnvironment environment) {
--	this.compoundName = CharOperation.splitOn('/', binaryType.getName());
--	computeId();
--
--	this.tagBits |= TagBits.IsBinaryBinding;
--	this.environment = environment;
--	this.fPackage = packageBinding;
--	this.fileName = binaryType.getFileName();
--
--	char[] typeSignature = environment.globalOptions.sourceLevel >= ClassFileConstants.JDK1_5 ? binaryType.getGenericSignature() : null;
--	this.typeVariables = typeSignature != null && typeSignature.length > 0 && typeSignature[0] == '<'
--		? null // is initialized in cachePartsFrom (called from LookupEnvironment.createBinaryTypeFrom())... must set to null so isGenericType() answers true
--		: Binding.NO_TYPE_VARIABLES;
--
--	this.sourceName = binaryType.getSourceName();
--	this.modifiers = binaryType.getModifiers();
--
--	if ((binaryType.getTagBits() & TagBits.HierarchyHasProblems) != 0)
--		this.tagBits |= TagBits.HierarchyHasProblems;
--		
--	if (binaryType.isAnonymous()) {
--		this.tagBits |= TagBits.AnonymousTypeMask;
--	} else if (binaryType.isLocal()) {
--		this.tagBits |= TagBits.LocalTypeMask;
--	} else if (binaryType.isMember()) {
--		this.tagBits |= TagBits.MemberTypeMask;
--	}
--	// need enclosing type to access type variables
--	char[] enclosingTypeName = binaryType.getEnclosingTypeName();
--	if (enclosingTypeName != null) {
--		// attempt to find the enclosing type if it exists in the cache (otherwise - resolve it when requested)
--		this.enclosingType = environment.getTypeFromConstantPoolName(enclosingTypeName, 0, -1, true, null /* could not be missing */); // pretend parameterized to avoid raw
--		this.tagBits |= TagBits.MemberTypeMask;   // must be a member type not a top-level or local type
--		this.tagBits |= 	TagBits.HasUnresolvedEnclosingType;
--		if (this.enclosingType().isStrictfp())
--			this.modifiers |= ClassFileConstants.AccStrictfp;
--		if (this.enclosingType().isDeprecated())
--			this.modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
--	}	
--}
--
--/**
-- * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#availableMethods()
-- */
--public FieldBinding[] availableFields() {
--	if ((this.tagBits & TagBits.AreFieldsComplete) != 0)
--		return 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;
--	}
--	FieldBinding[] availableFields = new FieldBinding[fields.length];
--	int count = 0;
--	for (int i = 0; i < fields.length; i++) {
--		try {
--			availableFields[count] = resolveTypeFor(fields[i]);
--			count++;
--		} catch (AbortCompilation a){
--			// silent abort
--		}
--	}
--	if (count < availableFields.length)
--		System.arraycopy(availableFields, 0, availableFields = new FieldBinding[count], 0, count);
--	return availableFields;
--}
--
--/**
-- * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#availableMethods()
-- */
--public MethodBinding[] availableMethods() {
--	if ((this.tagBits & TagBits.AreMethodsComplete) != 0)
--		return 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[] availableMethods = new MethodBinding[methods.length];
--	int count = 0;
--	for (int i = 0; i < methods.length; i++) {
--		try {
--			availableMethods[count] = resolveTypesFor(methods[i]);
--			count++;
--		} catch (AbortCompilation a){
--			// silent abort
--		}
--	}
--	if (count < availableMethods.length)
--		System.arraycopy(availableMethods, 0, availableMethods = new MethodBinding[count], 0, count);
--	return availableMethods;
--}
--void cachePartsFrom(IBinaryType binaryType, boolean needFieldsAndMethods) {
--	// default initialization for super-interfaces early, in case some aborting compilation error occurs,
--	// and still want to use binaries passed that point (e.g. type hierarchy resolver, see bug 63748).
--	this.typeVariables = Binding.NO_TYPE_VARIABLES;
--	this.superInterfaces = Binding.NO_SUPERINTERFACES;
--
--	// must retrieve member types in case superclass/interfaces need them
--	this.memberTypes = Binding.NO_MEMBER_TYPES;
--	IBinaryNestedType[] memberTypeStructures = binaryType.getMemberTypes();
--	if (memberTypeStructures != null) {
--		int size = memberTypeStructures.length;
--		if (size > 0) {
--			this.memberTypes = new ReferenceBinding[size];
--			for (int i = 0; i < size; i++)
--				// attempt to find each member type if it exists in the cache (otherwise - resolve it when requested)
--				this.memberTypes[i] = environment.getTypeFromConstantPoolName(memberTypeStructures[i].getName(), 0, -1, false, null /* could not be missing */);
--			this.tagBits |= 	TagBits.HasUnresolvedMemberTypes;
--		}
--	}
--
--	
--	long sourceLevel = environment.globalOptions.sourceLevel;
--	char[] typeSignature = null;
--	if (sourceLevel >= ClassFileConstants.JDK1_5) {
--		typeSignature = binaryType.getGenericSignature();
--		this.tagBits |= binaryType.getTagBits();
--	}
--	char[][][] missingTypeNames = binaryType.getMissingTypeNames();	
--	if (typeSignature == null) {
--		char[] superclassName = binaryType.getSuperclassName();
--		if (superclassName != null) {
--			// attempt to find the superclass if it exists in the cache (otherwise - resolve it when requested)
--			this.superclass = environment.getTypeFromConstantPoolName(superclassName, 0, -1, false, missingTypeNames);
--			this.tagBits |= TagBits.HasUnresolvedSuperclass;
--		}
--
--		this.superInterfaces = Binding.NO_SUPERINTERFACES;
--		char[][] interfaceNames = binaryType.getInterfaceNames();
--		if (interfaceNames != null) {
--			int size = interfaceNames.length;
--			if (size > 0) {
--				this.superInterfaces = new ReferenceBinding[size];
--				for (int i = 0; i < size; i++)
--					// attempt to find each superinterface if it exists in the cache (otherwise - resolve it when requested)
--					this.superInterfaces[i] = environment.getTypeFromConstantPoolName(interfaceNames[i], 0, -1, false, missingTypeNames);
--				this.tagBits |= TagBits.HasUnresolvedSuperinterfaces;
--			}
--		}
--	} else {
--		// ClassSignature = ParameterPart(optional) super_TypeSignature interface_signature
--		SignatureWrapper wrapper = new SignatureWrapper(typeSignature);
--		if (wrapper.signature[wrapper.start] == '<') {
--			// ParameterPart = '<' ParameterSignature(s) '>'
--			wrapper.start++; // skip '<'
--			this.typeVariables = createTypeVariables(wrapper, true, missingTypeNames);
--			wrapper.start++; // skip '>'
--			this.tagBits |=  TagBits.HasUnresolvedTypeVariables;
--			this.modifiers |= ExtraCompilerModifiers.AccGenericSignature;
--		}
--
--		// attempt to find the superclass if it exists in the cache (otherwise - resolve it when requested)
--		this.superclass = (ReferenceBinding) environment.getTypeFromTypeSignature(wrapper, Binding.NO_TYPE_VARIABLES, this, missingTypeNames);
--		this.tagBits |= TagBits.HasUnresolvedSuperclass;
--
--		this.superInterfaces = Binding.NO_SUPERINTERFACES;
--		if (!wrapper.atEnd()) {
--			// attempt to find each superinterface if it exists in the cache (otherwise - resolve it when requested)
--			java.util.ArrayList types = new java.util.ArrayList(2);
--			do {
--				types.add(environment.getTypeFromTypeSignature(wrapper, Binding.NO_TYPE_VARIABLES, this, missingTypeNames));
--			} while (!wrapper.atEnd());
--			this.superInterfaces = new ReferenceBinding[types.size()];
--			types.toArray(this.superInterfaces);
--			this.tagBits |= TagBits.HasUnresolvedSuperinterfaces;
--		}
--	}
--
--	if (needFieldsAndMethods) {
--		createFields(binaryType.getFields(), sourceLevel, missingTypeNames);
--		createMethods(binaryType.getMethods(), sourceLevel, missingTypeNames);
--	} else { // protect against incorrect use of the needFieldsAndMethods flag, see 48459
--		this.fields = Binding.NO_FIELDS;
--		this.methods = Binding.NO_METHODS;
--	}
--	if (this.environment.globalOptions.storeAnnotations)
--		setAnnotations(createAnnotations(binaryType.getAnnotations(), this.environment, missingTypeNames));	
--}
--private void createFields(IBinaryField[] iFields, long sourceLevel, char[][][] missingTypeNames) {
--	this.fields = Binding.NO_FIELDS;
--	if (iFields != null) {
--		int size = iFields.length;
--		if (size > 0) {
--			this.fields = new FieldBinding[size];
--			boolean use15specifics = sourceLevel >= ClassFileConstants.JDK1_5;
--			boolean isViewedAsDeprecated = isViewedAsDeprecated();
--			boolean hasRestrictedAccess = hasRestrictedAccess();
--			int firstAnnotatedFieldIndex = -1;
--			for (int i = 0; i < size; i++) {
--				IBinaryField binaryField = iFields[i];
--				char[] fieldSignature = use15specifics ? binaryField.getGenericSignature() : null;
--				TypeBinding type = fieldSignature == null 
--					? environment.getTypeFromSignature(binaryField.getTypeName(), 0, -1, false, this, missingTypeNames) 
--					: environment.getTypeFromTypeSignature(new SignatureWrapper(fieldSignature), Binding.NO_TYPE_VARIABLES, this, missingTypeNames);
--				FieldBinding field = 
--					new FieldBinding(
--						binaryField.getName(), 
--						type, 
--						binaryField.getModifiers() | ExtraCompilerModifiers.AccUnresolved, 
--						this, 
--						binaryField.getConstant());
--				if (firstAnnotatedFieldIndex < 0
--						&& this.environment.globalOptions.storeAnnotations 
--						&& binaryField.getAnnotations() != null) {
--					firstAnnotatedFieldIndex = i;
--				}
--				field.id = i; // ordinal
--				if (use15specifics)
--					field.tagBits |= binaryField.getTagBits();
--				if (isViewedAsDeprecated && !field.isDeprecated())
--					field.modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
--				if (hasRestrictedAccess)
--					field.modifiers |= ExtraCompilerModifiers.AccRestrictedAccess;
--				if (fieldSignature != null)
--					field.modifiers |= ExtraCompilerModifiers.AccGenericSignature;
--				this.fields[i] = field;
--			}
--			// second pass for reifying annotations, since may refer to fields being constructed (147875)
--			if (firstAnnotatedFieldIndex >= 0) {
--				for (int i = firstAnnotatedFieldIndex; i <size; i++) {
--					IBinaryField binaryField = iFields[i];
--					this.fields[i].setAnnotations(createAnnotations(binaryField.getAnnotations(), this.environment, missingTypeNames));
--				}
--			}
--		}
--	}
--}
--private MethodBinding createMethod(IBinaryMethod method, long sourceLevel, char[][][] missingTypeNames) {
--	int methodModifiers = method.getModifiers() | ExtraCompilerModifiers.AccUnresolved;
--	if (sourceLevel < ClassFileConstants.JDK1_5)
--		methodModifiers &= ~ClassFileConstants.AccVarargs; // vararg methods are not recognized until 1.5
--	ReferenceBinding[] exceptions = Binding.NO_EXCEPTIONS;
--	TypeBinding[] parameters = Binding.NO_PARAMETERS;
--	TypeVariableBinding[] typeVars = Binding.NO_TYPE_VARIABLES;
--	AnnotationBinding[][] paramAnnotations = null; 
--	TypeBinding returnType = null;
--
--	final boolean use15specifics = sourceLevel >= ClassFileConstants.JDK1_5;
--	char[] methodSignature = use15specifics ? method.getGenericSignature() : null;
--	if (methodSignature == null) { // no generics
--		char[] methodDescriptor = method.getMethodDescriptor();   // of the form (I[Ljava/jang/String;)V
--		int numOfParams = 0;
--		char nextChar;
--		int index = 0;   // first character is always '(' so skip it
--		while ((nextChar = methodDescriptor[++index]) != ')') {
--			if (nextChar != '[') {
--				numOfParams++;
--				if (nextChar == 'L')
--					while ((nextChar = methodDescriptor[++index]) != ';'){/*empty*/}
--			}
--		}
--
--		// Ignore synthetic argument for member types.
--		int startIndex = (method.isConstructor() && isMemberType() && !isStatic()) ? 1 : 0;
--		int size = numOfParams - startIndex;
--		if (size > 0) {
--			parameters = new TypeBinding[size];
--			if (this.environment.globalOptions.storeAnnotations)
--				paramAnnotations = new AnnotationBinding[size][];
--			index = 1;
--			int end = 0;   // first character is always '(' so skip it
--			for (int i = 0; i < numOfParams; i++) {
--				while ((nextChar = methodDescriptor[++end]) == '['){/*empty*/}
--				if (nextChar == 'L')
--					while ((nextChar = methodDescriptor[++end]) != ';'){/*empty*/}
--
--				if (i >= startIndex) {   // skip the synthetic arg if necessary
--					parameters[i - startIndex] = environment.getTypeFromSignature(methodDescriptor, index, end, false, this, missingTypeNames);
--					// 'paramAnnotations' line up with 'parameters'
--					// int parameter to method.getParameterAnnotations() include the synthetic arg
--					if (paramAnnotations != null)
--						paramAnnotations[i - startIndex] = createAnnotations(method.getParameterAnnotations(i), this.environment, missingTypeNames);
--				}
--				index = end + 1;
--			}
--		}
--
--		char[][] exceptionTypes = method.getExceptionTypeNames();
--		if (exceptionTypes != null) {
--			size = exceptionTypes.length;
--			if (size > 0) {
--				exceptions = new ReferenceBinding[size];
--				for (int i = 0; i < size; i++)
--					exceptions[i] = environment.getTypeFromConstantPoolName(exceptionTypes[i], 0, -1, false, missingTypeNames);
--			}
--		}
--
--		if (!method.isConstructor())
--			returnType = environment.getTypeFromSignature(methodDescriptor, index + 1, -1, false, this, missingTypeNames);   // index is currently pointing at the ')'
--	} else {
--		methodModifiers |= ExtraCompilerModifiers.AccGenericSignature;
--		// MethodTypeSignature = ParameterPart(optional) '(' TypeSignatures ')' return_typeSignature ['^' TypeSignature (optional)]
--		SignatureWrapper wrapper = new SignatureWrapper(methodSignature);
--		if (wrapper.signature[wrapper.start] == '<') {
--			// <A::Ljava/lang/annotation/Annotation;>(Ljava/lang/Class<TA;>;)TA;
--			// ParameterPart = '<' ParameterSignature(s) '>'
--			wrapper.start++; // skip '<'
--			typeVars = createTypeVariables(wrapper, false, missingTypeNames);
--			wrapper.start++; // skip '>'
--		}
--
--		if (wrapper.signature[wrapper.start] == '(') {
--			wrapper.start++; // skip '('
--			if (wrapper.signature[wrapper.start] == ')') {
--				wrapper.start++; // skip ')'
--			} else {
--				java.util.ArrayList types = new java.util.ArrayList(2);
--				while (wrapper.signature[wrapper.start] != ')')
--					types.add(environment.getTypeFromTypeSignature(wrapper, typeVars, this, missingTypeNames));
--				wrapper.start++; // skip ')'
--				int numParam = types.size();
--				parameters = new TypeBinding[numParam];
--				types.toArray(parameters);
--				if (this.environment.globalOptions.storeAnnotations) {
--					paramAnnotations = new AnnotationBinding[numParam][];
--					for (int i = 0; i < numParam; i++)
--						paramAnnotations[i] = createAnnotations(method.getParameterAnnotations(i), this.environment, missingTypeNames);
--				}
--			}
--		}
--
--		// always retrieve return type (for constructors, its V for void - will be ignored)
--		returnType = environment.getTypeFromTypeSignature(wrapper, typeVars, this, missingTypeNames);
--
--		if (!wrapper.atEnd() && wrapper.signature[wrapper.start] == '^') {
--			// attempt to find each exception if it exists in the cache (otherwise - resolve it when requested)
--			java.util.ArrayList types = new java.util.ArrayList(2);
--			do {
--				wrapper.start++; // skip '^'
--				types.add(environment.getTypeFromTypeSignature(wrapper, typeVars, this, missingTypeNames));
--			} while (!wrapper.atEnd() && wrapper.signature[wrapper.start] == '^');
--			exceptions = new ReferenceBinding[types.size()];
--			types.toArray(exceptions);
--		} else { // get the exceptions the old way
--			char[][] exceptionTypes = method.getExceptionTypeNames();
--			if (exceptionTypes != null) {
--				int size = exceptionTypes.length;
--				if (size > 0) {
--					exceptions = new ReferenceBinding[size];
--					for (int i = 0; i < size; i++)
--						exceptions[i] = environment.getTypeFromConstantPoolName(exceptionTypes[i], 0, -1, false, missingTypeNames);
--				}
--			}
--		}
--	}
--
--	MethodBinding result = method.isConstructor()
--		? new MethodBinding(methodModifiers, parameters, exceptions, this)
--		: new MethodBinding(methodModifiers, method.getSelector(), returnType, parameters, exceptions, this);
--	if (this.environment.globalOptions.storeAnnotations)
--		result.setAnnotations(
--			createAnnotations(method.getAnnotations(), this.environment, missingTypeNames),
--			paramAnnotations,
--			isAnnotationType() ? convertMemberValue(method.getDefaultValue(), this.environment, missingTypeNames) : null);
--
--	if (use15specifics)
--		result.tagBits |= method.getTagBits();
--	result.typeVariables = typeVars;
--	// fixup the declaring element of the type variable
--	for (int i = 0, length = typeVars.length; i < length; i++)
--		typeVars[i].declaringElement = result;
--	return result;
--}
--/**
-- * Create method bindings for binary type, filtering out <clinit> and synthetics
-- */
--private void createMethods(IBinaryMethod[] iMethods, long sourceLevel, char[][][] missingTypeNames) { 
--	if (iMethods == null) {
--		this.methods = this.bridgeMethods = Binding.NO_METHODS;
--		return;
--	}  
--	ArrayList<MethodBinding> methodBindings = new ArrayList<MethodBinding>(iMethods.length);
--	ArrayList<MethodBinding> bridgeBindings = new ArrayList<MethodBinding>(iMethods.length);
--	boolean isViewedAsDeprecated = isViewedAsDeprecated();
--	boolean hasRestrictedAccess = hasRestrictedAccess();  
--	boolean discardedClinit = false;
--  
--	for (int i = 0; i < iMethods.length; ++i) {
--		IBinaryMethod method = iMethods[i];
--		boolean isBridge = (method.getModifiers() & ClassFileConstants.AccBridge) != 0;
--		if (!isBridge && (method.getModifiers() & ClassFileConstants.AccSynthetic) != 0) {
--			continue;
--		}
--		if (!discardedClinit) {
--			char[] methodName = method.getSelector();
--			if (methodName.length == 8 && methodName[0] == '<') {
--				discardedClinit = true;
--				continue;
--			}
--		}
--		MethodBinding newMethod = createMethod(iMethods[i], sourceLevel, missingTypeNames);
--		if (isViewedAsDeprecated && !newMethod.isDeprecated())
--			newMethod.modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
--		if (hasRestrictedAccess)
--			newMethod.modifiers |= ExtraCompilerModifiers.AccRestrictedAccess;
--		if (isBridge)
--			bridgeBindings.add(newMethod);
--		else
--			methodBindings.add(newMethod);
--	}
--
--	if (sourceLevel < ClassFileConstants.JDK1_5 && this.environment.globalOptions.complianceLevel >= ClassFileConstants.JDK1_5)
--		methodBindings.addAll(bridgeBindings);
--
--	this.methods = methodBindings.size() == 0 ? Binding.NO_METHODS : methodBindings.toArray(new MethodBinding[methodBindings.size()]);
--	this.bridgeMethods = bridgeBindings.size() == 0 ? Binding.NO_METHODS : bridgeBindings.toArray(new MethodBinding[bridgeBindings.size()]);
--}
--private TypeVariableBinding[] createTypeVariables(SignatureWrapper wrapper, boolean assignVariables, char[][][] missingTypeNames) {
--	// detect all type variables first
--	char[] typeSignature = wrapper.signature;
--	int depth = 0, length = typeSignature.length;
--	int rank = 0;
--	ArrayList variables = new ArrayList(1);
--	depth = 0;
--	boolean pendingVariable = true;
--	createVariables: {
--		for (int i = 1; i < length; i++) {
--			switch(typeSignature[i]) {
--				case '<' : 
--					depth++;
--					break;
--				case '>' : 
--					if (--depth < 0)
--						break createVariables;
--					break;
--				case ';' :
--					if ((depth == 0) && (i +1 < length) && (typeSignature[i+1] != ':'))
--						pendingVariable = true;
--					break;
--				default:
--					if (pendingVariable) {
--						pendingVariable = false;
--						int colon = CharOperation.indexOf(':', typeSignature, i);
--						char[] variableName = CharOperation.subarray(typeSignature, i, colon);
--						variables.add(new TypeVariableBinding(variableName, this, rank++));
--					}
--			}
--		}
--	}
--	// initialize type variable bounds - may refer to forward variables
--	TypeVariableBinding[] result;
--	variables.toArray(result = new TypeVariableBinding[rank]);
--	// when creating the type variables for a type, the type must remember them before initializing each variable
--	// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=163680
--	if (assignVariables)
--		this.typeVariables = result;
--	for (int i = 0; i < rank; i++) {
--		initializeTypeVariable(result[i], result, wrapper, missingTypeNames);
--	}
--	return result;
--}
--/* Answer the receiver's enclosing type... null if the receiver is a top level type.
--*
--* NOTE: enclosingType of a binary type is resolved when needed
--*/
--public ReferenceBinding enclosingType() {
--	if ((this.tagBits & TagBits.HasUnresolvedEnclosingType) == 0)
--		return this.enclosingType;
--
--	// finish resolving the type
--	this.enclosingType = resolveType(this.enclosingType, this.environment, false);
--	this.tagBits &= ~TagBits.HasUnresolvedEnclosingType;
--	return this.enclosingType;
--}
--// NOTE: the type of each field of a binary type is resolved when needed
--public FieldBinding[] fields() {
--	if ((this.tagBits & TagBits.AreFieldsComplete) != 0)
--		return 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;
--	}
--	for (int i = fields.length; --i >= 0;)
--		resolveTypeFor(fields[i]);
--	this.tagBits |= TagBits.AreFieldsComplete;
--	return fields;
--}
--/**
-- * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#genericTypeSignature()
-- */
--public char[] genericTypeSignature() {
--	return computeGenericTypeSignature(this.typeVariables);
--}
--//NOTE: the return type, arg & exception types of each method of a binary type are resolved when needed
--public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) {
--
--	// 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 argCount = argumentTypes.length;
--	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 = methods[imethod];
--			if (method.parameters.length == argCount) {
--				resolveTypesFor(method);
--				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 binary 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)
--	
--	// 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 argCount = argumentTypes.length;
--	boolean foundNothing = true;
--
--	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 = methods[imethod];
--			foundNothing = false; // inner type lookups must know that a method with this name exists
--			if (method.parameters.length == argCount) {
--				resolveTypesFor(method);
--				TypeBinding[] toMatch = method.parameters;
--				for (int iarg = 0; iarg < argCount; iarg++)
--					if (toMatch[iarg] != argumentTypes[iarg])
--						continue nextMethod;
--				return method;
--			}
--		}
--	}
--	if (foundNothing) {
--		if (isInterface()) {
--			 if (superInterfaces().length == 1) { // ensure superinterfaces are resolved before checking
--				if (refScope != null)
--					refScope.recordTypeReference(superInterfaces[0]);
--				return superInterfaces[0].getExactMethod(selector, argumentTypes, refScope);
--			 }
--		} else if (superclass() != null) { // ensure superclass is resolved before checking
--			if (refScope != null)
--				refScope.recordTypeReference(superclass);
--			return superclass.getExactMethod(selector, argumentTypes, refScope);
--		}
--	}
--	return null;
--}
--//NOTE: the type of a field of a binary type is resolved when needed
--public FieldBinding getField(char[] fieldName, boolean needResolve) {
--	// 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;
--	}
--	FieldBinding field = ReferenceBinding.binarySearch(fieldName, this.fields);
--	return needResolve && field != null ? resolveTypeFor(field) : field;
--}
--/**
-- *  Rewrite of default getMemberType to avoid resolving eagerly all member types when one is requested
-- */
--public ReferenceBinding getMemberType(char[] typeName) {
--	for (int i = this.memberTypes.length; --i >= 0;) {
--	    ReferenceBinding memberType = this.memberTypes[i];
--	    if (memberType instanceof UnresolvedReferenceBinding) {
--			char[] name = memberType.sourceName; // source name is qualified with enclosing type name
--			int prefixLength = this.compoundName[this.compoundName.length - 1].length + 1; // enclosing$
--			if (name.length == (prefixLength + typeName.length)) // enclosing $ typeName
--				if (CharOperation.fragmentEquals(typeName, name, prefixLength, true)) // only check trailing portion
--					return this.memberTypes[i] = resolveType(memberType, this.environment, false); // no raw conversion for now
--	    } else if (CharOperation.equals(typeName, memberType.sourceName)) {
--	        return memberType;
--	    }
--	}
--	return null;
--}
--// NOTE: the return type, arg & exception types of each method of a binary 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;
--			if ((this.tagBits & TagBits.AreMethodsComplete) != 0) {
--				// simply clone method subset
--				MethodBinding[] result;				
--				System.arraycopy(this.methods, start, result = new MethodBinding[length], 0, length);
--				return result;
--			}
--		}
--		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;
--	}
--	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 = new MethodBinding[length];
--		// iterate methods to resolve them
--		for (int i = start, index = 0; i <= end; i++, index++)
--			result[index] = resolveTypesFor(methods[i]);
--		return result;
--	}
--	return Binding.NO_METHODS;
--}
--public boolean hasMemberTypes() {
--    return this.memberTypes.length > 0;
--}
--// NOTE: member types of binary types are resolved when needed
--public TypeVariableBinding getTypeVariable(char[] variableName) {
--	TypeVariableBinding variable = super.getTypeVariable(variableName);
--	variable.resolve(this.environment);
--	return variable;
--}
--private void initializeTypeVariable(TypeVariableBinding variable, TypeVariableBinding[] existingVariables, SignatureWrapper wrapper, char[][][] missingTypeNames) {
--	// ParameterSignature = Identifier ':' TypeSignature
--	//   or Identifier ':' TypeSignature(optional) InterfaceBound(s)
--	// InterfaceBound = ':' TypeSignature
--	int colon = CharOperation.indexOf(':', wrapper.signature, wrapper.start);
--	wrapper.start = colon + 1; // skip name + ':'
--	ReferenceBinding type, firstBound = null;
--	if (wrapper.signature[wrapper.start] == ':') {
--		type = environment.getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
--	} else {
--		type = (ReferenceBinding) environment.getTypeFromTypeSignature(wrapper, existingVariables, this, missingTypeNames);
--		firstBound = type;
--	}
--
--	// variable is visible to its bounds
--	variable.modifiers |= ExtraCompilerModifiers.AccUnresolved;
--	variable.superclass = type;
--
--	ReferenceBinding[] bounds = null;
--	if (wrapper.signature[wrapper.start] == ':') {
--		java.util.ArrayList types = new java.util.ArrayList(2);
--		do {
--			wrapper.start++; // skip ':'
--			types.add(environment.getTypeFromTypeSignature(wrapper, existingVariables, this, missingTypeNames));
--		} while (wrapper.signature[wrapper.start] == ':');
--		bounds = new ReferenceBinding[types.size()];
--		types.toArray(bounds);
--	}
--
--	variable.superInterfaces = bounds == null ? Binding.NO_SUPERINTERFACES : bounds;
--	if (firstBound == null) {
--		firstBound = variable.superInterfaces.length == 0 ? null : variable.superInterfaces[0];
--	}
--	variable.firstBound = firstBound;
--}
--/**
-- * 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.RAW_TYPE :
--			return otherType.erasure() == this;
--	}
--	return false;
--}
--public boolean isGenericType() {
--    return this.typeVariables != Binding.NO_TYPE_VARIABLES;
--}
--public int kind() {
--	if (this.typeVariables != Binding.NO_TYPE_VARIABLES)
--		return Binding.GENERIC_TYPE;
--	return Binding.TYPE;
--}
--// NOTE: member types of binary types are resolved when needed
--public ReferenceBinding[] memberTypes() {
-- 	if ((this.tagBits & TagBits.HasUnresolvedMemberTypes) == 0)
--		return this.memberTypes;
--
--	for (int i = this.memberTypes.length; --i >= 0;)
--		this.memberTypes[i] = resolveType(this.memberTypes[i], this.environment, false); // no raw conversion for now
--	this.tagBits &= ~TagBits.HasUnresolvedMemberTypes;
--	return this.memberTypes;
--}
--// NOTE: the return type, arg & exception types of each method of a binary type are resolved when needed
--private void lazyInitMethods() {
--	if ((this.tagBits & TagBits.AreMethodsComplete) != 0)
--		return;
--
--	// lazily sort methods
--	if ((this.tagBits & TagBits.AreMethodsSorted) == 0) {
--		int length = this.methods.length;
--		if (length > 1)
--			ReferenceBinding.sortMethods(this.methods, 0, length);
--		length = this.bridgeMethods.length;
--		if (length > 1)
--			ReferenceBinding.sortMethods(this.bridgeMethods, 0, length);
--		this.tagBits |= TagBits.AreMethodsSorted;
--	}
--	for (int i = methods.length; --i >= 0;)
--		resolveTypesFor(methods[i]);
--	for (int i = bridgeMethods.length; --i >= 0;)
--		resolveTypesFor(bridgeMethods[i]);  
--	this.tagBits |= TagBits.AreMethodsComplete;  
--}
--public MethodBinding[] methods() {
--	lazyInitMethods();
--	return methods;
--}
--public MethodBinding[] bridgeMethods() {
--	lazyInitMethods();
--	return bridgeMethods;
--}  
--private FieldBinding resolveTypeFor(FieldBinding field) {
--	if ((field.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
--		return field;
--
--	TypeBinding resolvedType = resolveType(field.type, this.environment, null, 0);
--	field.type = resolvedType;
--	if ((resolvedType.tagBits & TagBits.HasMissingType) != 0) {
--		field.tagBits |= TagBits.HasMissingType;
--	}		
--	field.modifiers &= ~ExtraCompilerModifiers.AccUnresolved;
--	return field;
--}
--MethodBinding resolveTypesFor(MethodBinding method) {
--	if ((method.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
--		return method;
--
--	if (!method.isConstructor()) {
--		TypeBinding resolvedType = resolveType(method.returnType, this.environment, null, 0);
--		method.returnType = resolvedType;
--		if ((resolvedType.tagBits & TagBits.HasMissingType) != 0) {
--			method.tagBits |= TagBits.HasMissingType;
--		}		
--	}
--	for (int i = method.parameters.length; --i >= 0;) {
--		TypeBinding resolvedType = resolveType(method.parameters[i], this.environment, null, 0);
--		method.parameters[i] = resolvedType;
--		if ((resolvedType.tagBits & TagBits.HasMissingType) != 0) {
--			method.tagBits |= TagBits.HasMissingType;
--		}		
--	}
--	for (int i = method.thrownExceptions.length; --i >= 0;) {
--		ReferenceBinding resolvedType = resolveType(method.thrownExceptions[i], this.environment, true);
--		method.thrownExceptions[i] = resolvedType;
--		if ((resolvedType.tagBits & TagBits.HasMissingType) != 0) {
--			method.tagBits |= TagBits.HasMissingType;
--		}
--	}
--	for (int i = method.typeVariables.length; --i >= 0;) {
--		method.typeVariables[i].resolve(this.environment);
--	}
--	method.modifiers &= ~ExtraCompilerModifiers.AccUnresolved;
--	return method;
--}
--AnnotationBinding[] retrieveAnnotations(Binding binding) {
--	return AnnotationBinding.addStandardAnnotations(super.retrieveAnnotations(binding), binding.getAnnotationTagBits(), this.environment);
--}
--SimpleLookupTable storedAnnotations(boolean forceInitialize) {
--	if (forceInitialize && this.storedAnnotations == null) {
--		if (!this.environment.globalOptions.storeAnnotations)
--			return null; // not supported during this compile
--		this.storedAnnotations = new SimpleLookupTable(3);
--	}
--	return this.storedAnnotations;
--}
--/* Answer the receiver's superclass... null if the receiver is Object or an interface.
--*
--* NOTE: superclass of a binary type is resolved when needed
--*/
--public ReferenceBinding superclass() {
--	if ((this.tagBits & TagBits.HasUnresolvedSuperclass) == 0)
--		return this.superclass;
--
--	// finish resolving the type
--	this.superclass = resolveType(this.superclass, this.environment, true);
--	this.tagBits &= ~TagBits.HasUnresolvedSuperclass;
--	if (this.superclass.problemId() == ProblemReasons.NotFound)
--		this.tagBits |= TagBits.HierarchyHasProblems; // propagate type inconsistency
--	return this.superclass;
--}
--// NOTE: superInterfaces of binary types are resolved when needed
--public ReferenceBinding[] superInterfaces() {
--	if ((this.tagBits & TagBits.HasUnresolvedSuperinterfaces) == 0)
--		return this.superInterfaces;
--
--	for (int i = this.superInterfaces.length; --i >= 0;) {
--		this.superInterfaces[i] = resolveType(this.superInterfaces[i], this.environment, true);
--		if (this.superInterfaces[i].problemId() == ProblemReasons.NotFound)
--			this.tagBits |= TagBits.HierarchyHasProblems; // propagate type inconsistency
--	}
--	this.tagBits &= ~TagBits.HasUnresolvedSuperinterfaces;
--	return this.superInterfaces;
--}
--public TypeVariableBinding[] typeVariables() {
-- 	if ((this.tagBits & TagBits.HasUnresolvedTypeVariables) == 0)
--		return this.typeVariables;
--
-- 	for (int i = this.typeVariables.length; --i >= 0;)
--		this.typeVariables[i].resolve(this.environment);
--	this.tagBits &= ~TagBits.HasUnresolvedTypeVariables;
--	return this.typeVariables;
--}
--public String toString() {
--	StringBuffer buffer = new StringBuffer();
--
--	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((compoundName != null) ? CharOperation.toString(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((superclass != null) ? superclass.debugName() : "NULL TYPE"); //$NON-NLS-1$
--
--	if (superInterfaces != null) {
--		if (superInterfaces != Binding.NO_SUPERINTERFACES) {
--			buffer.append("\n\timplements : "); //$NON-NLS-1$
--			for (int i = 0, length = superInterfaces.length; i < length; i++) {
--				if (i  > 0)
--					buffer.append(", "); //$NON-NLS-1$
--				buffer.append((superInterfaces[i] != null) ? 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 (fields != null) {
--		if (fields != Binding.NO_FIELDS) {
--			buffer.append("\n/*   fields   */"); //$NON-NLS-1$
--			for (int i = 0, length = fields.length; i < length; i++)
--				buffer.append((fields[i] != null) ? "\n" + fields[i].toString() : "\nNULL FIELD"); //$NON-NLS-1$ //$NON-NLS-2$
--		}
--	} else {
--		buffer.append("NULL FIELDS"); //$NON-NLS-1$
--	}
--
--	if (methods != null) {
--		if (methods != Binding.NO_METHODS) {
--			buffer.append("\n/*   methods   */"); //$NON-NLS-1$
--			for (int i = 0, length = methods.length; i < length; i++)
--				buffer.append((methods[i] != null) ? "\n" + methods[i].toString() : "\nNULL METHOD"); //$NON-NLS-1$ //$NON-NLS-2$
--		}
--	} else {
--		buffer.append("NULL METHODS"); //$NON-NLS-1$
--	}
--
--	if (memberTypes != null) {
--		if (memberTypes != Binding.NO_MEMBER_TYPES) {
--			buffer.append("\n/*   members   */"); //$NON-NLS-1$
--			for (int i = 0, length = memberTypes.length; i < length; i++)
--				buffer.append((memberTypes[i] != null) ? "\n" + memberTypes[i].toString() : "\nNULL TYPE"); //$NON-NLS-1$ //$NON-NLS-2$
--		}
--	} else {
--		buffer.append("NULL MEMBER TYPES"); //$NON-NLS-1$
--	}
--
--	buffer.append("\n\n\n"); //$NON-NLS-1$
--	return buffer.toString();
--}
--MethodBinding[] unResolvedMethods() { // for the MethodVerifier so it doesn't resolve types
--	return methods;
--}
--}
---- a/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
-+++ /dev/null
-@@ -1,1056 +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 java.util.List;
--
--import org.eclipse.jdt.core.compiler.CharOperation;
--import org.eclipse.jdt.internal.compiler.ClassFile;
--import org.eclipse.jdt.internal.compiler.ast.ASTNode;
--import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
--import org.eclipse.jdt.internal.compiler.ast.Argument;
--import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
--import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
--import org.eclipse.jdt.internal.compiler.codegen.ConstantPool;
--
--public class MethodBinding extends Binding {
--  
--  public int modifiers;
--  public char[] selector;
--  public TypeBinding returnType;
--  public TypeBinding[] parameters;
--  public ReferenceBinding[] thrownExceptions;
--  public ReferenceBinding declaringClass;
--  public TypeVariableBinding[] typeVariables = Binding.NO_TYPE_VARIABLES;
--  char[] signature;
--  public long tagBits;
--  
--protected MethodBinding() {
--  // for creating problem or synthetic method
--}
--public MethodBinding(int modifiers, char[] selector, TypeBinding returnType, TypeBinding[] parameters, ReferenceBinding[] thrownExceptions, ReferenceBinding declaringClass) {
--  this.modifiers = modifiers;
--  this.selector = selector;
--  this.returnType = returnType;
--  this.parameters = (parameters == null || parameters.length == 0) ? Binding.NO_PARAMETERS : parameters;
--  this.thrownExceptions = (thrownExceptions == null || thrownExceptions.length == 0) ? Binding.NO_EXCEPTIONS : thrownExceptions;
--  this.declaringClass = declaringClass;
--  
--  // propagate the strictfp & deprecated modifiers
--  if (this.declaringClass != null) {
--    if (this.declaringClass.isStrictfp())
--      if (!(isNative() || isAbstract()))
--        this.modifiers |= ClassFileConstants.AccStrictfp;
--  }
--}
--public MethodBinding(int modifiers, TypeBinding[] parameters, ReferenceBinding[] thrownExceptions, ReferenceBinding declaringClass) {
--  this(modifiers, TypeConstants.INIT, TypeBinding.VOID, parameters, thrownExceptions, declaringClass);
--}
--// special API used to change method declaring class for runtime visibility check
--public MethodBinding(MethodBinding initialMethodBinding, ReferenceBinding declaringClass) {
--  this.modifiers = initialMethodBinding.modifiers;
--  this.selector = initialMethodBinding.selector;
--  this.returnType = initialMethodBinding.returnType;
--  this.parameters = initialMethodBinding.parameters;
--  this.thrownExceptions = initialMethodBinding.thrownExceptions;
--  this.declaringClass = declaringClass;
--  declaringClass.storeAnnotationHolder(this, initialMethodBinding.declaringClass.retrieveAnnotationHolder(initialMethodBinding, true));
--}
--/* Answer true if the argument types & the receiver's parameters have the same erasure
--*/
--public final boolean areParameterErasuresEqual(MethodBinding method) {
--  TypeBinding[] args = method.parameters;
--  if (parameters == args)
--    return true;
--
--  int length = parameters.length;
--  if (length != args.length)
--    return false;
--
--  for (int i = 0; i < length; i++)
--    if (parameters[i] != args[i] && parameters[i].erasure() != args[i].erasure())
--      return false;
--  return true;
--}
--/*
-- * Returns true if given parameters are compatible with this method parameters.
-- * Callers to this method should first check that the number of TypeBindings
-- * passed as argument matches this MethodBinding number of parameters
-- */
--public final boolean areParametersCompatibleWith(TypeBinding[] arguments) {
--  int paramLength = this.parameters.length;
--  int argLength = arguments.length;
--  int lastIndex = argLength;
--  if (isVarargs()) {
--    lastIndex = paramLength - 1;
--    if (paramLength == argLength) { // accept X[] but not X or X[][]
--      TypeBinding varArgType = parameters[lastIndex]; // is an ArrayBinding by definition
--      TypeBinding lastArgument = arguments[lastIndex];
--      if (varArgType != lastArgument && !lastArgument.isCompatibleWith(varArgType))
--        return false;
--    } else if (paramLength < argLength) { // all remainig argument types must be compatible with the elementsType of varArgType
--      TypeBinding varArgType = ((ArrayBinding) parameters[lastIndex]).elementsType();
--      for (int i = lastIndex; i < argLength; i++)
--        if (varArgType != arguments[i] && !arguments[i].isCompatibleWith(varArgType))
--          return false;
--    } else if (lastIndex != argLength) { // can call foo(int i, X ... x) with foo(1) but NOT foo();
--      return false;
--    }
--    // now compare standard arguments from 0 to lastIndex
--  }
--  for (int i = 0; i < lastIndex; i++)
--    if (parameters[i] != arguments[i] && !arguments[i].isCompatibleWith(parameters[i]))
--      return false;
--  return true;
--}
--/* Answer true if the argument types & the receiver's parameters are equal
--*/
--public final boolean areParametersEqual(MethodBinding method) {
--  TypeBinding[] args = method.parameters;
--  if (parameters == args)
--    return true;
--
--  int length = parameters.length;
--  if (length != args.length)
--    return false;
--  
--  for (int i = 0; i < length; i++)
--    if (parameters[i] != args[i])
--      return false;
--  return true;
--}
--
--/* API
--* Answer the receiver's binding type from Binding.BindingID.
--*/
--
--/* Answer true if the type variables have the same erasure
--*/
--public final boolean areTypeVariableErasuresEqual(MethodBinding method) {
--  TypeVariableBinding[] vars = method.typeVariables;
--  if (this.typeVariables == vars)
--    return true;
--
--  int length = this.typeVariables.length;
--  if (length != vars.length)
--    return false;
--
--  for (int i = 0; i < length; i++)
--    if (this.typeVariables[i] != vars[i] && this.typeVariables[i].erasure() != vars[i].erasure())
--      return false;
--  return true;
--}
--/* Answer true if the receiver is visible to the type provided by the scope.
--* InvocationSite implements isSuperAccess() to provide additional information
--* if the receiver is protected.
--*
--* NOTE: This method should ONLY be sent if the receiver is a constructor.
--*
--* NOTE: Cannot invoke this method with a compilation unit scope.
--*/
--
--public final boolean canBeSeenBy(InvocationSite invocationSite, Scope scope) {
--  if (isPublic()) return true;
--
--  SourceTypeBinding invocationType = scope.enclosingSourceType();
--  if (invocationType == declaringClass) return true;
--
--  if (isProtected()) {
--    // answer true if the receiver is in the same package as the invocationType
--    if (invocationType.fPackage == declaringClass.fPackage) return true;
--    return invocationSite.isSuperAccess();
--  }
--
--  if (isPrivate()) {
--    // answer true if the invocationType and the declaringClass have a common enclosingType
--    // already know they are not the identical type
--    ReferenceBinding outerInvocationType = invocationType;
--    ReferenceBinding temp = outerInvocationType.enclosingType();
--    while (temp != null) {
--      outerInvocationType = temp;
--      temp = temp.enclosingType();
--    }
--
--    ReferenceBinding outerDeclaringClass = (ReferenceBinding)declaringClass.erasure();
--    temp = outerDeclaringClass.enclosingType();
--    while (temp != null) {
--      outerDeclaringClass = temp;
--      temp = temp.enclosingType();
--    }
--    return outerInvocationType == outerDeclaringClass;
--  }
--
--  // isDefault()
--  return invocationType.fPackage == declaringClass.fPackage;
--}
--public final boolean canBeSeenBy(PackageBinding invocationPackage) {
--  if (isPublic()) return true;
--  if (isPrivate()) return false;
--
--  // isProtected() or isDefault()
--  return invocationPackage == declaringClass.getPackage();
--}
--
--/* Answer true if the receiver is visible to the type provided by the scope.
--* InvocationSite implements isSuperAccess() to provide additional information
--* if the receiver is protected.
--*
--* NOTE: Cannot invoke this method with a compilation unit scope.
--*/
--public final boolean canBeSeenBy(TypeBinding receiverType, InvocationSite invocationSite, Scope scope) {
--  if (isPublic()) return true;
--
--  SourceTypeBinding invocationType = scope.enclosingSourceType();
--  if (invocationType == declaringClass && invocationType == receiverType) return true;
--
--  if (invocationType == null) // static import call
--    return !isPrivate() && scope.getCurrentPackage() == declaringClass.fPackage;
--
--  if (isProtected()) {
--    // answer true if the invocationType is the declaringClass or they are in the same package
--    // OR the invocationType is a subclass of the declaringClass
--    //    AND the receiverType is the invocationType or its subclass
--    //    OR the method is a static method accessed directly through a type
--    //    OR previous assertions are true for one of the enclosing type
--    if (invocationType == declaringClass) return true;
--    if (invocationType.fPackage == declaringClass.fPackage) return true;
--    
--    ReferenceBinding currentType = invocationType;
--    TypeBinding receiverErasure = receiverType.erasure();   
--    ReferenceBinding declaringErasure = (ReferenceBinding) declaringClass.erasure();
--    int depth = 0;
--    do {
--      if (currentType.findSuperTypeOriginatingFrom(declaringErasure) != null) {
--        if (invocationSite.isSuperAccess())
--          return true;
--        // receiverType can be an array binding in one case... see if you can change it
--        if (receiverType instanceof ArrayBinding)
--          return false;
--        if (isStatic()) {
--          if (depth > 0) invocationSite.setDepth(depth);
--          return true; // see 1FMEPDL - return invocationSite.isTypeAccess();
--        }
--        if (currentType == receiverErasure || receiverErasure.findSuperTypeOriginatingFrom(currentType) != null) {
--          if (depth > 0) invocationSite.setDepth(depth);
--          return true;
--        }
--      }
--      depth++;
--      currentType = currentType.enclosingType();
--    } while (currentType != null);
--    return false;
--  }
--
--  if (isPrivate()) {
--    // answer true if the receiverType is the declaringClass
--    // AND the invocationType and the declaringClass have a common enclosingType
--    receiverCheck: {
--      if (receiverType != declaringClass) {
--        // special tolerance for type variable direct bounds
--        if (receiverType.isTypeVariable() && ((TypeVariableBinding) receiverType).isErasureBoundTo(declaringClass.erasure()))
--          break receiverCheck;
--        return false;
--      }
--    }
--
--    if (invocationType != declaringClass) {
--      ReferenceBinding outerInvocationType = invocationType;
--      ReferenceBinding temp = outerInvocationType.enclosingType();
--      while (temp != null) {
--        outerInvocationType = temp;
--        temp = temp.enclosingType();
--      }
--
--      ReferenceBinding outerDeclaringClass = (ReferenceBinding)declaringClass.erasure();
--      temp = outerDeclaringClass.enclosingType();
--      while (temp != null) {
--        outerDeclaringClass = temp;
--        temp = temp.enclosingType();
--      }
--      if (outerInvocationType != outerDeclaringClass) return false;
--    }
--    return true;
--  }
--
--  // isDefault()
--  PackageBinding declaringPackage = declaringClass.fPackage;
--  if (invocationType.fPackage != declaringPackage) return false;
--
--  // receiverType can be an array binding in one case... see if you can change it
--  if (receiverType instanceof ArrayBinding)
--    return false;
--  ReferenceBinding currentType = (ReferenceBinding) receiverType;
--  do {
--    if (declaringClass == currentType) return true;
--    PackageBinding currentPackage = currentType.fPackage;
--    // package could be null for wildcards/intersection types, ignore and recurse in superclass
--    if (currentPackage != null && currentPackage != declaringPackage) return false;
--  } while ((currentType = currentType.superclass()) != null);
--  return false;
--}
--
--public List collectMissingTypes(List missingTypes) {
--  if ((this.tagBits & TagBits.HasMissingType) != 0) {
--    missingTypes = this.returnType.collectMissingTypes(missingTypes);
--    for (int i = 0, max = this.parameters.length; i < max; i++) {
--      missingTypes = this.parameters[i].collectMissingTypes(missingTypes);
--    }
--    for (int i = 0, max = this.thrownExceptions.length; i < max; i++) {
--      missingTypes = this.thrownExceptions[i].collectMissingTypes(missingTypes);
--    }
--    for (int i = 0, max = this.typeVariables.length; i < max; i++) {
--      TypeVariableBinding variable = this.typeVariables[i];
--      missingTypes = variable.superclass().collectMissingTypes(missingTypes);
--      ReferenceBinding[] interfaces = variable.superInterfaces();
--      for (int j = 0, length = interfaces.length; j < length; j++) {
--        missingTypes = interfaces[j].collectMissingTypes(missingTypes);
--      }
--    }
--  }
--  return missingTypes;
--}
--
--MethodBinding computeSubstitutedMethod(MethodBinding method, LookupEnvironment env) {
--  int length = this.typeVariables.length;
--  TypeVariableBinding[] vars = method.typeVariables;
--  if (length != vars.length)
--    return null;
--
--  // must substitute to detect cases like:
--  //   <T1 extends X<T1>> void dup() {}
--  //   <T2 extends X<T2>> Object dup() {return null;}
--  ParameterizedGenericMethodBinding substitute =
--    env.createParameterizedGenericMethod(method, this.typeVariables);
--  for (int i = 0; i < length; i++)
--    if (!this.typeVariables[i].isInterchangeableWith(vars[i], substitute))
--      return null;
--  return substitute;
--}
--
--/*
-- * declaringUniqueKey dot selector genericSignature
-- * p.X { <T> void bar(X<T> t) } --> Lp/X;.bar<T:Ljava/lang/Object;>(LX<TT;>;)V
-- */
--public char[] computeUniqueKey(boolean isLeaf) {
--  // declaring class 
--  char[] declaringKey = this.declaringClass.computeUniqueKey(false/*not a leaf*/);
--  int declaringLength = declaringKey.length;
--  
--  // selector
--  int selectorLength = this.selector == TypeConstants.INIT ? 0 : this.selector.length;
--  
--  // generic signature
--  char[] sig = genericSignature();
--  boolean isGeneric = sig != null;
--  if (!isGeneric) sig = signature();
--  int signatureLength = sig.length;
--  
--  // thrown exceptions
--  int thrownExceptionsLength = this.thrownExceptions.length;
--  int thrownExceptionsSignatureLength = 0;
--  char[][] thrownExceptionsSignatures = null;
--  boolean addThrownExceptions = thrownExceptionsLength > 0 && (!isGeneric || CharOperation.lastIndexOf('^', sig) < 0);
--  if (addThrownExceptions) {
--    thrownExceptionsSignatures = new char[thrownExceptionsLength][];
--    for (int i = 0; i < thrownExceptionsLength; i++) {
--      if (this.thrownExceptions[i] != null) {
--        thrownExceptionsSignatures[i] = this.thrownExceptions[i].signature();
--        thrownExceptionsSignatureLength += thrownExceptionsSignatures[i].length + 1;  // add one char for separator
--      }
--    }
--  }
--  
--  char[] uniqueKey = new char[declaringLength + 1 + selectorLength + signatureLength + thrownExceptionsSignatureLength];
--  int index = 0;
--  System.arraycopy(declaringKey, 0, uniqueKey, index, declaringLength);
--  index = declaringLength;
--  uniqueKey[index++] = '.';
--  System.arraycopy(this.selector, 0, uniqueKey, index, selectorLength);
--  index += selectorLength;
--  System.arraycopy(sig, 0, uniqueKey, index, signatureLength);
--  if (thrownExceptionsSignatureLength > 0) {
--    index += signatureLength;
--    for (int i = 0; i < thrownExceptionsLength; i++) {
--      char[] thrownExceptionSignature = thrownExceptionsSignatures[i];
--      if (thrownExceptionSignature != null) {
--        uniqueKey[index++] = '|';
--        int length = thrownExceptionSignature.length;
--        System.arraycopy(thrownExceptionSignature, 0, uniqueKey, index, length);
--        index += length;
--      }
--    }
--  }
--  return uniqueKey;
--}
--
--/* 
-- * Answer the declaring class to use in the constant pool
-- * may not be a reference binding (see subtypes)
-- */
--public TypeBinding constantPoolDeclaringClass() {
--  return this.declaringClass;
--}
--
--/* Answer the receiver's constant pool name.
--*
--* <init> for constructors
--* <clinit> for clinit methods
--* or the source name of the method
--*/
--public final char[] constantPoolName() {
--  return selector;
--}
--
--/**
-- *<typeParam1 ... typeParamM>(param1 ... paramN)returnType thrownException1 ... thrownExceptionP
-- * T foo(T t) throws X<T>   --->   (TT;)TT;LX<TT;>;
-- * void bar(X<T> t)   -->   (LX<TT;>;)V
-- * <T> void bar(X<T> t)   -->  <T:Ljava.lang.Object;>(LX<TT;>;)V
-- */
--public char[] genericSignature() {
--  if ((this.modifiers & ExtraCompilerModifiers.AccGenericSignature) == 0) return null;
--  StringBuffer sig = new StringBuffer(10);
--  if (this.typeVariables != Binding.NO_TYPE_VARIABLES) {
--    sig.append('<');
--    for (int i = 0, length = this.typeVariables.length; i < length; i++) {
--      sig.append(this.typeVariables[i].genericSignature());
--    }
--    sig.append('>');
--  }
--  sig.append('(');
--  for (int i = 0, length = this.parameters.length; i < length; i++) {
--    sig.append(this.parameters[i].genericTypeSignature());
--  }
--  sig.append(')');
--  if (this.returnType != null)
--    sig.append(this.returnType.genericTypeSignature());
--  
--  // only append thrown exceptions if any is generic/parameterized
--  boolean needExceptionSignatures = false;
--  int length = this.thrownExceptions.length;
--  for (int i = 0; i < length; i++) {
--    if((this.thrownExceptions[i].modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0) {
--      needExceptionSignatures = true;
--      break;
--    }
--  }
--  if (needExceptionSignatures) {
--    for (int i = 0; i < length; i++) {
--      sig.append('^');
--      sig.append(this.thrownExceptions[i].genericTypeSignature());
--    }
--  }
--  int sigLength = sig.length();
--  char[] genericSignature = new char[sigLength];
--  sig.getChars(0, sigLength, genericSignature, 0);  
--  return genericSignature;
--}
--
--public final int getAccessFlags() {
--  return modifiers & ExtraCompilerModifiers.AccJustFlag;
--}
--
--public AnnotationBinding[] getAnnotations() {
--  MethodBinding originalMethod = this.original();
--  return originalMethod.declaringClass.retrieveAnnotations(originalMethod);
--}
--
--/**
-- * 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() {
--  MethodBinding originalMethod = this.original();
--  if ((originalMethod.tagBits & TagBits.AnnotationResolved) == 0 && originalMethod.declaringClass instanceof SourceTypeBinding) {
--    ClassScope scope = ((SourceTypeBinding) originalMethod.declaringClass).scope;
--    if (scope != null) {
--      TypeDeclaration typeDecl = scope.referenceContext;
--      AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(originalMethod);
--      if (methodDecl != null)
--        ASTNode.resolveAnnotations(methodDecl.scope, methodDecl.annotations, originalMethod);
--    }
--  }
--  return originalMethod.tagBits;
--}
--/**
-- * @return the default value for this annotation method or <code>null</code> if there is no default value
-- */
--public Object getDefaultValue() {
--  MethodBinding originalMethod = this.original();
--  if ((originalMethod.tagBits & TagBits.DefaultValueResolved) == 0) {
--    //The method has not been resolved nor has its class been resolved.
--    //It can only be from a source type within compilation units to process.
--    if (originalMethod.declaringClass instanceof SourceTypeBinding) {
--      SourceTypeBinding sourceType = (SourceTypeBinding) originalMethod.declaringClass;
--      if (sourceType.scope != null) {
--        AbstractMethodDeclaration methodDeclaration = originalMethod.sourceMethod();
--        if (methodDeclaration != null && methodDeclaration.isAnnotationMethod()) {
--          methodDeclaration.resolve(sourceType.scope);
--        }
--      }
--    }
--    originalMethod.tagBits |= TagBits.DefaultValueResolved;
--  }
--  AnnotationHolder holder = originalMethod.declaringClass.retrieveAnnotationHolder(originalMethod, true);
--  return holder == null ? null : holder.getDefaultValue();
--}
--
--/**
-- * @return the annotations for each of the method parameters or <code>null></code>
-- *  if there's no parameter or no annotation at all.
-- */
--public AnnotationBinding[][] getParameterAnnotations() {
--  int length = this.parameters.length;
--  if (this.parameters == null || length == 0) {
--    return null;
--  }
--  MethodBinding originalMethod = this.original();
--  AnnotationHolder holder = originalMethod.declaringClass.retrieveAnnotationHolder(originalMethod, true);
--  AnnotationBinding[][] allParameterAnnotations = holder == null ? null : holder.getParameterAnnotations();
--  if (allParameterAnnotations == null && (this.tagBits & TagBits.HasParameterAnnotations) != 0) {
--    allParameterAnnotations = new AnnotationBinding[length][];
--    // forward reference to method, where param annotations have not yet been associated to method
--    if (this.declaringClass instanceof SourceTypeBinding) {
--      SourceTypeBinding sourceType = (SourceTypeBinding) this.declaringClass;
--      if (sourceType.scope != null) {
--        AbstractMethodDeclaration methodDecl = sourceType.scope.referenceType().declarationOf(this);
--        for (int i = 0; i < length; i++) {
--          Argument argument = methodDecl.arguments[i];
--          if (argument.annotations != null) {
--            ASTNode.resolveAnnotations(methodDecl.scope, argument.annotations, argument.binding);
--            allParameterAnnotations[i] = argument.binding.getAnnotations();
--          } else {
--            allParameterAnnotations[i] = Binding.NO_ANNOTATIONS;
--          }
--        }
--      } else {
--        for (int i = 0; i < length; i++) {
--          allParameterAnnotations[i] = Binding.NO_ANNOTATIONS;
--        }
--      }
--    } else {
--      for (int i = 0; i < length; i++) {
--        allParameterAnnotations[i] = Binding.NO_ANNOTATIONS;
--      }
--    }
--    this.setParameterAnnotations(allParameterAnnotations);
--  }
--  return allParameterAnnotations;
--}
--public TypeVariableBinding getTypeVariable(char[] variableName) {
--  for (int i = this.typeVariables.length; --i >= 0;)
--    if (CharOperation.equals(this.typeVariables[i].sourceName, variableName))
--      return this.typeVariables[i];
--  return null;
--}
--/**
-- * Returns true if method got substituted parameter types
-- * (see ParameterizedMethodBinding)
-- */
--public boolean hasSubstitutedParameters() {
--  return false;
--}
--/* Answer true if the return type got substituted.
-- */
--public boolean hasSubstitutedReturnType() {
--  return false;
--}
--
--/* Answer true if the receiver is an abstract method
--*/
--public final boolean isAbstract() {
--  return (modifiers & ClassFileConstants.AccAbstract) != 0;
--}
--
--/* Answer true if the receiver is a bridge method
--*/
--public final boolean isBridge() {
--  return (modifiers & ClassFileConstants.AccBridge) != 0;
--}
--
--/* Answer true if the receiver is a constructor
--*/
--public final boolean isConstructor() {
--  return selector == TypeConstants.INIT;
--}
--
--/* Answer true if the receiver has default visibility
--*/
--public final boolean isDefault() {
--  return !isPublic() && !isProtected() && !isPrivate();
--}
--
--/* Answer true if the receiver is a system generated default abstract method
--*/
--public final boolean isDefaultAbstract() {
--  return (modifiers & ExtraCompilerModifiers.AccDefaultAbstract) != 0;
--}
--
--/* Answer true if the receiver is a deprecated method
--*/
--public final boolean isDeprecated() {
--  return (modifiers & ClassFileConstants.AccDeprecated) != 0;
--}
--
--/* Answer true if the receiver is final and cannot be overridden
--*/
--public final boolean isFinal() {
--  return (modifiers & ClassFileConstants.AccFinal) != 0;
--}
--
--/* Answer true if the receiver is implementing another method
-- * in other words, it is overriding and concrete, and overriden method is abstract
-- * Only set for source methods
--*/
--public final boolean isImplementing() {
--  return (modifiers & ExtraCompilerModifiers.AccImplementing) != 0;
--}
--
--/*
-- * Answer true if the receiver is a "public static void main(String[])" method
-- */
--public final boolean isMain() {
--  if (this.selector.length == 4 && CharOperation.equals(this.selector, TypeConstants.MAIN)
--      && ((this.modifiers & (ClassFileConstants.AccPublic | ClassFileConstants.AccStatic)) != 0)
--      && TypeBinding.VOID == this.returnType  
--      && this.parameters.length == 1) {
--    TypeBinding paramType = this.parameters[0];
--    if (paramType.dimensions() == 1 && paramType.leafComponentType().id == TypeIds.T_JavaLangString) {
--      return true;
--    }
--  }
--  return false;
--}
--
--/* Answer true if the receiver is a native method
--*/
--public final boolean isNative() {
--  return (modifiers & ClassFileConstants.AccNative) != 0;
--}
--
--/* Answer true if the receiver is overriding another method
-- * Only set for source methods
--*/
--public final boolean isOverriding() {
--  return (modifiers & ExtraCompilerModifiers.AccOverriding) != 0;
--}
--/* Answer true if the receiver has private visibility
--*/
--public final boolean isPrivate() {
--  return (modifiers & ClassFileConstants.AccPrivate) != 0;
--}
--/* Answer true if the receiver has protected visibility
--*/
--public final boolean isProtected() {
--  return (modifiers & ClassFileConstants.AccProtected) != 0;
--}
--
--/* Answer true if the receiver has public visibility
--*/
--public final boolean isPublic() {
--  return (modifiers & ClassFileConstants.AccPublic) != 0;
--}
--
--/* Answer true if the receiver is a static method
--*/
--public final boolean isStatic() {
--  return (modifiers & ClassFileConstants.AccStatic) != 0;
--}
--
--/* Answer true if all float operations must adher to IEEE 754 float/double rules
--*/
--public final boolean isStrictfp() {
--  return (modifiers & ClassFileConstants.AccStrictfp) != 0;
--}
--
--/* Answer true if the receiver is a synchronized method
--*/
--public final boolean isSynchronized() {
--  return (modifiers & ClassFileConstants.AccSynchronized) != 0;
--}
--
--/* Answer true if the receiver has public visibility
--*/
--public final boolean isSynthetic() {
--  return (modifiers & ClassFileConstants.AccSynthetic) != 0;
--}
--
--/* Answer true if the receiver has private visibility and is used locally
--*/
--public final boolean isUsed() {
--  return (modifiers & ExtraCompilerModifiers.AccLocallyUsed) != 0;
--}
--
--/* Answer true if the receiver method has varargs
--*/
--public final boolean isVarargs() {
--  return (modifiers & ClassFileConstants.AccVarargs) != 0;
--}
--
--/* Answer true if the receiver's declaring type is deprecated (or any of its enclosing types)
--*/
--public final boolean isViewedAsDeprecated() {
--  return (modifiers & (ClassFileConstants.AccDeprecated | ExtraCompilerModifiers.AccDeprecatedImplicitly)) != 0;
--}
--
--public final int kind() {
--  return Binding.METHOD;
--}
--/* Answer true if the receiver is visible to the invocationPackage.
--*/
--
--/**
-- * Returns the original method (as opposed to parameterized instances)
-- */
--public MethodBinding original() {
--  return this;
--}
--
--public char[] readableName() /* foo(int, Thread) */ {
--  StringBuffer buffer = new StringBuffer(parameters.length + 1 * 20);
--  if (isConstructor())
--    buffer.append(declaringClass.sourceName());
--  else
--    buffer.append(selector);
--  buffer.append('(');
--  if (parameters != Binding.NO_PARAMETERS) {
--    for (int i = 0, length = parameters.length; i < length; i++) {
--      if (i > 0)
--        buffer.append(", "); //$NON-NLS-1$
--      buffer.append(parameters[i].sourceName());
--    }
--  }
--  buffer.append(')');
--  return buffer.toString().toCharArray();
--}
--public void setAnnotations(AnnotationBinding[] annotations) {
--  this.declaringClass.storeAnnotations(this, annotations);
--}
--public void setAnnotations(AnnotationBinding[] annotations, AnnotationBinding[][] parameterAnnotations, Object defaultValue) {
--  this.declaringClass.storeAnnotationHolder(this,  AnnotationHolder.storeAnnotations(annotations, parameterAnnotations, defaultValue));
--}
--public void setDefaultValue(Object defaultValue) {
--  MethodBinding originalMethod = this.original();
--  originalMethod.tagBits |= TagBits.DefaultValueResolved;
--
--  AnnotationHolder holder = this.declaringClass.retrieveAnnotationHolder(this, false);
--  if (holder == null)
--    setAnnotations(null, null, defaultValue);
--  else
--    setAnnotations(holder.getAnnotations(), holder.getParameterAnnotations(), defaultValue);
--}
--public void setParameterAnnotations(AnnotationBinding[][] parameterAnnotations) {
--  AnnotationHolder holder = this.declaringClass.retrieveAnnotationHolder(this, false);
--  if (holder == null)
--    setAnnotations(null, parameterAnnotations, null);
--  else
--    setAnnotations(holder.getAnnotations(), parameterAnnotations, holder.getDefaultValue());
--}
--protected final void setSelector(char[] selector) {
--  this.selector = selector;
--  this.signature = null;
--}
--
--/**
-- * @see org.eclipse.jdt.internal.compiler.lookup.Binding#shortReadableName()
-- */
--public char[] shortReadableName() {
--  StringBuffer buffer = new StringBuffer(parameters.length + 1 * 20);
--  if (isConstructor())
--    buffer.append(declaringClass.shortReadableName());
--  else
--    buffer.append(selector);
--  buffer.append('(');
--  if (parameters != Binding.NO_PARAMETERS) {
--    for (int i = 0, length = parameters.length; i < length; i++) {
--      if (i > 0)
--        buffer.append(", "); //$NON-NLS-1$
--      buffer.append(parameters[i].shortReadableName());
--    }
--  }
--  buffer.append(')');
--  int nameLength = buffer.length();
--  char[] shortReadableName = new char[nameLength];
--  buffer.getChars(0, nameLength, shortReadableName, 0);     
--  return shortReadableName;
--}
--
--/* Answer the receiver's signature.
--*
--* NOTE: This method should only be used during/after code gen.
--* The signature is cached so if the signature of the return type or any parameter
--* type changes, the cached state is invalid.
--*/
--public final char[] signature() /* (ILjava/lang/Thread;)Ljava/lang/Object; */ {
--  if (signature != null)
--    return signature;
--
--  StringBuffer buffer = new StringBuffer(parameters.length + 1 * 20);
--  buffer.append('(');
--  
--  TypeBinding[] targetParameters = this.parameters;
--  boolean isConstructor = isConstructor();
--  if (isConstructor && declaringClass.isEnum()) { // insert String name,int ordinal 
--    buffer.append(ConstantPool.JavaLangStringSignature);
--    buffer.append(TypeBinding.INT.signature());
--  }
--  boolean needSynthetics = isConstructor && declaringClass.isNestedType();
--  if (needSynthetics) {
--    // take into account the synthetic argument type signatures as well
--    ReferenceBinding[] syntheticArgumentTypes = declaringClass.syntheticEnclosingInstanceTypes();
--    if (syntheticArgumentTypes != null) {
--      for (int i = 0, count = syntheticArgumentTypes.length; i < count; i++) {
--        buffer.append(syntheticArgumentTypes[i].signature());
--      }
--    }
--    
--    if (this instanceof SyntheticMethodBinding) {
--      targetParameters = ((SyntheticMethodBinding)this).targetMethod.parameters;
--    }
--  }
--
--  if (targetParameters != Binding.NO_PARAMETERS) {
--    for (int i = 0; i < targetParameters.length; i++) {
--      buffer.append(targetParameters[i].signature());
--    }
--  }
--  if (needSynthetics) {
--    SyntheticArgumentBinding[] syntheticOuterArguments = declaringClass.syntheticOuterLocalVariables();
--    int count = syntheticOuterArguments == null ? 0 : syntheticOuterArguments.length;
--    for (int i = 0; i < count; i++) {
--      buffer.append(syntheticOuterArguments[i].type.signature());
--    }
--    // move the extra padding arguments of the synthetic constructor invocation to the end    
--    for (int i = targetParameters.length, extraLength = parameters.length; i < extraLength; i++) {
--      buffer.append(parameters[i].signature());
--    }
--  }
--  buffer.append(')');
--  if (this.returnType != null)
--    buffer.append(this.returnType.signature());
--  int nameLength = buffer.length();
--  signature = new char[nameLength];
--  buffer.getChars(0, nameLength, signature, 0);     
--  
--  return signature;
--}
--/*
-- * This method is used to record references to nested types inside the method signature.
-- * This is the one that must be used during code generation.
-- * 
-- * See https://bugs.eclipse.org/bugs/show_bug.cgi?id=171184
-- */
--public final char[] signature(ClassFile classFile) {
--  if (signature != null) {
--    if ((this.tagBits & TagBits.ContainsNestedTypesInSignature) != 0) {
--      // we need to record inner classes references
--      boolean isConstructor = isConstructor();
--      TypeBinding[] targetParameters = this.parameters;
--      boolean needSynthetics = isConstructor && declaringClass.isNestedType();
--      if (needSynthetics) {
--        // take into account the synthetic argument type signatures as well
--        ReferenceBinding[] syntheticArgumentTypes = declaringClass.syntheticEnclosingInstanceTypes();
--        if (syntheticArgumentTypes != null) {
--          for (int i = 0, count = syntheticArgumentTypes.length; i < count; i++) {
--            ReferenceBinding syntheticArgumentType = syntheticArgumentTypes[i];
--            if (syntheticArgumentType.isNestedType()) {
--              classFile.recordInnerClasses(syntheticArgumentType);
--            }
--          }
--        }
--        if (this instanceof SyntheticMethodBinding) {
--          targetParameters = ((SyntheticMethodBinding)this).targetMethod.parameters;
--        }
--      }
--
--      if (targetParameters != Binding.NO_PARAMETERS) {
--        for (int i = 0; i < targetParameters.length; i++) {
--          TypeBinding targetParameter = targetParameters[i];
--          TypeBinding leafTargetParameterType = targetParameter.leafComponentType();
--          if (leafTargetParameterType.isNestedType()) {
--            classFile.recordInnerClasses(leafTargetParameterType);
--          }
--        }
--      }
--      if (needSynthetics) {
--        // move the extra padding arguments of the synthetic constructor invocation to the end    
--        for (int i = targetParameters.length, extraLength = parameters.length; i < extraLength; i++) {
--          TypeBinding parameter = parameters[i];
--          TypeBinding leafParameterType = parameter.leafComponentType();
--          if (leafParameterType.isNestedType()) {
--            classFile.recordInnerClasses(leafParameterType);
--          }
--        }
--      }
--      if (this.returnType != null) {
--        TypeBinding ret = this.returnType.leafComponentType();
--        if (ret.isNestedType()) {
--          classFile.recordInnerClasses(ret);
--        }
--      }
--    }
--    return signature;
--  }
--
--  StringBuffer buffer = new StringBuffer(parameters.length + 1 * 20);
--  buffer.append('(');
--  
--  TypeBinding[] targetParameters = this.parameters;
--  boolean isConstructor = isConstructor();
--  if (isConstructor && declaringClass.isEnum()) { // insert String name,int ordinal 
--    buffer.append(ConstantPool.JavaLangStringSignature);
--    buffer.append(TypeBinding.INT.signature());
--  }
--  boolean needSynthetics = isConstructor && declaringClass.isNestedType();
--  if (needSynthetics) {
--    // take into account the synthetic argument type signatures as well
--    ReferenceBinding[] syntheticArgumentTypes = declaringClass.syntheticEnclosingInstanceTypes();
--    if (syntheticArgumentTypes != null) {
--      for (int i = 0, count = syntheticArgumentTypes.length; i < count; i++) {
--        ReferenceBinding syntheticArgumentType = syntheticArgumentTypes[i];
--        if (syntheticArgumentType.isNestedType()) {
--          this.tagBits |= TagBits.ContainsNestedTypesInSignature;
--          classFile.recordInnerClasses(syntheticArgumentType);
--        }
--        buffer.append(syntheticArgumentType.signature());
--      }
--    }
--    
--    if (this instanceof SyntheticMethodBinding) {
--      targetParameters = ((SyntheticMethodBinding)this).targetMethod.parameters;
--    }
--  }
--
--  if (targetParameters != Binding.NO_PARAMETERS) {
--    for (int i = 0; i < targetParameters.length; i++) {
--      TypeBinding targetParameter = targetParameters[i];
--      TypeBinding leafTargetParameterType = targetParameter.leafComponentType();
--      if (leafTargetParameterType.isNestedType()) {
--        this.tagBits |= TagBits.ContainsNestedTypesInSignature;
--        classFile.recordInnerClasses(leafTargetParameterType);
--      }
--      buffer.append(targetParameter.signature());
--    }
--  }
--  if (needSynthetics) {
--    SyntheticArgumentBinding[] syntheticOuterArguments = declaringClass.syntheticOuterLocalVariables();
--    int count = syntheticOuterArguments == null ? 0 : syntheticOuterArguments.length;
--    for (int i = 0; i < count; i++) {
--      buffer.append(syntheticOuterArguments[i].type.signature());
--    }
--    // move the extra padding arguments of the synthetic constructor invocation to the end    
--    for (int i = targetParameters.length, extraLength = parameters.length; i < extraLength; i++) {
--      TypeBinding parameter = parameters[i];
--      TypeBinding leafParameterType = parameter.leafComponentType();
--      if (leafParameterType.isNestedType()) {
--        this.tagBits |= TagBits.ContainsNestedTypesInSignature;
--        classFile.recordInnerClasses(leafParameterType);
--      }
--      buffer.append(parameter.signature());
--    }
--  }
--  buffer.append(')');
--  if (this.returnType != null) {
--    TypeBinding ret = this.returnType.leafComponentType();
--    if (ret.isNestedType()) {
--      this.tagBits |= TagBits.ContainsNestedTypesInSignature;
--      classFile.recordInnerClasses(ret);
--    }
--    buffer.append(this.returnType.signature());
--  }
--  int nameLength = buffer.length();
--  signature = new char[nameLength];
--  buffer.getChars(0, nameLength, signature, 0);
--  
--  return signature;
--}
--public final int sourceEnd() {
--  AbstractMethodDeclaration method = sourceMethod();
--  if (method == null) {
--    if (this.declaringClass instanceof SourceTypeBinding)
--      return ((SourceTypeBinding) this.declaringClass).sourceEnd();
--    return 0;
--  }
--  return method.sourceEnd;
--}
--public AbstractMethodDeclaration sourceMethod() {
--  SourceTypeBinding sourceType;
--  try {
--    sourceType = (SourceTypeBinding) declaringClass;
--  } catch (ClassCastException e) {
--    return null;    
--  }
--
--  AbstractMethodDeclaration[] methods = sourceType.scope.referenceContext.methods;
--  for (int i = methods.length; --i >= 0;)
--    if (this == methods[i].binding)
--      return methods[i];
--  return null;    
--}
--public final int sourceStart() {
--  AbstractMethodDeclaration method = sourceMethod();
--  if (method == null) {
--    if (this.declaringClass instanceof SourceTypeBinding)
--      return ((SourceTypeBinding) this.declaringClass).sourceStart();
--    return 0;
--  }
--  return method.sourceStart;
--}
--
--/**
-- * Returns the method to use during tiebreak (usually the method itself).
-- * For generic method invocations, tiebreak needs to use generic method with erasure substitutes.
-- */
--public MethodBinding tiebreakMethod() {
--  return this;
--}
--public String toString() {
--  StringBuffer output = new StringBuffer(10);
--  if ((this.modifiers & ExtraCompilerModifiers.AccUnresolved) != 0) {
--    output.append("[unresolved] "); //$NON-NLS-1$
--  }
--  ASTNode.printModifiers(this.modifiers, output);
--  output.append(returnType != null ? returnType.debugName() : "<no type>"); //$NON-NLS-1$
--  output.append(" "); //$NON-NLS-1$
--  output.append(selector != null ? new String(selector) : "<no selector>"); //$NON-NLS-1$
--  output.append("("); //$NON-NLS-1$
--  if (parameters != null) {
--    if (parameters != Binding.NO_PARAMETERS) {
--      for (int i = 0, length = parameters.length; i < length; i++) {
--        if (i  > 0)
--          output.append(", "); //$NON-NLS-1$
--        output.append(parameters[i] != null ? parameters[i].debugName() : "<no argument type>"); //$NON-NLS-1$
--      }
--    }
--  } else {
--    output.append("<no argument types>"); //$NON-NLS-1$
--  }
--  output.append(") "); //$NON-NLS-1$
--
--  if (thrownExceptions != null) {
--    if (thrownExceptions != Binding.NO_EXCEPTIONS) {
--      output.append("throws "); //$NON-NLS-1$
--      for (int i = 0, length = thrownExceptions.length; i < length; i++) {
--        if (i  > 0)
--          output.append(", "); //$NON-NLS-1$
--        output.append((thrownExceptions[i] != null) ? thrownExceptions[i].debugName() : "<no exception type>"); //$NON-NLS-1$
--      }
--    }
--  } else {
--    output.append("<no exception types>"); //$NON-NLS-1$
--  }
--  return output.toString();
--}
--public TypeVariableBinding[] typeVariables() {
--  return this.typeVariables;
--}
--}
 --- a/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
 +++ b/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
-@@ -366,12 +366,12 @@
-   SyntheticMethodBinding accessMethod = null;
-   SyntheticMethodBinding[] accessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(targetField);
-   if (accessors == null) {
--    accessMethod = new SyntheticMethodBinding(targetField, isReadAccess, this);
-+    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, this);
-+      accessMethod = new SyntheticMethodBinding(targetField, isReadAccess, false, this);
-       accessors[isReadAccess ? 0 : 1] = accessMethod;
-     }
-   }
+@@ -365,12 +365,12 @@
+ 	SyntheticMethodBinding accessMethod = null;
+ 	SyntheticMethodBinding[] accessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(targetField);
+ 	if (accessors == null) {
+-		accessMethod = new SyntheticMethodBinding(targetField, isReadAccess, this);
++		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, this);
++			accessMethod = new SyntheticMethodBinding(targetField, isReadAccess, false, this);
+ 			accessors[isReadAccess ? 0 : 1] = accessMethod;
+ 		}
+ 	}

Modified: gwt/trunk/debian/patches/build-with-jdt37
===================================================================
--- gwt/trunk/debian/patches/build-with-jdt37	2012-11-03 11:13:17 UTC (rev 295)
+++ gwt/trunk/debian/patches/build-with-jdt37	2012-11-03 11:33:51 UTC (rev 296)
@@ -5,7 +5,7 @@
 
 --- a/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
 +++ /dev/null
-@@ -1,1672 +0,0 @@
+@@ -1,1671 +0,0 @@
 -/*******************************************************************************
 - * Copyright (c) 2000, 2008 IBM Corporation and others.
 - * All rights reserved. This program and the accompanying materials
@@ -19,6 +19,8 @@
 -package org.eclipse.jdt.internal.compiler.lookup;
 -
 -import com.google.gwt.dev.util.collect.HashMap;
+-import java.util.Hashtable;
+-import java.util.Iterator;
 -
 -import org.eclipse.jdt.core.compiler.CharOperation;
 -import org.eclipse.jdt.internal.compiler.ast.ASTNode;
@@ -32,629 +34,626 @@
 -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 org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
 -
--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 ReferenceBinding superclass;
+-	public ReferenceBinding[] superInterfaces;
+-	private FieldBinding[] fields;
+-	private MethodBinding[] methods;
+-	public ReferenceBinding[] memberTypes;
+-	public TypeVariableBinding[] typeVariables;
 -
--  public ClassScope scope;
+-	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;
+-	// 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;
+-	HashMap[] synthetics;
+-	char[] genericReferenceTypeSignature;
 -
--  private SimpleLookupTable storedAnnotations = null; // keys are this ReferenceBinding & its fields and methods, value is an AnnotationHolder
+-	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;
+-	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;
+-	// expect the fields & methods to be initialized correctly later
+-	this.fields = Binding.UNINITIALIZED_FIELDS;
+-	this.methods = Binding.UNINITIALIZED_METHODS;
 -
--  computeId();
+-	computeId();
 -}
 -
 -private void addDefaultAbstractMethods() {
--  if ((this.tagBits & TagBits.KnowsDefaultAbstractMethods) != 0) return;
+-	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
+-	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;
--          }
+-		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()
--      }
--    }
--  }
+-					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.
+-*	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);
--  }
+-	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;
+-	// 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.
+-*	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();
+-	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;
+-	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.
+-*	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();
+-	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;
+-	// 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.
+-*	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();
+-	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;
+-	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.
+-*	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();
+-	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;
+-	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.
+-	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();
+-	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;
+-	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();
+-	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;
+-	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();
+-	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;
+-	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();
+-	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;
+-	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.
+-	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();
+-	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;
+-	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;
--        }
--      }
--    }
--  }
+-	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;
+-	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;
+-	return this.fields != Binding.UNINITIALIZED_FIELDS;
 -}
 -boolean areMethodsInitialized() {
--  return this.methods != Binding.UNINITIALIZED_METHODS;
+-	return this.methods != Binding.UNINITIALIZED_METHODS;
 -}
 -public int kind() {
--  if (this.typeVariables != Binding.NO_TYPE_VARIABLES) return Binding.GENERIC_TYPE;
--  return Binding.TYPE;
+-	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;
+-	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();
+-	// 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();
+-	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; 
+-	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;
+-	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;
+-			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);
+-    	this.genericReferenceTypeSignature = computeGenericTypeSignature(this.typeVariables);
 -    return this.genericReferenceTypeSignature;
 -}
 -/**
@@ -663,29 +662,29 @@
 - */
 -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());
+-	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();
+-	return sig.toString().toCharArray();
 -}
 -
 -/**
@@ -694,330 +693,330 @@
 - * @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;
+-	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;
+-	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;
+-	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;
+-	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;
+-	// 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 ((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;
+-	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);
+-	
+-	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;
+-	// 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;
+-	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.
+-*	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);
+-	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.
+-*	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;
+-	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;
+-	// 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];
+-	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;
--    }
--  }
+-	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.scope == null) return; // already initialized
 -
--  if (this.superInterfaces == null)
--    this.scope.connectTypeHierarchy();
--  this.scope.buildFields();
--  this.scope.buildMethods();
+-	if (this.superInterfaces == null)
+-		this.scope.connectTypeHierarchy();
+-	this.scope.buildFields();
+-	this.scope.buildMethods();
 -}
 -
 -/**
@@ -1026,556 +1025,556 @@
 - */
 -public boolean isEquivalentTo(TypeBinding otherType) {
 -
--  if (this == otherType) return true;
--  if (otherType == null) return false;
--  switch(otherType.kind()) {
+-	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.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.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;
+-		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;
+-	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();
+-	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;
+-	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();
+-	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;
+-	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;
--  }
+-	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++;
--      }
--    }
+-	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
+-		// 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;
+-				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));
--            }
--            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));
--          }
--          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;
--      }
--    }
+-					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));
+-						}
+-						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));
+-					}
+-					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;
+-		// 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;
+-public 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;
+-	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
+-			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 ((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;
+-	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
+-	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);
--  }
+-	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 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
+-	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;
+-	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);
+-	if (forceInitialization)
+-		binding.getAnnotationTagBits(); // ensure annotations are up to date
+-	return super.retrieveAnnotationHolder(binding, false);
 -}
 -public void setFields(FieldBinding[] fields) {
--  this.fields = fields;
+-	this.fields = fields;
 -}
 -public void setMethods(MethodBinding[] methods) {
--  this.methods = methods;
+-	this.methods = methods;
 -}
 -public final int sourceEnd() {
--  return this.scope.referenceContext.sourceEnd;
+-	return this.scope.referenceContext.sourceEnd;
 -}
 -public final int sourceStart() {
--  return this.scope.referenceContext.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;
+-	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;
+-	return this.superclass;
 -}
 -public ReferenceBinding[] superInterfaces() {
--  return this.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;
+-	
+-	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()) {
+-	// 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();
+-		Object fieldOrMethod = fieldsOrMethods.next();
 -
--    if (fieldOrMethod instanceof MethodBinding) {
+-		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
+-			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 {
+-		} 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
--    }
--  }
+-			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;
+-	// 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;
+-	
+-	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];
+-	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;
+-	// 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);
@@ -1585,112 +1584,96 @@
 -    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 (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 (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.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 (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 (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.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.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$
--  }
+-	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();
+-	buffer.append("\n\n"); //$NON-NLS-1$
+-	return buffer.toString();
 -}
 -public TypeVariableBinding[] typeVariables() {
--  return this.typeVariables;
+-	return this.typeVariables;
 -}
 -void verifyMethods(MethodVerifier verifier) {
--  verifier.verify(this);
+-	verifier.verify(this);
 -
--  for (int i = this.memberTypes.length; --i >= 0;)
--     ((SourceTypeBinding) this.memberTypes[i]).verifyMethods(verifier);
+-	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 @@
- 
-     if (type != null) {
-       if (type instanceof UnresolvedReferenceBinding) {
--        type = BinaryTypeBinding.resolveType(type, lookupEnvironment, true);
-+        /*
-+         * Since type is an instance of UnresolvedReferenceBinding, we know that
-+         * the return value BinaryTypeBinding.resolveType will be of type
-+         * ReferenceBinding
-+         */
-+        type = (ReferenceBinding) BinaryTypeBinding.resolveType(type, lookupEnvironment, true);
-       }
-       // found it
-       return type;

Deleted: gwt/trunk/debian/patches/build-with-jdt38
===================================================================
--- gwt/trunk/debian/patches/build-with-jdt38	2012-11-03 11:13:17 UTC (rev 295)
+++ gwt/trunk/debian/patches/build-with-jdt38	2012-11-03 11:33:51 UTC (rev 296)
@@ -1,26 +0,0 @@
---- a/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java
-+++ b/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java
-@@ -220,6 +220,10 @@
-     public String toString() {
-       return builder.toString();
-     }
-+
-+    public boolean ignoreOptionalProblems() {
-+      return false;
-+    }
-   }
- 
-   private class CompilerImpl extends Compiler {
---- a/dev/core/src/com/google/gwt/dev/jdt/AbstractCompiler.java
-+++ b/dev/core/src/com/google/gwt/dev/jdt/AbstractCompiler.java
-@@ -122,6 +122,10 @@
-     public String toString() {
-       return unit.toString();
-     }
-+
-+    public boolean ignoreOptionalProblems() {
-+      return false;
-+    }
-   }
- 
-   /**

Modified: gwt/trunk/debian/patches/series
===================================================================
--- gwt/trunk/debian/patches/series	2012-11-03 11:13:17 UTC (rev 295)
+++ gwt/trunk/debian/patches/series	2012-11-03 11:33:51 UTC (rev 296)
@@ -10,4 +10,3 @@
 generated-protobuf-class
 build-with-jdt37
 fix-test-classpath
-build-with-jdt38




More information about the pkg-eucalyptus-commits mailing list