Attachment #191785 for bug #339478

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 1377-1383 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (-1 / +2 lines)
1377	int MultiCatchNotBelow17 = Syntax + Internal + 875;	1377	int MultiCatchNotBelow17 = Syntax + Internal + 875;
1378	/** @since 3.7 */	1378	/** @since 3.7 */
1379	int PolymorphicMethodNotBelow17 = MethodRelated + 876;	1379	int PolymorphicMethodNotBelow17 = MethodRelated + 876;
1380		1380	/** @since 3.7 */
		1381	int InvalidUsageOfDiamondConstruct = Syntax + TypeRelated + 877;
1381	/**	1382	/**
1382	* External problems -- These are problems defined by other plugins	1383	* External problems -- These are problems defined by other plugins
1383	*/	1384	*/

Lines 29-35 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (-2 / +15 lines)
29	public TypeReference[] typeArguments;	29	public TypeReference[] typeArguments;
30	public TypeBinding[] genericTypeArguments;	30	public TypeBinding[] genericTypeArguments;
31	public FieldDeclaration enumConstant; // for enum constant initializations	31	public FieldDeclaration enumConstant; // for enum constant initializations
32		32	protected TypeBinding expectedType;
		33
33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	34	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
34	// check captured variables are initialized in current context (26134)	35	// check captured variables are initialized in current context (26134)
35	checkCapturedLocalInitializationIfNecessary((ReferenceBinding)this.binding.declaringClass.erasure(), currentScope, flowInfo);	36	checkCapturedLocalInitializationIfNecessary((ReferenceBinding)this.binding.declaringClass.erasure(), currentScope, flowInfo);
Lines 255-261 Link Here
255	// initialization of an enum constant	256	// initialization of an enum constant
256	this.resolvedType = scope.enclosingReceiverType();	257	this.resolvedType = scope.enclosingReceiverType();
257	} else {	258	} else {
258	this.resolvedType = this.type.resolveType(scope, true /* check bounds*/);	259	TypeBinding inferredArguments[] = null;
		260	if ((scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7) && (this.type.bits & ASTNode.IsDiamond) != 0) {
		261	if (this.expectedType != null && this.expectedType.isParameterizedTypeWithActualArguments())
		262	inferredArguments = ((ParameterizedTypeBinding)this.expectedType).arguments;
		263	}
		264	this.resolvedType = this.type.resolveType(scope, true /* check bounds*/, inferredArguments);
259	checkParameterizedAllocation: {	265	checkParameterizedAllocation: {
260	if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()	266	if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
261	ReferenceBinding currentType = (ReferenceBinding)this.resolvedType;	267	ReferenceBinding currentType = (ReferenceBinding)this.resolvedType;
Lines 409-412 Link Here
409	}	415	}
410	visitor.endVisit(this, scope);	416	visitor.endVisit(this, scope);
411	}	417	}
		418	/**
		419	* @see org.eclipse.jdt.internal.compiler.ast.Expression#setExpectedType(org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
		420	*/
		421	public void setExpectedType(TypeBinding expectedType) {
		422	this.expectedType = expectedType;
		423	}
		424
412	}	425	}




					this.initialization.computeConversion(initializationScope, fieldType, initializationType);
				}
			} else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) {
				boolean isDiamond = false;
				if (this.initialization instanceof AllocationExpression) {	
					AllocationExpression allocationExpression = (AllocationExpression) this.initialization;
					if (initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7 
							&& allocationExpression.type != null
							&& (allocationExpression.type.bits & ASTNode.IsDiamond) != 0) {
						isDiamond = true;
					}
				}
				if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()
					initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);
				if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)
						|| initializationType.isCompatibleWith(fieldType, isDiamond)) {
					this.initialization.computeConversion(initializationScope, fieldType, initializationType);
					if (initializationType.needsUncheckedConversion(fieldType)) {
						    initializationScope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, fieldType);

Lines 157-163 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (-2 / +11 lines)
157	}	157	}
158		158
159	public void resolve(BlockScope scope) {	159	public void resolve(BlockScope scope) {
160		160	boolean isCompliant17 = scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_7;
161	// create a binding and add it to the scope	161	// create a binding and add it to the scope
162	TypeBinding variableType = this.type.resolveType(scope, true /* check bounds*/);	162	TypeBinding variableType = this.type.resolveType(scope, true /* check bounds*/);
163		163
Lines 171-176 Link Here
171	scope.problemReporter().variableTypeCannotBeVoidArray(this);	171	scope.problemReporter().variableTypeCannotBeVoidArray(this);
172	return;	172	return;
173	}	173	}
		174	if (isCompliant17 && variableType.isParameterizedType() && (this.type.bits & ASTNode.IsDiamond) != 0) {
		175	scope.problemReporter().incorrectArityForParameterizedType(this.type, variableType.original(), ((ParameterizedTypeBinding)variableType).arguments);
		176	return;
		177	}
174	}	178	}
175		179
176	Binding existingVariable = scope.getBinding(this.name, Binding.VARIABLE, this, false /do not resolve hidden field/);	180	Binding existingVariable = scope.getBinding(this.name, Binding.VARIABLE, this, false /do not resolve hidden field/);
Lines 207-218 Link Here
207	}	211	}
208	} else {	212	} else {
209	this.initialization.setExpectedType(variableType);	213	this.initialization.setExpectedType(variableType);
		214	boolean isDiamond = false;
210	TypeBinding initializationType = this.initialization.resolveType(scope);	215	TypeBinding initializationType = this.initialization.resolveType(scope);
		216	if (this.initialization instanceof AllocationExpression) {
		217	if (isCompliant17 && (((AllocationExpression) this.initialization).type.bits & ASTNode.IsDiamond) != 0)
		218	isDiamond = true;
		219	}
211	if (initializationType != null) {	220	if (initializationType != null) {
212	if (variableType != initializationType) // must call before computeConversion() and typeMismatchError()	221	if (variableType != initializationType) // must call before computeConversion() and typeMismatchError()
213	scope.compilationUnitScope().recordTypeConversion(variableType, initializationType);	222	scope.compilationUnitScope().recordTypeConversion(variableType, initializationType);
214	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, variableType)	223	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, variableType)
215	\|\| initializationType.isCompatibleWith(variableType)) {	224	\|\| initializationType.isCompatibleWith(variableType, isDiamond)) {
216	this.initialization.computeConversion(scope, variableType, initializationType);	225	this.initialization.computeConversion(scope, variableType, initializationType);
217	if (initializationType.needsUncheckedConversion(variableType)) {	226	if (initializationType.needsUncheckedConversion(variableType)) {
218	scope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, variableType);	227	scope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, variableType);

Lines 27-32 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java (-3 / +24 lines)
27	public class ParameterizedQualifiedTypeReference extends ArrayQualifiedTypeReference {	27	public class ParameterizedQualifiedTypeReference extends ArrayQualifiedTypeReference {
28		28
29	public TypeReference[][] typeArguments;	29	public TypeReference[][] typeArguments;
		30	public TypeBinding[] inferredTypeArgs;
30		31
31	/**	32	/**
32	* @param tokens	33	* @param tokens
Lines 37-42 Link Here
37		38
38	super(tokens, dim, positions);	39	super(tokens, dim, positions);
39	this.typeArguments = typeArguments;	40	this.typeArguments = typeArguments;
		41	this.inferredTypeArgs = null;
40	}	42	}
41	public void checkBounds(Scope scope) {	43	public void checkBounds(Scope scope) {
42	if (this.resolvedType == null) return;	44	if (this.resolvedType == null) return;
Lines 68-73 Link Here
68	* @return char[][]	70	* @return char[][]
69	*/	71	*/
70	public char [][] getParameterizedTypeName(){	72	public char [][] getParameterizedTypeName(){
		73	if ((this.bits & ASTNode.IsDiamond) != 0)
		74	return this.getTypeName();
71	int length = this.tokens.length;	75	int length = this.tokens.length;
72	char[][] qParamName = new char[length][];	76	char[][] qParamName = new char[length][];
73	for (int i = 0; i < length; i++) {	77	for (int i = 0; i < length; i++) {
Lines 222-227 Link Here
222	argTypes[j] = argType;	226	argTypes[j] = argType;
223	}	227	}
224	}	228	}
		229	if (argLength == 0 && (this.bits & ASTNode.IsDiamond) != 0 && this.inferredTypeArgs != null) {
		230	argTypes = this.inferredTypeArgs;
		231	}
225	if (argHasError) {	232	if (argHasError) {
226	return null;	233	return null;
227	}	234	}
Lines 247-254 Link Here
247	}	254	}
248	return this.resolvedType;	255	return this.resolvedType;
249	} else if (argLength != typeVariables.length) { // check arity	256	} else if (argLength != typeVariables.length) { // check arity
250	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes, i);	257	if(scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_7 && argLength == 0) {
251	return null;	258	if ((this.bits & ASTNode.IsDiamond) ==0) {
		259	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);
		260	return null;
		261	}
		262	// argLength = 0 ok if its the diamond case for compliance >= 1.7
		263	// also no need to check bounds for such a case
		264	checkBounds = false;
		265	} else {
		266	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes, i);
		267	return null;
		268	}
