Attachment #191458 for bug #339478

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

Lines 3495-3500 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/Main.java (+4 lines)
3495	} else if (token.equals("typeHiding")) { //$NON-NLS-1$	3495	} else if (token.equals("typeHiding")) { //$NON-NLS-1$
3496	setSeverity(CompilerOptions.OPTION_ReportTypeParameterHiding, severity, isEnabling);	3496	setSeverity(CompilerOptions.OPTION_ReportTypeParameterHiding, severity, isEnabling);
3497	return;	3497	return;
		3498	} else if (token.equals("typeArgRedundant") /\|\| token.equals("redundantSuperinterface")/) { //$NON-NLS-1$
		3499	setSeverity(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, severity, isEnabling);
		3500	return;
3498	}	3501	}
3499	break;	3502	break;
3500	case 'u' :	3503	case 'u' :
Lines 3539-3544 Link Here
3539	setSeverity(CompilerOptions.OPTION_ReportUnusedDeclaredThrownException, severity, isEnabling);	3542	setSeverity(CompilerOptions.OPTION_ReportUnusedDeclaredThrownException, severity, isEnabling);
3540	setSeverity(CompilerOptions.OPTION_ReportUnusedLabel, severity, isEnabling);	3543	setSeverity(CompilerOptions.OPTION_ReportUnusedLabel, severity, isEnabling);
3541	setSeverity(CompilerOptions.OPTION_ReportUnusedTypeArgumentsForMethodInvocation, severity, isEnabling);	3544	setSeverity(CompilerOptions.OPTION_ReportUnusedTypeArgumentsForMethodInvocation, severity, isEnabling);
		3545	setSeverity(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, severity, isEnabling);
