Attachment #217460 for bug #337977




/*******************************************************************************
 * Copyright (c) 2012 GK Software AG 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:
 *     Stephan Herrmann - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.ui.tests.quickfix;

import java.io.File;
import java.util.ArrayList;
import java.util.Hashtable;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.jdt.testplugin.JavaProjectHelper;
import org.eclipse.jdt.testplugin.TestOptions;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jdt.core.ICompilationUnit;
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.dom.CompilationUnit;
import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;

import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;
import org.eclipse.jdt.internal.corext.template.java.CodeTemplateContextType;

import org.eclipse.jdt.ui.PreferenceConstants;
import org.eclipse.jdt.ui.tests.core.ProjectTestSetup;
import org.eclipse.jdt.ui.text.java.correction.CUCorrectionProposal;

import org.eclipse.jdt.internal.ui.JavaPlugin;

public class NullAnnotationQuickFixTest extends QuickFixTest {

	private static final Class THIS= NullAnnotationQuickFixTest.class;

	private IJavaProject fJProject1;
	private IPackageFragmentRoot fSourceFolder;

	private String ANNOTATION_JAR_PATH;


	public NullAnnotationQuickFixTest(String name) {
		super(name);
	}

	public static Test suite() {
		return setUpTest(new TestSuite(THIS));
	}

	public static Test setUpTest(Test test) {
		return new ProjectTestSetup(test);
	}


	protected void setUp() throws Exception {
		Hashtable options= TestOptions.getDefaultOptions();
		options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
		options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");
		options.put(DefaultCodeFormatterConstants.FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE, String.valueOf(99));
		options.put(JavaCore.COMPILER_PB_STATIC_ACCESS_RECEIVER, JavaCore.ERROR);
		options.put(JavaCore.COMPILER_PB_UNCHECKED_TYPE_OPERATION, JavaCore.IGNORE);
		options.put(JavaCore.COMPILER_PB_MISSING_HASHCODE_METHOD, JavaCore.WARNING);
		options.put(JavaCore.COMPILER_ANNOTATION_NULL_ANALYSIS, JavaCore.ENABLED);
		options.put(JavaCore.COMPILER_PB_NULL_SPECIFICATION_VIOLATION, JavaCore.ERROR);
		options.put(JavaCore.COMPILER_PB_NULL_REFERENCE, JavaCore.ERROR);
		options.put(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE, JavaCore.WARNING);
		options.put(JavaCore.COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT, JavaCore.WARNING);
		options.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.WARNING);
		options.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK, JavaCore.WARNING);

		JavaCore.setOptions(options);

		IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
		store.setValue(PreferenceConstants.CODEGEN_ADD_COMMENTS, false);

		StubUtility.setCodeTemplate(CodeTemplateContextType.CATCHBLOCK_ID, "", null);
		StubUtility.setCodeTemplate(CodeTemplateContextType.CONSTRUCTORSTUB_ID, "", null);
		StubUtility.setCodeTemplate(CodeTemplateContextType.METHODSTUB_ID, "", null);

		fJProject1= ProjectTestSetup.getProject();
		
		if (this.ANNOTATION_JAR_PATH == null) {
			File bundleFile = FileLocator.getBundleFile(Platform.getBundle("org.eclipse.jdt.annotation"));
			if (bundleFile.isDirectory())
				this.ANNOTATION_JAR_PATH = bundleFile.getPath()+"/bin";
			else
				this.ANNOTATION_JAR_PATH = bundleFile.getPath();
		}
		JavaProjectHelper.addLibrary(fJProject1, new Path(ANNOTATION_JAR_PATH));


		fSourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
	}


	protected void tearDown() throws Exception {
		JavaProjectHelper.clear(fJProject1, ProjectTestSetup.getDefaultClasspath());
	}

	// ==== Problem:	dereferencing a @Nullable field
	// ==== Fix:		extract field access to a fresh local variable and add a null-check
	
	// basic case
	public void testExtractNullableField1() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable String f;\n");
		buf.append("    public void foo() {\n");
		buf.append("        System.out.println(f.toUpperCase());\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);
		assertNumberOfProposals(proposals, 1);
		assertCorrectLabels(proposals);

		CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
		String preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable String f;\n");
		buf.append("    public void foo() {\n");
		buf.append("        String f2 = f;\n");
		buf.append("        if (f2 != null) {\n");
		buf.append("            System.out.println(f2.toUpperCase());\n");
		buf.append("        } else {\n");
		buf.append("            // TODO handle null value\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());
	}

	// statement is not element of a block - need to create a new block - local name f2 already in use
	public void testExtractNullableField2() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable String f;\n");
		buf.append("    public void foo(boolean b) {\n");
		buf.append("        @SuppressWarnings(\"unused\") boolean f2 = false;\n");
		buf.append("        if (b)\n");
		buf.append("          System.out.println(f.toUpperCase());\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);
		assertNumberOfProposals(proposals, 1);
		assertCorrectLabels(proposals);

		CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
		String preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable String f;\n");
		buf.append("    public void foo(boolean b) {\n");
		buf.append("        @SuppressWarnings(\"unused\") boolean f2 = false;\n");
		buf.append("        if (b) {\n");
		buf.append("            String f3 = f;\n");
		buf.append("            if (f3 != null) {\n");
		buf.append("                System.out.println(f3.toUpperCase());\n");
		buf.append("            } else {\n");
		buf.append("                // TODO handle null value\n");
		buf.append("            }\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());
	}

	// field name is part of a qualified field reference - inside a return statement (type: int)
	public void testExtractNullableField3() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable E other;\n");
		buf.append("    int f;\n");
		buf.append("    public int foo(E that) {\n");
		buf.append("        return that.other.f;\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);
		assertNumberOfProposals(proposals, 1);
		assertCorrectLabels(proposals);

		CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
		String preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable E other;\n");
		buf.append("    int f;\n");
		buf.append("    public int foo(E that) {\n");
		buf.append("        E other2 = that.other;\n");
		buf.append("        if (other2 != null) {\n");
		buf.append("            return other2.f;\n");
		buf.append("        } else {\n");
		buf.append("            // TODO handle null value\n");
		buf.append("            return 0;\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());
	}

	// field name is part of a this-qualified field reference - inside a return statement (type: String)
	public void testExtractNullableField4() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable E other;\n");
		buf.append("    @Nullable String f;\n");
		buf.append("    public String foo() {\n");
		buf.append("        return this.other.f;\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);
		assertNumberOfProposals(proposals, 1);
		assertCorrectLabels(proposals);

		CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
		String preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable E other;\n");
		buf.append("    @Nullable String f;\n");
		buf.append("    public String foo() {\n");
		buf.append("        E other2 = this.other;\n");
		buf.append("        if (other2 != null) {\n");
		buf.append("            return other2.f;\n");
		buf.append("        } else {\n");
		buf.append("            // TODO handle null value\n");
		buf.append("            return null;\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());
	}

	// field referenced inside the rhs of an assignment-as-expression
	public void testExtractNullableField5() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable E other;\n");
		buf.append("    @Nullable String f;\n");
		buf.append("    public void foo() {\n");
		buf.append("        String lo;\n");
		buf.append("        if ((lo = this.other.f) != null)\n");
		buf.append("            System.out.println(lo);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);
		assertNumberOfProposals(proposals, 1);
		assertCorrectLabels(proposals);

		CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
		String preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable E other;\n");
		buf.append("    @Nullable String f;\n");
		buf.append("    public void foo() {\n");
		buf.append("        String lo;\n");
		buf.append("        E other2 = this.other;\n");
		buf.append("        if (other2 != null) {\n");
		buf.append("            if ((lo = other2.f) != null)\n");
		buf.append("                System.out.println(lo);\n");
		buf.append("        } else {\n");
		buf.append("            // TODO handle null value\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());
	}

	// reference to field of array type - dereferenced by f[0] and f.length
	public void testExtractNullableField6() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable String[] f1;\n");
		buf.append("    @Nullable String[] f2;\n");
		buf.append("    public void foo() {\n");
		buf.append("        System.out.println(f1[0]);\n");
		buf.append("        System.out.println(f2.length);\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot, 2, 0); // get correction for first of two problems
		assertNumberOfProposals(proposals, 1);
		assertCorrectLabels(proposals);

		CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
		String preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable String[] f1;\n");
		buf.append("    @Nullable String[] f2;\n");
		buf.append("    public void foo() {\n");
		buf.append("        String[] f12 = f1;\n");
		buf.append("        if (f12 != null) {\n");
		buf.append("            System.out.println(f12[0]);\n");
		buf.append("        } else {\n");
		buf.append("            // TODO handle null value\n");
		buf.append("        }\n");
		buf.append("        System.out.println(f2.length);\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());

		proposals= collectCorrections(cu, astRoot, 2, 1); // get correction for second of two problems
		assertNumberOfProposals(proposals, 1);
		proposal= (CUCorrectionProposal) proposals.get(0);
		preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable String[] f1;\n");
		buf.append("    @Nullable String[] f2;\n");
		buf.append("    public void foo() {\n");
		buf.append("        System.out.println(f1[0]);\n");
		buf.append("        String[] f22 = f2;\n");
		buf.append("        if (f22 != null) {\n");
		buf.append("            System.out.println(f22.length);\n");
		buf.append("        } else {\n");
		buf.append("            // TODO handle null value\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());
	}

	// field has a generic type
	public void testExtractNullableField7() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("import java.util.List;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable List<String> f;\n");
		buf.append("    public void foo() {\n");
		buf.append("        System.out.println(f.size());\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);
		assertNumberOfProposals(proposals, 1);
		assertCorrectLabels(proposals);

		CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
		String preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("import java.util.List;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable List<String> f;\n");
		buf.append("    public void foo() {\n");
		buf.append("        List<String> f2 = f;\n");
		buf.append("        if (f2 != null) {\n");
		buf.append("            System.out.println(f2.size());\n");
		buf.append("        } else {\n");
		buf.append("            // TODO handle null value\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());
	}

	// occurrences inside a class initializer
	public void testExtractNullableField8() throws Exception {
		IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
		StringBuffer buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable Exception e;\n");
		buf.append("    {\n");
		buf.append("        e.printStackTrace();\n");
		buf.append("    }\n");
		buf.append("}\n");
		ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);

		CompilationUnit astRoot= getASTRoot(cu);
		ArrayList proposals= collectCorrections(cu, astRoot);
		assertNumberOfProposals(proposals, 1);
		assertCorrectLabels(proposals);

		CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
		String preview= getPreviewContent(proposal);

		buf= new StringBuffer();
		buf.append("package test1;\n");
		buf.append("import org.eclipse.jdt.annotation.*;\n");
		buf.append("public class E {\n");
		buf.append("    @Nullable Exception e;\n");
		buf.append("    {\n");
		buf.append("        Exception e2 = e;\n");
		buf.append("        if (e2 != null) {\n");
		buf.append("            e2.printStackTrace();\n");
		buf.append("        } else {\n");
		buf.append("            // TODO handle null value\n");
		buf.append("        }\n");
		buf.append("    }\n");
		buf.append("}\n");
		assertEqualString(preview, buf.toString());
	}
}




/*******************************************************************************
 * Copyright (c) 2012 GK Software AG 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:
 *     Stephan Herrmann - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.fix;

import java.util.Collection;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.text.edits.TextEditGroup;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
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.Block;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.FieldAccess;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
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.StubUtility;
import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory;
import org.eclipse.jdt.internal.corext.dom.ASTNodes;
import org.eclipse.jdt.internal.corext.dom.ScopeAnalyzer;
import org.eclipse.jdt.internal.corext.fix.LinkedProposalPositionGroup;

import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.text.correction.proposals.LinkedCorrectionProposal;

/**
 * Fix for {@link IProblem#NullableFieldReference}:
 * Extract the field reference to a fresh local variable.
 * Add a null check for that local variable and move
 * the dereference into the then-block of this null-check:
 * <pre>
 * {@code @Nullable Exception e;}
 * void test() {
 *     e.printStackTrace();
 * }</pre>
 * will be converted to:
 * <pre>
 * {@code @Nullable Exception e;}
 * void test() {
 *     Exception e2 = e;
 *     if (e2 != null) {
 *         e2.printStackTrace();
 *     } else {
 *         // TODO handle null value
 *     }
 * }</pre>
 * 
 * @since 3.9
 */
