Attachment #193271 for bug #342671




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

					}
				}
			}
			createArrayType(scope);
			return null;
		}


						}
				    }
				}
				createArrayType(scope);
				return null;
			}
			ReferenceBinding currentType = (ReferenceBinding) this.resolvedType;

					}
				}
				if (argHasError) {
					createArrayType(scope);
					return null;
				}
				if (isClassScope) {
					((ClassScope) scope).superTypeReference = keep;
					if (((ClassScope) scope).detectHierarchyCycle(currentOriginal, this)) {
						createArrayType(scope);
						return null;
					}
				}

			    TypeVariableBinding[] typeVariables = currentOriginal.typeVariables();
				if (typeVariables == Binding.NO_TYPE_VARIABLES) { // check generic
					if (scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_5) { // below 1.5, already reported as syntax error
						scope.problemReporter().nonGenericTypeCannotBeParameterized(i, this, currentType, argTypes);
						createArrayType(scope);
						return null;
					}
					this.resolvedType =  (qualifyingType != null && qualifyingType.isParameterizedType())
						? scope.environment().createParameterizedType(currentOriginal, null, qualifyingType)
						: currentType;
					createArrayType(scope);
						if (this.dimensions > 255)
							scope.problemReporter().tooManyDimensions(this);
						this.resolvedType = scope.createArrayType(this.resolvedType, this.dimensions);
					}
					return this.resolvedType;
				} else if (argLength != typeVariables.length) { // check arity
					scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes, i);
					createArrayType(scope);
					return null;
				}
				// check parameterizing non-static member type of raw type

		    } else {
				ReferenceBinding currentOriginal = (ReferenceBinding)currentType.original();
				if (isClassScope)
					if (((ClassScope) scope).detectHierarchyCycle(currentOriginal, this)) {
						createArrayType(scope);
						return null;
					}
				if (currentOriginal.isGenericType()) {
	   			    if (typeIsConsistent && qualifyingType != null && qualifyingType.isParameterizedType()) {
						scope.problemReporter().parameterizedMemberTypeMissingArguments(this, scope.environment().createParameterizedType(currentOriginal, null, qualifyingType), i);

				reportDeprecatedType(qualifyingType, scope, i);
			this.resolvedType = qualifyingType;
		}
		createArrayType(scope);
		return this.resolvedType;
	}
	private void createArrayType(Scope scope) {
		// array type ?
		if (this.dimensions > 0) {
			if (this.dimensions > 255)
				scope.problemReporter().tooManyDimensions(this);
			this.resolvedType = scope.createArrayType(this.resolvedType, this.dimensions);
		}
		return this.resolvedType;
	}

	public StringBuffer printExpression(int indent, StringBuffer output) {




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

				}
			}
		}
		boolean hasGenericError = false;
		ReferenceBinding currentType;
		this.bits |= ASTNode.DidResolve;
		if (enclosingType == null) {

			if (this.resolvedType.isValidBinding()) {
				currentType = (ReferenceBinding) this.resolvedType;
			} else {
				hasGenericError = true;
				reportInvalidType(scope);
				switch (this.resolvedType.problemId()) {
					case ProblemReasons.NotFound :

						//$FALL-THROUGH$ - unable to complete type binding, but still resolve type arguments
					default :
						boolean isClassScope = scope.kind == Scope.CLASS_SCOPE;
						int argLength = this.typeArguments.length;
						for (int i = 0; i < argLength; i++) {
							TypeReference typeArgument = this.typeArguments[i];
							if (isClassScope) {
								typeArgument.resolveType((ClassScope) scope);
							} else {
								typeArgument.resolveType((BlockScope) scope, checkBounds);
							}
						}
						createArrayType(scope);
						return null;
				}
				// be resilient, still attempt resolving arguments
			}

		} else { // resolving member type (relatively to enclosingType)
			this.resolvedType = currentType = scope.getMemberType(this.token, enclosingType);
			if (!this.resolvedType.isValidBinding()) {
				hasGenericError = true;
				scope.problemReporter().invalidEnclosingType(this, currentType, enclosingType);
				createArrayType(scope);
				return null;
			}
			if (isTypeUseDeprecated(currentType, scope))

		}

		// check generic and arity
		boolean isClassScope = scope.kind == Scope.CLASS_SCOPE;
		TypeReference keep = null;
		if (isClassScope) {
			keep = ((ClassScope) scope).superTypeReference;
			((ClassScope) scope).superTypeReference = null;
		}
		int argLength = this.typeArguments.length;
		TypeBinding[] argTypes = new TypeBinding[argLength];
		boolean argHasError = false;
		ReferenceBinding currentOriginal = (ReferenceBinding)currentType.original();
		for (int i = 0; i < argLength; i++) {
			TypeReference typeArgument = this.typeArguments[i];
			TypeBinding argType = isClassScope
					? typeArgument.resolveTypeArgument((ClassScope) scope, currentOriginal, i)
					: typeArgument.resolveTypeArgument((BlockScope) scope, currentOriginal, i);
			if (argType == null) {
				argHasError = true;
			} else {
				argTypes[i] = argType;
			}
		}
		if (argHasError) {
			createArrayType(scope);
			return null;
		}
		if (isClassScope) {
			((ClassScope) scope).superTypeReference = keep;
			if (((ClassScope) scope).detectHierarchyCycle(currentOriginal, this)) {
				createArrayType(scope);
				return null;
			}
		}

		TypeVariableBinding[] typeVariables = currentOriginal.typeVariables();

				if (isCompliant15) { // below 1.5, already reported as syntax error
					this.resolvedType = currentType;
					scope.problemReporter().nonGenericTypeCannotBeParameterized(0, this, currentType, argTypes);
					createArrayType(scope);
					return null;
				}
			}

						scope.problemReporter().tooManyDimensions(this);
					type = scope.createArrayType(type, this.dimensions);
				}
				if (hasGenericError)
					return type;
				return this.resolvedType = type;
			}
			// if missing generic type, and compliance >= 1.5, then will rebuild a parameterized binding
		} else if (argLength != typeVariables.length) { // check arity
			scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);
			createArrayType(scope);
			return null;
		} else if (!currentType.isStatic()) {
			ReferenceBinding actualEnclosing = currentType.enclosingType();
			if (actualEnclosing != null && actualEnclosing.isRawType()){
				scope.problemReporter().rawMemberTypeCannotBeParameterized(
						this, scope.environment().createRawType(currentOriginal, actualEnclosing), argTypes);
				createArrayType(scope);
				return null;
			}
		}

    	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, enclosingType);
		// check argument type compatibility
		if (checkBounds) {// otherwise will do it in Scope.connectTypeVariables() or generic method resolution
			parameterizedType.boundCheck(scope, this.typeArguments);
		} else {
			scope.deferBoundCheck(this);
		}
		if (isTypeUseDeprecated(parameterizedType, scope)) {
			reportDeprecatedType(parameterizedType, scope);
		}

		TypeBinding type = parameterizedType;
		// array type ?

				scope.problemReporter().tooManyDimensions(this);
			type = scope.createArrayType(type, this.dimensions);
		}
		if (hasGenericError) {
			return type;
		}
		return this.resolvedType = type;
	}
	private void createArrayType(Scope scope) {
		if (this.dimensions > 0) {
			if (this.dimensions > 255) {
				scope.problemReporter().tooManyDimensions(this);
			}
			this.resolvedType = scope.createArrayType(this.resolvedType, this.dimensions);
		}
	}

	public StringBuffer printExpression(int indent, StringBuffer output){
		output.append(this.token);




					case AST.JLS3 :
						if (typeArguments != null) {
							int numberOfEnclosingType = 0;
							int startingIndex = 0;
							int endingIndex = 0;
							for (int i = 0, max = typeArguments.length; i < max; i++) {
								if (typeArguments[i] != null) {
									numberOfEnclosingType++;
								} else if (numberOfEnclosingType == 0) {
									endingIndex++;
								}
							}
							Name name = null;
							if (endingIndex - startingIndex == 0) {

							simpleType.setSourceRange(start, end - start + 1);
							ParameterizedType parameterizedType = new ParameterizedType(this.ast);
							parameterizedType.setType(simpleType);
							if (this.resolveBindings) {
								recordNodes(simpleType, typeReference);
								recordNodes(parameterizedType, typeReference);
							}
							start = simpleType.getStartPosition();
							end = start + simpleType.getLength() - 1;
							for (int i = 0, max = typeArguments[endingIndex].length; i < max; i++) {

								QualifiedType qualifiedType = new QualifiedType(this.ast);
								qualifiedType.setQualifier(currentType);
								qualifiedType.setName(simpleName);
								if (this.resolveBindings) {
									recordNodes(simpleName, typeReference);
									recordNodes(qualifiedType, typeReference);
								}
								start = currentType.getStartPosition();
								end = simpleName.getStartPosition() + simpleName.getLength() - 1;
								qualifiedType.setSourceRange(start, end - start + 1);
								indexOfEnclosingType++;
								if (typeArguments[startingIndex] != null) {
									qualifiedType.index = indexOfEnclosingType;
									ParameterizedType parameterizedType2 = new ParameterizedType(this.ast);
									parameterizedType2.setType(qualifiedType);
									parameterizedType2.index = indexOfEnclosingType;
									if (this.resolveBindings) {
										recordNodes(parameterizedType2, typeReference);
									}
									for (int i = 0, max = typeArguments[startingIndex].length; i < max; i++) {
										final Type type2 = convertType(typeArguments[startingIndex][i]);
										parameterizedType2.typeArguments().add(type2);

									currentType = parameterizedType2;
								} else {
									currentType = qualifiedType;
									qualifiedType.index = indexOfEnclosingType;
								}
								startingIndex++;
							}




						return null;
					}
					ArrayType arrayType = (ArrayType) type;
					ArrayBinding arrayBinding = (ArrayBinding) typeBinding;
					return getTypeBinding(this.scope.createArrayType(arrayBinding.leafComponentType, arrayType.getDimensions()));
						return getTypeBinding(this.scope.createArrayType(arrayBinding.leafComponentType, arrayType.getDimensions()));
					}
					return getTypeBinding(this.scope.createArrayType(typeBinding, arrayType.getDimensions()));
				}
				if (typeBinding.isArrayType()) {
					typeBinding = ((ArrayBinding) typeBinding).leafComponentType;

					if (this.scope == null) {
						return null;
					}
					ArrayBinding arrayBinding = (ArrayBinding) binding;
					return getTypeBinding(this.scope.createArrayType(arrayBinding.leafComponentType, arrayType.getDimensions()));
						return getTypeBinding(this.scope.createArrayType(arrayBinding.leafComponentType, arrayType.getDimensions()));
					}
					return getTypeBinding(this.scope.createArrayType(binding, arrayType.getDimensions()));
				} else if (binding.isArrayType()) {
					ArrayBinding arrayBinding = (ArrayBinding) binding;
					return getTypeBinding(arrayBinding.leafComponentType);

Return to bug 342671

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java (-9 / +17 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 148-153 Link Here
148	}	148	}
149	}	149	}
150	}	150	}
		151	createArrayType(scope);
