Attachment 100659 Details for Bug 231861 – Patch for suggested cleanup (post 3.4)

[patch] Patch for suggested cleanup (post 3.4)

231861-cleanup.txt (text/plain), 24.36 KB, created by Philipe Mulet

on 2008-05-16 11:44:25 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Philipe Mulet

Created: 2008-05-16 11:44:25 EDT

Size: 24.36 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java,v
>retrieving revision 1.110
>diff -u -r1.110 BinaryTypeBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java	22 Feb 2008 09:49:37 -0000	1.110
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java	16 May 2008 15:43:41 -0000
>@@ -55,14 +55,14 @@
> 		if (typeFromSignature.isBaseType()) {
> 			return typeFromSignature;
> 		}
>-		return resolveType((ReferenceBinding) typeFromSignature, env, false);
>+		return resolveType(typeFromSignature, env, false /* no raw conversion */);
> 	}
> 	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);
>+		enumType = (ReferenceBinding) resolveType(enumType, env, false /* no raw conversion */);
> 		return enumType.getField(ref.getEnumConstantName(), false);
> 	}
> 	if (binaryValue instanceof Object[]) {
>@@ -78,6 +78,7 @@
> 	// 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;
>@@ -89,6 +90,7 @@
> 	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];
>@@ -96,32 +98,19 @@
> 		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) {
>+
>+public static TypeBinding resolveType(TypeBinding type, LookupEnvironment environment, boolean convertGenericToRawType) {
> 	switch (type.kind()) {
>-		
> 		case Binding.PARAMETERIZED_TYPE :
>-			return ((ParameterizedTypeBinding) type).resolve();
>-			
>+			((ParameterizedTypeBinding) type).resolve();
>+			break;
>+
> 		case Binding.WILDCARD_TYPE :
> 		case Binding.INTERSECTION_TYPE :
> 			return ((WildcardBinding) type).resolve();
> 			
> 		case Binding.ARRAY_TYPE :
>-			resolveType(((ArrayBinding) type).leafComponentType, environment, parameterizedType, rank);
>+			resolveType(((ArrayBinding) type).leafComponentType, environment, convertGenericToRawType);
> 			break;
> 			
> 		case Binding.TYPE_PARAMETER :
>@@ -129,13 +118,16 @@
> 			break;
> 						
> 		case Binding.GENERIC_TYPE :
>-			if (parameterizedType == null) // raw reference to generic ?
>+			if (convertGenericToRawType) // raw reference to generic ?
> 				return environment.convertUnresolvedBinaryToRawType(type);
> 			break;
>-			
>-		default:			
>+
>+		default:
> 			if (type instanceof UnresolvedReferenceBinding)
>-				return ((UnresolvedReferenceBinding) type).resolve(environment, parameterizedType == null);
>+				return ((UnresolvedReferenceBinding) type).resolve(environment, convertGenericToRawType);
>+			if (convertGenericToRawType) // raw reference to generic ?
>+				return environment.convertUnresolvedBinaryToRawType(type);
>+			break;
> 	}
> 	return type;
> }
>@@ -251,6 +243,7 @@
> 		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).
>@@ -338,6 +331,7 @@
> 	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) {
>@@ -387,6 +381,7 @@
> 		}
> 	}
> }
>+
> private MethodBinding createMethod(IBinaryMethod method, long sourceLevel, char[][][] missingTypeNames) {
> 	int methodModifiers = method.getModifiers() | ExtraCompilerModifiers.AccUnresolved;
> 	if (sourceLevel < ClassFileConstants.JDK1_5)
>@@ -523,6 +518,7 @@
> 		typeVars[i].declaringElement = result;
> 	return result;
> }
>+
> /**
>  * Create method bindings for binary type, filtering out <clinit> and synthetics
>  */
>@@ -582,6 +578,7 @@
> 		}
> 	}
> }
>+
> private TypeVariableBinding[] createTypeVariables(SignatureWrapper wrapper, boolean assignVariables, char[][][] missingTypeNames) {
> 	// detect all type variables first
> 	char[] typeSignature = wrapper.signature;
>@@ -626,6 +623,7 @@
> 	}
> 	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
>@@ -635,7 +633,7 @@
> 		return this.enclosingType;
> 
> 	// finish resolving the type
>-	this.enclosingType = resolveType(this.enclosingType, this.environment, false);
>+	this.enclosingType = (ReferenceBinding) resolveType(this.enclosingType, this.environment, false /* no raw conversion */);
> 	this.tagBits &= ~TagBits.HasUnresolvedEnclosingType;
> 	return this.enclosingType;
> }
>@@ -656,12 +654,14 @@
> 	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) {
> 
>@@ -759,7 +759,7 @@
> 			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
>+					return this.memberTypes[i] = (ReferenceBinding) resolveType(memberType, this.environment, false /* no raw conversion for now */);
> 	    } else if (CharOperation.equals(typeName, memberType.sourceName)) {
> 	        return memberType;
> 	    }
>@@ -875,7 +875,7 @@
> 		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.memberTypes[i] = (ReferenceBinding) resolveType(this.memberTypes[i], this.environment, false /* no raw conversion for now */);
> 	this.tagBits &= ~TagBits.HasUnresolvedMemberTypes;
> 	return this.memberTypes;
> }
>@@ -900,7 +900,7 @@
> 	if ((field.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
> 		return field;
> 
>-	TypeBinding resolvedType = resolveType(field.type, this.environment, null, 0);
>+	TypeBinding resolvedType = resolveType(field.type, this.environment, true /* raw conversion */);
> 	field.type = resolvedType;
> 	if ((resolvedType.tagBits & TagBits.HasMissingType) != 0) {
> 		field.tagBits |= TagBits.HasMissingType;
>@@ -913,21 +913,21 @@
> 		return method;
> 
> 	if (!method.isConstructor()) {
>-		TypeBinding resolvedType = resolveType(method.returnType, this.environment, null, 0);
>+		TypeBinding resolvedType = resolveType(method.returnType, this.environment, true /* raw conversion */);
> 		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);
>+		TypeBinding resolvedType = resolveType(method.parameters[i], this.environment, true /* raw conversion */);
> 		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);
>+		ReferenceBinding resolvedType = (ReferenceBinding) resolveType(method.thrownExceptions[i], this.environment, true /* raw conversion */);
> 		method.thrownExceptions[i] = resolvedType;
> 		if ((resolvedType.tagBits & TagBits.HasMissingType) != 0) {
> 			method.tagBits |= TagBits.HasMissingType;
>@@ -959,7 +959,7 @@
> 		return this.superclass;
> 
> 	// finish resolving the type
>-	this.superclass = resolveType(this.superclass, this.environment, true);
>+	this.superclass = (ReferenceBinding) resolveType(this.superclass, this.environment, true /* raw conversion */);
> 	this.tagBits &= ~TagBits.HasUnresolvedSuperclass;
> 	if (this.superclass.problemId() == ProblemReasons.NotFound)
> 		this.tagBits |= TagBits.HierarchyHasProblems; // propagate type inconsistency
>@@ -971,7 +971,7 @@
> 		return this.superInterfaces;
> 
> 	for (int i = this.superInterfaces.length; --i >= 0;) {
>-		this.superInterfaces[i] = resolveType(this.superInterfaces[i], this.environment, true);
>+		this.superInterfaces[i] = (ReferenceBinding) resolveType(this.superInterfaces[i], this.environment, true /* raw conversion */);
> 		if (this.superInterfaces[i].problemId() == ProblemReasons.NotFound)
> 			this.tagBits |= TagBits.HierarchyHasProblems; // propagate type inconsistency
> 	}
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java,v
>retrieving revision 1.104
>diff -u -r1.104 ParameterizedTypeBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java	16 May 2008 15:11:14 -0000	1.104
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java	16 May 2008 15:43:41 -0000
>@@ -830,11 +830,11 @@
> 			return this;
> 
> 		this.tagBits &= ~TagBits.HasUnresolvedTypeVariables; // can be recursive so only want to call once
>-		ReferenceBinding resolvedType = BinaryTypeBinding.resolveType(this.type, this.environment, false); // still part of parameterized type ref
>+		ReferenceBinding resolvedType = (ReferenceBinding) BinaryTypeBinding.resolveType(this.type, this.environment, false /* no raw conversion */); // still part of parameterized type ref
> 		if (this.arguments != null) {
> 			int argLength = this.arguments.length;
> 			for (int i = 0; i < argLength; i++)
>-				this.arguments[i] = BinaryTypeBinding.resolveType(this.arguments[i], this.environment, null, 0);
>+				this.arguments[i] = BinaryTypeBinding.resolveType(this.arguments[i], this.environment, true /* raw conversion */);
> 			// arity check
> 			TypeVariableBinding[] refTypeVariables = resolvedType.typeVariables();
> 			if (refTypeVariables == Binding.NO_TYPE_VARIABLES) { // check generic
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java,v
>retrieving revision 1.94
>diff -u -r1.94 MethodVerifier.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java	29 Feb 2008 21:17:55 -0000	1.94
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java	16 May 2008 15:43:41 -0000
>@@ -848,7 +848,7 @@
> 		return Binding.NO_EXCEPTIONS; // safety check
> 
> 	for (int i = exceptions.length; --i >= 0;)
>-		exceptions[i] = BinaryTypeBinding.resolveType(exceptions[i], this.environment, true);
>+		exceptions[i] = (ReferenceBinding) BinaryTypeBinding.resolveType(exceptions[i], this.environment, true /* raw conversion */);
> 	return exceptions;
> }
> 
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedAnnotationBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedAnnotationBinding.java,v
>retrieving revision 1.3
>diff -u -r1.3 UnresolvedAnnotationBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedAnnotationBinding.java	6 Sep 2006 04:58:45 -0000	1.3
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedAnnotationBinding.java	16 May 2008 15:43:42 -0000
>@@ -21,7 +21,7 @@
> 
> public ReferenceBinding getAnnotationType() {
> 	if (this.typeUnresolved) { // the type is resolved when requested
>-		this.type = BinaryTypeBinding.resolveType(this.type, this.env, false);
>+		this.type = (ReferenceBinding) BinaryTypeBinding.resolveType(this.type, this.env, false /* no raw conversion for now */);
> 			// annotation type are never parameterized
> 		this.typeUnresolved = false;
> 	}
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/PackageBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/PackageBinding.java,v
>retrieving revision 1.43
>diff -u -r1.43 PackageBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/PackageBinding.java	22 Feb 2008 09:49:37 -0000	1.43
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/PackageBinding.java	16 May 2008 15:43:41 -0000
>@@ -122,22 +122,22 @@
> */
> 
> ReferenceBinding getType(char[] name) {
>-	ReferenceBinding typeBinding = getType0(name);
>-	if (typeBinding == null) {
>-		if ((typeBinding = environment.askForType(this, name)) == null) {
>+	ReferenceBinding referenceBinding = getType0(name);
>+	if (referenceBinding == null) {
>+		if ((referenceBinding = environment.askForType(this, name)) == null) {
> 			// not found so remember a problem type binding in the cache for future lookups
> 			addNotFoundType(name);
> 			return null;
> 		}
> 	}
> 
>-	if (typeBinding == LookupEnvironment.TheNotFoundType)
>+	if (referenceBinding == LookupEnvironment.TheNotFoundType)
> 		return null;
> 
>-	typeBinding = BinaryTypeBinding.resolveType(typeBinding, environment, false); // no raw conversion for now
>-	if (typeBinding.isNestedType())
>-		return new ProblemReferenceBinding(new char[][]{ name }, typeBinding, ProblemReasons.InternalNameProvided);
>-	return typeBinding;
>+	referenceBinding = (ReferenceBinding) BinaryTypeBinding.resolveType(referenceBinding, environment, false /* no raw conversion for now */);
>+	if (referenceBinding.isNestedType())
>+		return new ProblemReferenceBinding(new char[][]{ name }, referenceBinding, ProblemReasons.InternalNameProvided);
>+	return referenceBinding;
> }
> /* Answer the type named name if it exists in the cache.
> * Answer theNotFoundType if it could not be resolved the first time
>@@ -163,23 +163,23 @@
> */
> 
> public Binding getTypeOrPackage(char[] name) {
>-	ReferenceBinding typeBinding = getType0(name);
>-	if (typeBinding != null && typeBinding != LookupEnvironment.TheNotFoundType) {
>-		typeBinding = BinaryTypeBinding.resolveType(typeBinding, environment, false); // no raw conversion for now
>-		if (typeBinding.isNestedType())
>-			return new ProblemReferenceBinding(new char[][]{name}, typeBinding, ProblemReasons.InternalNameProvided);
>-		return typeBinding;
>+	ReferenceBinding referenceBinding = getType0(name);
>+	if (referenceBinding != null && referenceBinding != LookupEnvironment.TheNotFoundType) {
>+		referenceBinding = (ReferenceBinding) BinaryTypeBinding.resolveType(referenceBinding, environment, false /* no raw conversion for now */);
>+		if (referenceBinding.isNestedType())
>+			return new ProblemReferenceBinding(new char[][]{name}, referenceBinding, ProblemReasons.InternalNameProvided);
>+		return referenceBinding;
> 	}
> 
> 	PackageBinding packageBinding = getPackage0(name);
> 	if (packageBinding != null && packageBinding != LookupEnvironment.TheNotFoundPackage)
> 		return packageBinding;
> 
>-	if (typeBinding == null) { // have not looked for it before
>-		if ((typeBinding = environment.askForType(this, name)) != null) {
>-			if (typeBinding.isNestedType())
>-				return new ProblemReferenceBinding(new char[][]{name}, typeBinding, ProblemReasons.InternalNameProvided);
>-			return typeBinding;
>+	if (referenceBinding == null) { // have not looked for it before
>+		if ((referenceBinding = environment.askForType(this, name)) != null) {
>+			if (referenceBinding.isNestedType())
>+				return new ProblemReferenceBinding(new char[][]{name}, referenceBinding, ProblemReasons.InternalNameProvided);
>+			return referenceBinding;
> 		}
> 
> 		// Since name could not be found, add a problem binding
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java,v
>retrieving revision 1.65
>diff -u -r1.65 TypeVariableBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java	12 Oct 2007 13:37:16 -0000	1.65
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java	16 May 2008 15:43:42 -0000
>@@ -373,13 +373,13 @@
> 
> 		TypeBinding oldSuperclass = this.superclass, oldFirstInterface = null;
> 		if (this.superclass != null)
>-			this.superclass = BinaryTypeBinding.resolveType(this.superclass, environment, true);
>+			this.superclass = (ReferenceBinding) BinaryTypeBinding.resolveType(this.superclass, environment, true /* raw conversion */);
> 		ReferenceBinding[] interfaces = this.superInterfaces;
> 		int length;
> 		if ((length = interfaces.length) != 0) {
> 			oldFirstInterface = interfaces[0];
> 			for (int i = length; --i >= 0;) {
>-				interfaces[i] = BinaryTypeBinding.resolveType(interfaces[i], environment, true);
>+				interfaces[i] = (ReferenceBinding) BinaryTypeBinding.resolveType(interfaces[i], environment, true /* raw conversion */);
> 			}
> 		}
> 		// refresh the firstBound in case it changed
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java,v
>retrieving revision 1.95
>diff -u -r1.95 LookupEnvironment.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java	11 Apr 2008 19:42:41 -0000	1.95
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java	16 May 2008 15:43:41 -0000
>@@ -1092,7 +1092,7 @@
> 
> 	if (referenceBinding == null || referenceBinding == TheNotFoundType)
> 		return null;
>-	referenceBinding = BinaryTypeBinding.resolveType(referenceBinding, this, false); // no raw conversion for now
>+	referenceBinding = (ReferenceBinding) BinaryTypeBinding.resolveType(referenceBinding, this, false /* no raw conversion for now */);
> 
> 	// compoundName refers to a nested type incorrectly (for example, package1.A$B)
> 	if (referenceBinding.isNestedType())
>@@ -1261,7 +1261,7 @@
> 	ReferenceBinding actualType = (ReferenceBinding) type;
> 	if (actualType instanceof UnresolvedReferenceBinding)
> 		if (CharOperation.indexOf('$', actualType.compoundName[actualType.compoundName.length - 1]) > 0)
>-			actualType = BinaryTypeBinding.resolveType(actualType, this, false); // must resolve member types before asking for enclosingType
>+			actualType = (ReferenceBinding) BinaryTypeBinding.resolveType(actualType, this, false /* no raw conversion */); // must resolve member types before asking for enclosingType
> 	ReferenceBinding actualEnclosing = actualType.enclosingType();
> 	if (actualEnclosing != null) { // convert needed if read some static member type
> 		actualEnclosing = (ReferenceBinding) convertToRawType(actualEnclosing, false /*do not force conversion of enclosing types*/);
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java,v
>retrieving revision 1.67
>diff -u -r1.67 WildcardBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java	27 Feb 2008 11:26:13 -0000	1.67
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java	16 May 2008 15:43:42 -0000
>@@ -489,16 +489,16 @@
> 			return this;
> 
> 		this.tagBits &= ~TagBits.HasUnresolvedTypeVariables;
>-		BinaryTypeBinding.resolveType(this.genericType, this.environment, null, 0); // do not assign to genericType field, since will return a raw type
>+		BinaryTypeBinding.resolveType(this.genericType, this.environment, false /* no raw conversion */); 
> 	    switch(this.boundKind) {
> 	        case Wildcard.EXTENDS :
>-				this.bound = BinaryTypeBinding.resolveType(this.bound, this.environment, null, 0);
>+				this.bound = BinaryTypeBinding.resolveType(this.bound, this.environment, true /* raw conversion */);
> 	        	for (int i = 0, length = this.otherBounds == null ? 0 : this.otherBounds.length; i < length; i++) {
>-					this.otherBounds[i]= BinaryTypeBinding.resolveType(this.bound, this.environment, null, 0);
>+					this.otherBounds[i]= BinaryTypeBinding.resolveType(this.bound, this.environment, true /* raw conversion */);
> 	        	}
> 				break;
> 	        case Wildcard.SUPER :
>-				this.bound = BinaryTypeBinding.resolveType(this.bound, this.environment, null, 0);
>+				this.bound = BinaryTypeBinding.resolveType(this.bound, this.environment, true /* raw conversion */);
> 				break;
> 			case Wildcard.UNBOUND :
> 	    }
>Index: codeassist/org/eclipse/jdt/internal/codeassist/InternalExtendedCompletionContext.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/InternalExtendedCompletionContext.java,v
>retrieving revision 1.4
>diff -u -r1.4 InternalExtendedCompletionContext.java
>--- codeassist/org/eclipse/jdt/internal/codeassist/InternalExtendedCompletionContext.java	12 May 2008 15:25:57 -0000	1.4
>+++ codeassist/org/eclipse/jdt/internal/codeassist/InternalExtendedCompletionContext.java	16 May 2008 15:43:41 -0000
>@@ -316,7 +316,7 @@
> 			SignatureWrapper wrapper = new SignatureWrapper(replacePackagesDot(typeSignature.toCharArray()));
> 			assignableTypeBinding = lookupEnvironment.getTypeFromTypeSignature(wrapper, typeVariables, this.assistScope.enclosingClassScope().referenceContext.binding, null);
> 			if (assignableTypeBinding instanceof ReferenceBinding) {
>-				assignableTypeBinding = BinaryTypeBinding.resolveType((ReferenceBinding)assignableTypeBinding, lookupEnvironment, true);
>+				assignableTypeBinding = BinaryTypeBinding.resolveType(assignableTypeBinding, lookupEnvironment, true);
> 			}
> 		} catch (AbortCompilation e) {
> 			assignableTypeBinding = null;

Actions: View | Diff

Attachments on bug 231861: 99986 | 100553 | 100620 | 100652 | 100659 | 100663