Attachment #210478 for bug #368546

View | Details | Raw Unified | Return to bug 368546
Collapse All | Expand All




public class ResourceLeakTests extends AbstractRegressionTest {

static {
//	TESTS_NAMES = new String[] { "test074"};
//	TESTS_NUMBERS = new int[] { 50 };
//	TESTS_RANGE = new int[] { 11, -1 };
}

			"        final FileReader reader23 = new FileReader(\"file\");\n" +
			"        provider = new ResourceProvider() {\n" +
			"            public FileReader provide() {\n" +
			"                return reader23;\n" + // responsibility now lies at the caller of this method
			"            }\n" +
			"        };\n" +
			"    }\n" +

		"	final FileReader reader31 = new FileReader(\"file\");\n" +
		"	                 ^^^^^^^^\n" +
		"Potential resource leak: 'reader31' may not be closed\n" +
		"----------\n" +
		"2. WARNING in X.java (at line 17)\n" +
		"	final FileReader reader23 = new FileReader(\"file\");\n" +
		"	                 ^^^^^^^^\n" +
		"Potential resource leak: 'reader23' may not be closed\n" +
		"----------\n",
		null,
		true,

			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 18)\n" +
		"	return wc.open(getObjectId(), type).openStream();\n" +
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		"Resource leak: \'in\' is not closed at this location\n" +
		"----------\n" +
		"2. ERROR in X.java (at line 18)\n" +
		"	return new ObjectStream.Filter(type, size, in);\n" +
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		"Potential resource leak: \'in\' may not be closed at this location\n" +

		true,
		options);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// example from comment 3
public void test064() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(new String[] {
		"Test064.java",
		"import java.io.*;\n" +
		"public class Test064 {\n" +
		"    void foo(File outfile) {\n" + 
		"        OutputStream out= System.out;\n" + 
		"        if (outfile != null) {\n" + 
		"            try {\n" + 
		"                out = new FileOutputStream(outfile);\n" + 
		"            } catch (java.io.IOException e) {\n" + 
		"                throw new RuntimeException(e);\n" + 
		"            }\n" + 
		"        }\n" + 
		"        setOutput(out);\n" + 
		"    }\n" + 
		"    private void setOutput(OutputStream out) { }\n" +
		"}\n"
	},
	"",
	null,
	true,
	null,
	options,
	null);
}
// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// example from comment 10
// disabled, because basic null-analysis machinery doesn't support this pattern
// see also Bug 370424 - [compiler][null] throw-catch analysis for null flow could be more precise
public void _test065() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runConformTest(new String[] {
		"Test065.java",
		"import java.io.*;\n" +
		"class MyException extends Exception{}\n" + 
		"public class Test065 {\n" +
		"	void foo(String fileName) throws IOException, MyException {\n" + 
		"		FileReader       fileRead   = new FileReader(fileName);\n" + 
		"		BufferedReader   bufRead    = new BufferedReader(fileRead);\n" + 
		"		LineNumberReader lineReader = new LineNumberReader(bufRead);\n" + 
		"		try {\n" + 
		"		while (lineReader.readLine() != null) {\n" + 
		"			bufRead.close();\n" + 
		"			callSome();  // only this can throw MyException\n" + 
		"		}\n" + 
		"		} catch (MyException e) {\n" + 
		"			throw e;  // Pot. leak reported here\n" + 
		"		}\n" + 
		"		bufRead.close(); \n" + 
		"	}\n" + 
		"	private void callSome() throws MyException\n" + 
		"	{\n" + 
		"		\n" + 
		"	}\n" + 
		"}\n"
	},
	"",
	null,
	true,
	null,
	options,
	null);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// example from comment 11
public void test066() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runNegativeTest(new String[] {
		"Test066.java",
		"import java.io.*;\n" +
		"class MyException extends Exception{}\n" + 
		"public class Test066 {\n" +
		"    void countFileLines(String fileName) throws IOException {\n" + 
		"		FileReader       fileRead   = new FileReader(fileName);\n" + 
		"		BufferedReader   bufRead    = new BufferedReader(fileRead);\n" + 
		"		LineNumberReader lineReader = new LineNumberReader(bufRead);\n" + 
		"		while (lineReader.readLine() != null) {\n" + 
		"			if (lineReader.markSupported())\n" +
		"               throw new IOException();\n" + 
		"			bufRead.close();\n" + 
		"		}\n" + 
		"		bufRead.close();\n" + 
		"	}\n" + 
		"}\n"
	},
	"----------\n" + 
	"1. ERROR in Test066.java (at line 10)\n" + 
	"	throw new IOException();\n" + 
	"	^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
	"Resource leak: \'lineReader\' is not closed at this location\n" + 
	"----------\n",
	null,
	true,
	options);
}
// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// example from comment 11 - variant with closing top-level resource 
public void test066b() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runNegativeTest(new String[] {
		"Test066.java",
		"import java.io.*;\n" +
		"class MyException extends Exception{}\n" + 
		"public class Test066 {\n" +
		"    void countFileLines(String fileName) throws IOException {\n" + 
		"		FileReader       fileRead   = new FileReader(fileName);\n" + 
		"		BufferedReader   bufRead    = new BufferedReader(fileRead);\n" + 
		"		LineNumberReader lineReader = new LineNumberReader(bufRead);\n" + 
		"		while (lineReader.readLine() != null) {\n" + 
		"			if (lineReader.markSupported())\n" +
		"               throw new IOException();\n" + 
		"			lineReader.close();\n" + 
		"		}\n" + 
		"		lineReader.close();\n" + 
		"	}\n" + 
		"}\n"
	},
	"----------\n" + 
	"1. ERROR in Test066.java (at line 10)\n" + 
	"	throw new IOException();\n" + 
	"	^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
	"Potential resource leak: \'lineReader\' may not be closed at this location\n" + 
	"----------\n",
	null,
	true,
	options);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// example from comment 12
// disabled because null info after try-catch is too weak,
// see also Bug 370424 - [compiler][null] throw-catch analysis for null flow could be more precise
public void _test067() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runConformTest(new String[] {
		"Test067.java",
		"import java.io.*;\n" +
		"public class Test067 {\n" +
		"	public void comment12() throws IOException {\n" + 
		"    	LineNumberReader o = null;\n" + 
		"    	try {\n" + 
		"    		o = new LineNumberReader(null);    		\n" + 
		"    	} catch (NumberFormatException e) {    		\n" + 
		"    	}\n" + 
		"    }\n" + 
		"}\n"
	},
	"",
	null,
	true,
	null,
	options,
	null);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// example from comment 12
// disabled because null info after try-catch is too weak,
// see also Bug 370424 - [compiler][null] throw-catch analysis for null flow could be more precise
public void _test067b() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runConformTest(new String[] {
		"Test067.java",
		"import java.io.*;\n" +
		"public class Test067 {\n" +
		"	public void comment12b() throws IOException {\n" + 
		"		LineNumberReader o = new LineNumberReader(null);\n" + 
		"    	try {\n" + 
		"    		o.close();\n" + 
		"    	} catch (NumberFormatException e) {\n" + 
		"    	}\n" + 
		"    }\n" + 
		"}\n"
	},
	"",
	null,
	true,
	null,
	options,
	null);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// example from comment 13
public void test068() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runConformTest(new String[] {
		"Test068.java",
		"import java.io.*;\n" +
		"public class Test068 {\n" +
		"	class ProcessingStep extends OutputStream {\n" + 
		"		public void write(int b) throws IOException {}\n" + 
		"		public OutputStream getDestination() { return null; }\n" + 
		"	}\n" + 
		"	class ArtifactOutputStream  extends OutputStream {\n" + 
		"		public void write(int b) throws IOException {}\n" + 
		"	}" +
		"	ArtifactOutputStream comment13(OutputStream stream) {\n" + 
		"		OutputStream current = stream;\n" + 
		"		while (current instanceof ProcessingStep)\n" + 
		"			current = ((ProcessingStep) current).getDestination(); //warning\n" + 
		"		if (current instanceof ArtifactOutputStream)\n" + 
		"			return (ArtifactOutputStream) current;\n" + 
		"		return null;\n" + 
		"	}\n" + 
		"}\n"
	},
	"",
	null,
	true,
	null,
	options,
	null);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// example from comment 16