class ExtractToNullCheckedLocalProposal extends LinkedCorrectionProposal {
	
	private static final String LOCAL_NAME_POSITION_GROUP = "localName"; //$NON-NLS-1$
	
	private SimpleName fieldReference;
	private CompilationUnit compilationUnit;
	private ASTNode enclosingMethod; // MethodDeclaration or Initializer 

	public ExtractToNullCheckedLocalProposal(ICompilationUnit cu, CompilationUnit compilationUnit, SimpleName fieldReference, ASTNode enclosingMethod) {
		super(NullFixMessages.NullQuickFixes_extractToCheckedLocal_proposalName, cu, null, 100, JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE));
		this.compilationUnit= compilationUnit;
		this.fieldReference= fieldReference;
		this.enclosingMethod= enclosingMethod;
	}
	
	@Override
	protected ASTRewrite getRewrite() throws CoreException {
		
		// infrastructure:
		AST ast= this.compilationUnit.getAST();
		ASTRewrite rewrite= ASTRewrite.create(ast);
		ImportRewrite imports= ImportRewrite.create(this.compilationUnit, true);
		TextEditGroup group= new TextEditGroup(NullFixMessages.NullQuickFixes_extractCheckedLocal_editName);
		LinkedProposalPositionGroup localNameGroup= new LinkedProposalPositionGroup(LOCAL_NAME_POSITION_GROUP);
		getLinkedProposalModel().addPositionGroup(localNameGroup);

		// AST context:
		Statement stmt= (Statement) ASTNodes.getParent(this.fieldReference, Statement.class);
		ASTNode parent= stmt.getParent();
		ListRewrite blockRewrite= null;
		Block block;
		if (parent instanceof Block) {
			// modifying statement list of the parent block
			block= (Block) parent;
			blockRewrite= rewrite.getListRewrite(block, Block.STATEMENTS_PROPERTY);
		} else {
			// replacing statement with a new block
			block= ast.newBlock();			
		}

		Expression toReplace;
		ASTNode directParent= this.fieldReference.getParent();
		if (directParent instanceof FieldAccess) {
			toReplace= (Expression) directParent;
		} else if (directParent instanceof QualifiedName && this.fieldReference.getLocationInParent() == QualifiedName.NAME_PROPERTY) {
			toReplace= (Expression) directParent;
		} else {
			toReplace= this.fieldReference;
		}

		// new local declaration initialized from the field reference
		VariableDeclarationFragment local = ast.newVariableDeclarationFragment();
		VariableDeclarationStatement localDecl= ast.newVariableDeclarationStatement(local);
		// ... type
		localDecl.setType(newType(toReplace.resolveTypeBinding(), ast, imports));
		// ... name
		String localName= proposeLocalName(this.fieldReference, this.compilationUnit, getCompilationUnit().getJavaProject());
		local.setName(ast.newSimpleName(localName));
		// ... initialization
		local.setInitializer((Expression) ASTNode.copySubtree(ast, toReplace));
		
		if (blockRewrite != null)
			blockRewrite.insertBefore(localDecl, stmt, group);
		else
			block.statements().add(localDecl);
		
		// prepare replacing stmt with a wrapper
		Statement statementToMove = (Statement) 
				(blockRewrite != null ? blockRewrite.createMoveTarget(stmt, stmt) : rewrite.createMoveTarget(stmt));
		
		// if statement:
		IfStatement ifStmt= ast.newIfStatement();
		
		// condition:
		InfixExpression nullCheck= ast.newInfixExpression();
		nullCheck.setLeftOperand(ast.newSimpleName(localName));
		nullCheck.setRightOperand(ast.newNullLiteral());
		nullCheck.setOperator(InfixExpression.Operator.NOT_EQUALS);
		ifStmt.setExpression(nullCheck);
		
		// then block: the original statement
		Block thenBlock = ast.newBlock();
		thenBlock.statements().add(statementToMove);
		ifStmt.setThenStatement(thenBlock);
		// ... but with the field reference replaced by the new local:
		SimpleName dereferencedName= ast.newSimpleName(localName);
		rewrite.replace(toReplace, dereferencedName, group);

		
		// else block: a TODO comment
		Block elseBlock = ast.newBlock();
		String elseStatement= "// TODO "+NullFixMessages.NullQuickFixes_todoHandleNullDescription; //$NON-NLS-1$
		if (stmt instanceof ReturnStatement) {
			Type returnType= newType(((ReturnStatement)stmt).getExpression().resolveTypeBinding(), ast, imports);
			ReturnStatement returnStatement= ast.newReturnStatement();
			returnStatement.setExpression(ASTNodeFactory.newDefaultExpression(ast, returnType, 0));
			elseStatement+= '\n'+ASTNodes.asFormattedString(returnStatement, 0, String.valueOf('\n'), getCompilationUnit().getJavaProject().getOptions(true));
		}

		ReturnStatement todoNode= (ReturnStatement) rewrite.createStringPlaceholder(elseStatement, ASTNode.RETURN_STATEMENT);
		elseBlock.statements().add(todoNode);
		ifStmt.setElseStatement(elseBlock);
		
		// link all three occurrences of the new local variable:
		addLinkedPosition(rewrite.track(local.getName()), true/*first*/, LOCAL_NAME_POSITION_GROUP);
		addLinkedPosition(rewrite.track(nullCheck.getLeftOperand()), false, LOCAL_NAME_POSITION_GROUP);
		addLinkedPosition(rewrite.track(dereferencedName), false, LOCAL_NAME_POSITION_GROUP);

		if (blockRewrite != null) {
			// inside a block replace old statement with wrapping if-statement
			blockRewrite.replace(stmt, ifStmt, group);
		} else {
			// did not have a block: add if-statement to new block
			block.statements().add(ifStmt);
			// and replace the single statement with this block
			rewrite.replace(stmt, block, group);
		}
		
		return rewrite;
	}

	String proposeLocalName(SimpleName fieldName, CompilationUnit root, IJavaProject javaProject) {
		// don't propose names that are already in use:
		Collection<String> variableNames= new ScopeAnalyzer(root).getUsedVariableNames(this.enclosingMethod.getStartPosition(), this.enclosingMethod.getLength());
		String[] names = new String[variableNames.size()+1];
		variableNames.toArray(names);
		// don't propose the field name itself, either:
		String identifier= fieldName.getIdentifier();
		names[names.length-1] = identifier;
		return StubUtility.getLocalNameSuggestions(javaProject, identifier, 0, names)[0];
	}

	/** 
	 * Create a fresh type reference
	 * @param typeBinding the type we want to refer to
	 * @param ast AST for creating new nodes
	 * @param imports use this for optimal type names
	 * @return a fully features non-null type reference (can be parameterized and/or array).
	 */
	public static Type newType(ITypeBinding typeBinding, AST ast, ImportRewrite imports) {
		// unwrap array type:
		int dimensions= typeBinding.getDimensions();
		if (dimensions > 0)
			typeBinding= typeBinding.getElementType();
		
		// unwrap parameterized type:
		ITypeBinding[] typeArguments= typeBinding.getTypeArguments();
		typeBinding= typeBinding.getErasure();	

		// create leaf type:
		Type elementType = (typeBinding.isPrimitive())
					? ast.newPrimitiveType(PrimitiveType.toCode(typeBinding.getName()))
					: ast.newSimpleType(ast.newName(imports.addImport(typeBinding)));

		// re-wrap as parameterized type:
		if (typeArguments.length > 0) {
			ParameterizedType parameterizedType= ast.newParameterizedType(elementType);
			for (ITypeBinding typeArgument : typeArguments)
				parameterizedType.typeArguments().add(newType(typeArgument, ast, imports));
			elementType = parameterizedType;
		}
		
		// re-wrap as array type:
		if (dimensions > 0)
			return ast.newArrayType(elementType, dimensions);
		else
			return elementType;
	}
}