151	return null;	152	return null;
152	}	153	}
153		154
Lines 173-178 Link Here
173	}	174	}
174	}	175	}
175	}	176	}
		177	createArrayType(scope);
176	return null;	178	return null;
177	}	179	}
178	ReferenceBinding currentType = (ReferenceBinding) this.resolvedType;	180	ReferenceBinding currentType = (ReferenceBinding) this.resolvedType;
Lines 219-249 Link Here
219	}	221	}
220	}	222	}
221	if (argHasError) {	223	if (argHasError) {
		224	createArrayType(scope);
222	return null;	225	return null;
223	}	226	}
224	if (isClassScope) {	227	if (isClassScope) {
225	((ClassScope) scope).superTypeReference = keep;	228	((ClassScope) scope).superTypeReference = keep;
226	if (((ClassScope) scope).detectHierarchyCycle(currentOriginal, this))	229	if (((ClassScope) scope).detectHierarchyCycle(currentOriginal, this)) {
		230	createArrayType(scope);
227	return null;	231	return null;
		232	}
228	}	233	}
229		234
230	TypeVariableBinding[] typeVariables = currentOriginal.typeVariables();	235	TypeVariableBinding[] typeVariables = currentOriginal.typeVariables();
231	if (typeVariables == Binding.NO_TYPE_VARIABLES) { // check generic	236	if (typeVariables == Binding.NO_TYPE_VARIABLES) { // check generic
232	if (scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_5) { // below 1.5, already reported as syntax error	237	if (scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_5) { // below 1.5, already reported as syntax error
233	scope.problemReporter().nonGenericTypeCannotBeParameterized(i, this, currentType, argTypes);	238	scope.problemReporter().nonGenericTypeCannotBeParameterized(i, this, currentType, argTypes);
		239	createArrayType(scope);
234	return null;	240	return null;
235	}	241	}
236	this.resolvedType = (qualifyingType != null && qualifyingType.isParameterizedType())	242	this.resolvedType = (qualifyingType != null && qualifyingType.isParameterizedType())
237	? scope.environment().createParameterizedType(currentOriginal, null, qualifyingType)	243	? scope.environment().createParameterizedType(currentOriginal, null, qualifyingType)
238	: currentType;	244	: currentType;
239	if (this.dimensions > 0) {	245	createArrayType(scope);
240	if (this.dimensions > 255)
241	scope.problemReporter().tooManyDimensions(this);
242	this.resolvedType = scope.createArrayType(this.resolvedType, this.dimensions);
243	}
244	return this.resolvedType;	246	return this.resolvedType;
245	} else if (argLength != typeVariables.length) { // check arity	247	} else if (argLength != typeVariables.length) { // check arity
246	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes, i);	248	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes, i);
		249	createArrayType(scope);