252	}	269	}
253	// check parameterizing non-static member type of raw type	270	// check parameterizing non-static member type of raw type
254	if (typeIsConsistent && !currentType.isStatic()) {	271	if (typeIsConsistent && !currentType.isStatic()) {
Lines 343-349 Link Here
343	}	360	}
344	return output;	361	return output;
345	}	362	}
346		363
		364	public TypeBinding resolveType(BlockScope scope, boolean checkBounds, TypeBinding[] inferredArgs) {
		365	this.inferredTypeArgs = inferredArgs;
		366	return internalResolveType(scope, checkBounds);
		367	}
347	public TypeBinding resolveType(BlockScope scope, boolean checkBounds) {	368	public TypeBinding resolveType(BlockScope scope, boolean checkBounds) {
348	return internalResolveType(scope, checkBounds);	369	return internalResolveType(scope, checkBounds);
349	}	370	}

Lines 27-37 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java (-2 / +25 lines)
27	public class ParameterizedSingleTypeReference extends ArrayTypeReference {	27	public class ParameterizedSingleTypeReference extends ArrayTypeReference {
28		28
29	public TypeReference[] typeArguments;	29	public TypeReference[] typeArguments;
		30	public TypeBinding[] inferredTypeArgs;
30		31
31	public ParameterizedSingleTypeReference(char[] name, TypeReference[] typeArguments, int dim, long pos){	32	public ParameterizedSingleTypeReference(char[] name, TypeReference[] typeArguments, int dim, long pos){
32	super(name, dim, pos);	33	super(name, dim, pos);
33	this.originalSourceEnd = this.sourceEnd;	34	this.originalSourceEnd = this.sourceEnd;
34	this.typeArguments = typeArguments;	35	this.typeArguments = typeArguments;
		36	this.inferredTypeArgs = null;
35	}	37	}
36	public void checkBounds(Scope scope) {	38	public void checkBounds(Scope scope) {
37	if (this.resolvedType == null) return;	39	if (this.resolvedType == null) return;
Lines 57-62 Link Here
57	* @return char[][]	59	* @return char[][]
58	*/	60	*/
59	public char [][] getParameterizedTypeName(){	61	public char [][] getParameterizedTypeName(){
		62	if ((this.bits & ASTNode.IsDiamond) != 0)
		63	return this.getTypeName();
60	StringBuffer buffer = new StringBuffer(5);	64	StringBuffer buffer = new StringBuffer(5);
61	buffer.append(this.token).append('<');	65	buffer.append(this.token).append('<');
62	for (int i = 0, length = this.typeArguments.length; i < length; i++) {	66	for (int i = 0, length = this.typeArguments.length; i < length; i++) {
Lines 90-95 Link Here
90	* No need to check for reference to raw type per construction	94	* No need to check for reference to raw type per construction
91	*/	95	*/
92	private TypeBinding internalResolveType(Scope scope, ReferenceBinding enclosingType, boolean checkBounds) {	96	private TypeBinding internalResolveType(Scope scope, ReferenceBinding enclosingType, boolean checkBounds) {
		97	boolean isCompliant17 = scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_7;
93	// handle the error here	98	// handle the error here
94	this.constant = Constant.NotAConstant;	99	this.constant = Constant.NotAConstant;
95	if ((this.bits & ASTNode.DidResolve) != 0) { // is a shared type reference which was already resolved	100	if ((this.bits & ASTNode.DidResolve) != 0) { // is a shared type reference which was already resolved
Lines 188-193 Link Here
188	argTypes[i] = argType;	193	argTypes[i] = argType;
189	}	194	}
190	}	195	}
		196	if (argLength == 0 && (this.bits & ASTNode.IsDiamond) != 0 && this.inferredTypeArgs != null) {
		197	argTypes = this.inferredTypeArgs;
		198	}
191	if (argHasError) {	199	if (argHasError) {
192	return null;	200	return null;
193	}	201	}
Lines 222-229 Link Here
222	}	230	}
223	// if missing generic type, and compliance >= 1.5, then will rebuild a parameterized binding	231	// if missing generic type, and compliance >= 1.5, then will rebuild a parameterized binding
224	} else if (argLength != typeVariables.length) { // check arity	232	} else if (argLength != typeVariables.length) { // check arity
225	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);	233	if(isCompliant17 && argLength == 0) {
226	return null;	234	if ((this.bits & ASTNode.IsDiamond) ==0) {
		235	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);
		236	return null;
		237	}
		238	// argLength = 0 ok if its the diamond case for compliance >= 1.7
		239	// also no need to check bounds for such a case
		240	checkBounds = false;
		241	} else {
		242	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);
		243	return null;
		244	}
227	} else if (!currentType.isStatic()) {	245	} else if (!currentType.isStatic()) {
228	ReferenceBinding actualEnclosing = currentType.enclosingType();	246	ReferenceBinding actualEnclosing = currentType.enclosingType();
229	if (actualEnclosing != null && actualEnclosing.isRawType()){	247	if (actualEnclosing != null && actualEnclosing.isRawType()){
Lines 281-286 Link Here
281	return output;	299	return output;
282	}	300	}
283		301
		302	public TypeBinding resolveType(BlockScope scope, boolean checkBounds, TypeBinding[] inferredArgs) {
		303	this.inferredTypeArgs = inferredArgs;
		304	return internalResolveType(scope, null, checkBounds);
		305	}
		306
284	public TypeBinding resolveType(BlockScope scope, boolean checkBounds) {	307	public TypeBinding resolveType(BlockScope scope, boolean checkBounds) {
285	return internalResolveType(scope, null, checkBounds);	308	return internalResolveType(scope, null, checkBounds);
286	}	309	}

Lines 236-242 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (-1 / +17 lines)
236	boolean hasError = false;	236	boolean hasError = false;
237	boolean enclosingInstanceContainsCast = false;	237	boolean enclosingInstanceContainsCast = false;
238	boolean argsContainCast = false;	238	boolean argsContainCast = false;
239		239	boolean isCompliant17 = scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_7;
		240	if (this.type != null) { // this.type = null for enum initialization
		241	if (isCompliant17 && this.anonymousType != null && (this.type.bits & ASTNode.IsDiamond) != 0) {
		242	// don't allow diamond construct if this allocation expressions corresponds to an anonymous type being declared
		243	scope.problemReporter().invalidUsageOfDiamondConstruct(this.type);
		244	return null;
		245	}
		246	}
240	if (this.enclosingInstance != null) {	247	if (this.enclosingInstance != null) {
241	if (this.enclosingInstance instanceof CastExpression) {	248	if (this.enclosingInstance instanceof CastExpression) {
242	this.enclosingInstance.bits \|= ASTNode.DisableUnnecessaryCastCheck; // will check later on	249	this.enclosingInstance.bits \|= ASTNode.DisableUnnecessaryCastCheck; // will check later on
Lines 498-501 Link Here
498	}	505	}
499	visitor.endVisit(this, scope);	506	visitor.endVisit(this, scope);
500	}	507	}
		508
		509	/**
		510	* @see org.eclipse.jdt.internal.compiler.ast.Expression#setExpectedType(org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
		511	*/
		512	public void setExpectedType(TypeBinding expectedType) {
		513	this.expectedType = expectedType;
		514	if (this.expectedType != null && this.enclosingInstance != null)
		515	this.enclosingInstance.setExpectedType(this.expectedType.enclosingType());
		516	}
501	}	517	}

Lines 208-213 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeReference.java (+4 lines)
208	return internalResolveType(scope);	208	return internalResolveType(scope);
209	}	209	}
210		210
		211	public TypeBinding resolveType(BlockScope scope, boolean checkBounds, TypeBinding[] inferredArgs) {
		212	return internalResolveType(scope);
		213	}
		214
