Bug 349336: [1.7][quick fix] Suggest to use <> where applicabledazad/bug-351956-Suggest-to-use-diamond-where-applicable

17 files changed, 649 insertions, 74 deletions

diff --git a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest17.java b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest17.java
new file mode 100644
index 0000000000..5464e35909
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest17.java
@@ -0,0 +1,122 @@
+/*******************************************************************************
+ * Copyright (c) 2013 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.ui.tests.quickfix;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+import org.eclipse.core.runtime.CoreException;
+
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragment;
+
+import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
+
+import org.eclipse.jdt.ui.tests.core.Java17ProjectTestSetup;
+
+public class CleanUpTest17 extends CleanUpTestCase {
+
+	private static final Class THIS= CleanUpTest17.class;
+
+	public CleanUpTest17(String name) {
+		super(name);
+	}
+
+	public static Test suite() {
+		return setUpTest(new TestSuite(THIS));
+	}
+	
+	public static Test setUpTest(Test test) {
+		return new Java17ProjectTestSetup(test);
+	}
+
+	protected IJavaProject getProject() {
+		return Java17ProjectTestSetup.getProject();
+	}
+
+	protected IClasspathEntry[] getDefaultClasspath() throws CoreException {
+		return Java17ProjectTestSetup.getDefaultClasspath();
+	}
+
+	public void testRemoveRedundantTypeArguments1() throws Exception {
+		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
+		StringBuffer buf= new StringBuffer();
+		buf.append("package test1;\n");
+		buf.append("import java.util.ArrayList;\n");
+		buf.append("import java.util.HashMap;\n");
+		buf.append("import java.util.List;\n");
+		buf.append("import java.util.Map;\n");
+		buf.append("public class E {\n");
+		buf.append("    void foo() {\n");
+		buf.append("        List<String> a = new ArrayList<String>();\n");
+		buf.append("        Map<Integer, String> m = new HashMap<Integer, String>();\n");
+		buf.append("    }\n");
+		buf.append("}\n");
+		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
+
+		enable(CleanUpConstants.USE_TYPE_ARGUMENTS);
+		enable(CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS);
+
+		buf= new StringBuffer();
+		buf.append("package test1;\n");
+		buf.append("import java.util.ArrayList;\n");
+		buf.append("import java.util.HashMap;\n");
+		buf.append("import java.util.List;\n");
+		buf.append("import java.util.Map;\n");
+		buf.append("public class E {\n");
+		buf.append("    void foo() {\n");
+		buf.append("        List<String> a = new ArrayList<>();\n");
+		buf.append("        Map<Integer, String> m = new HashMap<>();\n");
+		buf.append("    }\n");
+		buf.append("}\n");
+		String expected1= buf.toString();
+
+		assertRefactoringResultAsExpected(new ICompilationUnit[] {cu1}, new String[] {expected1});
+	}
+
+	public void testInsertInferredTypeArguments1() throws Exception {
+		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
+		StringBuffer buf= new StringBuffer();
+		buf.append("package test1;\n");
+		buf.append("import java.util.ArrayList;\n");
+		buf.append("import java.util.HashMap;\n");
+		buf.append("import java.util.List;\n");
+		buf.append("import java.util.Map;\n");
+		buf.append("public class E {\n");
+		buf.append("    void foo() {\n");
+		buf.append("        List<String> a = new ArrayList<>();\n");
+		buf.append("        Map<Integer, String> m = new HashMap<>();\n");
+		buf.append("    }\n");
+		buf.append("}\n");
+		ICompilationUnit cu1= pack1.createCompilationUnit("E1.java", buf.toString(), false, null);
+
+		enable(CleanUpConstants.USE_TYPE_ARGUMENTS);
+		enable(CleanUpConstants.INSERT_INFERRED_TYPE_ARGUMENTS);
+
+		buf= new StringBuffer();
+		buf.append("package test1;\n");
+		buf.append("import java.util.ArrayList;\n");
+		buf.append("import java.util.HashMap;\n");
+		buf.append("import java.util.List;\n");
+		buf.append("import java.util.Map;\n");
+		buf.append("public class E {\n");
+		buf.append("    void foo() {\n");
+		buf.append("        List<String> a = new ArrayList<String>();\n");
+		buf.append("        Map<Integer, String> m = new HashMap<Integer, String>();\n");
+		buf.append("    }\n");
+		buf.append("}\n");
+		String expected1= buf.toString();
+
+		assertRefactoringResultAsExpected(new ICompilationUnit[] { cu1 }, new String[] { expected1 });
+	}
+}
diff --git a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTestCase.java b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTestCase.java
index 7606629142..64dc204097 100644
--- a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTestCase.java
+++ b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTestCase.java
@@ -41,6 +41,7 @@ import org.eclipse.ltk.core.refactoring.PerformChangeOperation;
 import org.eclipse.ltk.core.refactoring.RefactoringCore;
 import org.eclipse.ltk.core.refactoring.RefactoringStatus;
 
+import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IPackageFragmentRoot;
@@ -116,7 +117,7 @@ public class CleanUpTestCase extends QuickFixTest {
 		corePrefs.setValue(JavaCore.CODEASSIST_FIELD_SUFFIXES, "");
 		corePrefs.setValue(JavaCore.CODEASSIST_STATIC_FIELD_SUFFIXES, "");
 
-		fJProject1= ProjectTestSetup.getProject();
+		fJProject1= getProject();
 
 		fSourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
 
@@ -129,13 +130,21 @@ public class CleanUpTestCase extends QuickFixTest {
 	}
 
 	protected void tearDown() throws Exception {
-		JavaProjectHelper.clear(fJProject1, ProjectTestSetup.getDefaultClasspath());
+		JavaProjectHelper.clear(fJProject1, getDefaultClasspath());
 		disableAll();
 		fJProject1= null;
 		fSourceFolder= null;
 		fProfile= null;
 	}
 
+	protected IJavaProject getProject() {
+		return ProjectTestSetup.getProject();
+	}
+
+	protected IClasspathEntry[] getDefaultClasspath() throws CoreException {
+		return ProjectTestSetup.getDefaultClasspath();
+	}
+
 	private void disableAll() throws CoreException {
 		Map settings= fProfile.getSettings();
 		CleanUpOptions options= JavaPlugin.getDefault().getCleanUpRegistry().getDefaultOptions(CleanUpConstants.DEFAULT_CLEAN_UP_OPTIONS);
diff --git a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java
index 4799c581c4..406ed1e350 100644
--- a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java
+++ b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/CleanUpConstants.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * Copyright (c) 2000, 2013 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
@@ -794,6 +794,53 @@ public class CleanUpConstants {
 	public static final String REMOVE_UNNECESSARY_NLS_TAGS= "cleanup.remove_unnecessary_nls_tags"; //$NON-NLS-1$
 
 	/**
+	 * Controls the usage of type arguments. For detailed settings use<br>
+	 * {@link #INSERT_INFERRED_TYPE_ARGUMENTS}<br>
+	 * {@link #REMOVE_REDUNDANT_TYPE_ARGUMENTS}<br>
+	 * <br>
+	 * <br>
+	 * Possible values: {TRUE, FALSE}<br>
+	 * 
+	 * <br>
+	 * 
+	 * @see CleanUpOptions#TRUE
+	 * @see CleanUpOptions#FALSE
+	 * @since 4.4
+	 */
+	public static final String USE_TYPE_ARGUMENTS= "cleanup.use_type_arguments"; //$NON-NLS-1$
+
+	/**
+	 * Insert redundant type arguments. <br>
+	 * <br>
+	 * Only has an effect if {@link #USE_TYPE_ARGUMENTS} is TRUE <br>
+	 * <br>
+	 * Possible values: {TRUE, FALSE}<br>
+	 * 
+	 * <br>
+	 * 
+	 * @see CleanUpOptions#TRUE
+	 * @see CleanUpOptions#FALSE
+	 * @since 4.4
+	 */
+	public static final String INSERT_INFERRED_TYPE_ARGUMENTS= "cleanup.insert_inferred_type_arguments"; //$NON-NLS-1$
+
+	/**
+	 * Removes redundant type arguments. <br>
+	 * <br>
+	 * Only has an effect if {@link #USE_TYPE_ARGUMENTS} is TRUE <br>
+	 * <br>
+	 * Possible values: {TRUE, FALSE}<br>
+	 * 
+	 * <br>
+	 * 
+	 * @see CleanUpOptions#TRUE
+	 * @see CleanUpOptions#FALSE
+	 * @since 4.4
+	 */
+	public static final String REMOVE_REDUNDANT_TYPE_ARGUMENTS= "cleanup.remove_redundant_type_arguments"; //$NON-NLS-1$
+
+
+	/**
 	 * Controls whether missing annotations should be added to the code. For detailed settings use:<br>
 	 * {@link #ADD_MISSING_ANNOTATIONS_DEPRECATED}<br> {@value #ADD_MISSING_ANNOTATIONS_OVERRIDE} <br>
 	 * <br>
@@ -1148,6 +1195,9 @@ public class CleanUpConstants {
 		//Unnecessary Code
 		options.setOption(REMOVE_UNNECESSARY_CASTS, CleanUpOptions.TRUE);
 		options.setOption(REMOVE_UNNECESSARY_NLS_TAGS, CleanUpOptions.TRUE);
+		options.setOption(USE_TYPE_ARGUMENTS, CleanUpOptions.FALSE);
+		options.setOption(INSERT_INFERRED_TYPE_ARGUMENTS, CleanUpOptions.FALSE);
+		options.setOption(REMOVE_REDUNDANT_TYPE_ARGUMENTS, CleanUpOptions.TRUE);
 
 		//Missing Code
 		options.setOption(ADD_MISSING_ANNOTATIONS, CleanUpOptions.TRUE);
@@ -1228,6 +1278,9 @@ public class CleanUpConstants {
 		//Unnecessary Code
 		options.setOption(REMOVE_UNNECESSARY_CASTS, CleanUpOptions.TRUE);
 		options.setOption(REMOVE_UNNECESSARY_NLS_TAGS, CleanUpOptions.FALSE);
+		options.setOption(USE_TYPE_ARGUMENTS, CleanUpOptions.FALSE);
+		options.setOption(INSERT_INFERRED_TYPE_ARGUMENTS, CleanUpOptions.FALSE);
+		options.setOption(REMOVE_REDUNDANT_TYPE_ARGUMENTS, CleanUpOptions.TRUE);
 
 		//Missing Code
 		options.setOption(ADD_MISSING_ANNOTATIONS, CleanUpOptions.TRUE);
diff --git a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.java b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.java
index ae8ca99c79..5585710bc2 100644
--- a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.java
+++ b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.java
@@ -133,6 +133,10 @@ public final class FixMessages extends NLS {
 	public static String ExtractToNullCheckedLocalProposal_extractCheckedLocal_editName;
 	public static String ExtractToNullCheckedLocalProposal_extractToCheckedLocal_proposalName;
 	public static String ExtractToNullCheckedLocalProposal_todoHandleNullDescription;
+	public static String TypeParametersFix_insert_inferred_type_arguments_description;
+	public static String TypeParametersFix_insert_inferred_type_arguments_name;
+	public static String TypeParametersFix_remove_redundant_type_arguments_description;
+	public static String TypeParametersFix_remove_redundant_type_arguments_name;
 
 	static {
 		// initialize resource bundle
diff --git a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.properties b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.properties
index 4344358d1e..ec6e1d6153 100644
--- a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.properties
+++ b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/FixMessages.properties
@@ -120,3 +120,7 @@ NullAnnotationsRewriteOperations_remove_redundant_nullness_annotation=Remove red
 ExtractToNullCheckedLocalProposal_extractCheckedLocal_editName=Extract checked local
 ExtractToNullCheckedLocalProposal_extractToCheckedLocal_proposalName=Extract to checked local variable
 ExtractToNullCheckedLocalProposal_todoHandleNullDescription=handle null value
+TypeParametersFix_insert_inferred_type_arguments_description=Insert inferred type arguments
+TypeParametersFix_insert_inferred_type_arguments_name=Insert inferred type arguments
+TypeParametersFix_remove_redundant_type_arguments_description=Remove redundant type arguments
+TypeParametersFix_remove_redundant_type_arguments_name=Remove redundant type arguments
diff --git a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/TypeParametersFix.java b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/TypeParametersFix.java
new file mode 100644
index 0000000000..6b673f650a
--- /dev/null
+++ b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/fix/TypeParametersFix.java
@@ -0,0 +1,228 @@
+/*******************************************************************************
+ * Copyright (c) 2013 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.corext.fix;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.core.runtime.CoreException;
+
+import org.eclipse.text.edits.TextEditGroup;
+
+import org.eclipse.jdt.core.compiler.IProblem;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.ITypeBinding;
+import org.eclipse.jdt.core.dom.ParameterizedType;
+import org.eclipse.jdt.core.dom.Statement;
+import org.eclipse.jdt.core.dom.Type;
+import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
+import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;
+import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
+
+import org.eclipse.jdt.internal.corext.codemanipulation.ContextSensitiveImportRewriteContext;
+import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;
+import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
+import org.eclipse.jdt.internal.corext.refactoring.util.NoCommentSourceRangeComputer;
+
+import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
+import org.eclipse.jdt.ui.text.java.IProblemLocation;
+
+import org.eclipse.jdt.internal.ui.text.correction.ProblemLocation;
+
+public class TypeParametersFix extends CompilationUnitRewriteOperationsFix {
+
+	private static final class InsertTypeArgumentsVisitor extends ASTVisitor {
+
+		private final ArrayList<ASTNode> fNodes;
+
+		private InsertTypeArgumentsVisitor(ArrayList<ASTNode> nodes) {
+			fNodes= nodes;
+		}
+
+		@Override
+		public boolean visit(ParameterizedType createdType) {
+			if (createdType == null || createdType.typeArguments().size() != 0) {
+				return true;
+			}
+
+			ITypeBinding binding= createdType.resolveBinding();
+			if (binding == null) {
+				return true;
+			}
+
+			ITypeBinding[] typeArguments= binding.getTypeArguments();
+			if (typeArguments.length == 0) {
+				return true;
+			}
+
+			fNodes.add(createdType);
+			return true;
+		}
+	}
+
+	private static class InsertTypeArgumentsOperation extends CompilationUnitRewriteOperation {
+
+		private final ParameterizedType[] fCreatedTypes;
+
+		public InsertTypeArgumentsOperation(ParameterizedType[] parameterizedTypes) {
+			fCreatedTypes= parameterizedTypes;
+		}
+
+		/**
+		 * {@inheritDoc}
+		 */
+		@Override
+		public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException {
+			TextEditGroup group= createTextEditGroup(FixMessages.TypeParametersFix_insert_inferred_type_arguments_description, cuRewrite);
+
+			ASTRewrite rewrite= cuRewrite.getASTRewrite();
+			AST ast= cuRewrite.getRoot().getAST();
+
+			ImportRewrite importRewrite= StubUtility.createImportRewrite(cuRewrite.getRoot(), true);
+
+			for (int i= 0; i < fCreatedTypes.length; i++) {
+				ParameterizedType createdType= fCreatedTypes[i];
+
+				ITypeBinding[] typeArguments= createdType.resolveBinding().getTypeArguments();
+				ContextSensitiveImportRewriteContext importContext= new ContextSensitiveImportRewriteContext(cuRewrite.getRoot(), createdType.getStartPosition(), importRewrite);
+
+				ListRewrite argumentsRewrite= rewrite.getListRewrite(createdType, ParameterizedType.TYPE_ARGUMENTS_PROPERTY);
+				for (int j= 0; j < typeArguments.length; j++) {
+					ITypeBinding typeArgument= typeArguments[j];
+					Type argumentNode= importRewrite.addImport(typeArgument, ast, importContext);
+					argumentsRewrite.insertLast(argumentNode, group);
+				}
+			}
+		}
+	}
+
+	private static class RemoveTypeArgumentsOperation extends CompilationUnitRewriteOperation {
+
+		private final ParameterizedType fParameterizedType;
+
+		public RemoveTypeArgumentsOperation(ParameterizedType parameterizedType) {
+			fParameterizedType= parameterizedType;
+		}
+
+		/**
+		 * {@inheritDoc}
+		 */
+		@Override
+		public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException {
+			TextEditGroup group= createTextEditGroup(FixMessages.TypeParametersFix_remove_redundant_type_arguments_description, cuRewrite);
+
+			ASTRewrite rewrite= cuRewrite.getASTRewrite();
+			rewrite.setTargetSourceRangeComputer(new NoCommentSourceRangeComputer());
+
+			ListRewrite listRewrite= rewrite.getListRewrite(fParameterizedType, ParameterizedType.TYPE_ARGUMENTS_PROPERTY);
+
+			List<Type> typeArguments= fParameterizedType.typeArguments();
+			for (Iterator<Type> iterator= typeArguments.iterator(); iterator.hasNext();) {
+				listRewrite.remove(iterator.next(), group);
+			}
+		}
+	}
+
+	public static TypeParametersFix createInsertInferredTypeArgumentsFix(CompilationUnit compilationUnit, ParameterizedType node) {
+
+		final ArrayList<ASTNode> changedNodes= new ArrayList<ASTNode>();
+		if (node == null)
+			return null;
+		node.accept(new InsertTypeArgumentsVisitor(changedNodes));
+
+		if (changedNodes.isEmpty())
+			return null;
+
+		CompilationUnitRewriteOperation op= new InsertTypeArgumentsOperation(new ParameterizedType[] { node });
+		return new TypeParametersFix(FixMessages.TypeParametersFix_insert_inferred_type_arguments_name, compilationUnit, new CompilationUnitRewriteOperation[] { op });
+	}
+
+	public static TypeParametersFix createRemoveRedundantTypeArgumentsFix(CompilationUnit compilationUnit, IProblemLocation problem) {
+		int id= problem.getProblemId();
+		if (id == IProblem.RedundantSpecificationOfTypeArguments) {
+			ParameterizedType parameterizedType= getParameterizedType(compilationUnit, problem);
+			if (parameterizedType == null)
+				return null;
+			RemoveTypeArgumentsOperation operation= new RemoveTypeArgumentsOperation(parameterizedType);
+			return new TypeParametersFix(FixMessages.TypeParametersFix_remove_redundant_type_arguments_name, compilationUnit, new CompilationUnitRewriteOperation[] { operation });
+		}
+		return null;
+	}
+
+	public static ICleanUpFix createCleanUp(CompilationUnit compilationUnit, boolean insertInferredTypeArguments, boolean removeRedundantTypeArguments) {
+
+		IProblem[] problems= compilationUnit.getProblems();
+		IProblemLocation[] locations= new IProblemLocation[problems.length];
+		for (int i= 0; i < problems.length; i++) {
+			locations[i]= new ProblemLocation(problems[i]);
+		}
+
+		return createCleanUp(compilationUnit, locations,
+				insertInferredTypeArguments,
+				removeRedundantTypeArguments);
+	}
+
+	public static ICleanUpFix createCleanUp(CompilationUnit compilationUnit, IProblemLocation[] problems, boolean insertInferredTypeArguments, boolean removeRedundantTypeArguments) {
+
+		if (insertInferredTypeArguments) {
+			final ArrayList<ASTNode> changedNodes= new ArrayList<ASTNode>();
+			compilationUnit.accept(new InsertTypeArgumentsVisitor(changedNodes));
+
+			if (changedNodes.isEmpty())
+				return null;
+
+			CompilationUnitRewriteOperation op= new InsertTypeArgumentsOperation(changedNodes.toArray(new ParameterizedType[changedNodes.size()]));
+			return new TypeParametersFix(FixMessages.TypeParametersFix_insert_inferred_type_arguments_name, compilationUnit, new CompilationUnitRewriteOperation[] { op });
+
+		} else if (removeRedundantTypeArguments) {
+			List<CompilationUnitRewriteOperation> result= new ArrayList<CompilationUnitRewriteOperation>();
+			for (int i= 0; i < problems.length; i++) {
+				IProblemLocation problem= problems[i];
+				int id= problem.getProblemId();
+
+				if (id == IProblem.RedundantSpecificationOfTypeArguments) {
+					ParameterizedType parameterizedType= getParameterizedType(compilationUnit, problem);
+					if (parameterizedType == null)
+						return null;
+					result.add(new RemoveTypeArgumentsOperation(parameterizedType));
+				}
+			}
+			if (result.size() == 0)
+				return null;
+
+			return new TypeParametersFix(FixMessages.TypeParametersFix_remove_redundant_type_arguments_name, compilationUnit, result.toArray(new CompilationUnitRewriteOperation[result.size()]));
+		}
+		return null;
+	}
+
+	private static ParameterizedType getParameterizedType(CompilationUnit compilationUnit, IProblemLocation problem) {
+		ASTNode selectedNode= problem.getCoveringNode(compilationUnit);
+		if (selectedNode == null)
+			return null;
+
+		while (!(selectedNode instanceof ParameterizedType) && !(selectedNode instanceof Statement)) {
+			selectedNode= selectedNode.getParent();
+		}
+		if (!(selectedNode instanceof ParameterizedType)) {
+			return null;
+		}
+		ParameterizedType parameterizedType= (ParameterizedType) selectedNode;
+		return parameterizedType;
+	}
+
+	protected TypeParametersFix(String name, CompilationUnit compilationUnit, CompilationUnitRewriteOperation[] fixRewriteOperations) {
+		super(name, compilationUnit, fixRewriteOperations);
+	}
+}
diff --git a/org.eclipse.jdt.ui/plugin.xml b/org.eclipse.jdt.ui/plugin.xml
index 9571ca1a31..9b9aeb8292 100644
--- a/org.eclipse.jdt.ui/plugin.xml
+++ b/org.eclipse.jdt.ui/plugin.xml
@@ -6656,9 +6656,14 @@
             runAfter="org.eclipse.jdt.ui.cleanup.potential_programming_problems">
       </cleanUp>
       <cleanUp