247	return null;	250	return null;
248	}	251	}
249	// check parameterizing non-static member type of raw type	252	// check parameterizing non-static member type of raw type
Lines 265-272 Link Here
265	} else {	268	} else {
266	ReferenceBinding currentOriginal = (ReferenceBinding)currentType.original();	269	ReferenceBinding currentOriginal = (ReferenceBinding)currentType.original();
267	if (isClassScope)	270	if (isClassScope)
268	if (((ClassScope) scope).detectHierarchyCycle(currentOriginal, this))	271	if (((ClassScope) scope).detectHierarchyCycle(currentOriginal, this)) {
		272	createArrayType(scope);
269	return null;	273	return null;
		274	}
270	if (currentOriginal.isGenericType()) {	275	if (currentOriginal.isGenericType()) {
271	if (typeIsConsistent && qualifyingType != null && qualifyingType.isParameterizedType()) {	276	if (typeIsConsistent && qualifyingType != null && qualifyingType.isParameterizedType()) {
272	scope.problemReporter().parameterizedMemberTypeMissingArguments(this, scope.environment().createParameterizedType(currentOriginal, null, qualifyingType), i);	277	scope.problemReporter().parameterizedMemberTypeMissingArguments(this, scope.environment().createParameterizedType(currentOriginal, null, qualifyingType), i);
Lines 283-295 Link Here
283	reportDeprecatedType(qualifyingType, scope, i);	288	reportDeprecatedType(qualifyingType, scope, i);
284	this.resolvedType = qualifyingType;	289	this.resolvedType = qualifyingType;
285	}	290	}
		291	createArrayType(scope);
		292	return this.resolvedType;
		293	}
		294	private void createArrayType(Scope scope) {
286	// array type ?	295	// array type ?
287	if (this.dimensions > 0) {	296	if (this.dimensions > 0) {
288	if (this.dimensions > 255)	297	if (this.dimensions > 255)
289	scope.problemReporter().tooManyDimensions(this);	298	scope.problemReporter().tooManyDimensions(this);
290	this.resolvedType = scope.createArrayType(this.resolvedType, this.dimensions);	299	this.resolvedType = scope.createArrayType(this.resolvedType, this.dimensions);
291	}	300	}
292	return this.resolvedType;
293	}	301	}
294		302
295	public StringBuffer printExpression(int indent, StringBuffer output) {	303	public StringBuffer printExpression(int indent, StringBuffer output) {

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java (-38 / +48 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 105-111 Link Here
105	}	105	}
106	}	106	}
107	}	107	}
108	boolean hasGenericError = false;
109	ReferenceBinding currentType;	108	ReferenceBinding currentType;
110	this.bits \|= ASTNode.DidResolve;	109	this.bits \|= ASTNode.DidResolve;
111	if (enclosingType == null) {	110	if (enclosingType == null) {
Lines 113-119 Link Here
113	if (this.resolvedType.isValidBinding()) {	112	if (this.resolvedType.isValidBinding()) {
114	currentType = (ReferenceBinding) this.resolvedType;	113	currentType = (ReferenceBinding) this.resolvedType;
115	} else {	114	} else {
116	hasGenericError = true;
117	reportInvalidType(scope);	115	reportInvalidType(scope);
118	switch (this.resolvedType.problemId()) {	116	switch (this.resolvedType.problemId()) {
119	case ProblemReasons.NotFound :	117	case ProblemReasons.NotFound :
Lines 127-142 Link Here
127	//$FALL-THROUGH$ - unable to complete type binding, but still resolve type arguments	125	//$FALL-THROUGH$ - unable to complete type binding, but still resolve type arguments
128	default :	126	default :
129	boolean isClassScope = scope.kind == Scope.CLASS_SCOPE;	127	boolean isClassScope = scope.kind == Scope.CLASS_SCOPE;
130	int argLength = this.typeArguments.length;	128	int argLength = this.typeArguments.length;
131	for (int i = 0; i < argLength; i++) {	129	for (int i = 0; i < argLength; i++) {
132	TypeReference typeArgument = this.typeArguments[i];	130	TypeReference typeArgument = this.typeArguments[i];
133	if (isClassScope) {	131	if (isClassScope) {
134	typeArgument.resolveType((ClassScope) scope);	132	typeArgument.resolveType((ClassScope) scope);
135	} else {	133	} else {
136	typeArgument.resolveType((BlockScope) scope, checkBounds);	134	typeArgument.resolveType((BlockScope) scope, checkBounds);
		135	}
137	}	136	}
138	}	137	createArrayType(scope);
139	return null;	138	return null;
140	}	139	}
141	// be resilient, still attempt resolving arguments	140	// be resilient, still attempt resolving arguments
142	}	141	}
Lines 150-157 Link Here
150	} else { // resolving member type (relatively to enclosingType)	149	} else { // resolving member type (relatively to enclosingType)
151	this.resolvedType = currentType = scope.getMemberType(this.token, enclosingType);	150	this.resolvedType = currentType = scope.getMemberType(this.token, enclosingType);
152	if (!this.resolvedType.isValidBinding()) {	151	if (!this.resolvedType.isValidBinding()) {
153	hasGenericError = true;
154	scope.problemReporter().invalidEnclosingType(this, currentType, enclosingType);	152	scope.problemReporter().invalidEnclosingType(this, currentType, enclosingType);
		153	createArrayType(scope);
155	return null;	154	return null;
156	}	155	}
157	if (isTypeUseDeprecated(currentType, scope))	156	if (isTypeUseDeprecated(currentType, scope))
Lines 163-196 Link Here
163	}	162	}
164		163
165	// check generic and arity	164	// check generic and arity
166	boolean isClassScope = scope.kind == Scope.CLASS_SCOPE;	165	boolean isClassScope = scope.kind == Scope.CLASS_SCOPE;
167	TypeReference keep = null;	166	TypeReference keep = null;
168	if (isClassScope) {	167	if (isClassScope) {
169	keep = ((ClassScope) scope).superTypeReference;	168	keep = ((ClassScope) scope).superTypeReference;
170	((ClassScope) scope).superTypeReference = null;	169	((ClassScope) scope).superTypeReference = null;
171	}	170	}
172	int argLength = this.typeArguments.length;	171	int argLength = this.typeArguments.length;
173	TypeBinding[] argTypes = new TypeBinding[argLength];	172	TypeBinding[] argTypes = new TypeBinding[argLength];
174	boolean argHasError = false;	173	boolean argHasError = false;
175	ReferenceBinding currentOriginal = (ReferenceBinding)currentType.original();	174	ReferenceBinding currentOriginal = (ReferenceBinding)currentType.original();
176	for (int i = 0; i < argLength; i++) {	175	for (int i = 0; i < argLength; i++) {
177	TypeReference typeArgument = this.typeArguments[i];	176	TypeReference typeArgument = this.typeArguments[i];
178	TypeBinding argType = isClassScope	177	TypeBinding argType = isClassScope
179	? typeArgument.resolveTypeArgument((ClassScope) scope, currentOriginal, i)	178	? typeArgument.resolveTypeArgument((ClassScope) scope, currentOriginal, i)
180	: typeArgument.resolveTypeArgument((BlockScope) scope, currentOriginal, i);	179	: typeArgument.resolveTypeArgument((BlockScope) scope, currentOriginal, i);
181	if (argType == null) {	180	if (argType == null) {
182	argHasError = true;	181	argHasError = true;
183	} else {	182	} else {
184	argTypes[i] = argType;	183	argTypes[i] = argType;
185	}	184	}
186	}	185	}
187	if (argHasError) {	186	if (argHasError) {
		187	createArrayType(scope);
188	return null;	188	return null;
189	}	189	}
190	if (isClassScope) {	190	if (isClassScope) {
191	((ClassScope) scope).superTypeReference = keep;	191	((ClassScope) scope).superTypeReference = keep;
192	if (((ClassScope) scope).detectHierarchyCycle(currentOriginal, this))	192	if (((ClassScope) scope).detectHierarchyCycle(currentOriginal, this)) {
		193	createArrayType(scope);
193	return null;	194	return null;
		195	}
194	}	196	}
195		197
196	TypeVariableBinding[] typeVariables = currentOriginal.typeVariables();	198	TypeVariableBinding[] typeVariables = currentOriginal.typeVariables();
Lines 200-205 Link Here
200	if (isCompliant15) { // below 1.5, already reported as syntax error	202	if (isCompliant15) { // below 1.5, already reported as syntax error
201	this.resolvedType = currentType;	203	this.resolvedType = currentType;
202	scope.problemReporter().nonGenericTypeCannotBeParameterized(0, this, currentType, argTypes);	204	scope.problemReporter().nonGenericTypeCannotBeParameterized(0, this, currentType, argTypes);
		205	createArrayType(scope);
203	return null;	206	return null;
204	}	207	}
205	}	208	}
Lines 212-242 Link Here
212	scope.problemReporter().tooManyDimensions(this);	215	scope.problemReporter().tooManyDimensions(this);
213	type = scope.createArrayType(type, this.dimensions);	216	type = scope.createArrayType(type, this.dimensions);
214	}	217	}
215	if (hasGenericError)
216	return type;
217	return this.resolvedType = type;	218	return this.resolvedType = type;
218	}	219	}
219	// if missing generic type, and compliance >= 1.5, then will rebuild a parameterized binding	220	// if missing generic type, and compliance >= 1.5, then will rebuild a parameterized binding
220	} else if (argLength != typeVariables.length) { // check arity	221	} else if (argLength != typeVariables.length) { // check arity
221	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);	222	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);
		223	createArrayType(scope);