211	public TypeBinding resolveType(ClassScope scope) {	215	public TypeBinding resolveType(ClassScope scope) {
212	return internalResolveType(scope);	216	return internalResolveType(scope);
213	}	217	}

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java (-2 / +10 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2010 IBM Corporation and others.	2	* Copyright (c) 2005, 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 31-36 Link Here
31	public ReferenceBinding[] memberTypes;	31	public ReferenceBinding[] memberTypes;
32	public MethodBinding[] methods;	32	public MethodBinding[] methods;
33	private ReferenceBinding enclosingType;	33	private ReferenceBinding enclosingType;
		34	private TypeBinding[] expectedArgumentTypes;
34		35
35	public ParameterizedTypeBinding(ReferenceBinding type, TypeBinding[] arguments, ReferenceBinding enclosingType, LookupEnvironment environment){	36	public ParameterizedTypeBinding(ReferenceBinding type, TypeBinding[] arguments, ReferenceBinding enclosingType, LookupEnvironment environment){
36	this.environment = environment;	37	this.environment = environment;
Lines 451-457 Link Here
451	public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) {	452	public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) {
452	int argCount = argumentTypes.length;	453	int argCount = argumentTypes.length;
453	MethodBinding match = null;	454	MethodBinding match = null;
454		455	this.expectedArgumentTypes = argumentTypes;
455	if ((this.tagBits & TagBits.AreMethodsComplete) != 0) { // have resolved all arg types & return type of the methods	456	if ((this.tagBits & TagBits.AreMethodsComplete) != 0) { // have resolved all arg types & return type of the methods
456	long range;	457	long range;
457	if ((range = ReferenceBinding.binarySearch(TypeConstants.INIT, this.methods)) >= 0) {	458	if ((range = ReferenceBinding.binarySearch(TypeConstants.INIT, this.methods)) >= 0) {
Lines 955-960 Link Here
955	// lazy init, since cannot do so during binding creation if during supertype connection	956	// lazy init, since cannot do so during binding creation if during supertype connection
956	if (currentType.arguments == null)	957	if (currentType.arguments == null)
957	currentType.initializeArguments(); // only for raw types	958	currentType.initializeArguments(); // only for raw types
		959	else if (currentType.arguments.length == 0) { // diamond case
		960	// this.expectedArgumentTypes should have the argument list
		961	if (currentType.expectedArgumentTypes != null && currentType.expectedArgumentTypes.length != 0) {
		962	return currentType.expectedArgumentTypes[originalVariable.rank];
		963	}
		964	return originalVariable;
		965	}
958	if (currentType.arguments != null)	966	if (currentType.arguments != null)
959	return currentType.arguments[originalVariable.rank];	967	return currentType.arguments[originalVariable.rank];
960	}	968	}




 * In addition to improving performance, caching also ensures there is no infinite regression
 * since per nature, the compatibility check is recursive through parameterized type arguments (122775)
 */
public boolean isCompatibleWith(TypeBinding otherType, boolean isDiamondCase) {
	if (isDiamondCase) {
		if (this.erasure() == otherType.erasure())
			return true;
	}
	return isCompatibleWith(otherType);
}
/**
 * Answer true if the receiver type can be assigned to the argument type (right)
 * In addition to improving performance, caching also ensures there is no infinite regression
 * since per nature, the compatibility check is recursive through parameterized type arguments (122775)
 */
public boolean isCompatibleWith(TypeBinding otherType) {
	if (otherType == this)
		return true;

Lines 1310-1315 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java (-1 / +13 lines)
1310	fieldDecl.binding = null;	1310	fieldDecl.binding = null;
1311	return null;	1311	return null;
1312	}	1312	}
		1313	if ((this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7) &&
		1314	fieldDecl.type != null &&
		1315	((fieldDecl.type.bits & ASTNode.IsDiamond) != 0)) {
		1316	this.scope.problemReporter().incorrectArityForParameterizedType(fieldDecl.type, fieldType, Binding.NO_TYPES);
		1317	fieldDecl.binding = null;
		1318	return null;
		1319	}
1313	if (fieldType == TypeBinding.VOID) {	1320	if (fieldType == TypeBinding.VOID) {
1314	this.scope.problemReporter().variableTypeCannotBeVoid(fieldDecl);	1321	this.scope.problemReporter().variableTypeCannotBeVoid(fieldDecl);
1315	fieldDecl.binding = null;	1322	fieldDecl.binding = null;
Lines 1390-1395 Link Here
1390	final boolean reportUnavoidableGenericTypeProblems = this.scope.compilerOptions().reportUnavoidableGenericTypeProblems;	1397	final boolean reportUnavoidableGenericTypeProblems = this.scope.compilerOptions().reportUnavoidableGenericTypeProblems;
1391	boolean foundArgProblem = false;	1398	boolean foundArgProblem = false;
1392	Argument[] arguments = methodDecl.arguments;	1399	Argument[] arguments = methodDecl.arguments;
		1400	boolean isCompliant17 = this.scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_7;
1393	if (arguments != null) {	1401	if (arguments != null) {
1394	int size = arguments.length;	1402	int size = arguments.length;
1395	method.parameters = Binding.NO_PARAMETERS;	1403	method.parameters = Binding.NO_PARAMETERS;
Lines 1415-1420 Link Here
1415		1423
1416	if (parameterType == null) {	1424	if (parameterType == null) {
1417	foundArgProblem = true;	1425	foundArgProblem = true;
		1426	} else if (isCompliant17 && (arg.type.bits & ASTNode.IsDiamond) != 0) {
		1427	// a parameter type cannot use diamond construct
		1428	methodDecl.scope.problemReporter().incorrectArityForParameterizedType(arg.type, parameterType.original(), Binding.NO_TYPES);
		1429	foundArgProblem = true;
1418	} else if (parameterType == TypeBinding.VOID) {	1430	} else if (parameterType == TypeBinding.VOID) {
1419	methodDecl.scope.problemReporter().argumentTypeCannotBeVoid(this, methodDecl, arg);	1431	methodDecl.scope.problemReporter().argumentTypeCannotBeVoid(this, methodDecl, arg);
1420	foundArgProblem = true;	1432	foundArgProblem = true;
Lines 1436-1442 Link Here
1436	}	1448	}
1437		1449
1438	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=337799	1450	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=337799
1439	if (this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7) {	1451	if (isCompliant17) {
1440	if ((method.tagBits & TagBits.AnnotationSafeVarargs) != 0) {	1452	if ((method.tagBits & TagBits.AnnotationSafeVarargs) != 0) {
1441	if (!method.isVarargs()) {	1453	if (!method.isVarargs()) {
1442	methodDecl.scope.problemReporter().safeVarargsOnFixedArityMethod(method);	1454	methodDecl.scope.problemReporter().safeVarargsOnFixedArityMethod(method);

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java (-1 / +5 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 1183-1186 Link Here
1183	public TypeVariableBinding[] typeVariables() {	1183	public TypeVariableBinding[] typeVariables() {
1184	return Binding.NO_TYPE_VARIABLES;	1184	return Binding.NO_TYPE_VARIABLES;
1185	}	1185	}
		1186
		1187	public boolean isCompatibleWith(TypeBinding variableType, boolean isDiamond){
		1188	return isCompatibleWith(variableType);
		1189	}
1186	}	1190	}




	// zero type arguments == <>
	pushOnGenericsLengthStack(-1);
	concatGenericsLists();
	this.intPtr--;	// no reference type to be consumed between < and >
}
protected void consumeImportDeclaration() {
	// SingleTypeImportDeclaration ::= SingleTypeImportDeclarationName ';'

		if (dim != 0) {
			parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;
		}
		if (isDiamond && (this.options.sourceLevel >= ClassFileConstants.JDK1_7)) {
			if (parameterizedSingleTypeReference.dimensions == 0)
				parameterizedSingleTypeReference.bits |= ASTNode.IsDiamond;
		}
		return parameterizedSingleTypeReference;
	} else {

		if (dim != 0) {
			parameterizedQualifiedTypeReference.sourceEnd = this.endStatementPosition;
		}
		if (isDiamond && (this.options.sourceLevel >= ClassFileConstants.JDK1_7)) {
			parameterizedQualifiedTypeReference.bits |= ASTNode.IsDiamond;
		}
		return parameterizedQualifiedTypeReference;

Lines 3877-3882 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (+8 lines)
3877	annotationTypeDeclaration.sourceStart,	3877	annotationTypeDeclaration.sourceStart,
3878	annotationTypeDeclaration.sourceEnd);	3878	annotationTypeDeclaration.sourceEnd);
3879	}	3879	}
		3880	public void invalidUsageOfDiamondConstruct(ASTNode typeRef) {
		3881	this.handle(
		3882	IProblem.InvalidUsageOfDiamondConstruct,
		3883	NoArgument,
		3884	NoArgument,
		3885	typeRef.sourceStart,
		3886	typeRef.sourceEnd);
		3887	}
3880	public void invalidUsageOfEnumDeclarations(TypeDeclaration enumDeclaration) {	3888	public void invalidUsageOfEnumDeclarations(TypeDeclaration enumDeclaration) {
3881	this.handle(	3889	this.handle(
3882	IProblem.InvalidUsageOfEnumDeclarations,	3890	IProblem.InvalidUsageOfEnumDeclarations,

Lines 638-643 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (+1 lines)
638	874 = Resource specification not allowed here for source level below 1.7	638	874 = Resource specification not allowed here for source level below 1.7
639	875 = Multi-catch parameters are not allowed for source level below 1.7	639	875 = Multi-catch parameters are not allowed for source level below 1.7
640	876 = Invocation of polymorphic methods not allowed for source level below 1.7	640	876 = Invocation of polymorphic methods not allowed for source level below 1.7
		641	877 = Empty type argument list cannot be used in anonymous class declaration
641		642
642	### ELABORATIONS	643	### ELABORATIONS
643	## Access restrictions	644	## Access restrictions




		expectedProblemAttributes.put("DuplicateParameterizedMethods", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("DuplicateSuperInterface", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("DuplicateTargetInTargetAnnotation", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		expectedProblemAttributes.put("DuplicateTypes", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("DuplicateTypeVariable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		expectedProblemAttributes.put("DuplicateTypes", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("EmptyControlFlowStatement", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		expectedProblemAttributes.put("EnclosingInstanceInConstructorCall", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		expectedProblemAttributes.put("EndOfSource", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));

		expectedProblemAttributes.put("FieldTypeNotVisible", DEPRECATED);
		expectedProblemAttributes.put("FinalBoundForTypeVariable", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		expectedProblemAttributes.put("FinalFieldAssignment", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("FinallyMustCompleteNormally", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		expectedProblemAttributes.put("FinalMethodCannotBeOverridden", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("FinalOuterLocalAssignment", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		expectedProblemAttributes.put("FinallyMustCompleteNormally", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		expectedProblemAttributes.put("ForbiddenReference", new ProblemAttributes(CategorizedProblem.CAT_RESTRICTION));
		expectedProblemAttributes.put("GenericConstructorTypeArgumentMismatch", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("GenericMethodTypeArgumentMismatch", new ProblemAttributes(CategorizedProblem.CAT_TYPE));

		expectedProblemAttributes.put("InvalidUnicodeEscape", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfAnnotationDeclarations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfAnnotations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfDiamondConstruct", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfEnumDeclarations", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfForeachStatements", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("InvalidUsageOfStaticImports", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));

		expectedProblemAttributes.put("JavadocNotVisibleField", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocNotVisibleMethod", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocNotVisibleType", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocParameterMismatch", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocParameterizedConstructorArgumentTypeMismatch", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocParameterizedMethodArgumentTypeMismatch", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocParameterMismatch", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocTypeArgumentsForRawGenericConstructor", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocTypeArgumentsForRawGenericMethod", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocUndefinedConstructor", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));

		expectedProblemAttributes.put("JavadocUsingDeprecatedField", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocUsingDeprecatedMethod", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("JavadocUsingDeprecatedType", new ProblemAttributes(CategorizedProblem.CAT_JAVADOC));
		expectedProblemAttributes.put("LocalVariableCannotBeNull", DEPRECATED);
		expectedProblemAttributes.put("LocalVariableCanOnlyBeNull", DEPRECATED);
		expectedProblemAttributes.put("LocalVariableCannotBeNull", DEPRECATED);
		expectedProblemAttributes.put("LocalVariableHidingField", new ProblemAttributes(CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT));
		expectedProblemAttributes.put("LocalVariableHidingLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT));
		expectedProblemAttributes.put("LocalVariableIsNeverUsed", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
		expectedProblemAttributes.put("LocalVariableMayBeNull", DEPRECATED);
		expectedProblemAttributes.put("MaskedCatch", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		expectedProblemAttributes.put("MethodButWithConstructorName", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		expectedProblemAttributes.put("MethodCanBeStatic", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		expectedProblemAttributes.put("MethodCanBePotentiallyStatic", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		expectedProblemAttributes.put("MethodCanBeStatic", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		expectedProblemAttributes.put("MethodMissingDeprecatedAnnotation", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		expectedProblemAttributes.put("MethodMustOverride", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("MethodMustOverrideOrImplement", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));

		expectedProblemAttributes.put("PackageCollidesWithType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("PackageIsNotExpectedPackage", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		expectedProblemAttributes.put("ParameterAssignment", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		expectedProblemAttributes.put("ParameterMismatch", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("ParameterizedConstructorArgumentTypeMismatch", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("ParameterizedMethodArgumentTypeMismatch", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("ParameterMismatch", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("ParsingError", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("ParsingErrorDeleteToken", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("ParsingErrorDeleteTokens", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));

		expectedProblemAttributes.put("ParsingErrorOnKeywordNoSuggestion", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("ParsingErrorReplaceTokens", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("ParsingErrorUnexpectedEOF", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
		expectedProblemAttributes.put("PolymorphicMethodNotBelow17", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(CategorizedProblem.CAT_UNCHECKED_RAW));
		expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));

		expectedProblemAttributes.put("RecursiveConstructorInvocation", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("RedefinedArgument", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		expectedProblemAttributes.put("RedefinedLocal", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		expectedProblemAttributes.put("RedundantDeclarationOfTypeArguments", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
		expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));

		expectedProblemAttributes.put("StaticMemberOfParameterizedType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("StaticMethodRequested", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		expectedProblemAttributes.put("StringConstantIsExceedingUtf8Limit", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		expectedProblemAttributes.put("SuperInterfaceMustBeAnInterface", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("SuperInterfacesCollide", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("SuperTypeUsingWildcard", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("SuperclassAmbiguous", DEPRECATED);
		expectedProblemAttributes.put("SuperclassInheritedNameHidesEnclosingName", DEPRECATED);
		expectedProblemAttributes.put("SuperclassInternalNameProvided", DEPRECATED);

		expectedProblemAttributes.put("SuperclassNotFound", DEPRECATED);
		expectedProblemAttributes.put("SuperclassNotVisible", DEPRECATED);
		expectedProblemAttributes.put("SuperfluousSemicolon", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		expectedProblemAttributes.put("SuperInterfaceMustBeAnInterface", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("SuperInterfacesCollide", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("SuperTypeUsingWildcard", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		expectedProblemAttributes.put("Task", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		expectedProblemAttributes.put("ThisInStaticContext", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		expectedProblemAttributes.put("ThisSuperDuringConstructorInvocation", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));

		expectedProblemAttributes.put("UnnecessaryCast", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
		expectedProblemAttributes.put("UnnecessaryElse", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
		expectedProblemAttributes.put("UnnecessaryInstanceof", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
		expectedProblemAttributes.put("UnnecessaryOperator", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
		expectedProblemAttributes.put("UnnecessaryNLSTag", new ProblemAttributes(CategorizedProblem.CAT_NLS));
		expectedProblemAttributes.put("UnqualifiedFieldAccess", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		expectedProblemAttributes.put("UnreachableCatch", new ProblemAttributes(CategorizedProblem.CAT_TYPE));

		expectedProblemAttributes.put("DuplicateParameterizedMethods", SKIP);
		expectedProblemAttributes.put("DuplicateSuperInterface", SKIP);
		expectedProblemAttributes.put("DuplicateTargetInTargetAnnotation", SKIP);
		expectedProblemAttributes.put("DuplicateTypes", SKIP);
		expectedProblemAttributes.put("DuplicateTypeVariable", SKIP);
		expectedProblemAttributes.put("DuplicateTypes", SKIP);
		expectedProblemAttributes.put("EmptyControlFlowStatement", new ProblemAttributes(JavaCore.COMPILER_PB_EMPTY_STATEMENT));
		expectedProblemAttributes.put("EnclosingInstanceInConstructorCall", SKIP);
		expectedProblemAttributes.put("EndOfSource", SKIP);

		expectedProblemAttributes.put("FieldTypeNotVisible", SKIP);
		expectedProblemAttributes.put("FinalBoundForTypeVariable", new ProblemAttributes(JavaCore.COMPILER_PB_FINAL_PARAMETER_BOUND));
		expectedProblemAttributes.put("FinalFieldAssignment", SKIP);
		expectedProblemAttributes.put("FinallyMustCompleteNormally", new ProblemAttributes(JavaCore.COMPILER_PB_FINALLY_BLOCK_NOT_COMPLETING));
		expectedProblemAttributes.put("FinalMethodCannotBeOverridden", SKIP);
		expectedProblemAttributes.put("FinalOuterLocalAssignment", SKIP);
		expectedProblemAttributes.put("FinallyMustCompleteNormally", new ProblemAttributes(JavaCore.COMPILER_PB_FINALLY_BLOCK_NOT_COMPLETING));
		expectedProblemAttributes.put("ForbiddenReference", new ProblemAttributes(JavaCore.COMPILER_PB_FORBIDDEN_REFERENCE));
		expectedProblemAttributes.put("GenericConstructorTypeArgumentMismatch", SKIP);
		expectedProblemAttributes.put("GenericMethodTypeArgumentMismatch", SKIP);

		expectedProblemAttributes.put("InvalidContinue", SKIP);
		expectedProblemAttributes.put("InvalidDigit", SKIP);
		expectedProblemAttributes.put("InvalidDisjunctiveTypeReferenceSequence", SKIP);
		expectedProblemAttributes.put("InvalidEmptyExoticIdentifier", SKIP);
		expectedProblemAttributes.put("InvalidEncoding", SKIP);
		expectedProblemAttributes.put("InvalidEscape", SKIP);
		expectedProblemAttributes.put("InvalidExplicitConstructorCall", SKIP);

		expectedProblemAttributes.put("InvalidUnicodeEscape", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfAnnotationDeclarations", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfAnnotations", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfDiamondConstruct", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfEnumDeclarations", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfForeachStatements", SKIP);
		expectedProblemAttributes.put("InvalidUsageOfStaticImports", SKIP);

		expectedProblemAttributes.put("JavadocNotVisibleField", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocNotVisibleMethod", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocNotVisibleType", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocParameterMismatch", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocParameterizedConstructorArgumentTypeMismatch", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocParameterizedMethodArgumentTypeMismatch", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocParameterMismatch", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocTypeArgumentsForRawGenericConstructor", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocTypeArgumentsForRawGenericMethod", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocUndefinedConstructor", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));

		expectedProblemAttributes.put("JavadocUsingDeprecatedField", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocUsingDeprecatedMethod", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("JavadocUsingDeprecatedType", new ProblemAttributes(JavaCore.COMPILER_PB_INVALID_JAVADOC));
		expectedProblemAttributes.put("LocalVariableCannotBeNull", SKIP);
		expectedProblemAttributes.put("LocalVariableCanOnlyBeNull", SKIP);
		expectedProblemAttributes.put("LocalVariableCannotBeNull", SKIP);
		expectedProblemAttributes.put("LocalVariableHidingField", new ProblemAttributes(JavaCore.COMPILER_PB_LOCAL_VARIABLE_HIDING));
		expectedProblemAttributes.put("LocalVariableHidingLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_LOCAL_VARIABLE_HIDING));
		expectedProblemAttributes.put("LocalVariableIsNeverUsed", new ProblemAttributes(JavaCore.COMPILER_PB_UNUSED_LOCAL));
		expectedProblemAttributes.put("LocalVariableMayBeNull", SKIP);
		expectedProblemAttributes.put("MaskedCatch", new ProblemAttributes(JavaCore.COMPILER_PB_HIDDEN_CATCH_BLOCK));
		expectedProblemAttributes.put("MethodButWithConstructorName", new ProblemAttributes(JavaCore.COMPILER_PB_METHOD_WITH_CONSTRUCTOR_NAME));
		expectedProblemAttributes.put("MethodCanBeStatic", new ProblemAttributes(JavaCore.COMPILER_PB_MISSING_STATIC_ON_METHOD));
		expectedProblemAttributes.put("MethodCanBePotentiallyStatic", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIALLY_MISSING_STATIC_ON_METHOD));
		expectedProblemAttributes.put("MethodCanBeStatic", new ProblemAttributes(JavaCore.COMPILER_PB_MISSING_STATIC_ON_METHOD));
		expectedProblemAttributes.put("MethodMissingDeprecatedAnnotation", new ProblemAttributes(JavaCore.COMPILER_PB_MISSING_DEPRECATED_ANNOTATION));
		expectedProblemAttributes.put("MethodMustOverride", SKIP);
		expectedProblemAttributes.put("MethodMustOverrideOrImplement", SKIP);

		expectedProblemAttributes.put("MissingEnclosingInstanceForConstructorCall", SKIP);
		expectedProblemAttributes.put("MissingEnumConstantCase", new ProblemAttributes(JavaCore.COMPILER_PB_INCOMPLETE_ENUM_SWITCH));
		expectedProblemAttributes.put("MissingOverrideAnnotation", new ProblemAttributes(JavaCore.COMPILER_PB_MISSING_OVERRIDE_ANNOTATION));
		expectedProblemAttributes.put("MissingOverrideAnnotationForInterfaceMethodImplementation", new ProblemAttributes(JavaCore.COMPILER_PB_MISSING_OVERRIDE_ANNOTATION));
		expectedProblemAttributes.put("MissingReturnType", SKIP);
		expectedProblemAttributes.put("MissingSemiColon", SKIP);
		expectedProblemAttributes.put("MissingSerialVersion", new ProblemAttributes(JavaCore.COMPILER_PB_MISSING_SERIAL_VERSION));

		expectedProblemAttributes.put("PackageCollidesWithType", SKIP);
		expectedProblemAttributes.put("PackageIsNotExpectedPackage", SKIP);
		expectedProblemAttributes.put("ParameterAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_PARAMETER_ASSIGNMENT));
		expectedProblemAttributes.put("ParameterMismatch", SKIP);
		expectedProblemAttributes.put("ParameterizedConstructorArgumentTypeMismatch", SKIP);
		expectedProblemAttributes.put("ParameterizedMethodArgumentTypeMismatch", SKIP);
		expectedProblemAttributes.put("ParameterMismatch", SKIP);
		expectedProblemAttributes.put("ParsingError", SKIP);
		expectedProblemAttributes.put("ParsingErrorDeleteToken", SKIP);
		expectedProblemAttributes.put("ParsingErrorDeleteTokens", SKIP);

		expectedProblemAttributes.put("StaticMemberOfParameterizedType", SKIP);
		expectedProblemAttributes.put("StaticMethodRequested", SKIP);
		expectedProblemAttributes.put("StringConstantIsExceedingUtf8Limit", SKIP);
		expectedProblemAttributes.put("SuperInterfaceMustBeAnInterface", SKIP);
		expectedProblemAttributes.put("SuperInterfacesCollide", SKIP);
		expectedProblemAttributes.put("SuperTypeUsingWildcard", SKIP);
		expectedProblemAttributes.put("SuperclassAmbiguous", new ProblemAttributes(JavaCore.COMPILER_PB_MISSING_HASHCODE_METHOD));
		expectedProblemAttributes.put("SuperclassInheritedNameHidesEnclosingName", SKIP);
		expectedProblemAttributes.put("SuperclassInternalNameProvided", SKIP);
		expectedProblemAttributes.put("SuperclassMustBeAClass", SKIP);
		expectedProblemAttributes.put("SuperclassNotFound", SKIP);
		expectedProblemAttributes.put("SuperclassNotVisible", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_SUPERINTERFACE));
		expectedProblemAttributes.put("SuperfluousSemicolon", new ProblemAttributes(JavaCore.COMPILER_PB_EMPTY_STATEMENT));
		expectedProblemAttributes.put("SuperInterfaceMustBeAnInterface", SKIP);
		expectedProblemAttributes.put("SuperInterfacesCollide", SKIP);
		expectedProblemAttributes.put("SuperTypeUsingWildcard", SKIP);
		expectedProblemAttributes.put("Task", SKIP);
		expectedProblemAttributes.put("ThisInStaticContext", SKIP);
		expectedProblemAttributes.put("ThisSuperDuringConstructorInvocation", SKIP);




		compilerOptions15,
		null);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=339478
// To verify that diamond construct is not allowed in source level 1.6 or below
public void test339478a() {
	if (this.complianceLevel >= ClassFileConstants.JDK1_7)
		return;
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String> x = new X<>();\n" + 
			"		x.testFunction(\"SUCCESS\");\n" + 
			"	}\n" +
			"	public void testFunction(T param){\n" +
			"		System.out.println(param);\n" +
			"	}\n" + 
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	X<String> x = new X<>();\n" + 
		"	                  ^\n" + 
		"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" + 
		"----------\n");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=339478
// To verify that diamond construct is not allowed in source level 1.6 or below
public void test339478b() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	public static void main(String[] args) {\n" + 
			"		X<> x1 = null;\n" +
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	X<> x1 = null;\n" + 
		"	^\n" + 
		"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" + 
		"----------\n");
}
}




/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation.
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * This is an implementation of an early-draft specification developed under the Java
 * Community Process (JCP) and is made available for testing and evaluation purposes
 * only. The code is not compatible with any specification of the JCP.
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;

import java.util.Map;

import junit.framework.Test;
public class GenericsRegressionTest_1_7 extends AbstractRegressionTest {

static {
//	TESTS_NAMES = new String[] { "test0014" };
//	TESTS_NUMBERS = new int[] { 40, 41, 43, 45, 63, 64 };
//	TESTS_RANGE = new int[] { 11, -1 };
}
public GenericsRegressionTest_1_7(String name) {
	super(name);
}
public static Test suite() {
	return buildMinimalComplianceTestSuite(testClass(), F_1_7);
}
public void test001() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String> x = new X<>();\n" + 
			"		x.testFunction(\"SUCCESS\");\n" + 
			"	}\n" +
			"	public void testFunction(T param){\n" +
			"		System.out.println(param);\n" +
			"	}\n" + 
			"}",
		},
		"SUCCESS");
}
public void test001a() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String> x = new X<>();\n" + 
			"		x.testFunction(1);\n" + 
			"	}\n" +
			"	public void testFunction(T param){\n" +
			"		System.out.println(param);\n" +
			"	}\n" + 
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	x.testFunction(1);\n" + 
		"	  ^^^^^^^^^^^^\n" + 
		"The method testFunction(String) in the type X<String> is not applicable for the arguments (int)\n" + 
		"----------\n");
}
public void test001b() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		java.util.ArrayList<String> x = new java.util.ArrayList<>();\n" + 
			"		x.add(\"\");\n" +
			"		System.out.println(\"SUCCESS\");\n" + 
			"	}\n" +
			"}",
		},
		"SUCCESS");
}
// fields
public void test001b_1() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	static java.util.ArrayList<String> x = new java.util.ArrayList<>();\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X.x.add(\"\");\n" +
			"		System.out.println(\"SUCCESS\");\n" + 
			"	}\n" +
			"}",
		},
		"SUCCESS");
}
public void test001c() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		java.util.ArrayList<String> x = new java.util.ArrayList<>();\n" + 
			"		x.add(1);\n" +
			"		System.out.println(\"SUCCESS\");\n" + 
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	x.add(1);\n" + 
		"	  ^^^\n" + 
		"The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)\n" + 
		"----------\n");
}
// fields
public void test001c_1() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	static java.util.ArrayList<String> x = new java.util.ArrayList<>();\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X.x.add(1);\n" +
			"		System.out.println(\"SUCCESS\");\n" + 
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	X.x.add(1);\n" + 
		"	    ^^^\n" + 
		"The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)\n" + 
		"----------\n");
}
public void _test001d() {
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.util.ArrayList;\n" +
			"public class X<T> {" +
			"	public void ab(ArrayList<String> al){\n" + 
			"		System.out.println(\"SUCCESS\");\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String> x = new X<>();\n" + 
			"		x.ab(new ArrayList<>());\n" + 
			"	}\n" +
			"}",
		},
		"SUCCESS");
}
public void _test001e() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.ArrayList;\n" +
			"public class X<T> {" +
			"	public void ab(ArrayList<T> al){\n" + 
			"		System.out.println(\"SUCCESS\");\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String> x = new X<>();\n" + 
			"		x.ab(new ArrayList<>());\n" + 
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	x.ab(new ArrayList<Integer>());\n" + 
		"	  ^^\n" + 
		"The method ab(ArrayList<String>) in the type X<String> is not applicable for the arguments (ArrayList<Integer>)\n" + 
		"----------\n");
}
public void test001f() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<T>{\n" +
			"		void methodx(T param){\n" +
			"			System.out.println(param);\n" +
			"		}\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String>.X2<String> x = new X<>().new X2<>();\n" + 
			"		x.methodx(\"SUCCESS\");\n" + 
			"	}\n" +
			"}",
		},
		"SUCCESS");
}
// fields
public void test001f_1() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<T>{\n" +
			"		void methodx(T param){\n" +
			"			System.out.println(param);\n" +
			"		}\n" +
			"	}\n" +
			"	X<String>.X2<String> x;\n" + 
			"	public static void main(String[] args) {\n" +
			"		X test = new X();\n" + 
			"		test.x = new X<>().new X2<>();\n" + 
			"		test.x.methodx(\"SUCCESS\");\n" + 
			"	}\n" +
			"}",
		},
		"SUCCESS");
}
public void test001g() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<K>{\n" +
			"		void methodx(T param, K param2){\n" +
			"			System.out.println(param);\n" +
			"			System.out.println(param2);\n" +
			"		}\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String>.X2<Integer> x = new X<>().new X2<>();\n" + 
			"		x.methodx(\"SUCCESS\",1);\n" + 
			"	}\n" +
			"}",
		},
		"SUCCESS\n1");
}
public void test001g_1() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<K>{\n" +
			"		void methodx(T param, K param2){\n" +
			"			System.out.println(param);\n" +
			"			System.out.println(param2);\n" +
			"		}\n" +
			"	}\n" +
			"	X<String>.X2<Integer> x;\n" + 
			"	public static void main(String[] args) {\n" +
			"		X test = new X();" + 
			"		test.x = new X<>().new X2<>();\n" + 
			"		test.x.methodx(\"SUCCESS\",1);\n" + 
			"	}\n" +
			"}",
		},
		"SUCCESS\n1");
}
public void test001h() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<T>{\n" +
			"		void methodx(T param){\n" +
			"			System.out.println(param);\n" +
			"		}\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String>.X2<String> x = new X<>().new X2<>();\n" + 
			"		x.methodx(1);\n" + 
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 2)\n" + 
		"	class X2<T>{\n" + 
		"	         ^\n" + 
		"The type parameter T is hiding the type T\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 9)\n" + 
		"	x.methodx(1);\n" + 
		"	  ^^^^^^^\n" + 
		"The method methodx(String) in the type X<String>.X2<String> is not applicable for the arguments (int)\n" + 
		"----------\n");
}
public void test001h_1() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<T>{\n" +
			"		void methodx(T param){\n" +
			"			System.out.println(param);\n" +
			"		}\n" +
			"	}\n" +
			"	X<String>.X2<String> x;\n" + 
			"	public static void main(String[] args) {\n" +
			"		X test = new X();\n" + 
			"		test.x = new X<>().new X2<>();\n" + 
			"		test.x.methodx(1);\n" + 
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 2)\n" + 
		"	class X2<T>{\n" + 
		"	         ^\n" + 
		"The type parameter T is hiding the type T\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 9)\n" + 
		"	X test = new X();\n" + 
		"	^\n" + 
		"X is a raw type. References to generic type X<T> should be parameterized\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 9)\n" + 
		"	X test = new X();\n" + 
		"	             ^\n" + 
		"X is a raw type. References to generic type X<T> should be parameterized\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 10)\n" + 
		"	test.x = new X<>().new X2<>();\n" + 
		"	     ^\n" + 
		"Type safety: The field x from the raw type X is assigned a value of type X<>.X2. References to generic type X<T> should be parameterized\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 11)\n" + 
		"	test.x.methodx(1);\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: The method methodx(Object) belongs to the raw type X.X2. References to generic type X<T>.X2<T> should be parameterized\n" + 
		"----------\n");
}
public void test001i() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<K>{\n" +
			"		class X22<I>{\n" +
			"			void methodx(T param, K param2, I param3){\n" +
			"				System.out.println(param);\n" +
			"			}\n" +
			"		}\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" +
			"		X<String> test = new X<>();" + 
			"		X<String>.X2<Integer>.X22<X<String>> x = new X<>().new X2<>().new X22<>();\n" + 
			"		x.methodx(\"SUCCESS\", 1, test);\n" + 
			"	}\n" +
			"}",
		},
		"SUCCESS");
}
public void test002() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X x = new X<>();\n" + 
			"		x.testFunction(\"SUCCESS\");\n" + 
			"	}\n" +
			"	public void testFunction(T param){\n" +
			"		System.out.println(param);\n" +
			"	}\n" + 
			"}",
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 3)\n" + 
		"	X x = new X<>();\n" + 
		"	^\n" + 
		"X is a raw type. References to generic type X<T> should be parameterized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 4)\n" + 
		"	x.testFunction(\"SUCCESS\");\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: The method testFunction(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" + 
		"----------\n");
}
public void _test003() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		new X<>().testFunction(\"SUCCESS\");\n" + 
			"	}\n" +
			"	public void testFunction(T param){\n" +
			"		System.out.println(param);\n" +
			"	}\n" + 
			"}",
		},
		"SUCCESS");
}
public void test004() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		new X<>(){\n" +
			"			void newMethod(){\n" +
			"			}\n" +
			"		}.testFunction(\"SUCCESS\");\n" + 
			"	}\n" +
			"	public void testFunction(T param){\n" +
			"		System.out.println(param);\n" +
			"	}\n" + 
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	new X<>(){\n" + 
		"	    ^\n" + 
		"Empty type argument list cannot be used in anonymous class declaration\n" + 
		"----------\n");
}
public void test004b() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<U> {\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		new X<>().new X2<>(){\n" +
			"			void newMethod(){\n" +
			"			}\n" +
			"		};\n" + 
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	new X<>().new X2<>(){\n" + 
		"	              ^^\n" + 
		"Empty type argument list cannot be used in anonymous class declaration\n" + 
		"----------\n");
}
public void test004c() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<U> {\n" +
			"		U f1;" +
			"		public void setF(U a){\n" +
			"			this.f1 = a;" +
			"			System.out.println(this.f1);\n" +
			"		}\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		new X<>().new X2<Integer>(){\n" +
			"			void newMethod(){\n" +
			"			}\n" +
			"		}.setF(1);\n" + 
			"	}\n" +
			"}",
		},
		"1");
}
public void test005() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X Test = new X<>(){\n" +
			"			void newMethod(){\n" +
			"			}\n" +
			"		}.testFunction(\"SUCCESS\");\n" + 
			"	}\n" +
			"	public void testFunction(T param){\n" +
			"		System.out.println(param);\n" +
			"	}\n" + 
			"}",
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 3)\n" + 
		"	X Test = new X<>(){\n" + 
		"	^\n" + 
		"X is a raw type. References to generic type X<T> should be parameterized\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 3)\n" + 
		"	X Test = new X<>(){\n" + 
		"	             ^\n" + 
		"Empty type argument list cannot be used in anonymous class declaration\n" + 
		"----------\n");
}
public void test006() {
	this.runConformTest(
		new String[] {
			"X.java",
			"class X1<T> {\n" +
			"	int abc = 1;\n" +
			"	public void testFunction(T param){\n" +
			"		System.out.println(param + \"X1\");\n" +
			"	}\n" + 
			"}\n" +
			"public class X<T> extends X1<T> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X1<String> x = new X<>();\n" + 
			"		x.testFunction(\"SUCCESS\");\n" + 
			"	}\n" +
			"	public void testFunction(T param){\n" +
			"		System.out.println(param);\n" +
			"	}\n" + 
			"}",
		},
		"SUCCESS");
}
// shows the difference between using <> and the raw type - different semantics
public void _test007() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	T field1;" +
			"	public X(T param){\n" +
			"		field1 = param;\n" +
			"	}\n" +
			"	public static void main(String[] args) {\n" + 
			"		X.testFunction(new X<>(\"hello\").getField());\n" + // prints 1
			"		X.testFunction(new X(\"hello\").getField());\n" + //prints 2
			"	}\n" +
			"	public static void testFunction(String param){\n" +
			"		System.out.println(1);\n" +
			"	}\n" +
			"	public static void testFunction(Object param){\n" +
			"		System.out.println(2);\n" +
			"	}\n" +
			"	public T getField(){\n" +
			"		return field1;" +
			"	}\n" + 
			"}",
		},
		"1\n" + 
		"2");
}
// to verify if diamond works inside an allocation expression in a method invocation
public void _test007a() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	public X(){\n" +
			"	}\n" +
			"	public X(T param){\n" +
			"		System.out.println(param);\n" +
			"	}\n" +
			"	public static void testFunction(X<String> param){\n" +
			"		System.out.println(\"SUCCESS\");\n" +
			"	}\n" +
			"	public static void main(String[] args) {\n" + 
			"		X.testFunction(new X<>());\n" + 
			"		X.testFunction(new X(\"hello\"));\n" +
			"	}\n" +
			"}",
		},
		"1\n" + 
		"2");
}
//shows the difference between using <> and the raw type - different semantics
public void _test008() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	T field1;" +
			"	public X(T param){\n" +
			"		field1 = param;\n" +
			"	}\n" +
			"	public static void main(String[] args) {\n" + 
			"		X<?> x1 = new X(1).get(\"\");\n" + // ok - passing String where Object is expected
			"		X<?> x2 = new X<>(1).get(\"\");\n" + // bad - passing String where Integer is expected
			"	}\n" +
			"	public X<T> get(T t){\n" +
			"		return this;" +
			"	}\n" + 
			"}",
		},
		"1\n" + 
		"2");
}
public void test009() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	public static void main(String[] args) {\n" + 
			"		X<>[] x1 = null;\n" +
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	X<>[] x1 = null;\n" + 
		"	^\n" + 
		"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" + 
		"----------\n");
}
public void test009a() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	X<>[] x1 = null;\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	X<>[] x1 = null;\n" + 
		"	^\n" + 
		"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" + 
		"----------\n");
}
public void test010() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	public static void main(String[] args) {\n" + 
			"		X<> x1 = null;\n" + 
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	X<> x1 = null;\n" + 
		"	^\n" + 
		"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" + 
		"----------\n");
}
public void test010a() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	X<> f1 = null;\n" + 
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	X<> f1 = null;\n" + 
		"	^\n" + 
		"Incorrect number of arguments for type X<>; it cannot be parameterized with arguments <>\n" + 
		"----------\n");
}
public void test011() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	public void foo(X<> args) {\n" + 
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	public void foo(X<> args) {\n" + 
		"	                ^\n" + 
		"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" + 
		"----------\n");
}
// To be activated if we introduce a warning to be raised when <> can be used but is not used.
public void _test012() {
	Map options = getCompilerOptions();
	//options.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	X<String> f1 = new X<String>();\n" +
			"	public void foo() {\n" +
			"		X<Integer> i1 = new X<Integer>();\n" +
			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	X<String> f1 = new X<String>();\n" + 
		"	               ^^^^^^^^^^^^^^^\n" + 
		"Redundant declaration of type arguments <String>\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 4)\n" + 
		"	X<Integer> i1 = new X<Integer>();\n" + 
		"	                ^^^^^^^^^^^^^^^^\n" + 
		"Redundant declaration of type arguments <Integer>\n" + 
		"----------\n",
		null,
		true,
		options);
}
// To be activated if we introduce a warning to be raised when <> can be used but is not used.
public void _test013a() {
	Map options = getCompilerOptions();
	//options.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class Y<U>{}\n" +
			"	Y<String> f1 = new Y();\n" +
			"	public static void main(String[] args) {\n" +
			"		X<Integer> i1 = new X<>();\n" +
			"		System.out.println(\"SUCCESS\");\n" +
			"	}\n" +
			"}",
		},
		"SUCCESS",
		null,
		true,
		null,
		options,
		null);
}
public void test0014() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<J,K> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String,Integer> x = new X<>();\n" + 
			"		x.testFunction(\"SUCCESS\", 123);\n" + 
			"	}\n" +
			"	public void testFunction(J param, K param2){\n" +
			"		System.out.println(param);\n" +
			"		System.out.println(param2);\n" +
			"	}\n" + 
			"}",
		},
		"SUCCESS\n" +
		"123");
}
public void test0014a() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<J,K> {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String,Integer> x = new X<>();\n" + 
			"		x.testFunction(123, \"SUCCESS\");\n" + 
			"	}\n" +
			"	public void testFunction(J param, K param2){\n" +
			"		System.out.println(param);\n" +
			"		System.out.println(param2);\n" +
			"	}\n" + 
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	x.testFunction(123, \"SUCCESS\");\n" + 
		"	  ^^^^^^^^^^^^\n" + 
		"The method testFunction(String, Integer) in the type X<String,Integer> is not applicable for the arguments (int, String)\n" + 
		"----------\n");
}
public void test0015() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	X(){\n" +
			"		System.out.println(\"const.1\");\n" +
			"	}\n" +
			"	X (T t) {\n" +
			"		System.out.println(\"const.2\");\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String> x = new X<>();\n" + 
			"		X<String> x2 = new X<>(\"\");\n" + 
			"	}\n" +
			"}",
		},
		"const.1\nconst.2");
}
// To verify that a parameterized invocation of a generic constructor works even if <> is used
// to elide class type parameters.
public void test0016() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	<E> X(){\n" +
			"		System.out.println(\"const.1\");\n" +
			"	}\n" +
			"	<K,J> X (Integer i) {\n" +
			"		System.out.println(\"const.2\");\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String> x = new <String>X<>();\n" + 
			"		X<String> x2 = new <String, Integer>X<>(1);\n" + 
			"	}\n" +
			"}",
		},
		"const.1\nconst.2");
}
// To verify that a parameterized invocation of a generic constructor works even if <> is used
// to elide class type parameters. This test handles fields
public void test0016b() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	X<String> x;\n" +
			"	X<String> x2;\n" +
			"	<E> X(){\n" +
			"		System.out.println(\"const.1\");\n" +
			"	}\n" +
			"	<K,J> X (Integer i) {\n" +
			"		System.out.println(\"const.2\");\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" +
			"		X<Integer> test = new <String>X<>();\n" + 
			"		test.x = new <String>X<>();\n" + 
			"		test.x2 = new <String, Integer>X<>(1);\n" + 
			"	}\n" +
			"}",
		},
		"const.1\nconst.1\nconst.2");
}
// To verify that a parameterized invocation of a non-generic constructor works even if <> is used
// to elide class type parameters.
// This was not allowed in java 1.6 and 1.5 (https://bugs.eclipse.org/bugs/show_bug.cgi?id=168230)
public void test0017() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	X(int i){\n" +
			"		System.out.println(\"const.1\");\n" +
			"	}\n" +
			"	<K,J> X (Integer i) {\n" +
			"		System.out.println(\"const.2\");\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X<String> x = new X<>(1);\n" + 
			"		X<String> x2 = new <String, Integer>X<>(1);\n" +
			"		Integer i = 1;\n" + 
			"		X<String> x3 = new <String, Integer>X<>(i);\n" + 
			"	}\n" +
			"}",
		},
		"const.1\nconst.1\nconst.2");
}
// To verify that the correct constructor is found by parameter substitution in the diamond case
public void test0018() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	X(T t){\n" +
			"		System.out.println(\"const.1\");\n" +
			"	}\n" +
			"	X (T t, Integer i) {\n" +
			"		System.out.println(\"const.2\");\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" + 
			"		X x = new X<>(\"\");\n" + 
			"		X x2 = new X<>(\"\",1);\n" +
			"	}\n" +
			"}",
		},
		"const.1\nconst.2");
}
// To verify that the correct constructor is found by parameter substitution 
// in the diamond case -- fields
public void test0018b() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	X f1;\n" + 
			"	X f2;\n" +
			"	X(T t){\n" +
			"		System.out.println(\"const.1\");\n" +
			"	}\n" +
			"	X (T t, Integer i) {\n" +
			"		System.out.println(\"const.2\");\n" +
			"	}\n" + 
			"	public static void main(String[] args) {\n" +
			"		X x = new X<>(\"\");\n" + 
			"		x.f1 = new X<>(\"\");\n" +
			"		x.f2 = new X<>(\"\",1);\n" + 
			"	}\n" +
			"}",
		},
		"const.1\nconst.1\nconst.2");
}
public static Class testClass() {
	return GenericsRegressionTest_1_7.class;
}
}

