Attachment 60210 Details for Bug 174588 – Working single walk

[patch] Working single walk

patch.txt (text/plain), 9.59 KB, created by Kent Johnson

on 2007-03-02 16:58:40 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Kent Johnson

Created: 2007-03-02 16:58:40 EST

Size: 9.59 KB

patch

obsolete

>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java,v
>retrieving revision 1.299
>diff -u -r1.299 Scope.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java	29 Jan 2007 07:37:02 -0000	1.299
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java	2 Mar 2007 21:52:21 -0000
>@@ -1035,16 +1035,17 @@
> 	// Internal use only - use findMethod()
> 	public MethodBinding findMethod(ReferenceBinding receiverType, char[] selector, TypeBinding[] argumentTypes, InvocationSite invocationSite) {
> 		ReferenceBinding currentType = receiverType;
>+		boolean receiverTypeIsInterface = receiverType.isInterface();
> 		ObjectVector found = new ObjectVector(3);
> 		CompilationUnitScope unitScope = compilationUnitScope();
> 		unitScope.recordTypeReferences(argumentTypes);
> 
>-		if (currentType.isInterface()) {
>-			unitScope.recordTypeReference(currentType);
>-			MethodBinding[] currentMethods = currentType.getMethods(selector);
>-			if (currentMethods.length > 0)
>-				found.addAll(currentMethods);
>-			findMethodInSuperInterfaces(currentType, selector, found);
>+		if (receiverTypeIsInterface) {
>+			unitScope.recordTypeReference(receiverType);
>+			MethodBinding[] receiverMethods = receiverType.getMethods(selector);
>+			if (receiverMethods.length > 0)
>+				found.addAll(receiverMethods);
>+			findMethodInSuperInterfaces(receiverType, selector, found);
> 			currentType = getJavaLangObject();
> 		}
> 
>@@ -1053,17 +1054,16 @@
> 		boolean isCompliant14 = complianceLevel >= ClassFileConstants.JDK1_4;
> 		boolean isCompliant15 = complianceLevel >= ClassFileConstants.JDK1_5;
> 		ReferenceBinding classHierarchyStart = currentType;
>-		boolean mustBePublic = receiverType.isInterface();
> 		while (currentType != null) {
> 			unitScope.recordTypeReference(currentType);
> 			MethodBinding[] currentMethods = currentType.getMethods(selector);
> 			int currentLength = currentMethods.length;
> 			if (currentLength > 0) {
>-				if (isCompliant14 && (mustBePublic || found.size > 0)) {
>+				if (isCompliant14 && (receiverTypeIsInterface || found.size > 0)) {
> 					nextMethod: for (int i = 0, l = currentLength; i < l; i++) { // currentLength can be modified inside the loop
> 						MethodBinding currentMethod = currentMethods[i];
> 						if (currentMethod == null) continue nextMethod;
>-						if (mustBePublic && !currentMethod.isPublic()) { // only public methods from Object are visible to interface receiverTypes
>+						if (receiverTypeIsInterface && !currentMethod.isPublic()) { // only public methods from Object are visible to interface receiverTypes
> 							currentLength--;
> 							currentMethods[i] = null;
> 							continue nextMethod;
>@@ -1109,6 +1109,18 @@
> 			currentType = currentType.superclass();
> 		}
> 
>+		boolean addInterfaceMethods = isCompliant14 && !receiverTypeIsInterface && classHierarchyStart.isAbstract() || classHierarchyStart.isTypeVariable();
>+		if (addInterfaceMethods) {
>+			// add interface methods to found
>+			// cannot be done until all matching methods in class hierarchy have been found
>+			// an interface method cannot prevent a concrete method from being considered as a match
>+			currentType = receiverType;
>+			while (currentType != null) {
>+				findMethodInSuperInterfaces(currentType, selector, found);
>+				currentType = currentType.superclass();
>+			}
>+		}
>+
> 		// if found several candidates, then eliminate those not matching argument types
> 		int foundSize = found.size;
> 		MethodBinding[] candidates = null;
>@@ -1123,9 +1135,6 @@
> 					if (compatibleMethod.isValidBinding()) {
> 						if (foundSize == 1 && compatibleMethod.canBeSeenBy(receiverType, invocationSite, this)) {
> 							// return the single visible match now
>-							if (isCompliant14 && (receiverType.isAbstract() || receiverType.isTypeVariable()))
>-								return findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, found, compatibleMethod);
>-							unitScope.recordTypeReferences(compatibleMethod.thrownExceptions);
> 							return compatibleMethod;
> 						}
> 						if (candidatesCount == 0)
>@@ -1138,15 +1147,22 @@
> 			}
> 		}
> 
>-		// no match was found, try to find a close match when the parameter order is wrong or missing some parameters
>+		// no match was found
> 		if (candidatesCount == 0) {
>-			// reduces secondary errors since missing interface method error is already reported
>-			MethodBinding interfaceMethod =
>-				findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, found, null);
>-			if (interfaceMethod != null) return interfaceMethod;
>+			// abstract classes may get a match in interfaces; for non abstract classes
>+			// reduces secondary errors since missing interface method 
>+			// error is already reported
>+			if (!addInterfaceMethods) {
>+				MethodBinding interfaceMethod =
>+					findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, found, null);
>+				if (interfaceMethod != null) return interfaceMethod;
>+			}
> 			if (found.size == 0) return null;
> 			if (problemMethod != null) return problemMethod;
> 
>+			// still no match; try to find a close match when the parameter 
>+			// order is wrong or missing some parameters
>+
> 			// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=69471
> 			// bad guesses are foo(), when argument types have been supplied
> 			// and foo(X, Y), when the argument types are (int, float, Y)
>@@ -1186,27 +1202,35 @@
> 
> 		// 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) {
>-			if (isCompliant14 && (receiverType.isAbstract() || receiverType.isTypeVariable()))
>-				return findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, found, candidates[0]);
>-			unitScope.recordTypeReferences(candidates[0].thrownExceptions);
>-			return candidates[0];
>-		}
>-		if (visiblesCount == 0) {
>-			MethodBinding interfaceMethod =
>-				findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, found, null);
>-			if (interfaceMethod != null) return interfaceMethod;
>-			return new ProblemMethodBinding(candidates[0], candidates[0].selector, candidates[0].parameters, ProblemReasons.NotVisible);
>+		if (receiverTypeIsInterface) {
>+			if (candidatesCount == 1) {
>+				unitScope.recordTypeReferences(candidates[0].thrownExceptions);
>+				return candidates[0];
>+			}
>+			visiblesCount = candidatesCount;
>+		} else {
>+			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) {
>+				unitScope.recordTypeReferences(candidates[0].thrownExceptions);
>+				return candidates[0];
>+			}
>+			if (visiblesCount == 0) {
>+				if (!addInterfaceMethods) {
>+					MethodBinding interfaceMethod =
>+						findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, found, null);
>+					if (interfaceMethod != null) return interfaceMethod;
>+				}
>+				return new ProblemMethodBinding(candidates[0], candidates[0].selector, candidates[0].parameters, ProblemReasons.NotVisible);
>+			}
> 		}
> 
> 		if (complianceLevel <= ClassFileConstants.JDK1_3) {
>@@ -1229,14 +1253,7 @@
> 			}
> 		}
> 
>-		MethodBinding mostSpecificMethod = mostSpecificMethodBinding(candidates, visiblesCount, argumentTypes, invocationSite, receiverType);
>-		if (isCompliant15
>-			&& mostSpecificMethod.isValidBinding()
>-			&& parameterCompatibilityLevel(mostSpecificMethod, argumentTypes) > COMPATIBLE) {
>-				// see if there is a better match in the interfaces - see AutoBoxingTest 99
>-				return findDefaultAbstractMethod(receiverType, selector, argumentTypes, invocationSite, classHierarchyStart, found, mostSpecificMethod);
>-		}
>-		return mostSpecificMethod;
>+		return mostSpecificMethodBinding(candidates, visiblesCount, argumentTypes, invocationSite, receiverType);
> 	}
> 
> 	// Internal use only
>@@ -1295,8 +1312,20 @@
> 				currentType = interfacesToVisit[i];
> 				compilationUnitScope().recordTypeReference(currentType);
> 				MethodBinding[] currentMethods = currentType.getMethods(selector);
>-				if (currentMethods.length > 0)
>-					found.addAll(currentMethods);
>+				if (currentMethods.length > 0) {
>+					int foundSize = found.size;
>+					if (foundSize > 0) {
>+						// its possible to walk the same superinterface from different classes in the hierarchy
>+						next : for (int c = 0, l = currentMethods.length; c < l; c++) {
>+							MethodBinding current = currentMethods[c];
>+							for (int f = 0; f < foundSize; f++)
>+								if (current == found.elementAt(f)) continue next;
>+							found.add(current);
>+						}
>+					} else {
>+						found.addAll(currentMethods);
>+					}
>+				}
> 				if ((itsInterfaces = currentType.superInterfaces()) != null && itsInterfaces != Binding.NO_SUPERINTERFACES) {
> 					int itsLength = itsInterfaces.length;
> 					if (nextPosition + itsLength >= interfacesToVisit.length)

Actions: View | Diff

Attachments on bug 174588: 59468 | 59545 | 59636 | 59643 | 60024 | 60148 | 60207 | 60210