Attachment #63416 for bug #180109

View | Details | Raw Unified | Return to bug 180109
Collapse All | Expand All




 */
public class ParameterizedTypeBinding extends ReferenceBinding implements Substitution {

	private ReferenceBinding type; // must ensure the type is resolved 
	public TypeBinding[] arguments;
	public LookupEnvironment environment; 
	public char[] genericTypeSignature;

//		}
		initialize(type, arguments);
		if (type instanceof UnresolvedReferenceBinding)
			((UnresolvedReferenceBinding) type).addWrapper(this, environment);
		if (arguments != null) {
			for (int i = 0, l = arguments.length; i < l; i++)
				if (arguments[i] instanceof UnresolvedReferenceBinding)
					((UnresolvedReferenceBinding) arguments[i]).addWrapper(this, environment);
		}
		this.tagBits |=  TagBits.HasUnresolvedTypeVariables; // cleared in resolve()
	}

		}		
		return this.methods;
	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#qualifiedPackageName()
	 */
	public char[] qualifiedPackageName() {
		return this.type.qualifiedPackageName();
	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#qualifiedSourceName()
	 */

		return this;
	}

	public ReferenceBinding genericType() {
		if (this.type instanceof UnresolvedReferenceBinding)
			((UnresolvedReferenceBinding) this.type).resolve(this.environment, false);
		return this.type;
	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.lookup.Binding#shortReadableName()
	 */

	}

	/**
	 * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#qualifiedPackageName()
	 */
	public char[] qualifiedPackageName() {
		return this.type.qualifiedPackageName();
	}

	/**
	 * @see java.lang.Object#toString()
	 */
	public String toString() {

		
	}

	protected ReferenceBinding type() {
		// can be an UnresolvedReferenceBinding
		// most clients should call resolveType()
		return this.type; 
	}

	public TypeVariableBinding[] typeVariables() {
		if (this.arguments == null) {
			// retain original type variables if not substituted (member type of parameterized type)




			// abstract class X<K,V> implements java.util.Map<K,V>
			//    static abstract class M<K,V> implements Entry<K,V>
			if (superType.isParameterizedType())
				superType = ((ParameterizedTypeBinding) superType).genericType();
			compilationUnitScope().recordSuperTypeReference(superType); // to record supertypes
			return detectHierarchyCycle(referenceContext.binding, (ReferenceBinding) superType, reference);
		}

	// Answer whether a cycle was found between the sourceType & the superType
	private boolean detectHierarchyCycle(SourceTypeBinding sourceType, ReferenceBinding superType, TypeReference reference) {
		if (superType.isRawType())
			superType = ((RawTypeBinding) superType).genericType();
		// by this point the superType must be a binary or source type

		if (sourceType == superType) {

					return true;
				}
				if (parentType.isParameterizedType())
					parentType = ((ParameterizedTypeBinding) parentType).genericType();
				hasCycle |= detectHierarchyCycle(sourceType, parentType, reference);
				if ((parentType.tagBits & TagBits.HierarchyHasProblems) != 0) {
					sourceType.tagBits |= TagBits.HierarchyHasProblems;

						return true;
					}
					if (anInterface.isParameterizedType())
						anInterface = ((ParameterizedTypeBinding) anInterface).genericType();
					hasCycle |= detectHierarchyCycle(sourceType, anInterface, reference);
					if ((anInterface.tagBits & TagBits.HierarchyHasProblems) != 0) {
						sourceType.tagBits |= TagBits.HierarchyHasProblems;




		    for (int i = 0; i < typeSig.length-1; i++) sig.append(typeSig[i]); // copy all but trailing semicolon
		    sig.append('.').append(sourceName()).append('<').append('>').append(';');
		} else {
		     sig.append(genericType().computeUniqueKey(false/*not a leaf*/));
		     sig.insert(sig.length()-1, "<>"); //$NON-NLS-1$
		}


	 */
	public String debugName() {
	    StringBuffer nameBuffer = new StringBuffer(10);
		nameBuffer.append(type().sourceName()).append("#RAW"); //$NON-NLS-1$
	    return nameBuffer.toString();		
	}	


				this.genericTypeSignature = new char[sigLength];
				sig.getChars(0, sigLength, this.genericTypeSignature, 0);						    
			} else {
			     this.genericTypeSignature = genericType().signature(); // erasure
			}
	    }
	   return this.genericTypeSignature;

	}	
	
	protected void initializeArguments() {
		TypeVariableBinding[] typeVariables = genericType().typeVariables();
		int length = typeVariables.length;
		TypeBinding[] typeArguments = new TypeBinding[length];
		for (int i = 0; i < length; i++) {

		if (isMemberType()) {
			readableName = CharOperation.concat(enclosingType().readableName(), sourceName, '.');
		} else {
			readableName = CharOperation.concatWith(type().compoundName, '.');
		}
		return readableName;
	}

		if (isMemberType()) {
			shortReadableName = CharOperation.concat(enclosingType().shortReadableName(), sourceName, '.');
		} else {
			shortReadableName = type().sourceName;
		}
		return shortReadableName;
	}