Lines 20-25 public class NullFixMessages extends NLS { Link Here

(-)a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/NullFixMessages.java (+5 lines)
20	public static String NullAnnotationsCleanUp_add_nullable_annotation;	20	public static String NullAnnotationsCleanUp_add_nullable_annotation;
21	public static String NullAnnotationsCleanUp_add_nonnull_annotation;	21	public static String NullAnnotationsCleanUp_add_nonnull_annotation;
22		22
		23	public static String NullQuickFixes_extractCheckedLocal_editName;
		24	public static String NullQuickFixes_extractToCheckedLocal_proposalName;
		25
		26	public static String NullQuickFixes_todoHandleNullDescription;
		27
23	public static String QuickFixes_add_annotation_change_name;	28	public static String QuickFixes_add_annotation_change_name;
24	public static String QuickFixes_change_method_parameter_nullness;	29	public static String QuickFixes_change_method_parameter_nullness;
25	public static String QuickFixes_change_method_return_nullness;	30	public static String QuickFixes_change_method_return_nullness;

Lines 11-16 Link Here

(-)a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/NullFixMessages.properties (+4 lines)
11	###############################################################################	11	###############################################################################
12	NullAnnotationsCleanUp_add_nullable_annotation=Add missing @Nullable annotation	12	NullAnnotationsCleanUp_add_nullable_annotation=Add missing @Nullable annotation
13	NullAnnotationsCleanUp_add_nonnull_annotation=Add missing @NonNull annotation	13	NullAnnotationsCleanUp_add_nonnull_annotation=Add missing @NonNull annotation
		14	NullQuickFixes_extractCheckedLocal_editName=Extract checked local
		15	NullQuickFixes_extractToCheckedLocal_proposalName=Extract to checked local variable
		16	NullQuickFixes_todoHandleNullDescription=handle null value
		17
14	QuickFixes_add_annotation_change_name=Add Annotations	18	QuickFixes_add_annotation_change_name=Add Annotations
15	QuickFixes_change_method_parameter_nullness=Change parameter type to ''@{0}''	19	QuickFixes_change_method_parameter_nullness=Change parameter type to ''@{0}''
16	QuickFixes_change_method_return_nullness=Change return type of ''{0}(..)'' to ''@{1}''	20	QuickFixes_change_method_return_nullness=Change return type of ''{0}(..)'' to ''@{1}''

Lines 29-34 import org.eclipse.jdt.core.dom.ASTNode; Link Here

(-)a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/fix/NullQuickFixes.java (+22 lines)
29	import org.eclipse.jdt.core.dom.CompilationUnit;	29	import org.eclipse.jdt.core.dom.CompilationUnit;
30	import org.eclipse.jdt.core.dom.IBinding;	30	import org.eclipse.jdt.core.dom.IBinding;
31	import org.eclipse.jdt.core.dom.IVariableBinding;	31	import org.eclipse.jdt.core.dom.IVariableBinding;
		32	import org.eclipse.jdt.core.dom.Initializer;
		33	import org.eclipse.jdt.core.dom.MethodDeclaration;
32	import org.eclipse.jdt.core.dom.SimpleName;	34	import org.eclipse.jdt.core.dom.SimpleName;
33	import org.eclipse.jdt.core.dom.VariableDeclaration;	35	import org.eclipse.jdt.core.dom.VariableDeclaration;
34		36
Lines 271-274 public class NullQuickFixes { Link Here
271	return qualifiedName.substring(lastDot + 1);	273	return qualifiedName.substring(lastDot + 1);
272	return qualifiedName;	274	return qualifiedName;
273	}	275	}
		276
		277	/**
		278	* Fix for {@link IProblem#NullableFieldReference}
		279	* @param context context
		280	* @param problem problem to be fixed
		281	* @param proposals accumulator for computed proposals
		282	*/
		283	public static void addExtractCheckedLocalProposal(IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
		284	CompilationUnit compilationUnit = context.getASTRoot();
		285	ICompilationUnit cu= (ICompilationUnit) compilationUnit.getJavaElement();
		286
		287	ASTNode selectedNode= problem.getCoveringNode(compilationUnit);
		288	if (selectedNode instanceof SimpleName) {
		289	ASTNode method= ASTNodes.getParent(selectedNode, MethodDeclaration.class);
		290	if (method == null)
		291	method= ASTNodes.getParent(selectedNode, Initializer.class);
		292	if (method != null)
		293	proposals.add(new ExtractToNullCheckedLocalProposal(cu, compilationUnit, (SimpleName) selectedNode, method));
		294	}
		295	}