public void test069() {
	if (this.complianceLevel < ClassFileConstants.JDK1_5) return; // generics used
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runConformTest(new String[] {
		"Test069.java",
		"import java.io.*;\n" +
		"import java.util.Collection;\n" +
		"public class Test069 {\n" +
		"	class Profile {}\n" + 
		"	class CoreException extends Exception {}\n" + 
		"	void writeProfilesToStream(Collection<Profile> p, OutputStream s, String enc) {}\n" + 
		"	CoreException createException(IOException ioex, String message) { return new CoreException(); }\n" + 
		"	public void comment16(Collection<Profile> profiles, File file, String encoding) throws CoreException {\n" + 
		"		final OutputStream stream;\n" + 
		"		try {\n" + 
		"			stream= new FileOutputStream(file);\n" + 
		"			try {\n" + 
		"				writeProfilesToStream(profiles, stream, encoding);\n" + 
		"			} finally {\n" + 
		"				try { stream.close(); } catch (IOException e) { /* ignore */ }\n" + 
		"			}\n" + 
		"		} catch (IOException e) {\n" + 
		"			throw createException(e, \"message\"); // should not shout here\n" + 
		"		}\n" + 
		"	}\n" + 
		"}\n"
	},
	"",
	null,
	true,
	null,
	options,
	null);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// referenced in array initializer 
public void test070() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runNegativeTest(new String[] {
		"Test070.java",
		"import java.io.*;\n" +
		"public class Test070 {\n" +
		"    void storeInArray(String fileName) throws IOException {\n" + 
		"		FileReader       fileRead   = new FileReader(fileName);\n" + 
		"		closeThemAll(new FileReader[] { fileRead });\n" + 
		"	}\n" +
		"   void closeThemAll(FileReader[] readers) { }\n" + 
		"}\n"
	},
	"----------\n" + 
	"1. ERROR in Test070.java (at line 4)\n" + 
	"	FileReader       fileRead   = new FileReader(fileName);\n" + 
	"	                 ^^^^^^^^\n" + 
	"Potential resource leak: \'fileRead\' may not be closed\n" + 
	"----------\n",
	null,
	true,
	options);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// referenced in array initializer 
public void test071() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runNegativeTest(new String[] {
		"Test071.java",
		"import java.io.*;\n" +
		"public class Test071 {\n" +
		"    class ReaderHolder {\n" + 
		"		FileReader reader;\n" + 
		"	}\n" + 
		"	private FileReader getReader() {\n" + 
		"		return null;\n" + 
		"	}\n" + 
		"	void invokeCompiler(ReaderHolder readerHolder, boolean flag) throws FileNotFoundException {\n" + 
		"		FileReader reader = readerHolder.reader;\n" + 
		"		if (reader == null)\n" + 
		"			reader = getReader();\n" + 
		"		try {\n" + 
		"			return;\n" + 
		"		} finally {\n" + 
		"			try {\n" + 
		"				if (flag)\n" + 
		"					reader.close();\n" + 
		"			} catch (IOException e) {\n" + 
		"				// nop\n" + 
		"			}\n" + 
		"		}\n" + 
		"	}\n" + 
		"}\n"
	},
	"----------\n" + 
	"1. ERROR in Test071.java (at line 14)\n" + 
	"	return;\n" + 
	"	^^^^^^^\n" + 
	"Potential resource leak: \'reader\' may not be closed at this location\n" + 
	"----------\n",
	null,
	true,
	options);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// referenced in array initializer
// disabled because it would require correlation analysis between the tracking variable and its original
// need to pass to downstream: either (nonnull & open) or (null)
public void _test071b() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runNegativeTest(new String[] {
		"Test071b.java",
		"import java.io.*;\n" +
		"public class Test071b {\n" +
		"   private FileReader getReader() {\n" + 
		"		return null;\n" + 
		"	}\n" + 
		"	void invokeCompiler(boolean flag) throws FileNotFoundException {\n" + 
		"		FileReader reader = null;\n" + 
		"		if (flag)\n" + 
		"			reader = new FileReader(\"file\");\n" + 
		"		if (reader == null)\n" + 
		"			reader = getReader();\n" + 
		"		try {\n" + 
		"			return;\n" + 
		"		} finally {\n" + 
		"			try {\n" + 
		"				if (flag)\n" + 
		"					reader.close();\n" + 
		"			} catch (IOException e) {\n" + 
		"				// nop\n" + 
		"			}\n" + 
		"		}\n" + 
		"	}\n" + 
		"}\n"
	},
	"----------\n" + 
	"1. ERROR in Test071.java (at line 14)\n" + 
	"	return;\n" + 
	"	^^^^^^^\n" + 
	"Potential resource leak: \'reader\' may not be closed at this location\n" + 
	"----------\n",
	null,
	true,
	options);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// throw inside loop inside try - while closed in finally
public void test072() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runConformTest(new String[] {
		"Test072.java",
		"import java.io.*;\n" +
		"public class Test072 {\n" +
		"   void readState(File file) {\n" + 
		"		DataInputStream in = null;\n" + 
		"		try {\n" + 
		"			in= new DataInputStream(new BufferedInputStream(new FileInputStream(file)));\n" + 
		"			int sizeOfFlags = in.readInt();\n" + 
		"			for (int i = 0; i < sizeOfFlags; ++i) {\n" + 
		"				String childPath = in.readUTF();\n" + 
		"				if (childPath.length() == 0)\n" + 
		"					throw new IOException();\n" + 
		"			}\n" + 
		"		}\n" + 
		"		catch (IOException ioe) { /* nop */ }\n" + 
		"		finally {\n" + 
		"			if (in != null) {\n" + 
		"				try {in.close();} catch (IOException ioe) {}\n" + 
		"			}\n" + 
		"		}\n" + 
		"	}\n" + 
		"}\n"
	},
	"",
	null,
	true,
	null,
	options,
	null);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// unspecific parameter is casted into a resource, yet need to mark as OWNED_BY_OUTSIDE
public void test073() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runConformTest(new String[] {
		"Test073.java",
		"import java.io.*;\n" +
		"public class Test073 {\n" +
		"   String getEncoding(Object reader) {\n" + 
		"		if (reader instanceof FileReader) {\n" + 
		"			final FileReader fr = (FileReader) reader;\n" + 
		"			return fr.getEncoding();\n" + 
		"		}\n" + 
		"		return null;\n" + 
		"	}\n" + 
		"}\n"
	},
	"",
	null,
	true,
	null,
	options,
	null);
}

// Bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
// status after nested try-finally
public void test074() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportMissingSerialVersion, CompilerOptions.IGNORE);
	this.runNegativeTest(new String[] {
		"Test074.java",
		"import java.io.*;\n" +
		"public class Test074 {\n" +
		"   void foo() throws FileNotFoundException {\n" + 
		"		FileOutputStream out = null;\n" + 
		"		try {\n" + 
		"			out = new FileOutputStream(\"outfile\");\n" + 
		"		} finally {\n" + 
		"			try {\n" + 
		"				out.flush();\n" + 
		"				out.close();\n" + 
		"			} catch (IOException e) {\n" + 
		"				e.printStackTrace();\n" + 
		"			}\n" + 
		"			out = null;\n" + // unclosed if exception occurred on flush()
		"		}\n" + 
		"	}\n" + 
		"}\n"
	},
	"----------\n" + 
	"1. ERROR in Test074.java (at line 14)\n" + 
	"	out = null;\n" + 
	"	^^^^^^^^^^\n" + 
	"Potential resource leak: \'out\' may not be closed at this location\n" + 
	"----------\n",
	null,
	true,
	options);
}
}

Lines 64-72 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, Fl Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (-3 / +5 lines)
64	analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);	64	analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);
65	}	65	}
66		66
67	if (FakedTrackingVariable.isAnyCloseable(this.resolvedType))
68	FakedTrackingVariable.analyseCloseableAllocation(currentScope, flowInfo, this);
69
70	// record some dependency information for exception types	67	// record some dependency information for exception types
71	ReferenceBinding[] thrownExceptions;	68	ReferenceBinding[] thrownExceptions;
72	if (((thrownExceptions = this.binding.thrownExceptions).length) != 0) {	69	if (((thrownExceptions = this.binding.thrownExceptions).length) != 0) {
Lines 81-86 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, Fl Link Here
81	flowInfo.unconditionalCopy(),	78	flowInfo.unconditionalCopy(),
82	currentScope);	79	currentScope);
83	}	80	}
		81
		82	// after having analysed exceptions above start tracking newly allocated resource:
		83	if (FakedTrackingVariable.isAnyCloseable(this.resolvedType))
		84	FakedTrackingVariable.analyseCloseableAllocation(currentScope, flowInfo, this);
		85