222	return null;	224	return null;
223	} else if (!currentType.isStatic()) {	225	} else if (!currentType.isStatic()) {
224	ReferenceBinding actualEnclosing = currentType.enclosingType();	226	ReferenceBinding actualEnclosing = currentType.enclosingType();
225	if (actualEnclosing != null && actualEnclosing.isRawType()){	227	if (actualEnclosing != null && actualEnclosing.isRawType()){
226	scope.problemReporter().rawMemberTypeCannotBeParameterized(	228	scope.problemReporter().rawMemberTypeCannotBeParameterized(
227	this, scope.environment().createRawType(currentOriginal, actualEnclosing), argTypes);	229	this, scope.environment().createRawType(currentOriginal, actualEnclosing), argTypes);
		230	createArrayType(scope);
228	return null;	231	return null;
229	}	232	}
230	}	233	}
231		234
232	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, enclosingType);	235	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, enclosingType);
233	// check argument type compatibility	236	// check argument type compatibility
234	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution	237	if (checkBounds) {// otherwise will do it in Scope.connectTypeVariables() or generic method resolution
235	parameterizedType.boundCheck(scope, this.typeArguments);	238	parameterizedType.boundCheck(scope, this.typeArguments);
236	else	239	} else {
237	scope.deferBoundCheck(this);	240	scope.deferBoundCheck(this);
238	if (isTypeUseDeprecated(parameterizedType, scope))	241	}
		242	if (isTypeUseDeprecated(parameterizedType, scope)) {
239	reportDeprecatedType(parameterizedType, scope);	243	reportDeprecatedType(parameterizedType, scope);
		244	}