Lines 172-177 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/TestAll.java (+1 lines)
172	tests_1_7.add(UnderscoresInLiteralsTest.class);	172	tests_1_7.add(UnderscoresInLiteralsTest.class);
173	tests_1_7.add(TryStatement17Test.class);	173	tests_1_7.add(TryStatement17Test.class);
174	tests_1_7.add(TryWithResourcesStatementTest.class);	174	tests_1_7.add(TryWithResourcesStatementTest.class);
		175	tests_1_7.add(GenericsRegressionTest_1_7.class);
175	// Reset forgotten subsets tests	176	// Reset forgotten subsets tests
176	TestCase.TESTS_PREFIX = null;	177	TestCase.TESTS_PREFIX = null;
177	TestCase.TESTS_NAMES = null;	178	TestCase.TESTS_NAMES = null;

Return to bug 339478

Lines 1005-1010 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java (+12 lines)
1005	* In addition to improving performance, caching also ensures there is no infinite regression	1005	* In addition to improving performance, caching also ensures there is no infinite regression
1006	* since per nature, the compatibility check is recursive through parameterized type arguments (122775)	1006	* since per nature, the compatibility check is recursive through parameterized type arguments (122775)
1007	*/	1007	*/
		1008	public boolean isCompatibleWith(TypeBinding otherType, boolean isDiamondCase) {
		1009	if (isDiamondCase) {
		1010	if (this.erasure() == otherType.erasure())
		1011	return true;
		1012	}
		1013	return isCompatibleWith(otherType);
		1014	}
		1015	/**
		1016	* Answer true if the receiver type can be assigned to the argument type (right)
		1017	* In addition to improving performance, caching also ensures there is no infinite regression
		1018	* since per nature, the compatibility check is recursive through parameterized type arguments (122775)
		1019	*/
