Attachment 199377 Details for Bug 340747 – fix v1.0 corrected+ regression tests

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

[patch] fix v1.0 corrected+ regression tests

patch340747.txt (text/plain), 36.07 KB, created by Ayushman Jain

on 2011-07-09 13:33:20 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Ayushman Jain

Created: 2011-07-09 13:33:20 EDT

Size: 36.07 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core
>Index: compiler/org/eclipse/jdt/core/compiler/IProblem.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java,v
>retrieving revision 1.225.2.23
>diff -u -r1.225.2.23 IProblem.java
>--- compiler/org/eclipse/jdt/core/compiler/IProblem.java	6 Jul 2011 18:46:34 -0000	1.225.2.23
>+++ compiler/org/eclipse/jdt/core/compiler/IProblem.java	9 Jul 2011 17:27:45 -0000
>@@ -1394,6 +1394,8 @@
> 	int UnhandledExceptionOnAutoClose = TypeRelated + 882;
> 	/** @since 3.7 */
> 	int DiamondNotBelow17 = TypeRelated + 883;
>+	/** @since 3.7 */
>+	int RedundantDeclarationOfTypeArguments = TypeRelated + 884;
> 	/**
> 	 * External problems -- These are problems defined by other plugins
> 	 */
>Index: compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java,v
>retrieving revision 1.84.2.11
>diff -u -r1.84.2.11 AllocationExpression.java
>--- compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java	23 May 2011 10:57:30 -0000	1.84.2.11
>+++ compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java	9 Jul 2011 17:27:46 -0000
>@@ -17,12 +17,15 @@
> *******************************************************************************/
> package org.eclipse.jdt.internal.compiler.ast;
> 
>+import org.eclipse.jdt.core.compiler.IProblem;
> import org.eclipse.jdt.internal.compiler.ASTVisitor;
> import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
> import org.eclipse.jdt.internal.compiler.codegen.*;
> import org.eclipse.jdt.internal.compiler.flow.*;
> import org.eclipse.jdt.internal.compiler.impl.Constant;
> import org.eclipse.jdt.internal.compiler.lookup.*;
>+import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
>+import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
> 
> public class AllocationExpression extends Expression implements InvocationSite {
> 
>@@ -402,6 +405,9 @@
> 	if (this.typeArguments != null && this.binding.original().typeVariables == Binding.NO_TYPE_VARIABLES) {
> 		scope.problemReporter().unnecessaryTypeArgumentsForMethodInvocation(this.binding, this.genericTypeArguments, this.typeArguments);
> 	}
>+	if (!isDiamond && this.resolvedType.isParameterizedTypeWithActualArguments()) {
>+ 		checkTypeParameterRequired((ParameterizedTypeBinding) this.resolvedType, null, argumentTypes, scope);
>+ 	}
> 	return allocationType;
> }
> 
>@@ -418,6 +424,60 @@
> 	return null;
> }
> 
>+public void checkTypeParameterRequired(ParameterizedTypeBinding allocationType, ReferenceBinding enclosingType, TypeBinding[] argumentTypes, final BlockScope scope) {
>+	ProblemReporter reporter = scope.problemReporter();
>+	if ((reporter.computeSeverity(IProblem.RedundantDeclarationOfTypeArguments) == ProblemSeverities.Ignore) || scope.compilerOptions().sourceLevel < ClassFileConstants.JDK1_7) return;
>+	if (allocationType.arguments == null) return; // raw binding
>+	if (this.genericTypeArguments != null) return; // diamond can't occur with explicit type args for constructor
>+	if (argumentTypes != Binding.NO_PARAMETERS) { // check if any parameter type is one of the class's type vars
>+		if (this.typeExpected != null) {
>+			MethodBinding originalMethod = this.binding.original();
>+			TypeBinding[] methodParams = originalMethod.parameters;
>+			TypeVariableBinding[] classVariables = originalMethod.declaringClass.typeVariables();
>+			int i;
>+			boolean flag = false;
>+			for (i = 0; i < methodParams.length && !flag; i++) {
>+				if (methodParams[i] instanceof TypeVariableBinding) {
>+					for (int j = 0; j < classVariables.length; j++) {
>+						if (methodParams[i] == classVariables[j]) {
>+							flag = true;
>+							break;
>+						}
>+					}
>+				}
>+			}
>+			if (!flag) {
>+				reporter.redundantDeclarationOfTypeArguments(this.type, allocationType.arguments);
>+				return;
>+			}
>+		}
>+	} else if (this.typeExpected instanceof ParameterizedTypeBinding
>+			&& ((ParameterizedTypeBinding) this.typeExpected).arguments != null
>+			&& allocationType.arguments.length == ((ParameterizedTypeBinding) this.typeExpected).arguments.length) {
>+		// check the case when no ctor takes no params and inference uses the expected type directly
>+		// eg. X<String> x = new X<String>()
>+		int i;
>+		for (i = 0; i < allocationType.arguments.length; i++) {
>+			if (allocationType.arguments[i] != ((ParameterizedTypeBinding) this.typeExpected).arguments[i])
>+				break;
>+		}
>+		if (i == allocationType.arguments.length) {
>+			reporter.redundantDeclarationOfTypeArguments(this.type, allocationType.arguments);
>+			return;
>+		}
>+	}
>+	ParameterizedTypeBinding allocTypeWithDiamond = new ParameterizedTypeBinding(allocationType.genericType(), Binding.NO_PARAMETERS, enclosingType, scope.environment());
>+	TypeBinding [] inferredTypes = inferElidedTypes(allocTypeWithDiamond.genericType(), enclosingType, argumentTypes, scope);
>+	if (inferredTypes == null) {
>+		return;
>+	}
>+	for (int i = 0; i < inferredTypes.length; i++) {
>+		if (inferredTypes[i] != allocationType.arguments[i])
>+			return;
>+	}
>+	reporter.redundantDeclarationOfTypeArguments(this.type, allocationType.arguments);
>+}
>+
> public void setActualReceiverType(ReferenceBinding receiverType) {
> 	// ignored
> }
>Index: compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java,v
>retrieving revision 1.101.2.11
>diff -u -r1.101.2.11 QualifiedAllocationExpression.java
>--- compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java	23 May 2011 10:57:30 -0000	1.101.2.11
>+++ compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java	9 Jul 2011 17:27:47 -0000
>@@ -431,6 +431,9 @@
> 			if ((this.binding.tagBits & TagBits.HasMissingType) != 0) {
> 				scope.problemReporter().missingTypeInConstructor(this, this.binding);
> 			}
>+			if (!isDiamond && receiverType.isParameterizedTypeWithActualArguments()) {
>+		 		checkTypeParameterRequired((ParameterizedTypeBinding)receiverType, receiverType.enclosingType(), argumentTypes , scope);
>+		 	}
> 			// The enclosing instance must be compatible with the innermost enclosing type
> 			ReferenceBinding expectedType = this.binding.declaringClass.enclosingType();
> 			if (expectedType != enclosingInstanceType) // must call before computeConversion() and typeMismatchError()
>Index: compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java,v
>retrieving revision 1.241.2.3
>diff -u -r1.241.2.3 CompilerOptions.java
>--- compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java	14 Feb 2011 14:08:01 -0000	1.241.2.3
>+++ compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java	9 Jul 2011 17:27:49 -0000
>@@ -136,6 +136,7 @@
> 	public static final String OPTION_IncludeNullInfoFromAsserts = "org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"; //$NON-NLS-1$
> 	public static final String OPTION_ReportMethodCanBeStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"; //$NON-NLS-1$
> 	public static final String OPTION_ReportMethodCanBePotentiallyStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$
>+	public static final String OPTION_ReportRedundantDeclarationOfTypeArguments = "org.eclipse.jdt.core.compiler.problem.redundantDeclarationOfTypeArguments"; //$NON-NLS-1$
> 	/**
> 	 * Possible values for configurable options
> 	 */
>@@ -238,6 +239,7 @@
> 	public static final int UnusedObjectAllocation = IrritantSet.GROUP2 | ASTNode.Bit4;
> 	public static final int MethodCanBeStatic = IrritantSet.GROUP2 | ASTNode.Bit5;
> 	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 | ASTNode.Bit6;
>+	public static final int RedundantDeclarationOfTypeArguments = IrritantSet.GROUP2 | ASTNode.Bit7;
> 
> 	// Severity level for handlers
> 	/** 
>@@ -547,6 +549,8 @@
> 				return OPTION_ReportMethodCanBeStatic;
> 			case MethodCanBePotentiallyStatic :
> 				return OPTION_ReportMethodCanBePotentiallyStatic;
>+			case RedundantDeclarationOfTypeArguments :
>+				return OPTION_ReportRedundantDeclarationOfTypeArguments;
> 		}
> 		return null;
> 	}
>@@ -682,6 +686,7 @@
> 			OPTION_ReportRawTypeReference,
> 			OPTION_ReportRedundantNullCheck,
> 			OPTION_ReportRedundantSuperinterface,
>+			OPTION_ReportRedundantDeclarationOfTypeArguments,
> 			OPTION_ReportSpecialParameterHidingField,
> 			OPTION_ReportSyntheticAccessEmulation,
> 			OPTION_ReportTasks,
>@@ -763,6 +768,7 @@
> 			case UnusedDeclaredThrownException :
> 			case DeadCode :
> 			case UnusedObjectAllocation :
>+			case RedundantDeclarationOfTypeArguments :
> 				return "unused"; //$NON-NLS-1$
> 			case DiscouragedReference :
> 			case ForbiddenReference :
>@@ -973,6 +979,7 @@
> 		optionsMap.put(OPTION_IncludeNullInfoFromAsserts, this.includeNullInfoFromAsserts ? ENABLED : DISABLED);
> 		optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic));
> 		optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic));
>+		optionsMap.put(OPTION_ReportRedundantDeclarationOfTypeArguments, getSeverityString(RedundantDeclarationOfTypeArguments));
> 		return optionsMap;
> 	}
> 
>@@ -1402,6 +1409,7 @@
> 		if ((optionValue = optionsMap.get(OPTION_ReportUnusedObjectAllocation)) != null) updateSeverity(UnusedObjectAllocation, optionValue);
> 		if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBeStatic)) != null) updateSeverity(MethodCanBeStatic, optionValue);
> 		if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBePotentiallyStatic)) != null) updateSeverity(MethodCanBePotentiallyStatic, optionValue);
>+		if ((optionValue = optionsMap.get(OPTION_ReportRedundantDeclarationOfTypeArguments)) != null) updateSeverity(RedundantDeclarationOfTypeArguments, optionValue);
> 
> 		// Javadoc options
> 		if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {
>@@ -1616,6 +1624,7 @@
> 		buf.append("\n\t- unused object allocation: ").append(getSeverityString(UnusedObjectAllocation)); //$NON-NLS-1$
> 		buf.append("\n\t- method can be static: ").append(getSeverityString(MethodCanBeStatic)); //$NON-NLS-1$
> 		buf.append("\n\t- method can be potentially static: ").append(getSeverityString(MethodCanBePotentiallyStatic)); //$NON-NLS-1$
>+		buf.append("\n\t- redundant declaration of type arguments: ").append(getSeverityString(RedundantDeclarationOfTypeArguments)); //$NON-NLS-1$
> 		return buf.toString();
> 	}
> 	
>Index: compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java,v
>retrieving revision 1.13.2.1
>diff -u -r1.13.2.1 IrritantSet.java
>--- compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java	11 Feb 2011 15:17:16 -0000	1.13.2.1
>+++ compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java	9 Jul 2011 17:27:49 -0000
>@@ -120,7 +120,8 @@
> 			.set(CompilerOptions.UnusedTypeArguments)
> 			.set(CompilerOptions.RedundantSuperinterface)
> 			.set(CompilerOptions.DeadCode)
>-			.set(CompilerOptions.UnusedObjectAllocation);
>+			.set(CompilerOptions.UnusedObjectAllocation)
>+			.set(CompilerOptions.RedundantDeclarationOfTypeArguments);
> 		STATIC_METHOD
> 		 .set(CompilerOptions.MethodCanBePotentiallyStatic);
> 		String suppressRawWhenUnchecked = System.getProperty("suppressRawWhenUnchecked"); //$NON-NLS-1$
>Index: compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java,v
>retrieving revision 1.430.2.34
>diff -u -r1.430.2.34 ProblemReporter.java
>--- compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java	6 Jul 2011 18:46:35 -0000	1.430.2.34
>+++ compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java	9 Jul 2011 17:28:01 -0000
>@@ -430,6 +430,9 @@
> 			
> 		case IProblem.MethodCanBePotentiallyStatic:
> 			return CompilerOptions.MethodCanBePotentiallyStatic;
>+				
>+		case IProblem.RedundantDeclarationOfTypeArguments:
>+			return CompilerOptions.RedundantDeclarationOfTypeArguments;
> 	}
> 	return 0;
> }
>@@ -502,7 +505,8 @@
> 			case CompilerOptions.UnhandledWarningToken :
> 			case CompilerOptions.UnusedWarningToken :
> 			case CompilerOptions.UnusedLabel :
>-			case CompilerOptions.RedundantSuperinterface :	
>+			case CompilerOptions.RedundantSuperinterface :
>+			case CompilerOptions.RedundantDeclarationOfTypeArguments :
> 				return CategorizedProblem.CAT_UNNECESSARY_CODE;
> 
> 			case CompilerOptions.UsingDeprecatedAPI :
>@@ -7884,4 +7888,20 @@
> 			type.sourceStart, 
> 			type.sourceEnd);
> }
>+public void redundantDeclarationOfTypeArguments(ASTNode location, TypeBinding[] argumentTypes) {
>+	int severity = computeSeverity(IProblem.RedundantDeclarationOfTypeArguments);
>+	int sourceStart = -1;
>+	if (location instanceof QualifiedTypeReference) {
>+		sourceStart = (int) (((QualifiedTypeReference)location).sourcePositions[((QualifiedTypeReference)location).sourcePositions.length - 1] >> 32);
>+	}
>+ if (severity != ProblemSeverities.Ignore) {
>+		this.handle(
>+			IProblem.RedundantDeclarationOfTypeArguments,
>+			new String[] {typesAsString(argumentTypes, false)},
>+			new String[] {typesAsString(argumentTypes, true)},
>+			severity,
>+			sourceStart == -1? location.sourceStart : sourceStart,
>+			location.sourceEnd);
>+ }
>+}
> }
>\ No newline at end of file
>Index: compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties,v
>retrieving revision 1.262.2.31
>diff -u -r1.262.2.31 messages.properties
>--- compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties	6 Jul 2011 18:46:35 -0000	1.262.2.31
>+++ compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties	9 Jul 2011 17:28:04 -0000
>@@ -646,6 +646,7 @@
> 881 = Cannot switch on a value of type String for source level below 1.7. Only convertible int values or enum constants are permitted
> 882 = Unhandled exception type {0} thrown by automatic close() invocation on {1}
> 883 = '<>' operator is not allowed for source level below 1.7
>+884 = Redundant declaration of type arguments <{0}>
> 
> ### ELABORATIONS
> ## Access restrictions
>Index: model/org/eclipse/jdt/core/JavaCore.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java,v
>retrieving revision 1.659.2.2
>diff -u -r1.659.2.2 JavaCore.java
>--- model/org/eclipse/jdt/core/JavaCore.java	19 Apr 2011 16:41:17 -0000	1.659.2.2
>+++ model/org/eclipse/jdt/core/JavaCore.java	9 Jul 2011 17:28:13 -0000
>@@ -1658,6 +1658,20 @@
> 	 */
> 	public static final String COMPILER_PB_UNUSED_OBJECT_ALLOCATION = PLUGIN_ID + ".compiler.problem.unusedObjectAllocation"; //$NON-NLS-1$
> 	/**
>+	 * Compiler option ID: Reporting redundant declaration of type arguments in class instance creation expressions.
>+	 * When enabled, the compiler will issue an error or a warning if type arguments are used in a class instance creation,
>+	 * when the '<>' operator can be used instead.
>+	 * This option only has an effect if the compiler compliance is 1.7 or greater.
>+	 * <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>"ignore"</code></dd>
>+	 * </dl>
>+	 * @since 3.7
>+	 * @category CompilerOptionID
>+	 */
>+	public static final String COMPILER_PB_REDUNDANT_TYPE_ARGUMENTS = PLUGIN_ID + ".compiler.problem.redundantDeclarationOfTypeArguments"; //$NON-NLS-1$
>+	/**
> 	 * Core option ID: Computing Project Build Order.
> 	 * Indicate whether JavaCore should enforce the project build order to be based on
> 	 * the classpath prerequisite chain. When requesting to compute, this takes over
>#P org.eclipse.jdt.core.tests.compiler
>Index: src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java,v
>retrieving revision 1.224.2.2
>diff -u -r1.224.2.2 BatchCompilerTest.java
>--- src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java	28 Jun 2011 19:34:33 -0000	1.224.2.2
>+++ src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java	9 Jul 2011 17:28:32 -0000
>@@ -1857,7 +1857,8 @@
> 			"		<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.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" + 
>Index: src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java,v
>retrieving revision 1.40.2.19
>diff -u -r1.40.2.19 CompilerInvocationTests.java
>--- src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java	6 Jul 2011 18:45:55 -0000	1.40.2.19
>+++ src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java	9 Jul 2011 17:28:36 -0000
>@@ -775,6 +775,7 @@
> 		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));
>@@ -1441,6 +1442,7 @@
> 		expectedProblemAttributes.put("RecursiveConstructorInvocation", SKIP);
> 		expectedProblemAttributes.put("RedefinedArgument", SKIP);
> 		expectedProblemAttributes.put("RedefinedLocal", SKIP);
>+		expectedProblemAttributes.put("RedundantDeclarationOfTypeArguments", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_TYPE_ARGUMENTS));
> 		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));
>Index: src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest_1_7.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/Attic/GenericsRegressionTest_1_7.java,v
>retrieving revision 1.1.2.22
>diff -u -r1.1.2.22 GenericsRegressionTest_1_7.java
>--- src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest_1_7.java	5 Jul 2011 11:02:30 -0000	1.1.2.22
>+++ src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest_1_7.java	9 Jul 2011 17:28:37 -0000
>@@ -14,6 +14,10 @@
> *******************************************************************************/
> 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 {
> 
>@@ -1811,6 +1815,388 @@
> 		},
> 		"");
> }
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747
>+public void test0052() {
>+	Map customOptions = getCompilerOptions();
>+	customOptions.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);	
>+	customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);	
>+	this.runNegativeTest(
>+		new String[] {
>+			"X.java",
>+			"public class X<E> {\n" +
>+			" X(E e) {}\n" +
>+			" X() {}\n" +
>+			" public static void main(String[] args) {\n" +
>+			" X<Number> x = new X<Number>(1);\n" +
>+			" X<String> x2 = new X<String>(\"SUCCESS\");\n" +
>+			" X<Integer> x3 = new X<Integer>(1);\n" +
>+			" X<AX> x4 = new X<AX>(new AX());\n" +
>+			"		 X<? extends AX> x5 = new X<AX<String>>(new AX<String>());\n" +
>+			"		 X<?> x6 = new X<AX<String>>(new AX<String>());\n" +
>+			"		 X<Class<? extends Object>> x7 = new X<Class<? extends Object>>();\n" +
>+			"	}\n" +
>+			"}\n" +
>+			"class AX<T>{}\n"
>+		},
>+		"----------\n" + 
>+		"1. ERROR in X.java (at line 6)\n" + 
>+		"	X<String> x2 = new X<String>(\"SUCCESS\");\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <String>\n" + 
>+		"----------\n" + 
>+		"2. ERROR in X.java (at line 7)\n" + 
>+		"	X<Integer> x3 = new X<Integer>(1);\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n" + 
>+		"3. ERROR in X.java (at line 8)\n" + 
>+		"	X<AX> x4 = new X<AX>(new AX());\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <AX>\n" + 
>+		"----------\n" + 
>+		"4. ERROR in X.java (at line 9)\n" + 
>+		"	X<? extends AX> x5 = new X<AX<String>>(new AX<String>());\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <AX<String>>\n" + 
>+		"----------\n" + 
>+		"5. ERROR in X.java (at line 10)\n" + 
>+		"	X<?> x6 = new X<AX<String>>(new AX<String>());\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <AX<String>>\n" + 
>+		"----------\n" + 
>+		"6. ERROR in X.java (at line 11)\n" + 
>+		"	X<Class<? extends Object>> x7 = new X<Class<? extends Object>>();\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <Class<? extends Object>>\n" + 
>+		"----------\n",
>+		null,
>+		false,
>+		customOptions);
>+}
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747
>+public void test0052b() {
>+	Map customOptions = getCompilerOptions();
>+	customOptions.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);	
>+	customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);	
>+	this.runNegativeTest(
>+		new String[] {
>+			"X.java",
>+			"public class X<E> {\n" +
>+			"	 E eField;\n" +
>+			"	 E get() { return this.eField; }\n" +
>+			" X(E e) {}\n" +
>+			" X(int e, String e2) {}\n" +
>+			" public static void main(String[] args) {\n" +
>+			" X<Number> x = new X<Number>(1);\n" +
>+			" X<String> x2 = new X<String>(\"SUCCESS\");\n" +
>+			" X<String> x22 = new X<String>(1,\"SUCCESS\");\n" +
>+			" X<Integer> x3 = new X<Integer>(1);\n" +
>+			" String s = foo(new X<String>(\"aaa\"));\n" +
>+			" String s2 = foo(new X<String>(1,\"aaa\"));\n" +
>+			"	}\n" +
>+			" static String foo(X<String> x) {\n" +
>+			"		return x.get();\n" +
>+			" }\n" +
>+			"}\n"
>+		},
>+		"----------\n" + 
>+		"1. ERROR in X.java (at line 8)\n" + 
>+		"	X<String> x2 = new X<String>(\"SUCCESS\");\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <String>\n" + 
>+		"----------\n" + 
>+		"2. ERROR in X.java (at line 9)\n" + 
>+		"	X<String> x22 = new X<String>(1,\"SUCCESS\");\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <String>\n" + 
>+		"----------\n" + 
>+		"3. ERROR in X.java (at line 10)\n" + 
>+		"	X<Integer> x3 = new X<Integer>(1);\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n" + 
>+		"4. ERROR in X.java (at line 11)\n" + 
>+		"	String s = foo(new X<String>(\"aaa\"));\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <String>\n" + 
>+		"----------\n",
>+		null,
>+		false,
>+		customOptions);
>+}
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747
>+public void test0052c() {
>+	Map customOptions = getCompilerOptions();
>+	customOptions.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);	
>+	customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);	
>+	this.runNegativeTest(
>+		new String[] {
>+			"X.java",
>+			"public class X<E> {\n" +
>+			"	X(String abc, String def) {}\n" +
>+			"	void foo() {\n" +
>+			"		X<Integer> x = new X<Integer>(\"\",\"\");\n" +
>+			"		foo3(new X<Integer>(\"\",\"\"));\n" +
>+			"	}\n" +
>+			"	X<Integer> foo2() {\n" +
>+			"		return new X<Integer>(\"\",\"\");\n" +
>+			"	}\n" +
>+			"	void foo3(X<Integer> x) {}\n" +
>+			"}"
>+		},
>+		"----------\n" + 
>+		"1. ERROR in X.java (at line 4)\n" + 
>+		"	X<Integer> x = new X<Integer>(\"\",\"\");\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n" + 
>+		"2. ERROR in X.java (at line 8)\n" + 
>+		"	return new X<Integer>(\"\",\"\");\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n",
>+		null,
>+		false,
>+		customOptions);
>+}
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747
>+public void test0053() {
>+	Map customOptions = getCompilerOptions();
>+	customOptions.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);	
>+	customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);	
>+	this.runNegativeTest(
>+		new String[] {
>+			"Z.java",
>+			"public class Z <T extends ZB> { \n" +
>+			" public static void main(String[] args) {\n" +
>+			" foo(new Z<ZB>());\n" +
>+			" }\n" +
>+			" static void foo(Z<ZB> z) {\n" +
>+			" }\n" +
>+			"}\n" +
>+			"class ZB {\n" +
>+			"}"
>+		},
>+		"----------\n" + 
>+		"1. ERROR in Z.java (at line 3)\n" + 
>+		"	foo(new Z<ZB>());\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <ZB>\n" + 
>+		"----------\n",
>+		null,
>+		false,
>+		customOptions);
>+}
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747
>+public void test0054() {
>+	Map customOptions = getCompilerOptions();
>+	customOptions.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);	
>+	customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);	
>+	this.runNegativeTest(
>+		new String[] {
>+			"Y.java",
>+			"public class Y<V> {\n" +
>+			" public static <W extends ABC> Y<W> make(Class<W> clazz) {\n" +
>+			" return new Y<W>();\n" +
>+			" }\n" +
>+			"}\n" +
>+			"class ABC{}\n"
>+		},
>+		"----------\n" + 
>+		"1. ERROR in Y.java (at line 3)\n" + 
>+		"	return new Y<W>();\n" + 
>+		"	 ^\n" + 
>+		"Redundant declaration of type arguments <W>\n" + 
>+		"----------\n",
>+		null,
>+		false,
>+		customOptions);
>+}
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747
>+public void test0055() {
>+	Map customOptions = getCompilerOptions();
>+	customOptions.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);	
>+	customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);	
>+	this.runNegativeTest(
>+		new String[] {
>+			"X.java",
>+			"public class X<A> {\n" +
>+			" class Inner { }\n" +
>+			" static class Inner2<C> { }\n" +
>+			"\n" +
>+			" void method() {\n" +
>+			" X<String>.Inner<Integer> a= new X<String>().new Inner<Integer>();\n" +
>+			" Inner<Integer> b= new X<A>().new Inner<Integer>();\n" +
>+			" Inner<Integer> c= new Inner<Integer>();\n" +
>+			" X<A>.Inner<Integer> e= new X<A>().new Inner<Integer>();\n" +
>+			" X<A>.Inner<Integer> f= new Inner<Integer>();\n" +
>+			" X.Inner2<Integer> d3 = new X.Inner2<Integer>();\n" +
>+			" }\n" +
>+			"}\n",
>+		},
>+		"----------\n" + 
>+		"1. ERROR in X.java (at line 6)\n" + 
>+		"	X<String>.Inner<Integer> a= new X<String>().new Inner<Integer>();\n" + 
>+		"	 ^^^^^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n" + 
>+		"2. ERROR in X.java (at line 7)\n" + 
>+		"	Inner<Integer> b= new X<A>().new Inner<Integer>();\n" + 
>+		"	 ^^^^^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n" + 
>+		"3. ERROR in X.java (at line 8)\n" + 
>+		"	Inner<Integer> c= new Inner<Integer>();\n" + 
>+		"	 ^^^^^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n" + 
>+		"4. ERROR in X.java (at line 9)\n" + 
>+		"	X<A>.Inner<Integer> e= new X<A>().new Inner<Integer>();\n" + 
>+		"	 ^^^^^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n" + 
>+		"5. ERROR in X.java (at line 10)\n" + 
>+		"	X<A>.Inner<Integer> f= new Inner<Integer>();\n" + 
>+		"	 ^^^^^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n" + 
>+		"6. ERROR in X.java (at line 11)\n" + 
>+		"	X.Inner2<Integer> d3 = new X.Inner2<Integer>();\n" + 
>+		"	 ^^^^^^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n",
>+		null,
>+		false,
>+		customOptions);
>+}
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747
>+// qualified allocation
>+public void test0056() {
>+	Map customOptions = getCompilerOptions();
>+	customOptions.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);	
>+	customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);	
>+	this.runNegativeTest(
>+		new String[] {
>+			"X.java",
>+			"public class X <T> {\n" +
>+			"	void foo1() {\n" +
>+			"		X<String>.Item<Thread> i = new X<Exception>().new Item<Thread>();\n" +
>+			"	}\n" +
>+			"	void foo2() {\n" +
>+			"		X<Exception>.Item<Thread> j = new X<Exception>.Item<Thread>();\n" +
>+			"	}\n" +
>+			"	class Item <E> {}\n" +
>+			"}\n"
>+		},
>+		"----------\n" + 
>+		"1. ERROR in X.java (at line 3)\n" + 
>+		"	X<String>.Item<Thread> i = new X<Exception>().new Item<Thread>();\n" + 
>+		"	 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
>+		"Type mismatch: cannot convert from X<Exception>.Item<Thread> to X<String>.Item<Thread>\n" + 
>+		"----------\n" + 
>+		"2. ERROR in X.java (at line 3)\n" + 
>+		"	X<String>.Item<Thread> i = new X<Exception>().new Item<Thread>();\n" + 
>+		"	 ^^^^\n" + 
>+		"Redundant declaration of type arguments <Thread>\n" + 
>+		"----------\n" + 
>+		"3. ERROR in X.java (at line 6)\n" + 
>+		"	X<Exception>.Item<Thread> j = new X<Exception>.Item<Thread>();\n" + 
>+		"	 ^^^^^^^^^^^^^^^^^\n" + 
>+		"Cannot allocate the member type X<Exception>.Item<Thread> using a parameterized compound name; use its simple name and an enclosing instance of type X<Exception>\n" + 
>+		"----------\n" + 
>+		"4. ERROR in X.java (at line 6)\n" + 
>+		"	X<Exception>.Item<Thread> j = new X<Exception>.Item<Thread>();\n" + 
>+		"	 ^^^^\n" + 
>+		"Redundant declaration of type arguments <Thread>\n" + 
>+		"----------\n",
>+		null,
>+		false,
>+		customOptions);
>+}
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747
>+// qualified allocation
>+public void test0056b() {
>+	Map customOptions = getCompilerOptions();
>+	customOptions.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);	
>+	customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);	
>+	this.runNegativeTest(
>+		new String[] {
>+			"X.java",
>+			"public class X <T> {\n" +
>+			"	static class X1<Z> {\n" +
>+			"		X1(Z z){}\n" +
>+			"	}\n" +
>+			"	X1<Integer> x1 = new X.X1<Integer>(1);\n" +
>+			"	X1<Number> x2 = new X.X1<Number>(1);\n" +
>+			"}\n"
>+		},
>+		"----------\n" + 
>+		"1. ERROR in X.java (at line 5)\n" + 
>+		"	X1<Integer> x1 = new X.X1<Integer>(1);\n" + 
>+		"	 ^^\n" + 
>+		"Redundant declaration of type arguments <Integer>\n" + 
>+		"----------\n",
>+		null,
>+		false,
>+		customOptions);
>+}
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747
>+public void test0057() {
>+	Map customOptions = getCompilerOptions();
>+	customOptions.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);	
>+	customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);	
>+	this.runNegativeTest(
>+		new String[] {
>+			"X.java",
>+			"public class X {\n" +
>+			"	void test() {\n" +
>+			"		Pair<Double, Integer> p = new InvertedPair<Integer, Double>();\n" +
>+			"	}\n" +
>+			"}\n" +
>+			"class Pair<A, B> {\n" +
>+			"}\n" +
>+			"class InvertedPair<A, B> extends Pair<B, A> {\n" +
>+			"}\n"
>+		},
>+		"----------\n" + 
>+		"1. ERROR in X.java (at line 3)\n" + 
>+		"	Pair<Double, Integer> p = new InvertedPair<Integer, Double>();\n" + 
>+		"	 ^^^^^^^^^^^^\n" + 
>+		"Redundant declaration of type arguments <Integer, Double>\n" + 
>+		"----------\n",
>+		null,
>+		false,
>+		customOptions);
>+}
>+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747
>+public void test0058() {
>+	Map customOptions = getCompilerOptions();
>+	customOptions.put(CompilerOptions.OPTION_ReportRedundantDeclarationOfTypeArguments, CompilerOptions.ERROR);	
>+	customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);	
>+	this.runNegativeTest(
>+		new String[] {
>+			"X.java",
>+			"import java.util.ArrayList;\n" +
>+			"\n" +
>+			"public class X {\n" +
>+			" public void test(boolean param) {\n" +
>+			" ArrayList<?> ls = (param) \n" +
>+			" 		? new ArrayList<String>()\n" +
>+			" 		: new ArrayList<Object>();\n" +
>+			" 		\n" +
>+			" }\n" +
>+			"}\n"
>+		},
>+		"----------\n" + 
>+		"1. ERROR in X.java (at line 7)\n" + 
>+		"	: new ArrayList<Object>();\n" + 
>+		"	 ^^^^^^^^^\n" + 
>+		"Redundant declaration of type arguments <Object>\n" + 
>+		"----------\n",
>+		null,
>+		false,
>+		customOptions);
>+}
> public static Class testClass() {
> 	return GenericsRegressionTest_1_7.class;
> }

Actions: View | Diff

Attachments on bug 340747: 199376 | 199377 | 199483 | 199547