+            class="org.eclipse.jdt.internal.ui.fix.TypeParametersCleanUp"
+            id="org.eclipse.jdt.ui.cleanup.type_parameters"
+            runAfter="org.eclipse.jdt.ui.cleanup.unnecessary_code">
+      </cleanUp>
+      <cleanUp
             class="org.eclipse.jdt.internal.ui.fix.StringCleanUp"
             id="org.eclipse.jdt.ui.cleanup.strings"
-            runAfter="org.eclipse.jdt.ui.cleanup.unnecessary_code">
+            runAfter="org.eclipse.jdt.ui.cleanup.type_parameters">
       </cleanUp>
       <cleanUp
             class="org.eclipse.jdt.internal.ui.fix.UnimplementedCodeCleanUp"
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.java
index 9f05b024c8..6a546219ba 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.java
@@ -84,6 +84,7 @@ public class MultiFixMessages extends NLS {
 
 	public static String UnimplementedCodeCleanUp_AddUnimplementedMethods_description;
 	public static String UnimplementedCodeCleanUp_MakeAbstract_description;
+	public static String UnnecessaryCodeCleanUp_RemoveRedundantTypeArguments_description;
 
 	public static String ExpressionsCleanUp_addParanoiac_description;
 	public static String ExpressionsCleanUp_removeUnnecessary_description;
@@ -98,6 +99,8 @@ public class MultiFixMessages extends NLS {
 	public static String NullAnnotationsCleanUp_add_nullable_annotation;
 	public static String NullAnnotationsCleanUp_add_nonnull_annotation;
 	public static String NullAnnotationsCleanUp_remove_redundant_nullness_annotation;
+	public static String TypeParametersCleanUp_InsertInferredTypeArguments_description;
+	public static String TypeParametersCleanUp_RemoveRedundantTypeArguments_description;
 
 	static {
 		// initialize resource bundle
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.properties b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.properties
index 21e948553f..ad38f5767c 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.properties
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/MultiFixMessages.properties
@@ -26,6 +26,7 @@ ControlStatementsCleanUp_RemoveUnnecessaryBlocksWithReturnOrThrow_description=Co
 
 UnimplementedCodeCleanUp_AddUnimplementedMethods_description=Add unimplemented methods
 UnimplementedCodeCleanUp_MakeAbstract_description=Make classes abstract
+UnnecessaryCodeCleanUp_RemoveRedundantTypeArguments_description=Remove type arguments
 
 CodeStyleMultiFix_ChangeIndirectAccessToStaticToDirect=Change indirect accesses to static members to direct accesses (accesses through subtypes)
 CodeStyleCleanUp_addDefaultSerialVersionId_description=Add missing serial version ID (default 1L)
@@ -85,3 +86,5 @@ SortMembersCleanUp_RemoveMarkersWarning0=The file ''{0}'' in project ''{1}'' con
 NullAnnotationsCleanUp_add_nullable_annotation=Add missing @Nullable annotation
 NullAnnotationsCleanUp_add_nonnull_annotation=Add missing @NonNull annotation
 NullAnnotationsCleanUp_remove_redundant_nullness_annotation=Remove redundant nullness annotation
+TypeParametersCleanUp_InsertInferredTypeArguments_description=Insert inferred type arguments
+TypeParametersCleanUp_RemoveRedundantTypeArguments_description=Remove redundant type arguments
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/TypeParametersCleanUp.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/TypeParametersCleanUp.java
new file mode 100644
index 0000000000..454d31cd58
--- /dev/null
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/TypeParametersCleanUp.java
@@ -0,0 +1,162 @@
+/*******************************************************************************
+ * Copyright (c) 2013 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.ui.fix;
+
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.CoreException;
+
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.compiler.IProblem;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+
+import org.eclipse.jdt.internal.corext.fix.CleanUpConstants;
+import org.eclipse.jdt.internal.corext.fix.TypeParametersFix;
+
+import org.eclipse.jdt.ui.cleanup.CleanUpRequirements;
+import org.eclipse.jdt.ui.cleanup.ICleanUpFix;
+import org.eclipse.jdt.ui.text.java.IProblemLocation;
+
+public class TypeParametersCleanUp extends AbstractMultiFix {
+
+	private Map<String, String> fOptions;
+
+	public TypeParametersCleanUp(Map<String, String> options) {
+		super(options);
+		fOptions= options;
+	}
+
+	public TypeParametersCleanUp() {
+		super();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public CleanUpRequirements getRequirements() {
+		boolean requireAST= requireAST();
+		Map<String, String> requiredOptions= requireAST ? getRequiredOptions() : null;
+		return new CleanUpRequirements(requireAST, false, false, requiredOptions);
+	}
+
+	private boolean requireAST() {
+		boolean useTypeArguments= isEnabled(CleanUpConstants.USE_TYPE_ARGUMENTS);
+		if (!useTypeArguments)
+			return false;
+
+		return isEnabled(CleanUpConstants.INSERT_INFERRED_TYPE_ARGUMENTS) ||
+				isEnabled(CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS);
+	}
+
+	private Map<String, String> getRequiredOptions() {
+		Map<String, String> result= new Hashtable<String, String>();
+
+		if (isEnabled(CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS))
+			result.put(JavaCore.COMPILER_PB_REDUNDANT_TYPE_ARGUMENTS, JavaCore.WARNING);
+
+		return result;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	protected ICleanUpFix createFix(CompilationUnit compilationUnit) throws CoreException {
+		if (compilationUnit == null)
+			return null;
+
+		boolean useTypeParameters= isEnabled(CleanUpConstants.USE_TYPE_ARGUMENTS);
+		if (!useTypeParameters)
+			return null;
+
+		return TypeParametersFix.createCleanUp(compilationUnit,
+				isEnabled(CleanUpConstants.INSERT_INFERRED_TYPE_ARGUMENTS),
+				isEnabled(CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS));
+	}
+
+	@Override
+	protected ICleanUpFix createFix(CompilationUnit compilationUnit, IProblemLocation[] problems) throws CoreException {
+		if (compilationUnit == null)
+			return null;
+
+		boolean useTypeParameters= isEnabled(CleanUpConstants.USE_TYPE_ARGUMENTS);
+		if (!useTypeParameters)
+			return null;
+
+		return TypeParametersFix.createCleanUp(compilationUnit, problems,
+				isEnabled(CleanUpConstants.INSERT_INFERRED_TYPE_ARGUMENTS),
+				isEnabled(CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS));
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public String[] getStepDescriptions() {
+		List<String> result= new ArrayList<String>();
+		if (isEnabled(CleanUpConstants.USE_TYPE_ARGUMENTS) && isEnabled(CleanUpConstants.INSERT_INFERRED_TYPE_ARGUMENTS))
+			result.add(MultiFixMessages.TypeParametersCleanUp_InsertInferredTypeArguments_description);
+
+		if (isEnabled(CleanUpConstants.USE_TYPE_ARGUMENTS) && isEnabled(CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS))
+			result.add(MultiFixMessages.TypeParametersCleanUp_RemoveRedundantTypeArguments_description);
+
+		return result.toArray(new String[result.size()]);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public String getPreview() {
+		StringBuffer buf= new StringBuffer();
+
+		if (isEnabled(CleanUpConstants.USE_TYPE_ARGUMENTS) && isEnabled(CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS)) {
+			buf.append("List<String> a= new ArrayList<>();\n"); //$NON-NLS-1$
+		} else {
+			buf.append("List<String> a= new ArrayList<String>();\n"); //$NON-NLS-1$
+		}
+
+		return buf.toString();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public boolean canFix(ICompilationUnit compilationUnit, IProblemLocation problem) {
+		int problemId= problem.getProblemId();
+
+		if (problemId == IProblem.RedundantSpecificationOfTypeArguments)
+			return isEnabled(CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS);
+
+		return false;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	public int computeNumberOfFixes(CompilationUnit compilationUnit) {
+		if (fOptions == null)
+			return 0;
+		int result= 0;
+		IProblem[] problems= compilationUnit.getProblems();
+		if (isEnabled(CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS))
+			result+= getNumberOfProblems(problems, IProblem.RedundantSpecificationOfTypeArguments);
+		return result;
+
+	}
+
+}
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.java
index 47a5578aad..cdc610d4b2 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.java
@@ -94,6 +94,10 @@ public class CleanUpMessages extends NLS {
 	public static String MissingCodeTabPage_RadioName_AddDefaultSUID;
 	public static String MissingCodeTabPage_RadioName_AddGeneratedSUID;
 
+	public static String UnnecessaryCodeTabPage_RadioName_InsertRedundantTypeArguments;
+
+	public static String UnnecessaryCodeTabPage_RadioName_RemoveRedundantTypeArguments;
+
 	public static String UnnecessaryCodeTabPage_CheckboxName_UnnecessaryCasts;
 	public static String UnnecessaryCodeTabPage_CheckboxName_UnnecessaryNLSTags;
 	public static String UnnecessaryCodeTabPage_CheckboxName_UnusedConstructors;
@@ -103,6 +107,10 @@ public class CleanUpMessages extends NLS {
 	public static String UnnecessaryCodeTabPage_CheckboxName_UnusedMembers;
 	public static String UnnecessaryCodeTabPage_CheckboxName_UnusedMethods;
 	public static String UnnecessaryCodeTabPage_CheckboxName_UnusedTypes;
+
+	public static String UnnecessaryCodeTabPage_CheckboxName_UseTypeArguments;
+	public static String UnnecessaryCodeTabPage_GroupName_GenericTypes;
+
 	public static String UnnecessaryCodeTabPage_GroupName_UnnecessaryCode;
 	public static String UnnecessaryCodeTabPage_GroupName_UnusedCode;
 
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties
index 4221d23c4a..ef6a99a94c 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties
@@ -76,7 +76,10 @@ MissingCodeTabPage_Label_CodeTemplatePreferencePage=The settings for the method
 MissingCodeTabPage_RadioName_AddGeneratedSUID=&Generated
 MissingCodeTabPage_RadioName_AddDefaultSUID=Default (&1L)
 
+UnnecessaryCodeTabPage_GroupName_GenericTypes=Generic types
 UnnecessaryCodeTabPage_GroupName_UnusedCode=Unused code
+UnnecessaryCodeTabPage_RadioName_InsertRedundantTypeArguments=Always
+UnnecessaryCodeTabPage_RadioName_RemoveRedundantTypeArguments= Only if necessary
 UnnecessaryCodeTabPage_CheckboxName_UnusedImports=Remove unu&sed imports
 UnnecessaryCodeTabPage_CheckboxName_UnusedMembers=Remove unuse&d private members
 UnnecessaryCodeTabPage_CheckboxName_UnusedTypes=&Types
@@ -86,4 +89,5 @@ UnnecessaryCodeTabPage_CheckboxName_UnusedMethods=Met&hods
 UnnecessaryCodeTabPage_CheckboxName_UnusedLocalVariables=Remove unused &local variables
 UnnecessaryCodeTabPage_GroupName_UnnecessaryCode=Unnecessary code
 UnnecessaryCodeTabPage_CheckboxName_UnnecessaryCasts=Remove unnecessar&y casts
-UnnecessaryCodeTabPage_CheckboxName_UnnecessaryNLSTags=Remove unnecessary '$NON-NLS$' ta&gs
\ No newline at end of file
+UnnecessaryCodeTabPage_CheckboxName_UnnecessaryNLSTags=Remove unnecessary '$NON-NLS$' ta&gs
+UnnecessaryCodeTabPage_CheckboxName_UseTypeArguments=Use Type Arguments (Java 7 or higher)
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/UnnecessaryCodeTabPage.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/UnnecessaryCodeTabPage.java
index 5795b8c8fa..94b9008cd6 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/UnnecessaryCodeTabPage.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/UnnecessaryCodeTabPage.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * Copyright (c) 2000, 2013 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
@@ -65,6 +65,18 @@ public final class UnnecessaryCodeTabPage extends AbstractCleanUpTabPage {
 
     	CheckboxPreference nls= createCheckboxPref(unnecessaryGroup, numColumns, CleanUpMessages.UnnecessaryCodeTabPage_CheckboxName_UnnecessaryNLSTags, CleanUpConstants.REMOVE_UNNECESSARY_NLS_TAGS, CleanUpModifyDialog.FALSE_TRUE);
     	registerPreference(nls);
+
+		Group redundantTypeArgumentsGroup= createGroup(numColumns, composite, CleanUpMessages.UnnecessaryCodeTabPage_GroupName_GenericTypes);
+
+		CheckboxPreference useTypeArguments= createCheckboxPref(redundantTypeArgumentsGroup, numColumns, CleanUpMessages.UnnecessaryCodeTabPage_CheckboxName_UseTypeArguments,
+				CleanUpConstants.USE_TYPE_ARGUMENTS, CleanUpModifyDialog.FALSE_TRUE);
+		intent(redundantTypeArgumentsGroup);
+		final RadioPreference useParenthesesNeverPref= createRadioPref(redundantTypeArgumentsGroup, 1, CleanUpMessages.UnnecessaryCodeTabPage_RadioName_InsertRedundantTypeArguments,
+				CleanUpConstants.INSERT_INFERRED_TYPE_ARGUMENTS, CleanUpModifyDialog.FALSE_TRUE);
+		final RadioPreference useParenthesesAlwaysPref= createRadioPref(redundantTypeArgumentsGroup, 1, CleanUpMessages.UnnecessaryCodeTabPage_RadioName_RemoveRedundantTypeArguments,
+				CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS, CleanUpModifyDialog.FALSE_TRUE);
+		registerSlavePreference(useTypeArguments, new RadioPreference[] { useParenthesesAlwaysPref, useParenthesesNeverPref });
+
     }
 
 }
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.java
index 5df46e8069..4d1baa856b 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.java
@@ -50,7 +50,6 @@ public final class CorrectionMessages extends NLS {
 	public static String QuickAssistProcessor_convert_to_string_buffer_description;
 	public static String QuickAssistProcessor_exceptiontothrows_description;
 	public static String QuickAssistProcessor_extract_to_constant_description;
-	public static String QuickAssistProcessor_infer_diamond_description;
 	public static String QuickAssistProcessor_inline_local_description;
 	public static String QuickAssistProcessor_name_extension_from_class;
 	public static String QuickAssistProcessor_name_extension_from_interface;
@@ -370,7 +369,6 @@ public final class CorrectionMessages extends NLS {
 	public static String UnresolvedElementsSubProcessor_copy_annotation_jar_info;
 	public static String LocalCorrectionsSubProcessor_remove_allocated_description;
 	public static String LocalCorrectionsSubProcessor_remove_redundant_superinterface;
-	public static String LocalCorrectionsSubProcessor_remove_type_arguments;
 	public static String LocalCorrectionsSubProcessor_return_allocated_description;
 	public static String LocalCorrectionsSubProcessor_qualify_left_hand_side_description;
 	public static String LocalCorrectionsSubProcessor_qualify_right_hand_side_description;
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.properties b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.properties
index b7c7ac6e3b..1d6947dc8b 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.properties
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/CorrectionMessages.properties
@@ -95,7 +95,6 @@ LocalCorrectionsSubProcessor_uninitializedvariable_description=Initialize variab
 LocalCorrectionsSubProcessor_removesemicolon_description=Remove semicolon
 LocalCorrectionsSubProcessor_remove_allocated_description=Remove
 LocalCorrectionsSubProcessor_remove_redundant_superinterface=Remove super interface
-LocalCorrectionsSubProcessor_remove_type_arguments=Remove type arguments
 LocalCorrectionsSubProcessor_renaming_duplicate_method=Rename method ''{0}''
 LocalCorrectionsSubProcessor_removeunreachablecode_description=Remove
 LocalCorrectionsSubProcessor_removeunreachablecode_including_condition_description=Remove (including condition)
@@ -335,7 +334,6 @@ QuickAssistProcessor_replaceelsewithblock_description=Change 'else' statement to
 QuickAssistProcessor_replacethenelsewithblock_description=Change 'if-else' statements to blocks
 QuickAssistProcessor_replacebodywithblock_description=Change body statement to block
 
-QuickAssistProcessor_infer_diamond_description=Insert inferred type arguments
 QuickAssistProcessor_invertequals_description=Invert equals
 QuickAssistProcessor_inline_local_description=Inline local variable
 QuickAssistProcessor_convert_anonym_to_nested=Convert anonymous to nested class
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsSubProcessor.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsSubProcessor.java
index 2cf0228d77..bc71619b8b 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsSubProcessor.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/LocalCorrectionsSubProcessor.java
@@ -76,7 +76,6 @@ import org.eclipse.jdt.core.dom.MethodDeclaration;
 import org.eclipse.jdt.core.dom.MethodInvocation;
 import org.eclipse.jdt.core.dom.Modifier;
 import org.eclipse.jdt.core.dom.Name;
-import org.eclipse.jdt.core.dom.ParameterizedType;
 import org.eclipse.jdt.core.dom.ParenthesizedExpression;
 import org.eclipse.jdt.core.dom.PrefixExpression;
 import org.eclipse.jdt.core.dom.PrimitiveType;
@@ -119,6 +118,7 @@ import org.eclipse.jdt.internal.corext.fix.CodeStyleFix;
 import org.eclipse.jdt.internal.corext.fix.IProposableFix;
 import org.eclipse.jdt.internal.corext.fix.Java50Fix;
 import org.eclipse.jdt.internal.corext.fix.StringFix;
+import org.eclipse.jdt.internal.corext.fix.TypeParametersFix;
 import org.eclipse.jdt.internal.corext.fix.UnimplementedCodeFix;
 import org.eclipse.jdt.internal.corext.fix.UnusedCodeFix;
 import org.eclipse.jdt.internal.corext.refactoring.code.Invocations;
@@ -146,6 +146,7 @@ import org.eclipse.jdt.internal.ui.JavaPluginImages;
 import org.eclipse.jdt.internal.ui.fix.CodeStyleCleanUp;
 import org.eclipse.jdt.internal.ui.fix.Java50CleanUp;
 import org.eclipse.jdt.internal.ui.fix.StringCleanUp;
+import org.eclipse.jdt.internal.ui.fix.TypeParametersCleanUp;
 import org.eclipse.jdt.internal.ui.fix.UnimplementedCodeCleanUp;
 import org.eclipse.jdt.internal.ui.fix.UnnecessaryCodeCleanUp;
 import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
@@ -1474,32 +1475,15 @@ public class LocalCorrectionsSubProcessor {
 	}
 
 	public static void addRemoveRedundantTypeArgumentsProposals(IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
-		CompilationUnit astRoot= context.getASTRoot();
-		ASTNode selectedNode= problem.getCoveringNode(astRoot);
-		if (selectedNode == null)
-			return;
-
-		while (!(selectedNode instanceof ParameterizedType) && !(selectedNode instanceof Statement)) {
-			selectedNode= selectedNode.getParent();
-		}
-		if (!(selectedNode instanceof ParameterizedType)) {
-			return;
-		}
-		ParameterizedType parameterizedType= (ParameterizedType) selectedNode;
-
-		AST ast= astRoot.getAST();
-		ASTRewrite rewrite= ASTRewrite.create(ast);
-		ListRewrite listRewrite= rewrite.getListRewrite(parameterizedType, ParameterizedType.TYPE_ARGUMENTS_PROPERTY);
-
-		List<Type> typeArguments= parameterizedType.typeArguments();
-		for (Iterator<Type> iterator= typeArguments.iterator(); iterator.hasNext();) {
-			listRewrite.remove(iterator.next(), null);
+		IProposableFix fix= TypeParametersFix.createRemoveRedundantTypeArgumentsFix(context.getASTRoot(), problem);
+		if (fix != null) {
+			Image image= JavaPlugin.getDefault().getWorkbench().getSharedImages().getImage(ISharedImages.IMG_TOOL_DELETE);
+			Map<String, String> options= new HashMap<String, String>();
+			options.put(CleanUpConstants.USE_TYPE_ARGUMENTS, CleanUpOptions.TRUE);
+			options.put(CleanUpConstants.REMOVE_REDUNDANT_TYPE_ARGUMENTS, CleanUpOptions.TRUE);
+			FixCorrectionProposal proposal= new FixCorrectionProposal(fix, new TypeParametersCleanUp(options), IProposalRelevance.REMOVE_REDUNDANT_TYPE_ARGUMENTS, image, context);
+			proposals.add(proposal);
 		}
-
-		Image image= JavaPlugin.getDefault().getWorkbench().getSharedImages().getImage(ISharedImages.IMG_TOOL_DELETE);
-		String label= CorrectionMessages.LocalCorrectionsSubProcessor_remove_type_arguments;
-		ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, IProposalRelevance.REMOVE_REDUNDANT_TYPE_ARGUMENTS, image);
-		proposals.add(proposal);
 	}
 
 	public static void addFallThroughProposals(IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java
index 346512a382..56d3ed343c 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickAssistProcessor.java
@@ -121,6 +121,7 @@ import org.eclipse.jdt.internal.corext.fix.ControlStatementsFix;
 import org.eclipse.jdt.internal.corext.fix.ConvertLoopFix;
 import org.eclipse.jdt.internal.corext.fix.IProposableFix;
 import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel;
+import org.eclipse.jdt.internal.corext.fix.TypeParametersFix;
 import org.eclipse.jdt.internal.corext.fix.VariableDeclarationFix;
 import org.eclipse.jdt.internal.corext.refactoring.RefactoringAvailabilityTester;
 import org.eclipse.jdt.internal.corext.refactoring.code.ConvertAnonymousToNestedRefactoring;
@@ -147,6 +148,7 @@ import org.eclipse.jdt.internal.ui.JavaPlugin;
 import org.eclipse.jdt.internal.ui.JavaPluginImages;
 import org.eclipse.jdt.internal.ui.fix.ControlStatementsCleanUp;
 import org.eclipse.jdt.internal.ui.fix.ConvertLoopCleanUp;
+import org.eclipse.jdt.internal.ui.fix.TypeParametersCleanUp;
 import org.eclipse.jdt.internal.ui.fix.VariableDeclarationCleanUp;
 import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
 import org.eclipse.jdt.internal.ui.text.correction.proposals.AssignToVariableAssistProposal;
@@ -497,6 +499,10 @@ public class QuickAssistProcessor implements IQuickAssistProcessor {
 	}
 
 	public static boolean getInferDiamondArgumentsProposal(IInvocationContext context, ASTNode node, IProblemLocation[] locations, Collection<ICommandAccess> resultingCollections) {
+		// don't add if already added as quick fix
+		if (containsMatchingProblem(locations, IProblem.DiamondNotBelow17))
+			return false;
+
 		ParameterizedType createdType= null;
 		
 		if (node instanceof Name) {
@@ -523,47 +529,19 @@ public class QuickAssistProcessor implements IQuickAssistProcessor {
 			}
 		}
 		
-		if (createdType == null || createdType.typeArguments().size() != 0) {
-			return false;
-		}
-		
-		ITypeBinding binding= createdType.resolveBinding();
-		if (binding == null) {
-			return false;
-		}
-		
-		ITypeBinding[] typeArguments= binding.getTypeArguments();
-		if (typeArguments.length == 0) {
-			return false;
-		}
-		
-		if (resultingCollections == null) {
-			return true;
-		}
-
-		// don't add if already added as quick fix
-		if (containsMatchingProblem(locations, IProblem.DiamondNotBelow17))
-			return false;
-		
-		AST ast= node.getAST();
-		ASTRewrite rewrite= ASTRewrite.create(ast);
-		ImportRewrite importRewrite= StubUtility.createImportRewrite(context.getASTRoot(), true);
-		ContextSensitiveImportRewriteContext importContext= new ContextSensitiveImportRewriteContext(context.getASTRoot(), createdType.getStartPosition(), importRewrite);
-
-		String label= CorrectionMessages.QuickAssistProcessor_infer_diamond_description;
-		Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
-		int relevance= locations == null ? IProposalRelevance.INSERT_INFERRED_TYPE_ARGUMENTS : IProposalRelevance.INSERT_INFERRED_TYPE_ARGUMENTS_ERROR; // if error -> higher than ReorgCorrectionsSubProcessor.getNeedHigherComplianceProposals()
-		LinkedCorrectionProposal proposal= new LinkedCorrectionProposal(label, context.getCompilationUnit(), rewrite, relevance, image);
+		IProposableFix fix= TypeParametersFix.createInsertInferredTypeArgumentsFix(context.getASTRoot(), createdType);
+		if (fix != null) {
+			if (resultingCollections == null) {
+				return true;
+			}
+			Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
+			int relevance= locations == null ? IProposalRelevance.INSERT_INFERRED_TYPE_ARGUMENTS : IProposalRelevance.INSERT_INFERRED_TYPE_ARGUMENTS_ERROR; // if error -> higher than ReorgCorrectionsSubProcessor.getNeedHigherComplianceProposals()
 
-		ListRewrite argumentsRewrite= rewrite.getListRewrite(createdType, ParameterizedType.TYPE_ARGUMENTS_PROPERTY);
-		for (int i= 0; i < typeArguments.length; i++) {
-			ITypeBinding typeArgument= typeArguments[i];
-			Type argumentNode= importRewrite.addImport(typeArgument, ast, importContext);
-			argumentsRewrite.insertLast(argumentNode, null);
-			proposal.addLinkedPosition(rewrite.track(argumentNode), true, "arg" + i); //$NON-NLS-1$
+			FixCorrectionProposal proposal= new FixCorrectionProposal(fix, new TypeParametersCleanUp(), relevance, image, context);
+			resultingCollections.add(proposal);
 		}
+		
 
-		resultingCollections.add(proposal);
 		return true;
 	}