[pkg-eucalyptus-commits] r228 - gwt/trunk/debian/patches
Chris Halls
halls at alioth.debian.org
Wed Jul 4 12:09:02 UTC 2012
Author: halls
Date: 2012-07-04 12:09:02 +0000 (Wed, 04 Jul 2012)
New Revision: 228
Modified:
gwt/trunk/debian/patches/build-with-jdt35
gwt/trunk/debian/patches/build-with-jdt37
Log:
Copy changes from upstream's trunk to fix unit tests
Modified: gwt/trunk/debian/patches/build-with-jdt35
===================================================================
--- gwt/trunk/debian/patches/build-with-jdt35 2012-07-04 12:08:57 UTC (rev 227)
+++ gwt/trunk/debian/patches/build-with-jdt35 2012-07-04 12:09:02 UTC (rev 228)
@@ -1,7 +1,5 @@
-Index: gwt-2.4.0/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java
-===================================================================
---- gwt-2.4.0.orig/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java 2011-04-28 15:57:23.000000000 +0200
-+++ gwt-2.4.0/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java 2011-08-30 12:46:52.014143804 +0200
+--- a/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java
++++ b/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java
@@ -410,7 +410,7 @@
// Turn off all warnings, saves some memory / speed.
options.reportUnusedDeclaredThrownExceptionIncludeDocCommentReference = false;
@@ -11,117 +9,2147 @@
options.inlineJsrBytecode = true;
return options;
}
-Index: gwt-2.4.0/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
-===================================================================
---- gwt-2.4.0.orig/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java 2010-07-29 01:37:27.000000000 +0200
-+++ gwt-2.4.0/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java 2011-08-30 12:46:52.014143804 +0200
-@@ -126,7 +126,7 @@
- break;
-
- case Binding.TYPE_PARAMETER :
+--- 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);
-+ ((TypeVariableBinding) type).resolve();
- break;
-
- case Binding.GENERIC_TYPE :
-@@ -595,7 +595,7 @@
- pendingVariable = false;
- int colon = CharOperation.indexOf(':', typeSignature, i);
- char[] variableName = CharOperation.subarray(typeSignature, i, colon);
+- 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++));
-+ variables.add(new TypeVariableBinding(variableName, this, rank++, this.environment));
- }
- }
- }
-@@ -793,7 +793,7 @@
- // NOTE: member types of binary types are resolved when needed
- public TypeVariableBinding getTypeVariable(char[] variableName) {
- TypeVariableBinding variable = super.getTypeVariable(variableName);
+- }
+- }
+- }
+- }
+- // 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);
-+ variable.resolve();
- return variable;
- }
- private void initializeTypeVariable(TypeVariableBinding variable, TypeVariableBinding[] existingVariables, SignatureWrapper wrapper, char[][][] missingTypeNames) {
-@@ -932,7 +932,7 @@
- }
- }
- for (int i = method.typeVariables.length; --i >= 0;) {
+- 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.typeVariables[i].resolve();
- }
- method.modifiers &= ~ExtraCompilerModifiers.AccUnresolved;
- return method;
-@@ -981,7 +981,7 @@
- return this.typeVariables;
-
- for (int i = this.typeVariables.length; --i >= 0;)
+- }
+- 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.typeVariables[i].resolve();
- this.tagBits &= ~TagBits.HasUnresolvedTypeVariables;
- return this.typeVariables;
- }
-Index: gwt-2.4.0/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
-===================================================================
---- gwt-2.4.0.orig/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java 2011-01-06 15:20:30.000000000 +0100
-+++ gwt-2.4.0/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java 2011-08-30 12:46:52.054141836 +0200
-@@ -736,7 +736,7 @@
- this.declaringClass.storeAnnotations(this, annotations);
- }
- public void setAnnotations(AnnotationBinding[] annotations, AnnotationBinding[][] parameterAnnotations, Object defaultValue) {
+- 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));
-+ this.declaringClass.storeAnnotationHolder(this, AnnotationHolder.storeAnnotations(annotations, parameterAnnotations, defaultValue, null));
- }
- public void setDefaultValue(Object defaultValue) {
- MethodBinding originalMethod = this.original();
-@@ -851,7 +851,7 @@
- */
- public final char[] signature(ClassFile classFile) {
- if (signature != null) {
+-}
+-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) {
-+ if ((this.tagBits & TagBits.ContainsNestedTypeReferences) != 0) {
- // we need to record inner classes references
- boolean isConstructor = isConstructor();
- TypeBinding[] targetParameters = this.parameters;
-@@ -918,7 +918,7 @@
- for (int i = 0, count = syntheticArgumentTypes.length; i < count; i++) {
- ReferenceBinding syntheticArgumentType = syntheticArgumentTypes[i];
- if (syntheticArgumentType.isNestedType()) {
+- // 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;
-+ this.tagBits |= TagBits.ContainsNestedTypeReferences;
- classFile.recordInnerClasses(syntheticArgumentType);
- }
- buffer.append(syntheticArgumentType.signature());
-@@ -935,7 +935,7 @@
- TypeBinding targetParameter = targetParameters[i];
- TypeBinding leafTargetParameterType = targetParameter.leafComponentType();
- if (leafTargetParameterType.isNestedType()) {
+- 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;
-+ this.tagBits |= TagBits.ContainsNestedTypeReferences;
- classFile.recordInnerClasses(leafTargetParameterType);
- }
- buffer.append(targetParameter.signature());
-@@ -952,7 +952,7 @@
- TypeBinding parameter = parameters[i];
- TypeBinding leafParameterType = parameter.leafComponentType();
- if (leafParameterType.isNestedType()) {
+- 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;
-+ this.tagBits |= TagBits.ContainsNestedTypeReferences;
- classFile.recordInnerClasses(leafParameterType);
- }
- buffer.append(parameter.signature());
-@@ -962,7 +962,7 @@
- if (this.returnType != null) {
- TypeBinding ret = this.returnType.leafComponentType();
- if (ret.isNestedType()) {
+- 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;
-+ this.tagBits |= TagBits.ContainsNestedTypeReferences;
- classFile.recordInnerClasses(ret);
- }
- buffer.append(this.returnType.signature());
-Index: gwt-2.4.0/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
-===================================================================
---- gwt-2.4.0.orig/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java 2009-10-28 17:10:53.000000000 +0100
-+++ gwt-2.4.0/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java 2011-08-30 12:46:52.054141836 +0200
+- 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);
Modified: gwt/trunk/debian/patches/build-with-jdt37
===================================================================
--- gwt/trunk/debian/patches/build-with-jdt37 2012-07-04 12:08:57 UTC (rev 227)
+++ gwt/trunk/debian/patches/build-with-jdt37 2012-07-04 12:09:02 UTC (rev 228)
@@ -3,9 +3,9 @@
Bug-Debian: http://bugs.debian.org/624205
Bug-Debian: http://bugs.debian.org/629733
---- gwt-2.4.0.orig/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
-+++ gwt-2.4.0/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
-@@ -26,6 +26,7 @@ import org.eclipse.jdt.internal.compiler
+--- a/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
++++ b/dev/core/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
+@@ -26,6 +26,7 @@
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
import org.eclipse.jdt.internal.compiler.util.Util;
@@ -13,7 +13,7 @@
import java.util.Hashtable;
import java.util.Iterator;
-@@ -1202,13 +1203,14 @@ public MethodBinding[] methods() {
+@@ -1202,13 +1203,14 @@
}
boolean isEnumSpecialMethod = isEnum() && (CharOperation.equals(selector,TypeConstants.VALUEOF) || CharOperation.equals(selector,TypeConstants.VALUES));
// report duplicate
@@ -29,7 +29,7 @@
}
methodDecl.binding = null;
// do not alter original method array until resolution is over, due to reentrance (143259)
-@@ -1224,7 +1226,7 @@ public MethodBinding[] methods() {
+@@ -1224,7 +1226,7 @@
if (isEnumSpecialMethod) {
this.scope.problemReporter().duplicateEnumSpecialMethod(this, method2Decl);
} else {
More information about the pkg-eucalyptus-commits
mailing list