1008	public boolean isCompatibleWith(TypeBinding otherType) {	1020	public boolean isCompatibleWith(TypeBinding otherType) {
1009	if (otherType == this)	1021	if (otherType == this)
1010	return true;	1022	return true;

Lines 3956-3961 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java (-3 / +5 lines)
3956	// zero type arguments == <>	3956	// zero type arguments == <>
3957	pushOnGenericsLengthStack(-1);	3957	pushOnGenericsLengthStack(-1);
3958	concatGenericsLists();	3958	concatGenericsLists();
		3959	this.intPtr--; // no reference type to be consumed between < and >
3959	}	3960	}
3960	protected void consumeImportDeclaration() {	3961	protected void consumeImportDeclaration() {
3961	// SingleTypeImportDeclaration ::= SingleTypeImportDeclarationName ';'	3962	// SingleTypeImportDeclaration ::= SingleTypeImportDeclarationName ';'
Lines 8912-8919 Link Here
8912	if (dim != 0) {	8913	if (dim != 0) {
8913	parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;	8914	parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;
8914	}	8915	}
8915	if (isDiamond) {	8916	if (isDiamond && (this.options.sourceLevel >= ClassFileConstants.JDK1_7)) {
8916	parameterizedSingleTypeReference.bits \|= ASTNode.IsDiamond;	8917	if (parameterizedSingleTypeReference.dimensions == 0)
		8918	parameterizedSingleTypeReference.bits \|= ASTNode.IsDiamond;
8917	}	8919	}
8918	return parameterizedSingleTypeReference;	8920	return parameterizedSingleTypeReference;
8919	} else {	8921	} else {
Lines 8954-8960 Link Here
8954	if (dim != 0) {	8956	if (dim != 0) {
8955	parameterizedQualifiedTypeReference.sourceEnd = this.endStatementPosition;	8957	parameterizedQualifiedTypeReference.sourceEnd = this.endStatementPosition;
8956	}	8958	}
8957	if (isDiamond) {	8959	if (isDiamond && (this.options.sourceLevel >= ClassFileConstants.JDK1_7)) {
8958	parameterizedQualifiedTypeReference.bits \|= ASTNode.IsDiamond;	8960	parameterizedQualifiedTypeReference.bits \|= ASTNode.IsDiamond;
8959	}	8961	}
8960	return parameterizedQualifiedTypeReference;	8962	return parameterizedQualifiedTypeReference;

Lines 1740-1743 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest.java (+44 lines)
1740	compilerOptions15,	1740	compilerOptions15,
1741	null);	1741	null);
1742	}	1742	}
		1743	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=339478
		1744	// To verify that diamond construct is not allowed in source level 1.6 or below
		1745	public void test339478a() {
		1746	if (this.complianceLevel >= ClassFileConstants.JDK1_7)
		1747	return;
		1748	this.runNegativeTest(
		1749	new String[] {
		1750	"X.java",
		1751	"public class X<T> {\n" +
		1752	" public static void main(String[] args) {\n" +
		1753	" X<String> x = new X<>();\n" +
		1754	" x.testFunction(\"SUCCESS\");\n" +
		1755	" }\n" +
		1756	" public void testFunction(T param){\n" +
		1757	" System.out.println(param);\n" +
		1758	" }\n" +
		1759	"}",
		1760	},
		1761	"----------\n" +
		1762	"1. ERROR in X.java (at line 3)\n" +
		1763	" X<String> x = new X<>();\n" +
		1764	" ^\n" +
		1765	"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" +
		1766	"----------\n");
		1767	}
		1768	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=339478
		1769	// To verify that diamond construct is not allowed in source level 1.6 or below
		1770	public void test339478b() {
		1771	this.runNegativeTest(
		1772	new String[] {
		1773	"X.java",
		1774	"public class X<T> {\n" +
		1775	" public static void main(String[] args) {\n" +
		1776	" X<> x1 = null;\n" +
		1777	" }\n" +
		1778	"}",
		1779	},
		1780	"----------\n" +
		1781	"1. ERROR in X.java (at line 3)\n" +
		1782	" X<> x1 = null;\n" +
		1783	" ^\n" +
		1784	"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" +
		1785	"----------\n");
		1786	}