84	if (this.binding.declaringClass.isMemberType() && !this.binding.declaringClass.isStatic()) {	86	if (this.binding.declaringClass.isMemberType() && !this.binding.declaringClass.isStatic()) {
85	// allocating a non-static member type without an enclosing instance of parent type	87	// allocating a non-static member type without an enclosing instance of parent type
86	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=335845	88	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=335845

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ArrayInitializer.java (-1 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 34-39 public class ArrayInitializer extends Expression { Link Here
34	if (this.expressions != null) {	34	if (this.expressions != null) {
35	for (int i = 0, max = this.expressions.length; i < max; i++) {	35	for (int i = 0, max = this.expressions.length; i < max; i++) {
36	flowInfo = this.expressions[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();	36	flowInfo = this.expressions[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
		37
		38	if (FakedTrackingVariable.isAnyCloseable(this.expressions[i].resolvedType)) {
		39	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.expressions[i], flowInfo, false);
		40	}
37	}	41	}
38	}	42	}
39	return flowInfo;	43	return flowInfo;

Lines 39-45 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, Fl Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Block.java (-1 / +1 lines)
39	}	39	}
40		40
41	if (this.explicitDeclarations > 0) // if block has its own scope analyze tracking vars now:	41	if (this.explicitDeclarations > 0) // if block has its own scope analyze tracking vars now:
42	this.scope.checkUnclosedCloseables(flowInfo, null, null);	42	this.scope.checkUnclosedCloseables(flowInfo, flowContext, null, null);
43	return flowInfo;	43	return flowInfo;
44	}	44	}
45	/**	45	/**

Lines 177-183 public void analyseCode(ClassScope classScope, InitializationFlowContext initial Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ConstructorDeclaration.java (-1 / +1 lines)
177	constructorContext.complainIfUnusedExceptionHandlers(this);	177	constructorContext.complainIfUnusedExceptionHandlers(this);
178	// check unused parameters	178	// check unused parameters
179	this.scope.checkUnusedParameters(this.binding);	179	this.scope.checkUnusedParameters(this.binding);
180	this.scope.checkUnclosedCloseables(flowInfo, null/don't report against a specific location/, null);	180	this.scope.checkUnclosedCloseables(flowInfo, null, null/don't report against a specific location/, null);
181	} catch (AbortMethod e) {	181	} catch (AbortMethod e) {
182	this.ignoreFurtherInvestigation = true;	182	this.ignoreFurtherInvestigation = true;
183	}	183	}

Lines 109-114 public class FakedTrackingVariable extends LocalDeclaration { Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java (-6 / +55 lines)
109	scope.getJavaLangObject(), // dummy, just needs to be a reference type	109	scope.getJavaLangObject(), // dummy, just needs to be a reference type
110	0,	110	0,
111	false);	111	false);
		112	this.binding.closeTracker = this;
112	this.binding.declaringScope = scope;	113	this.binding.declaringScope = scope;
113	this.binding.setConstant(Constant.NotAConstant);	114	this.binding.setConstant(Constant.NotAConstant);
114	this.binding.useFlag = LocalVariableBinding.USED;	115	this.binding.useFlag = LocalVariableBinding.USED;
Lines 341-349 public class FakedTrackingVariable extends LocalDeclaration { Link Here
341	FakedTrackingVariable rhsTrackVar = getCloseTrackingVariable(rhs);	342	FakedTrackingVariable rhsTrackVar = getCloseTrackingVariable(rhs);
342	if (rhsTrackVar != null) { // 1. if RHS has a tracking variable...	343	if (rhsTrackVar != null) { // 1. if RHS has a tracking variable...
343	if (local.closeTracker == null) {	344	if (local.closeTracker == null) {
344	// null shouldn't occur but let's play safe	345	// null shouldn't occur but let's play safe:
345	if (rhsTrackVar.originalBinding != null)	346	if (rhsTrackVar.originalBinding != null)
346	local.closeTracker = rhsTrackVar; // a.: let fresh LHS share it	347	local.closeTracker = rhsTrackVar; // a.: let fresh LHS share it
		348	if (rhsTrackVar.currentAssignment == location) {
		349	// pre-set tracker from lhs - passed from outside?
		350	// now it's a fresh resource
		351	rhsTrackVar.globalClosingState &= ~(SHARED_WITH_OUTSIDE\|OWNED_BY_OUTSIDE);
		352	}
347	} else {	353	} else {
348	if (rhsTrackVar == disconnectedTracker && rhs instanceof AllocationExpression)	354	if (rhsTrackVar == disconnectedTracker && rhs instanceof AllocationExpression)
349	return; // b.: self wrapper: res = new Wrap(res); -> done!	355	return; // b.: self wrapper: res = new Wrap(res); -> done!
Lines 420-427 public class FakedTrackingVariable extends LocalDeclaration { Link Here
420	FakedTrackingVariable tracker = new FakedTrackingVariable(local, location);	426	FakedTrackingVariable tracker = new FakedTrackingVariable(local, location);
421	tracker.globalClosingState \|= SHARED_WITH_OUTSIDE;	427	tracker.globalClosingState \|= SHARED_WITH_OUTSIDE;
422	flowInfo.markPotentiallyNullBit(tracker.binding); // shed some doubt	428	flowInfo.markPotentiallyNullBit(tracker.binding); // shed some doubt
423	return tracker;	429	return tracker;
424	} else if ((expression.bits & RestrictiveFlagMASK) == Binding.FIELD)	430	} else if (
		431	(expression.bits & RestrictiveFlagMASK) == Binding.FIELD
		432	\|\|((expression instanceof QualifiedNameReference)
		433	&& ((QualifiedNameReference) expression).isFieldAccess()))
425	{	434	{
426	// responsibility for this resource probably lies at a higher level	435	// responsibility for this resource probably lies at a higher level
427	FakedTrackingVariable tracker = new FakedTrackingVariable(local, location);	436	FakedTrackingVariable tracker = new FakedTrackingVariable(local, location);
Lines 440-446 public class FakedTrackingVariable extends LocalDeclaration { Link Here
440	if (local.closeTracker != null)	449	if (local.closeTracker != null)
441	// (c): inner has already been analyzed: -> re-use track var	450	// (c): inner has already been analyzed: -> re-use track var
442	return local.closeTracker;	451	return local.closeTracker;
443	return new FakedTrackingVariable(local, location);	452	FakedTrackingVariable newTracker = new FakedTrackingVariable(local, location);
		453	LocalVariableBinding rhsLocal = expression.localVariableBinding();
		454	if (rhsLocal != null && rhsLocal.isParameter()) {
		455	newTracker.globalClosingState \|= OWNED_BY_OUTSIDE;
		456	}
		457	return newTracker;
444	}	458	}
445		459
446	public static void cleanUpAfterAssignment(BlockScope currentScope, int lhsBits, Expression expression) {	460	public static void cleanUpAfterAssignment(BlockScope currentScope, int lhsBits, Expression expression) {
Lines 631-636 public class FakedTrackingVariable extends LocalDeclaration { Link Here
631	return trackingVar;	645	return trackingVar;
632	}	646	}
633		647
		648	/**
		649	* Answer true if we know for sure that no resource is bound to this variable
		650	* at the point of 'flowInfo'.
		651	*/
		652	public boolean hasDefinitelyNoResource(FlowInfo flowInfo) {
		653	if (this.originalBinding == null) return false; // shouldn't happen but keep quiet.
		654	if (flowInfo.isDefinitelyNull(this.originalBinding)) {
		655	return true;
		656	}
		657	if (!(flowInfo.isDefinitelyAssigned(this.originalBinding)
		658	\|\| flowInfo.isPotentiallyAssigned(this.originalBinding))) {
		659	return true;
		660	}
		661	return false;
		662	}
		663
		664	public boolean isClosedInFinallyOfEnclosing(BlockScope scope) {
		665	BlockScope currentScope = scope;
		666	while (true) {
		667	if (currentScope.finallyInfo != null
		668	&& currentScope.finallyInfo.isDefinitelyNonNull(this.binding)) {
		669	return true; // closed in enclosing finally
		670	}
		671	if (!(currentScope.parent instanceof BlockScope)) {
		672	return false;
		673	}
		674	currentScope = (BlockScope) currentScope.parent;
		675	}
		676	}
634	/**	677	/**
635	* If current is the same as 'returnedResource' or a wrapper thereof,	678	* If current is the same as 'returnedResource' or a wrapper thereof,
636	* mark as reported and return true, otherwise false.	679	* mark as reported and return true, otherwise false.
Lines 648-653 public class FakedTrackingVariable extends LocalDeclaration { Link Here
648	}	691	}
649		692
650	public void recordErrorLocation(ASTNode location, int nullStatus) {	693	public void recordErrorLocation(ASTNode location, int nullStatus) {
		694	if ((this.globalClosingState & OWNED_BY_OUTSIDE) != 0) {
		695	return;
		696	}
651	if (this.recordedLocations == null)	697	if (this.recordedLocations == null)
652	this.recordedLocations = new HashMap();	698	this.recordedLocations = new HashMap();
653	this.recordedLocations.put(location, new Integer(nullStatus));	699	this.recordedLocations.put(location, new Integer(nullStatus));
Lines 684-695 public class FakedTrackingVariable extends LocalDeclaration { Link Here
684	}	730	}
685		731
686	public int reportError(ProblemReporter problemReporter, ASTNode location, int nullStatus) {	732	public int reportError(ProblemReporter problemReporter, ASTNode location, int nullStatus) {
		733	if ((this.globalClosingState & OWNED_BY_OUTSIDE) != 0) {
		734	return 0; // TODO: should we still propagate some flags??
		735	}
687	// which degree of problem?	736	// which degree of problem?
688	boolean isPotentialProblem = false;	737	boolean isPotentialProblem = false;
689	if (nullStatus == FlowInfo.NULL) {	738	if (nullStatus == FlowInfo.NULL) {
690	if ((this.globalClosingState & CLOSED_IN_NESTED_METHOD) != 0)	739	if ((this.globalClosingState & CLOSED_IN_NESTED_METHOD) != 0)
691	isPotentialProblem = true;	740	isPotentialProblem = true;
692	} else if (nullStatus == FlowInfo.POTENTIALLY_NULL) {	741	} else if ((nullStatus & (FlowInfo.POTENTIALLY_NULL\|FlowInfo.POTENTIALLY_NON_NULL)) != 0) {
693	isPotentialProblem = true;	742	isPotentialProblem = true;
694	}	743	}
695	// report:	744	// report:

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MethodDeclaration.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 139-145 public class MethodDeclaration extends AbstractMethodDeclaration { Link Here
139	}	139	}
140		140
141	}	141	}
142	this.scope.checkUnclosedCloseables(flowInfo, null/don't report against a specific location/, null);	142	this.scope.checkUnclosedCloseables(flowInfo, null, null/don't report against a specific location/, null);
143	} catch (AbortMethod e) {	143	} catch (AbortMethod e) {
144	this.ignoreFurtherInvestigation = true;	144	this.ignoreFurtherInvestigation = true;
145	}	145	}

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (-1 / +7 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 109-114 public class QualifiedAllocationExpression extends AllocationExpression { Link Here
109	flowInfo.unconditionalCopy(),	109	flowInfo.unconditionalCopy(),
110	currentScope);	110	currentScope);
111	}	111	}
		112
		113	// after having analysed exceptions above start tracking newly allocated resource:
		114	if (FakedTrackingVariable.isAnyCloseable(this.resolvedType)) {
		115	FakedTrackingVariable.analyseCloseableAllocation(currentScope, flowInfo, this);
		116	}
		117
112	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);	118	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
113	manageSyntheticAccessIfNecessary(currentScope, flowInfo);	119	manageSyntheticAccessIfNecessary(currentScope, flowInfo);
114	return flowInfo;	120	return flowInfo;

Lines 785-790 public TypeBinding getOtherFieldBindings(BlockScope scope) { Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java (+7 lines)
785	: type;	785	: type;
786	}	786	}
787		787
		788	public boolean isFieldAccess() {
		789	if (this.otherBindings != null) {
		790	return true;
		791	}
		792	return (this.bits & ASTNode.RestrictiveFlagMASK) == Binding.FIELD;
		793	}
		794
788	public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {	795	public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
789	//If inlinable field, forget the access emulation, the code gen will directly target it	796	//If inlinable field, forget the access emulation, the code gen will directly target it
790	if (((this.bits & ASTNode.DepthMASK) == 0) \|\| (this.constant != Constant.NotAConstant)) {	797	if (((this.bits & ASTNode.DepthMASK) == 0) \|\| (this.constant != Constant.NotAConstant)) {

Lines 129-135 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, Fl Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java (-1 / +1 lines)
129	}	129	}
130	}	130	}
131	}	131	}
132	currentScope.checkUnclosedCloseables(flowInfo, this, currentScope);	132	currentScope.checkUnclosedCloseables(flowInfo, flowContext, this, currentScope);
133	return FlowInfo.DEAD_END;	133	return FlowInfo.DEAD_END;
134	}	134	}
135	void checkAgainstNullAnnotation(BlockScope scope, FlowContext flowContext, int nullStatus) {	135	void checkAgainstNullAnnotation(BlockScope scope, FlowContext flowContext, int nullStatus) {




/*******************************************************************************
 * Copyright (c) 2000, 2012 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

			if (previousComplaintLevel < COMPLAINED_UNREACHABLE) {
				scope.problemReporter().unreachableCode(this);
				if (endOfBlock)
					scope.checkUnclosedCloseables(flowInfo, null, null, null);
			}
			return COMPLAINED_UNREACHABLE;
		} else {
			if (previousComplaintLevel < COMPLAINED_FAKE_REACHABLE) {
				scope.problemReporter().fakeReachable(this);
				if (endOfBlock)
					scope.checkUnclosedCloseables(flowInfo, null, null, null);
			}
			return COMPLAINED_FAKE_REACHABLE;
		}

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ThrowStatement.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 36-42 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, Fl Link Here
36	this.exception.checkNPE(currentScope, flowContext, flowInfo);	36	this.exception.checkNPE(currentScope, flowContext, flowInfo);
37	// need to check that exception thrown is actually caught somewhere	37	// need to check that exception thrown is actually caught somewhere
38	flowContext.checkExceptionHandlers(this.exceptionType, this, flowInfo, currentScope);	38	flowContext.checkExceptionHandlers(this.exceptionType, this, flowInfo, currentScope);
39	currentScope.checkUnclosedCloseables(flowInfo, this, currentScope);	39	currentScope.checkUnclosedCloseables(flowInfo, flowContext, this, currentScope);
40	return FlowInfo.DEAD_END;	40	return FlowInfo.DEAD_END;
41	}	41	}
42		42




	VariableBinding[] finalVariables;
	int assignCount;

	// the following three arrays are in sync regarding their indices:
	VariableBinding[] nullVariables;
	ASTNode[] nullReferences;	// Expressions for null checking, Statements for resource analysis
								// cast to Expression is safe if corresponding nullCheckType != EXIT_RESOURCE
	int[] nullCheckTypes;
	int nullCount;
	// see also the related field FlowContext#expectedTypes

	if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) { // within an enclosing loop, be conservative
		for (int i = 0; i < this.nullCount; i++) {
			if (this.nullCheckTypes[i] == ASSIGN_TO_NONNULL)
				this.parent.recordNullityMismatch(scope, (Expression)this.nullReferences[i],
						flowInfo.nullStatus(this.nullVariables[i]), this.expectedTypes[i]);
			else
				this.parent.recordUsingNullReference(scope, this.nullVariables[i],

	}
	else { // no enclosing loop, be as precise as possible right now
		for (int i = 0; i < this.nullCount; i++) {
			ASTNode location = this.nullReferences[i];
			// final local variable
			VariableBinding var = this.nullVariables[i];
			switch (this.nullCheckTypes[i]) {

					if (flowInfo.isDefinitelyNonNull(var)) {
						if (this.nullCheckTypes[i] == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableRedundantCheckOnNonNull(var, location);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNonNullComparedToNull(var, location);
							}
						}
						continue;

				case CAN_ONLY_NULL | IN_COMPARISON_NON_NULL:
				case CAN_ONLY_NULL | IN_ASSIGNMENT:
				case CAN_ONLY_NULL | IN_INSTANCEOF:
					Expression expression = (Expression) location;
					if (flowInfo.isDefinitelyNull(var)) {
						switch(this.nullCheckTypes[i] & CONTEXT_MASK) {
							case FlowContext.IN_COMPARISON_NULL:

					break;
				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(var)) {
						scope.problemReporter().variableNullReference(var, location);
						continue;
					}
					if (flowInfo.isPotentiallyNull(var)) {
						scope.problemReporter().variablePotentialNullReference(var, location);
					}
					break;
				case ASSIGN_TO_NONNULL:
					int nullStatus = flowInfo.nullStatus(var);
					if (nullStatus != FlowInfo.NON_NULL) {
						char[][] annotationName = scope.environment().getNonNullAnnotationName();
						scope.problemReporter().nullityMismatch((Expression) location, this.expectedTypes[i], nullStatus, annotationName);
					}
					break;
				default:

	}

	public void recordUsingNullReference(Scope scope, VariableBinding var,
			ASTNode location, int checkType, FlowInfo flowInfo) {
		if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0 && !flowInfo.isDefinitelyUnknown(var))	{
			if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) { // within an enclosing loop, be conservative
				switch (checkType) {

					case CAN_ONLY_NULL | IN_COMPARISON_NON_NULL:
					case CAN_ONLY_NULL | IN_ASSIGNMENT:
					case CAN_ONLY_NULL | IN_INSTANCEOF:
						Expression reference = (Expression) location;
						if (flowInfo.cannotBeNull(var)) {
							if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {

							return;
						}
						if (flowInfo.canOnlyBeNull(var)) {
							scope.problemReporter().variableNullReference(var, location);
							return;
						}
						break;

						if (flowInfo.isDefinitelyNonNull(var)) {
							if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableRedundantCheckOnNonNull(var, location);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {
									flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
								}
							} else {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableNonNullComparedToNull(var, location);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {
									flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);

					case CAN_ONLY_NULL | IN_COMPARISON_NON_NULL:
					case CAN_ONLY_NULL | IN_ASSIGNMENT:
					case CAN_ONLY_NULL | IN_INSTANCEOF:
						Expression reference = (Expression) location;
						if (flowInfo.isDefinitelyNull(var)) {
							switch(checkType & CONTEXT_MASK) {
								case FlowContext.IN_COMPARISON_NULL:

						break;
					case MAY_NULL :
						if (flowInfo.isDefinitelyNull(var)) {
							scope.problemReporter().variableNullReference(var, location);
							return;
						}
						if (flowInfo.isPotentiallyNull(var)) {
							scope.problemReporter().variablePotentialNullReference(var, location);
							return;
						}
						if (flowInfo.isDefinitelyNonNull(var)) {

			if(((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) || checkType == MAY_NULL
					|| (checkType & CONTEXT_MASK) == FlowContext.IN_ASSIGNMENT
					|| (checkType & CONTEXT_MASK) == FlowContext.IN_INSTANCEOF) {
				recordNullReference(var, location, checkType);
			}
			// prepare to re-check with try/catch flow info
		}

	}

protected void recordNullReference(VariableBinding var,
	ASTNode expression, int status) {
	if (this.nullCount == 0) {
		this.nullVariables = new VariableBinding[5];
		this.nullReferences = new Expression[5];

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FlowContext.java (-10 / +22 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 19-24 import org.eclipse.jdt.core.compiler.CharOperation; Link Here
19	import org.eclipse.jdt.internal.compiler.ast.ASTNode;	19	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
20	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;	20	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
21	import org.eclipse.jdt.internal.compiler.ast.Expression;	21	import org.eclipse.jdt.internal.compiler.ast.Expression;
		22	import org.eclipse.jdt.internal.compiler.ast.FakedTrackingVariable;
22	import org.eclipse.jdt.internal.compiler.ast.LabeledStatement;	23	import org.eclipse.jdt.internal.compiler.ast.LabeledStatement;
23	import org.eclipse.jdt.internal.compiler.ast.Reference;	24	import org.eclipse.jdt.internal.compiler.ast.Reference;
24	import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;	25	import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
Lines 74-79 public static final int CAN_ONLY_NON_NULL = 0x0002; Link Here
74	public static final int MAY_NULL = 0x0003;	75	public static final int MAY_NULL = 0x0003;
75	//check binding a value to a @NonNull variable	76	//check binding a value to a @NonNull variable
76	public final static int ASSIGN_TO_NONNULL = 0x0080;	77	public final static int ASSIGN_TO_NONNULL = 0x0080;
		78	//check against unclosed resource at early exit:
		79	public static final int EXIT_RESOURCE = 0x0800;
77	// check against null, with potential values -- NPE guard	80	// check against null, with potential values -- NPE guard
78	public static final int CHECK_MASK = 0x00FF;	81	public static final int CHECK_MASK = 0x00FF;
79	public static final int IN_COMPARISON_NULL = 0x0100;	82	public static final int IN_COMPARISON_NULL = 0x0100;
Lines 556-561 public void recordContinueFrom(FlowContext innerFlowContext, FlowInfo flowInfo) Link Here
556	// default implementation: do nothing	559	// default implementation: do nothing
557	}	560	}
558		561
		562	public boolean recordExitAgainstResource(BlockScope scope, FlowInfo flowInfo, FakedTrackingVariable trackingVar, ASTNode reference) {
		563	return false; // not handled
		564	}
		565
559	protected void recordExpectedType(TypeBinding expectedType, int nullCount) {	566	protected void recordExpectedType(TypeBinding expectedType, int nullCount) {
560	if (nullCount == 0) {	567	if (nullCount == 0) {
561	this.expectedTypes = new TypeBinding[5];	568	this.expectedTypes = new TypeBinding[5];
Lines 580-586 protected boolean recordFinalAssignment(VariableBinding variable, Reference fina Link Here
580	* Record a null reference for use by deferred checks. Only looping or	587	* Record a null reference for use by deferred checks. Only looping or
581	* finally contexts really record that information.	588	* finally contexts really record that information.
582	* @param local the local variable involved in the check	589	* @param local the local variable involved in the check
583	* @param expression the expression within which local lays	590	* @param location the location triggering the analysis, for normal null dereference
		591	* this is an expression resolving to 'local', for resource leaks it is an
		592	* early exit statement.
584	* @param status the status against which the check must be performed; one of	593	* @param status the status against which the check must be performed; one of
585	* {@link #CAN_ONLY_NULL CAN_ONLY_NULL}, {@link #CAN_ONLY_NULL_NON_NULL	594	* {@link #CAN_ONLY_NULL CAN_ONLY_NULL}, {@link #CAN_ONLY_NULL_NON_NULL
586	* CAN_ONLY_NULL_NON_NULL}, {@link #MAY_NULL MAY_NULL},	595	* CAN_ONLY_NULL_NON_NULL}, {@link #MAY_NULL MAY_NULL},
Lines 589-595 protected boolean recordFinalAssignment(VariableBinding variable, Reference fina Link Here
589	* {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})	598	* {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})
590	*/	599	*/
591	protected void recordNullReference(VariableBinding local,	600	protected void recordNullReference(VariableBinding local,
592	Expression expression, int status) {	601	ASTNode location, int status) {
593	// default implementation: do nothing	602	// default implementation: do nothing
594	}	603	}
595		604
Lines 620-626 public void recordSettingFinal(VariableBinding variable, Reference finalReferenc Link Here
620	* context).	629	* context).
621	* @param scope the scope into which the check is performed	630	* @param scope the scope into which the check is performed
622	* @param local the local variable involved in the check	631	* @param local the local variable involved in the check
623	* @param reference the expression within which local lies	632	* @param location the location triggering the analysis, for normal null dereference
		633	* this is an expression resolving to 'local', for resource leaks it is an
		634	* early exit statement.