Lines 23-29 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedReferenceBinding.java (-1 / +7 lines)
23	this.fPackage = packageBinding;	23	this.fPackage = packageBinding;
24	this.wrappers = null;	24	this.wrappers = null;
25	}	25	}
26	void addWrapper(TypeBinding wrapper) {	26	void addWrapper(TypeBinding wrapper, LookupEnvironment environment) {
		27	if (this.resolvedType != null) {
		28	// the type reference B<B<T>.M> means a signature of <T:Ljava/lang/Object;>LB<LB<TT;>.M;>;
		29	// when the ParameterizedType for Unresolved B is created with args B<T>.M, the Unresolved B is resolved before the wrapper is added
		30	wrapper.swapUnresolved(this, this.resolvedType, environment);
		31	return;
		32	}
27	if (this.wrappers == null) {	33	if (this.wrappers == null) {
28	this.wrappers = new TypeBinding[] {wrapper};	34	this.wrappers = new TypeBinding[] {wrapper};
29	} else {	35	} else {

Lines 162-167 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java (+3 lines)
162		162
163	this.sourceName = binaryType.getSourceName();	163	this.sourceName = binaryType.getSourceName();
164	this.modifiers = binaryType.getModifiers();	164	this.modifiers = binaryType.getModifiers();
		165
		166	if ((binaryType.getTagBits() & TagBits.HasInconsistentHierarchy) != 0)
		167	this.tagBits \|= TagBits.HierarchyHasProblems;
165		168
166	if (binaryType.isAnonymous()) {	169	if (binaryType.isAnonymous()) {
167	this.tagBits \|= TagBits.AnonymousTypeMask;	170	this.tagBits \|= TagBits.AnonymousTypeMask;

Lines 675-683 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java (-2 / +1 lines)
675	}	675	}
676	ParameterizedTypeBinding substituteReturnType = (ParameterizedTypeBinding) substituteMethod.returnType,	676	ParameterizedTypeBinding substituteReturnType = (ParameterizedTypeBinding) substituteMethod.returnType,
677	existingReturnType = (ParameterizedTypeBinding) existingMethod.returnType;	677	existingReturnType = (ParameterizedTypeBinding) existingMethod.returnType;
678	if (substituteReturnType.type != existingReturnType.type) {	678	if (substituteReturnType.type() != existingReturnType.type())
679	return false;	679	return false;
680	}
681	for (int i = 0; i < substituteReturnType.arguments.length; i++) {	680	for (int i = 0; i < substituteReturnType.arguments.length; i++) {
682	TypeBinding substituteArgumentType, existingArgumentType;	681	TypeBinding substituteArgumentType, existingArgumentType;
683	if (! (existingArgumentType = existingReturnType.arguments[i]).isCompatibleWith(	682	if (! (existingArgumentType = existingReturnType.arguments[i]).isCompatibleWith(

Lines 1005-1011 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java (-1 / +1 lines)
1005	if ((otherType.tagBits & TagBits.HasDirectWildcard) == 0 && (!this.isMemberType() \|\| !otherType.isMemberType()))	1005	if ((otherType.tagBits & TagBits.HasDirectWildcard) == 0 && (!this.isMemberType() \|\| !otherType.isMemberType()))
1006	return false; // should have been identical	1006	return false; // should have been identical
1007	ParameterizedTypeBinding otherParamType = (ParameterizedTypeBinding) otherType;	1007	ParameterizedTypeBinding otherParamType = (ParameterizedTypeBinding) otherType;
1008	if (this != otherParamType.type)	1008	if (this != otherParamType.type())
1009	return false;	1009	return false;
1010	if (!isStatic()) { // static member types do not compare their enclosing	1010	if (!isStatic()) { // static member types do not compare their enclosing
1011	ReferenceBinding enclosing = enclosingType();	1011	ReferenceBinding enclosing = enclosingType();




				TypeBinding[] substitutedArguments = originalArguments;
				if (originalArguments != null) {
					if (substitution.isRawSubstitution()) {
						return originalParameterizedType.environment.createRawType(originalParameterizedType.genericType(), substitutedEnclosing);
					}
					substitutedArguments = substitute(substitution, originalArguments);
				}

//						return originalParameterizedType.type;
//					}
					return originalParameterizedType.environment.createParameterizedType(
							originalParameterizedType.genericType(), substitutedArguments, substitutedEnclosing);
				}
				break;
				

			ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
			if (itsInterfaces == null) { // needed for statically imported types which don't know their hierarchy yet
				ReferenceBinding sourceType = currentType.isParameterizedType()
					? ((ParameterizedTypeBinding) enclosingType).genericType()
					: currentType;
				if (sourceType.isHierarchyBeingConnected())
					return null; // looking for an undefined member type in its own superclass ref




			break;
		case Binding.PARAMETERIZED_TYPE :
			ParameterizedTypeBinding paramType = (ParameterizedTypeBinding) originalType;
			needToConvert = paramType.genericType().isGenericType(); // only recursive call to enclosing type can find parameterizedType with arguments
			break;
		default :
			needToConvert = false;

			break;
		case Binding.PARAMETERIZED_TYPE :
			ParameterizedTypeBinding paramType = (ParameterizedTypeBinding) originalType;
			needToConvert = paramType.genericType().isGenericType(); // only recursive call to enclosing type can find parameterizedType with arguments
			break;
		default :
			needToConvert = false;

			for (int max = cachedInfo.length; index < max; index++){
			    ParameterizedTypeBinding cachedType = cachedInfo[index];
			    if (cachedType == null) break nextCachedType;
			    if (cachedType.type() != genericType) continue nextCachedType; // remain of unresolved type
			    if (cachedType.enclosingType() != enclosingType) continue nextCachedType;
				TypeBinding[] cachedArguments = cachedType.arguments;
				int cachedArgLength = cachedArguments == null ? 0 : cachedArguments.length;

			for (int max = cachedInfo.length; index < max; index++){
			    RawTypeBinding cachedType = cachedInfo[index];
			    if (cachedType == null) break nextCachedType;
			    if (cachedType.type() != genericType) continue nextCachedType; // remain of unresolved type
			    if (cachedType.enclosingType() != enclosingType) continue nextCachedType;
				// all enclosing type match, reuse current
				return cachedType;

		wrapper.start++; // skip '.'
		char[] memberName = wrapper.nextWord();
		BinaryTypeBinding.resolveType(parameterizedType, this, false);
		ReferenceBinding memberType = parameterizedType.genericType().getMemberType(memberName);
		if (wrapper.signature[wrapper.start] == '<') {
			wrapper.start++; // skip '<'
			typeArguments = getTypeArgumentsFromSignature(wrapper, staticVariables, enclosingType, memberType);

Lines 31-37 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ArrayBinding.java (-1 / +1 lines)
31	this.dimensions = dimensions;	31	this.dimensions = dimensions;
32	this.environment = environment;	32	this.environment = environment;
33	if (type instanceof UnresolvedReferenceBinding)	33	if (type instanceof UnresolvedReferenceBinding)
34	((UnresolvedReferenceBinding) type).addWrapper(this);	34	((UnresolvedReferenceBinding) type).addWrapper(this, environment);
35	else	35	else
36	this.tagBits \|= type.tagBits & (TagBits.HasTypeVariable \| TagBits.HasDirectWildcard);	36	this.tagBits \|= type.tagBits & (TagBits.HasTypeVariable \| TagBits.HasDirectWildcard);
37	}	37	}

Lines 495-501 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java (-2 / +2 lines)
495		495
496	case Binding.PARAMETERIZED_TYPE:	496	case Binding.PARAMETERIZED_TYPE:
497	ParameterizedTypeBinding parameterizedType = (ParameterizedTypeBinding) this;	497	ParameterizedTypeBinding parameterizedType = (ParameterizedTypeBinding) this;
498	if (parameterizedType.type.isProvablyDistinctFrom(otherType.erasure(), depth))	498	if (parameterizedType.genericType().isProvablyDistinctFrom(otherType.erasure(), depth))
499	return true;	499	return true;
500	switch (otherType.kind()) {	500	switch (otherType.kind()) {
501	case Binding.GENERIC_TYPE:	501	case Binding.GENERIC_TYPE:
Lines 649-655 Link Here
649	return false;	649	return false;
650	ParameterizedTypeBinding paramType = (ParameterizedTypeBinding) this;	650	ParameterizedTypeBinding paramType = (ParameterizedTypeBinding) this;
651	ParameterizedTypeBinding otherParamType = (ParameterizedTypeBinding) otherType;	651	ParameterizedTypeBinding otherParamType = (ParameterizedTypeBinding) otherType;
652	if (paramType.type != otherParamType.type)	652	if (paramType.type() != otherParamType.type())
653	return false;	653	return false;
654	if (!paramType.isStatic()) { // static member types do not compare their enclosing	654	if (!paramType.isStatic()) { // static member types do not compare their enclosing
655	ReferenceBinding enclosing = enclosingType();	655	ReferenceBinding enclosing = enclosingType();

Lines 44-52 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java (-2 / +2 lines)
44	initialize(genericType, bound, otherBounds);	44	initialize(genericType, bound, otherBounds);
45		45
46	if (genericType instanceof UnresolvedReferenceBinding)	46	if (genericType instanceof UnresolvedReferenceBinding)
47	((UnresolvedReferenceBinding) genericType).addWrapper(this);	47	((UnresolvedReferenceBinding) genericType).addWrapper(this, environment);
48	if (bound instanceof UnresolvedReferenceBinding)	48	if (bound instanceof UnresolvedReferenceBinding)
49	((UnresolvedReferenceBinding) bound).addWrapper(this);	49	((UnresolvedReferenceBinding) bound).addWrapper(this, environment);
50	this.tagBits \|= TagBits.HasUnresolvedTypeVariables; // cleared in resolve()	50	this.tagBits \|= TagBits.HasUnresolvedTypeVariables; // cleared in resolve()
51	}	51	}
52		52

Lines 527-533 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MethodLocator.java (-1 / +1 lines)
527	locator.reportBinaryMemberDeclaration(resource, method, methodBinding, info, SearchMatch.A_ACCURATE);	527	locator.reportBinaryMemberDeclaration(resource, method, methodBinding, info, SearchMatch.A_ACCURATE);
528	} else {	528	} else {
529	if (declaringClass instanceof ParameterizedTypeBinding)	529	if (declaringClass instanceof ParameterizedTypeBinding)
530	declaringClass = ((ParameterizedTypeBinding) declaringClass).type;	530	declaringClass = ((ParameterizedTypeBinding) declaringClass).genericType();
531	ClassScope scope = ((SourceTypeBinding) declaringClass).scope;	531	ClassScope scope = ((SourceTypeBinding) declaringClass).scope;
532	if (scope != null) {	532	if (scope != null) {
533	TypeDeclaration typeDecl = scope.referenceContext;	533	TypeDeclaration typeDecl = scope.referenceContext;

Lines 600-606 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/TypeReferenceLocator.java (-1 / +1 lines)
600	locator.reportBinaryMemberDeclaration(resource, type, typeBinding, info, SearchMatch.A_ACCURATE);	600	locator.reportBinaryMemberDeclaration(resource, type, typeBinding, info, SearchMatch.A_ACCURATE);
601	} else {	601	} else {
602	if (typeBinding instanceof ParameterizedTypeBinding)	602	if (typeBinding instanceof ParameterizedTypeBinding)
603	typeBinding = ((ParameterizedTypeBinding) typeBinding).type;	603	typeBinding = ((ParameterizedTypeBinding) typeBinding).genericType();
604	ClassScope scope = ((SourceTypeBinding) typeBinding).scope;	604	ClassScope scope = ((SourceTypeBinding) typeBinding).scope;
605	if (scope != null) {	605	if (scope != null) {
606	TypeDeclaration typeDecl = scope.referenceContext;	606	TypeDeclaration typeDecl = scope.referenceContext;

Lines 266-272 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/FieldLocator.java (-1 / +1 lines)
266	locator.reportBinaryMemberDeclaration(resource, field, fieldBinding, info, SearchMatch.A_ACCURATE);	266	locator.reportBinaryMemberDeclaration(resource, field, fieldBinding, info, SearchMatch.A_ACCURATE);
267	} else {	267	} else {
268	if (declaringClass instanceof ParameterizedTypeBinding)	268	if (declaringClass instanceof ParameterizedTypeBinding)
269	declaringClass = ((ParameterizedTypeBinding) declaringClass).type;	269	declaringClass = ((ParameterizedTypeBinding) declaringClass).genericType();
270	ClassScope scope = ((SourceTypeBinding) declaringClass).scope;	270	ClassScope scope = ((SourceTypeBinding) declaringClass).scope;
271	if (scope != null) {	271	if (scope != null) {
272	TypeDeclaration typeDecl = scope.referenceContext;	272	TypeDeclaration typeDecl = scope.referenceContext;

Lines 438-444 Link Here

(-)dom/org/eclipse/jdt/core/dom/TypeBinding.java (-2 / +2 lines)
438	*/	438	*/
439	public ITypeBinding getTypeDeclaration() {	439	public ITypeBinding getTypeDeclaration() {
440	if (this.binding instanceof ParameterizedTypeBinding)	440	if (this.binding instanceof ParameterizedTypeBinding)
441	return this.resolver.getTypeBinding(((ParameterizedTypeBinding)this.binding).type);	441	return this.resolver.getTypeBinding(((ParameterizedTypeBinding)this.binding).genericType());
442	return this;	442	return this;
443	}	443	}
444		444
Lines 1175-1181 Link Here
1175	if (isClass() \|\| isInterface() \|\| isEnum()) {	1175	if (isClass() \|\| isInterface() \|\| isEnum()) {
1176	ReferenceBinding referenceBinding = (ReferenceBinding) this.binding;	1176	ReferenceBinding referenceBinding = (ReferenceBinding) this.binding;
1177	if (referenceBinding.isRawType()) {	1177	if (referenceBinding.isRawType()) {
1178	return !((RawTypeBinding) referenceBinding).type.isBinaryBinding();	1178	return !((RawTypeBinding) referenceBinding).genericType().isBinaryBinding();
1179	} else if (referenceBinding.isParameterizedType()) {	1179	} else if (referenceBinding.isParameterizedType()) {
1180	ParameterizedTypeBinding parameterizedTypeBinding = (ParameterizedTypeBinding) referenceBinding;	1180	ParameterizedTypeBinding parameterizedTypeBinding = (ParameterizedTypeBinding) referenceBinding;
1181	org.eclipse.jdt.internal.compiler.lookup.TypeBinding erasure = parameterizedTypeBinding.erasure();	1181	org.eclipse.jdt.internal.compiler.lookup.TypeBinding erasure = parameterizedTypeBinding.erasure();

Lines 79-85 Link Here

(-)dom/org/eclipse/jdt/core/dom/MethodBinding.java (-1 / +1 lines)
79	final ReferenceBinding declaringClassBinding = this.binding.declaringClass;	79	final ReferenceBinding declaringClassBinding = this.binding.declaringClass;
80	if (declaringClassBinding.isRawType()) {	80	if (declaringClassBinding.isRawType()) {
81	RawTypeBinding rawTypeBinding = (RawTypeBinding) declaringClassBinding;	81	RawTypeBinding rawTypeBinding = (RawTypeBinding) declaringClassBinding;
82	if (rawTypeBinding.type.isBinaryBinding()) {	82	if (rawTypeBinding.genericType().isBinaryBinding()) {
83	return false;	83	return false;
84	}	84	}
85	return (this.binding.modifiers & ExtraCompilerModifiers.AccIsDefaultConstructor) != 0;	85	return (this.binding.modifiers & ExtraCompilerModifiers.AccIsDefaultConstructor) != 0;

Lines 75-81 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/JavadocQualifiedTypeReference.java (-1 / +1 lines)
75	if (isTypeUseDeprecated(this.resolvedType, scope))	75	if (isTypeUseDeprecated(this.resolvedType, scope))
76	reportDeprecatedType(this.resolvedType, scope);	76	reportDeprecatedType(this.resolvedType, scope);
77	if (this.resolvedType instanceof ParameterizedTypeBinding) {	77	if (this.resolvedType instanceof ParameterizedTypeBinding) {
78	this.resolvedType = ((ParameterizedTypeBinding)this.resolvedType).type;	78	this.resolvedType = ((ParameterizedTypeBinding)this.resolvedType).genericType();
79	}	79	}
80	return this.resolvedType;	80	return this.resolvedType;
81	}	81	}

Lines 87-93 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/JavadocSingleTypeReference.java (-1 / +1 lines)
87	if (isTypeUseDeprecated(this.resolvedType, scope))	87	if (isTypeUseDeprecated(this.resolvedType, scope))
88	reportDeprecatedType(this.resolvedType, scope);	88	reportDeprecatedType(this.resolvedType, scope);
89	if (this.resolvedType instanceof ParameterizedTypeBinding) {	89	if (this.resolvedType instanceof ParameterizedTypeBinding) {
90	this.resolvedType = ((ParameterizedTypeBinding)this.resolvedType).type;	90	this.resolvedType = ((ParameterizedTypeBinding)this.resolvedType).genericType();
91	}	91	}
92	return this.resolvedType;	92	return this.resolvedType;
93	}	93	}

Lines 49-55 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java (-1 / +1 lines)
49	}	49	}
50	if (type.isParameterizedType()) {	50	if (type.isParameterizedType()) {
51	ParameterizedTypeBinding parameterizedType = (ParameterizedTypeBinding) type;	51	ParameterizedTypeBinding parameterizedType = (ParameterizedTypeBinding) type;
52	ReferenceBinding currentType = parameterizedType.type;	52	ReferenceBinding currentType = parameterizedType.genericType();
53	TypeVariableBinding[] typeVariables = currentType.typeVariables();	53	TypeVariableBinding[] typeVariables = currentType.typeVariables();
54	TypeBinding[] argTypes = parameterizedType.arguments;	54	TypeBinding[] argTypes = parameterizedType.arguments;
55	if (argTypes != null && typeVariables != null) { // argTypes may be null in error cases	55	if (argTypes != null && typeVariables != null) { // argTypes may be null in error cases

Lines 34-40 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java (-1 / +1 lines)
34		34
35	if (this.resolvedType.leafComponentType() instanceof ParameterizedTypeBinding) {	35	if (this.resolvedType.leafComponentType() instanceof ParameterizedTypeBinding) {
36	ParameterizedTypeBinding parameterizedType = (ParameterizedTypeBinding) this.resolvedType.leafComponentType();	36	ParameterizedTypeBinding parameterizedType = (ParameterizedTypeBinding) this.resolvedType.leafComponentType();
37	ReferenceBinding currentType = parameterizedType.type;	37	ReferenceBinding currentType = parameterizedType.genericType();
38	TypeVariableBinding[] typeVariables = currentType.typeVariables();	38	TypeVariableBinding[] typeVariables = currentType.typeVariables();
39	TypeBinding[] argTypes = parameterizedType.arguments;	39	TypeBinding[] argTypes = parameterizedType.arguments;
40	if (argTypes != null && typeVariables != null) { // may be null in error cases	40	if (argTypes != null && typeVariables != null) { // may be null in error cases

Lines 255-260 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ClassFile.java (+6 lines)
255	ClassFile classFile = ClassFile.getNewInstance(typeBinding);	255	ClassFile classFile = ClassFile.getNewInstance(typeBinding);
256	classFile.initialize(typeBinding, null, true);	256	classFile.initialize(typeBinding, null, true);
257		257
		258	if (typeBinding.hasMemberTypes()) {
		259	// see bug 180109
		260	ReferenceBinding[] members = typeBinding.memberTypes;
		261	for (int i = 0, l = members.length; i < l; i++)
		262	classFile.recordInnerClasses(members[i]);
		263	}
258	// TODO (olivier) handle cases where a field cannot be generated (name too long)	264	// TODO (olivier) handle cases where a field cannot be generated (name too long)
259	// TODO (olivier) handle too many methods	265	// TODO (olivier) handle too many methods
260	// inner attributes	266	// inner attributes

Lines 366-372 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/SelectionEngine.java (-2 / +2 lines)
366	return false; // not enough characters to decode an unicode	366	return false; // not enough characters to decode an unicode
367	}	367	}
368	}	368	}
369		369
370	if ((c1 = ScannerHelper.getNumericValue(source[pos++])) > 15	370	if ((c1 = ScannerHelper.getNumericValue(source[pos++])) > 15
371	\|\| c1 < 0	371	\|\| c1 < 0
372	\|\| (c2 = ScannerHelper.getNumericValue(source[pos++])) > 15	372	\|\| (c2 = ScannerHelper.getNumericValue(source[pos++])) > 15
Lines 560-566 Link Here
560	*/	560	*/
561	private boolean isLocal(ReferenceBinding binding) {	561	private boolean isLocal(ReferenceBinding binding) {
562	if(binding instanceof ParameterizedTypeBinding) {	562	if(binding instanceof ParameterizedTypeBinding) {
563	return isLocal(((ParameterizedTypeBinding)binding).type);	563	return isLocal(((ParameterizedTypeBinding)binding).genericType());
564	}	564	}
565	if (!(binding instanceof SourceTypeBinding)) return false;	565	if (!(binding instanceof SourceTypeBinding)) return false;
566	if (binding instanceof LocalTypeBinding) return true;	566	if (binding instanceof LocalTypeBinding) return true;

Lines 5768-5774 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java (-2 / +2 lines)
5768	completion.append('.');	5768	completion.append('.');
5769	completion.append(parameterizedType.sourceName);	5769	completion.append(parameterizedType.sourceName);
5770	} else {	5770	} else {
5771	completion.append(CharOperation.concatWith(parameterizedType.type.compoundName, '.'));	5771	completion.append(CharOperation.concatWith(parameterizedType.genericType().compoundName, '.'));
5772	}	5772	}
5773	if (parameterizedType.arguments != null) {	5773	if (parameterizedType.arguments != null) {
5774	completion.append('<');	5774	completion.append('<');
Lines 6082-6088 Link Here
6082	hasPotentialDefaultAbstractMethods = false;	6082	hasPotentialDefaultAbstractMethods = false;
6083	}	6083	}
6084	if(currentType.isParameterizedType()) {	6084	if(currentType.isParameterizedType()) {
6085	currentType = ((ParameterizedTypeBinding)currentType).type.superclass();	6085	currentType = ((ParameterizedTypeBinding)currentType).genericType().superclass();
6086	} else {	6086	} else {
6087	currentType = currentType.superclass();	6087	currentType = currentType.superclass();
6088	}	6088	}




public void acceptLocalField(FieldBinding fieldBinding) {
	IJavaElement res;
	if(fieldBinding.declaringClass instanceof ParameterizedTypeBinding) {
		LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)fieldBinding.declaringClass).genericType();
		res = findLocalElement(localTypeBinding.sourceStart());
	} else {
		SourceTypeBinding typeBinding = (SourceTypeBinding)fieldBinding.declaringClass;

public void acceptLocalType(TypeBinding typeBinding) {
	IJavaElement res =  null;
	if(typeBinding instanceof ParameterizedTypeBinding) {
		LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)typeBinding).genericType();
		res = findLocalElement(localTypeBinding.sourceStart());
	} else if(typeBinding instanceof SourceTypeBinding) {
		res = findLocalElement(((SourceTypeBinding)typeBinding).sourceStart());

public void acceptLocalTypeParameter(TypeVariableBinding typeVariableBinding) {
	IJavaElement res;
	if(typeVariableBinding.declaringElement instanceof ParameterizedTypeBinding) {
		LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)typeVariableBinding.declaringElement).genericType();
		res = findLocalElement(localTypeBinding.sourceStart());
	} else {
		SourceTypeBinding typeBinding = (SourceTypeBinding)typeVariableBinding.declaringElement;




			"Problem : The annotation @Ann is disallowed for this location [ resource : </Project/p/Use.java> range : <11,17> category : <40> severity : <2>]"
		);
	}

	public void testParameterizedMemberType() throws JavaModelException {
		IPath projectPath = env.addProject("Project", "1.5"); 
		env.addExternalJars(projectPath, Util.getJavaClassLibs());
		env.setOutputFolder(projectPath, "");

		IPath xPath = env.addClass(projectPath, "", "X",
			"class X<T> extends A<T> {}"
		);

		IPath aPath = env.addClass(projectPath, "", "A",
			"class A<T> extends B<B<T>.M> {}\n" + 
			"class B<T> extends Missing<T> {\n" + 
			"	class M{}\n" + 
			"}\n" + 
			"class Missing<T> {}"
		); 

		fullBuild(projectPath);
		expectingNoProblems();

		env.addClass(projectPath, "", "A",
			"class A<T> extends B<B<T>.M> {}\n" + 
			"class B<T> extends Missing<T> {\n" + 
			"	class M{}\n" + 
			"}"
		); 

		incrementalBuild(projectPath);
		expectingProblemsFor(
			new IPath[] {aPath, xPath},
			"Problem : The hierarchy of the type A is inconsistent [ resource : </Project/A.java> range : <6,7> category : <40> severity : <2>]\n" + 
			"Problem : Missing cannot be resolved to a type [ resource : </Project/A.java> range : <51,58> category : <40> severity : <2>]\n" + 
			"Problem : The hierarchy of the type X is inconsistent [ resource : </Project/X.java> range : <6,7> category : <40> severity : <2>]"
		);

		env.addClass(projectPath, "", "X",
			"class X<T> extends A<T> {}"
		);

		incrementalBuild(projectPath);
		expectingProblemsFor(
			new IPath[] {aPath, xPath},
			"Problem : The hierarchy of the type A is inconsistent [ resource : </Project/A.java> range : <6,7> category : <40> severity : <2>]\n" + 
			"Problem : Missing cannot be resolved to a type [ resource : </Project/A.java> range : <51,58> category : <40> severity : <2>]\n" + 
			"Problem : The hierarchy of the type X is inconsistent [ resource : </Project/X.java> range : <6,7> category : <40> severity : <2>]"
		);

		env.addClass(projectPath, "", "A",
			"class A<T> extends B<B<T>.M> {}\n" + 
			"class B<T> extends Missing<T> {\n" + 
			"	class M{}\n" + 
			"}"
		); 

		incrementalBuild(projectPath);
		expectingProblemsFor(
			new IPath[] {aPath, xPath},
			"Problem : The hierarchy of the type A is inconsistent [ resource : </Project/A.java> range : <6,7> category : <40> severity : <2>]\n" + 
			"Problem : Missing cannot be resolved to a type [ resource : </Project/A.java> range : <51,58> category : <40> severity : <2>]\n" + 
			"Problem : The hierarchy of the type X is inconsistent [ resource : </Project/X.java> range : <6,7> category : <40> severity : <2>]"
		);

		env.addClass(projectPath, "", "A",
			"class A<T> extends B<B<T>.M> {}\n" + 
			"class B<T> extends Missing<T> {\n" + 
			"	class M{}\n" + 
			"}\n" + 
			"class Missing<T> {}"
		); 

		incrementalBuild(projectPath);
		expectingNoProblems();
	}

	public void testParameterizedType1() throws JavaModelException {
		IPath projectPath = env.addProject("Project", "1.5"); 
		env.addExternalJars(projectPath, Util.getJavaClassLibs());

Return to bug 180109

Lines 19-25 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java (-11 / +23 lines)
19	*/	19	*/
20	public class ParameterizedTypeBinding extends ReferenceBinding implements Substitution {	20	public class ParameterizedTypeBinding extends ReferenceBinding implements Substitution {
21		21
22	public ReferenceBinding type;	22	private ReferenceBinding type; // must ensure the type is resolved
23	public TypeBinding[] arguments;	23	public TypeBinding[] arguments;
24	public LookupEnvironment environment;	24	public LookupEnvironment environment;
25	public char[] genericTypeSignature;	25	public char[] genericTypeSignature;
Lines 41-51 Link Here
41	// }	41	// }
42	initialize(type, arguments);	42	initialize(type, arguments);
43	if (type instanceof UnresolvedReferenceBinding)	43	if (type instanceof UnresolvedReferenceBinding)
44	((UnresolvedReferenceBinding) type).addWrapper(this);	44	((UnresolvedReferenceBinding) type).addWrapper(this, environment);
45	if (arguments != null) {	45	if (arguments != null) {
46	for (int i = 0, l = arguments.length; i < l; i++)	46	for (int i = 0, l = arguments.length; i < l; i++)
47	if (arguments[i] instanceof UnresolvedReferenceBinding)	47	if (arguments[i] instanceof UnresolvedReferenceBinding)
48	((UnresolvedReferenceBinding) arguments[i]).addWrapper(this);	48	((UnresolvedReferenceBinding) arguments[i]).addWrapper(this, environment);
49	}	49	}
50	this.tagBits \|= TagBits.HasUnresolvedTypeVariables; // cleared in resolve()	50	this.tagBits \|= TagBits.HasUnresolvedTypeVariables; // cleared in resolve()
51	}	51	}
Lines 778-784 Link Here
778	}	778	}
779	return this.methods;	779	return this.methods;
780	}	780	}
781		781
		782	/**
		783	* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#qualifiedPackageName()
		784	*/
		785	public char[] qualifiedPackageName() {
		786	return this.type.qualifiedPackageName();
		787	}
		788
782	/**	789	/**
783	* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#qualifiedSourceName()	790	* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#qualifiedSourceName()
784	*/	791	*/
Lines 840-845 Link Here
840	return this;	847	return this;
841	}	848	}
842		849
		850	public ReferenceBinding genericType() {
		851	if (this.type instanceof UnresolvedReferenceBinding)
		852	((UnresolvedReferenceBinding) this.type).resolve(this.environment, false);
		853	return this.type;
		854	}
		855
843	/**	856	/**
844	* @see org.eclipse.jdt.internal.compiler.lookup.Binding#shortReadableName()	857	* @see org.eclipse.jdt.internal.compiler.lookup.Binding#shortReadableName()
845	*/	858	*/
Lines 970-982 Link Here
970	}	983	}
971		984
972	/**	985	/**
973	* @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#qualifiedPackageName()
974	*/
975	public char[] qualifiedPackageName() {
976	return this.type.qualifiedPackageName();
977	}
978
979	/**
980	* @see java.lang.Object#toString()	986	* @see java.lang.Object#toString()
981	*/	987	*/
982	public String toString() {	988	public String toString() {
Lines 1051-1056 Link Here
1051		1057
1052	}	1058	}
1053		1059
		1060	protected ReferenceBinding type() {
		1061	// can be an UnresolvedReferenceBinding
		1062	// most clients should call resolveType()
		1063	return this.type;
		1064	}
		1065
1054	public TypeVariableBinding[] typeVariables() {	1066	public TypeVariableBinding[] typeVariables() {
1055	if (this.arguments == null) {	1067	if (this.arguments == null) {
1056	// retain original type variables if not substituted (member type of parameterized type)	1068	// retain original type variables if not substituted (member type of parameterized type)

Lines 1002-1008 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java (-4 / +4 lines)
1002	// abstract class X<K,V> implements java.util.Map<K,V>	1002	// abstract class X<K,V> implements java.util.Map<K,V>
1003	// static abstract class M<K,V> implements Entry<K,V>	1003	// static abstract class M<K,V> implements Entry<K,V>
1004	if (superType.isParameterizedType())	1004	if (superType.isParameterizedType())
1005	superType = ((ParameterizedTypeBinding) superType).type;	1005	superType = ((ParameterizedTypeBinding) superType).genericType();
1006	compilationUnitScope().recordSuperTypeReference(superType); // to record supertypes	1006	compilationUnitScope().recordSuperTypeReference(superType); // to record supertypes
1007	return detectHierarchyCycle(referenceContext.binding, (ReferenceBinding) superType, reference);	1007	return detectHierarchyCycle(referenceContext.binding, (ReferenceBinding) superType, reference);
1008	}	1008	}
Lines 1016-1022 Link Here
1016	// Answer whether a cycle was found between the sourceType & the superType	1016	// Answer whether a cycle was found between the sourceType & the superType
1017	private boolean detectHierarchyCycle(SourceTypeBinding sourceType, ReferenceBinding superType, TypeReference reference) {	1017	private boolean detectHierarchyCycle(SourceTypeBinding sourceType, ReferenceBinding superType, TypeReference reference) {
1018	if (superType.isRawType())	1018	if (superType.isRawType())
1019	superType = ((RawTypeBinding) superType).type;	1019	superType = ((RawTypeBinding) superType).genericType();
1020	// by this point the superType must be a binary or source type	1020	// by this point the superType must be a binary or source type
1021		1021
1022	if (sourceType == superType) {	1022	if (sourceType == superType) {
Lines 1052-1058 Link Here
1052	return true;	1052	return true;
1053	}	1053	}
1054	if (parentType.isParameterizedType())	1054	if (parentType.isParameterizedType())
1055	parentType = ((ParameterizedTypeBinding) parentType).type;	1055	parentType = ((ParameterizedTypeBinding) parentType).genericType();
1056	hasCycle \|= detectHierarchyCycle(sourceType, parentType, reference);	1056	hasCycle \|= detectHierarchyCycle(sourceType, parentType, reference);
1057	if ((parentType.tagBits & TagBits.HierarchyHasProblems) != 0) {	1057	if ((parentType.tagBits & TagBits.HierarchyHasProblems) != 0) {
1058	sourceType.tagBits \|= TagBits.HierarchyHasProblems;	1058	sourceType.tagBits \|= TagBits.HierarchyHasProblems;
Lines 1071-1077 Link Here
1071	return true;	1071	return true;
1072	}	1072	}
1073	if (anInterface.isParameterizedType())	1073	if (anInterface.isParameterizedType())
1074	anInterface = ((ParameterizedTypeBinding) anInterface).type;	1074	anInterface = ((ParameterizedTypeBinding) anInterface).genericType();
1075	hasCycle \|= detectHierarchyCycle(sourceType, anInterface, reference);	1075	hasCycle \|= detectHierarchyCycle(sourceType, anInterface, reference);
1076	if ((anInterface.tagBits & TagBits.HierarchyHasProblems) != 0) {	1076	if ((anInterface.tagBits & TagBits.HierarchyHasProblems) != 0) {
1077	sourceType.tagBits \|= TagBits.HierarchyHasProblems;	1077	sourceType.tagBits \|= TagBits.HierarchyHasProblems;

Lines 37-43 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/RawTypeBinding.java (-6 / +6 lines)
37	for (int i = 0; i < typeSig.length-1; i++) sig.append(typeSig[i]); // copy all but trailing semicolon	37	for (int i = 0; i < typeSig.length-1; i++) sig.append(typeSig[i]); // copy all but trailing semicolon
38	sig.append('.').append(sourceName()).append('<').append('>').append(';');	38	sig.append('.').append(sourceName()).append('<').append('>').append(';');
39	} else {	39	} else {
40	sig.append(this.type.computeUniqueKey(false/not a leaf/));	40	sig.append(genericType().computeUniqueKey(false/not a leaf/));
41	sig.insert(sig.length()-1, "<>"); //$NON-NLS-1$	41	sig.insert(sig.length()-1, "<>"); //$NON-NLS-1$
42	}	42	}
43		43
Lines 66-72 Link Here
66	*/	66	*/
67	public String debugName() {	67	public String debugName() {
68	StringBuffer nameBuffer = new StringBuffer(10);	68	StringBuffer nameBuffer = new StringBuffer(10);
69	nameBuffer.append(this.type.sourceName()).append("#RAW"); //$NON-NLS-1$	69	nameBuffer.append(type().sourceName()).append("#RAW"); //$NON-NLS-1$
70	return nameBuffer.toString();	70	return nameBuffer.toString();
71	}	71	}
72		72
Lines 86-92 Link Here
86	this.genericTypeSignature = new char[sigLength];	86	this.genericTypeSignature = new char[sigLength];
87	sig.getChars(0, sigLength, this.genericTypeSignature, 0);	87	sig.getChars(0, sigLength, this.genericTypeSignature, 0);
88	} else {	88	} else {
89	this.genericTypeSignature = this.type.signature(); // erasure	89	this.genericTypeSignature = genericType().signature(); // erasure
90	}	90	}
91	}	91	}
92	return this.genericTypeSignature;	92	return this.genericTypeSignature;
Lines 137-143 Link Here
137	}	137	}
138		138
139	protected void initializeArguments() {	139	protected void initializeArguments() {
140	TypeVariableBinding[] typeVariables = this.type.typeVariables();	140	TypeVariableBinding[] typeVariables = genericType().typeVariables();
141	int length = typeVariables.length;	141	int length = typeVariables.length;
142	TypeBinding[] typeArguments = new TypeBinding[length];	142	TypeBinding[] typeArguments = new TypeBinding[length];
143	for (int i = 0; i < length; i++) {	143	for (int i = 0; i < length; i++) {
Lines 154-160 Link Here
154	if (isMemberType()) {	154	if (isMemberType()) {
155	readableName = CharOperation.concat(enclosingType().readableName(), sourceName, '.');	155	readableName = CharOperation.concat(enclosingType().readableName(), sourceName, '.');
156	} else {	156	} else {
157	readableName = CharOperation.concatWith(this.type.compoundName, '.');	157	readableName = CharOperation.concatWith(type().compoundName, '.');
158	}	158	}
159	return readableName;	159	return readableName;
160	}	160	}
Lines 167-173 Link Here
167	if (isMemberType()) {	167	if (isMemberType()) {
168	shortReadableName = CharOperation.concat(enclosingType().shortReadableName(), sourceName, '.');	168	shortReadableName = CharOperation.concat(enclosingType().shortReadableName(), sourceName, '.');
169	} else {	169	} else {
170	shortReadableName = this.type.sourceName;	170	shortReadableName = type().sourceName;
171	}	171	}
172	return shortReadableName;	172	return shortReadableName;
173	}	173	}

Lines 241-247 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java (-3 / +3 lines)
241	TypeBinding[] substitutedArguments = originalArguments;	241	TypeBinding[] substitutedArguments = originalArguments;
242	if (originalArguments != null) {	242	if (originalArguments != null) {
243	if (substitution.isRawSubstitution()) {	243	if (substitution.isRawSubstitution()) {
244	return originalParameterizedType.environment.createRawType(originalParameterizedType.type, substitutedEnclosing);	244	return originalParameterizedType.environment.createRawType(originalParameterizedType.genericType(), substitutedEnclosing);
245	}	245	}
246	substitutedArguments = substitute(substitution, originalArguments);	246	substitutedArguments = substitute(substitution, originalArguments);
247	}	247	}
Lines 259-265 Link Here
259	// return originalParameterizedType.type;	259	// return originalParameterizedType.type;
260	// }	260	// }
261	return originalParameterizedType.environment.createParameterizedType(	261	return originalParameterizedType.environment.createParameterizedType(
262	originalParameterizedType.type, substitutedArguments, substitutedEnclosing);	262	originalParameterizedType.genericType(), substitutedArguments, substitutedEnclosing);
263	}	263	}
264	break;	264	break;
265		265
Lines 951-957 Link Here
951	ReferenceBinding[] itsInterfaces = currentType.superInterfaces();	951	ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
952	if (itsInterfaces == null) { // needed for statically imported types which don't know their hierarchy yet	952	if (itsInterfaces == null) { // needed for statically imported types which don't know their hierarchy yet
953	ReferenceBinding sourceType = currentType.isParameterizedType()	953	ReferenceBinding sourceType = currentType.isParameterizedType()
954	? ((ParameterizedTypeBinding) enclosingType).type	954	? ((ParameterizedTypeBinding) enclosingType).genericType()
955	: currentType;	955	: currentType;
956	if (sourceType.isHierarchyBeingConnected())	956	if (sourceType.isHierarchyBeingConnected())
957	return null; // looking for an undefined member type in its own superclass ref	957	return null; // looking for an undefined member type in its own superclass ref

Lines 442-448 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java (-2 / +2 lines)
442	// Set match raw flag	442	// Set match raw flag
443	boolean endPattern = patternTypeArguments==null ? true : depth>=patternTypeArguments.length;	443	boolean endPattern = patternTypeArguments==null ? true : depth>=patternTypeArguments.length;
444	TypeBinding[] argumentsBindings = parameterizedBinding.arguments;	444	TypeBinding[] argumentsBindings = parameterizedBinding.arguments;
445	boolean isRaw = parameterizedBinding.isRawType()\|\| (argumentsBindings==null && parameterizedBinding.type.isGenericType());	445	boolean isRaw = parameterizedBinding.isRawType()\|\| (argumentsBindings==null && parameterizedBinding.genericType().isGenericType());
446	if (isRaw && !match.isRaw()) {	446	if (isRaw && !match.isRaw()) {
447	match.setRaw(isRaw);	447	match.setRaw(isRaw);
448	}	448	}
Lines 452-458 Link Here
452	// verify if this is a reference to the generic type itself	452	// verify if this is a reference to the generic type itself
453	if (!isRaw && patternHasTypeParameters && argumentsBindings != null) {	453	if (!isRaw && patternHasTypeParameters && argumentsBindings != null) {
454	boolean needUpdate = false;	454	boolean needUpdate = false;
455	TypeVariableBinding[] typeVariables = parameterizedBinding.type.typeVariables();	455	TypeVariableBinding[] typeVariables = parameterizedBinding.genericType().typeVariables();
456	for (int i=0, l=argumentsBindings.length; i<l; i++) {	456	for (int i=0, l=argumentsBindings.length; i<l; i++) {
457	if (argumentsBindings[i] != typeVariables[i]) {	457	if (argumentsBindings[i] != typeVariables[i]) {
458	needUpdate = true;	458	needUpdate = true;

Lines 281-287 Link Here

(-)model/org/eclipse/jdt/internal/core/SelectionRequestor.java (-3 / +3 lines)
281	public void acceptLocalField(FieldBinding fieldBinding) {	281	public void acceptLocalField(FieldBinding fieldBinding) {
282	IJavaElement res;	282	IJavaElement res;
283	if(fieldBinding.declaringClass instanceof ParameterizedTypeBinding) {	283	if(fieldBinding.declaringClass instanceof ParameterizedTypeBinding) {
284	LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)fieldBinding.declaringClass).type;	284	LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)fieldBinding.declaringClass).genericType();
285	res = findLocalElement(localTypeBinding.sourceStart());	285	res = findLocalElement(localTypeBinding.sourceStart());
286	} else {	286	} else {
287	SourceTypeBinding typeBinding = (SourceTypeBinding)fieldBinding.declaringClass;	287	SourceTypeBinding typeBinding = (SourceTypeBinding)fieldBinding.declaringClass;
Lines 361-367 Link Here
361	public void acceptLocalType(TypeBinding typeBinding) {	361	public void acceptLocalType(TypeBinding typeBinding) {
362	IJavaElement res = null;	362	IJavaElement res = null;
363	if(typeBinding instanceof ParameterizedTypeBinding) {	363	if(typeBinding instanceof ParameterizedTypeBinding) {
364	LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)typeBinding).type;	364	LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)typeBinding).genericType();
365	res = findLocalElement(localTypeBinding.sourceStart());	365	res = findLocalElement(localTypeBinding.sourceStart());
366	} else if(typeBinding instanceof SourceTypeBinding) {	366	} else if(typeBinding instanceof SourceTypeBinding) {
367	res = findLocalElement(((SourceTypeBinding)typeBinding).sourceStart());	367	res = findLocalElement(((SourceTypeBinding)typeBinding).sourceStart());
Lines 379-385 Link Here
379	public void acceptLocalTypeParameter(TypeVariableBinding typeVariableBinding) {	379	public void acceptLocalTypeParameter(TypeVariableBinding typeVariableBinding) {
380	IJavaElement res;	380	IJavaElement res;
381	if(typeVariableBinding.declaringElement instanceof ParameterizedTypeBinding) {	381	if(typeVariableBinding.declaringElement instanceof ParameterizedTypeBinding) {
382	LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)typeVariableBinding.declaringElement).type;	382	LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)typeVariableBinding.declaringElement).genericType();
383	res = findLocalElement(localTypeBinding.sourceStart());	383	res = findLocalElement(localTypeBinding.sourceStart());
384	} else {	384	} else {
385	SourceTypeBinding typeBinding = (SourceTypeBinding)typeVariableBinding.declaringElement;	385	SourceTypeBinding typeBinding = (SourceTypeBinding)typeVariableBinding.declaringElement;

Lines 59-65 Link Here

(-)src/org/eclipse/jdt/core/tests/builder/Java50Tests.java (-1 / +75 lines)
59	"Problem : The annotation @Ann is disallowed for this location [ resource : </Project/p/Use.java> range : <11,17> category : <40> severity : <2>]"	59	"Problem : The annotation @Ann is disallowed for this location [ resource : </Project/p/Use.java> range : <11,17> category : <40> severity : <2>]"
60	);	60	);
61	}	61	}
62		62
		63	public void testParameterizedMemberType() throws JavaModelException {
		64	IPath projectPath = env.addProject("Project", "1.5");
		65	env.addExternalJars(projectPath, Util.getJavaClassLibs());
		66	env.setOutputFolder(projectPath, "");
		67
		68	IPath xPath = env.addClass(projectPath, "", "X",
		69	"class X<T> extends A<T> {}"
		70	);
		71
		72	IPath aPath = env.addClass(projectPath, "", "A",
		73	"class A<T> extends B<B<T>.M> {}\n" +
		74	"class B<T> extends Missing<T> {\n" +
		75	" class M{}\n" +
		76	"}\n" +
		77	"class Missing<T> {}"
		78	);
		79
		80	fullBuild(projectPath);
		81	expectingNoProblems();
		82
		83	env.addClass(projectPath, "", "A",
		84	"class A<T> extends B<B<T>.M> {}\n" +
		85	"class B<T> extends Missing<T> {\n" +
		86	" class M{}\n" +
		87	"}"
		88	);
		89
		90	incrementalBuild(projectPath);
		91	expectingProblemsFor(
		92	new IPath[] {aPath, xPath},
		93	"Problem : The hierarchy of the type A is inconsistent [ resource : </Project/A.java> range : <6,7> category : <40> severity : <2>]\n" +
		94	"Problem : Missing cannot be resolved to a type [ resource : </Project/A.java> range : <51,58> category : <40> severity : <2>]\n" +
		95	"Problem : The hierarchy of the type X is inconsistent [ resource : </Project/X.java> range : <6,7> category : <40> severity : <2>]"
		96	);
		97
		98	env.addClass(projectPath, "", "X",
		99	"class X<T> extends A<T> {}"
		100	);
		101
		102	incrementalBuild(projectPath);
		103	expectingProblemsFor(
		104	new IPath[] {aPath, xPath},
		105	"Problem : The hierarchy of the type A is inconsistent [ resource : </Project/A.java> range : <6,7> category : <40> severity : <2>]\n" +
		106	"Problem : Missing cannot be resolved to a type [ resource : </Project/A.java> range : <51,58> category : <40> severity : <2>]\n" +
		107	"Problem : The hierarchy of the type X is inconsistent [ resource : </Project/X.java> range : <6,7> category : <40> severity : <2>]"
		108	);
		109
		110	env.addClass(projectPath, "", "A",
		111	"class A<T> extends B<B<T>.M> {}\n" +
		112	"class B<T> extends Missing<T> {\n" +
		113	" class M{}\n" +
		114	"}"
		115	);
		116
		117	incrementalBuild(projectPath);
		118	expectingProblemsFor(
		119	new IPath[] {aPath, xPath},
		120	"Problem : The hierarchy of the type A is inconsistent [ resource : </Project/A.java> range : <6,7> category : <40> severity : <2>]\n" +
		121	"Problem : Missing cannot be resolved to a type [ resource : </Project/A.java> range : <51,58> category : <40> severity : <2>]\n" +
		122	"Problem : The hierarchy of the type X is inconsistent [ resource : </Project/X.java> range : <6,7> category : <40> severity : <2>]"
		123	);
		124
		125	env.addClass(projectPath, "", "A",
		126	"class A<T> extends B<B<T>.M> {}\n" +
127	"class B<T> extends Missing<T> {\n" +
128	" class M{}\n" +
129	"}\n" +
130	"class Missing<T> {}"
131	);
132
133	incrementalBuild(projectPath);
134	expectingNoProblems();
135	}
136
63	public void testParameterizedType1() throws JavaModelException {	137	public void testParameterizedType1() throws JavaModelException {
64	IPath projectPath = env.addProject("Project", "1.5");	138	IPath projectPath = env.addProject("Project", "1.5");
65	env.addExternalJars(projectPath, Util.getJavaClassLibs());	139	env.addExternalJars(projectPath, Util.getJavaClassLibs());