274	}	296	}

Lines 246-251 public class QuickFixProcessor implements IQuickFixProcessor { Link Here

(-)a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/correction/QuickFixProcessor.java (+4 lines)
246	case IProblem.ParameterLackingNullableAnnotation:	246	case IProblem.ParameterLackingNullableAnnotation:
247	case IProblem.NonNullLocalVariableComparisonYieldsFalse:	247	case IProblem.NonNullLocalVariableComparisonYieldsFalse:
248	case IProblem.RedundantNullCheckOnNonNullLocalVariable:	248	case IProblem.RedundantNullCheckOnNonNullLocalVariable:
		249	case IProblem.NullableFieldReference:
249	return true;	250	return true;
250	default:	251	default:
251	return SuppressWarningsSubProcessor.hasSuppressWarningsProposal(cu.getJavaProject(), problemId);	252	return SuppressWarningsSubProcessor.hasSuppressWarningsProposal(cu.getJavaProject(), problemId);
Lines 689-694 public class QuickFixProcessor implements IQuickFixProcessor { Link Here
689	case IProblem.RedundantNullCheckOnNonNullLocalVariable:	690	case IProblem.RedundantNullCheckOnNonNullLocalVariable:
690	NullQuickFixes.addReturnAndArgumentTypeProposal(context, problem, proposals);	691	NullQuickFixes.addReturnAndArgumentTypeProposal(context, problem, proposals);
691	break;	692	break;
		693	case IProblem.NullableFieldReference:
		694	NullQuickFixes.addExtractCheckedLocalProposal(context, problem, proposals);
		695	break;
692	default:	696	default:
693	}	697	}
694	if (JavaModelUtil.is50OrHigher(context.getCompilationUnit().getJavaProject())) {	698	if (JavaModelUtil.is50OrHigher(context.getCompilationUnit().getJavaProject())) {

Return to bug 337977

Line 0 Link Here

(-)a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/NullAnnotationQuickFixTest.java (+474 lines)
		1	/*******************************************************************************
		2	* Copyright (c) 2012 GK Software AG and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Stephan Herrmann - initial API and implementation
		10	*******************************************************************************/
		11	package org.eclipse.jdt.ui.tests.quickfix;
		12
		13	import java.io.File;
		14	import java.util.ArrayList;
		15	import java.util.Hashtable;
		16
		17	import junit.framework.Test;
		18	import junit.framework.TestSuite;
		19
		20	import org.eclipse.jdt.testplugin.JavaProjectHelper;
		21	import org.eclipse.jdt.testplugin.TestOptions;
		22
		23	import org.eclipse.core.runtime.FileLocator;
		24	import org.eclipse.core.runtime.Path;
		25	import org.eclipse.core.runtime.Platform;
		26
		27	import org.eclipse.jface.preference.IPreferenceStore;
		28
		29	import org.eclipse.jdt.core.ICompilationUnit;
		30	import org.eclipse.jdt.core.IJavaProject;
		31	import org.eclipse.jdt.core.IPackageFragment;
		32	import org.eclipse.jdt.core.IPackageFragmentRoot;
		33	import org.eclipse.jdt.core.JavaCore;
		34	import org.eclipse.jdt.core.dom.CompilationUnit;
		35	import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
		36
		37	import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility;
		38	import org.eclipse.jdt.internal.corext.template.java.CodeTemplateContextType;
		39
		40	import org.eclipse.jdt.ui.PreferenceConstants;
		41	import org.eclipse.jdt.ui.tests.core.ProjectTestSetup;
		42	import org.eclipse.jdt.ui.text.java.correction.CUCorrectionProposal;
		43
		44	import org.eclipse.jdt.internal.ui.JavaPlugin;
		45
		46	public class NullAnnotationQuickFixTest extends QuickFixTest {
		47
		48	private static final Class THIS= NullAnnotationQuickFixTest.class;
		49
		50	private IJavaProject fJProject1;
		51	private IPackageFragmentRoot fSourceFolder;
		52
		53	private String ANNOTATION_JAR_PATH;
		54
		55
		56	public NullAnnotationQuickFixTest(String name) {
		57	super(name);
		58	}
		59
		60	public static Test suite() {
		61	return setUpTest(new TestSuite(THIS));
		62	}
		63
		64	public static Test setUpTest(Test test) {
65	return new ProjectTestSetup(test);
66	}
67
68
69	protected void setUp() throws Exception {
70	Hashtable options= TestOptions.getDefaultOptions();
71	options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
72	options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");
73	options.put(DefaultCodeFormatterConstants.FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE, String.valueOf(99));
74	options.put(JavaCore.COMPILER_PB_STATIC_ACCESS_RECEIVER, JavaCore.ERROR);
75	options.put(JavaCore.COMPILER_PB_UNCHECKED_TYPE_OPERATION, JavaCore.IGNORE);
76	options.put(JavaCore.COMPILER_PB_MISSING_HASHCODE_METHOD, JavaCore.WARNING);
77	options.put(JavaCore.COMPILER_ANNOTATION_NULL_ANALYSIS, JavaCore.ENABLED);
78	options.put(JavaCore.COMPILER_PB_NULL_SPECIFICATION_VIOLATION, JavaCore.ERROR);
79	options.put(JavaCore.COMPILER_PB_NULL_REFERENCE, JavaCore.ERROR);
80	options.put(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE, JavaCore.WARNING);
81	options.put(JavaCore.COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT, JavaCore.WARNING);
82	options.put(JavaCore.COMPILER_PB_NULL_UNCHECKED_CONVERSION, JavaCore.WARNING);
83	options.put(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK, JavaCore.WARNING);
84
85	JavaCore.setOptions(options);
86
87	IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
88	store.setValue(PreferenceConstants.CODEGEN_ADD_COMMENTS, false);
89
90	StubUtility.setCodeTemplate(CodeTemplateContextType.CATCHBLOCK_ID, "", null);
91	StubUtility.setCodeTemplate(CodeTemplateContextType.CONSTRUCTORSTUB_ID, "", null);
92	StubUtility.setCodeTemplate(CodeTemplateContextType.METHODSTUB_ID, "", null);
93
94	fJProject1= ProjectTestSetup.getProject();
95
96	if (this.ANNOTATION_JAR_PATH == null) {
97	File bundleFile = FileLocator.getBundleFile(Platform.getBundle("org.eclipse.jdt.annotation"));
98	if (bundleFile.isDirectory())
99	this.ANNOTATION_JAR_PATH = bundleFile.getPath()+"/bin";
100	else
101	this.ANNOTATION_JAR_PATH = bundleFile.getPath();
102	}
103	JavaProjectHelper.addLibrary(fJProject1, new Path(ANNOTATION_JAR_PATH));
104
105
106	fSourceFolder= JavaProjectHelper.addSourceContainer(fJProject1, "src");
107	}
108
109
110	protected void tearDown() throws Exception {
111	JavaProjectHelper.clear(fJProject1, ProjectTestSetup.getDefaultClasspath());
112	}
113
114	// ==== Problem: dereferencing a @Nullable field
115	// ==== Fix: extract field access to a fresh local variable and add a null-check
116
117	// basic case
118	public void testExtractNullableField1() throws Exception {
119	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
120	StringBuffer buf= new StringBuffer();
121	buf.append("package test1;\n");
122	buf.append("import org.eclipse.jdt.annotation.*;\n");
123	buf.append("public class E {\n");
124	buf.append(" @Nullable String f;\n");
125	buf.append(" public void foo() {\n");
126	buf.append(" System.out.println(f.toUpperCase());\n");
127	buf.append(" }\n");
128	buf.append("}\n");
129	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
130
131	CompilationUnit astRoot= getASTRoot(cu);
132	ArrayList proposals= collectCorrections(cu, astRoot);
133	assertNumberOfProposals(proposals, 1);
134	assertCorrectLabels(proposals);
135
136	CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
137	String preview= getPreviewContent(proposal);
138
139	buf= new StringBuffer();
140	buf.append("package test1;\n");
141	buf.append("import org.eclipse.jdt.annotation.*;\n");
142	buf.append("public class E {\n");
143	buf.append(" @Nullable String f;\n");
144	buf.append(" public void foo() {\n");
145	buf.append(" String f2 = f;\n");
146	buf.append(" if (f2 != null) {\n");
147	buf.append(" System.out.println(f2.toUpperCase());\n");
148	buf.append(" } else {\n");
149	buf.append(" // TODO handle null value\n");
150	buf.append(" }\n");
151	buf.append(" }\n");
152	buf.append("}\n");
153	assertEqualString(preview, buf.toString());
154	}
155
156	// statement is not element of a block - need to create a new block - local name f2 already in use
157	public void testExtractNullableField2() throws Exception {
158	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
159	StringBuffer buf= new StringBuffer();
160	buf.append("package test1;\n");
161	buf.append("import org.eclipse.jdt.annotation.*;\n");
162	buf.append("public class E {\n");
163	buf.append(" @Nullable String f;\n");
164	buf.append(" public void foo(boolean b) {\n");
165	buf.append(" @SuppressWarnings(\"unused\") boolean f2 = false;\n");
166	buf.append(" if (b)\n");
167	buf.append(" System.out.println(f.toUpperCase());\n");
168	buf.append(" }\n");
169	buf.append("}\n");
170	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
171
172	CompilationUnit astRoot= getASTRoot(cu);
173	ArrayList proposals= collectCorrections(cu, astRoot);
174	assertNumberOfProposals(proposals, 1);
175	assertCorrectLabels(proposals);
176
177	CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
178	String preview= getPreviewContent(proposal);
179
180	buf= new StringBuffer();
181	buf.append("package test1;\n");
182	buf.append("import org.eclipse.jdt.annotation.*;\n");
183	buf.append("public class E {\n");
184	buf.append(" @Nullable String f;\n");
185	buf.append(" public void foo(boolean b) {\n");
186	buf.append(" @SuppressWarnings(\"unused\") boolean f2 = false;\n");
187	buf.append(" if (b) {\n");
188	buf.append(" String f3 = f;\n");
189	buf.append(" if (f3 != null) {\n");
190	buf.append(" System.out.println(f3.toUpperCase());\n");
191	buf.append(" } else {\n");
192	buf.append(" // TODO handle null value\n");
193	buf.append(" }\n");
194	buf.append(" }\n");
195	buf.append(" }\n");
196	buf.append("}\n");
197	assertEqualString(preview, buf.toString());
198	}
199
200	// field name is part of a qualified field reference - inside a return statement (type: int)
201	public void testExtractNullableField3() throws Exception {
202	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
203	StringBuffer buf= new StringBuffer();
204	buf.append("package test1;\n");
205	buf.append("import org.eclipse.jdt.annotation.*;\n");
206	buf.append("public class E {\n");
207	buf.append(" @Nullable E other;\n");
208	buf.append(" int f;\n");
209	buf.append(" public int foo(E that) {\n");
210	buf.append(" return that.other.f;\n");
211	buf.append(" }\n");
212	buf.append("}\n");
213	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
214
215	CompilationUnit astRoot= getASTRoot(cu);
216	ArrayList proposals= collectCorrections(cu, astRoot);
217	assertNumberOfProposals(proposals, 1);
218	assertCorrectLabels(proposals);
219
220	CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
221	String preview= getPreviewContent(proposal);
222
223	buf= new StringBuffer();
224	buf.append("package test1;\n");
225	buf.append("import org.eclipse.jdt.annotation.*;\n");
226	buf.append("public class E {\n");
227	buf.append(" @Nullable E other;\n");
228	buf.append(" int f;\n");
229	buf.append(" public int foo(E that) {\n");
230	buf.append(" E other2 = that.other;\n");
231	buf.append(" if (other2 != null) {\n");
232	buf.append(" return other2.f;\n");
233	buf.append(" } else {\n");
234	buf.append(" // TODO handle null value\n");
235	buf.append(" return 0;\n");
236	buf.append(" }\n");
237	buf.append(" }\n");
238	buf.append("}\n");
239	assertEqualString(preview, buf.toString());
240	}
241
242	// field name is part of a this-qualified field reference - inside a return statement (type: String)
243	public void testExtractNullableField4() throws Exception {
244	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
245	StringBuffer buf= new StringBuffer();
246	buf.append("package test1;\n");
247	buf.append("import org.eclipse.jdt.annotation.*;\n");
248	buf.append("public class E {\n");
249	buf.append(" @Nullable E other;\n");
250	buf.append(" @Nullable String f;\n");
251	buf.append(" public String foo() {\n");
252	buf.append(" return this.other.f;\n");
253	buf.append(" }\n");
254	buf.append("}\n");
255	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
256
257	CompilationUnit astRoot= getASTRoot(cu);
258	ArrayList proposals= collectCorrections(cu, astRoot);
259	assertNumberOfProposals(proposals, 1);
260	assertCorrectLabels(proposals);
261
262	CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
263	String preview= getPreviewContent(proposal);
264
265	buf= new StringBuffer();
266	buf.append("package test1;\n");
267	buf.append("import org.eclipse.jdt.annotation.*;\n");
268	buf.append("public class E {\n");
269	buf.append(" @Nullable E other;\n");
270	buf.append(" @Nullable String f;\n");
271	buf.append(" public String foo() {\n");
272	buf.append(" E other2 = this.other;\n");
273	buf.append(" if (other2 != null) {\n");
274	buf.append(" return other2.f;\n");
275	buf.append(" } else {\n");
276	buf.append(" // TODO handle null value\n");
277	buf.append(" return null;\n");
278	buf.append(" }\n");
279	buf.append(" }\n");
280	buf.append("}\n");
281	assertEqualString(preview, buf.toString());
282	}
283
284	// field referenced inside the rhs of an assignment-as-expression
285	public void testExtractNullableField5() throws Exception {
286	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
287	StringBuffer buf= new StringBuffer();
288	buf.append("package test1;\n");
289	buf.append("import org.eclipse.jdt.annotation.*;\n");
290	buf.append("public class E {\n");
291	buf.append(" @Nullable E other;\n");
292	buf.append(" @Nullable String f;\n");
293	buf.append(" public void foo() {\n");
294	buf.append(" String lo;\n");
295	buf.append(" if ((lo = this.other.f) != null)\n");
296	buf.append(" System.out.println(lo);\n");
297	buf.append(" }\n");
298	buf.append("}\n");
299	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
300
301	CompilationUnit astRoot= getASTRoot(cu);
302	ArrayList proposals= collectCorrections(cu, astRoot);
303	assertNumberOfProposals(proposals, 1);
304	assertCorrectLabels(proposals);
305
306	CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
307	String preview= getPreviewContent(proposal);
308
309	buf= new StringBuffer();
310	buf.append("package test1;\n");
311	buf.append("import org.eclipse.jdt.annotation.*;\n");
312	buf.append("public class E {\n");
313	buf.append(" @Nullable E other;\n");
314	buf.append(" @Nullable String f;\n");
315	buf.append(" public void foo() {\n");
316	buf.append(" String lo;\n");
317	buf.append(" E other2 = this.other;\n");
318	buf.append(" if (other2 != null) {\n");
319	buf.append(" if ((lo = other2.f) != null)\n");
320	buf.append(" System.out.println(lo);\n");
321	buf.append(" } else {\n");
322	buf.append(" // TODO handle null value\n");
323	buf.append(" }\n");
324	buf.append(" }\n");
325	buf.append("}\n");
326	assertEqualString(preview, buf.toString());
327	}
328
329	// reference to field of array type - dereferenced by f[0] and f.length
330	public void testExtractNullableField6() throws Exception {
331	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
332	StringBuffer buf= new StringBuffer();
333	buf.append("package test1;\n");
334	buf.append("import org.eclipse.jdt.annotation.*;\n");
335	buf.append("public class E {\n");
336	buf.append(" @Nullable String[] f1;\n");
337	buf.append(" @Nullable String[] f2;\n");
338	buf.append(" public void foo() {\n");
339	buf.append(" System.out.println(f1[0]);\n");
340	buf.append(" System.out.println(f2.length);\n");
341	buf.append(" }\n");
342	buf.append("}\n");
343	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
344
345	CompilationUnit astRoot= getASTRoot(cu);
346	ArrayList proposals= collectCorrections(cu, astRoot, 2, 0); // get correction for first of two problems
347	assertNumberOfProposals(proposals, 1);
348	assertCorrectLabels(proposals);
349
350	CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
351	String preview= getPreviewContent(proposal);
352
353	buf= new StringBuffer();
354	buf.append("package test1;\n");
355	buf.append("import org.eclipse.jdt.annotation.*;\n");
356	buf.append("public class E {\n");
357	buf.append(" @Nullable String[] f1;\n");
358	buf.append(" @Nullable String[] f2;\n");
359	buf.append(" public void foo() {\n");
360	buf.append(" String[] f12 = f1;\n");
361	buf.append(" if (f12 != null) {\n");
362	buf.append(" System.out.println(f12[0]);\n");
363	buf.append(" } else {\n");
364	buf.append(" // TODO handle null value\n");
365	buf.append(" }\n");
366	buf.append(" System.out.println(f2.length);\n");
367	buf.append(" }\n");
368	buf.append("}\n");
369	assertEqualString(preview, buf.toString());
370
371	proposals= collectCorrections(cu, astRoot, 2, 1); // get correction for second of two problems
372	assertNumberOfProposals(proposals, 1);
373	proposal= (CUCorrectionProposal) proposals.get(0);
374	preview= getPreviewContent(proposal);
375
376	buf= new StringBuffer();
377	buf.append("package test1;\n");
378	buf.append("import org.eclipse.jdt.annotation.*;\n");
379	buf.append("public class E {\n");
380	buf.append(" @Nullable String[] f1;\n");
381	buf.append(" @Nullable String[] f2;\n");
382	buf.append(" public void foo() {\n");
383	buf.append(" System.out.println(f1[0]);\n");
384	buf.append(" String[] f22 = f2;\n");
385	buf.append(" if (f22 != null) {\n");
386	buf.append(" System.out.println(f22.length);\n");
387	buf.append(" } else {\n");
388	buf.append(" // TODO handle null value\n");
389	buf.append(" }\n");
390	buf.append(" }\n");
391	buf.append("}\n");
392	assertEqualString(preview, buf.toString());
393	}
394
395	// field has a generic type
396	public void testExtractNullableField7() throws Exception {
397	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
398	StringBuffer buf= new StringBuffer();
399	buf.append("package test1;\n");
400	buf.append("import org.eclipse.jdt.annotation.*;\n");
401	buf.append("import java.util.List;\n");
402	buf.append("public class E {\n");
403	buf.append(" @Nullable List<String> f;\n");
404	buf.append(" public void foo() {\n");
405	buf.append(" System.out.println(f.size());\n");
406	buf.append(" }\n");
407	buf.append("}\n");
408	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
409
410	CompilationUnit astRoot= getASTRoot(cu);
411	ArrayList proposals= collectCorrections(cu, astRoot);
412	assertNumberOfProposals(proposals, 1);
413	assertCorrectLabels(proposals);
414
415	CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
416	String preview= getPreviewContent(proposal);
417
418	buf= new StringBuffer();
419	buf.append("package test1;\n");
420	buf.append("import org.eclipse.jdt.annotation.*;\n");
421	buf.append("import java.util.List;\n");
422	buf.append("public class E {\n");
423	buf.append(" @Nullable List<String> f;\n");
424	buf.append(" public void foo() {\n");
425	buf.append(" List<String> f2 = f;\n");
426	buf.append(" if (f2 != null) {\n");
427	buf.append(" System.out.println(f2.size());\n");
428	buf.append(" } else {\n");
429	buf.append(" // TODO handle null value\n");
430	buf.append(" }\n");
431	buf.append(" }\n");
432	buf.append("}\n");
433	assertEqualString(preview, buf.toString());
434	}
435
436	// occurrences inside a class initializer
437	public void testExtractNullableField8() throws Exception {
438	IPackageFragment pack1= fSourceFolder.createPackageFragment("test1", false, null);
439	StringBuffer buf= new StringBuffer();
440	buf.append("package test1;\n");
441	buf.append("import org.eclipse.jdt.annotation.*;\n");
442	buf.append("public class E {\n");
443	buf.append(" @Nullable Exception e;\n");
444	buf.append(" {\n");
445	buf.append(" e.printStackTrace();\n");
446	buf.append(" }\n");
447	buf.append("}\n");
448	ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
449
450	CompilationUnit astRoot= getASTRoot(cu);
451	ArrayList proposals= collectCorrections(cu, astRoot);
452	assertNumberOfProposals(proposals, 1);
453	assertCorrectLabels(proposals);
454
455	CUCorrectionProposal proposal= (CUCorrectionProposal) proposals.get(0);
456	String preview= getPreviewContent(proposal);
457
458	buf= new StringBuffer();
459	buf.append("package test1;\n");
460	buf.append("import org.eclipse.jdt.annotation.*;\n");
461	buf.append("public class E {\n");
462	buf.append(" @Nullable Exception e;\n");
463	buf.append(" {\n");
464	buf.append(" Exception e2 = e;\n");
465	buf.append(" if (e2 != null) {\n");
466	buf.append(" e2.printStackTrace();\n");
467	buf.append(" } else {\n");
468	buf.append(" // TODO handle null value\n");
469	buf.append(" }\n");
470	buf.append(" }\n");
471	buf.append("}\n");
472	assertEqualString(preview, buf.toString());
473	}
474	}