624	* @param checkType the status against which the check must be performed; one	635	* @param checkType the status against which the check must be performed; one
625	* of {@link #CAN_ONLY_NULL CAN_ONLY_NULL}, {@link #CAN_ONLY_NULL_NON_NULL	636	* of {@link #CAN_ONLY_NULL CAN_ONLY_NULL}, {@link #CAN_ONLY_NULL_NON_NULL
626	* CAN_ONLY_NULL_NON_NULL}, {@link #MAY_NULL MAY_NULL}, potentially	637	* CAN_ONLY_NULL_NON_NULL}, {@link #MAY_NULL MAY_NULL}, potentially
Lines 632-638 public void recordSettingFinal(VariableBinding variable, Reference finalReferenc Link Here
632	* code that follows the current point)	643	* code that follows the current point)
633	*/	644	*/
634	public void recordUsingNullReference(Scope scope, VariableBinding local,	645	public void recordUsingNullReference(Scope scope, VariableBinding local,
635	Expression reference, int checkType, FlowInfo flowInfo) {	646	ASTNode location, int checkType, FlowInfo flowInfo) {
636	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 \|\|	647	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 \|\|
637	flowInfo.isDefinitelyUnknown(local)) {	648	flowInfo.isDefinitelyUnknown(local)) {
638	return;	649	return;
Lines 643-656 public void recordUsingNullReference(Scope scope, VariableBinding local, Link Here
643	if (flowInfo.isDefinitelyNonNull(local)) {	654	if (flowInfo.isDefinitelyNonNull(local)) {
644	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {	655	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {
645	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	656	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
646	scope.problemReporter().variableRedundantCheckOnNonNull(local, reference);	657	scope.problemReporter().variableRedundantCheckOnNonNull(local, location);
647	}	658	}
648	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	659	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
649	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	660	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
650	}	661	}
651	} else {	662	} else {
652	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	663	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
653	scope.problemReporter().variableNonNullComparedToNull(local, reference);	664	scope.problemReporter().variableNonNullComparedToNull(local, location);
654	}	665	}
655	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	666	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
656	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	667	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
Lines 666-671 public void recordUsingNullReference(Scope scope, VariableBinding local, Link Here
666	case CAN_ONLY_NULL \| IN_COMPARISON_NON_NULL:	677	case CAN_ONLY_NULL \| IN_COMPARISON_NON_NULL:
667	case CAN_ONLY_NULL \| IN_ASSIGNMENT:	678	case CAN_ONLY_NULL \| IN_ASSIGNMENT:
668	case CAN_ONLY_NULL \| IN_INSTANCEOF:	679	case CAN_ONLY_NULL \| IN_INSTANCEOF:
		680	Expression reference = (Expression)location;
669	if (flowInfo.isDefinitelyNull(local)) {	681	if (flowInfo.isDefinitelyNull(local)) {
670	switch(checkType & CONTEXT_MASK) {	682	switch(checkType & CONTEXT_MASK) {
671	case FlowContext.IN_COMPARISON_NULL:	683	case FlowContext.IN_COMPARISON_NULL:
Lines 720-730 public void recordUsingNullReference(Scope scope, VariableBinding local, Link Here
720	break;	732	break;
721	case MAY_NULL :	733	case MAY_NULL :
722	if (flowInfo.isDefinitelyNull(local)) {	734	if (flowInfo.isDefinitelyNull(local)) {
723	scope.problemReporter().variableNullReference(local, reference);	735	scope.problemReporter().variableNullReference(local, location);
724	return;	736	return;
725	}	737	}
726	if (flowInfo.isPotentiallyNull(local)) {	738	if (flowInfo.isPotentiallyNull(local)) {
727	scope.problemReporter().variablePotentialNullReference(local, reference);	739	scope.problemReporter().variablePotentialNullReference(local, location);
728	return;	740	return;
729	}	741	}
730	break;	742	break;
Lines 732-738 public void recordUsingNullReference(Scope scope, VariableBinding local, Link Here
732	// never happens	744	// never happens
733	}	745	}
734	if (this.parent != null) {	746	if (this.parent != null) {
735	this.parent.recordUsingNullReference(scope, local, reference, checkType,	747	this.parent.recordUsingNullReference(scope, local, location, checkType,
736	flowInfo);	748	flowInfo);
737	}	749	}
738	}	750	}





import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.FakedTrackingVariable;
import org.eclipse.jdt.internal.compiler.ast.Reference;
import org.eclipse.jdt.internal.compiler.codegen.BranchLabel;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;

	VariableBinding finalVariables[];
	int assignCount = 0;

	// the following three arrays are in sync regarding their indices:
	VariableBinding[] nullVariables;
	ASTNode[] nullReferences;	// Expressions for null checking, Statements for resource analysis
								// cast to Expression is safe if corresponding nullCheckType != EXIT_RESOURCE
	int[] nullCheckTypes;
	int nullCount;
	// see also the related field FlowContext#expectedTypes

		// check only immutable null checks on innermost looping context
		for (int i = 0; i < this.nullCount; i++) {
			VariableBinding local = this.nullVariables[i];
			ASTNode location = this.nullReferences[i];
			// final local variable
			switch (this.nullCheckTypes[i]) {
				case CAN_ONLY_NON_NULL | IN_COMPARISON_NULL:

						this.nullReferences[i] = null;
						if (this.nullCheckTypes[i] == (CAN_ONLY_NON_NULL | IN_COMPARISON_NON_NULL)) {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableRedundantCheckOnNonNull(local, location);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNonNullComparedToNull(local, location);
							}
						}
						continue;

						this.nullReferences[i] = null;
						if (this.nullCheckTypes[i] == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableRedundantCheckOnNonNull(local, location);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNonNullComparedToNull(local, location);
							}
						}
						continue;

						this.nullReferences[i] = null;
						if (this.nullCheckTypes[i] == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NULL)) {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableRedundantCheckOnNull(local, location);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNullComparedToNonNull(local, location);
							}
						}
						continue;

				case CAN_ONLY_NULL | IN_COMPARISON_NON_NULL:
				case CAN_ONLY_NULL | IN_ASSIGNMENT:
				case CAN_ONLY_NULL | IN_INSTANCEOF:
					Expression expression = (Expression)location;
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						switch(this.nullCheckTypes[i] & CONTEXT_MASK) {

				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().variableNullReference(local, location);
						continue;
					}
					break;
				case ASSIGN_TO_NONNULL:
					this.parent.recordNullityMismatch(scope, (Expression)location, flowInfo.nullStatus(local), this.expectedTypes[i]);
					break;
				case EXIT_RESOURCE:
					if (local instanceof LocalVariableBinding) {
						FakedTrackingVariable trackingVar = ((LocalVariableBinding) local).closeTracker;
						if (trackingVar != null) {
							if (trackingVar.hasDefinitelyNoResource(flowInfo)) {
								continue; // no resource - no warning.
							}
							if (trackingVar.isClosedInFinallyOfEnclosing(scope)) {
								continue;
							}
							if (this.parent.recordExitAgainstResource(scope, flowInfo, trackingVar, location)) {
								this.nullReferences[i] = null;
								continue;
							}
						}
					}
					break;
				default:
					// never happens
			}
			this.parent.recordUsingNullReference(scope, local, location,
					this.nullCheckTypes[i], flowInfo);
		}
	}
	else {
		// check inconsistent null checks on outermost looping context
		for (int i = 0; i < this.nullCount; i++) {
			ASTNode location = this.nullReferences[i];
			// final local variable
			VariableBinding local = this.nullVariables[i];
			switch (this.nullCheckTypes[i]) {

						this.nullReferences[i] = null;
						if (this.nullCheckTypes[i] == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableRedundantCheckOnNonNull(local, location);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNonNullComparedToNull(local, location);
							}
						}
						continue;

				case CAN_ONLY_NULL | IN_COMPARISON_NON_NULL:
				case CAN_ONLY_NULL | IN_ASSIGNMENT:
				case CAN_ONLY_NULL | IN_INSTANCEOF:
					Expression expression = (Expression) location;
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						switch(this.nullCheckTypes[i] & CONTEXT_MASK) {

				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().variableNullReference(local, location);
						continue;
					}
					if (flowInfo.isPotentiallyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().variablePotentialNullReference(local, location);
						continue;
					}
					break;

					int nullStatus = flowInfo.nullStatus(local);
					if (nullStatus != FlowInfo.NON_NULL) {
						char[][] annotationName = scope.environment().getNonNullAnnotationName();
						scope.problemReporter().nullityMismatch((Expression) location, this.expectedTypes[i], nullStatus, annotationName);
					}
					break;
				case EXIT_RESOURCE:
					nullStatus = flowInfo.nullStatus(local);
					if (nullStatus != FlowInfo.NON_NULL && local instanceof LocalVariableBinding) {
						FakedTrackingVariable closeTracker = ((LocalVariableBinding)local).closeTracker;
						if (closeTracker != null) {
							if (closeTracker.hasDefinitelyNoResource(flowInfo)) {
								continue; // no resource - no warning.
							}
							if (closeTracker.isClosedInFinallyOfEnclosing(scope)) {
								continue;
							}
							closeTracker.recordErrorLocation(this.nullReferences[i], nullStatus);
							closeTracker.reportRecordedErrors(scope, nullStatus);
							this.nullReferences[i] = null;
							continue;
						}
					}
					break;
				default:

	}

protected void recordNullReference(VariableBinding local,
	ASTNode expression, int status) {
	if (this.nullCount == 0) {
		this.nullVariables = new VariableBinding[5];
		this.nullReferences = new ASTNode[5];
		this.nullCheckTypes = new int[5];
	}
	else if (this.nullCount == this.nullVariables.length) {
		System.arraycopy(this.nullVariables, 0,
			this.nullVariables = new VariableBinding[this.nullCount * 2], 0, this.nullCount);
		System.arraycopy(this.nullReferences, 0,
			this.nullReferences = new ASTNode[this.nullCount * 2], 0, this.nullCount);
		System.arraycopy(this.nullCheckTypes, 0,
			this.nullCheckTypes = new int[this.nullCount * 2], 0, this.nullCount);
	}

	this.nullCheckTypes[this.nullCount++] = status;
}

/** Record the fact that we see an early exit (in 'reference') while 'trackingVar' is in scope and may be unclosed. */
public boolean recordExitAgainstResource(BlockScope scope, FlowInfo flowInfo, FakedTrackingVariable trackingVar, ASTNode reference) {
	LocalVariableBinding local = trackingVar.binding;
	if (flowInfo.isDefinitelyNonNull(local)) {
		return false;
	}
	if (flowInfo.isDefinitelyNull(local)) {
		scope.problemReporter().unclosedCloseable(trackingVar, reference);
		return true; // handled
	}
	if (flowInfo.isPotentiallyNull(local)) {
		scope.problemReporter().potentiallyUnclosedCloseable(trackingVar, reference);
		return true; // handled
	}
	recordNullReference(trackingVar.binding, reference, EXIT_RESOURCE);
	return true; // handled
}

public void recordUsingNullReference(Scope scope, VariableBinding local,
		ASTNode location, int checkType, FlowInfo flowInfo) {
	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 ||
			flowInfo.isDefinitelyUnknown(local)) {
		return;

	switch (checkType) {
		case CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NULL:
		case CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL:
			Expression reference = (Expression)location;
			if (flowInfo.isDefinitelyNonNull(local)) {
				if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {

		case CAN_ONLY_NULL | IN_COMPARISON_NON_NULL:
		case CAN_ONLY_NULL | IN_ASSIGNMENT:
		case CAN_ONLY_NULL | IN_INSTANCEOF:
			reference = (Expression)location;
			if (flowInfo.isPotentiallyNonNull(local)
					|| flowInfo.isPotentiallyUnknown(local)
					|| flowInfo.isProtectedNonNull(local)) {

				return;
			}
			if (flowInfo.isDefinitelyNull(local)) {
				scope.problemReporter().variableNullReference(local, location);
				return;
			}
			if (flowInfo.isPotentiallyNull(local)) {
				scope.problemReporter().variablePotentialNullReference(local, location);
				return;
			}
			recordNullReference(local, location, checkType);
			return;
		default:
			// never happens




import org.eclipse.jdt.internal.compiler.ast.*;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;

 * At the end of a block check the closing-status of all tracked closeables that are declared in this block.
 * Also invoked when entering unreachable code.
 */
public void checkUnclosedCloseables(FlowInfo flowInfo, FlowContext flowContext, ASTNode location, BlockScope locationScope) {
	if (this.trackingVariables == null) {
		// at a method return we also consider enclosing scopes
		if (location != null && this.parent instanceof BlockScope)
			((BlockScope) this.parent).checkUnclosedCloseables(flowInfo, flowContext, location, locationScope);
		return;
	}
	if (location != null && flowInfo.reachMode() != 0) return;

			continue;
		}

		if (location != null && trackingVar.hasDefinitelyNoResource(flowInfo)) {
			continue; // reporting against a specific location, there is no resource at this flow, don't complain
		}

		if (location != null && flowContext != null && flowContext.recordExitAgainstResource(this, flowInfo, trackingVar, location)) {
			continue; // handled by the flow context
		}

		// compute the most specific null status for this resource,
		int status = trackingVar.findMostSpecificStatus(flowInfo, this, locationScope);
		

Return to bug 368546

Lines 34-41 public class FinallyFlowContext extends FlowContext { Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FinallyFlowContext.java (-16 / +21 lines)
34	VariableBinding[] finalVariables;	34	VariableBinding[] finalVariables;
35	int assignCount;	35	int assignCount;
36		36
		37	// the following three arrays are in sync regarding their indices:
37	VariableBinding[] nullVariables;	38	VariableBinding[] nullVariables;
38	Expression[] nullReferences;	39	ASTNode[] nullReferences; // Expressions for null checking, Statements for resource analysis
		40	// cast to Expression is safe if corresponding nullCheckType != EXIT_RESOURCE
39	int[] nullCheckTypes;	41	int[] nullCheckTypes;
40	int nullCount;	42	int nullCount;
41	// see also the related field FlowContext#expectedTypes	43	// see also the related field FlowContext#expectedTypes
Lines 89-95 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
89	if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) { // within an enclosing loop, be conservative	91	if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) { // within an enclosing loop, be conservative
90	for (int i = 0; i < this.nullCount; i++) {	92	for (int i = 0; i < this.nullCount; i++) {
91	if (this.nullCheckTypes[i] == ASSIGN_TO_NONNULL)	93	if (this.nullCheckTypes[i] == ASSIGN_TO_NONNULL)
92	this.parent.recordNullityMismatch(scope, this.nullReferences[i],	94	this.parent.recordNullityMismatch(scope, (Expression)this.nullReferences[i],
93	flowInfo.nullStatus(this.nullVariables[i]), this.expectedTypes[i]);	95	flowInfo.nullStatus(this.nullVariables[i]), this.expectedTypes[i]);
94	else	96	else
95	this.parent.recordUsingNullReference(scope, this.nullVariables[i],	97	this.parent.recordUsingNullReference(scope, this.nullVariables[i],
Lines 98-104 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
98	}	100	}
99	else { // no enclosing loop, be as precise as possible right now	101	else { // no enclosing loop, be as precise as possible right now
100	for (int i = 0; i < this.nullCount; i++) {	102	for (int i = 0; i < this.nullCount; i++) {
101	Expression expression = this.nullReferences[i];	103	ASTNode location = this.nullReferences[i];
102	// final local variable	104	// final local variable
103	VariableBinding var = this.nullVariables[i];	105	VariableBinding var = this.nullVariables[i];
104	switch (this.nullCheckTypes[i]) {	106	switch (this.nullCheckTypes[i]) {
Lines 107-117 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
107	if (flowInfo.isDefinitelyNonNull(var)) {	109	if (flowInfo.isDefinitelyNonNull(var)) {
108	if (this.nullCheckTypes[i] == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {	110	if (this.nullCheckTypes[i] == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {
109	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	111	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
110	scope.problemReporter().variableRedundantCheckOnNonNull(var, expression);	112	scope.problemReporter().variableRedundantCheckOnNonNull(var, location);
111	}	113	}
112	} else {	114	} else {
113	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	115	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
114	scope.problemReporter().variableNonNullComparedToNull(var, expression);	116	scope.problemReporter().variableNonNullComparedToNull(var, location);
115	}	117	}
116	}	118	}
117	continue;	119	continue;
Lines 121-126 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
121	case CAN_ONLY_NULL \| IN_COMPARISON_NON_NULL:	123	case CAN_ONLY_NULL \| IN_COMPARISON_NON_NULL:
122	case CAN_ONLY_NULL \| IN_ASSIGNMENT:	124	case CAN_ONLY_NULL \| IN_ASSIGNMENT:
123	case CAN_ONLY_NULL \| IN_INSTANCEOF:	125	case CAN_ONLY_NULL \| IN_INSTANCEOF:
		126	Expression expression = (Expression) location;
124	if (flowInfo.isDefinitelyNull(var)) {	127	if (flowInfo.isDefinitelyNull(var)) {
125	switch(this.nullCheckTypes[i] & CONTEXT_MASK) {	128	switch(this.nullCheckTypes[i] & CONTEXT_MASK) {
126	case FlowContext.IN_COMPARISON_NULL:	129	case FlowContext.IN_COMPARISON_NULL:
Lines 169-186 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
169	break;	172	break;
170	case MAY_NULL:	173	case MAY_NULL:
171	if (flowInfo.isDefinitelyNull(var)) {	174	if (flowInfo.isDefinitelyNull(var)) {
172	scope.problemReporter().variableNullReference(var, expression);	175	scope.problemReporter().variableNullReference(var, location);
173	continue;	176	continue;
174	}	177	}
175	if (flowInfo.isPotentiallyNull(var)) {	178	if (flowInfo.isPotentiallyNull(var)) {
176	scope.problemReporter().variablePotentialNullReference(var, expression);	179	scope.problemReporter().variablePotentialNullReference(var, location);
177	}	180	}
178	break;	181	break;
179	case ASSIGN_TO_NONNULL:	182	case ASSIGN_TO_NONNULL:
180	int nullStatus = flowInfo.nullStatus(var);	183	int nullStatus = flowInfo.nullStatus(var);
181	if (nullStatus != FlowInfo.NON_NULL) {	184	if (nullStatus != FlowInfo.NON_NULL) {
182	char[][] annotationName = scope.environment().getNonNullAnnotationName();	185	char[][] annotationName = scope.environment().getNonNullAnnotationName();
183	scope.problemReporter().nullityMismatch(expression, this.expectedTypes[i], nullStatus, annotationName);	186	scope.problemReporter().nullityMismatch((Expression) location, this.expectedTypes[i], nullStatus, annotationName);
184	}	187	}
185	break;	188	break;
186	default:	189	default:
Lines 229-235 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
229	}	232	}
230		233
231	public void recordUsingNullReference(Scope scope, VariableBinding var,	234	public void recordUsingNullReference(Scope scope, VariableBinding var,
232	Expression reference, int checkType, FlowInfo flowInfo) {	235	ASTNode location, int checkType, FlowInfo flowInfo) {
233	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0 && !flowInfo.isDefinitelyUnknown(var)) {	236	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0 && !flowInfo.isDefinitelyUnknown(var)) {
234	if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) { // within an enclosing loop, be conservative	237	if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) { // within an enclosing loop, be conservative
235	switch (checkType) {	238	switch (checkType) {
Lines 239-244 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
239	case CAN_ONLY_NULL \| IN_COMPARISON_NON_NULL:	242	case CAN_ONLY_NULL \| IN_COMPARISON_NON_NULL:
240	case CAN_ONLY_NULL \| IN_ASSIGNMENT:	243	case CAN_ONLY_NULL \| IN_ASSIGNMENT:
241	case CAN_ONLY_NULL \| IN_INSTANCEOF:	244	case CAN_ONLY_NULL \| IN_INSTANCEOF:
		245	Expression reference = (Expression) location;
242	if (flowInfo.cannotBeNull(var)) {	246	if (flowInfo.cannotBeNull(var)) {
243	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {	247	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {
244	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	248	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
Lines 312-318 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
312	return;	316	return;
313	}	317	}
314	if (flowInfo.canOnlyBeNull(var)) {	318	if (flowInfo.canOnlyBeNull(var)) {
315	scope.problemReporter().variableNullReference(var, reference);	319	scope.problemReporter().variableNullReference(var, location);
316	return;	320	return;
317	}	321	}
318	break;	322	break;
Lines 327-340 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
327	if (flowInfo.isDefinitelyNonNull(var)) {	331	if (flowInfo.isDefinitelyNonNull(var)) {
328	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {	332	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {
329	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	333	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
330	scope.problemReporter().variableRedundantCheckOnNonNull(var, reference);	334	scope.problemReporter().variableRedundantCheckOnNonNull(var, location);
331	}	335	}
332	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {	336	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {
333	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	337	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
334	}	338	}
335	} else {	339	} else {
336	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	340	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
337	scope.problemReporter().variableNonNullComparedToNull(var, reference);	341	scope.problemReporter().variableNonNullComparedToNull(var, location);
338	}	342	}
339	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {	343	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {
340	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	344	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
Lines 347-352 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
347	case CAN_ONLY_NULL \| IN_COMPARISON_NON_NULL:	351	case CAN_ONLY_NULL \| IN_COMPARISON_NON_NULL:
348	case CAN_ONLY_NULL \| IN_ASSIGNMENT:	352	case CAN_ONLY_NULL \| IN_ASSIGNMENT:
349	case CAN_ONLY_NULL \| IN_INSTANCEOF:	353	case CAN_ONLY_NULL \| IN_INSTANCEOF:
		354	Expression reference = (Expression) location;
350	if (flowInfo.isDefinitelyNull(var)) {	355	if (flowInfo.isDefinitelyNull(var)) {
351	switch(checkType & CONTEXT_MASK) {	356	switch(checkType & CONTEXT_MASK) {
352	case FlowContext.IN_COMPARISON_NULL:	357	case FlowContext.IN_COMPARISON_NULL:
Lines 399-409 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
399	break;	404	break;
400	case MAY_NULL :	405	case MAY_NULL :
401	if (flowInfo.isDefinitelyNull(var)) {	406	if (flowInfo.isDefinitelyNull(var)) {
402	scope.problemReporter().variableNullReference(var, reference);	407	scope.problemReporter().variableNullReference(var, location);
403	return;	408	return;
404	}	409	}
405	if (flowInfo.isPotentiallyNull(var)) {	410	if (flowInfo.isPotentiallyNull(var)) {
406	scope.problemReporter().variablePotentialNullReference(var, reference);	411	scope.problemReporter().variablePotentialNullReference(var, location);
407	return;	412	return;
408	}	413	}
409	if (flowInfo.isDefinitelyNonNull(var)) {	414	if (flowInfo.isDefinitelyNonNull(var)) {
Lines 419-425 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
419	if(((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) \|\| checkType == MAY_NULL	424	if(((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) \|\| checkType == MAY_NULL
420	\|\| (checkType & CONTEXT_MASK) == FlowContext.IN_ASSIGNMENT	425	\|\| (checkType & CONTEXT_MASK) == FlowContext.IN_ASSIGNMENT
421	\|\| (checkType & CONTEXT_MASK) == FlowContext.IN_INSTANCEOF) {	426	\|\| (checkType & CONTEXT_MASK) == FlowContext.IN_INSTANCEOF) {
422	recordNullReference(var, reference, checkType);	427	recordNullReference(var, location, checkType);
423	}	428	}
424	// prepare to re-check with try/catch flow info	429	// prepare to re-check with try/catch flow info
425	}	430	}
Lines 436-442 public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) { Link Here
436	}	441	}
437		442
438	protected void recordNullReference(VariableBinding var,	443	protected void recordNullReference(VariableBinding var,
439	Expression expression, int status) {	444	ASTNode expression, int status) {
440	if (this.nullCount == 0) {	445	if (this.nullCount == 0) {
441	this.nullVariables = new VariableBinding[5];	446	this.nullVariables = new VariableBinding[5];
442	this.nullReferences = new Expression[5];	447	this.nullReferences = new Expression[5];