1743	}	1787	}

Lines 214-224 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java (-2 / +10 lines)
214	this.initialization.computeConversion(initializationScope, fieldType, initializationType);	214	this.initialization.computeConversion(initializationScope, fieldType, initializationType);
215	}	215	}
216	} else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) {	216	} else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) {
217		217	boolean isDiamond = false;
		218	if (this.initialization instanceof AllocationExpression) {
		219	AllocationExpression allocationExpression = (AllocationExpression) this.initialization;
		220	if (initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7
		221	&& allocationExpression.type != null
		222	&& (allocationExpression.type.bits & ASTNode.IsDiamond) != 0) {
		223	isDiamond = true;
		224	}
		225	}
218	if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()	226	if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()
219	initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);	227	initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);
220	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)	228	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)
221	\|\| initializationType.isCompatibleWith(fieldType)) {	229	\|\| initializationType.isCompatibleWith(fieldType, isDiamond)) {
222	this.initialization.computeConversion(initializationScope, fieldType, initializationType);	230	this.initialization.computeConversion(initializationScope, fieldType, initializationType);
223	if (initializationType.needsUncheckedConversion(fieldType)) {	231	if (initializationType.needsUncheckedConversion(fieldType)) {
224	initializationScope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, fieldType);	232	initializationScope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, fieldType);