240		245
241	TypeBinding type = parameterizedType;	246	TypeBinding type = parameterizedType;
242	// array type ?	247	// array type ?
Lines 245-255 Link Here
245	scope.problemReporter().tooManyDimensions(this);	250	scope.problemReporter().tooManyDimensions(this);
246	type = scope.createArrayType(type, this.dimensions);	251	type = scope.createArrayType(type, this.dimensions);
247	}	252	}
248	if (hasGenericError) {
249	return type;
250	}
251	return this.resolvedType = type;	253	return this.resolvedType = type;
252	}	254	}
		255	private void createArrayType(Scope scope) {
		256	if (this.dimensions > 0) {
		257	if (this.dimensions > 255) {
		258	scope.problemReporter().tooManyDimensions(this);
		259	}
		260	this.resolvedType = scope.createArrayType(this.resolvedType, this.dimensions);
		261	}
		262	}
253		263
254	public StringBuffer printExpression(int indent, StringBuffer output){	264	public StringBuffer printExpression(int indent, StringBuffer output){
255	output.append(this.token);	265	output.append(this.token);

Lines 1523-1533 Link Here

(-)dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java (-10 / +4 lines)
1523	return null;	1523	return null;
1524	}	1524	}
1525	ArrayType arrayType = (ArrayType) type;	1525	ArrayType arrayType = (ArrayType) type;
1526	if (typeBinding.isArrayType()) {	1526	ArrayBinding arrayBinding = (ArrayBinding) typeBinding;
1527	ArrayBinding arrayBinding = (ArrayBinding) typeBinding;	1527	return getTypeBinding(this.scope.createArrayType(arrayBinding.leafComponentType, arrayType.getDimensions()));
1528	return getTypeBinding(this.scope.createArrayType(arrayBinding.leafComponentType, arrayType.getDimensions()));
1529	}
1530	return getTypeBinding(this.scope.createArrayType(typeBinding, arrayType.getDimensions()));
1531	}	1528	}
1532	if (typeBinding.isArrayType()) {	1529	if (typeBinding.isArrayType()) {
1533	typeBinding = ((ArrayBinding) typeBinding).leafComponentType;	1530	typeBinding = ((ArrayBinding) typeBinding).leafComponentType;
Lines 1567-1577 Link Here
1567	if (this.scope == null) {	1564	if (this.scope == null) {
1568	return null;	1565	return null;
1569	}	1566	}
1570	if (binding.isArrayType()) {	1567	ArrayBinding arrayBinding = (ArrayBinding) binding;
1571	ArrayBinding arrayBinding = (ArrayBinding) binding;	1568	return getTypeBinding(this.scope.createArrayType(arrayBinding.leafComponentType, arrayType.getDimensions()));
1572	return getTypeBinding(this.scope.createArrayType(arrayBinding.leafComponentType, arrayType.getDimensions()));
1573	}
1574	return getTypeBinding(this.scope.createArrayType(binding, arrayType.getDimensions()));
1575	} else if (binding.isArrayType()) {	1569	} else if (binding.isArrayType()) {
1576	ArrayBinding arrayBinding = (ArrayBinding) binding;	1570	ArrayBinding arrayBinding = (ArrayBinding) binding;
1577	return getTypeBinding(arrayBinding.leafComponentType);	1571	return getTypeBinding(arrayBinding.leafComponentType);

Lines 3157-3170 Link Here

(-)dom/org/eclipse/jdt/core/dom/ASTConverter.java (-18 / +18 lines)
3157	case AST.JLS3 :	3157	case AST.JLS3 :
3158	if (typeArguments != null) {	3158	if (typeArguments != null) {
3159	int numberOfEnclosingType = 0;	3159	int numberOfEnclosingType = 0;
3160	int startingIndex = 0;	3160	int startingIndex = 0;
3161	int endingIndex = 0;	3161	int endingIndex = 0;
3162	for (int i = 0, max = typeArguments.length; i < max; i++) {	3162	for (int i = 0, max = typeArguments.length; i < max; i++) {
3163	if (typeArguments[i] != null) {	3163	if (typeArguments[i] != null) {
3164	numberOfEnclosingType++;	3164	numberOfEnclosingType++;
3165	} else if (numberOfEnclosingType == 0) {	3165	} else if (numberOfEnclosingType == 0) {
3166	endingIndex++;	3166	endingIndex++;
3167	}	3167	}
3168	}	3168	}
3169	Name name = null;	3169	Name name = null;
3170	if (endingIndex - startingIndex == 0) {	3170	if (endingIndex - startingIndex == 0) {
Lines 3189-3198 Link Here
3189	simpleType.setSourceRange(start, end - start + 1);	3189	simpleType.setSourceRange(start, end - start + 1);
3190	ParameterizedType parameterizedType = new ParameterizedType(this.ast);	3190	ParameterizedType parameterizedType = new ParameterizedType(this.ast);
3191	parameterizedType.setType(simpleType);	3191	parameterizedType.setType(simpleType);
3192	if (this.resolveBindings) {	3192	if (this.resolveBindings) {
3193	recordNodes(simpleType, typeReference);	3193	recordNodes(simpleType, typeReference);
3194	recordNodes(parameterizedType, typeReference);	3194	recordNodes(parameterizedType, typeReference);
3195	}	3195	}
3196	start = simpleType.getStartPosition();	3196	start = simpleType.getStartPosition();
3197	end = start + simpleType.getLength() - 1;	3197	end = start + simpleType.getLength() - 1;
3198	for (int i = 0, max = typeArguments[endingIndex].length; i < max; i++) {	3198	for (int i = 0, max = typeArguments[endingIndex].length; i < max; i++) {
Lines 3218-3239 Link Here
3218	QualifiedType qualifiedType = new QualifiedType(this.ast);	3218	QualifiedType qualifiedType = new QualifiedType(this.ast);
3219	qualifiedType.setQualifier(currentType);	3219	qualifiedType.setQualifier(currentType);
3220	qualifiedType.setName(simpleName);	3220	qualifiedType.setName(simpleName);
3221	if (this.resolveBindings) {	3221	if (this.resolveBindings) {
3222	recordNodes(simpleName, typeReference);	3222	recordNodes(simpleName, typeReference);
3223	recordNodes(qualifiedType, typeReference);	3223	recordNodes(qualifiedType, typeReference);
3224	}	3224	}
3225	start = currentType.getStartPosition();	3225	start = currentType.getStartPosition();
3226	end = simpleName.getStartPosition() + simpleName.getLength() - 1;	3226	end = simpleName.getStartPosition() + simpleName.getLength() - 1;
3227	qualifiedType.setSourceRange(start, end - start + 1);	3227	qualifiedType.setSourceRange(start, end - start + 1);
3228	indexOfEnclosingType++;	3228	indexOfEnclosingType++;
3229	if (typeArguments[startingIndex] != null) {	3229	if (typeArguments[startingIndex] != null) {
3230	qualifiedType.index = indexOfEnclosingType;	3230	qualifiedType.index = indexOfEnclosingType;
3231	ParameterizedType parameterizedType2 = new ParameterizedType(this.ast);	3231	ParameterizedType parameterizedType2 = new ParameterizedType(this.ast);
3232	parameterizedType2.setType(qualifiedType);	3232	parameterizedType2.setType(qualifiedType);
3233	parameterizedType2.index = indexOfEnclosingType;	3233	parameterizedType2.index = indexOfEnclosingType;
3234	if (this.resolveBindings) {	3234	if (this.resolveBindings) {
3235	recordNodes(parameterizedType2, typeReference);	3235	recordNodes(parameterizedType2, typeReference);
3236	}	3236	}
3237	for (int i = 0, max = typeArguments[startingIndex].length; i < max; i++) {	3237	for (int i = 0, max = typeArguments[startingIndex].length; i < max; i++) {
3238	final Type type2 = convertType(typeArguments[startingIndex][i]);	3238	final Type type2 = convertType(typeArguments[startingIndex][i]);
3239	parameterizedType2.typeArguments().add(type2);	3239	parameterizedType2.typeArguments().add(type2);
Lines 3245-3251 Link Here
3245	currentType = parameterizedType2;	3245	currentType = parameterizedType2;
3246	} else {	3246	} else {
3247	currentType = qualifiedType;	3247	currentType = qualifiedType;
3248	qualifiedType.index = indexOfEnclosingType;	3248	qualifiedType.index = indexOfEnclosingType;
3249	}	3249	}
3250	startingIndex++;	3250	startingIndex++;
3251	}	3251	}