3542	return;	3546	return;
3543	} else if (token.equals("unusedTypeArgs")) { //$NON-NLS-1$	3547	} else if (token.equals("unusedTypeArgs")) { //$NON-NLS-1$
3544	setSeverity(CompilerOptions.OPTION_ReportUnusedTypeArgumentsForMethodInvocation, severity, isEnabling);	3548	setSeverity(CompilerOptions.OPTION_ReportUnusedTypeArgumentsForMethodInvocation, severity, isEnabling);

Lines 1377-1383 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (-1 / +4 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;
		1382	/** @since 3.7 */
		1383	int RedundantDeclarationOfTypeArguments = FieldRelated + Internal + 878;
1381	/**	1384	/**
1382	* External problems -- These are problems defined by other plugins	1385	* External problems -- These are problems defined by other plugins
1383	*/	1386	*/

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	private 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 ((this.type.bits & ASTNode.IsDiamond) != 0) {
		261	if (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	}

Lines 217-222 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java (+3 lines)
217		217
218	if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()	218	if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()
219	initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);	219	initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);
		220	else if (initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7 &&
		221	initializationType.isParameterizedTypeWithActualArguments())
		222	initializationScope.problemReporter().redundantDeclarationOfTypeArguments(this.initialization, ((ParameterizedTypeBinding)initializationType).arguments);
220	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)	223	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)
221	\|\| initializationType.isCompatibleWith(fieldType)) {	224	\|\| initializationType.isCompatibleWith(fieldType)) {
222	this.initialization.computeConversion(initializationScope, fieldType, initializationType);	225	this.initialization.computeConversion(initializationScope, fieldType, initializationType);

Lines 157-163 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (-2 / +14 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);
		223	else if (isCompliant17 && initializationType.isParameterizedTypeWithActualArguments()) {
		224	scope.problemReporter().redundantDeclarationOfTypeArguments(this.initialization, ((ParameterizedTypeBinding)initializationType).arguments);
		225	}
214	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, variableType)	226	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, variableType)
215	\|\| initializationType.isCompatibleWith(variableType)) {	227	\|\| initializationType.isCompatibleWith(variableType, isDiamond)) {
216	this.initialization.computeConversion(scope, variableType, initializationType);	228	this.initialization.computeConversion(scope, variableType, initializationType);
217	if (initializationType.needsUncheckedConversion(variableType)) {	229	if (initializationType.needsUncheckedConversion(variableType)) {
218	scope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, variableType);	230	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 272-277 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (+5 lines)
272	receiverType = scope.enclosingSourceType();	272	receiverType = scope.enclosingSourceType();
273	} else {	273	} else {
274	receiverType = this.type.resolveType(scope, true /* check bounds*/);	274	receiverType = this.type.resolveType(scope, true /* check bounds*/);
		275	boolean isCompliant17 = scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_7;
		276	if (isCompliant17 && this.anonymousType != null && (this.type.bits & ASTNode.IsDiamond) != 0) {
		277	scope.problemReporter().invalidUsageOfDiamondConstruct(this.type);
		278	return null;
		279	}
275	checkParameterizedAllocation: {	280	checkParameterizedAllocation: {
276	if (receiverType == null \|\| !receiverType.isValidBinding()) break checkParameterizedAllocation;	281	if (receiverType == null \|\| !receiverType.isValidBinding()) break checkParameterizedAllocation;
277	if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()	282	if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()

Lines 208-213 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeReference.java (+5 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
		215
211	public TypeBinding resolveType(ClassScope scope) {	216	public TypeBinding resolveType(ClassScope scope) {
212	return internalResolveType(scope);	217	return internalResolveType(scope);
213	}	218	}

Lines 136-141 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java (+9 lines)
136	public static final String OPTION_IncludeNullInfoFromAsserts = "org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"; //$NON-NLS-1$	136	public static final String OPTION_IncludeNullInfoFromAsserts = "org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"; //$NON-NLS-1$
137	public static final String OPTION_ReportMethodCanBeStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"; //$NON-NLS-1$	137	public static final String OPTION_ReportMethodCanBeStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"; //$NON-NLS-1$
138	public static final String OPTION_ReportMethodCanBePotentiallyStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$	138	public static final String OPTION_ReportMethodCanBePotentiallyStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$
		139	public static final String OPTION_ReportRedundantDeclarationOfTypeArguments = "org.eclipse.jdt.core.compiler.problem.redundantDeclarationOfTypeArguments"; //$NON-NLS-1$
139	/**	140	/**
140	* Possible values for configurable options	141	* Possible values for configurable options
141	*/	142	*/
Lines 238-243 Link Here
238	public static final int UnusedObjectAllocation = IrritantSet.GROUP2 \| ASTNode.Bit4;	239	public static final int UnusedObjectAllocation = IrritantSet.GROUP2 \| ASTNode.Bit4;
239	public static final int MethodCanBeStatic = IrritantSet.GROUP2 \| ASTNode.Bit5;	240	public static final int MethodCanBeStatic = IrritantSet.GROUP2 \| ASTNode.Bit5;
240	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 \| ASTNode.Bit6;	241	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 \| ASTNode.Bit6;
		242	public static final int RedundantDeclarationOfTypeArguments = IrritantSet.GROUP2 \| ASTNode.Bit7;
241		243
242	// Severity level for handlers	244	// Severity level for handlers
243	/**	245	/**
Lines 547-552 Link Here
547	return OPTION_ReportMethodCanBeStatic;	549	return OPTION_ReportMethodCanBeStatic;
548	case MethodCanBePotentiallyStatic :	550	case MethodCanBePotentiallyStatic :
549	return OPTION_ReportMethodCanBePotentiallyStatic;	551	return OPTION_ReportMethodCanBePotentiallyStatic;
		552	case RedundantDeclarationOfTypeArguments :
		553	return OPTION_ReportRedundantDeclarationOfTypeArguments;
550	}	554	}
551	return null;	555	return null;
552	}	556	}
Lines 680-685 Link Here
680	OPTION_ReportPossibleAccidentalBooleanAssignment,	684	OPTION_ReportPossibleAccidentalBooleanAssignment,
681	OPTION_ReportPotentialNullReference,	685	OPTION_ReportPotentialNullReference,
682	OPTION_ReportRawTypeReference,	686	OPTION_ReportRawTypeReference,
		687	OPTION_ReportRedundantDeclarationOfTypeArguments,
683	OPTION_ReportRedundantNullCheck,	688	OPTION_ReportRedundantNullCheck,
684	OPTION_ReportRedundantSuperinterface,	689	OPTION_ReportRedundantSuperinterface,
685	OPTION_ReportSpecialParameterHidingField,	690	OPTION_ReportSpecialParameterHidingField,
Lines 763-768 Link Here
763	case UnusedDeclaredThrownException :	768	case UnusedDeclaredThrownException :
764	case DeadCode :	769	case DeadCode :
765	case UnusedObjectAllocation :	770	case UnusedObjectAllocation :
		771	case RedundantDeclarationOfTypeArguments :
766	return "unused"; //$NON-NLS-1$	772	return "unused"; //$NON-NLS-1$
767	case DiscouragedReference :	773	case DiscouragedReference :
768	case ForbiddenReference :	774	case ForbiddenReference :
Lines 973-978 Link Here
973	optionsMap.put(OPTION_IncludeNullInfoFromAsserts, this.includeNullInfoFromAsserts ? ENABLED : DISABLED);	979	optionsMap.put(OPTION_IncludeNullInfoFromAsserts, this.includeNullInfoFromAsserts ? ENABLED : DISABLED);
974	optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic));	980	optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic));
975	optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic));	981	optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic));
		982	optionsMap.put(OPTION_ReportRedundantDeclarationOfTypeArguments, getSeverityString(RedundantDeclarationOfTypeArguments));
976	return optionsMap;	983	return optionsMap;
977	}	984	}
978		985
Lines 1402-1407 Link Here
1402	if ((optionValue = optionsMap.get(OPTION_ReportUnusedObjectAllocation)) != null) updateSeverity(UnusedObjectAllocation, optionValue);	1409	if ((optionValue = optionsMap.get(OPTION_ReportUnusedObjectAllocation)) != null) updateSeverity(UnusedObjectAllocation, optionValue);
1403	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBeStatic)) != null) updateSeverity(MethodCanBeStatic, optionValue);	1410	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBeStatic)) != null) updateSeverity(MethodCanBeStatic, optionValue);
1404	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBePotentiallyStatic)) != null) updateSeverity(MethodCanBePotentiallyStatic, optionValue);	1411	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBePotentiallyStatic)) != null) updateSeverity(MethodCanBePotentiallyStatic, optionValue);
		1412	if ((optionValue = optionsMap.get(OPTION_ReportRedundantDeclarationOfTypeArguments)) != null) updateSeverity(RedundantDeclarationOfTypeArguments, optionValue);
1405		1413
1406	// Javadoc options	1414	// Javadoc options
1407	if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {	1415	if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {
Lines 1616-1621 Link Here
1616	buf.append("\n\t- unused object allocation: ").append(getSeverityString(UnusedObjectAllocation)); //$NON-NLS-1$	1624	buf.append("\n\t- unused object allocation: ").append(getSeverityString(UnusedObjectAllocation)); //$NON-NLS-1$
1617	buf.append("\n\t- method can be static: ").append(getSeverityString(MethodCanBeStatic)); //$NON-NLS-1$	1625	buf.append("\n\t- method can be static: ").append(getSeverityString(MethodCanBeStatic)); //$NON-NLS-1$
1618	buf.append("\n\t- method can be potentially static: ").append(getSeverityString(MethodCanBePotentiallyStatic)); //$NON-NLS-1$	1626	buf.append("\n\t- method can be potentially static: ").append(getSeverityString(MethodCanBePotentiallyStatic)); //$NON-NLS-1$
		1627	buf.append("\n\t- redundant declaration of type arguments: ").append(getSeverityString(RedundantDeclarationOfTypeArguments)); //$NON-NLS-1$
1619	return buf.toString();	1628	return buf.toString();
1620	}	1629	}
1621		1630

Lines 120-126 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java (-1 / +2 lines)
120	.set(CompilerOptions.UnusedTypeArguments)	120	.set(CompilerOptions.UnusedTypeArguments)
121	.set(CompilerOptions.RedundantSuperinterface)	121	.set(CompilerOptions.RedundantSuperinterface)
122	.set(CompilerOptions.DeadCode)	122	.set(CompilerOptions.DeadCode)
123	.set(CompilerOptions.UnusedObjectAllocation);	123	.set(CompilerOptions.UnusedObjectAllocation)
		124	.set(CompilerOptions.RedundantDeclarationOfTypeArguments);
124	STATIC_METHOD	125	STATIC_METHOD
125	.set(CompilerOptions.MethodCanBePotentiallyStatic);	126	.set(CompilerOptions.MethodCanBePotentiallyStatic);
126	String suppressRawWhenUnchecked = System.getProperty("suppressRawWhenUnchecked"); //$NON-NLS-1$	127	String suppressRawWhenUnchecked = System.getProperty("suppressRawWhenUnchecked"); //$NON-NLS-1$




 * 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 / +11 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) && ((fieldDecl.type.bits & ASTNode.IsDiamond) != 0)) {
		1314	this.scope.problemReporter().incorrectArityForParameterizedType(fieldDecl.type, fieldType, Binding.NO_TYPES);
		1315	fieldDecl.binding = null;
		1316	return null;
		1317	}
1313	if (fieldType == TypeBinding.VOID) {	1318	if (fieldType == TypeBinding.VOID) {
1314	this.scope.problemReporter().variableTypeCannotBeVoid(fieldDecl);	1319	this.scope.problemReporter().variableTypeCannotBeVoid(fieldDecl);
1315	fieldDecl.binding = null;	1320	fieldDecl.binding = null;
Lines 1390-1395 Link Here
1390	final boolean reportUnavoidableGenericTypeProblems = this.scope.compilerOptions().reportUnavoidableGenericTypeProblems;	1395	final boolean reportUnavoidableGenericTypeProblems = this.scope.compilerOptions().reportUnavoidableGenericTypeProblems;
1391	boolean foundArgProblem = false;	1396	boolean foundArgProblem = false;
1392	Argument[] arguments = methodDecl.arguments;	1397	Argument[] arguments = methodDecl.arguments;
		1398	boolean isCompliant17 = this.scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_7;
1393	if (arguments != null) {	1399	if (arguments != null) {
1394	int size = arguments.length;	1400	int size = arguments.length;
1395	method.parameters = Binding.NO_PARAMETERS;	1401	method.parameters = Binding.NO_PARAMETERS;
Lines 1415-1420 Link Here
1415		1421
1416	if (parameterType == null) {	1422	if (parameterType == null) {
1417	foundArgProblem = true;	1423	foundArgProblem = true;
		1424	} else if (isCompliant17 && (arg.type.bits & ASTNode.IsDiamond) != 0) {
		1425	// a parameter type cannot use diamond construct
		1426	methodDecl.scope.problemReporter().incorrectArityForParameterizedType(arg.type, parameterType.original(), Binding.NO_TYPES);
		1427	foundArgProblem = true;
1418	} else if (parameterType == TypeBinding.VOID) {	1428	} else if (parameterType == TypeBinding.VOID) {
1419	methodDecl.scope.problemReporter().argumentTypeCannotBeVoid(this, methodDecl, arg);	1429	methodDecl.scope.problemReporter().argumentTypeCannotBeVoid(this, methodDecl, arg);
1420	foundArgProblem = true;	1430	foundArgProblem = true;
Lines 1436-1442 Link Here
1436	}	1446	}
1437		1447
1438	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=337799	1448	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=337799
1439	if (this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7) {	1449	if (isCompliant17) {
1440	if ((method.tagBits & TagBits.AnnotationSafeVarargs) != 0) {	1450	if ((method.tagBits & TagBits.AnnotationSafeVarargs) != 0) {
1441	if (!method.isVarargs()) {	1451	if (!method.isVarargs()) {
1442	methodDecl.scope.problemReporter().safeVarargsOnFixedArityMethod(method);	1452	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	}

Lines 3956-3961 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java (-1 / +3 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 8915-8921 Link Here
8915	parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;	8916	parameterizedSingleTypeReference.sourceEnd = this.endStatementPosition;
8916	}	8917	}
8917	if (isDiamond) {	8918	if (isDiamond) {
8918	parameterizedSingleTypeReference.bits \|= ASTNode.IsDiamond;	8919	if (parameterizedSingleTypeReference.dimensions == 0)
		8920	parameterizedSingleTypeReference.bits \|= ASTNode.IsDiamond;
8919	}	8921	}
8920	return parameterizedSingleTypeReference;	8922	return parameterizedSingleTypeReference;
8921	} else {	8923	} else {

Lines 430-435 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (+25 lines)
430		430
431	case IProblem.MethodCanBePotentiallyStatic:	431	case IProblem.MethodCanBePotentiallyStatic:
432	return CompilerOptions.MethodCanBePotentiallyStatic;	432	return CompilerOptions.MethodCanBePotentiallyStatic;
		433
		434	case IProblem.RedundantDeclarationOfTypeArguments:
		435	return CompilerOptions.RedundantDeclarationOfTypeArguments;
433	}	436	}
434	return 0;	437	return 0;
435	}	438	}
Lines 503-508 Link Here
503	case CompilerOptions.UnusedWarningToken :	506	case CompilerOptions.UnusedWarningToken :
504	case CompilerOptions.UnusedLabel :	507	case CompilerOptions.UnusedLabel :
505	case CompilerOptions.RedundantSuperinterface :	508	case CompilerOptions.RedundantSuperinterface :
		509	case CompilerOptions.RedundantDeclarationOfTypeArguments :
506	return CategorizedProblem.CAT_UNNECESSARY_CODE;	510	return CategorizedProblem.CAT_UNNECESSARY_CODE;
507		511
508	case CompilerOptions.UsingDeprecatedAPI :	512	case CompilerOptions.UsingDeprecatedAPI :
Lines 3877-3882 Link Here
3877	annotationTypeDeclaration.sourceStart,	3881	annotationTypeDeclaration.sourceStart,
3878	annotationTypeDeclaration.sourceEnd);	3882	annotationTypeDeclaration.sourceEnd);
3879	}	3883	}
		3884	public void invalidUsageOfDiamondConstruct(ASTNode typeRef) {
		3885	//int i = 1;
		3886	this.handle(
		3887	IProblem.InvalidUsageOfDiamondConstruct,
		3888	NoArgument,
		3889	NoArgument,
		3890	typeRef.sourceStart,
		3891	typeRef.sourceEnd);
		3892	}
3880	public void invalidUsageOfEnumDeclarations(TypeDeclaration enumDeclaration) {	3893	public void invalidUsageOfEnumDeclarations(TypeDeclaration enumDeclaration) {
3881	this.handle(	3894	this.handle(
3882	IProblem.InvalidUsageOfEnumDeclarations,	3895	IProblem.InvalidUsageOfEnumDeclarations,
Lines 6177-6182 Link Here
6177	localDecl.sourceStart,	6190	localDecl.sourceStart,
6178	localDecl.sourceEnd);	6191	localDecl.sourceEnd);
6179	}	6192	}
		6193	public void redundantDeclarationOfTypeArguments(ASTNode location, TypeBinding[] argumentTypes) {
		6194	int severity = computeSeverity(IProblem.RedundantDeclarationOfTypeArguments);
		6195	if (severity != ProblemSeverities.Ignore) {
		6196	this.handle(
		6197	IProblem.RedundantDeclarationOfTypeArguments,
		6198	new String[] {typesAsString(false, argumentTypes, false)},
		6199	new String[] {typesAsString(false, argumentTypes, true)},
		6200	severity,
		6201	location.sourceStart,
		6202	nodeSourceEnd(null, location));
		6203	}
		6204	}
6180	public void redundantSuperInterface(SourceTypeBinding type, TypeReference reference, ReferenceBinding superinterface, ReferenceBinding declaringType) {	6205	public void redundantSuperInterface(SourceTypeBinding type, TypeReference reference, ReferenceBinding superinterface, ReferenceBinding declaringType) {
6181	int severity = computeSeverity(IProblem.RedundantSuperinterface);	6206	int severity = computeSeverity(IProblem.RedundantSuperinterface);
6182	if (severity != ProblemSeverities.Ignore) {	6207	if (severity != ProblemSeverities.Ignore) {

Lines 638-643 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (+2 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
		642	878 = Redundant declaration of type arguments <{0}>
641		643
642	### ELABORATIONS	644	### ELABORATIONS
643	## Access restrictions	645	## Access restrictions




/*******************************************************************************
 * 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

	 */
	public static final String COMPILER_PB_REDUNDANT_SUPERINTERFACE = PLUGIN_ID + ".compiler.problem.redundantSuperinterface"; //$NON-NLS-1$
	/**
	 * Compiler option ID: Reporting Redundant Declaration of Type Arguments.
	 * <p>When enabled, the compiler will issue an error or a warning if type arguments are specified
	 *    in a class instantiation expression where the diamond semantics "<>" are sufficient for the 
	 *    compiler to infer the type arguments.
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantDeclarationOfTypeArguments"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.7
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_REDUNDANT_DECLARATION_OF_TYPE_ARGS = PLUGIN_ID + ".compiler.problem.redundantDeclarationOfTypeArguments"; //$NON-NLS-1$
	/**
	 * Compiler option ID: Reporting Comparison of Identical Expressions.
	 * <p>When enabled, the compiler will issue an error or a warning if a comparison
	 * is involving identical operands (e.g <code>'x == x'</code>).




				true);
		String logContents = Util.fileContent(logFileName);
		String expectedLogContents =
				"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + 
				"<!DOCTYPE compiler PUBLIC \"-//Eclipse.org//DTD Eclipse JDT 3.2.004 Compiler//EN\" \"http://www.eclipse.org/jdt/core/compiler_32_004.dtd\">\n" + 
				"<compiler copyright=\"{2}\" name=\"{1}\" version=\"{3}\">\n" + 
				"	<command_line>\n" + 
				"		<argument value=\"---OUTPUT_DIR_PLACEHOLDER---{0}X.java\"/>\n" + 
				"		<argument value=\"-1.5\"/>\n" + 
				"		<argument value=\"-proceedOnError\"/>\n" + 
				"		<argument value=\"-log\"/>\n" + 
				"		<argument value=\"---OUTPUT_DIR_PLACEHOLDER---{0}log.xml\"/>\n" + 
				"		<argument value=\"-d\"/>\n" + 
				"		<argument value=\"---OUTPUT_DIR_PLACEHOLDER---\"/>\n" + 
				"	</command_line>\n" + 
				"	<options>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.codegen.targetPlatform\" value=\"1.5\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.codegen.unusedLocal\" value=\"optimize out\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.compliance\" value=\"1.5\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.debug.lineNumber\" value=\"generate\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.debug.localVariable\" value=\"do not generate\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.debug.sourceFile\" value=\"generate\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.doc.comment.support\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.generateClassFiles\" value=\"enabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.maxProblemPerUnit\" value=\"100\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.annotationSuperInterface\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.assertIdentifier\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.autoboxing\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.comparingIdentical\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.deadCode\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.deadCodeInTrivialIfStatement\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.deprecation\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.discouragedReference\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.emptyStatement\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.enumIdentifier\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.fallthroughCase\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.fatalOptionalError\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.fieldHiding\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.finalParameterBound\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.forbiddenReference\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadoc\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTags\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility\" value=\"public\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.localVariableHiding\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocComments\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility\" value=\"public\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription\" value=\"return_tag\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTags\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility\" value=\"public\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation\" value=\"enabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingSerialVersion\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.noEffectAssignment\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.nullReference\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.parameterAssignment\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.potentialNullReference\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.rawTypeReference\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.redundantDeclarationOfTypeArguments\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.redundantNullCheck\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.specialParameterHidingField\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.suppressWarnings\" value=\"enabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.tasks\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.typeParameterHiding\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems\" value=\"enabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unnecessaryElse\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable\" value=\"enabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference\" value=\"enabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedImport\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedLabel\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedLocal\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameter\" value=\"ignore\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference\" value=\"enabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedTypeArgumentsForMethodInvocation\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedWarningToken\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast\" value=\"warning\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.processAnnotations\" value=\"disabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.source\" value=\"1.5\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.taskCaseSensitive\" value=\"enabled\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.taskPriorities\" value=\"\"/>\n" + 
				"		<option key=\"org.eclipse.jdt.core.compiler.taskTags\" value=\"\"/>\n" + 
				"	</options>\n" + 
				"	<classpaths>NORMALIZED SECTION</classpaths>\n" + 
				"	<sources>\n" + 
				"		<source output=\"---OUTPUT_DIR_PLACEHOLDER---\" path=\"---OUTPUT_DIR_PLACEHOLDER---\\X.java\">\n" + 
				"			<problems errors=\"1\" problems=\"1\" warnings=\"0\">\n" + 
				"				<problem categoryID=\"40\" charEnd=\"28\" charStart=\"25\" id=\"UndefinedType\" line=\"3\" problemID=\"16777218\" severity=\"ERROR\">\n" + 
				"					<message value=\"Zork cannot be resolved to a type\"/>\n" + 
				"					<source_context sourceEnd=\"3\" sourceStart=\"0\" value=\"Zork z;\"/>\n" + 
				"					<arguments>\n" + 
				"						<argument value=\"Zork\"/>\n" + 
				"					</arguments>\n" + 
				"				</problem>\n" + 
				"			</problems>\n" + 
				"			<classfile path=\"---OUTPUT_DIR_PLACEHOLDER---\\X.class\"/>\n" + 
				"		</source>\n" + 
				"	</sources>\n" + 
				"	<stats>\n" + 
				"		<problem_summary errors=\"1\" problems=\"1\" tasks=\"0\" warnings=\"0\"/>\n" + 
				"	</stats>\n" + 
				"</compiler>\n";
		String normalizedExpectedLogContents =
				MessageFormat.format(
						expectedLogContents,




		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("RecursiveConstructorInvocation", SKIP);
		expectedProblemAttributes.put("RedefinedArgument", SKIP);
		expectedProblemAttributes.put("RedefinedLocal", SKIP);
		expectedProblemAttributes.put("RedundantDeclarationOfTypeArguments", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_DECLARATION_OF_TYPE_ARGS));
		expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
		expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
		expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));

		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() {
	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 org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

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");
}
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");
}
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 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 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");
}
//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 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 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");
}
public void test012() {
	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 test013() {
	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);
}
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 static Class testClass() {
	return GenericsRegressionTest_1_7.class;
}
}

Lines 32-37 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/RunComparableTests.java (+1 lines)
32	ALL_CLASSES.add(Compliance_1_5.class);	32	ALL_CLASSES.add(Compliance_1_5.class);
33	ALL_CLASSES.add(GenericTypeTest.class);	33	ALL_CLASSES.add(GenericTypeTest.class);
34	ALL_CLASSES.add(GenericsRegressionTest.class);	34	ALL_CLASSES.add(GenericsRegressionTest.class);
		35	ALL_CLASSES.add(GenericsRegressionTest_1_7.class);
35	ALL_CLASSES.add(ForeachStatementTest.class);	36	ALL_CLASSES.add(ForeachStatementTest.class);
36	ALL_CLASSES.add(StaticImportTest.class);	37	ALL_CLASSES.add(StaticImportTest.class);
37	ALL_CLASSES.add(VarargsTest.class);	38	ALL_CLASSES.add(VarargsTest.class);

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 1740-1743 Link Here

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

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/core/JavaCore.java (-1 / +15 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 1619-1624 Link Here
1619	*/	1619	*/
1620	public static final String COMPILER_PB_REDUNDANT_SUPERINTERFACE = PLUGIN_ID + ".compiler.problem.redundantSuperinterface"; //$NON-NLS-1$	1620	public static final String COMPILER_PB_REDUNDANT_SUPERINTERFACE = PLUGIN_ID + ".compiler.problem.redundantSuperinterface"; //$NON-NLS-1$
1621	/**	1621	/**
		1622	* Compiler option ID: Reporting Redundant Declaration of Type Arguments.
		1623	* <p>When enabled, the compiler will issue an error or a warning if type arguments are specified
		1624	* in a class instantiation expression where the diamond semantics "<>" are sufficient for the
		1625	* compiler to infer the type arguments.
		1626	* <dl>
		1627	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantDeclarationOfTypeArguments"</code></dd>
		1628	* <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
		1629	* <dt>Default:</dt><dd><code>"warning"</code></dd>
		1630	* </dl>
		1631	* @since 3.7
		1632	* @category CompilerOptionID
		1633	*/
		1634	public static final String COMPILER_PB_REDUNDANT_DECLARATION_OF_TYPE_ARGS = PLUGIN_ID + ".compiler.problem.redundantDeclarationOfTypeArguments"; //$NON-NLS-1$
		1635	/**
1622	* Compiler option ID: Reporting Comparison of Identical Expressions.	1636	* Compiler option ID: Reporting Comparison of Identical Expressions.
1623	* <p>When enabled, the compiler will issue an error or a warning if a comparison	1637	* <p>When enabled, the compiler will issue an error or a warning if a comparison
1624	* is involving identical operands (e.g <code>'x == x'</code>).	1638	* is involving identical operands (e.g <code>'x == x'</code>).

Added Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest_1_7.java (+444 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 IBM Corporation.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* This is an implementation of an early-draft specification developed under the Java
9	* Community Process (JCP) and is made available for testing and evaluation purposes
10	* only. The code is not compatible with any specification of the JCP.
11	*
12	* Contributors:
13	* IBM Corporation - initial API and implementation
14	*******************************************************************************/
15	package org.eclipse.jdt.core.tests.compiler.regression;
16
17	import java.util.Map;
18
19	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
20
21	import junit.framework.Test;
22	public class GenericsRegressionTest_1_7 extends AbstractRegressionTest {
23
24	static {
25	// TESTS_NAMES = new String[] { "test0014" };
26	// TESTS_NUMBERS = new int[] { 40, 41, 43, 45, 63, 64 };
27	// TESTS_RANGE = new int[] { 11, -1 };
28	}
29	public GenericsRegressionTest_1_7(String name) {
30	super(name);
31	}
32	public static Test suite() {
33	return buildMinimalComplianceTestSuite(testClass(), F_1_7);
34	}
35	public void test001() {
36	this.runConformTest(
37	new String[] {
38	"X.java",
39	"public class X<T> {\n" +
40	" public static void main(String[] args) {\n" +
41	" X<String> x = new X<>();\n" +
42	" x.testFunction(\"SUCCESS\");\n" +
43	" }\n" +
44	" public void testFunction(T param){\n" +
45	" System.out.println(param);\n" +
46	" }\n" +
47	"}",
48	},
49	"SUCCESS");
50	}
51	public void test001a() {
52	this.runNegativeTest(
53	new String[] {
54	"X.java",
55	"public class X<T> {\n" +
56	" public static void main(String[] args) {\n" +
57	" X<String> x = new X<>();\n" +
58	" x.testFunction(1);\n" +
59	" }\n" +
60	" public void testFunction(T param){\n" +
61	" System.out.println(param);\n" +
62	" }\n" +
63	"}",
64	},
65	"----------\n" +
66	"1. ERROR in X.java (at line 4)\n" +
67	" x.testFunction(1);\n" +
68	" ^^^^^^^^^^^^\n" +
69	"The method testFunction(String) in the type X<String> is not applicable for the arguments (int)\n" +
70	"----------\n");
71	}
72	public void test001b() {
73	this.runConformTest(
74	new String[] {
75	"X.java",
76	"public class X<T> {\n" +
77	" public static void main(String[] args) {\n" +
78	" java.util.ArrayList<String> x = new java.util.ArrayList<>();\n" +
79	" x.add(\"\");\n" +
80	" System.out.println(\"SUCCESS\");\n" +
81	" }\n" +
82	"}",
83	},
84	"SUCCESS");
85	}
86	public void test001c() {
87	this.runNegativeTest(
88	new String[] {
89	"X.java",
90	"public class X<T> {\n" +
91	" public static void main(String[] args) {\n" +
92	" java.util.ArrayList<String> x = new java.util.ArrayList<>();\n" +
93	" x.add(1);\n" +
94	" System.out.println(\"SUCCESS\");\n" +
95	" }\n" +
96	"}",
97	},
98	"----------\n" +
99	"1. ERROR in X.java (at line 4)\n" +
100	" x.add(1);\n" +
101	" ^^^\n" +
102	"The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)\n" +
103	"----------\n");
104	}
105	public void _test001d() {
106	this.runConformTest(
107	new String[] {
108	"X.java",
109	"import java.util.ArrayList;\n" +
110	"public class X<T> {" +
111	" public void ab(ArrayList<String> al){\n" +
112	" System.out.println(\"SUCCESS\");\n" +
113	" }\n" +
114	" public static void main(String[] args) {\n" +
115	" X<String> x = new X<>();\n" +
116	" x.ab(new ArrayList<>());\n" +
117	" }\n" +
118	"}",
119	},
120	"SUCCESS");
121	}
122	public void _test001e() {
123	this.runNegativeTest(
124	new String[] {
125	"X.java",
126	"import java.util.ArrayList;\n" +
127	"public class X<T> {" +
128	" public void ab(ArrayList<T> al){\n" +
129	" System.out.println(\"SUCCESS\");\n" +
130	" }\n" +
131	" public static void main(String[] args) {\n" +
132	" X<String> x = new X<>();\n" +
133	" x.ab(new ArrayList<>());\n" +
134	" }\n" +
135	"}",
136	},
137	"----------\n" +
138	"1. ERROR in X.java (at line 7)\n" +
139	" x.ab(new ArrayList<Integer>());\n" +
140	" ^^\n" +
141	"The method ab(ArrayList<String>) in the type X<String> is not applicable for the arguments (ArrayList<Integer>)\n" +
142	"----------\n");
143	}
144	public void test002() {
145	this.runNegativeTest(
146	new String[] {
147	"X.java",
148	"public class X<T> {\n" +
149	" public static void main(String[] args) {\n" +
150	" X x = new X<>();\n" +
151	" x.testFunction(\"SUCCESS\");\n" +
152	" }\n" +
153	" public void testFunction(T param){\n" +
154	" System.out.println(param);\n" +
155	" }\n" +
156	"}",
157	},
158	"----------\n" +
159	"1. WARNING in X.java (at line 3)\n" +
160	" X x = new X<>();\n" +
161	" ^\n" +
162	"X is a raw type. References to generic type X<T> should be parameterized\n" +
163	"----------\n" +
164	"2. WARNING in X.java (at line 4)\n" +
165	" x.testFunction(\"SUCCESS\");\n" +
166	" ^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
167	"Type safety: The method testFunction(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" +
168	"----------\n");
169	}
170	public void _test003() {
171	this.runNegativeTest(
172	new String[] {
173	"X.java",
174	"public class X<T> {\n" +
175	" public static void main(String[] args) {\n" +
176	" new X<>().testFunction(\"SUCCESS\");\n" +
177	" }\n" +
178	" public void testFunction(T param){\n" +
179	" System.out.println(param);\n" +
180	" }\n" +
181	"}",
182	},
183	"SUCCESS");
184	}
185	public void test004() {
186	this.runNegativeTest(
187	new String[] {
188	"X.java",
189	"public class X<T> {\n" +
190	" public static void main(String[] args) {\n" +
191	" new X<>(){\n" +
192	" void newMethod(){\n" +
193	" }\n" +
194	" }.testFunction(\"SUCCESS\");\n" +
195	" }\n" +
196	" public void testFunction(T param){\n" +
197	" System.out.println(param);\n" +
198	" }\n" +
199	"}",
200	},
201	"----------\n" +
202	"1. ERROR in X.java (at line 3)\n" +
203	" new X<>(){\n" +
204	" ^\n" +
205	"Empty type argument list cannot be used in anonymous class declaration\n" +
206	"----------\n");
207	}
208	public void test005() {
209	this.runNegativeTest(
210	new String[] {
211	"X.java",
212	"public class X<T> {\n" +
213	" public static void main(String[] args) {\n" +
214	" X Test = new X<>(){\n" +
215	" void newMethod(){\n" +
216	" }\n" +
217	" }.testFunction(\"SUCCESS\");\n" +
218	" }\n" +
219	" public void testFunction(T param){\n" +
220	" System.out.println(param);\n" +
221	" }\n" +
222	"}",
223	},
224	"----------\n" +
225	"1. WARNING in X.java (at line 3)\n" +
226	" X Test = new X<>(){\n" +
227	" ^\n" +
228	"X is a raw type. References to generic type X<T> should be parameterized\n" +
229	"----------\n" +
230	"2. ERROR in X.java (at line 3)\n" +
231	" X Test = new X<>(){\n" +
232	" ^\n" +
233	"Empty type argument list cannot be used in anonymous class declaration\n" +
234	"----------\n");
235	}
236	public void test006() {
237	this.runConformTest(
238	new String[] {
239	"X.java",
240	"class X1<T> {\n" +
241	" int abc = 1;\n" +
242	" public void testFunction(T param){\n" +
243	" System.out.println(param + \"X1\");\n" +
244	" }\n" +
245	"}\n" +
246	"public class X<T> extends X1<T> {\n" +
247	" public static void main(String[] args) {\n" +
248	" X1<String> x = new X<>();\n" +
249	" x.testFunction(\"SUCCESS\");\n" +
250	" }\n" +
251	" public void testFunction(T param){\n" +
252	" System.out.println(param);\n" +
253	" }\n" +
254	"}",
255	},
256	"SUCCESS");
257	}
258	// shows the difference between using <> and the raw type - different semantics
259	public void _test007() {
260	this.runConformTest(
261	new String[] {
262	"X.java",
263	"public class X<T> {\n" +
264	" T field1;" +
265	" public X(T param){\n" +
266	" field1 = param;\n" +
267	" }\n" +
268	" public static void main(String[] args) {\n" +
269	" X.testFunction(new X<>(\"hello\").getField());\n" + // prints 1
270	" X.testFunction(new X(\"hello\").getField());\n" + //prints 2
271	" }\n" +
272	" public static void testFunction(String param){\n" +
273	" System.out.println(1);\n" +
274	" }\n" +
275	" public static void testFunction(Object param){\n" +
276	" System.out.println(2);\n" +
277	" }\n" +
278	" public T getField(){\n" +
279	" return field1;" +
280	" }\n" +
281	"}",
282	},
283	"1\n" +
284	"2");
285	}
286	//shows the difference between using <> and the raw type - different semantics
287	public void _test008() {
288	this.runConformTest(
289	new String[] {
290	"X.java",
291	"public class X<T> {\n" +
292	" T field1;" +
293	" public X(T param){\n" +
294	" field1 = param;\n" +
295	" }\n" +
296	" public static void main(String[] args) {\n" +
297	" X<?> x1 = new X(1).get(\"\");\n" + // ok - passing String where Object is expected
298	" X<?> x2 = new X<>(1).get(\"\");\n" + // bad - passing String where Integer is expected
299	" }\n" +
300	" public X<T> get(T t){\n" +
301	" return this;" +
302	" }\n" +
303	"}",
304	},
305	"1\n" +
306	"2");
307	}
308	public void test009() {
309	this.runNegativeTest(
310	new String[] {
311	"X.java",
312	"public class X<T> {\n" +
313	" public static void main(String[] args) {\n" +
314	" X<>[] x1 = null;\n" +
315	" }\n" +
316	"}",
317	},
318	"----------\n" +
319	"1. ERROR in X.java (at line 3)\n" +
320	" X<>[] x1 = null;\n" +
321	" ^\n" +
322	"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" +
323	"----------\n");
324	}
325	public void test010() {
326	this.runNegativeTest(
327	new String[] {
328	"X.java",
329	"public class X<T> {\n" +
330	" public static void main(String[] args) {\n" +
331	" X<> x1 = null;\n" +
332	" }\n" +
333	"}",
334	},
335	"----------\n" +
336	"1. ERROR in X.java (at line 3)\n" +
337	" X<> x1 = null;\n" +
338	" ^\n" +
339	"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" +
340	"----------\n");
341	}
342	public void test011() {
343	this.runNegativeTest(
344	new String[] {
345	"X.java",
346	"public class X<T> {\n" +
347	" public void foo(X<> args) {\n" +
348	" }\n" +
349	"}",
350	},
351	"----------\n" +
352	"1. ERROR in X.java (at line 2)\n" +
353	" public void foo(X<> args) {\n" +
354	" ^\n" +
355	"Incorrect number of arguments for type X<T>; it cannot be parameterized with arguments <>\n" +
356	"----------\n");
357	}
358	public void test012() {
359	this.runNegativeTest(
360	new String[] {
361	"X.java",
362	"public class X<T> {\n" +
363	" X<> f1 = null;\n" +
364	"}",
365	},
366	"----------\n" +
367	"1. ERROR in X.java (at line 2)\n" +
368	" X<> f1 = null;\n" +
369	" ^\n" +
370	"Incorrect number of arguments for type X<>; it cannot be parameterized with arguments <>\n" +
371	"----------\n");
372	}
373	public void test013() {
374	Map options = getCompilerOptions();
375	options.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);
376	this.runNegativeTest(
377	new String[] {
378	"X.java",
379	"public class X<T> {\n" +
380	" X<String> f1 = new X<String>();\n" +
381	" public void foo() {\n" +
382	" X<Integer> i1 = new X<Integer>();\n" +
383	" }\n" +
384	"}",
385	},
386	"----------\n" +
387	"1. ERROR in X.java (at line 2)\n" +
388	" X<String> f1 = new X<String>();\n" +
389	" ^^^^^^^^^^^^^^^\n" +
390	"Redundant declaration of type arguments <String>\n" +
391	"----------\n" +
392	"2. ERROR in X.java (at line 4)\n" +
393	" X<Integer> i1 = new X<Integer>();\n" +
394	" ^^^^^^^^^^^^^^^^\n" +
395	"Redundant declaration of type arguments <Integer>\n" +
396	"----------\n",
397	null,
398	true,
399	options);
400	}
401	public void test0014() {
402	this.runConformTest(
403	new String[] {
404	"X.java",
405	"public class X<J,K> {\n" +
406	" public static void main(String[] args) {\n" +
407	" X<String,Integer> x = new X<>();\n" +
408	" x.testFunction(\"SUCCESS\", 123);\n" +
409	" }\n" +
410	" public void testFunction(J param, K param2){\n" +
411	" System.out.println(param);\n" +
412	" System.out.println(param2);\n" +
413	" }\n" +
414	"}",
415	},
416	"SUCCESS\n" +
417	"123");
418	}
419	public void test0014a() {
420	this.runNegativeTest(
421	new String[] {
422	"X.java",
423	"public class X<J,K> {\n" +
424	" public static void main(String[] args) {\n" +
425	" X<String,Integer> x = new X<>();\n" +
426	" x.testFunction(123, \"SUCCESS\");\n" +
427	" }\n" +
428	" public void testFunction(J param, K param2){\n" +
429	" System.out.println(param);\n" +
430	" System.out.println(param2);\n" +
431	" }\n" +
432	"}",
433	},
434	"----------\n" +
435	"1. ERROR in X.java (at line 4)\n" +
436	" x.testFunction(123, \"SUCCESS\");\n" +
437	" ^^^^^^^^^^^^\n" +
438	"The method testFunction(String, Integer) in the type X<String,Integer> is not applicable for the arguments (int, String)\n" +
439	"----------\n");
440	}
441	public static Class testClass() {
442	return GenericsRegressionTest_1_7.class;
443	}
444	}