--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.compiler.lookup;
+
+import org.eclipse.jdt.core.compiler.CharOperation;
+import org.eclipse.jdt.internal.compiler.ast.*;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
+import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
+import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
+import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
+import org.eclipse.jdt.internal.compiler.util.HashtableOfObject;
+import org.eclipse.jdt.internal.compiler.util.ObjectVector;
+
+public abstract class Scope
+ implements BaseTypes, BindingIds, CompilerModifiers, ProblemReasons, TagBits, TypeConstants, TypeIds {
+
+ public final static int BLOCK_SCOPE = 1;
+ public final static int METHOD_SCOPE = 2;
+ public final static int CLASS_SCOPE = 3;
+ public final static int COMPILATION_UNIT_SCOPE = 4;
+
+ public int kind;
+ public Scope parent;
+
+ protected Scope(int kind, Scope parent) {
+ this.kind = kind;
+ this.parent = parent;
+ }
+
+ /* Answer an int describing the relationship between the given types.
+ *
+ * NotRelated
+ * EqualOrMoreSpecific : left is compatible with right
+ * MoreGeneric : right is compatible with left
+ */
+ public static int compareTypes(TypeBinding left, TypeBinding right) {
+ if (left.isCompatibleWith(right))
+ return EqualOrMoreSpecific;
+ if (right.isCompatibleWith(left))
+ return MoreGeneric;
+ return NotRelated;
+ }
+
+ // Internal use only
+ protected final boolean areParametersAssignable(TypeBinding[] parameters, TypeBinding[] arguments) {
+ if (parameters == arguments)
+ return true;
+
+ int length = parameters.length;
+ if (length != arguments.length)
+ return false;
+
+ for (int i = 0; i < length; i++)
+ if (parameters[i] != arguments[i])
+ if (!arguments[i].isCompatibleWith(parameters[i]))
+ return false;
+ return true;
+ }
+
+ public final ClassScope classScope() {
+ Scope scope = this;
+ do {
+ if (scope instanceof ClassScope)
+ return (ClassScope) scope;
+ scope = scope.parent;
+ } while (scope != null);
+ return null;
+ }
+
+ /* Answer an int describing the relationship between the given type and unchecked exceptions.
+ *
+ * NotRelated
+ * EqualOrMoreSpecific : type is known for sure to be an unchecked exception type
+ * MoreGeneric : type is a supertype of an actual unchecked exception type
+ */
+ public int compareUncheckedException(ReferenceBinding type) {
+ int comparison = compareTypes(type, getJavaLangRuntimeException());
+ if (comparison != 0) return comparison;
+ return compareTypes(type, getJavaLangError());
+ }
+
+ public final CompilationUnitScope compilationUnitScope() {
+ Scope lastScope = null;
+ Scope scope = this;
+ do {
+ lastScope = scope;
+ scope = scope.parent;
+ } while (scope != null);
+ return (CompilationUnitScope) lastScope;
+ }
+
+ public ArrayBinding createArray(TypeBinding type, int dimension) {
+ if (!type.isValidBinding())
+ return new ArrayBinding(type, dimension);
+ return environment().createArrayType(type, dimension);
+ }
+
+ public final ClassScope enclosingClassScope() {
+ Scope scope = this;
+ while ((scope = scope.parent) != null) {
+ if (scope instanceof ClassScope) return (ClassScope)scope;
+ }
+ return null; // may answer null if no type around
+ }
+
+ public final MethodScope enclosingMethodScope() {
+ Scope scope = this;
+ while ((scope = scope.parent) != null) {
+ if (scope instanceof MethodScope) return (MethodScope)scope;
+ }
+ return null; // may answer null if no method around
+ }
+
+ /* Answer the receiver's enclosing source type.
+ */
+ public final SourceTypeBinding enclosingSourceType() {
+ Scope scope = this;
+ do {
+ if (scope instanceof ClassScope)
+ return ((ClassScope) scope).referenceContext.binding;
+ scope = scope.parent;
+ } while (scope != null);
+ return null;
+ }
+ public final LookupEnvironment environment() {
+ Scope scope, unitScope = this;
+ while ((scope = unitScope.parent) != null)
+ unitScope = scope;
+ return ((CompilationUnitScope) unitScope).environment;
+ }
+
+ protected void faultInReceiverType(TypeBinding type) {
+ if (type.isArrayType())
+ type = ((ArrayBinding) type).leafComponentType;
+
+ // check on Begin bit, so as to be resilient with potential illformed binaries containing cycles (67769)
+ if (type instanceof BinaryTypeBinding && (type.tagBits & BeginHierarchyCheck) == 0) {
+ type.tagBits |= BeginHierarchyCheck;
+ // fault in the hierarchy of the type now so we can detect missing types instead of in storeDependencyInfo
+ BinaryTypeBinding binaryType = (BinaryTypeBinding) type;
+ ReferenceBinding enclosingType = binaryType.enclosingType();
+ if (enclosingType != null)
+ faultInReceiverType(enclosingType);
+ ReferenceBinding superclass = binaryType.superclass();
+ if (superclass != null)
+ faultInReceiverType(superclass);
+ ReferenceBinding[] interfaces = binaryType.superInterfaces();
+ for (int i = 0, l = interfaces.length; i < l; i++)
+ faultInReceiverType(interfaces[i]);
+ type.tagBits |= EndHierarchyCheck;
+ }
+ }
+
+ // abstract method lookup lookup (since maybe missing default abstract methods)
+ public MethodBinding findDefaultAbstractMethod(
+ ReferenceBinding receiverType,
+ char[] selector,
+ TypeBinding[] argumentTypes,
+ InvocationSite invocationSite,
+ ReferenceBinding classHierarchyStart,
+ MethodBinding matchingMethod,
+ ObjectVector found) {
+
+ int startFoundSize = found.size;
+ ReferenceBinding currentType = classHierarchyStart;
+ while (currentType != null) {
+ matchingMethod = findMethodInSuperInterfaces(currentType, selector, found, matchingMethod);
+ currentType = currentType.superclass();
+ }
+ int foundSize = found.size;
+ if (foundSize == startFoundSize) {
+ if (matchingMethod != null) compilationUnitScope().recordTypeReferences(matchingMethod.thrownExceptions);
+ return matchingMethod; // maybe null
+ }
+ MethodBinding[] candidates = new MethodBinding[foundSize - startFoundSize];
+ int candidatesCount = 0;
+ // argument type compatibility check
+ for (int i = startFoundSize; i < foundSize; i++) {
+ MethodBinding methodBinding = (MethodBinding) found.elementAt(i);
+ if (areParametersAssignable(methodBinding.parameters, argumentTypes))
+ candidates[candidatesCount++] = methodBinding;
+ }
+ if (candidatesCount == 1) {
+ compilationUnitScope().recordTypeReferences(candidates[0].thrownExceptions);
+ return candidates[0];
+ }
+ if (candidatesCount == 0) { // try to find a close match when the parameter order is wrong or missing some parameters
+ int argLength = argumentTypes.length;
+ nextMethod : for (int i = 0; i < foundSize; i++) {
+ MethodBinding methodBinding = (MethodBinding) found.elementAt(i);
+ TypeBinding[] params = methodBinding.parameters;
+ int paramLength = params.length;
+ nextArg: for (int a = 0; a < argLength; a++) {
+ TypeBinding arg = argumentTypes[a];
+ for (int p = 0; p < paramLength; p++)
+ if (params[p] == arg)
+ continue nextArg;
+ continue nextMethod;
+ }
+ return methodBinding;
+ }
+ return (MethodBinding) found.elementAt(0); // no good match so just use the first one found
+ }
+ // no need to check for visibility - interface methods are public
+ return mostSpecificInterfaceMethodBinding(candidates, candidatesCount);
+ }
+
+ // Internal use only
+ public ReferenceBinding findDirectMemberType(char[] typeName, ReferenceBinding enclosingType) {
+ if ((enclosingType.tagBits & HasNoMemberTypes) != 0)
+ return null; // know it has no member types (nor inherited member types)
+
+ SourceTypeBinding enclosingSourceType = enclosingSourceType();
+ compilationUnitScope().recordReference(enclosingType.compoundName, typeName);
+ ReferenceBinding memberType = enclosingType.getMemberType(typeName);
+ if (memberType != null) {
+ compilationUnitScope().recordTypeReference(memberType); // to record supertypes
+ if (enclosingSourceType == null
+ ? memberType.canBeSeenBy(getCurrentPackage())
+ : memberType.canBeSeenBy(enclosingType, enclosingSourceType))
+ return memberType;
+ return new ProblemReferenceBinding(typeName, memberType, NotVisible);
+ }
+ return null;
+ }
+
+ // Internal use only
+ public MethodBinding findExactMethod(
+ ReferenceBinding receiverType,
+ char[] selector,
+ TypeBinding[] argumentTypes,
+ InvocationSite invocationSite) {
+
+ faultInReceiverType(receiverType);
+ compilationUnitScope().recordTypeReference(receiverType);
+ compilationUnitScope().recordTypeReferences(argumentTypes);
+ MethodBinding exactMethod = receiverType.getExactMethod(selector, argumentTypes);
+ if (exactMethod != null) {
+ compilationUnitScope().recordTypeReferences(exactMethod.thrownExceptions);
+ if (receiverType.isInterface() || exactMethod.canBeSeenBy(receiverType, invocationSite, this))
+ return exactMethod;
+ }
+ return null;
+ }
+
+ // Internal use only
+ /* Answer the field binding that corresponds to fieldName.
+ Start the lookup at the receiverType.
+ InvocationSite implements
+ isSuperAccess(); this is used to determine if the discovered field is visible.
+ Only fields defined by the receiverType or its supertypes are answered;
+ a field of an enclosing type will not be found using this API.
+
+ If no visible field is discovered, null is answered.
+ */
+ public FieldBinding findField(TypeBinding receiverType, char[] fieldName, InvocationSite invocationSite, boolean needResolve) {
+ if (receiverType.isBaseType()) return null;
+ if (receiverType.isArrayType()) {
+ TypeBinding leafType = receiverType.leafComponentType();
+ if (leafType instanceof ReferenceBinding) {
+ if (!((ReferenceBinding) leafType).canBeSeenBy(this))
+ return new ProblemFieldBinding((ReferenceBinding)leafType, fieldName, ReceiverTypeNotVisible);
+ }
+ if (CharOperation.equals(fieldName, LENGTH))
+ return ArrayBinding.ArrayLength;
+ return null;
+ }
+
+ faultInReceiverType(receiverType);
+ compilationUnitScope().recordTypeReference(receiverType);
+
+ ReferenceBinding currentType = (ReferenceBinding) receiverType;
+ if (!currentType.canBeSeenBy(this))
+ return new ProblemFieldBinding(currentType, fieldName, ReceiverTypeNotVisible);
+
+ FieldBinding field = currentType.getField(fieldName, true /*resolve*/);
+ if (field != null) {
+ if (field.canBeSeenBy(currentType, invocationSite, this))
+ return field;
+ return new ProblemFieldBinding(field /* closest match*/, field.declaringClass, fieldName, NotVisible);
+ }
+ // collect all superinterfaces of receiverType until the field is found in a supertype
+ ReferenceBinding[][] interfacesToVisit = null;
+ int lastPosition = -1;
+ FieldBinding visibleField = null;
+ boolean keepLooking = true;
+ boolean notVisible = false;
+ // we could hold onto the not visible field for extra error reporting
+ while (keepLooking) {
+ ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
+ if (itsInterfaces != NoSuperInterfaces) {
+ if (interfacesToVisit == null)
+ interfacesToVisit = new ReferenceBinding[5][];
+ if (++lastPosition == interfacesToVisit.length)
+ System.arraycopy(
+ interfacesToVisit,
+ 0,
+ interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
+ 0,
+ lastPosition);
+ interfacesToVisit[lastPosition] = itsInterfaces;
+ }
+ if ((currentType = currentType.superclass()) == null)
+ break;
+
+ if ((field = currentType.getField(fieldName, needResolve)) != null) {
+ keepLooking = false;
+ if (field.canBeSeenBy(receiverType, invocationSite, this)) {
+ if (visibleField == null)
+ visibleField = field;
+ else
+ return new ProblemFieldBinding(visibleField /* closest match*/, visibleField.declaringClass, fieldName, Ambiguous);
+ } else {
+ notVisible = true;
+ }
+ }
+ }
+
+ // walk all visible interfaces to find ambiguous references
+ if (interfacesToVisit != null) {
+ ProblemFieldBinding ambiguous = null;
+ done : for (int i = 0; i <= lastPosition; i++) {
+ ReferenceBinding[] interfaces = interfacesToVisit[i];
+ for (int j = 0, length = interfaces.length; j < length; j++) {
+ ReferenceBinding anInterface = interfaces[j];
+ if ((anInterface.tagBits & InterfaceVisited) == 0) {
+ // if interface as not already been visited
+ anInterface.tagBits |= InterfaceVisited;
+ if ((field = anInterface.getField(fieldName, true /*resolve*/)) != null) {
+ if (visibleField == null) {
+ visibleField = field;
+ } else {
+ ambiguous = new ProblemFieldBinding(visibleField /* closest match*/, visibleField.declaringClass, fieldName, Ambiguous);
+ break done;
+ }
+ } else {
+ ReferenceBinding[] itsInterfaces = anInterface.superInterfaces();
+ if (itsInterfaces != NoSuperInterfaces) {
+ if (++lastPosition == interfacesToVisit.length)
+ System.arraycopy(
+ interfacesToVisit,
+ 0,
+ interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
+ 0,
+ lastPosition);
+ interfacesToVisit[lastPosition] = itsInterfaces;
+ }
+ }
+ }
+ }
+ }
+
+ // bit reinitialization
+ for (int i = 0; i <= lastPosition; i++) {
+ ReferenceBinding[] interfaces = interfacesToVisit[i];
+ for (int j = 0, length = interfaces.length; j < length; j++)
+ interfaces[j].tagBits &= ~InterfaceVisited;
+ }
+ if (ambiguous != null)
+ return ambiguous;
+ }
+
+ if (visibleField != null)
+ return visibleField;
+ if (notVisible)
+ return new ProblemFieldBinding(currentType, fieldName, NotVisible);
+ return null;
+ }
+
+ // Internal use only
+ public ReferenceBinding findMemberType(char[] typeName, ReferenceBinding enclosingType) {
+ if ((enclosingType.tagBits & HasNoMemberTypes) != 0)
+ return null; // know it has no member types (nor inherited member types)
+
+ SourceTypeBinding enclosingSourceType = enclosingSourceType();
+ PackageBinding currentPackage = getCurrentPackage();
+ compilationUnitScope().recordReference(enclosingType.compoundName, typeName);
+ ReferenceBinding memberType = enclosingType.getMemberType(typeName);
+ if (memberType != null) {
+ compilationUnitScope().recordTypeReference(memberType); // to record supertypes
+ if (enclosingSourceType == null
+ ? memberType.canBeSeenBy(currentPackage)
+ : memberType.canBeSeenBy(enclosingType, enclosingSourceType))
+ return memberType;
+ return new ProblemReferenceBinding(typeName, memberType, NotVisible);
+ }
+
+ // collect all superinterfaces of receiverType until the memberType is found in a supertype
+ ReferenceBinding currentType = enclosingType;
+ ReferenceBinding[][] interfacesToVisit = null;
+ int lastPosition = -1;
+ ReferenceBinding visibleMemberType = null;
+ boolean keepLooking = true;
+ ReferenceBinding notVisible = null;
+ // we could hold onto the not visible field for extra error reporting
+ while (keepLooking) {
+ ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
+ if (itsInterfaces != NoSuperInterfaces) {
+ if (interfacesToVisit == null)
+ interfacesToVisit = new ReferenceBinding[5][];
+ if (++lastPosition == interfacesToVisit.length)
+ System.arraycopy(
+ interfacesToVisit,
+ 0,
+ interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
+ 0,
+ lastPosition);
+ interfacesToVisit[lastPosition] = itsInterfaces;
+ }
+ if ((currentType = currentType.superclass()) == null)
+ break;
+
+ compilationUnitScope().recordReference(currentType.compoundName, typeName);
+ if ((memberType = currentType.getMemberType(typeName)) != null) {
+ compilationUnitScope().recordTypeReference(memberType); // to record supertypes
+ keepLooking = false;
+ if (enclosingSourceType == null
+ ? memberType.canBeSeenBy(currentPackage)
+ : memberType.canBeSeenBy(enclosingType, enclosingSourceType)) {
+ if (visibleMemberType == null)
+ visibleMemberType = memberType;
+ else
+ return new ProblemReferenceBinding(typeName, Ambiguous);
+ } else {
+ notVisible = memberType;
+ }
+ }
+ }
+ // walk all visible interfaces to find ambiguous references
+ if (interfacesToVisit != null) {
+ ProblemReferenceBinding ambiguous = null;
+ done : for (int i = 0; i <= lastPosition; i++) {
+ ReferenceBinding[] interfaces = interfacesToVisit[i];
+ for (int j = 0, length = interfaces.length; j < length; j++) {
+ ReferenceBinding anInterface = interfaces[j];
+ if ((anInterface.tagBits & InterfaceVisited) == 0) {
+ // if interface as not already been visited
+ anInterface.tagBits |= InterfaceVisited;
+ compilationUnitScope().recordReference(anInterface.compoundName, typeName);
+ if ((memberType = anInterface.getMemberType(typeName)) != null) {
+ compilationUnitScope().recordTypeReference(memberType); // to record supertypes
+ if (visibleMemberType == null) {
+ visibleMemberType = memberType;
+ } else {
+ ambiguous = new ProblemReferenceBinding(typeName, Ambiguous);
+ break done;
+ }
+ } else {
+ ReferenceBinding[] itsInterfaces = anInterface.superInterfaces();
+ if (itsInterfaces != NoSuperInterfaces) {
+ if (++lastPosition == interfacesToVisit.length)
+ System.arraycopy(
+ interfacesToVisit,
+ 0,
+ interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
+ 0,
+ lastPosition);
+ interfacesToVisit[lastPosition] = itsInterfaces;
+ }
+ }
+ }
+ }
+ }
+
+ // bit reinitialization
+ for (int i = 0; i <= lastPosition; i++) {
+ ReferenceBinding[] interfaces = interfacesToVisit[i];
+ for (int j = 0, length = interfaces.length; j < length; j++)
+ interfaces[j].tagBits &= ~InterfaceVisited;
+ }
+ if (ambiguous != null)
+ return ambiguous;
+ }
+ if (visibleMemberType != null)
+ return visibleMemberType;
+ if (notVisible != null)
+ return new ProblemReferenceBinding(typeName, notVisible, NotVisible);
+ return null;
+ }
+
+ // Internal use only
+ public MethodBinding findMethod(
+ ReferenceBinding receiverType,
+ char[] selector,
+ TypeBinding[] argumentTypes,
+ InvocationSite invocationSite) {
+
+ ReferenceBinding currentType = receiverType;
+ MethodBinding matchingMethod = null;
+ ObjectVector found = new ObjectVector(); //TODO should rewrite to remove #matchingMethod since found is allocated anyway
+
+ faultInReceiverType(receiverType);
+ compilationUnitScope().recordTypeReference(receiverType);
+ compilationUnitScope().recordTypeReferences(argumentTypes);
+
+ if (currentType.isInterface()) {
+ MethodBinding[] currentMethods = currentType.getMethods(selector);
+ int currentLength = currentMethods.length;
+ if (currentLength == 1) {
+ matchingMethod = currentMethods[0];
+ } else if (currentLength > 1) {
+ found.addAll(currentMethods);
+ }
+ matchingMethod = findMethodInSuperInterfaces(currentType, selector, found, matchingMethod);
+ currentType = getJavaLangObject();
+ }
+
+ boolean isCompliant14 = compilationUnitScope().environment.options.complianceLevel >= ClassFileConstants.JDK1_4;
+ // superclass lookup
+ ReferenceBinding classHierarchyStart = currentType;
+ while (currentType != null) {
+ MethodBinding[] currentMethods = currentType.getMethods(selector);
+ int currentLength = currentMethods.length;
+
+ /*
+ * if 1.4 compliant, must filter out redundant protected methods from superclasses
+ */
+ if (isCompliant14){
+ nextMethod: for (int i = 0; i < currentLength; i++){
+ MethodBinding currentMethod = currentMethods[i];
+ // protected method need to be checked only - default access is already dealt with in #canBeSeen implementation
+ // when checking that p.C -> q.B -> p.A cannot see default access members from A through B.
+ if ((currentMethod.modifiers & AccProtected) == 0) continue nextMethod;
+ if (matchingMethod != null){
+ if (currentMethod.areParametersEqual(matchingMethod)){
+ currentLength--;
+ currentMethods[i] = null; // discard this match
+ continue nextMethod;
+ }
+ } else {
+ for (int j = 0, max = found.size; j < max; j++) {
+ if (((MethodBinding)found.elementAt(j)).areParametersEqual(currentMethod)){
+ currentLength--;
+ currentMethods[i] = null;
+ continue nextMethod;
+ }
+ }
+ }
+ }
+ }
+
+ if (currentLength == 1 && matchingMethod == null && found.size == 0) {
+ matchingMethod = currentMethods[0];
+ } else if (currentLength > 0) {
+ if (matchingMethod != null) {
+ found.add(matchingMethod);
+ matchingMethod = null;
+ }
+ // append currentMethods, filtering out null entries
+ int maxMethod = currentMethods.length;
+ if (maxMethod == currentLength) { // no method was eliminated for 1.4 compliance (see above)
+ found.addAll(currentMethods);
+ } else {
+ for (int i = 0, max = currentMethods.length; i < max; i++) {
+ MethodBinding currentMethod = currentMethods[i];
+ if (currentMethod != null) found.add(currentMethod);
+ }
+ }
+ }
+ currentType = currentType.superclass();
+ }
+
+ // if found several candidates, then eliminate those not matching argument types
+ int foundSize = found.size;
+ MethodBinding[] candidates = null;
+ int candidatesCount = 0;
+ boolean checkedMatchingMethod = false; // is matchingMethod meeting argument expectation ?
+ if (foundSize > 0) {
+ // argument type compatibility check
+ for (int i = 0; i < foundSize; i++) {
+ MethodBinding methodBinding = (MethodBinding) found.elementAt(i);
+ if (areParametersAssignable(methodBinding.parameters, argumentTypes)) {
+ switch (candidatesCount) {
+ case 0:
+ matchingMethod = methodBinding; // if only one match, reuse matchingMethod
+ checkedMatchingMethod = true; // matchingMethod is known to exist and match params here
+ break;
+ case 1:
+ candidates = new MethodBinding[foundSize]; // only lazily created if more than one match
+ candidates[0] = matchingMethod; // copy back
+ matchingMethod = null;
+ // fall through
+ default:
+ candidates[candidatesCount] = methodBinding;
+ }
+ candidatesCount++;
+ }
+ }
+ }
+ // if only one matching method left (either from start or due to elimination of rivals), then match is in matchingMethod
+ if (matchingMethod != null) {
+ if (checkedMatchingMethod || areParametersAssignable(matchingMethod.parameters, argumentTypes)) {
+ // (if no default abstract) must explicitly look for one instead, which could be a better match
+ if (!matchingMethod.canBeSeenBy(receiverType, invocationSite, this)) {
+ // ignore matching method (to be consistent with multiple matches, none visible (matching method is then null)
+ MethodBinding interfaceMethod = findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, null, found);
+ if (interfaceMethod != null) return interfaceMethod;
+ compilationUnitScope().recordTypeReferences(matchingMethod.thrownExceptions);
+ return matchingMethod;
+ }
+ }
+ return findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, matchingMethod, found);
+ }
+
+ // no match was found, try to find a close match when the parameter order is wrong or missing some parameters
+ if (candidatesCount == 0) {
+ MethodBinding interfaceMethod =
+ findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, matchingMethod, found);
+ if (interfaceMethod != null) return interfaceMethod;
+
+ int argLength = argumentTypes.length;
+ foundSize = found.size;
+ nextMethod : for (int i = 0; i < foundSize; i++) {
+ MethodBinding methodBinding = (MethodBinding) found.elementAt(i);
+ TypeBinding[] params = methodBinding.parameters;
+ int paramLength = params.length;
+ nextArg: for (int a = 0; a < argLength; a++) {
+ TypeBinding arg = argumentTypes[a];
+ for (int p = 0; p < paramLength; p++)
+ if (params[p] == arg)
+ continue nextArg;
+ continue nextMethod;
+ }
+ return methodBinding;
+ }
+ return (MethodBinding) found.elementAt(0); // no good match so just use the first one found
+ }
+
+ // tiebreak using visibility check
+ int visiblesCount = 0;
+ for (int i = 0; i < candidatesCount; i++) {
+ MethodBinding methodBinding = candidates[i];
+ if (methodBinding.canBeSeenBy(receiverType, invocationSite, this)) {
+ if (visiblesCount != i) {
+ candidates[i] = null;
+ candidates[visiblesCount] = methodBinding;
+ }
+ visiblesCount++;
+ }
+ }
+ if (visiblesCount == 1) {
+ compilationUnitScope().recordTypeReferences(candidates[0].thrownExceptions);
+ return candidates[0];
+ }
+ if (visiblesCount == 0) {
+ MethodBinding interfaceMethod =
+ findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, matchingMethod, found);
+ if (interfaceMethod != null) return interfaceMethod;
+ return new ProblemMethodBinding(candidates[0], candidates[0].selector, candidates[0].parameters, NotVisible);
+ }
+ if (isCompliant14)
+ return mostSpecificMethodBinding(candidates, visiblesCount);
+ return candidates[0].declaringClass.isClass()
+ ? mostSpecificClassMethodBinding(candidates, visiblesCount)
+ : mostSpecificInterfaceMethodBinding(candidates, visiblesCount);
+ }
+
+ // Internal use only
+ public MethodBinding findMethodForArray(
+ ArrayBinding receiverType,
+ char[] selector,
+ TypeBinding[] argumentTypes,
+ InvocationSite invocationSite) {
+
+ TypeBinding leafType = receiverType.leafComponentType();
+ if (leafType instanceof ReferenceBinding) {
+ if (!((ReferenceBinding) leafType).canBeSeenBy(this))
+ return new ProblemMethodBinding(selector, TypeConstants.NoParameters, (ReferenceBinding)leafType, ReceiverTypeNotVisible);
+ }
+
+ ReferenceBinding object = getJavaLangObject();
+ MethodBinding methodBinding = object.getExactMethod(selector, argumentTypes);
+ if (methodBinding != null) {
+ // handle the method clone() specially... cannot be protected or throw exceptions
+ if (argumentTypes == NoParameters && CharOperation.equals(selector, CLONE))
+ return new UpdatedMethodBinding(
+ environment().options.targetJDK >= ClassFileConstants.JDK1_4 ? (TypeBinding)receiverType : (TypeBinding)object, // remember its array type for codegen purpose on target>=1.4.0
+ (methodBinding.modifiers ^ AccProtected) | AccPublic,
+ CLONE,
+ methodBinding.returnType,
+ argumentTypes,
+ null,
+ object);
+ if (methodBinding.canBeSeenBy(receiverType, invocationSite, this))
+ return methodBinding;
+ }
+ // answers closest approximation, may not check argumentTypes or visibility
+ methodBinding = findMethod(object, selector, argumentTypes, invocationSite);
+ if (methodBinding == null)
+ return new ProblemMethodBinding(selector, argumentTypes, NotFound);
+ if (methodBinding.isValidBinding()) {
+ if (!areParametersAssignable(methodBinding.parameters, argumentTypes))
+ return new ProblemMethodBinding(
+ methodBinding,
+ selector,
+ argumentTypes,
+ NotFound);
+ if (!methodBinding.canBeSeenBy(receiverType, invocationSite, this))
+ return new ProblemMethodBinding(
+ methodBinding,
+ selector,
+ methodBinding.parameters,
+ NotVisible);
+ }
+ return methodBinding;
+ }
+
+ public MethodBinding findMethodInSuperInterfaces(
+ ReferenceBinding currentType,
+ char[] selector,
+ ObjectVector found,
+ MethodBinding matchingMethod) {
+
+ ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
+ if (itsInterfaces != NoSuperInterfaces) {
+ ReferenceBinding[][] interfacesToVisit = new ReferenceBinding[5][];
+ int lastPosition = -1;
+ if (++lastPosition == interfacesToVisit.length)
+ System.arraycopy(
+ interfacesToVisit, 0,
+ interfacesToVisit = new ReferenceBinding[lastPosition * 2][], 0,
+ lastPosition);
+ interfacesToVisit[lastPosition] = itsInterfaces;
+
+ for (int i = 0; i <= lastPosition; i++) {
+ ReferenceBinding[] interfaces = interfacesToVisit[i];
+ for (int j = 0, length = interfaces.length; j < length; j++) {
+ currentType = interfaces[j];
+ if ((currentType.tagBits & InterfaceVisited) == 0) {
+ // if interface as not already been visited
+ currentType.tagBits |= InterfaceVisited;
+
+ MethodBinding[] currentMethods = currentType.getMethods(selector);
+ int currentLength = currentMethods.length;
+ if (currentLength == 1 && matchingMethod == null && found.size == 0) {
+ matchingMethod = currentMethods[0];
+ } else if (currentLength > 0) {
+ if (matchingMethod != null) {
+ found.add(matchingMethod);
+ matchingMethod = null;
+ }
+ found.addAll(currentMethods);
+ }
+ itsInterfaces = currentType.superInterfaces();
+ if (itsInterfaces != NoSuperInterfaces) {
+ if (++lastPosition == interfacesToVisit.length)
+ System.arraycopy(
+ interfacesToVisit, 0,
+ interfacesToVisit = new ReferenceBinding[lastPosition * 2][], 0,
+ lastPosition);
+ interfacesToVisit[lastPosition] = itsInterfaces;
+ }
+ }
+ }
+ }
+
+ // bit reinitialization
+ for (int i = 0; i <= lastPosition; i++) {
+ ReferenceBinding[] interfaces = interfacesToVisit[i];
+ for (int j = 0, length = interfaces.length; j < length; j++)
+ interfaces[j].tagBits &= ~InterfaceVisited;
+ }
+ }
+ return matchingMethod;
+ }
+
+ // Internal use only
+ public ReferenceBinding findType(
+ char[] typeName,
+ PackageBinding declarationPackage,
+ PackageBinding invocationPackage) {
+
+ compilationUnitScope().recordReference(declarationPackage.compoundName, typeName);
+ ReferenceBinding typeBinding = declarationPackage.getType(typeName);
+ if (typeBinding == null)
+ return null;
+
+ if (typeBinding.isValidBinding()) {
+ if (declarationPackage != invocationPackage && !typeBinding.canBeSeenBy(invocationPackage))
+ return new ProblemReferenceBinding(typeName, typeBinding, NotVisible);
+ }
+ return typeBinding;
+ }
+
+ public LocalVariableBinding findVariable(char[] variable) {
+
+ return null;
+ }
+
+ public TypeBinding getBaseType(char[] name) {
+ // list should be optimized (with most often used first)
+ int length = name.length;
+ if (length > 2 && length < 8) {
+ switch (name[0]) {
+ case 'i' :
+ if (length == 3 && name[1] == 'n' && name[2] == 't')
+ return IntBinding;
+ break;
+ case 'v' :
+ if (length == 4 && name[1] == 'o' && name[2] == 'i' && name[3] == 'd')
+ return VoidBinding;
+ break;
+ case 'b' :
+ if (length == 7
+ && name[1] == 'o'
+ && name[2] == 'o'
+ && name[3] == 'l'
+ && name[4] == 'e'
+ && name[5] == 'a'
+ && name[6] == 'n')
+ return BooleanBinding;
+ if (length == 4 && name[1] == 'y' && name[2] == 't' && name[3] == 'e')
+ return ByteBinding;
+ break;
+ case 'c' :
+ if (length == 4 && name[1] == 'h' && name[2] == 'a' && name[3] == 'r')
+ return CharBinding;
+ break;
+ case 'd' :
+ if (length == 6
+ && name[1] == 'o'
+ && name[2] == 'u'
+ && name[3] == 'b'
+ && name[4] == 'l'
+ && name[5] == 'e')
+ return DoubleBinding;
+ break;
+ case 'f' :
+ if (length == 5
+ && name[1] == 'l'
+ && name[2] == 'o'
+ && name[3] == 'a'
+ && name[4] == 't')
+ return FloatBinding;
+ break;
+ case 'l' :
+ if (length == 4 && name[1] == 'o' && name[2] == 'n' && name[3] == 'g')
+ return LongBinding;
+ break;
+ case 's' :
+ if (length == 5
+ && name[1] == 'h'
+ && name[2] == 'o'
+ && name[3] == 'r'
+ && name[4] == 't')
+ return ShortBinding;
+ }
+ }
+ return null;
+ }
+
+ /* API
+ *
+ * Answer the binding that corresponds to the argument name.
+ * flag is a mask of the following values VARIABLE (= FIELD or LOCAL), TYPE, PACKAGE.
+ * Only bindings corresponding to the mask can be answered.
+ *
+ * For example, getBinding("foo", VARIABLE, site) will answer
+ * the binding for the field or local named "foo" (or an error binding if none exists).
+ * If a type named "foo" exists, it will not be detected (and an error binding will be answered)
+ *
+ * The VARIABLE mask has precedence over the TYPE mask.
+ *
+ * If the VARIABLE mask is not set, neither fields nor locals will be looked for.
+ *
+ * InvocationSite implements:
+ * isSuperAccess(); this is used to determine if the discovered field is visible.
+ *
+ * Limitations: cannot request FIELD independently of LOCAL, or vice versa
+ */
+ public Binding getBinding(char[] name, int mask, InvocationSite invocationSite, boolean needResolve) {
+
+ try {
+ Binding binding = null;
+ FieldBinding problemField = null;
+ if ((mask & VARIABLE) != 0) {
+ boolean insideStaticContext = false;
+ boolean insideConstructorCall = false;
+
+ FieldBinding foundField = null;
+ // can be a problem field which is answered if a valid field is not found
+ ProblemFieldBinding foundInsideProblem = null;
+ // inside Constructor call or inside static context
+ Scope scope = this;
+ int depth = 0;
+ int foundDepth = 0;
+ ReferenceBinding foundActualReceiverType = null;
+ done : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
+ switch (scope.kind) {
+ case METHOD_SCOPE :
+ MethodScope methodScope = (MethodScope) scope;
+ insideStaticContext |= methodScope.isStatic;
+ insideConstructorCall |= methodScope.isConstructorCall;
+ // Fall through... could duplicate the code below to save a cast - questionable optimization
+ case BLOCK_SCOPE :
+ LocalVariableBinding variableBinding = scope.findVariable(name);
+ // looks in this scope only
+ if (variableBinding != null) {
+ if (foundField != null && foundField.isValidBinding())
+ return new ProblemFieldBinding(
+ foundField, // closest match
+ foundField.declaringClass,
+ name,
+ InheritedNameHidesEnclosingName);
+ if (depth > 0)
+ invocationSite.setDepth(depth);
+ return variableBinding;
+ }
+ break;
+ case CLASS_SCOPE :
+ ClassScope classScope = (ClassScope) scope;
+ SourceTypeBinding enclosingType = classScope.referenceContext.binding;
+ FieldBinding fieldBinding =
+ classScope.findField(enclosingType, name, invocationSite, needResolve);
+ // Use next line instead if willing to enable protected access accross inner types
+ // FieldBinding fieldBinding = findField(enclosingType, name, invocationSite);
+ if (fieldBinding != null) { // skip it if we did not find anything
+ if (fieldBinding.problemId() == Ambiguous) {
+ if (foundField == null || foundField.problemId() == NotVisible)
+ // supercedes any potential InheritedNameHidesEnclosingName problem
+ return fieldBinding;
+ // make the user qualify the field, likely wants the first inherited field (javac generates an ambiguous error instead)
+ return new ProblemFieldBinding(
+ foundField, // closest match
+ foundField.declaringClass,
+ name,
+ InheritedNameHidesEnclosingName);
+ }
+
+ ProblemFieldBinding insideProblem = null;
+ if (fieldBinding.isValidBinding()) {
+ if (!fieldBinding.isStatic()) {
+ if (insideConstructorCall) {
+ insideProblem =
+ new ProblemFieldBinding(
+ fieldBinding, // closest match
+ fieldBinding.declaringClass,
+ name,
+ NonStaticReferenceInConstructorInvocation);
+ } else if (insideStaticContext) {
+ insideProblem =
+ new ProblemFieldBinding(
+ fieldBinding, // closest match
+ fieldBinding.declaringClass,
+ name,
+ NonStaticReferenceInStaticContext);
+ }
+ }
+ if (enclosingType == fieldBinding.declaringClass
+ || environment().options.complianceLevel >= ClassFileConstants.JDK1_4){
+ // found a valid field in the 'immediate' scope (ie. not inherited)
+ // OR in 1.4 mode (inherited shadows enclosing)
+ if (foundField == null) {
+ if (depth > 0){
+ invocationSite.setDepth(depth);
+ invocationSite.setActualReceiverType(enclosingType);
+ }
+ // return the fieldBinding if it is not declared in a superclass of the scope's binding (that is, inherited)
+ return insideProblem == null ? fieldBinding : insideProblem;
+ }
+ if (foundField.isValidBinding())
+ // if a valid field was found, complain when another is found in an 'immediate' enclosing type (that is, not inherited)
+ if (foundField.declaringClass != fieldBinding.declaringClass)
+ // ie. have we found the same field - do not trust field identity yet
+ return new ProblemFieldBinding(
+ foundField, // closest match
+ foundField.declaringClass,
+ name,
+ InheritedNameHidesEnclosingName);
+ }
+ }
+
+ if (foundField == null
+ || (foundField.problemId() == NotVisible
+ && fieldBinding.problemId() != NotVisible)) {
+ // only remember the fieldBinding if its the first one found or the previous one was not visible & fieldBinding is...
+ foundDepth = depth;
+ foundActualReceiverType = enclosingType;
+ foundInsideProblem = insideProblem;
+ foundField = fieldBinding;
+ }
+ }
+ depth++;
+ insideStaticContext |= enclosingType.isStatic();
+ // 1EX5I8Z - accessing outer fields within a constructor call is permitted
+ // in order to do so, we change the flag as we exit from the type, not the method
+ // itself, because the class scope is used to retrieve the fields.
+ MethodScope enclosingMethodScope = scope.methodScope();
+ insideConstructorCall =
+ enclosingMethodScope == null ? false : enclosingMethodScope.isConstructorCall;
+ break;
+ case COMPILATION_UNIT_SCOPE :
+ break done;
+ }
+ scope = scope.parent;
+ }
+
+ if (foundInsideProblem != null)
+ return foundInsideProblem;
+ if (foundField != null) {
+ if (foundField.isValidBinding()){
+ if (foundDepth > 0){
+ invocationSite.setDepth(foundDepth);
+ invocationSite.setActualReceiverType(foundActualReceiverType);
+ }
+ return foundField;
+ }
+ problemField = foundField;
+ }
+ }
+
+ // We did not find a local or instance variable.
+ if ((mask & TYPE) != 0) {
+ if ((binding = getBaseType(name)) != null)
+ return binding;
+ binding = getTypeOrPackage(name, (mask & PACKAGE) == 0 ? TYPE : TYPE | PACKAGE);
+ if (binding.isValidBinding() || mask == TYPE)
+ return binding;
+ // answer the problem type binding if we are only looking for a type
+ } else if ((mask & PACKAGE) != 0) {
+ compilationUnitScope().recordSimpleReference(name);
+ if ((binding = environment().getTopLevelPackage(name)) != null)
+ return binding;
+ }
+ if (problemField != null) return problemField;
+ return new ProblemBinding(name, enclosingSourceType(), NotFound);
+
+ } catch (AbortCompilation e) {
+ e.updateContext(invocationSite, referenceCompilationUnit().compilationResult);
+ throw e;
+ }
+ }
+
+ public MethodBinding getConstructor(ReferenceBinding receiverType, TypeBinding[] argumentTypes, InvocationSite invocationSite) {
+ try {
+ faultInReceiverType(receiverType);
+ compilationUnitScope().recordTypeReference(receiverType);
+ compilationUnitScope().recordTypeReferences(argumentTypes);
+ MethodBinding methodBinding = receiverType.getExactConstructor(argumentTypes);
+ if (methodBinding != null && methodBinding.canBeSeenBy(invocationSite, this))
+ return methodBinding;
+ MethodBinding[] methods = receiverType.getMethods(ConstructorDeclaration.ConstantPoolName);
+ if (methods == NoMethods)
+ return new ProblemMethodBinding(
+ ConstructorDeclaration.ConstantPoolName,
+ argumentTypes,
+ NotFound);
+
+ MethodBinding[] compatible = new MethodBinding[methods.length];
+ int compatibleIndex = 0;
+ for (int i = 0, length = methods.length; i < length; i++)
+ if (areParametersAssignable(methods[i].parameters, argumentTypes))
+ compatible[compatibleIndex++] = methods[i];
+ if (compatibleIndex == 0)
+ return new ProblemMethodBinding(
+ ConstructorDeclaration.ConstantPoolName,
+ argumentTypes,
+ NotFound);
+ // need a more descriptive error... cannot convert from X to Y
+
+ MethodBinding[] visible = new MethodBinding[compatibleIndex];
+ int visibleIndex = 0;
+ for (int i = 0; i < compatibleIndex; i++) {
+ MethodBinding method = compatible[i];
+ if (method.canBeSeenBy(invocationSite, this))
+ visible[visibleIndex++] = method;
+ }
+ if (visibleIndex == 1) return visible[0];
+ if (visibleIndex == 0)
+ return new ProblemMethodBinding(
+ compatible[0],
+ ConstructorDeclaration.ConstantPoolName,
+ compatible[0].parameters,
+ NotVisible);
+ return mostSpecificClassMethodBinding(visible, visibleIndex);
+ } catch (AbortCompilation e) {
+ e.updateContext(invocationSite, referenceCompilationUnit().compilationResult);
+ throw e;
+ }
+ }
+
+ public final PackageBinding getCurrentPackage() {
+ Scope scope, unitScope = this;
+ while ((scope = unitScope.parent) != null)
+ unitScope = scope;
+ return ((CompilationUnitScope) unitScope).fPackage;
+ }
+
+ /**
+ * Returns the modifiers of the innermost enclosing declaration.
+ * @return modifiers
+ */
+ public int getDeclarationModifiers(){
+ switch(this.kind){
+ case Scope.BLOCK_SCOPE :
+ case Scope.METHOD_SCOPE :
+ MethodScope methodScope = methodScope();
+ if (!methodScope.isInsideInitializer()){
+ // check method modifiers to see if deprecated
+ MethodBinding context = ((AbstractMethodDeclaration)methodScope.referenceContext).binding;
+ if (context != null) {
+ return context.modifiers;
+ }
+ } else {
+ SourceTypeBinding type = ((BlockScope)this).referenceType().binding;
+
+ // inside field declaration ? check field modifier to see if deprecated
+ if (methodScope.initializedField != null) {
+ return methodScope.initializedField.modifiers;
+ }
+ if (type != null) {
+ return type.modifiers;
+ }
+ }
+ break;
+ case Scope.CLASS_SCOPE :
+ ReferenceBinding context = ((ClassScope)this).referenceType().binding;
+ if (context != null) {
+ return context.modifiers;
+ }
+ break;
+ }
+ return -1;
+ }
+
+ public FieldBinding getField(TypeBinding receiverType, char[] fieldName, InvocationSite invocationSite) {
+ try {
+ FieldBinding field = findField(receiverType, fieldName, invocationSite, true /*resolve*/);
+ if (field != null) return field;
+
+ return new ProblemFieldBinding(
+ receiverType instanceof ReferenceBinding ? (ReferenceBinding) receiverType : null,
+ fieldName,
+ NotFound);
+ } catch (AbortCompilation e) {
+ e.updateContext(invocationSite, referenceCompilationUnit().compilationResult);
+ throw e;
+ }
+ }
+
+ /* API
+ *
+ * Answer the method binding that corresponds to selector, argumentTypes.
+ * Start the lookup at the enclosing type of the receiver.
+ * InvocationSite implements
+ * isSuperAccess(); this is used to determine if the discovered method is visible.
+ * setDepth(int); this is used to record the depth of the discovered method
+ * relative to the enclosing type of the receiver. (If the method is defined
+ * in the enclosing type of the receiver, the depth is 0; in the next enclosing
+ * type, the depth is 1; and so on
+ *
+ * If no visible method is discovered, an error binding is answered.
+ */
+ public MethodBinding getImplicitMethod(
+ char[] selector,
+ TypeBinding[] argumentTypes,
+ InvocationSite invocationSite) {
+
+ boolean insideStaticContext = false;
+ boolean insideConstructorCall = false;
+ MethodBinding foundMethod = null;
+ ProblemMethodBinding foundFuzzyProblem = null;
+ // the weird method lookup case (matches method name in scope, then arg types, then visibility)
+ ProblemMethodBinding foundInsideProblem = null;
+ // inside Constructor call or inside static context
+ Scope scope = this;
+ int depth = 0;
+ done : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
+ switch (scope.kind) {
+ case METHOD_SCOPE :
+ MethodScope methodScope = (MethodScope) scope;
+ insideStaticContext |= methodScope.isStatic;
+ insideConstructorCall |= methodScope.isConstructorCall;
+ break;
+ case CLASS_SCOPE :
+ ClassScope classScope = (ClassScope) scope;
+ SourceTypeBinding receiverType = classScope.referenceContext.binding;
+ boolean isExactMatch = true;
+ // retrieve an exact visible match (if possible)
+ MethodBinding methodBinding =
+ (foundMethod == null)
+ ? classScope.findExactMethod(
+ receiverType,
+ selector,
+ argumentTypes,
+ invocationSite)
+ : classScope.findExactMethod(
+ receiverType,
+ foundMethod.selector,
+ foundMethod.parameters,
+ invocationSite);
+ // ? findExactMethod(receiverType, selector, argumentTypes, invocationSite)
+ // : findExactMethod(receiverType, foundMethod.selector, foundMethod.parameters, invocationSite);
+ if (methodBinding == null) {
+ // answers closest approximation, may not check argumentTypes or visibility
+ isExactMatch = false;
+ methodBinding =
+ classScope.findMethod(receiverType, selector, argumentTypes, invocationSite);
+ // methodBinding = findMethod(receiverType, selector, argumentTypes, invocationSite);
+ }
+ if (methodBinding != null) { // skip it if we did not find anything
+ if (methodBinding.problemId() == Ambiguous) {
+ if (foundMethod == null || foundMethod.problemId() == NotVisible) {
+ // supercedes any potential InheritedNameHidesEnclosingName problem
+ return methodBinding;
+ }
+ // make the user qualify the method, likely wants the first inherited method (javac generates an ambiguous error instead)
+ return new ProblemMethodBinding(
+ methodBinding, // closest match
+ selector,
+ argumentTypes,
+ InheritedNameHidesEnclosingName);
+ }
+ ProblemMethodBinding fuzzyProblem = null;
+ ProblemMethodBinding insideProblem = null;
+ if (methodBinding.isValidBinding()) {
+ if (!isExactMatch) {
+ if (!areParametersAssignable(methodBinding.parameters, argumentTypes)) {
+ if (foundMethod == null || foundMethod.problemId() == NotVisible){
+ // inherited mismatch is reported directly, not looking at enclosing matches
+ return new ProblemMethodBinding(methodBinding, selector, argumentTypes, NotFound);
+ }
+ // make the user qualify the method, likely wants the first inherited method (javac generates an ambiguous error instead)
+ fuzzyProblem = new ProblemMethodBinding(selector, methodBinding.parameters, InheritedNameHidesEnclosingName);
+
+ } else if (!methodBinding.canBeSeenBy(receiverType, invocationSite, classScope)) {
+ // using <classScope> instead of <this> for visibility check does grant all access to innerclass
+ fuzzyProblem =
+ new ProblemMethodBinding(
+ methodBinding,
+ selector,
+ methodBinding.parameters,
+ NotVisible);
+ }
+ }
+ if (fuzzyProblem == null && !methodBinding.isStatic()) {
+ if (insideConstructorCall) {
+ insideProblem =
+ new ProblemMethodBinding(
+ methodBinding, // closest match
+ methodBinding.selector,
+ methodBinding.parameters,
+ NonStaticReferenceInConstructorInvocation);
+ } else if (insideStaticContext) {
+ insideProblem =
+ new ProblemMethodBinding(
+ methodBinding, // closest match
+ methodBinding.selector,
+ methodBinding.parameters,
+ NonStaticReferenceInStaticContext);
+ }
+ }
+
+ if (receiverType == methodBinding.declaringClass
+ || (receiverType.getMethods(selector)) != NoMethods
+ || ((fuzzyProblem == null || fuzzyProblem.problemId() != NotVisible) && environment().options.complianceLevel >= ClassFileConstants.JDK1_4)){
+ // found a valid method in the 'immediate' scope (ie. not inherited)
+ // OR the receiverType implemented a method with the correct name
+ // OR in 1.4 mode (inherited visible shadows enclosing)
+ if (foundMethod == null) {
+ if (depth > 0){
+ invocationSite.setDepth(depth);
+ invocationSite.setActualReceiverType(receiverType);
+ }
+ // return the methodBinding if it is not declared in a superclass of the scope's binding (that is, inherited)
+ if (fuzzyProblem != null)
+ return fuzzyProblem;
+ if (insideProblem != null)
+ return insideProblem;
+ return methodBinding;
+ }
+ // if a method was found, complain when another is found in an 'immediate' enclosing type (that is, not inherited)
+ // NOTE: Unlike fields, a non visible method hides a visible method
+ if (foundMethod.declaringClass != methodBinding.declaringClass)
+ // ie. have we found the same method - do not trust field identity yet
+ return new ProblemMethodBinding(
+ methodBinding, // closest match
+ methodBinding.selector,
+ methodBinding.parameters,
+ InheritedNameHidesEnclosingName);
+ }
+ }
+
+ if (foundMethod == null
+ || (foundMethod.problemId() == NotVisible
+ && methodBinding.problemId() != NotVisible)) {
+ // only remember the methodBinding if its the first one found or the previous one was not visible & methodBinding is...
+ // remember that private methods are visible if defined directly by an enclosing class
+ if (depth > 0){
+ invocationSite.setDepth(depth);
+ invocationSite.setActualReceiverType(receiverType);
+ }
+ foundFuzzyProblem = fuzzyProblem;
+ foundInsideProblem = insideProblem;
+ if (fuzzyProblem == null)
+ foundMethod = methodBinding; // only keep it if no error was found
+ }
+ }
+ depth++;
+ insideStaticContext |= receiverType.isStatic();
+ // 1EX5I8Z - accessing outer fields within a constructor call is permitted
+ // in order to do so, we change the flag as we exit from the type, not the method
+ // itself, because the class scope is used to retrieve the fields.
+ MethodScope enclosingMethodScope = scope.methodScope();
+ insideConstructorCall =
+ enclosingMethodScope == null ? false : enclosingMethodScope.isConstructorCall;
+ break;
+ case COMPILATION_UNIT_SCOPE :
+ break done;
+ }
+ scope = scope.parent;
+ }
+
+ if (foundFuzzyProblem != null)
+ return foundFuzzyProblem;
+ if (foundInsideProblem != null)
+ return foundInsideProblem;
+ if (foundMethod != null)
+ return foundMethod;
+ return new ProblemMethodBinding(selector, argumentTypes, NotFound);
+ }
+
+ public final ReferenceBinding getJavaIoSerializable() {
+ compilationUnitScope().recordQualifiedReference(JAVA_IO_SERIALIZABLE);
+ ReferenceBinding type = environment().getType(JAVA_IO_SERIALIZABLE);
+ if (type != null) return type;
+
+ problemReporter().isClassPathCorrect(JAVA_IO_SERIALIZABLE, referenceCompilationUnit());
+ return null; // will not get here since the above error aborts the compilation
+ }
+
+ public final ReferenceBinding getJavaLangAssertionError() {
+ compilationUnitScope().recordQualifiedReference(JAVA_LANG_ASSERTIONERROR);
+ ReferenceBinding type = environment().getType(JAVA_LANG_ASSERTIONERROR);
+ if (type != null) return type;
+ problemReporter().isClassPathCorrect(JAVA_LANG_ASSERTIONERROR, referenceCompilationUnit());
+ return null; // will not get here since the above error aborts the compilation
+ }
+
+ public final ReferenceBinding getJavaLangClass() {
+ compilationUnitScope().recordQualifiedReference(JAVA_LANG_CLASS);
+ ReferenceBinding type = environment().getType(JAVA_LANG_CLASS);
+ if (type != null) return type;
+
+ problemReporter().isClassPathCorrect(JAVA_LANG_CLASS, referenceCompilationUnit());
+ return null; // will not get here since the above error aborts the compilation
+ }
+
+ public final ReferenceBinding getJavaLangCloneable() {
+ compilationUnitScope().recordQualifiedReference(JAVA_LANG_CLONEABLE);
+ ReferenceBinding type = environment().getType(JAVA_LANG_CLONEABLE);
+ if (type != null) return type;
+
+ problemReporter().isClassPathCorrect(JAVA_LANG_CLONEABLE, referenceCompilationUnit());
+ return null; // will not get here since the above error aborts the compilation
+ }
+
+ public final ReferenceBinding getJavaLangError() {
+ compilationUnitScope().recordQualifiedReference(JAVA_LANG_ERROR);
+ ReferenceBinding type = environment().getType(JAVA_LANG_ERROR);
+ if (type != null) return type;
+
+ problemReporter().isClassPathCorrect(JAVA_LANG_ERROR, referenceCompilationUnit());
+ return null; // will not get here since the above error aborts the compilation
+ }
+
+ public final ReferenceBinding getJavaLangObject() {
+ compilationUnitScope().recordQualifiedReference(JAVA_LANG_OBJECT);
+ ReferenceBinding type = environment().getType(JAVA_LANG_OBJECT);
+ if (type != null) return type;
+
+ problemReporter().isClassPathCorrect(JAVA_LANG_OBJECT, referenceCompilationUnit());
+ return null; // will not get here since the above error aborts the compilation
+ }
+
+ public final ReferenceBinding getJavaLangRuntimeException() {
+ compilationUnitScope().recordQualifiedReference(JAVA_LANG_RUNTIMEEXCEPTION);
+ ReferenceBinding type = environment().getType(JAVA_LANG_RUNTIMEEXCEPTION);
+ if (type != null) return type;
+
+ problemReporter().isClassPathCorrect(JAVA_LANG_RUNTIMEEXCEPTION, referenceCompilationUnit());
+ return null; // will not get here since the above error aborts the compilation
+ }
+
+ public final ReferenceBinding getJavaLangString() {
+ compilationUnitScope().recordQualifiedReference(JAVA_LANG_STRING);
+ ReferenceBinding type = environment().getType(JAVA_LANG_STRING);
+ if (type != null) return type;
+
+ problemReporter().isClassPathCorrect(JAVA_LANG_STRING, referenceCompilationUnit());
+ return null; // will not get here since the above error aborts the compilation
+ }
+
+ public final ReferenceBinding getJavaLangThrowable() {
+ compilationUnitScope().recordQualifiedReference(JAVA_LANG_THROWABLE);
+ ReferenceBinding type = environment().getType(JAVA_LANG_THROWABLE);
+ if (type != null) return type;
+
+ problemReporter().isClassPathCorrect(JAVA_LANG_THROWABLE, referenceCompilationUnit());
+ return null; // will not get here since the above error aborts the compilation
+ }
+
+ /* Answer the type binding corresponding to the typeName argument, relative to the enclosingType.
+ */
+ public final ReferenceBinding getMemberType(char[] typeName, ReferenceBinding enclosingType) {
+ ReferenceBinding memberType = findMemberType(typeName, enclosingType);
+ if (memberType != null) return memberType;
+ return new ProblemReferenceBinding(typeName, NotFound);
+ }
+
+ public MethodBinding getMethod(TypeBinding receiverType, char[] selector, TypeBinding[] argumentTypes, InvocationSite invocationSite) {
+ try {
+ if (receiverType.isArrayType())
+ return findMethodForArray((ArrayBinding) receiverType, selector, argumentTypes, invocationSite);
+ if (receiverType.isBaseType())
+ return new ProblemMethodBinding(selector, argumentTypes, NotFound);
+
+ ReferenceBinding currentType = (ReferenceBinding) receiverType;
+ if (!currentType.canBeSeenBy(this))
+ return new ProblemMethodBinding(selector, argumentTypes, ReceiverTypeNotVisible);
+
+ // retrieve an exact visible match (if possible)
+ MethodBinding methodBinding = findExactMethod(currentType, selector, argumentTypes, invocationSite);
+ if (methodBinding != null) return methodBinding;
+
+ // answers closest approximation, may not check argumentTypes or visibility
+ methodBinding = findMethod(currentType, selector, argumentTypes, invocationSite);
+ if (methodBinding == null)
+ return new ProblemMethodBinding(selector, argumentTypes, NotFound);
+ if (methodBinding.isValidBinding()) {
+ if (!areParametersAssignable(methodBinding.parameters, argumentTypes))
+ return new ProblemMethodBinding(
+ methodBinding,
+ selector,
+ argumentTypes,
+ NotFound);
+ if (!methodBinding.canBeSeenBy(currentType, invocationSite, this))
+ return new ProblemMethodBinding(
+ methodBinding,
+ selector,
+ methodBinding.parameters,
+ NotVisible);
+ }
+ return methodBinding;
+
+ } catch (AbortCompilation e) {
+ e.updateContext(invocationSite, referenceCompilationUnit().compilationResult);
+ throw e;
+ }
+ }
+
+ /* Answer the type binding that corresponds the given name, starting the lookup in the receiver.
+ * The name provided is a simple source name (e.g., "Object" , "Point", ...)
+ */
+ // The return type of this method could be ReferenceBinding if we did not answer base types.
+ // NOTE: We could support looking for Base Types last in the search, however any code using
+ // this feature would be extraordinarily slow. Therefore we don't do this
+ public final TypeBinding getType(char[] name) {
+ // Would like to remove this test and require senders to specially handle base types
+ TypeBinding binding = getBaseType(name);
+ if (binding != null) return binding;
+ return (ReferenceBinding) getTypeOrPackage(name, TYPE);
+ }
+
+ /* Answer the type binding corresponding to the compoundName.
+ *
+ * NOTE: If a problem binding is returned, senders should extract the compound name
+ * from the binding & not assume the problem applies to the entire compoundName.
+ */
+ public final TypeBinding getType(char[][] compoundName) {
+ int typeNameLength = compoundName.length;
+ if (typeNameLength == 1) {
+ // Would like to remove this test and require senders to specially handle base types
+ TypeBinding binding = getBaseType(compoundName[0]);
+ if (binding != null) return binding;
+ }
+
+ compilationUnitScope().recordQualifiedReference(compoundName);
+ Binding binding =
+ getTypeOrPackage(compoundName[0], typeNameLength == 1 ? TYPE : TYPE | PACKAGE);
+ if (binding == null)
+ return new ProblemReferenceBinding(compoundName[0], NotFound);
+ if (!binding.isValidBinding())
+ return (ReferenceBinding) binding;
+
+ int currentIndex = 1;
+ boolean checkVisibility = false;
+ if (binding instanceof PackageBinding) {
+ PackageBinding packageBinding = (PackageBinding) binding;
+ while (currentIndex < typeNameLength) {
+ binding = packageBinding.getTypeOrPackage(compoundName[currentIndex++]); // does not check visibility
+ if (binding == null)
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ NotFound);
+ if (!binding.isValidBinding())
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ binding.problemId());
+ if (!(binding instanceof PackageBinding))
+ break;
+ packageBinding = (PackageBinding) binding;
+ }
+ if (binding instanceof PackageBinding)
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ NotFound);
+ checkVisibility = true;
+ }
+
+ // binding is now a ReferenceBinding
+ ReferenceBinding typeBinding = (ReferenceBinding) binding;
+ compilationUnitScope().recordTypeReference(typeBinding); // to record supertypes
+ if (checkVisibility) // handles the fall through case
+ if (!typeBinding.canBeSeenBy(this))
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ typeBinding,
+ NotVisible);
+
+ while (currentIndex < typeNameLength) {
+ typeBinding = getMemberType(compoundName[currentIndex++], typeBinding);
+ if (!typeBinding.isValidBinding()) {
+ if (typeBinding instanceof ProblemReferenceBinding) {
+ ProblemReferenceBinding problemBinding = (ProblemReferenceBinding) typeBinding;
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ problemBinding.original,
+ typeBinding.problemId());
+ }
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ typeBinding.problemId());
+ }
+ }
+ return typeBinding;
+ }
+
+ /* Internal use only
+ */
+ final Binding getTypeOrPackage(char[] name, int mask) {
+ Scope scope = this;
+ ReferenceBinding foundType = null;
+ if ((mask & TYPE) == 0) {
+ Scope next = scope;
+ while ((next = scope.parent) != null)
+ scope = next;
+ } else {
+ done : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
+ switch (scope.kind) {
+ case METHOD_SCOPE :
+ case BLOCK_SCOPE :
+ ReferenceBinding localType = ((BlockScope) scope).findLocalType(name); // looks in this scope only
+ if (localType != null) {
+ if (foundType != null && foundType != localType)
+ return new ProblemReferenceBinding(name, InheritedNameHidesEnclosingName);
+ return localType;
+ }
+ break;
+ case CLASS_SCOPE :
+ SourceTypeBinding sourceType = ((ClassScope) scope).referenceContext.binding;
+ // 6.5.5.1 - simple name favors member type over top-level type in same unit
+ ReferenceBinding memberType = findMemberType(name, sourceType);
+ if (memberType != null) { // skip it if we did not find anything
+ if (memberType.problemId() == Ambiguous) {
+ if (foundType == null || foundType.problemId() == NotVisible)
+ // supercedes any potential InheritedNameHidesEnclosingName problem
+ return memberType;
+ // make the user qualify the type, likely wants the first inherited type
+ return new ProblemReferenceBinding(name, InheritedNameHidesEnclosingName);
+ }
+ if (memberType.isValidBinding()) {
+ if (sourceType == memberType.enclosingType()
+ || environment().options.complianceLevel >= ClassFileConstants.JDK1_4) {
+ // found a valid type in the 'immediate' scope (ie. not inherited)
+ // OR in 1.4 mode (inherited shadows enclosing)
+ if (foundType == null)
+ return memberType;
+ if (foundType.isValidBinding())
+ // if a valid type was found, complain when another is found in an 'immediate' enclosing type (ie. not inherited)
+ if (foundType != memberType)
+ return new ProblemReferenceBinding(name, InheritedNameHidesEnclosingName);
+ }
+ }
+ if (foundType == null || (foundType.problemId() == NotVisible && memberType.problemId() != NotVisible))
+ // only remember the memberType if its the first one found or the previous one was not visible & memberType is...
+ foundType = memberType;
+ }
+ if (CharOperation.equals(sourceType.sourceName, name)) {
+ if (foundType != null && foundType != sourceType && foundType.problemId() != NotVisible)
+ return new ProblemReferenceBinding(name, InheritedNameHidesEnclosingName);
+ return sourceType;
+ }
+ break;
+ case COMPILATION_UNIT_SCOPE :
+ break done;
+ }
+ scope = scope.parent;
+ }
+ if (foundType != null && foundType.problemId() != NotVisible)
+ return foundType;
+ }
+
+ // at this point the scope is a compilation unit scope
+ CompilationUnitScope unitScope = (CompilationUnitScope) scope;
+ PackageBinding currentPackage = unitScope.fPackage;
+ // ask for the imports + name
+ if ((mask & TYPE) != 0) {
+ // check single type imports.
+
+ ImportBinding[] imports = unitScope.imports;
+ if (imports != null) {
+ HashtableOfObject typeImports = unitScope.resolvedSingeTypeImports;
+ if (typeImports != null) {
+ ImportBinding typeImport = (ImportBinding) typeImports.get(name);
+ if (typeImport != null) {
+ ImportReference importReference = typeImport.reference;
+ if (importReference != null) importReference.used = true;
+ return typeImport.resolvedImport; // already know its visible
+ }
+ } else {
+ // walk all the imports since resolvedSingeTypeImports is not yet initialized
+ for (int i = 0, length = imports.length; i < length; i++) {
+ ImportBinding typeImport = imports[i];
+ if (!typeImport.onDemand) {
+ if (CharOperation.equals(typeImport.compoundName[typeImport.compoundName.length - 1], name)) {
+ if (unitScope.resolveSingleTypeImport(typeImport) != null) {
+ ImportReference importReference = typeImport.reference;
+ if (importReference != null) importReference.used = true;
+ return typeImport.resolvedImport; // already know its visible
+ }
+ }
+ }
+ }
+ }
+ }
+ // check if the name is in the current package, skip it if its a sub-package
+ unitScope.recordReference(currentPackage.compoundName, name);
+ Binding binding = currentPackage.getTypeOrPackage(name);
+ if (binding instanceof ReferenceBinding) return binding; // type is always visible to its own package
+
+ // check on demand imports
+ if (imports != null) {
+ boolean foundInImport = false;
+ ReferenceBinding type = null;
+ for (int i = 0, length = imports.length; i < length; i++) {
+ ImportBinding someImport = imports[i];
+ if (someImport.onDemand) {
+ Binding resolvedImport = someImport.resolvedImport;
+ ReferenceBinding temp = resolvedImport instanceof PackageBinding
+ ? findType(name, (PackageBinding) resolvedImport, currentPackage)
+ : findDirectMemberType(name, (ReferenceBinding) resolvedImport);
+ if (temp != null) {
+ if (temp.isValidBinding()) {
+ ImportReference importReference = someImport.reference;
+ if (importReference != null) importReference.used = true;
+ if (foundInImport)
+ // Answer error binding -- import on demand conflict; name found in two import on demand packages.
+ return new ProblemReferenceBinding(name, Ambiguous);
+ type = temp;
+ foundInImport = true;
+ } else if (foundType == null) {
+ foundType = temp;
+ }
+ }
+ }
+ }
+ if (type != null) return type;
+ }
+ }
+
+ unitScope.recordSimpleReference(name);
+ if ((mask & PACKAGE) != 0) {
+ PackageBinding packageBinding = unitScope.environment.getTopLevelPackage(name);
+ if (packageBinding != null) return packageBinding;
+ }
+
+ // Answer error binding -- could not find name
+ if (foundType != null) return foundType; // problem type from above
+ return new ProblemReferenceBinding(name, NotFound);
+ }
+
+ // Added for code assist... NOT Public API
+ public final Binding getTypeOrPackage(char[][] compoundName) {
+ int nameLength = compoundName.length;
+ if (nameLength == 1) {
+ TypeBinding binding = getBaseType(compoundName[0]);
+ if (binding != null) return binding;
+ }
+ Binding binding = getTypeOrPackage(compoundName[0], TYPE | PACKAGE);
+ if (!binding.isValidBinding()) return binding;
+
+ int currentIndex = 1;
+ boolean checkVisibility = false;
+ if (binding instanceof PackageBinding) {
+ PackageBinding packageBinding = (PackageBinding) binding;
+
+ while (currentIndex < nameLength) {
+ binding = packageBinding.getTypeOrPackage(compoundName[currentIndex++]);
+ if (binding == null)
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ NotFound);
+ if (!binding.isValidBinding())
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ binding.problemId());
+ if (!(binding instanceof PackageBinding))
+ break;
+ packageBinding = (PackageBinding) binding;
+ }
+ if (binding instanceof PackageBinding) return binding;
+ checkVisibility = true;
+ }
+ // binding is now a ReferenceBinding
+ ReferenceBinding typeBinding = (ReferenceBinding) binding;
+ if (checkVisibility) // handles the fall through case
+ if (!typeBinding.canBeSeenBy(this))
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ typeBinding,
+ NotVisible);
+
+ while (currentIndex < nameLength) {
+ typeBinding = getMemberType(compoundName[currentIndex++], typeBinding);
+ // checks visibility
+ if (!typeBinding.isValidBinding())
+ return new ProblemReferenceBinding(
+ CharOperation.subarray(compoundName, 0, currentIndex),
+ typeBinding.problemId());
+ }
+ return typeBinding;
+ }
+
+ /* Answer true if the scope is nested inside a given field declaration.
+ * Note: it works as long as the scope.fieldDeclarationIndex is reflecting the field being traversed
+ * e.g. during name resolution.
+ */
+ public final boolean isDefinedInField(FieldBinding field) {
+ Scope scope = this;
+ do {
+ if (scope instanceof MethodScope) {
+ MethodScope methodScope = (MethodScope) scope;
+ if (methodScope.initializedField == field) return true;
+ }
+ scope = scope.parent;
+ } while (scope != null);
+ return false;
+ }
+
+ /* Answer true if the scope is nested inside a given method declaration
+ */
+ public final boolean isDefinedInMethod(MethodBinding method) {
+ Scope scope = this;
+ do {
+ if (scope instanceof MethodScope) {
+ ReferenceContext refContext = ((MethodScope) scope).referenceContext;
+ if (refContext instanceof AbstractMethodDeclaration
+ && ((AbstractMethodDeclaration)refContext).binding == method) {
+ return true;
+ }
+ }
+ scope = scope.parent;
+ } while (scope != null);
+ return false;
+ }
+
+ /* Answer whether the type is defined in the same compilation unit as the receiver
+ */
+ public final boolean isDefinedInSameUnit(ReferenceBinding type) {
+ // find the outer most enclosing type
+ ReferenceBinding enclosingType = type;
+ while ((type = enclosingType.enclosingType()) != null)
+ enclosingType = type;
+
+ // find the compilation unit scope
+ Scope scope, unitScope = this;
+ while ((scope = unitScope.parent) != null)
+ unitScope = scope;
+
+ // test that the enclosingType is not part of the compilation unit
+ SourceTypeBinding[] topLevelTypes =
+ ((CompilationUnitScope) unitScope).topLevelTypes;
+ for (int i = topLevelTypes.length; --i >= 0;)
+ if (topLevelTypes[i] == enclosingType)
+ return true;
+ return false;
+ }
+
+ /* Answer true if the scope is nested inside a given type declaration
+ */
+ public final boolean isDefinedInType(ReferenceBinding type) {
+ Scope scope = this;
+ do {
+ if (scope instanceof ClassScope)
+ if (((ClassScope) scope).referenceContext.binding == type){
+ return true;
+ }
+ scope = scope.parent;
+ } while (scope != null);
+ return false;
+ }
+
+ public boolean isInsideDeprecatedCode(){
+ switch(this.kind){
+ case Scope.BLOCK_SCOPE :
+ case Scope.METHOD_SCOPE :
+ MethodScope methodScope = methodScope();
+ if (!methodScope.isInsideInitializer()){
+ // check method modifiers to see if deprecated
+ MethodBinding context = ((AbstractMethodDeclaration)methodScope.referenceContext).binding;
+ if (context != null && context.isViewedAsDeprecated()) {
+ return true;
+ }
+ } else {
+ SourceTypeBinding type = ((BlockScope)this).referenceType().binding;
+ // inside field declaration ? check field modifier to see if deprecated
+ if (methodScope.initializedField != null && methodScope.initializedField.isViewedAsDeprecated()) {
+ return true;
+ }
+ if (type != null && type.isViewedAsDeprecated()) {
+ return true;
+ }
+ }
+ break;
+ case Scope.CLASS_SCOPE :
+ ReferenceBinding context = ((ClassScope)this).referenceType().binding;
+ if (context != null && context.isViewedAsDeprecated()) {
+ return true;
+ }
+ break;
+ }
+ return false;
+ }
+
+ public final MethodScope methodScope() {
+ Scope scope = this;
+ do {
+ if (scope instanceof MethodScope)
+ return (MethodScope) scope;
+ scope = scope.parent;
+ } while (scope != null);
+ return null;
+ }
+
+ // Internal use only
+ /* All methods in visible are acceptable matches for the method in question...
+ * The methods defined by the receiver type appear before those defined by its
+ * superclass and so on. We want to find the one which matches best.
+ *
+ * Since the receiver type is a class, we know each method's declaring class is
+ * either the receiver type or one of its superclasses. It is an error if the best match
+ * is defined by a superclass, when a lesser match is defined by the receiver type
+ * or a closer superclass.
+ */
+ protected final MethodBinding mostSpecificClassMethodBinding(MethodBinding[] visible, int visibleSize) {
+
+ MethodBinding method = null;
+ MethodBinding previous = null;
+
+ nextVisible : for (int i = 0; i < visibleSize; i++) {
+ method = visible[i];
+
+ if (previous != null && method.declaringClass != previous.declaringClass)
+ break; // cannot answer a method farther up the hierarchy than the first method found
+ if (!method.isStatic()) previous = method; // no ambiguity for static methods
+ for (int j = 0; j < visibleSize; j++) {
+ if (i == j) continue;
+ MethodBinding next = visible[j];
+ if (!areParametersAssignable(next.parameters, method.parameters))
+ continue nextVisible;
+ }
+ compilationUnitScope().recordTypeReferences(method.thrownExceptions);
+ return method;
+ }
+ return new ProblemMethodBinding(visible[0].selector, visible[0].parameters, Ambiguous);
+ }
+
+ // Internal use only
+ /* All methods in visible are acceptable matches for the method in question...
+ * Since the receiver type is an interface, we ignore the possibility that 2 inherited
+ * but unrelated superinterfaces may define the same method in acceptable but
+ * not identical ways... we just take the best match that we find since any class which
+ * implements the receiver interface MUST implement all signatures for the method...
+ * in which case the best match is correct.
+ *
+ * NOTE: This is different than javac... in the following example, the message send of
+ * bar(X) in class Y is supposed to be ambiguous. But any class which implements the
+ * interface I MUST implement both signatures for bar. If this class was the receiver of
+ * the message send instead of the interface I, then no problem would be reported.
+ *
+ interface I1 {
+ void bar(J j);
+ }
+ interface I2 {
+ // void bar(J j);
+ void bar(Object o);
+ }
+ interface I extends I1, I2 {}
+ interface J {}
+
+ class X implements J {}
+
+ class Y extends X {
+ public void foo(I i, X x) { i.bar(x); }
+ }
+ */
+ protected final MethodBinding mostSpecificInterfaceMethodBinding(MethodBinding[] visible, int visibleSize) {
+ MethodBinding method = null;
+ nextVisible : for (int i = 0; i < visibleSize; i++) {
+ method = visible[i];
+ for (int j = 0; j < visibleSize; j++) {
+ if (i == j) continue;
+ MethodBinding next = visible[j];
+ if (!areParametersAssignable(next.parameters, method.parameters))
+ continue nextVisible;
+ }
+ compilationUnitScope().recordTypeReferences(method.thrownExceptions);
+ return method;
+ }
+ return new ProblemMethodBinding(visible[0].selector, visible[0].parameters, Ambiguous);
+ }
+
+
+ // Internal use only
+ /* All methods in visible are acceptable matches for the method in question...
+ * Since 1.4, the inherited ambiguous case has been removed from mostSpecificClassMethodBinding
+ */
+ protected final MethodBinding mostSpecificMethodBinding(MethodBinding[] visible, int visibleSize) {
+ MethodBinding method = null;
+ nextVisible : for (int i = 0; i < visibleSize; i++) {
+ method = visible[i];
+ for (int j = 0; j < visibleSize; j++) {
+ if (i == j) continue;
+ MethodBinding next = visible[j];
+ if (!areParametersAssignable(next.parameters, method.parameters))
+ continue nextVisible;
+ }
+ compilationUnitScope().recordTypeReferences(method.thrownExceptions);
+ return method;
+ }
+ return new ProblemMethodBinding(visible[0].selector, visible[0].parameters, Ambiguous);
+ }
+
+ public final ClassScope outerMostClassScope() {
+ ClassScope lastClassScope = null;
+ Scope scope = this;
+ do {
+ if (scope instanceof ClassScope)
+ lastClassScope = (ClassScope) scope;
+ scope = scope.parent;
+ } while (scope != null);
+ return lastClassScope; // may answer null if no class around
+ }
+
+ public final MethodScope outerMostMethodScope() {
+ MethodScope lastMethodScope = null;
+ Scope scope = this;
+ do {
+ if (scope instanceof MethodScope)
+ lastMethodScope = (MethodScope) scope;
+ scope = scope.parent;
+ } while (scope != null);
+ return lastMethodScope; // may answer null if no method around
+ }
+
+ public abstract ProblemReporter problemReporter();
+
+ public final CompilationUnitDeclaration referenceCompilationUnit() {
+ Scope scope, unitScope = this;
+ while ((scope = unitScope.parent) != null)
+ unitScope = scope;
+ return ((CompilationUnitScope) unitScope).referenceContext;
+ }
+ // start position in this scope - for ordering scopes vs. variables
+ int startIndex() {
+ return 0;
+ }
+
+ /**
+ * Returns the immediately enclosing switchCase statement (carried by closest blockScope),
+ */
+ public CaseStatement switchCase() {
+ Scope scope = this;
+ do {
+ if (scope instanceof BlockScope)
+ return ((BlockScope) scope).switchCase;
+ scope = scope.parent;
+ } while (scope != null);
+ return null;
+ }
+}
projects / org.ibex.tool.git / blobdiff