Bug 514213 - [1.8][null] Avoid creating redundant @NonNull in "CreateI20170411-2000I20170411-0500I20170410-2000I20170409-2000

method"-quick fixes


Change-Id: I3181c7bfcbbbf1dd3cc706ac0c1c5eb4435377f3
Signed-off-by: Till Brychcy <register.eclipse@brychcy.de>

5 files changed, 263 insertions, 38 deletions

diff --git a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/QuickFixTest.java b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/QuickFixTest.java
index 3a769fde83..8b8373ceaf 100644
--- a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/QuickFixTest.java
+++ b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/QuickFixTest.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2016 IBM Corporation and others.
+ * Copyright (c) 2000, 2017 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
@@ -169,6 +169,11 @@ public class QuickFixTest extends TestCase {
 		StringAsserts.assertExpectedExistInProposals(getPreviewContents(actualProposals), expecteds);
 	}
 
+	protected static void assertProposalPreviewEquals(String expected, String proposalName, List<IJavaCompletionProposal> proposals) throws CoreException, BadLocationException {
+		final ICompletionProposal proposal= findProposalByName(proposalName, proposals);
+		assertNotNull("proposal \""+proposalName+"\" not found", proposal);
+		assertEquals(expected, getProposalPreviewContent(proposal));
+	}
 
 	public static void assertCommandIdDoesNotExist(List<? extends ICompletionProposal> actualProposals, String commandId) {
 		assertTrue(findProposalByCommandId(commandId, actualProposals) == null);
@@ -418,22 +423,28 @@ public class QuickFixTest extends TestCase {
 	protected static String[] getPreviewContents(List<IJavaCompletionProposal> proposals) throws CoreException, BadLocationException {
 		String[] res= new String[proposals.size()];
 		for (int i= 0; i < proposals.size(); i++) {
-			Object curr= proposals.get(i);
-			if (curr instanceof ReorgCorrectionsSubProcessor.ClasspathFixCorrectionProposal) {
-				// ignore
-			} else if (curr instanceof CUCorrectionProposal) {
-				res[i]= getPreviewContent((CUCorrectionProposal) curr);
-			} else if (curr instanceof NewCUUsingWizardProposal) {
-				res[i]= getWizardPreviewContent((NewCUUsingWizardProposal) curr);
-			} else if (curr instanceof SurroundWithTemplateProposal) {
-				res[i]= getTemplatePreviewContent((SurroundWithTemplateProposal) curr);
-			} else if (curr instanceof SelfEncapsulateFieldProposal) {
-				res[i]= getSEFPreviewContent((SelfEncapsulateFieldProposal) curr);
-			}
+			res[i]=getProposalPreviewContent(proposals.get(i));
 		}
 		return res;
 	}
 
+
+	private static String getProposalPreviewContent(ICompletionProposal curr) throws CoreException, BadLocationException {
+		String previewContent = null;
+		if (curr instanceof ReorgCorrectionsSubProcessor.ClasspathFixCorrectionProposal) {
+			// ignore
+		} else if (curr instanceof CUCorrectionProposal) {
+			previewContent= getPreviewContent((CUCorrectionProposal) curr);
+		} else if (curr instanceof NewCUUsingWizardProposal) {
+			previewContent= getWizardPreviewContent((NewCUUsingWizardProposal) curr);
+		} else if (curr instanceof SurroundWithTemplateProposal) {
+			previewContent= getTemplatePreviewContent((SurroundWithTemplateProposal) curr);
+		} else if (curr instanceof SelfEncapsulateFieldProposal) {
+			previewContent= getSEFPreviewContent((SelfEncapsulateFieldProposal) curr);
+		}
+		return previewContent;
+	}
+	
 	private static String getSEFPreviewContent(SelfEncapsulateFieldProposal sefp) throws CoreException {
 		ICompilationUnit compilationUnit= sefp.getField().getCompilationUnit();
 		TextFileChange change= sefp.getChange((IFile) compilationUnit.getResource());
diff --git a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/UnresolvedMethodsQuickFixTest18.java b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/UnresolvedMethodsQuickFixTest18.java
index 2e43fec995..f5dfe28092 100644
--- a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/UnresolvedMethodsQuickFixTest18.java
+++ b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/UnresolvedMethodsQuickFixTest18.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2014, 2016 IBM Corporation and others.
+ * Copyright (c) 2014, 2017 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
@@ -12,10 +12,13 @@ package org.eclipse.jdt.ui.tests.quickfix;
 
 import java.util.ArrayList;
 import java.util.Hashtable;
+import java.util.List;
 
 import org.eclipse.jdt.testplugin.JavaProjectHelper;
 import org.eclipse.jdt.testplugin.TestOptions;
 
+import org.eclipse.core.runtime.Path;
+
 import org.eclipse.jface.preference.IPreferenceStore;
 
 import org.eclipse.jdt.core.ICompilationUnit;
@@ -23,6 +26,7 @@ import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IPackageFragment;
 import org.eclipse.jdt.core.IPackageFragmentRoot;
 import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.compiler.IProblem;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
 
@@ -36,6 +40,7 @@ import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;
 import org.eclipse.jdt.ui.text.java.correction.CUCorrectionProposal;
 
 import org.eclipse.jdt.internal.ui.JavaPlugin;
+import org.eclipse.jdt.internal.ui.text.correction.AssistContext;
 import org.eclipse.jdt.internal.ui.text.correction.CorrectionMessages;
 
 import junit.framework.Test;
@@ -392,5 +397,211 @@ public class UnresolvedMethodsQuickFixTest18 extends QuickFixTest {
 		buf.append("}\n");
 		assertEqualStringsIgnoreOrder(new String[] { getPreviewContent(proposal) }, new String[] { buf.toString() });
 	}
+	public void testBug514213_avoidRedundantNonNullWhenCreatingMissingMethodForOverride() throws Exception {
+		Hashtable<String, String> options= JavaCore.getOptions();
+		options.put(JavaCore.COMPILER_ANNOTATION_NULL_ANALYSIS, JavaCore.ENABLED);
+		JavaCore.setOptions(options);
+		JavaProjectHelper.addLibrary(fJProject1, new Path(Java18ProjectTestSetup.getJdtAnnotations20Path()));
+		
+		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
+
+		StringBuffer buf;
+
+		buf= new StringBuffer();
+		buf.append("@org.eclipse.jdt.annotation.NonNullByDefault\n");
+		buf.append("package test1;\n");
+		pack1.createCompilationUnit("package-info.java", buf.toString(), false, null);
+
+		buf= new StringBuffer();
+		buf.append("package test1;\n");
+		buf.append("\n");
+		buf.append("import java.util.Comparator;\n");
+		buf.append("import java.util.List;\n");
+		buf.append("import java.util.Map;\n");
+		buf.append("\n");
+		buf.append("import org.eclipse.jdt.annotation.NonNullByDefault;\n");
+		buf.append("import org.eclipse.jdt.annotation.Nullable;\n");
+		buf.append("\n");
+		buf.append("@NonNullByDefault({})\n");
+		buf.append("interface I1 {\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("interface I2 {\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("class X implements I1, I2 {\n");
+		buf.append("	@Override\n");
+		buf.append("	public Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] f(Number n1, @Nullable Number n2) {\n");
+		buf.append("		return null;\n");
+		buf.append("	}\n");
+		buf.append("}");
+		ICompilationUnit cu= pack1.createCompilationUnit("X.java", buf.toString(), false, null);
+
+		AssistContext context= getCorrectionContext(cu, buf.toString().indexOf("f("), 0);
+		List<IJavaCompletionProposal> proposals= collectAssists(context, false);
+
+		buf= new StringBuffer();
+		buf.append("package test1;\n");
+		buf.append("\n");
+		buf.append("import java.util.Comparator;\n");
+		buf.append("import java.util.List;\n");
+		buf.append("import java.util.Map;\n");
+		buf.append("\n");
+		buf.append("import org.eclipse.jdt.annotation.NonNull;\n");
+		buf.append("import org.eclipse.jdt.annotation.NonNullByDefault;\n");
+		buf.append("import org.eclipse.jdt.annotation.Nullable;\n");
+		buf.append("\n");
+		buf.append("@NonNullByDefault({})\n");
+		buf.append("interface I1 {\n");
+		buf.append("\n");
+		buf.append("    Comparator<@NonNull List<? extends @NonNull Map<@Nullable Number, String @NonNull []>>> @Nullable [] f(\n");
+		buf.append("            @NonNull Number n1, @Nullable Number n2);\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("interface I2 {\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("class X implements I1, I2 {\n");
+		buf.append("	@Override\n");
+		buf.append("	public Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] f(Number n1, @Nullable Number n2) {\n");
+		buf.append("		return null;\n");
+		buf.append("	}\n");
+		buf.append("}");
+		assertProposalPreviewEquals(buf.toString(), "Create 'f()' in super type 'I1'", proposals);		
+
+		buf= new StringBuffer();
+		buf.append("package test1;\n");
+		buf.append("\n");
+		buf.append("import java.util.Comparator;\n");
+		buf.append("import java.util.List;\n");
+		buf.append("import java.util.Map;\n");
+		buf.append("\n");
+		buf.append("import org.eclipse.jdt.annotation.NonNullByDefault;\n");
+		buf.append("import org.eclipse.jdt.annotation.Nullable;\n");
+		buf.append("\n");
+		buf.append("@NonNullByDefault({})\n");
+		buf.append("interface I1 {\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("interface I2 {\n");
+		buf.append("\n");
+		buf.append("    Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] f(\n");
+		buf.append("            Number n1, @Nullable Number n2);\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("class X implements I1, I2 {\n");
+		buf.append("	@Override\n");
+		buf.append("	public Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] f(Number n1, @Nullable Number n2) {\n");
+		buf.append("		return null;\n");
+		buf.append("	}\n");
+		buf.append("}");
+		assertProposalPreviewEquals(buf.toString(), "Create 'f()' in super type 'I2'", proposals);		
+	}
+
+	public void testBug514213_avoidRedundantNonNullWhenCreatingMissingMethodForInvocation() throws Exception {
+		Hashtable<String, String> options= JavaCore.getOptions();
+		options.put(JavaCore.COMPILER_ANNOTATION_NULL_ANALYSIS, JavaCore.ENABLED);
+		JavaCore.setOptions(options);
+		JavaProjectHelper.addLibrary(fJProject1, new Path(Java18ProjectTestSetup.getJdtAnnotations20Path()));
+		
+		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
+
+		StringBuffer buf;
+
+		buf= new StringBuffer();
+		buf.append("@org.eclipse.jdt.annotation.NonNullByDefault\n");
+		buf.append("package test1;\n");
+		pack1.createCompilationUnit("package-info.java", buf.toString(), false, null);
+
+		buf= new StringBuffer();
+		buf.append("package test1;\n");
+		buf.append("\n");
+		buf.append("import java.util.Comparator;\n");
+		buf.append("import java.util.List;\n");
+		buf.append("import java.util.Map;\n");
+		buf.append("\n");
+		buf.append("import org.eclipse.jdt.annotation.NonNullByDefault;\n");
+		buf.append("import org.eclipse.jdt.annotation.Nullable;\n");
+		buf.append("\n");
+		buf.append("@NonNullByDefault({})\n");
+		buf.append("interface I1 {\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("interface I2 {\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("class X {\n");
+		buf.append("	public boolean f(Number n1, @Nullable Number n2, I1 i1, I2 i2) {\n");
+		buf.append("		Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] x1 = i1.g(n1, n2);\n");
+		buf.append("		Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] x2 = i2.g(n1, n2);\n");
+		buf.append("		return x1 == x2;\n");
+		buf.append("	}\n");
+		buf.append("}");
+		ICompilationUnit cu= pack1.createCompilationUnit("X.java", buf.toString(), false, null);
+
+		CompilationUnit astRoot= getASTRoot(cu);
+		IProblem[] problems= astRoot.getProblems();
+		assertNumberOfProblems(2, problems);
+		List<IJavaCompletionProposal> proposals1= collectCorrections(cu, problems[0], null);
+		List<IJavaCompletionProposal> proposals2= collectCorrections(cu, problems[1], null);
+		buf= new StringBuffer();
+		buf.append("package test1;\n");
+		buf.append("\n");
+		buf.append("import java.util.Comparator;\n");
+		buf.append("import java.util.List;\n");
+		buf.append("import java.util.Map;\n");
+		buf.append("\n");
+		buf.append("import org.eclipse.jdt.annotation.NonNull;\n");
+		buf.append("import org.eclipse.jdt.annotation.NonNullByDefault;\n");
+		buf.append("import org.eclipse.jdt.annotation.Nullable;\n");
+		buf.append("\n");
+		buf.append("@NonNullByDefault({})\n");
+		buf.append("interface I1 {\n");
+		buf.append("\n");
+		buf.append("    Comparator<@NonNull List<? extends @NonNull Map<@Nullable Number, String @NonNull []>>> @Nullable [] g(\n");
+		buf.append("            @NonNull Number n1, @Nullable Number n2);\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("interface I2 {\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("class X {\n");
+		buf.append("	public boolean f(Number n1, @Nullable Number n2, I1 i1, I2 i2) {\n");
+		buf.append("		Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] x1 = i1.g(n1, n2);\n");
+		buf.append("		Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] x2 = i2.g(n1, n2);\n");
+		buf.append("		return x1 == x2;\n");
+		buf.append("	}\n");
+		buf.append("}");
+		assertProposalPreviewEquals(buf.toString(), "Create method 'g(Number, Number)' in type 'I1'", proposals1);		
+
+		buf= new StringBuffer();
+		buf.append("package test1;\n");
+		buf.append("\n");
+		buf.append("import java.util.Comparator;\n");
+		buf.append("import java.util.List;\n");
+		buf.append("import java.util.Map;\n");
+		buf.append("\n");
+		buf.append("import org.eclipse.jdt.annotation.NonNullByDefault;\n");
+		buf.append("import org.eclipse.jdt.annotation.Nullable;\n");
+		buf.append("\n");
+		buf.append("@NonNullByDefault({})\n");
+		buf.append("interface I1 {\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("interface I2 {\n");
+		buf.append("\n");
+		buf.append("    Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] g(\n");
+		buf.append("            Number n1, @Nullable Number n2);\n");
+		buf.append("}\n");
+		buf.append("\n");
+		buf.append("class X {\n");
+		buf.append("	public boolean f(Number n1, @Nullable Number n2, I1 i1, I2 i2) {\n");
+		buf.append("		Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] x1 = i1.g(n1, n2);\n");
+		buf.append("		Comparator<List<? extends Map<@Nullable Number, String[]>>> @Nullable [] x2 = i2.g(n1, n2);\n");
+		buf.append("		return x1 == x2;\n");
+		buf.append("	}\n");
+		buf.append("}");
+		assertProposalPreviewEquals(buf.toString(), "Create method 'g(Number, Number)' in type 'I2'", proposals2);		
+	}
 
 }
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/AbstractMethodCorrectionProposal.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/AbstractMethodCorrectionProposal.java
index 089ced10a2..19a35919b5 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/AbstractMethodCorrectionProposal.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/AbstractMethodCorrectionProposal.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2016 IBM Corporation and others.
+ * Copyright (c) 2000, 2017 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
@@ -42,10 +42,12 @@ import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
 import org.eclipse.jdt.core.dom.Type;
 import org.eclipse.jdt.core.dom.TypeParameter;
 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
+import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext;
 import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
 
 import org.eclipse.jdt.internal.core.manipulation.dom.ASTResolving;
 import org.eclipse.jdt.internal.corext.codemanipulation.CodeGenerationSettings;
+import org.eclipse.jdt.internal.corext.codemanipulation.ContextSensitiveImportRewriteContext;
 import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
 import org.eclipse.jdt.internal.corext.dom.ASTNodes;
 import org.eclipse.jdt.internal.corext.dom.Bindings;
@@ -120,6 +122,8 @@ public abstract class AbstractMethodCorrectionProposal extends LinkedCorrectionP
 	}
 
 	private MethodDeclaration getStub(ASTRewrite rewrite, ASTNode targetTypeDecl) throws CoreException {
+		ImportRewriteContext context=new ContextSensitiveImportRewriteContext(targetTypeDecl, getImportRewrite());
+
 		AST ast= targetTypeDecl.getAST();
 		MethodDeclaration decl= ast.newMethodDeclaration();
 
@@ -130,7 +134,7 @@ public abstract class AbstractMethodCorrectionProposal extends LinkedCorrectionP
 		addNewModifiers(rewrite, targetTypeDecl, decl.modifiers());
 
 		ArrayList<String> takenNames= new ArrayList<>();
-		addNewTypeParameters(rewrite, takenNames, decl.typeParameters());
+		addNewTypeParameters(rewrite, takenNames, decl.typeParameters(), context);
 
 		decl.setName(newNameNode);
 
@@ -142,7 +146,7 @@ public abstract class AbstractMethodCorrectionProposal extends LinkedCorrectionP
 		String bodyStatement= ""; //$NON-NLS-1$
 		boolean isAbstractMethod= Modifier.isAbstract(decl.getModifiers()) || (fSenderBinding.isInterface() && !Modifier.isStatic(decl.getModifiers()) && !Modifier.isDefault(decl.getModifiers()));
 		if (!isConstructor()) {
-			Type returnType= getNewMethodType(rewrite);
+			Type returnType= getNewMethodType(rewrite, context);
 			decl.setReturnType2(returnType);
 
 			boolean isVoid= returnType instanceof PrimitiveType && PrimitiveType.VOID.equals(((PrimitiveType)returnType).getPrimitiveTypeCode());
@@ -153,8 +157,8 @@ public abstract class AbstractMethodCorrectionProposal extends LinkedCorrectionP
 			}
 		}
 
-		addNewParameters(rewrite, takenNames, decl.parameters());
-		addNewExceptions(rewrite, decl.thrownExceptionTypes());
+		addNewParameters(rewrite, takenNames, decl.parameters(), context);
+		addNewExceptions(rewrite, decl.thrownExceptionTypes(), context);
 
 		Block body= null;
 		if (!isAbstractMethod && !Flags.isAbstract(decl.getModifiers())) {
@@ -207,12 +211,12 @@ public abstract class AbstractMethodCorrectionProposal extends LinkedCorrectionP
 	protected abstract boolean isConstructor();
 
 	protected abstract void addNewModifiers(ASTRewrite rewrite, ASTNode targetTypeDecl, List<IExtendedModifier> modifiers);
-	protected abstract void addNewTypeParameters(ASTRewrite rewrite, List<String> takenNames, List<TypeParameter> params) throws CoreException;
-	protected abstract void addNewParameters(ASTRewrite rewrite, List<String> takenNames, List<SingleVariableDeclaration> params) throws CoreException;
-	protected abstract void addNewExceptions(ASTRewrite rewrite, List<Type> exceptions) throws CoreException;
+	protected abstract void addNewTypeParameters(ASTRewrite rewrite, List<String> takenNames, List<TypeParameter> params, ImportRewriteContext context) throws CoreException;
+	protected abstract void addNewParameters(ASTRewrite rewrite, List<String> takenNames, List<SingleVariableDeclaration> params, ImportRewriteContext context) throws CoreException;
+	protected abstract void addNewExceptions(ASTRewrite rewrite, List<Type> exceptions, ImportRewriteContext context) throws CoreException;
 
 	protected abstract SimpleName getNewName(ASTRewrite rewrite);
-	protected abstract Type getNewMethodType(ASTRewrite rewrite) throws CoreException;
+	protected abstract Type getNewMethodType(ASTRewrite rewrite, ImportRewriteContext context) throws CoreException;
 
 
 }
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/NewDefiningMethodProposal.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/NewDefiningMethodProposal.java
index cfe3c3c9cd..09c54a9c10 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/NewDefiningMethodProposal.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/NewDefiningMethodProposal.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2013 IBM Corporation and others.
+ * Copyright (c) 2000, 2017 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
@@ -30,6 +30,8 @@ import org.eclipse.jdt.core.dom.Type;
 import org.eclipse.jdt.core.dom.TypeParameter;
 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
 import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;
+import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext;
+import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.TypeLocation;
 
 import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;
 
@@ -56,7 +58,7 @@ public class NewDefiningMethodProposal extends AbstractMethodCorrectionProposal
 	}
 
 	@Override
-	protected void addNewParameters(ASTRewrite rewrite, List<String> takenNames, List<SingleVariableDeclaration> params) throws CoreException {
+	protected void addNewParameters(ASTRewrite rewrite, List<String> takenNames, List<SingleVariableDeclaration> params, ImportRewriteContext context) throws CoreException {
 		AST ast= rewrite.getAST();
 		ImportRewrite importRewrite= getImportRewrite();
 		ITypeBinding[] bindings= fMethod.getParameterTypes();
@@ -71,7 +73,7 @@ public class NewDefiningMethodProposal extends AbstractMethodCorrectionProposal
 
 			SingleVariableDeclaration newParam= ast.newSingleVariableDeclaration();
 
-			newParam.setType(importRewrite.addImport(curr, ast));
+			newParam.setType(importRewrite.addImport(curr, ast, context, TypeLocation.PARAMETER));
 			newParam.setName(ast.newSimpleName(proposedNames[0]));
 
 			params.add(newParam);
@@ -110,17 +112,17 @@ public class NewDefiningMethodProposal extends AbstractMethodCorrectionProposal
 	}
 
 	@Override
-	protected Type getNewMethodType(ASTRewrite rewrite) throws CoreException {
-		return getImportRewrite().addImport(fMethod.getReturnType(), rewrite.getAST());
+	protected Type getNewMethodType(ASTRewrite rewrite, ImportRewriteContext context) throws CoreException {
+		return getImportRewrite().addImport(fMethod.getReturnType(), rewrite.getAST(), context, TypeLocation.RETURN_TYPE);
 	}
 
 	@Override
-	protected void addNewExceptions(ASTRewrite rewrite, List<Type> exceptions) throws CoreException {
+	protected void addNewExceptions(ASTRewrite rewrite, List<Type> exceptions, ImportRewriteContext context) throws CoreException {
 		AST ast= rewrite.getAST();
 		ImportRewrite importRewrite= getImportRewrite();
 		ITypeBinding[] bindings= fMethod.getExceptionTypes();
 		for (int i= 0; i < bindings.length; i++) {
-			Type newType= importRewrite.addImport(bindings[i], ast);
+			Type newType= importRewrite.addImport(bindings[i], ast, context, TypeLocation.EXCEPTION);
 			exceptions.add(newType);
 
 			addLinkedPosition(rewrite.track(newType), false, "exc_type_" + i); //$NON-NLS-1$
@@ -128,7 +130,7 @@ public class NewDefiningMethodProposal extends AbstractMethodCorrectionProposal
 	}
 
 	@Override
-	protected void addNewTypeParameters(ASTRewrite rewrite, List<String> takenNames, List<TypeParameter> params) throws CoreException {
+	protected void addNewTypeParameters(ASTRewrite rewrite, List<String> takenNames, List<TypeParameter> params, ImportRewriteContext context) throws CoreException {
 
 	}
 
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/NewMethodCorrectionProposal.java b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/NewMethodCorrectionProposal.java
index 7eb0cfc70c..f9001e94e1 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/NewMethodCorrectionProposal.java
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/proposals/NewMethodCorrectionProposal.java
@@ -48,7 +48,6 @@ import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext;
 import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.TypeLocation;
 
 import org.eclipse.jdt.internal.core.manipulation.dom.ASTResolving;
-import org.eclipse.jdt.internal.corext.codemanipulation.ContextSensitiveImportRewriteContext;
 import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;
 import org.eclipse.jdt.internal.corext.dom.ASTNodes;
 import org.eclipse.jdt.internal.corext.dom.Bindings;
@@ -196,14 +195,13 @@ public class NewMethodCorrectionProposal extends AbstractMethodCorrectionProposa
 	}
 
 	@Override
-	protected Type getNewMethodType(ASTRewrite rewrite) throws CoreException {
+	protected Type getNewMethodType(ASTRewrite rewrite, ImportRewriteContext importRewriteContext) throws CoreException {
 		ASTNode node= getInvocationNode();
 		AST ast= rewrite.getAST();
 
 		Type newTypeNode= null;
 		ITypeBinding[] otherProposals= null;
 
-		ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(node, getImportRewrite());
 		if (node.getParent() instanceof MethodInvocation) {
 			MethodInvocation parent= (MethodInvocation) node.getParent();
 			if (parent.getExpression() == node) {
@@ -245,11 +243,10 @@ public class NewMethodCorrectionProposal extends AbstractMethodCorrectionProposa
 	}
 
 	@Override
-	protected void addNewParameters(ASTRewrite rewrite, List<String> takenNames, List<SingleVariableDeclaration> params) throws CoreException {
+	protected void addNewParameters(ASTRewrite rewrite, List<String> takenNames, List<SingleVariableDeclaration> params, ImportRewriteContext context) throws CoreException {
 		AST ast= rewrite.getAST();
 
 		List<Expression> arguments= fArguments;
-		ImportRewriteContext context= new ContextSensitiveImportRewriteContext(ASTResolving.findParentBodyDeclaration(getInvocationNode()), getImportRewrite());
 
 		for (int i= 0; i < arguments.size(); i++) {
 			Expression elem= arguments.get(i);
@@ -299,10 +296,10 @@ public class NewMethodCorrectionProposal extends AbstractMethodCorrectionProposa
 	}
 
 	@Override
-	protected void addNewExceptions(ASTRewrite rewrite, List<Type> exceptions) throws CoreException {
+	protected void addNewExceptions(ASTRewrite rewrite, List<Type> exceptions, ImportRewriteContext context) throws CoreException {
 	}
 
 	@Override
-	protected void addNewTypeParameters(ASTRewrite rewrite, List<String> takenNames, List<TypeParameter> params) throws CoreException {
+	protected void addNewTypeParameters(ASTRewrite rewrite, List<String> takenNames, List<TypeParameter> params, ImportRewriteContext context) throws CoreException {
 	}
 }