Attachment #204108 for bug #349326

Lines 7-13 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/FlowAnalysisTest.java (-1 / +49 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 236385	10	* Stephan Herrmann - Contributions for
		11	* bug 236385 - [compiler] Warn for potential programming problem if an object is created but not used
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.core.tests.compiler.regression;	14	package org.eclipse.jdt.core.tests.compiler.regression;
13		15
Lines 2360-2365 Link Here
2360	"The local variable i may not have been initialized\n" +	2362	"The local variable i may not have been initialized\n" +
2361	"----------\n");	2363	"----------\n");
2362	}	2364	}
		2365	// Bug 349326 - [1.7] new warning for missing try-with-resources
		2366	// variant < 1.7 using Closeable: not closed
		2367	public void testCloseable1() {
		2368	this.runNegativeTest(
		2369	new String[] {
		2370	"X.java",
		2371	"import java.io.File;\n" +
		2372	"import java.io.FileReader;\n" +
		2373	"import java.io.IOException;\n" +
		2374	"public class X {\n" +
		2375	" void foo() throws IOException {\n" +
		2376	" File file = new File(\"somefile\");\n" +
		2377	" FileReader fileReader = new FileReader(file); // not closed\n" +
		2378	" char[] in = new char[50];\n" +
		2379	" fileReader.read(in);\n" +
		2380	" }\n" +
		2381	"}\n"
		2382	},
		2383	"----------\n" +
		2384	"1. WARNING in X.java (at line 7)\n" +
		2385	" FileReader fileReader = new FileReader(file); // not closed\n" +
		2386	" ^^^^^^^^^^\n" +
		2387	"Resource leak: 'fileReader' is never closed\n" +
		2388	"----------\n");
		2389	}
		2390	// Bug 349326 - [1.7] new warning for missing try-with-resources
		2391	// variant < 1.7 using Closeable: resource is closed, cannot suggest try-with-resources < 1.7
		2392	public void testCloseable2() {
		2393	this.runConformTest(
		2394	new String[] {
		2395	"X.java",
		2396	"import java.io.File;\n" +
		2397	"import java.io.FileReader;\n" +
		2398	"import java.io.IOException;\n" +
		2399	"public class X {\n" +
		2400	" void foo() throws IOException {\n" +
		2401	" File file = new File(\"somefile\");\n" +
		2402	" FileReader fileReader = new FileReader(file); // not closed\n" +
		2403	" char[] in = new char[50];\n" +
		2404	" fileReader.read(in);\n" +
		2405	" fileReader.close();\n" +
		2406	" }\n" +
		2407	"}\n"
		2408	},
		2409	"");
		2410	}
2363	public static Class testClass() {	2411	public static Class testClass() {
2364	return FlowAnalysisTest.class;	2412	return FlowAnalysisTest.class;
2365	}	2413	}




 * 							bug 324178 - [null] ConditionalExpression.nullStatus(..) doesn't take into account the analysis of condition itself
 * 							bug 354554 - [null] conditional with redundant condition yields weak error message
 * 							bug 358827 - [1.7] exception analysis for t-w-r spoils null analysis
 * 							bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;


			"    }\n" +
			"  }\n" +
			"}\n"},
			"----------\n" +
			"1. WARNING in X.java (at line 6)\n" +
			"	o = new LineNumberReader(new FileReader(\"dummy\"));\n" +
			"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
			"Resource leak: \'o\' is never closed\n" +
			"----------\n" +
			"2. ERROR in X.java (at line 8)\n" +
			"	o.toString();\n" +
			"	^\n" +
			"Potential null pointer access: The variable o may be null at this location\n" +
			"----------\n",
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}





 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contributions for
 *     							bug 358827 - [1.7] exception analysis for t-w-r spoils null analysis
 *     							bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;

import java.util.Map;

import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

import junit.framework.Test;
public class TryWithResourcesStatementTest extends AbstractRegressionTest {

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

		"	               ^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 5)\n" + 
		"	Y why = new Y();\n" + 
		"	  ^^^\n" + 
		"Resource leak: 'why' is never closed\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 5)\n" + 
		"	Y why = new Y();\n" + 
		"	        ^^^^^^^\n" + 
		"Unhandled exception type WeirdException\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 22)\n" + 
		"	class WeirdException extends Throwable {}\n" + 
		"	      ^^^^^^^^^^^^^^\n" + 
		"The serializable class WeirdException does not declare a static final serialVersionUID field of type long\n" + 

		"	               ^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 5)\n" + 
		"	Y why = new Y();\n" + 
		"	  ^^^\n" + 
		"Resource leak: 'why' is never closed\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 5)\n" + 
		"	Y why = new Y();\n" + 
		"	        ^^^^^^^\n" + 
		"Unhandled exception type WeirdException\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 20)\n" + 
		"	class WeirdException extends Throwable {}\n" + 
		"	      ^^^^^^^^^^^^^^\n" + 
		"The serializable class WeirdException does not declare a static final serialVersionUID field of type long\n" + 

		},
		"Done");
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable without ever closing it.
public void test056() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
// not invoking any methods on FileReader, try to avoid necessary call to superclass() in the compiler
//			"        char[] in = new char[50];\n" +
//			"        fileReader.read(in);\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Resource leak: 'fileReader' is never closed\n" +
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable and closes it but not protected by t-w-r nor regular try-finally
public void test056a() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportExplicitlyClosedAutoCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"		 fileReader.close();\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        try {\n" +
			"            new X().foo();\n" +
			"        } catch (IOException ioex) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Resource 'fileReader' should be managed by try-with-resource\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable and closes it properly in a finally block
public void test056b() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        try {\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"        } finally {\n" +
			"		     fileReader.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        try {\n" +
			"            new X().foo();\n" +
			"        } catch (IOException ioex) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable properly within try-with-resources.
public void test056c() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        try (FileReader fileReader = new FileReader(file)) {\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"		 }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        try {\n" +
			"            new X().foo();\n" +
			"        } catch (IOException ioex) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses two AutoCloseables (testing independent analysis)
// - one closeable may be unclosed at a conditional return
// - the other is only conditionally closed
public void test056d() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean flag1, boolean flag2) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        char[] in = new char[50];\n" +
			"        FileReader fileReader1 = new FileReader(file);\n" +
			"        fileReader1.read(in);\n" +
			"        FileReader fileReader2 = new FileReader(file);\n" +
			"        fileReader2.read(in);\n" +
			"        if (flag1) {\n" +
			"            fileReader2.close();\n" +
			"            return;\n" +
			"        } else if (flag2) {\n" +
			"            fileReader2.close();\n" +
			"        }\n" +
			"        fileReader1.close();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(false, true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 10)\n" + 
		"	FileReader fileReader2 = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^^\n" + 
		"Potential resource leak: 'fileReader2' may not be closed\n" +
		"----------\n" + 
		"2. ERROR in X.java (at line 14)\n" + 
		"	return;\n" + 
		"	^^^^^^^\n" + 
		"Resource leak: \'fileReader1\' is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
//Bug 349326 - [1.7] new warning for missing try-with-resources
//a method uses two AutoCloseables (testing independent analysis)
//- one closeable may be unclosed at a conditional return
//- the other is only conditionally closed
public void test056d_suppress() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	options.put(CompilerOptions.OPTION_SuppressOptionalErrors, CompilerOptions.ENABLED);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean flag1, boolean flag2) throws IOException {\n" +
			"        @SuppressWarnings(\"resource\") File file = new File(\"somefile\"); // unnecessary suppress\n" +
			"        char[] in = new char[50];\n" +
			"        FileReader fileReader1 = new FileReader(file);\n" +
			"        fileReader1.read(in);\n" +
			"        @SuppressWarnings(\"resource\") FileReader fileReader2 = new FileReader(file); // useful suppress\n" +
			"        fileReader2.read(in);\n" +
			"        if (flag1) {\n" +
			"            fileReader2.close();\n" +
			"            return; // not suppressed\n" +
			"        } else if (flag2) {\n" +
			"            fileReader2.close();\n" +
			"        }\n" +
			"        fileReader1.close();\n" +
			"    }\n" +
			"    @SuppressWarnings(\"resource\") // useful suppress\n" +
			"    void bar() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(false, true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 6)\n" + 
		"	@SuppressWarnings(\"resource\") File file = new File(\"somefile\"); // unnecessary suppress\n" + 
		"	                  ^^^^^^^^^^\n" + 
		"Unnecessary @SuppressWarnings(\"resource\")\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 14)\n" + 
		"	return; // not suppressed\n" + 
		"	^^^^^^^\n" + 
		"Resource leak: \'fileReader1\' is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// one method returns an AutoCleasble, a second method uses this object without ever closing it.
public void test056e() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    FileReader getReader(String filename) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        return fileReader;\n" + 		// don't complain here, pass responsibility to caller
			"    }\n" +
			"    void foo() throws IOException {\n" +
			"        FileReader reader = getReader(\"somefile\");\n" +
			"        char[] in = new char[50];\n" +
			"        reader.read(in);\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 11)\n" + 
		"	FileReader reader = getReader(\"somefile\");\n" + 
		"	           ^^^^^^\n" + 
		"Resource leak: 'reader' is never closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method explicitly closes its AutoCloseable rather than using t-w-r
public void test056f() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	options.put(CompilerOptions.OPTION_ReportExplicitlyClosedAutoCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = null;\n" +
			"        try {\n" +
			"            fileReader = new FileReader(file);\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"        } finally {\n" +
			"            fileReader.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = null;\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Resource \'fileReader\' should be managed by try-with-resource\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// an AutoCloseable local is re-assigned
public void test056g() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"        fileReader = new FileReader(file);\n" +
			"        fileReader.read(in);\n" +
			"        fileReader.close();\n" +
			"        fileReader = null;\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	fileReader = new FileReader(file);\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Resource leak: \'fileReader\' is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// an AutoCloseable local is re-assigned after null-assigned
public void test056g2() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"        fileReader = null;\n" +
			"        fileReader = new FileReader(file);\n" + // don't complain again, fileReader is null, so nothing can leak here
			"        fileReader.read(in);\n" +
			"        fileReader.close();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	fileReader = null;\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"Resource leak: \'fileReader\' is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// two AutoCloseables at different nesting levels (anonymous local type)
public void test056h() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        final File file = new File(\"somefile\");\n" +
			"        final FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"        new Runnable() {\n public void run() {\n" +
			"            try {\n" +
			"                fileReader.close();\n" +
			"                FileReader localReader = new FileReader(file);\n" +
			"            } catch (IOException ex) { /* nop */ }\n" +
			"        }}.run();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 7)\n" + 
		"	final FileReader fileReader = new FileReader(file);\n" + 
		"	                 ^^^^^^^^^^\n" + 
		"Potential resource leak: 'fileReader' may not be closed\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 14)\n" + 
		"	FileReader localReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^^\n" + 
		"Resource leak: 'localReader' is never closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// three AutoCloseables in different blocks of the same method
public void test056i() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean f1, boolean f2) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        if (f1) {\n" +
			"            FileReader fileReader = new FileReader(file); // err: not closed\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"            while (true) {\n" +
			"                 FileReader loopReader = new FileReader(file); // don't warn, properly closed\n" +
			"                 loopReader.close();" +
			"                 break;\n" +
			"            }\n" +
			"        } else {\n" +
			"            FileReader fileReader = new FileReader(file); // warn: not closed on all paths\n" +
			"            if (f2)\n" +
			"                fileReader.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(true, true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	FileReader fileReader = new FileReader(file); // err: not closed\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Resource leak: 'fileReader' is never closed\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 16)\n" + 
		"	FileReader fileReader = new FileReader(file); // warn: not closed on all paths\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Potential resource leak: 'fileReader' may not be closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// three AutoCloseables in different blocks of the same method
public void test056i2() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" + 
			"import java.io.FileReader;\n" + 
			"import java.io.IOException;\n" + 
			"public class X {\n" +
			"    void foo(boolean f1, boolean f2) throws IOException {\n" + 
			"        File file = new File(\"somefile\");\n" + 
			"        if (f1) {\n" + 
			"            FileReader fileReader = new FileReader(file); // properly closed\n" + 
			"            char[] in = new char[50];\n" + 
			"            fileReader.read(in);\n" + 
			"            while (true) {\n" + 
			"                  fileReader.close();\n" + 
			"                  FileReader loopReader = new FileReader(file); // don't warn, properly closed\n" + 
			"                  loopReader.close();\n" + 
			"                  break;\n" + 
			"            }\n" + 
			"        } else {\n" + 
			"            FileReader fileReader = new FileReader(file); // warn: not closed on all paths\n" + 
			"            if (f2)\n" + 
			"                fileReader.close();\n" + 
			"        }\n" + 
			"    }\n" + 
			"    public static void main(String[] args) throws IOException {\n" + 
			"        new X().foo(true, true);\n" + 
			"    }\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 18)\n" + 
		"	FileReader fileReader = new FileReader(file); // warn: not closed on all paths\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Potential resource leak: 'fileReader' may not be closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable without closing it locally but passing as arg to another method
public void test056j() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        read(fileReader);\n" +
			"    }\n" +
			"    void read(FileReader reader) { }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Potential resource leak: 'fileReader' may not be closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable without closing it locally but passing as arg to another method
public void test056jconditional() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean b) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        synchronized (b ? this : new X()) {\n" +
			"            new ReadDelegator(fileReader);\n" +
			"        }\n" +
			"    }\n" +
			"    class ReadDelegator { ReadDelegator(FileReader reader) { } }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Potential resource leak: 'fileReader' may not be closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// many locals, some are AutoCloseable.
// Unfortunately analysis cannot respect how exception exits may affect ra3 and rb3,
// doing so would create false positives.
public void test056k() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	options.put(CompilerOptions.OPTION_ReportExplicitlyClosedAutoCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        int i01, i02, i03, i04, i05, i06, i07, i08, i09,\n" +
			"            i11, i12, i13, i14, i15, i16, i17, i18, i19,\n" +
			"            i21, i22, i23, i24, i25, i26, i27, i28, i29,\n" +
			"            i31, i32, i33, i34, i35, i36, i37, i38, i39,\n" +
			"            i41, i42, i43, i44, i45, i46, i47, i48, i49;\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader ra1 = null, ra2 = null;\n" +
			"        try {\n" +
			"            ra1 = new FileReader(file);\n" +
			"            ra2 = new FileReader(file);\n" +
			"            FileReader ra3 = new FileReader(file);\n" +
			"            char[] in = new char[50];\n" +
			"            ra1.read(in);\n" +
			"            ra2.read(in);\n" +
			"            ra3.close();\n" +
			"        } finally {\n" +
			"            ra1.close();\n" +
			"        }\n" +
			"        int i51, i52, i53, i54, i55, i56, i57, i58, i59, i60;\n" + // beyond this point locals are analyzed using extraBits
			"        FileReader rb1 = null, rb2 = null;\n" +
			"        try {\n" +
			"            rb1 = new FileReader(file);\n" +
			"            rb2 = new FileReader(file);\n" +
			"            FileReader rb3 = new FileReader(file);\n" +
			"            char[] in = new char[50];\n" +
			"            rb1.read(in);\n" +
			"            rb2.read(in);\n" +
			"            rb3.close();\n" +
			"        } finally {\n" +
			"            rb1.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 12)\n" + 
		"	FileReader ra1 = null, ra2 = null;\n" + 
		"	           ^^^\n" + 
		"Resource \'ra1\' should be managed by try-with-resource\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 15)\n" + 
		"	ra2 = new FileReader(file);\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Resource leak: 'ra2' is never closed\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 16)\n" + 
		"	FileReader ra3 = new FileReader(file);\n" + 
		"	           ^^^\n" + 
		"Resource \'ra3\' should be managed by try-with-resource\n" +
		"----------\n" + 
		"4. ERROR in X.java (at line 25)\n" + 
		"	FileReader rb1 = null, rb2 = null;\n" + 
		"	           ^^^\n" + 
		"Resource \'rb1\' should be managed by try-with-resource\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 28)\n" + 
		"	rb2 = new FileReader(file);\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Resource leak: 'rb2' is never closed\n" + 
		"----------\n" + 
		"6. ERROR in X.java (at line 29)\n" + 
		"	FileReader rb3 = new FileReader(file);\n" + 
		"	           ^^^\n" + 
		"Resource \'rb3\' should be managed by try-with-resource\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// various non-problems
public void test056l() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportExplicitlyClosedAutoCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    X(FileReader r0) {}\n" + // don't complain against argument
			"    FileReader getReader() { return null; }\n" +
			"    void foo(FileReader r1) throws IOException {\n" +
			"        FileReader fileReader = getReader();\n" +
			"        if (fileReader == null)\n" +
			"            return;\n" + // don't complain, resource is actually null
			"        FileReader r3 = getReader();\n" +
			"        if (r3 == null)\n" +
			"            r3 = new FileReader(new File(\"absent\"));\n" + // don't complain, previous resource is actually null
			"        try {\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"            r1.read(in);\n" +
			"        } finally {\n" +
			"            fileReader.close();\n" +
			"            r3.close();\n" +  // the effect of this close() call might be spoiled by exception in fileReader.close() above, but we ignore exception exits in the analysis
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        FileReader r2 = new FileReader(new File(\"inexist\")); // only potential problem: ctor X below might close r2\n" +
			"        new X(r2).foo(new FileReader(new File(\"notthere\")));\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	FileReader fileReader = getReader();\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Resource \'fileReader\' should be managed by try-with-resource\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 11)\n" + 
		"	FileReader r3 = getReader();\n" + 
		"	           ^^\n" + 
		"Resource 'r3' should be managed by try-with-resource\n" +
		"----------\n" + 
		"3. ERROR in X.java (at line 24)\n" + 
		"	FileReader r2 = new FileReader(new File(\"inexist\")); // only potential problem: ctor X below might close r2\n" + 
		"	           ^^\n" + 
		"Potential resource leak: 'r2' may not be closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// nested try with early exit
public void test056m() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() {\n" +
			"        File file = new File(\"somefile\");" +
			"        try {\n" +
			"            FileReader fileReader = new FileReader(file);\n" +
			"            try {\n" +
			"                char[] in = new char[50];\n" +
			"                if (fileReader.read(in)==0)\n" +
			"                    return;\n" +
			"            } finally {\n" +
			"		         fileReader.close();\n" +
			"            }\n" +
			"        } catch (IOException e) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// nested try should not interfere with earlier analysis.
public void test056n() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"import java.io.FileNotFoundException;\n" +
			"public class X {\n" +
			"    void foo(File someFile, char[] buf) throws IOException {\n" + 
			"		FileReader fr1 = new FileReader(someFile);\n" + 
			"		try {\n" + 
			"			fr1.read(buf);\n" + 
			"		} finally {\n" + 
			"			fr1.close();\n" + 
			"		}\n" + 
			"		try {\n" + 
			"			FileReader fr3 = new FileReader(someFile);\n" + 
			"			try {\n" + 
			"			} finally {\n" + 
			"				fr3.close();\n" + 
			"			}\n" + 
			"		} catch (IOException e) {\n" + 
			"		}\n" + 
			"	 }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        try {\n" +
			"            new X().foo(new File(\"missing\"), new char[100]);\n" +
			"        } catch (FileNotFoundException e) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// if close is guarded by null check this should still be recognized as definitely closed
public void test056o() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"import java.io.FileNotFoundException;\n" +
			"public class X {\n" +
			"    void foo(File someFile, char[] buf) throws IOException {\n" + 
			"		FileReader fr1 = null;\n" + 
			"		try {\n" +
			"           fr1 = new FileReader(someFile);" + 
			"			fr1.read(buf);\n" + 
			"		} finally {\n" + 
			"			if (fr1 != null)\n" +
			"               try {\n" +
			"                   fr1.close();\n" +
			"               } catch (IOException e) { /*do nothing*/ }\n" + 
			"		}\n" + 
			"	 }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        try {\n" +
			"            new X().foo(new File(\"missing\"), new char[100]);\n" +
			"        } catch (FileNotFoundException e) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable without ever closing it, type from a type variable
public void test056p() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.Reader;\n" +
			"import java.io.IOException;\n" +
			"public abstract class X <T extends Reader> {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        T fileReader = newReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"    }\n" +
			"    abstract T newReader(File file) throws IOException;\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X<FileReader>() {\n" +
			"            FileReader newReader(File f) throws IOException { return new FileReader(f); }\n" +
			"        }.foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	T fileReader = newReader(file);\n" + 
		"	  ^^^^^^^^^^\n" + 
		"Resource leak: 'fileReader' is never closed\n" +
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// closed in dead code
public void test056q() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"        if (2*2 == 4)\n" +
			"        	return;\n" +
			"        fileReader.close();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Resource leak: \'fileReader\' is never closed\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 10)\n" + 
		"	if (2*2 == 4)\n" + 
		"	    ^^^^^^^^\n" + 
		"Comparing identical expressions\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 12)\n" + 
		"	fileReader.close();\n" + 
		"	^^^^^^^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// closed in dead code
public void test056r() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fr = new FileReader(file);\n" +
			"  		 Object b = null;\n" + 
			"        fr.close();\n" + 
			"        if (b != null) {\n" + 
			"            fr = new FileReader(file);\n" + 
			"            return;\n" + 
			"        } else {\n" + 
			"            System.out.print(42);\n" + 
			"        }\n" + 
			"        return;     // Should not complain about fr\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	if (b != null) {\n" + 
		"            fr = new FileReader(file);\n" + 
		"            return;\n" + 
		"        } else {\n" + 
		"	               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 13)\n" + 
		"	} else {\n" + 
		"            System.out.print(42);\n" + 
		"        }\n" + 
		"	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Statement unnecessarily nested within else clause. The corresponding then clause does not complete normally\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// resource inside t-w-r is re-assigned, shouldn't even record an errorLocation
public void test056s() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" + 
			"import java.io.FileReader;\n" + 
			"import java.io.IOException;\n" + 
			"public class X {\n" + 
			"    void foo() throws IOException {\n" + 
			"        File file = new File(\"somefile\");\n" + 
			"        try (FileReader fileReader = new FileReader(file);) {\n" + 
			"            char[] in = new char[50];\n" + 
			"            fileReader.read(in);\n" + 
			"            fileReader = new FileReader(file);  // debug here\n" + 
			"            fileReader.read(in);\n" + 
			"        }\n" + 
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" + 
			"        new X().foo();\n" + 
			"    }\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	fileReader = new FileReader(file);  // debug here\n" + 
		"	^^^^^^^^^^\n" + 
		"The resource fileReader of a try-with-resources statement cannot be assigned\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// resource is closed, dead code follows
public void test056t() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.FileReader;\n" + 
			"import java.io.IOException;\n" + 
			"public class X {\n" + 
			"    void foo31() throws IOException {\n" + 
			"        FileReader reader = new FileReader(\"file\"); //warning\n" +
			"        if (reader != null) {\n" + 
			"            reader.close();\n" + 
			"        } else {\n" + 
			"            // nop\n" + 
			"        }\n" + 
			"    }\n" + 
			"    public static void main(String[] args) throws IOException {\n" + 
			"        new X().foo31();\n" + 
			"    }\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	} else {\n" + 
		"            // nop\n" + 
		"        }\n" + 
		"	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// resource is reassigned within t-w-r with different resource
// disabled due to Bug 358827 - [1.7] exception analysis for t-w-r spoils null analysis
public void _test056u() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.FileReader;\n" + 
			"public class X {\n" + 
			"    void foo() throws Exception {\n" + 
			"        FileReader reader1 = new FileReader(\"file1\");\n" + 
			"        FileReader reader2 = new FileReader(\"file2\");\n" + 
			"        reader2 = reader1;// warning 1\n" + 
			"        try (FileReader reader3 = new FileReader(\"file3\")) {\n" + 
			"            int ch;\n" + 
			"            while ((ch = reader2.read()) != -1) {\n" + 
			"                System.out.println(ch);\n" + 
			"                reader1.read();\n" + 
			"            }\n" + 
			"            reader2 = reader1;// warning 2\n" + 
			"            reader2 = reader1;// warning 3\n" + 
			"        } finally {\n" + 
			"            if (reader2 != null) {\n" + 
			"                reader2.close();\n" + 
			"            } else {\n" + 
			"                System.out.println();\n" + 
			"            }\n" + 
			"        }\n" + 
			"    }\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	FileReader reader1 = new FileReader(\"file1\");\n" + 
		"	           ^^^^^^^\n" + 
		"Resource leak: \'reader1\' is never closed\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 4)\n" + 
		"	reader2 = reader1;// warning 1\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"Resource leak: \'reader2\' is not closed at this location\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 13)\n" + 
		"	reader2 = reader1;// warning 2\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"Resource leak: \'reader2\' is not closed at this location\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 14)\n" + 
		"	reader2 = reader1;// warning 3\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"Resource leak: \'reader2\' is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// pb reported in https://bugs.eclipse.org/bugs/show_bug.cgi?id=349326#c70
public void test056v() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.FileReader;\n" + 
			"public class X {\n" + 
			"    boolean foo1() throws Exception {\n" + 
			"        FileReader reader = new FileReader(\"file\");\n" + 
			"        try {\n" + 
			"            int ch;\n" + 
			"            while ((ch = reader.read()) != -1) {\n" + 
			"                System.out.println(ch);\n" + 
			"                reader.read();\n" + 
			"            }\n" + 
			"            if (ch > 10) {\n" + 
			"                return true;\n" + 
			"            }\n" + 
			"            return false;\n" + // return while resource from enclosing scope remains unclosed
			"        } finally {\n" + 
			"        }\n" + 
			"    }\n" + 
			"    void foo2() throws Exception {\n" + 
			"        FileReader reader2 = new FileReader(\"file\");\n" + 
			"        try {\n" + 
			"            int ch;\n" + 
			"            while ((ch = reader2.read()) != -1) {\n" + 
			"                System.out.println(ch);\n" + 
			"                reader2.read();\n" + 
			"            }\n" + 
			"            if (ch > 10) {\n" + 
			"                return;\n" + // potential leak
			"            }\n" + 
			"        } finally {\n" + 
			"        }\n" +
			"        reader2.close();\n" + // due to this close we don't say "never closed"
			"    }\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	FileReader reader = new FileReader(\"file\");\n" + 
		"	           ^^^^^^\n" + 
		"Resource leak: \'reader\' is never closed\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 27)\n" + 
		"	return;\n" + 
		"	^^^^^^^\n" + 
		"Resource leak: \'reader2\' is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// end of method is dead end, but before we have both a close() and an early return
public void test056w() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.FileReader;\n" + 
			"public class X {\n" + 
			"    boolean foo1() throws Exception {\n" + 
			"        FileReader reader = new FileReader(\"file\");\n" + 
			"        try {\n" + 
			"            int ch;\n" + 
			"            while ((ch = reader.read()) != -1) {\n" + 
			"                System.out.println(ch);\n" + 
			"                reader.read();\n" + 
			"            }\n" + 
			"            if (ch > 10) {\n" +
			"				 reader.close();\n" + 
			"                return true;\n" + 
			"            }\n" + 
			"            return false;\n" + 
			"        } finally {\n" + 
			"        }\n" + 
			"    }\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 15)\n" + 
		"	return false;\n" + 
		"	^^^^^^^^^^^^^\n" + 
		"Resource leak: \'reader\' is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// different early exits, if no close seen report as definitely unclosed
public void test056x() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.FileReader;\n" +
			"public class X {\n" +
			"    void foo31(boolean b) throws Exception {\n" +
			"        FileReader reader = new FileReader(\"file\");\n" +
			"        if (b) {\n" +
			"            reader.close();\n" +
			"        } else {\n" +
			"            return; // warning\n" +
			"        }\n" +
			"    }\n" +
			"    void foo32(boolean b) throws Exception {\n" +
			"        FileReader reader = new FileReader(\"file\"); // warn here\n" +
			"        return;\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 8)\n" +
		"	return; // warning\n" +
		"	^^^^^^^\n" +
		"Resource leak: \'reader\' is not closed at this location\n" +
		"----------\n" +
		"2. ERROR in X.java (at line 12)\n" +
		"	FileReader reader = new FileReader(\"file\"); // warn here\n" +
		"	           ^^^^^^\n" +
		"Resource leak: \'reader\' is never closed\n" +
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// nested method passes the resource to outside code
public void test056y() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.FileReader;\n" +
			"public class X {\n" +
			"    void foo31(boolean b) throws Exception {\n" +
			"        final FileReader reader31 = new FileReader(\"file\");\n" +
			"        new Runnable() {\n" +
			"            public void run() {\n" +
			"                foo18(reader31);\n" +
			"            }\n" +
			"        }.run();\n" +
			"    }\n" +
			"    void foo18(FileReader r18) {\n" +
			"        // could theoretically close r18;\n" +
			"    }\n" +
			"    abstract class ResourceProvider {\n" +
			"        abstract FileReader provide();" +
			"    }\n" +
			"    ResourceProvider provider;" +
			"    void foo23() throws Exception {\n" +
			"        final FileReader reader23 = new FileReader(\"file\");\n" +
			"        provider = new ResourceProvider() {\n" +
			"            public FileReader provide() {\n" +
			"                return reader23;\n" +
			"            }\n" +
			"        };\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 4)\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,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// resource assigned to second local and is (potentially) closed on the latter
public void test056z() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.FileReader;\n" +
			"public class X {\n" +
			"    void foo17() throws Exception {\n" +
			"        FileReader reader17 = new FileReader(\"file\");\n" +
			"        final FileReader readerCopy = reader17;\n" +
			"        readerCopy.close();\n" +
			"    }\n" +
			"    void foo17a() throws Exception {\n" +
			"        FileReader reader17a = new FileReader(\"file\");\n" +
			"        FileReader readerCopya;" +
			"		 readerCopya = reader17a;\n" +
			"        bar(readerCopya);\n" + // potentially closes
			"    }\n" +
			"    void bar(FileReader r) {}\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 9)\n" + 
		"	FileReader reader17a = new FileReader(\"file\");\n" + 
		"	           ^^^^^^^^^\n" + 
		"Potential resource leak: \'reader17a\' may not be closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// multiple early exists from nested scopes (always closed) 
public void test056zz() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.FileReader;\n" +
			"public class X {\n" +
			"    void foo16() throws Exception {\n" +
			"        FileReader reader16 = new FileReader(\"file\");\n" +
			"        try {\n" +
			"            reader16.close();\n " +
			"            return;\n" +
			"        } catch (RuntimeException re) {\n" +
			"            return;\n" +
			"        } catch (Error e) {\n" +
			"            return;\n" +
			"        } finally {\n" +
			"            reader16.close();\n " +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	FileReader reader16 = new FileReader(\"file\");\n" + 
		"	           ^^^^^^^^\n" + 
		"Resource \'reader16\' should be managed by try-with-resource\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// multiple early exists from nested scopes (never closed) 
public void test056zzz() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.FileReader;\n" +
			"public class X {\n" +
			"    void foo16() throws Exception {\n" +
			"        FileReader reader16 = new FileReader(\"file\");\n" +
			"        try {\n" +
			"            return;\n" +
			"        } catch (RuntimeException re) {\n" +
			"            return;\n" +
			"        } catch (Error e) {\n" +
			"            return;\n" +
			"        } finally {\n" +
			"            System.out.println();\n " +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	FileReader reader16 = new FileReader(\"file\");\n" + 
		"	           ^^^^^^^^\n" + 
		"Resource leak: \'reader16\' is never closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
public static Class testClass() {
	return TryWithResourcesStatementTest.class;
}

Lines 116-122 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java (-1 / +16 lines)
116	* Benjamin Muskalla - added the following constants	116	* Benjamin Muskalla - added the following constants
117	* MissingSynchronizedModifierInInheritedMethod	117	* MissingSynchronizedModifierInInheritedMethod
118	* Stephan Herrmann - added the following constants	118	* Stephan Herrmann - added the following constants
119	* UnusedObjectAllocation	119	* UnusedObjectAllocation
		120	* PotentiallyUnclosedCloseable
		121	* PotentiallyUnclosedCloseableAtExit
		122	* UnclosedCloseable
		123	* UnclosedCloseableAtExit
		124	* ExplicitlyClosedAutoCloseable
120	*******************************************************************************/	125	*******************************************************************************/
121	package org.eclipse.jdt.core.compiler;	126	package org.eclipse.jdt.core.compiler;
122		127
Lines 1394-1399 Link Here
1394	int DiamondNotBelow17 = TypeRelated + 883;	1399	int DiamondNotBelow17 = TypeRelated + 883;
1395	/** @since 3.7.1 */	1400	/** @since 3.7.1 */
1396	int RedundantSpecificationOfTypeArguments = TypeRelated + 884;	1401	int RedundantSpecificationOfTypeArguments = TypeRelated + 884;
		1402	/** @since 3.8 */
		1403	int PotentiallyUnclosedCloseable = Internal + 885;
		1404	/** @since 3.8 */
		1405	int PotentiallyUnclosedCloseableAtExit = Internal + 886;
		1406	/** @since 3.8 */
		1407	int UnclosedCloseable = Internal + 887;
		1408	/** @since 3.8 */
		1409	int UnclosedCloseableAtExit = Internal + 888;
		1410	/** @since 3.8 */
		1411	int ExplicitlyClosedAutoCloseable = Internal + 889;
1397	/**	1412	/**
1398	* External problems -- These are problems defined by other plugins	1413	* External problems -- These are problems defined by other plugins
1399	*/	1414	*/

Lines 10-15 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (+3 lines)
10	* Stephan Herrmann - Contributions for	10	* Stephan Herrmann - Contributions for
11	* bug 236385 - [compiler] Warn for potential programming problem if an object is created but not used	11	* bug 236385 - [compiler] Warn for potential programming problem if an object is created but not used
12	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	12	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		13	* bug 349326 - [1.7] new warning for missing try-with-resources
13	*******************************************************************************/	14	*******************************************************************************/
14	package org.eclipse.jdt.internal.compiler.ast;	15	package org.eclipse.jdt.internal.compiler.ast;
15		16
Lines 42-47 Link Here
42	// process arguments	43	// process arguments
43	if (this.arguments != null) {	44	if (this.arguments != null) {
44	for (int i = 0, count = this.arguments.length; i < count; i++) {	45	for (int i = 0, count = this.arguments.length; i < count; i++) {
		46	// if argument is an AutoCloseable insert info that it may be closed (by the target method, i.e.)
		47	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo);
45	flowInfo =	48	flowInfo =
46	this.arguments[i]	49	this.arguments[i]
47	.analyseCode(currentScope, flowContext, flowInfo)	50	.analyseCode(currentScope, flowContext, flowInfo)




 * 							bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
 * 							bug 292478 - Report potentially null across variable assignment
 *     						bug 335093 - [compiler][null] minimal hook for future null annotation support
 *     						bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;


	flowInfo = ((Reference) this.lhs)
		.analyseAssignment(currentScope, flowContext, flowInfo, this, false)
		.unconditionalInits();
	if (local != null) {
		LocalVariableBinding previousTrackerBinding = null;
		if (local.closeTracker != null) {
			// Assigning to a variable already holding an AutoCloseable, has it been closed before?
			previousTrackerBinding = local.closeTracker.binding;
			if (!flowInfo.isDefinitelyNull(local)) // only if previous value may be non-null
				local.closeTracker.recordErrorLocation(this, flowInfo.nullStatus(previousTrackerBinding));
		}
		FakedTrackingVariable.handleResourceAssignment(flowInfo, this, this.expression, local, previousTrackerBinding);
	}
	int nullStatus = this.expression.nullStatus(flowInfo);
	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
		if (nullStatus == FlowInfo.NULL) {

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Block.java (-2 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 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 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	12	package org.eclipse.jdt.internal.compiler.ast;
12		13
Lines 32-41 Link Here
32	int complaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;	33	int complaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;
33	for (int i = 0, max = this.statements.length; i < max; i++) {	34	for (int i = 0, max = this.statements.length; i < max; i++) {
34	Statement stat = this.statements[i];	35	Statement stat = this.statements[i];
35	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {	36	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, flowContext, this.scope, complaintLevel, true)) < Statement.COMPLAINED_UNREACHABLE) {
36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);	37	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);
37	}	38	}
38	}	39	}
		40	if (this.explicitDeclarations > 0) // if block has its own scope analyze tracking vars now:
		41	this.scope.checkUnclosedCloseables(flowInfo, flowContext, null);
39	return flowInfo;	42	return flowInfo;
40	}	43	}
41	/**	44	/**




 *     						bug 292478 - Report potentially null across variable assignment
 * 							bug 324178 - [null] ConditionalExpression.nullStatus(..) doesn't take into account the analysis of condition itself
 * 							bug 354554 - [null] conditional with redundant condition yields weak error message
 *     						bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;


				trueFlowInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);
			}
			if (!isKnowDeadCodePattern(this.condition) || currentScope.compilerOptions().reportDeadCodeInTrivialIfStatement) {
				this.valueIfTrue.complainIfUnreachable(trueFlowInfo, flowContext, currentScope, initialComplaintLevel, false);
			}
		}
		this.trueInitStateIndex = currentScope.methodScope().recordInitializationStates(trueFlowInfo);

				falseFlowInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);
			}
			if (!isKnowDeadCodePattern(this.condition) || currentScope.compilerOptions().reportDeadCodeInTrivialIfStatement) {
				this.valueIfFalse.complainIfUnreachable(falseFlowInfo, flowContext, currentScope, initialComplaintLevel, true);
			}
		}
		this.falseInitStateIndex = currentScope.methodScope().recordInitializationStates(falseFlowInfo);

Lines 7-13 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ConstructorDeclaration.java (-2 / +4 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for Bug 343713 - [compiler] bogus line number in constructor of inner class in 1.5 compliance	10	* Stephan Herrmann - Contributions for
		11	* bug 343713 - [compiler] bogus line number in constructor of inner class in 1.5 compliance
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
Lines 151-157 Link Here
151	int complaintLevel = (nonStaticFieldInfoReachMode & FlowInfo.UNREACHABLE) == 0 ? Statement.NOT_COMPLAINED : Statement.COMPLAINED_FAKE_REACHABLE;	153	int complaintLevel = (nonStaticFieldInfoReachMode & FlowInfo.UNREACHABLE) == 0 ? Statement.NOT_COMPLAINED : Statement.COMPLAINED_FAKE_REACHABLE;
152	for (int i = 0, count = this.statements.length; i < count; i++) {	154	for (int i = 0, count = this.statements.length; i < count; i++) {
153	Statement stat = this.statements[i];	155	Statement stat = this.statements[i];
154	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {	156	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, constructorContext, this.scope, complaintLevel, true)) < Statement.COMPLAINED_UNREACHABLE) {
155	flowInfo = stat.analyseCode(this.scope, constructorContext, flowInfo);	157	flowInfo = stat.analyseCode(this.scope, constructorContext, flowInfo);
156	}	158	}
157	}	159	}




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

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;


	}

	// Report an error if necessary
	public int complainIfUnreachable(FlowInfo flowInfo, FlowContext flowContext, BlockScope scope, int complaintLevel, boolean endOfBlock) {
		// before 1.4, empty statements are tolerated anywhere
		if (scope.compilerOptions().complianceLevel < ClassFileConstants.JDK1_4) {
			return complaintLevel;
		}
		return super.complainIfUnreachable(flowInfo, flowContext, scope, complaintLevel, endOfBlock);
	}

	public void generateCode(BlockScope currentScope, CodeStream codeStream){




/*******************************************************************************
 * Copyright (c) 2011 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.compiler.ast;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import org.eclipse.jdt.core.compiler.CharOperation;
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.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;

/**
 * A faked local variable declaration used for keeping track of data flows of a
 * special variable. Certain events will be recorded by changing the null info
 * for this variable.
 * 
 * See bug 349326 - [1.7] new warning for missing try-with-resources
 */
public class FakedTrackingVariable extends LocalDeclaration {

	private static final int CLOSE_SEEN = 1;
	private static final int PASSED_TO_OUTSIDE = 2;
	// If close() is invoked from a nested method (inside a local type) report remaining problems only as potential:
	private static final int CLOSED_IN_NESTED_METHOD = 4;
	private static final int REPORTED = 8;
	
	/**
	 * Bitset of {@link #CLOSE_SEEN}, {@link #PASSED_TO_OUTSIDE} and {@link #CLOSED_IN_NESTED_METHOD}.
	 */
	private int globalClosingState = 0;

	MethodScope methodScope; // designates the method declaring this variable
	
	public LocalVariableBinding originalBinding; // the real local being tracked
	
	HashMap recordedLocations; // initially null, ASTNode -> Integer 


	public FakedTrackingVariable(LocalVariableBinding original, Statement location) {
		super(original.name, location.sourceStart, location.sourceEnd);
		this.type = new SingleTypeReference(
				TypeConstants.OBJECT,
				((long)this.sourceStart <<32)+this.sourceEnd);
		this.methodScope = original.declaringScope.methodScope();
		this.originalBinding = original;
		resolve(original.declaringScope);
	}
	
	public void generateCode(BlockScope currentScope, CodeStream codeStream)
	{ /* NOP - this variable is completely dummy, ie. for analysis only. */ }

	public void resolve (BlockScope scope) {
		// only need the binding, which is used as reference in FlowInfo methods.
		this.binding = new LocalVariableBinding(
				this.name,
				scope.getJavaLangObject(),  // dummy, just needs to be a reference type
				0,
				false);
		this.binding.setConstant(Constant.NotAConstant);
		this.binding.useFlag = LocalVariableBinding.USED;
		// use a free slot without assigning it:
		this.binding.id = scope.registerTrackingVariable(this);
	}

	/**
	 * If expression resolves to a local variable binding of type AutoCloseable,
	 * answer the variable that tracks closing of that local, creating it if needed.
	 * @param expression
	 * @return a new {@link FakedTrackingVariable} or null.
	 */
	public static FakedTrackingVariable getCloseTrackingVariable(Expression expression) {
		if (expression instanceof SingleNameReference) {
			SingleNameReference name = (SingleNameReference) expression;
			if (name.binding instanceof LocalVariableBinding) {
				LocalVariableBinding local = (LocalVariableBinding)name.binding;
				if (local.closeTracker != null)
					return local.closeTracker;
				if (local.isParameter() || !isAutoCloseable(expression.resolvedType))
					return null;
				// tracking var doesn't yet exist. This happens in finally block
				// which is analyzed before the corresponding try block
				Statement location = local.declaration;
				return local.closeTracker = new FakedTrackingVariable(local, location);
			}
		}
		return null;
	}

	/** if 'invocationSite' is a call to close() that has a registered tracking variable, answer that variable's binding. */
	public static LocalVariableBinding getTrackerForCloseCall(ASTNode invocationSite) {
		if (invocationSite instanceof MessageSend) {
			MessageSend send = (MessageSend) invocationSite;
			if (CharOperation.equals(TypeConstants.CLOSE, send.selector) && send.receiver instanceof SingleNameReference) {
				Binding receiverBinding = ((SingleNameReference)send.receiver).binding;
				if (receiverBinding instanceof LocalVariableBinding) {
					FakedTrackingVariable trackingVariable = ((LocalVariableBinding)receiverBinding).closeTracker;
					if (trackingVariable != null)
						return trackingVariable.binding;
				}
			}
		}
		return null;
	}

	/** 
	 * Check if the rhs of an assignment or local declaration is an (Auto)Closeable.
	 * If so create or re-use a tracking variable, and wire and initialize everything. 
	 */
	public static void handleResourceAssignment(FlowInfo flowInfo, Statement location, Expression rhs, LocalVariableBinding local,
				LocalVariableBinding previousTrackerBinding) 
	{
		if (isAutoCloseable(rhs.resolvedType)) {
			// new value is AutoCloseable, start tracking, possibly re-using existing tracker var:
	
			FakedTrackingVariable rhsTrackVar = getCloseTrackingVariable(rhs);
			if (rhsTrackVar != null) {								// 1. share tracking variable with RHS?
				local.closeTracker = rhsTrackVar;
				// keep null-status unchanged across this assignment
			} else if (previousTrackerBinding != null) {			// 2. re-use tracking variable from the LHS?
				// re-assigning from a fresh, mark as not-closed again:
				flowInfo.markAsDefinitelyNull(previousTrackerBinding);
			} else {												// 3. no re-use, create a fresh tracking variable:
				local.closeTracker = new FakedTrackingVariable(local, location);
				// a fresh resource, mark as not-closed:
				flowInfo.markAsDefinitelyNull(local.closeTracker.binding);
// TODO(stephan): this might be useful, but I could not find a test case for it: 
//				if (flowContext.initsOnFinally != null)
//					flowContext.initsOnFinally.markAsDefinitelyNonNull(trackerBinding);
			}
		}
	}

	/** Answer wither the given type binding is a subtype of java.lang.AutoCloseable. */
	public static boolean isAutoCloseable(TypeBinding typeBinding) {
		return typeBinding instanceof ReferenceBinding
			&& ((ReferenceBinding)typeBinding).hasTypeBit(TypeIds.BitAutoCloseable|TypeIds.BitCloseable);
	}

	/** Mark that this resource is closed locally. */
	public void markClose(FlowInfo flowInfo, FlowContext flowContext) {
		flowInfo.markAsDefinitelyNonNull(this.binding);
		this.globalClosingState |= CLOSE_SEEN;
//TODO(stephan): this might be useful, but I could not find a test case for it: 
//		if (flowContext.initsOnFinally != null)
//			flowContext.initsOnFinally.markAsDefinitelyNonNull(this.binding);		
	}

	/** Mark that this resource is closed from a nested method (inside a local class). */
	public void markClosedInNestedMethod() {
		this.globalClosingState |= CLOSED_IN_NESTED_METHOD;
	}

	/** 
	 * Mark that this resource is passed to some outside code
	 * (as argument to a method/ctor call or as a return value from the current method), 
	 * and thus should be considered as potentially closed.
	 */
	public static FlowInfo markPassedToOutside(BlockScope scope, Expression expression, FlowInfo flowInfo) {
		FakedTrackingVariable trackVar = getCloseTrackingVariable(expression);
		if (trackVar != null) {
			trackVar.globalClosingState |= PASSED_TO_OUTSIDE;
			if (scope.methodScope() != trackVar.methodScope)
				trackVar.globalClosingState |= CLOSED_IN_NESTED_METHOD;
			// insert info that the tracked resource *may* be closed (by the target method, i.e.)
			FlowInfo infoResourceIsClosed = flowInfo.copy();
			infoResourceIsClosed.markAsDefinitelyNonNull(trackVar.binding);
			return FlowInfo.conditional(flowInfo, infoResourceIsClosed);
		}
		return flowInfo;
	}
	
	public void recordErrorLocation(ASTNode location, int nullStatus) {
		if (this.recordedLocations == null)
			this.recordedLocations = new HashMap();
		this.recordedLocations.put(location, new Integer(nullStatus));
	}

	public boolean reportRecordedErrors(Scope scope) {
		if (this.globalClosingState == 0) {
			reportError(scope.problemReporter(), null, FlowInfo.NULL);
			return true;
		}
		boolean hasReported = false;
		if (this.recordedLocations != null) {
			Iterator locations = this.recordedLocations.entrySet().iterator();
			while (locations.hasNext()) {
				Map.Entry entry = (Entry) locations.next();
				reportError(scope.problemReporter(), (ASTNode)entry.getKey(), ((Integer)entry.getValue()).intValue());
				hasReported = true;
			}
		}
		return hasReported;
	}
	
	public void reportError(ProblemReporter problemReporter, ASTNode location, int nullStatus) {
		if (nullStatus == FlowInfo.NULL) {
			if ((this.globalClosingState & CLOSED_IN_NESTED_METHOD) != 0)
				problemReporter.potentiallyUnclosedCloseable(this, location);
			else
				problemReporter.unclosedCloseable(this, location);
		} else if (nullStatus == FlowInfo.POTENTIALLY_NULL) {
			problemReporter.potentiallyUnclosedCloseable(this, location);
		}		
	}

	public void reportExplicitClosing(ProblemReporter problemReporter) {
		if ((this.globalClosingState & REPORTED) == 0) {
			this.globalClosingState |= REPORTED;
			problemReporter.explicitlyClosedAutoCloseable(this);
		}
		
	}
}

Lines 7-13 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ForStatement.java (-2 / +4 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	10	* Stephan Herrmann - Contributions for
		11	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
Lines 138-144 Link Here
138	actionInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);	140	actionInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);
139	}	141	}
140	}	142	}
141	if (this.action.complainIfUnreachable(actionInfo, this.scope, initialComplaintLevel) < Statement.COMPLAINED_UNREACHABLE) {	143	if (this.action.complainIfUnreachable(actionInfo, flowContext, this.scope, initialComplaintLevel, true) < Statement.COMPLAINED_UNREACHABLE) {
142	actionInfo = this.action.analyseCode(this.scope, loopingContext, actionInfo).unconditionalInits();	144	actionInfo = this.action.analyseCode(this.scope, loopingContext, actionInfo).unconditionalInits();
143	}	145	}
144		146

Lines 7-12 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java (-1 / +2 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	12	package org.eclipse.jdt.internal.compiler.ast;
12		13
Lines 99-105 Link Here
99	if (!(this.action == null \|\| (this.action.isEmptyBlock()	100	if (!(this.action == null \|\| (this.action.isEmptyBlock()
100	&& currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3))) {	101	&& currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3))) {
101		102
102	if (this.action.complainIfUnreachable(actionInfo, this.scope, initialComplaintLevel) < Statement.COMPLAINED_UNREACHABLE) {	103	if (this.action.complainIfUnreachable(actionInfo, flowContext, this.scope, initialComplaintLevel, true) < Statement.COMPLAINED_UNREACHABLE) {
103	actionInfo = this.action.analyseCode(this.scope, loopingContext, actionInfo).unconditionalCopy();	104	actionInfo = this.action.analyseCode(this.scope, loopingContext, actionInfo).unconditionalCopy();
104	}	105	}
105		106

Lines 7-13 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/IfStatement.java (-3 / +7 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	10	* Stephan Herrmann - Contributions for
		11	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
Lines 89-95 Link Here
89	this.thenInitStateIndex = currentScope.methodScope().recordInitializationStates(thenFlowInfo);	91	this.thenInitStateIndex = currentScope.methodScope().recordInitializationStates(thenFlowInfo);
90	if (isConditionOptimizedFalse \|\| ((this.bits & ASTNode.IsThenStatementUnreachable) != 0)) {	92	if (isConditionOptimizedFalse \|\| ((this.bits & ASTNode.IsThenStatementUnreachable) != 0)) {
91	if (!isKnowDeadCodePattern(this.condition) \|\| currentScope.compilerOptions().reportDeadCodeInTrivialIfStatement) {	93	if (!isKnowDeadCodePattern(this.condition) \|\| currentScope.compilerOptions().reportDeadCodeInTrivialIfStatement) {
92	this.thenStatement.complainIfUnreachable(thenFlowInfo, currentScope, initialComplaintLevel);	94	this.thenStatement.complainIfUnreachable(thenFlowInfo, flowContext, currentScope, initialComplaintLevel, false);
93	} else {	95	} else {
94	// its a known coding pattern which should be tolerated by dead code analysis	96	// its a known coding pattern which should be tolerated by dead code analysis
95	// according to isKnowDeadCodePattern()	97	// according to isKnowDeadCodePattern()
Lines 115-121 Link Here
115	this.elseInitStateIndex = currentScope.methodScope().recordInitializationStates(elseFlowInfo);	117	this.elseInitStateIndex = currentScope.methodScope().recordInitializationStates(elseFlowInfo);
116	if (isConditionOptimizedTrue \|\| ((this.bits & ASTNode.IsElseStatementUnreachable) != 0)) {	118	if (isConditionOptimizedTrue \|\| ((this.bits & ASTNode.IsElseStatementUnreachable) != 0)) {
117	if (!isKnowDeadCodePattern(this.condition) \|\| currentScope.compilerOptions().reportDeadCodeInTrivialIfStatement) {	119	if (!isKnowDeadCodePattern(this.condition) \|\| currentScope.compilerOptions().reportDeadCodeInTrivialIfStatement) {
118	this.elseStatement.complainIfUnreachable(elseFlowInfo, currentScope, initialComplaintLevel);	120	this.elseStatement.complainIfUnreachable(elseFlowInfo, flowContext, currentScope, initialComplaintLevel, false);
119	} else {	121	} else {
120	// its a known coding pattern which should be tolerated by dead code analysis	122	// its a known coding pattern which should be tolerated by dead code analysis
121	// according to isKnowDeadCodePattern()	123	// according to isKnowDeadCodePattern()
Lines 124-129 Link Here
124	}	126	}
125	elseFlowInfo = this.elseStatement.analyseCode(currentScope, flowContext, elseFlowInfo);	127	elseFlowInfo = this.elseStatement.analyseCode(currentScope, flowContext, elseFlowInfo);
126	}	128	}
		129	// process AutoCloseable resources closed in only one branch:
		130	currentScope.correlateTrackingVarsIfElse(thenFlowInfo, elseFlowInfo);
127	// merge THEN & ELSE initializations	131	// merge THEN & ELSE initializations
128	FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranchesIfElse(	132	FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranchesIfElse(
129	thenFlowInfo,	133	thenFlowInfo,

Lines 8-14 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (-1 / +18 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Nick Teryaev - fix for bug (https://bugs.eclipse.org/bugs/show_bug.cgi?id=40752)	10	* Nick Teryaev - fix for bug (https://bugs.eclipse.org/bugs/show_bug.cgi?id=40752)
11	* Stephan Herrmann - Contribution for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	11	* Stephan Herrmann - Contributions for
		12	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		13	* bug 349326 - [1.7] new warning for missing try-with-resources
12	*******************************************************************************/	14	*******************************************************************************/
13	package org.eclipse.jdt.internal.compiler.ast;	15	package org.eclipse.jdt.internal.compiler.ast;
14		16
Lines 38-43 Link Here
38	import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;	40	import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
39	import org.eclipse.jdt.internal.compiler.lookup.TagBits;	41	import org.eclipse.jdt.internal.compiler.lookup.TagBits;
40	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;	42	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
		43	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
41	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	44	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
42	import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;	45	import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
43		46
Lines 60-65 Link Here
60	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	63	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
61	boolean nonStatic = !this.binding.isStatic();	64	boolean nonStatic = !this.binding.isStatic();
62	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic).unconditionalInits();	65	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic).unconditionalInits();
		66	// recording the closing of AutoCloseable resources:
		67	if (CharOperation.equals(TypeConstants.CLOSE, this.selector))
		68	{
		69	FakedTrackingVariable trackingVariable = FakedTrackingVariable.getCloseTrackingVariable(this.receiver);
		70	if (trackingVariable != null) { // null happens if receiver is not a local variable or not an AutoCloseable
		71	if (trackingVariable.methodScope == currentScope.methodScope()) {
		72	trackingVariable.markClose(flowInfo, flowContext);
		73	} else {
		74	trackingVariable.markClosedInNestedMethod();
		75	}
		76	}
		77	}
63	if (nonStatic) {	78	if (nonStatic) {
64	this.receiver.checkNPE(currentScope, flowContext, flowInfo);	79	this.receiver.checkNPE(currentScope, flowContext, flowInfo);
65	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682	80	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682
Lines 80-85 Link Here
80	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {	95	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {
81	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	96	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);
82	}	97	}
		98	// if argument is an AutoCloseable insert info that it may be closed (by the target method, i.e.)
		99	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo);
83	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();	100	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
84	}	101	}
85	}	102	}




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;


				int complaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) == 0 ? Statement.NOT_COMPLAINED : Statement.COMPLAINED_FAKE_REACHABLE;
				for (int i = 0, count = this.statements.length; i < count; i++) {
					Statement stat = this.statements[i];
					if ((complaintLevel = stat.complainIfUnreachable(flowInfo, methodContext, this.scope, complaintLevel, true)) < Statement.COMPLAINED_UNREACHABLE) {
						flowInfo = stat.analyseCode(this.scope, methodContext, flowInfo);
					}
				}

				}
					
			}
			this.scope.checkUnclosedCloseables(flowInfo, methodContext, null/*don't report against a specific location*/);
		} catch (AbortMethod e) {
			this.ignoreFurtherInvestigation = true;
		}

Lines 7-13 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (-1 / +5 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	10	* Stephan Herrmann - Contributions for
		11	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
Lines 72-77 Link Here
72	// process arguments	74	// process arguments
73	if (this.arguments != null) {	75	if (this.arguments != null) {
74	for (int i = 0, count = this.arguments.length; i < count; i++) {	76	for (int i = 0, count = this.arguments.length; i < count; i++) {
		77	// if argument is an AutoCloseable insert info that it may be closed (by the target method, i.e.)
		78	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo);
75	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo);	79	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo);
76	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {	80	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {
77	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	81	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);

Lines 7-13 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java (-1 / +12 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	10	* Stephan Herrmann - Contributions for
		11	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
Lines 39-44 Link Here
39	flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo);	41	flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo);
40	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {	42	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
41	this.expression.checkNPE(currentScope, flowContext, flowInfo);	43	this.expression.checkNPE(currentScope, flowContext, flowInfo);
		44	}
		45	FakedTrackingVariable trackingVariable = FakedTrackingVariable.getCloseTrackingVariable(this.expression);
		46	if (trackingVariable != null) {
		47	if (currentScope.methodScope() != trackingVariable.methodScope)
		48	trackingVariable.markClosedInNestedMethod();
		49	// don't report issues concerning this local, since by returning
		50	// the method passes the responsibility to the caller:
		51	currentScope.removeTrackingVar(trackingVariable);
42	}	52	}
43	}	53	}
44	this.initStateIndex =	54	this.initStateIndex =
Lines 104-109 Link Here
104	this.expression.bits \|= ASTNode.IsReturnedValue;	114	this.expression.bits \|= ASTNode.IsReturnedValue;
105	}	115	}
106	}	116	}
		117	currentScope.checkUnclosedCloseables(flowInfo, null/ignore exception exits from flowContext/, this);
107	return FlowInfo.DEAD_END;	118	return FlowInfo.DEAD_END;
108	}	119	}
109		120

Lines 7-13 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Statement.java (-2 / +8 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 335093 - [compiler][null] minimal hook for future null annotation support	10	* Stephan Herrmann - Contributions for
		11	* bug 335093 - [compiler][null] minimal hook for future null annotation support
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
Lines 70-87 Link Here
70		72
71	// Report an error if necessary (if even more unreachable than previously reported	73	// Report an error if necessary (if even more unreachable than previously reported
72	// complaintLevel = 0 if was reachable up until now, 1 if fake reachable (deadcode), 2 if fatal unreachable (error)	74	// complaintLevel = 0 if was reachable up until now, 1 if fake reachable (deadcode), 2 if fatal unreachable (error)
73	public int complainIfUnreachable(FlowInfo flowInfo, BlockScope scope, int previousComplaintLevel) {	75	public int complainIfUnreachable(FlowInfo flowInfo, FlowContext flowContext, BlockScope scope, int previousComplaintLevel, boolean endOfBlock) {
74	if ((flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0) {	76	if ((flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0) {
75	if ((flowInfo.reachMode() & FlowInfo.UNREACHABLE_OR_DEAD) != 0)	77	if ((flowInfo.reachMode() & FlowInfo.UNREACHABLE_OR_DEAD) != 0)
76	this.bits &= ~ASTNode.IsReachable;	78	this.bits &= ~ASTNode.IsReachable;
77	if (flowInfo == FlowInfo.DEAD_END) {	79	if (flowInfo == FlowInfo.DEAD_END) {
78	if (previousComplaintLevel < COMPLAINED_UNREACHABLE) {	80	if (previousComplaintLevel < COMPLAINED_UNREACHABLE) {
79	scope.problemReporter().unreachableCode(this);	81	scope.problemReporter().unreachableCode(this);
		82	if (endOfBlock)
		83	scope.checkUnclosedCloseables(flowInfo, flowContext, null);
80	}	84	}
81	return COMPLAINED_UNREACHABLE;	85	return COMPLAINED_UNREACHABLE;
82	} else {	86	} else {
83	if (previousComplaintLevel < COMPLAINED_FAKE_REACHABLE) {	87	if (previousComplaintLevel < COMPLAINED_FAKE_REACHABLE) {
84	scope.problemReporter().fakeReachable(this);	88	scope.problemReporter().fakeReachable(this);
		89	if (endOfBlock)
		90	scope.checkUnclosedCloseables(flowInfo, flowContext, null);
85	}	91	}
86	return COMPLAINED_FAKE_REACHABLE;	92	return COMPLAINED_FAKE_REACHABLE;
87	}	93	}

Lines 7-13 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java (-2 / +4 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	10	* Stephan Herrmann - Contributions for
		11	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
Lines 99-105 Link Here
99	} else {	101	} else {
100	fallThroughState = FALLTHROUGH; // reset below if needed	102	fallThroughState = FALLTHROUGH; // reset below if needed
101	}	103	}
102	if ((complaintLevel = statement.complainIfUnreachable(caseInits, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {	104	if ((complaintLevel = statement.complainIfUnreachable(caseInits, flowContext, this.scope, complaintLevel, true)) < Statement.COMPLAINED_UNREACHABLE) {
103	caseInits = statement.analyseCode(this.scope, switchContext, caseInits);	105	caseInits = statement.analyseCode(this.scope, switchContext, caseInits);
104	if (caseInits == FlowInfo.DEAD_END) {	106	if (caseInits == FlowInfo.DEAD_END) {
105	fallThroughState = ESCAPING;	107	fallThroughState = ESCAPING;

Lines 10-15 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TryStatement.java (-4 / +17 lines)
10	* Stephan Herrmann - Contributions for	10	* Stephan Herrmann - Contributions for
11	* bug 332637 - Dead Code detection removing code that isn't dead	11	* bug 332637 - Dead Code detection removing code that isn't dead
12	* bug 358827 - [1.7] exception analysis for t-w-r spoils null analysis	12	* bug 358827 - [1.7] exception analysis for t-w-r spoils null analysis
		13	* bug 349326 - [1.7] new warning for missing try-with-resources
13	*******************************************************************************/	14	*******************************************************************************/
14	package org.eclipse.jdt.internal.compiler.ast;	15	package org.eclipse.jdt.internal.compiler.ast;
15		16
Lines 126-133 Link Here
126	for (int i = 0; i < resourcesLength; i++) {	127	for (int i = 0; i < resourcesLength; i++) {
127	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());	128	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());
128	this.postResourcesInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(flowInfo);	129	this.postResourcesInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(flowInfo);
129	this.resources[i].binding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.	130	LocalVariableBinding resourceBinding = this.resources[i].binding;
130	TypeBinding type = this.resources[i].binding.type;	131	resourceBinding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.
		132	if (resourceBinding.closeTracker != null) {
		133	// this was false alarm, we don't need to track the resource
		134	this.tryBlock.scope.removeTrackingVar(resourceBinding.closeTracker);
		135	resourceBinding.closeTracker = null;
		136	}
		137	TypeBinding type = resourceBinding.type;
131	if (type != null && type.isValidBinding()) {	138	if (type != null && type.isValidBinding()) {
132	ReferenceBinding binding = (ReferenceBinding) type;	139	ReferenceBinding binding = (ReferenceBinding) type;
133	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter	140	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter
Lines 252-259 Link Here
252	for (int i = 0; i < resourcesLength; i++) {	259	for (int i = 0; i < resourcesLength; i++) {
253	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());	260	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());
254	this.postResourcesInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(flowInfo);	261	this.postResourcesInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(flowInfo);
255	this.resources[i].binding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.	262	LocalVariableBinding resourceBinding = this.resources[i].binding;
256	TypeBinding type = this.resources[i].binding.type;	263	resourceBinding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.
		264	if (resourceBinding.closeTracker != null) {
		265	// this was false alarm, we don't need to track the resource
		266	this.tryBlock.scope.removeTrackingVar(resourceBinding.closeTracker);
		267	resourceBinding.closeTracker = null;
		268	}
		269	TypeBinding type = resourceBinding.type;
257	if (type != null && type.isValidBinding()) {	270	if (type != null && type.isValidBinding()) {
258	ReferenceBinding binding = (ReferenceBinding) type;	271	ReferenceBinding binding = (ReferenceBinding) type;
259	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter	272	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter

Lines 7-13 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java (-2 / +4 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	10	* Stephan Herrmann - Contributions for
		11	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
Lines 113-119 Link Here
113	currentScope.methodScope().recordInitializationStates(	115	currentScope.methodScope().recordInitializationStates(
114	condInfo.initsWhenTrue());	116	condInfo.initsWhenTrue());
115		117
116	if (this.action.complainIfUnreachable(actionInfo, currentScope, initialComplaintLevel) < Statement.COMPLAINED_UNREACHABLE) {	118	if (this.action.complainIfUnreachable(actionInfo, flowContext, currentScope, initialComplaintLevel, true) < Statement.COMPLAINED_UNREACHABLE) {
117	actionInfo = this.action.analyseCode(currentScope, loopingContext, actionInfo);	119	actionInfo = this.action.analyseCode(currentScope, loopingContext, actionInfo);
118	}	120	}
119		121




 *     						bug 292478 - Report potentially null across variable assignment
 *     						bug 332637 - Dead Code detection removing code that isn't dead
 *     						bug 341499 - [compiler][null] allocate extra bits in all methods of UnconditionalFlowInfo
 *     						bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.flow;


	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1)
			>= this.extra[2].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return ((this.extra[2][vectorIndex] & this.extra[4][vectorIndex]

	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >=
			this.extra[2].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return ((this.extra[2][vectorIndex] & this.extra[3][vectorIndex]

	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >=
			this.extra[2].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return ((this.extra[2][vectorIndex] & this.extra[5][vectorIndex]

	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >=
			this.extra[2].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return ((this.extra[4][vectorIndex]

	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >=
			this.extra[2].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return ((this.extra[3][vectorIndex]

	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >=
			this.extra[2].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return (this.extra[5][vectorIndex]

Lines 8-15 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java (-4 / +38 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Benjamin Muskalla - Contribution for bug 239066	10	* Benjamin Muskalla - Contribution for bug 239066
11	* Stephan Herrmann - Contribution for bug 236385	11	* Stephan Herrmann - Contributions for
12	* Stephan Herrmann - Contribution for bug 295551	12	* bug 236385 - [compiler] Warn for potential programming problem if an object is created but not used
		13	* bug 295551 - Add option to automatically promote all warnings to errors
		14	* bug 349326 - [1.7] new warning for missing try-with-resources
13	*******************************************************************************/	15	*******************************************************************************/
14	package org.eclipse.jdt.internal.compiler.impl;	16	package org.eclipse.jdt.internal.compiler.impl;
15		17
Lines 137-142 Link Here
137	public static final String OPTION_ReportMethodCanBeStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"; //$NON-NLS-1$	139	public static final String OPTION_ReportMethodCanBeStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"; //$NON-NLS-1$
138	public static final String OPTION_ReportMethodCanBePotentiallyStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$	140	public static final String OPTION_ReportMethodCanBePotentiallyStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$
139	public static final String OPTION_ReportRedundantSpecificationOfTypeArguments = "org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments"; //$NON-NLS-1$	141	public static final String OPTION_ReportRedundantSpecificationOfTypeArguments = "org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments"; //$NON-NLS-1$
		142	public static final String OPTION_ReportUnclosedCloseable = "org.eclipse.jdt.core.compiler.problem.unclosedCloseable"; //$NON-NLS-1$
		143	public static final String OPTION_ReportPotentiallyUnclosedCloseable = "org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable"; //$NON-NLS-1$
		144	public static final String OPTION_ReportExplicitlyClosedAutoCloseable = "org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable"; //$NON-NLS-1$
140	/**	145	/**
141	* Possible values for configurable options	146	* Possible values for configurable options
142	*/	147	*/
Lines 240-245 Link Here
240	public static final int MethodCanBeStatic = IrritantSet.GROUP2 \| ASTNode.Bit5;	245	public static final int MethodCanBeStatic = IrritantSet.GROUP2 \| ASTNode.Bit5;
241	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 \| ASTNode.Bit6;	246	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 \| ASTNode.Bit6;
242	public static final int RedundantSpecificationOfTypeArguments = IrritantSet.GROUP2 \| ASTNode.Bit7;	247	public static final int RedundantSpecificationOfTypeArguments = IrritantSet.GROUP2 \| ASTNode.Bit7;
		248	// bits 8-10 reserved for https://bugs.eclipse.org/bugs/show_bug.cgi?id=186342
		249	public static final int UnclosedCloseable = IrritantSet.GROUP2 \| ASTNode.Bit11;
		250	public static final int PotentiallyUnclosedCloseable = IrritantSet.GROUP2 \| ASTNode.Bit12;
		251	public static final int ExplicitlyClosedAutoCloseable = IrritantSet.GROUP2 \| ASTNode.Bit13;
243		252
244	// Severity level for handlers	253	// Severity level for handlers
245	/**	254	/**
Lines 376-383 Link Here
376	"javadoc", //$NON-NLS-1$	385	"javadoc", //$NON-NLS-1$
377	"nls", //$NON-NLS-1$	386	"nls", //$NON-NLS-1$
378	"null", //$NON-NLS-1$	387	"null", //$NON-NLS-1$
379	"restriction", //$NON-NLS-1$
380	"rawtypes", //$NON-NLS-1$	388	"rawtypes", //$NON-NLS-1$
		389	"resource", //$NON-NLS-1$
		390	"restriction", //$NON-NLS-1$
381	"serial", //$NON-NLS-1$	391	"serial", //$NON-NLS-1$
382	"static-access", //$NON-NLS-1$	392	"static-access", //$NON-NLS-1$
383	"static-method", //$NON-NLS-1$	393	"static-method", //$NON-NLS-1$
Lines 551-556 Link Here
551	return OPTION_ReportMethodCanBePotentiallyStatic;	561	return OPTION_ReportMethodCanBePotentiallyStatic;
552	case RedundantSpecificationOfTypeArguments :	562	case RedundantSpecificationOfTypeArguments :
553	return OPTION_ReportRedundantSpecificationOfTypeArguments;	563	return OPTION_ReportRedundantSpecificationOfTypeArguments;
		564	case UnclosedCloseable :
		565	return OPTION_ReportUnclosedCloseable;
		566	case PotentiallyUnclosedCloseable :
		567	return OPTION_ReportPotentiallyUnclosedCloseable;
		568	case ExplicitlyClosedAutoCloseable :
		569	return OPTION_ReportExplicitlyClosedAutoCloseable;
554	}	570	}
555	return null;	571	return null;
556	}	572	}
Lines 714-719 Link Here
714	OPTION_ReportUnusedTypeArgumentsForMethodInvocation,	730	OPTION_ReportUnusedTypeArgumentsForMethodInvocation,
715	OPTION_ReportUnusedWarningToken,	731	OPTION_ReportUnusedWarningToken,
716	OPTION_ReportVarargsArgumentNeedCast,	732	OPTION_ReportVarargsArgumentNeedCast,
		733	OPTION_ReportUnclosedCloseable,
		734	OPTION_ReportPotentiallyUnclosedCloseable,
		735	OPTION_ReportExplicitlyClosedAutoCloseable,
717	};	736	};
718	return result;	737	return result;
719	}	738	}
Lines 784-793 Link Here
784	case MethodCanBeStatic :	803	case MethodCanBeStatic :
785	case MethodCanBePotentiallyStatic :	804	case MethodCanBePotentiallyStatic :
786	return "static-method"; //$NON-NLS-1$	805	return "static-method"; //$NON-NLS-1$
		806	case PotentiallyUnclosedCloseable:
		807	case UnclosedCloseable:
		808	case ExplicitlyClosedAutoCloseable:
		809	return "resource"; //$NON-NLS-1$
787	case InvalidJavadoc :	810	case InvalidJavadoc :
788	case MissingJavadocComments :	811	case MissingJavadocComments :
789	case MissingJavadocTags:	812	case MissingJavadocTags:
790	return "javadoc"; //$NON-NLS-1$	813	return "javadoc"; //$NON-NLS-1$
791	}	814	}
792	return null;	815	return null;
793	}	816	}
Lines 841-846 Link Here
841	case 'r' :	864	case 'r' :
842	if ("rawtypes".equals(warningToken)) //$NON-NLS-1$	865	if ("rawtypes".equals(warningToken)) //$NON-NLS-1$
843	return IrritantSet.RAW;	866	return IrritantSet.RAW;
		867	if ("resource".equals(warningToken)) //$NON-NLS-1$
		868	return IrritantSet.RESOURCE;
844	if ("restriction".equals(warningToken)) //$NON-NLS-1$	869	if ("restriction".equals(warningToken)) //$NON-NLS-1$
845	return IrritantSet.RESTRICTION;	870	return IrritantSet.RESTRICTION;
846	break;	871	break;
Lines 980-985 Link Here
980	optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic));	1005	optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic));
981	optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic));	1006	optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic));
982	optionsMap.put(OPTION_ReportRedundantSpecificationOfTypeArguments, getSeverityString(RedundantSpecificationOfTypeArguments));	1007	optionsMap.put(OPTION_ReportRedundantSpecificationOfTypeArguments, getSeverityString(RedundantSpecificationOfTypeArguments));
		1008	optionsMap.put(OPTION_ReportUnclosedCloseable, getSeverityString(UnclosedCloseable));
		1009	optionsMap.put(OPTION_ReportPotentiallyUnclosedCloseable, getSeverityString(PotentiallyUnclosedCloseable));
		1010	optionsMap.put(OPTION_ReportExplicitlyClosedAutoCloseable, getSeverityString(ExplicitlyClosedAutoCloseable));
983	return optionsMap;	1011	return optionsMap;
984	}	1012	}
985		1013
Lines 1410-1415 Link Here
1410	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBeStatic)) != null) updateSeverity(MethodCanBeStatic, optionValue);	1438	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBeStatic)) != null) updateSeverity(MethodCanBeStatic, optionValue);
1411	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBePotentiallyStatic)) != null) updateSeverity(MethodCanBePotentiallyStatic, optionValue);	1439	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBePotentiallyStatic)) != null) updateSeverity(MethodCanBePotentiallyStatic, optionValue);
1412	if ((optionValue = optionsMap.get(OPTION_ReportRedundantSpecificationOfTypeArguments)) != null) updateSeverity(RedundantSpecificationOfTypeArguments, optionValue);	1440	if ((optionValue = optionsMap.get(OPTION_ReportRedundantSpecificationOfTypeArguments)) != null) updateSeverity(RedundantSpecificationOfTypeArguments, optionValue);
		1441	if ((optionValue = optionsMap.get(OPTION_ReportUnclosedCloseable)) != null) updateSeverity(UnclosedCloseable, optionValue);
		1442	if ((optionValue = optionsMap.get(OPTION_ReportPotentiallyUnclosedCloseable)) != null) updateSeverity(PotentiallyUnclosedCloseable, optionValue);
		1443	if ((optionValue = optionsMap.get(OPTION_ReportExplicitlyClosedAutoCloseable)) != null) updateSeverity(ExplicitlyClosedAutoCloseable, optionValue);
1413		1444
1414	// Javadoc options	1445	// Javadoc options
1415	if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {	1446	if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {
Lines 1625-1630 Link Here
1625	buf.append("\n\t- method can be static: ").append(getSeverityString(MethodCanBeStatic)); //$NON-NLS-1$	1656	buf.append("\n\t- method can be static: ").append(getSeverityString(MethodCanBeStatic)); //$NON-NLS-1$
1626	buf.append("\n\t- method can be potentially static: ").append(getSeverityString(MethodCanBePotentiallyStatic)); //$NON-NLS-1$	1657	buf.append("\n\t- method can be potentially static: ").append(getSeverityString(MethodCanBePotentiallyStatic)); //$NON-NLS-1$
1627	buf.append("\n\t- redundant specification of type arguments: ").append(getSeverityString(RedundantSpecificationOfTypeArguments)); //$NON-NLS-1$	1658	buf.append("\n\t- redundant specification of type arguments: ").append(getSeverityString(RedundantSpecificationOfTypeArguments)); //$NON-NLS-1$
		1659	buf.append("\n\t- resource is not closed: ").append(getSeverityString(UnclosedCloseable)); //$NON-NLS-1$
		1660	buf.append("\n\t- resource may not be closed: ").append(getSeverityString(PotentiallyUnclosedCloseable)); //$NON-NLS-1$
		1661	buf.append("\n\t- resource should be handled by try-with-resources: ").append(getSeverityString(ExplicitlyClosedAutoCloseable)); //$NON-NLS-1$
1628	return buf.toString();	1662	return buf.toString();
1629	}	1663	}
1630		1664




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/

package org.eclipse.jdt.internal.compiler.impl;

	public static final IrritantSet UNUSED = new IrritantSet(CompilerOptions.UnusedLocalVariable);
	public static final IrritantSet UNCHECKED = new IrritantSet(CompilerOptions.UncheckedTypeOperation);
	public static final IrritantSet UNQUALIFIED_FIELD_ACCESS = new IrritantSet(CompilerOptions.UnqualifiedFieldAccess);
	public static final IrritantSet RESOURCE = new IrritantSet(CompilerOptions.UnclosedCloseable);

	public static final IrritantSet JAVADOC = new IrritantSet(CompilerOptions.InvalidJavadoc);
	public static final IrritantSet COMPILER_DEFAULT_ERRORS = new IrritantSet(0); // no optional error by default	

			// group-2 warnings enabled by default
			.set(
				CompilerOptions.DeadCode
				|CompilerOptions.Tasks
				|CompilerOptions.UnclosedCloseable);
			
		ALL.setAll();
		HIDING

			.set(CompilerOptions.RedundantSpecificationOfTypeArguments);
		STATIC_METHOD
		    .set(CompilerOptions.MethodCanBePotentiallyStatic);
		RESOURCE
			.set(CompilerOptions.PotentiallyUnclosedCloseable)
			.set(CompilerOptions.ExplicitlyClosedAutoCloseable);
		String suppressRawWhenUnchecked = System.getProperty("suppressRawWhenUnchecked"); //$NON-NLS-1$
		if (suppressRawWhenUnchecked != null && "true".equalsIgnoreCase(suppressRawWhenUnchecked)) { //$NON-NLS-1$
			UNCHECKED.set(CompilerOptions.RawTypeReference);

Lines 7-12 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java (-2 / +21 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 972-977 Link Here
972	variable.resolve();	973	variable.resolve();
973	return variable;	974	return variable;
974	}	975	}
		976	public boolean hasTypeBit(int bit) {
		977	// ensure hierarchy is resolved, which will propagate bits down to us
		978	superclass();
		979	superInterfaces();
		980	return (this.typeBits & bit) != 0;
		981	}
975	private void initializeTypeVariable(TypeVariableBinding variable, TypeVariableBinding[] existingVariables, SignatureWrapper wrapper, char[][][] missingTypeNames) {	982	private void initializeTypeVariable(TypeVariableBinding variable, TypeVariableBinding[] existingVariables, SignatureWrapper wrapper, char[][][] missingTypeNames) {
976	// ParameterSignature = Identifier ':' TypeSignature	983	// ParameterSignature = Identifier ':' TypeSignature
977	// or Identifier ':' TypeSignature(optional) InterfaceBound(s)	984	// or Identifier ':' TypeSignature(optional) InterfaceBound(s)
Lines 1140-1147 Link Here
1140	// finish resolving the type	1147	// finish resolving the type
1141	this.superclass = (ReferenceBinding) resolveType(this.superclass, this.environment, true /* raw conversion */);	1148	this.superclass = (ReferenceBinding) resolveType(this.superclass, this.environment, true /* raw conversion */);
1142	this.tagBits &= ~TagBits.HasUnresolvedSuperclass;	1149	this.tagBits &= ~TagBits.HasUnresolvedSuperclass;
1143	if (this.superclass.problemId() == ProblemReasons.NotFound)	1150	if (this.superclass.problemId() == ProblemReasons.NotFound) {
1144	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency	1151	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency
		1152	} else {
		1153	// make super-type resolving recursive for propagating typeBits downwards
		1154	this.superclass.superclass();
		1155	this.superclass.superInterfaces();
		1156	}
		1157	this.typeBits \|= this.superclass.typeBits;
1145	return this.superclass;	1158	return this.superclass;
1146	}	1159	}
1147	// NOTE: superInterfaces of binary types are resolved when needed	1160	// NOTE: superInterfaces of binary types are resolved when needed
Lines 1151-1158 Link Here
1151		1164
1152	for (int i = this.superInterfaces.length; --i >= 0;) {	1165	for (int i = this.superInterfaces.length; --i >= 0;) {
1153	this.superInterfaces[i] = (ReferenceBinding) resolveType(this.superInterfaces[i], this.environment, true /* raw conversion */);	1166	this.superInterfaces[i] = (ReferenceBinding) resolveType(this.superInterfaces[i], this.environment, true /* raw conversion */);
1154	if (this.superInterfaces[i].problemId() == ProblemReasons.NotFound)	1167	if (this.superInterfaces[i].problemId() == ProblemReasons.NotFound) {
1155	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency	1168	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency
		1169	} else {
		1170	// make super-type resolving recursive for propagating typeBits downwards
		1171	this.superInterfaces[i].superclass();
		1172	this.superInterfaces[i].superInterfaces();
		1173	}
		1174	this.typeBits \|= this.superInterfaces[i].typeBits;
1156	}	1175	}
1157	this.tagBits &= ~TagBits.HasUnresolvedSuperinterfaces;	1176	this.tagBits &= ~TagBits.HasUnresolvedSuperinterfaces;
1158	return this.superInterfaces;	1177	return this.superInterfaces;

Lines 7-19 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java (+147 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
		13
		14	import java.util.ArrayList;
		15	import java.util.List;
12		16
13	import org.eclipse.jdt.core.compiler.CharOperation;	17	import org.eclipse.jdt.core.compiler.CharOperation;
14	import org.eclipse.jdt.internal.compiler.ast.*;	18	import org.eclipse.jdt.internal.compiler.ast.*;
15	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	19	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;	20	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
		21	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
		22	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
17	import org.eclipse.jdt.internal.compiler.impl.Constant;	23	import org.eclipse.jdt.internal.compiler.impl.Constant;
18	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;	24	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
19		25
Lines 957-960 Link Here
957	}	963	}
958	}	964	}
959	}	965	}
		966
		967	private List trackingVariables; // can be null if no resources are tracked
		968	/**
		969	* Register a tracking variable and compute its id.
		970	*/
		971	public int registerTrackingVariable(FakedTrackingVariable fakedTrackingVariable) {
		972	if (this.trackingVariables == null)
		973	this.trackingVariables = new ArrayList(3);
		974	this.trackingVariables.add(fakedTrackingVariable);
		975	MethodScope outerMethodScope = outerMostMethodScope();
		976	return outerMethodScope.analysisIndex + (outerMethodScope.trackVarCount++);
		977
		978	}
		979	/** When no longer interested in this tracking variable remove it. */
		980	public void removeTrackingVar(FakedTrackingVariable trackingVariable) {
		981	if (this.trackingVariables != null)
		982	if (this.trackingVariables.remove(trackingVariable))
		983	return;
		984	if (this.parent instanceof BlockScope)
		985	((BlockScope)this.parent).removeTrackingVar(trackingVariable);
		986	}
		987	/**
		988	* At the end of a block check the closing-status of all tracked closeables that are declared in this block.
		989	* Also invoked when entering unreachable code.
		990	*/
		991	public void checkUnclosedCloseables(FlowInfo flowInfo, FlowContext flowContext, ASTNode location) {
		992	if (this.trackingVariables == null) {
		993	// at a method return we also consider enclosing scopes
		994	if (location != null && this.parent instanceof BlockScope)
		995	((BlockScope) this.parent).checkUnclosedCloseables(flowInfo, flowContext, location);
		996	return;
		997	}
		998	if (location != null && flowInfo.reachMode() != 0) return;
		999	for (int i=0; i<this.trackingVariables.size(); i++) {
		1000	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
		1001	if (location != null && trackingVar.originalBinding != null && flowInfo.isDefinitelyNull(trackingVar.originalBinding))
		1002	continue; // reporting against a specific location, resource is null at this flow, don't complain
		1003	int status = getNullStatusAggressively(trackingVar.binding, flowInfo);
		1004	if (status == FlowInfo.NULL) {
		1005	// definitely unclosed: highest priority
		1006	reportResourceLeak(trackingVar, location, status);
		1007	if (location == null) {
		1008	// definitely done with this trackingVar, remove it
		1009	this.trackingVariables.remove(trackingVar);
		1010	i--; // ... but don't disturb the enclosing loop.
		1011	}
		1012	continue;
		1013	}
		1014	if (location == null) // at end of block and not definitely unclosed
		1015	{
		1016	// problems at specific locations: medium priority
		1017	if (trackingVar.reportRecordedErrors(this)) // ... report previously recorded errors
		1018	continue;
		1019	}
		1020	if (status == FlowInfo.POTENTIALLY_NULL) {
		1021	// potentially unclosed: lower priority
		1022	reportResourceLeak(trackingVar, location, status);
		1023	} else if (status == FlowInfo.NON_NULL) {
		1024	// properly closed but not managed by t-w-r: lowest priority
		1025	if (environment().globalOptions.complianceLevel >= ClassFileConstants.JDK1_7)
		1026	trackingVar.reportExplicitClosing(problemReporter());
		1027	}
		1028	}
		1029	}
1030	private void reportResourceLeak(FakedTrackingVariable trackingVar, ASTNode location, int nullStatus) {
1031	if (location != null)
1032	trackingVar.recordErrorLocation(location, nullStatus);
1033	else
1034	trackingVar.reportError(problemReporter(), null, nullStatus);
1035	}
1036
1037	/**
1038	* If one branch of an if-else closes any AutoCloseable resource, and if the same
1039	* resource is known to be null on the other branch mark it as closed, too,
1040	* so that merging both branches indicates that the resource is always closed.
1041	* Example:
1042	* FileReader fr1 = null;
1043	* try {\n" +
1044	* fr1 = new FileReader(someFile);" +
1045	* fr1.read(buf);\n" +
1046	* } finally {\n" +
1047	* if (fr1 != null)\n" +
1048	* try {\n" +
1049	* fr1.close();\n" +
1050	* } catch (IOException e) {
1051	* // do nothing
1052	* }
1053	* // after this if statement fr1 is definitely not leaked
1054	* }
1055	*/
1056	public void correlateTrackingVarsIfElse(FlowInfo thenFlowInfo, FlowInfo elseFlowInfo) {
1057	if (this.trackingVariables != null) {
1058	for (int i=0; i<this.trackingVariables.size(); i++) {
1059	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
1060	if ( thenFlowInfo.isDefinitelyNonNull(trackingVar.binding) // closed in then branch
1061	&& elseFlowInfo.isDefinitelyNull(trackingVar.originalBinding)) // null in else branch
1062	{
1063	elseFlowInfo.markAsDefinitelyNonNull(trackingVar.binding); // -> always closed
1064	}
1065	else if ( elseFlowInfo.isDefinitelyNonNull(trackingVar.binding) // closed in else branch
1066	&& thenFlowInfo.isDefinitelyNull(trackingVar.originalBinding)) // null in then branch
1067	{
1068	thenFlowInfo.markAsDefinitelyNonNull(trackingVar.binding); // -> always closed
1069	}
1070	}
1071	}
1072	if (this.parent instanceof BlockScope)
1073	((BlockScope) this.parent).correlateTrackingVarsIfElse(thenFlowInfo, elseFlowInfo);
1074	}
1075
1076	/**
1077	* Get the null status looking even into unreachable flows
1078	* @param local
1079	* @param flowInfo
1080	* @return one of the constants FlowInfo.{NULL,POTENTIALLY_NULL,POTENTIALLY_NON_NULL,NON_NULL}.
1081	*/
1082	private int getNullStatusAggressively(LocalVariableBinding local, FlowInfo flowInfo) {
1083	int reachMode = flowInfo.reachMode();
1084	int status = 0;
1085	try {
1086	// unreachable flowInfo is too shy in reporting null-issues, temporarily forget reachability:
1087	if (reachMode != FlowInfo.REACHABLE)
1088	flowInfo.tagBits &= ~FlowInfo.UNREACHABLE;
1089	status = flowInfo.nullStatus(local);
1090	} finally {
1091	// reset
1092	flowInfo.tagBits \|= reachMode;
1093	}
1094	// at this point some combinations are not useful so flatten to a single bit:
1095	if ((status & FlowInfo.NULL) != 0) {
1096	if ((status & (FlowInfo.NON_NULL \| FlowInfo.POTENTIALLY_NON_NULL)) != 0)
1097	return FlowInfo.POTENTIALLY_NULL; // null + doubt = pot null
1098	return FlowInfo.NULL;
1099	} else if ((status & FlowInfo.NON_NULL) != 0) {
1100	if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
1101	return FlowInfo.POTENTIALLY_NULL; // non-null + doubt = pot null
1102	return FlowInfo.NON_NULL;
1103	} else if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
1104	return FlowInfo.POTENTIALLY_NULL;
1105	return status;
1106	}
960	}	1107	}




 *     						Bug 328281 - visibility leaks not detected when analyzing unused field in private class
 *     						Bug 300576 - NPE Computing type hierarchy when compliance doesn't match libraries
 *     						Bug 354536 - compiling package-info.java still depends on the order of compilation units
 *     						Bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;


			} else {
				// only want to reach here when no errors are reported
				sourceType.superclass = superclass;
				sourceType.typeBits |= superclass.typeBits;
				return true;
			}
		}

				noProblems &= superInterfaceRef.resolvedType.isValidBinding();
			}
			// only want to reach here when no errors are reported
			sourceType.typeBits |= superInterface.typeBits;
			interfaceBindings[count++] = superInterface;
		}
		// hold onto all correctly resolved superinterfaces

Lines 7-12 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodScope.java (+4 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 49-54 Link Here
49	// inner-emulation	50	// inner-emulation
50	public SyntheticArgumentBinding[] extraSyntheticArguments;	51	public SyntheticArgumentBinding[] extraSyntheticArguments;
51		52
		53	// count number of tracking variables, see FakedTrackingVariable
		54	int trackVarCount = 0;
		55
52	public MethodScope(ClassScope parent, ReferenceContext context, boolean isStatic) {	56	public MethodScope(ClassScope parent, ReferenceContext context, boolean isStatic) {
53	super(METHOD_SCOPE, parent);	57	super(METHOD_SCOPE, parent);
54	this.locals = new LocalVariableBinding[5];	58	this.locals = new LocalVariableBinding[5];

Lines 7-12 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java (+8 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 629-634 Link Here
629	return this.type.hasMemberTypes();	630	return this.type.hasMemberTypes();
630	}	631	}
631		632
		633	public boolean hasTypeBit(int bit) {
		634	TypeBinding erasure = erasure();
		635	if (erasure instanceof ReferenceBinding)
		636	return ((ReferenceBinding) erasure).hasTypeBit(bit);
		637	return false;
		638	}
		639
632	/**	640	/**
633	* @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#implementsMethod(MethodBinding)	641	* @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#implementsMethod(MethodBinding)
634	*/	642	*/

Lines 7-12 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ProblemReferenceBinding.java (+7 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 40-45 Link Here
40	return this.closestMatch;	41	return this.closestMatch;
41	}	42	}
42		43
		44	public boolean hasTypeBit(int bit) {
		45	if (this.closestMatch != null)
		46	return this.closestMatch.hasTypeBit(bit);
		47	return false;
		48	}
		49
43	/* API	50	/* API
44	* Answer the problem id associated with the receiver.	51	* Answer the problem id associated with the receiver.
45	* NoError if the receiver is a valid binding.	52	* NoError if the receiver is a valid binding.

Lines 7-12 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java (-2 / +15 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 41-47 Link Here
41		42
42	private SimpleLookupTable compatibleCache;	43	private SimpleLookupTable compatibleCache;
43		44
44	public static final ReferenceBinding LUB_GENERIC = new ReferenceBinding() { /* used for lub computation */};	45	int typeBits; // additional bits characterizing this type
		46
		47	public static final ReferenceBinding LUB_GENERIC = new ReferenceBinding() { /* used for lub computation */
		48	public boolean hasTypeBit(int bit) { return false; }
		49	};
45		50
46	private static final Comparator FIELD_COMPARATOR = new Comparator() {	51	private static final Comparator FIELD_COMPARATOR = new Comparator() {
47	public int compare(Object o1, Object o2) {	52	public int compare(Object o1, Object o2) {
Lines 392-397 Link Here
392	case 'i' :	397	case 'i' :
393	if (CharOperation.equals(packageName, TypeConstants.IO)) {	398	if (CharOperation.equals(packageName, TypeConstants.IO)) {
394	switch (typeName[0]) {	399	switch (typeName[0]) {
		400	case 'C' :
		401	if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_CLOSEABLE[2]))
		402	this.typeBits \|= TypeIds.BitCloseable; // don't assign id, only typeBit (for analysis of resource leaks)
		403	return;
395	case 'E' :	404	case 'E' :
396	if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_EXTERNALIZABLE[2]))	405	if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_EXTERNALIZABLE[2]))
397	this.id = TypeIds.T_JavaIoExternalizable;	406	this.id = TypeIds.T_JavaIoExternalizable;
Lines 438-445 Link Here
438	case 'A' :	447	case 'A' :
439	switch(typeName.length) {	448	switch(typeName.length) {
440	case 13 :	449	case 13 :
441	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2]))	450	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2])) {
442	this.id = TypeIds.T_JavaLangAutoCloseable;	451	this.id = TypeIds.T_JavaLangAutoCloseable;
		452	this.typeBits \|= TypeIds.BitAutoCloseable;
		453	}
443	return;	454	return;
444	case 14:	455	case 14:
445	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))	456	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))
Lines 937-942 Link Here
937	public final boolean hasRestrictedAccess() {	948	public final boolean hasRestrictedAccess() {
938	return (this.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0;	949	return (this.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0;
939	}	950	}
		951	/** Answer an additional bit characterizing this type, like {@link TypeIds#BitAutoCloseable}. */
		952	abstract public boolean hasTypeBit(int bit);
940		953
941	/** Answer true if the receiver implements anInterface or is identical to anInterface.	954	/** Answer true if the receiver implements anInterface or is identical to anInterface.
942	* If searchHierarchy is true, then also search the receiver's superclasses.	955	* If searchHierarchy is true, then also search the receiver's superclasses.

Lines 7-13 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java (-1 / +8 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann <stephan@cs.tu-berlin.de> - Contribution for bug 328281 - visibility leaks not detected when analyzing unused field in private class	10	* Stephan Herrmann <stephan@cs.tu-berlin.de> - Contributions for
		11	* bug 328281 - visibility leaks not detected when analyzing unused field in private class
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.lookup;	14	package org.eclipse.jdt.internal.compiler.lookup;
13		15
Lines 1063-1068 Link Here
1063	return accessors[1];	1065	return accessors[1];
1064	}	1066	}
1065		1067
		1068	public boolean hasTypeBit(int bit) {
		1069	// source types initialize type bits during connectSuperclass/interfaces()
		1070	return (this.typeBits & bit) != 0;
		1071	}
		1072
1066	/**	1073	/**
1067	* @see org.eclipse.jdt.internal.compiler.lookup.Binding#initializeDeprecatedAnnotationTagBits()	1074	* @see org.eclipse.jdt.internal.compiler.lookup.Binding#initializeDeprecatedAnnotationTagBits()
1068	*/	1075	*/




 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;


	char[][] JAVA_LANG_ANNOTATION_ELEMENTTYPE = {JAVA, LANG, ANNOTATION, "ElementType".toCharArray()}; //$NON-NLS-1$
	char[][] JAVA_LANG_REFLECT_FIELD = new char[][] {JAVA, LANG, REFLECT, "Field".toCharArray()}; //$NON-NLS-1$
	char[][] JAVA_LANG_REFLECT_METHOD = new char[][] {JAVA, LANG, REFLECT, "Method".toCharArray()}; //$NON-NLS-1$
	char[][] JAVA_IO_CLOSEABLE = new char[][] { JAVA, IO, "Closeable".toCharArray()};//$NON-NLS-1$
	char[][] JAVA_IO_OBJECTSTREAMEXCEPTION = new char[][] { JAVA, IO, "ObjectStreamException".toCharArray()};//$NON-NLS-1$
	char[][] JAVA_IO_EXTERNALIZABLE = {JAVA, IO, "Externalizable".toCharArray()}; //$NON-NLS-1$
	char[][] JAVA_IO_IOEXCEPTION = new char[][] { JAVA, IO, "IOException".toCharArray()};//$NON-NLS-1$

			"MethodHandle$PolymorphicSignature".toCharArray() //$NON-NLS-1$
	};
	char[][] JAVA_LANG_AUTOCLOSEABLE =  {JAVA, LANG, "AutoCloseable".toCharArray()}; //$NON-NLS-1$
	char[] CLOSE = "close".toCharArray(); //$NON-NLS-1$

	// Constraints for generic type argument inference
	int CONSTRAINT_EQUAL = 0;		// Actual = Formal




 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;


	final int Object2boolean = T_JavaLangObject + (T_boolean << 4);
	final int BOXING = 0x200;
	final int UNBOXING = 0x400;

	/** 
	 * Marks all sub-types of java.lang.AutoCloseable.
	 * @see ReferenceBinding#hasTypeBit(int)
	 */
	final int BitAutoCloseable = 1;
	/** 
	 * Marks all sub-types of java.io.Closeable.
	 * @see ReferenceBinding#hasTypeBit(int)
	 */
	final int BitCloseable = 2;
}

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java (-2 / +18 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 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 7-13 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann <stephan@cs.tu-berlin.de> - Contribution for bug 282152 - [1.5][compiler] Generics code rejected by Eclipse but accepted by javac	10	* Stephan Herrmann <stephan@cs.tu-berlin.de> - Contributions for
		11	* bug 282152 - [1.5][compiler] Generics code rejected by Eclipse but accepted by javac
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.lookup;	14	package org.eclipse.jdt.internal.compiler.lookup;
13		15
Lines 42-47 Link Here
42	this.modifiers = ClassFileConstants.AccPublic \| ExtraCompilerModifiers.AccGenericSignature; // treat type var as public	44	this.modifiers = ClassFileConstants.AccPublic \| ExtraCompilerModifiers.AccGenericSignature; // treat type var as public
43	this.tagBits \|= TagBits.HasTypeVariable;	45	this.tagBits \|= TagBits.HasTypeVariable;
44	this.environment = environment;	46	this.environment = environment;
		47	this.typeBits = -1;
45	}	48	}
46		49
47	/**	50	/**
Lines 307-312 Link Here
307	return true;	310	return true;
308	}	311	}
309		312
		313	public boolean hasTypeBit(int bit) {
		314	if (this.typeBits == -1) {
		315	// initialize from bounds
		316	this.typeBits = 0;
		317	if (this.superclass != null)
		318	this.typeBits \|= this.superclass.typeBits;
		319	if (this.superInterfaces != null)
		320	for (int i = 0, l = this.superInterfaces.length; i < l; i++)
		321	this.typeBits \|= this.superInterfaces[i].typeBits;
		322	}
		323	return (this.typeBits & bit) != 0;
		324	}
		325
310	/**	326	/**
311	* Returns true if the type variable is directly bound to a given type	327	* Returns true if the type variable is directly bound to a given type
312	*/	328	*/

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedReferenceBinding.java (-1 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 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 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 41-46 Link Here
41	public String debugName() {	42	public String debugName() {
42	return toString();	43	return toString();
43	}	44	}
		45	public boolean hasTypeBit(int bit) {
		46	// shouldn't happen since we are not called before analyseCode(), but play safe:
		47	return false;
		48	}
44	ReferenceBinding resolve(LookupEnvironment environment, boolean convertGenericToRawType) {	49	ReferenceBinding resolve(LookupEnvironment environment, boolean convertGenericToRawType) {
45	ReferenceBinding targetType = this.resolvedType;	50	ReferenceBinding targetType = this.resolvedType;
46	if (targetType == null) {	51	if (targetType == null) {

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java (-1 / +16 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2009 IBM Corporation and others.	2	* Copyright (c) 2005, 2011 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 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 54-59 Link Here
54	if (bound instanceof UnresolvedReferenceBinding)	55	if (bound instanceof UnresolvedReferenceBinding)
55	((UnresolvedReferenceBinding) bound).addWrapper(this, environment);	56	((UnresolvedReferenceBinding) bound).addWrapper(this, environment);
56	this.tagBits \|= TagBits.HasUnresolvedTypeVariables; // cleared in resolve()	57	this.tagBits \|= TagBits.HasUnresolvedTypeVariables; // cleared in resolve()
		58	this.typeBits = -1;
57	}	59	}
58		60
59	public int kind() {	61	public int kind() {
Lines 420-425 Link Here
420	return this.genericType.hashCode();	422	return this.genericType.hashCode();
421	}	423	}
422		424
		425	public boolean hasTypeBit(int bit) {
		426	if (this.typeBits == -1) {
		427	// initialize from upper bounds
		428	this.typeBits = 0;
		429	if (this.superclass != null)
		430	this.typeBits \|= this.superclass.typeBits;
		431	if (this.superInterfaces != null)
		432	for (int i = 0, l = this.superInterfaces.length; i < l; i++)
		433	this.typeBits \|= this.superInterfaces[i].typeBits;
		434	}
		435	return (this.typeBits & bit) != 0;
		436	}
		437
423	void initialize(ReferenceBinding someGenericType, TypeBinding someBound, TypeBinding[] someOtherBounds) {	438	void initialize(ReferenceBinding someGenericType, TypeBinding someBound, TypeBinding[] someOtherBounds) {
424	this.genericType = someGenericType;	439	this.genericType = someGenericType;
425	this.bound = someBound;	440	this.bound = someBound;




 *     Stephan Herrmann  - Contributions for 
 *     						bug 236385 - 
 *     						bug 338303 - Warning about Redundant assignment conflicts with definite assignment
 *     						bug 349326 - [1.7] new warning for missing try-with-resources
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.problem;


import org.eclipse.jdt.internal.compiler.ast.EqualExpression;
import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.FakedTrackingVariable;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.FieldReference;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;

			
		case IProblem.MethodCanBePotentiallyStatic:
			return CompilerOptions.MethodCanBePotentiallyStatic;

		case IProblem.UnclosedCloseable:
		case IProblem.UnclosedCloseableAtExit:
			return CompilerOptions.UnclosedCloseable;
		case IProblem.PotentiallyUnclosedCloseable:
		case IProblem.PotentiallyUnclosedCloseableAtExit:
			return CompilerOptions.PotentiallyUnclosedCloseable;
		case IProblem.ExplicitlyClosedAutoCloseable:
			return CompilerOptions.ExplicitlyClosedAutoCloseable;
				
		case IProblem.RedundantSpecificationOfTypeArguments:
			return CompilerOptions.RedundantSpecificationOfTypeArguments;

			case CompilerOptions.ParameterAssignment :
			case CompilerOptions.MethodCanBeStatic :
			case CompilerOptions.MethodCanBePotentiallyStatic :
			case CompilerOptions.ExplicitlyClosedAutoCloseable :
				return CategorizedProblem.CAT_CODE_STYLE;

			case CompilerOptions.MaskedCatchBlock :

			case CompilerOptions.ShouldImplementHashcode :
			case CompilerOptions.DeadCode :
			case CompilerOptions.UnusedObjectAllocation :
			case CompilerOptions.UnclosedCloseable :
			case CompilerOptions.PotentiallyUnclosedCloseable :
				return CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM;
			
			case CompilerOptions.OverriddenPackageDefaultMethod :

			location.sourceEnd);
    }
}
public void potentiallyUnclosedCloseable(FakedTrackingVariable trackVar, ASTNode location) {
	String[] args = { String.valueOf(trackVar.name) };
	if (location == null) {
		this.handle(
			IProblem.PotentiallyUnclosedCloseable,
			args,
			args,
			trackVar.sourceStart,
			trackVar.sourceEnd);
	} else {
		this.handle(
			IProblem.PotentiallyUnclosedCloseableAtExit,
			args,
			args,
			location.sourceStart,
			location.sourceEnd);
	}
}
public void unclosedCloseable(FakedTrackingVariable trackVar, ASTNode location) {
	String[] args = { String.valueOf(trackVar.name) };
	if (location == null) {
		this.handle(
			IProblem.UnclosedCloseable,
			args,
			args,
			trackVar.sourceStart,
			trackVar.sourceEnd);
	} else {
		this.handle(
			IProblem.UnclosedCloseableAtExit,
			args,
			args,
			location.sourceStart,
			location.sourceEnd);
	}
}
public void explicitlyClosedAutoCloseable(FakedTrackingVariable trackVar) {
	String[] args = { String.valueOf(trackVar.name) };
	this.handle(
		IProblem.ExplicitlyClosedAutoCloseable,
		args,
		args,
		trackVar.sourceStart,
		trackVar.sourceEnd);	
}
}

Lines 8-14 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (-1 / +8 lines)
8	# Contributors:	8	# Contributors:
9	# IBM Corporation - initial API and implementation	9	# IBM Corporation - initial API and implementation
10	# Benjamin Muskalla - Contribution for bug 239066	10	# Benjamin Muskalla - Contribution for bug 239066
11	# Stephan Herrmann <stephan@cs.tu-berlin.de> - Contribution for bug 185682 - Increment/decrement operators mark local variables as read	11	# Stephan Herrmann <stephan@cs.tu-berlin.de> - Contributions for
		12	# bug 185682 - Increment/decrement operators mark local variables as read
		13	# bug 349326 - [1.7] new warning for missing try-with-resources
12	###############################################################################	14	###############################################################################
13	0 = {0}	15	0 = {0}
14	1 = super cannot be used in java.lang.Object	16	1 = super cannot be used in java.lang.Object
Lines 644-649 Link Here
644	882 = Unhandled exception type {0} thrown by automatic close() invocation on {1}	646	882 = Unhandled exception type {0} thrown by automatic close() invocation on {1}
645	883 = '<>' operator is not allowed for source level below 1.7	647	883 = '<>' operator is not allowed for source level below 1.7
646	884 = Redundant specification of type arguments <{0}>	648	884 = Redundant specification of type arguments <{0}>
		649	885 = Potential resource leak: '{0}' may not be closed
		650	886 = Potential resource leak: '{0}' may not be closed at this location
		651	887 = Resource leak: '{0}' is never closed
		652	888 = Resource leak: '{0}' is not closed at this location
		653	889 = Resource '{0}' should be managed by try-with-resource
647		654
648	### ELABORATIONS	655	### ELABORATIONS
649	## Access restrictions	656	## Access restrictions

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CompilationUnit.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 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 867-873 Link Here
867		867
868	/**	868	/**
869	* Enables the recording of changes to this compilation	869	* Enables the recording of changes to this compilation
870	* unit and its descendents. The compilation unit must have	870	* unit and its descendants. The compilation unit must have
871	* been created by <code>ASTParser</code> and still be in	871	* been created by <code>ASTParser</code> and still be in
872	* its original state. Once recording is on,	872	* its original state. Once recording is on,
873	* arbitrary changes to the subtree rooted at this compilation	873	* arbitrary changes to the subtree rooted at this compilation

Lines 83-88 Link Here

(-)a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java (+50 lines)
83	* Benjamin Muskalla - added COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD	83	* Benjamin Muskalla - added COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD
84	* Stephan Herrmann - added COMPILER_PB_UNUSED_OBJECT_ALLOCATION	84	* Stephan Herrmann - added COMPILER_PB_UNUSED_OBJECT_ALLOCATION
85	* Stephan Herrmann - added COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS	85	* Stephan Herrmann - added COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS
		86	* Stephan Herrmann - added the following constants:
		87	* COMPILER_PB_UNCLOSED_CLOSEABLE,
		88	* COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE
		89	* COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE
86	*******************************************************************************/	90	*******************************************************************************/
87		91
88	package org.eclipse.jdt.core;	92	package org.eclipse.jdt.core;
Lines 1357-1362 Link Here
1357	*/	1361	*/
1358	public static final String COMPILER_PB_POTENTIALLY_MISSING_STATIC_ON_METHOD = PLUGIN_ID + ".compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$	1362	public static final String COMPILER_PB_POTENTIALLY_MISSING_STATIC_ON_METHOD = PLUGIN_ID + ".compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$
1359	/**	1363	/**
		1364	* Compiler option ID: Reporting a resource that is not closed properly.
		1365	* <p>When enabled, that compiler will issue an error or a warning if
		1366	* a local variable holds a value of type <code>java.lang.AutoCloseable</code> (compliance>=1.7)
		1367	* or a value of type <code>java.io.Closeable</code> (compliance<=1.6) and if
		1368	* flow analysis shows that the method <code>close()</code> is not invoked locally on that value.
		1369	* <dl>
		1370	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportUnclosedCloseable"</code></dd>
		1371	* <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
		1372	* <dt>Default:</dt><dd><code>"warning"</code></dd>
		1373	* </dl>
		1374	* @since 3.8
		1375	* @category CompilerOptionID
		1376	*/
		1377	public static final String COMPILER_PB_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.unclosedCloseable"; //$NON-NLS-1$
		1378	/**
		1379	* Compiler option ID: Reporting a resource that may not be closed properly.
		1380	* <p>When enabled, that compiler will issue an error or a warning if
		1381	* a local variable holds a value of type <code>java.lang.AutoCloseable</code> (compliance>=1.7)
		1382	* or a value of type <code>java.io.Closeable</code> (compliance<=1.6) and if
		1383	* flow analysis shows that the method <code>close()</code> is
		1384	* not invoked locally on that value for all execution paths.
		1385	* <dl>
		1386	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportPotentiallyUnclosedCloseable"</code></dd>
		1387	* <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
		1388	* <dt>Default:</dt><dd><code>"ignore"</code></dd>
		1389	* </dl>
		1390	* @since 3.8
		1391	* @category CompilerOptionID
		1392	*/
		1393	public static final String COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.potentiallyUnclosedCloseable"; //$NON-NLS-1$
		1394	/**
		1395	* Compiler option ID: Reporting a resource that is not managed by try-with-resources.
		1396	* <p>When enabled, that compiler will issue an error or a warning if a local variable
		1397	* holds a value of type <code>java.lang.AutoCloseable</code>, and if the method
		1398	* <code>close()</code> is explicitly invoked on that resource, but the resource is
		1399	* not managed by a try-with-resources block.
		1400	* <dl>
		1401	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportPotentiallyUnclosedCloseable"</code></dd>
		1402	* <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
		1403	* <dt>Default:</dt><dd><code>"ignore"</code></dd>
		1404	* </dl>
		1405	* @since 3.8
		1406	* @category CompilerOptionID
		1407	*/
		1408	public static final String COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE = PLUGIN_ID + ".compiler.problem.explicitlyClosedAutoCloseable"; //$NON-NLS-1$
		1409	/**
1360	* Compiler option ID: Setting Source Compatibility Mode.	1410	* Compiler option ID: Setting Source Compatibility Mode.
1361	* <p>Specify whether which source level compatibility is used. From 1.4 on, <code>'assert'</code> is a keyword	1411	* <p>Specify whether which source level compatibility is used. From 1.4 on, <code>'assert'</code> is a keyword
1362	* reserved for assertion support. Also note, than when toggling to 1.4 mode, the target VM	1412	* reserved for assertion support. Also note, than when toggling to 1.4 mode, the target VM

Return to bug 349326

Lines 19-24 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullReferenceTest.java (-6 / +12 lines)
19	* bug 324178 - [null] ConditionalExpression.nullStatus(..) doesn't take into account the analysis of condition itself	19	* bug 324178 - [null] ConditionalExpression.nullStatus(..) doesn't take into account the analysis of condition itself
20	* bug 354554 - [null] conditional with redundant condition yields weak error message	20	* bug 354554 - [null] conditional with redundant condition yields weak error message
21	* bug 358827 - [1.7] exception analysis for t-w-r spoils null analysis	21	* bug 358827 - [1.7] exception analysis for t-w-r spoils null analysis
		22	* bug 349326 - [1.7] new warning for missing try-with-resources
22	*******************************************************************************/	23	*******************************************************************************/
23	package org.eclipse.jdt.core.tests.compiler.regression;	24	package org.eclipse.jdt.core.tests.compiler.regression;
24		25
Lines 6030-6041 Link Here
6030	" }\n" +	6031	" }\n" +
6031	" }\n" +	6032	" }\n" +
6032	"}\n"},	6033	"}\n"},
6033	"----------\n" +	6034	"----------\n" +
6034	"1. ERROR in X.java (at line 8)\n" +	6035	"1. WARNING in X.java (at line 6)\n" +
6035	" o.toString();\n" +	6036	" o = new LineNumberReader(new FileReader(\"dummy\"));\n" +
6036	" ^\n" +	6037	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
6037	"Potential null pointer access: The variable o may be null at this location\n" +	6038	"Resource leak: \'o\' is never closed\n" +
6038	"----------\n",	6039	"----------\n" +
		6040	"2. ERROR in X.java (at line 8)\n" +
		6041	" o.toString();\n" +
		6042	" ^\n" +
		6043	"Potential null pointer access: The variable o may be null at this location\n" +
		6044	"----------\n",
6039	JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);	6045	JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
6040	}	6046	}
6041		6047

Lines 12-17 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java (-2 / +3 lines)
12	* bug 292478 - Report potentially null across variable assignment	12	* bug 292478 - Report potentially null across variable assignment
13	* bug 324178 - [null] ConditionalExpression.nullStatus(..) doesn't take into account the analysis of condition itself	13	* bug 324178 - [null] ConditionalExpression.nullStatus(..) doesn't take into account the analysis of condition itself
14	* bug 354554 - [null] conditional with redundant condition yields weak error message	14	* bug 354554 - [null] conditional with redundant condition yields weak error message
		15	* bug 349326 - [1.7] new warning for missing try-with-resources
15	*******************************************************************************/	16	*******************************************************************************/
16	package org.eclipse.jdt.internal.compiler.ast;	17	package org.eclipse.jdt.internal.compiler.ast;
17		18
Lines 65-71 Link Here
65	trueFlowInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);	66	trueFlowInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);
66	}	67	}
67	if (!isKnowDeadCodePattern(this.condition) \|\| currentScope.compilerOptions().reportDeadCodeInTrivialIfStatement) {	68	if (!isKnowDeadCodePattern(this.condition) \|\| currentScope.compilerOptions().reportDeadCodeInTrivialIfStatement) {
68	this.valueIfTrue.complainIfUnreachable(trueFlowInfo, currentScope, initialComplaintLevel);	69	this.valueIfTrue.complainIfUnreachable(trueFlowInfo, flowContext, currentScope, initialComplaintLevel, false);
69	}	70	}
70	}	71	}
71	this.trueInitStateIndex = currentScope.methodScope().recordInitializationStates(trueFlowInfo);	72	this.trueInitStateIndex = currentScope.methodScope().recordInitializationStates(trueFlowInfo);
Lines 78-84 Link Here
78	falseFlowInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);	79	falseFlowInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);
79	}	80	}
80	if (!isKnowDeadCodePattern(this.condition) \|\| currentScope.compilerOptions().reportDeadCodeInTrivialIfStatement) {	81	if (!isKnowDeadCodePattern(this.condition) \|\| currentScope.compilerOptions().reportDeadCodeInTrivialIfStatement) {
81	this.valueIfFalse.complainIfUnreachable(falseFlowInfo, currentScope, initialComplaintLevel);	82	this.valueIfFalse.complainIfUnreachable(falseFlowInfo, flowContext, currentScope, initialComplaintLevel, true);
82	}	83	}
83	}	84	}
84	this.falseInitStateIndex = currentScope.methodScope().recordInitializationStates(falseFlowInfo);	85	this.falseInitStateIndex = currentScope.methodScope().recordInitializationStates(falseFlowInfo);

Added Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java (+235 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 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.internal.compiler.ast;
12
13	import java.util.HashMap;
14	import java.util.Iterator;
15	import java.util.Map;
16	import java.util.Map.Entry;
17
18	import org.eclipse.jdt.core.compiler.CharOperation;
19	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
20	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
21	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
22	import org.eclipse.jdt.internal.compiler.impl.Constant;
23	import org.eclipse.jdt.internal.compiler.lookup.Binding;
24	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
25	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
26	import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
27	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
28	import org.eclipse.jdt.internal.compiler.lookup.Scope;
29	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
30	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
31	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
32	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
33
34	/**
35	* A faked local variable declaration used for keeping track of data flows of a
36	* special variable. Certain events will be recorded by changing the null info
37	* for this variable.
38	*
39	* See bug 349326 - [1.7] new warning for missing try-with-resources
40	*/
41	public class FakedTrackingVariable extends LocalDeclaration {
42
43	private static final int CLOSE_SEEN = 1;
44	private static final int PASSED_TO_OUTSIDE = 2;
45	// If close() is invoked from a nested method (inside a local type) report remaining problems only as potential:
46	private static final int CLOSED_IN_NESTED_METHOD = 4;
47	private static final int REPORTED = 8;
48
49	/**
50	* Bitset of {@link #CLOSE_SEEN}, {@link #PASSED_TO_OUTSIDE} and {@link #CLOSED_IN_NESTED_METHOD}.
51	*/
52	private int globalClosingState = 0;
53
54	MethodScope methodScope; // designates the method declaring this variable
55
56	public LocalVariableBinding originalBinding; // the real local being tracked
57
58	HashMap recordedLocations; // initially null, ASTNode -> Integer
59
60
61	public FakedTrackingVariable(LocalVariableBinding original, Statement location) {
62	super(original.name, location.sourceStart, location.sourceEnd);
63	this.type = new SingleTypeReference(
64	TypeConstants.OBJECT,
65	((long)this.sourceStart <<32)+this.sourceEnd);
66	this.methodScope = original.declaringScope.methodScope();
67	this.originalBinding = original;
68	resolve(original.declaringScope);
69	}
70
71	public void generateCode(BlockScope currentScope, CodeStream codeStream)
72	{ /* NOP - this variable is completely dummy, ie. for analysis only. */ }
73
74	public void resolve (BlockScope scope) {
75	// only need the binding, which is used as reference in FlowInfo methods.
76	this.binding = new LocalVariableBinding(
77	this.name,
78	scope.getJavaLangObject(), // dummy, just needs to be a reference type
79	0,
80	false);
81	this.binding.setConstant(Constant.NotAConstant);
82	this.binding.useFlag = LocalVariableBinding.USED;
83	// use a free slot without assigning it:
84	this.binding.id = scope.registerTrackingVariable(this);
85	}
86
87	/**
88	* If expression resolves to a local variable binding of type AutoCloseable,
89	* answer the variable that tracks closing of that local, creating it if needed.
90	* @param expression
91	* @return a new {@link FakedTrackingVariable} or null.
92	*/
93	public static FakedTrackingVariable getCloseTrackingVariable(Expression expression) {
94	if (expression instanceof SingleNameReference) {
95	SingleNameReference name = (SingleNameReference) expression;
96	if (name.binding instanceof LocalVariableBinding) {
97	LocalVariableBinding local = (LocalVariableBinding)name.binding;
98	if (local.closeTracker != null)
99	return local.closeTracker;
100	if (local.isParameter() \|\| !isAutoCloseable(expression.resolvedType))
101	return null;
102	// tracking var doesn't yet exist. This happens in finally block
103	// which is analyzed before the corresponding try block
104	Statement location = local.declaration;
105	return local.closeTracker = new FakedTrackingVariable(local, location);
106	}
107	}
108	return null;
109	}
110
111	/** if 'invocationSite' is a call to close() that has a registered tracking variable, answer that variable's binding. */
112	public static LocalVariableBinding getTrackerForCloseCall(ASTNode invocationSite) {
113	if (invocationSite instanceof MessageSend) {
114	MessageSend send = (MessageSend) invocationSite;
115	if (CharOperation.equals(TypeConstants.CLOSE, send.selector) && send.receiver instanceof SingleNameReference) {
116	Binding receiverBinding = ((SingleNameReference)send.receiver).binding;
117	if (receiverBinding instanceof LocalVariableBinding) {
118	FakedTrackingVariable trackingVariable = ((LocalVariableBinding)receiverBinding).closeTracker;
119	if (trackingVariable != null)
120	return trackingVariable.binding;
121	}
122	}
123	}
124	return null;
125	}
126
127	/**
128	* Check if the rhs of an assignment or local declaration is an (Auto)Closeable.
129	* If so create or re-use a tracking variable, and wire and initialize everything.
130	*/
131	public static void handleResourceAssignment(FlowInfo flowInfo, Statement location, Expression rhs, LocalVariableBinding local,
132	LocalVariableBinding previousTrackerBinding)
133	{
134	if (isAutoCloseable(rhs.resolvedType)) {
135	// new value is AutoCloseable, start tracking, possibly re-using existing tracker var:
136
137	FakedTrackingVariable rhsTrackVar = getCloseTrackingVariable(rhs);
138	if (rhsTrackVar != null) { // 1. share tracking variable with RHS?
139	local.closeTracker = rhsTrackVar;
140	// keep null-status unchanged across this assignment
141	} else if (previousTrackerBinding != null) { // 2. re-use tracking variable from the LHS?
142	// re-assigning from a fresh, mark as not-closed again:
143	flowInfo.markAsDefinitelyNull(previousTrackerBinding);
144	} else { // 3. no re-use, create a fresh tracking variable:
145	local.closeTracker = new FakedTrackingVariable(local, location);
146	// a fresh resource, mark as not-closed:
147	flowInfo.markAsDefinitelyNull(local.closeTracker.binding);
148	// TODO(stephan): this might be useful, but I could not find a test case for it:
149	// if (flowContext.initsOnFinally != null)
150	// flowContext.initsOnFinally.markAsDefinitelyNonNull(trackerBinding);
151	}
152	}
153	}
154
155	/** Answer wither the given type binding is a subtype of java.lang.AutoCloseable. */
156	public static boolean isAutoCloseable(TypeBinding typeBinding) {
157	return typeBinding instanceof ReferenceBinding
158	&& ((ReferenceBinding)typeBinding).hasTypeBit(TypeIds.BitAutoCloseable\|TypeIds.BitCloseable);
159	}
160
161	/** Mark that this resource is closed locally. */
162	public void markClose(FlowInfo flowInfo, FlowContext flowContext) {
163	flowInfo.markAsDefinitelyNonNull(this.binding);
164	this.globalClosingState \|= CLOSE_SEEN;
165	//TODO(stephan): this might be useful, but I could not find a test case for it:
166	// if (flowContext.initsOnFinally != null)
167	// flowContext.initsOnFinally.markAsDefinitelyNonNull(this.binding);
168	}
169
170	/** Mark that this resource is closed from a nested method (inside a local class). */
171	public void markClosedInNestedMethod() {
172	this.globalClosingState \|= CLOSED_IN_NESTED_METHOD;
173	}
174
175	/**
176	* Mark that this resource is passed to some outside code
177	* (as argument to a method/ctor call or as a return value from the current method),
178	* and thus should be considered as potentially closed.
179	*/
180	public static FlowInfo markPassedToOutside(BlockScope scope, Expression expression, FlowInfo flowInfo) {
181	FakedTrackingVariable trackVar = getCloseTrackingVariable(expression);
182	if (trackVar != null) {
183	trackVar.globalClosingState \|= PASSED_TO_OUTSIDE;
184	if (scope.methodScope() != trackVar.methodScope)
185	trackVar.globalClosingState \|= CLOSED_IN_NESTED_METHOD;
186	// insert info that the tracked resource may be closed (by the target method, i.e.)
187	FlowInfo infoResourceIsClosed = flowInfo.copy();
188	infoResourceIsClosed.markAsDefinitelyNonNull(trackVar.binding);
189	return FlowInfo.conditional(flowInfo, infoResourceIsClosed);
190	}
191	return flowInfo;
192	}
193
194	public void recordErrorLocation(ASTNode location, int nullStatus) {
195	if (this.recordedLocations == null)
196	this.recordedLocations = new HashMap();
197	this.recordedLocations.put(location, new Integer(nullStatus));
198	}
199
200	public boolean reportRecordedErrors(Scope scope) {
201	if (this.globalClosingState == 0) {
202	reportError(scope.problemReporter(), null, FlowInfo.NULL);
203	return true;
204	}
205	boolean hasReported = false;
206	if (this.recordedLocations != null) {
207	Iterator locations = this.recordedLocations.entrySet().iterator();
208	while (locations.hasNext()) {
209	Map.Entry entry = (Entry) locations.next();
210	reportError(scope.problemReporter(), (ASTNode)entry.getKey(), ((Integer)entry.getValue()).intValue());
211	hasReported = true;
212	}
213	}
214	return hasReported;
215	}
216
217	public void reportError(ProblemReporter problemReporter, ASTNode location, int nullStatus) {
218	if (nullStatus == FlowInfo.NULL) {
219	if ((this.globalClosingState & CLOSED_IN_NESTED_METHOD) != 0)
220	problemReporter.potentiallyUnclosedCloseable(this, location);
221	else
222	problemReporter.unclosedCloseable(this, location);
223	} else if (nullStatus == FlowInfo.POTENTIALLY_NULL) {
224	problemReporter.potentiallyUnclosedCloseable(this, location);
225	}
226	}
227
228	public void reportExplicitClosing(ProblemReporter problemReporter) {
229	if ((this.globalClosingState & REPORTED) == 0) {
230	this.globalClosingState \|= REPORTED;
231	problemReporter.explicitlyClosedAutoCloseable(this);
232	}
233
234	}
235	}

Lines 8-16 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java (-3 / +8 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Benjamin Muskalla - Contribution for bug 239066	10	* Benjamin Muskalla - Contribution for bug 239066
11	* Stephan Herrmann - Contribution for bug 236385	11	* Stephan Herrmann <stephan@cs.tu-berlin.de> - Contributions for
12	* Stephan Herrmann - Contribution for bug 295551	12	* bug 236385 - [compiler] Warn for potential programming problem if an object is created but not used
13	* Stephan Herrmann <stephan@cs.tu-berlin.de> - Contribution for bug 185682 - Increment/decrement operators mark local variables as read	13	* bug 295551 - Add option to automatically promote all warnings to errors
		14	* bug 185682 - Increment/decrement operators mark local variables as read
		15	* bug 349326 - [1.7] new warning for missing try-with-resources
14	*******************************************************************************/	16	*******************************************************************************/
15	package org.eclipse.jdt.core.tests.compiler.regression;	17	package org.eclipse.jdt.core.tests.compiler.regression;
16		18
Lines 1816-1821 Link Here
1816	" <option key=\"org.eclipse.jdt.core.compiler.problem.discouragedReference\" value=\"warning\"/>\n" +	1818	" <option key=\"org.eclipse.jdt.core.compiler.problem.discouragedReference\" value=\"warning\"/>\n" +
1817	" <option key=\"org.eclipse.jdt.core.compiler.problem.emptyStatement\" value=\"ignore\"/>\n" +	1819	" <option key=\"org.eclipse.jdt.core.compiler.problem.emptyStatement\" value=\"ignore\"/>\n" +
1818	" <option key=\"org.eclipse.jdt.core.compiler.problem.enumIdentifier\" value=\"warning\"/>\n" +	1820	" <option key=\"org.eclipse.jdt.core.compiler.problem.enumIdentifier\" value=\"warning\"/>\n" +
		1821	" <option key=\"org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable\" value=\"ignore\"/>\n" +
1819	" <option key=\"org.eclipse.jdt.core.compiler.problem.fallthroughCase\" value=\"ignore\"/>\n" +	1822	" <option key=\"org.eclipse.jdt.core.compiler.problem.fallthroughCase\" value=\"ignore\"/>\n" +
1820	" <option key=\"org.eclipse.jdt.core.compiler.problem.fatalOptionalError\" value=\"disabled\"/>\n" +	1823	" <option key=\"org.eclipse.jdt.core.compiler.problem.fatalOptionalError\" value=\"disabled\"/>\n" +
1821	" <option key=\"org.eclipse.jdt.core.compiler.problem.fieldHiding\" value=\"ignore\"/>\n" +	1824	" <option key=\"org.eclipse.jdt.core.compiler.problem.fieldHiding\" value=\"ignore\"/>\n" +
Lines 1857-1862 Link Here
1857	" <option key=\"org.eclipse.jdt.core.compiler.problem.parameterAssignment\" value=\"ignore\"/>\n" +	1860	" <option key=\"org.eclipse.jdt.core.compiler.problem.parameterAssignment\" value=\"ignore\"/>\n" +
1858	" <option key=\"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment\" value=\"ignore\"/>\n" +	1861	" <option key=\"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment\" value=\"ignore\"/>\n" +
1859	" <option key=\"org.eclipse.jdt.core.compiler.problem.potentialNullReference\" value=\"ignore\"/>\n" +	1862	" <option key=\"org.eclipse.jdt.core.compiler.problem.potentialNullReference\" value=\"ignore\"/>\n" +
		1863	" <option key=\"org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable\" value=\"ignore\"/>\n" +
1860	" <option key=\"org.eclipse.jdt.core.compiler.problem.rawTypeReference\" value=\"warning\"/>\n" +	1864	" <option key=\"org.eclipse.jdt.core.compiler.problem.rawTypeReference\" value=\"warning\"/>\n" +
1861	" <option key=\"org.eclipse.jdt.core.compiler.problem.redundantNullCheck\" value=\"ignore\"/>\n" +	1865	" <option key=\"org.eclipse.jdt.core.compiler.problem.redundantNullCheck\" value=\"ignore\"/>\n" +
1862	" <option key=\"org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments\" value=\"ignore\"/>\n" +	1866	" <option key=\"org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments\" value=\"ignore\"/>\n" +
Lines 1872-1877 Link Here
1872	" <option key=\"org.eclipse.jdt.core.compiler.problem.typeParameterHiding\" value=\"warning\"/>\n" +	1876	" <option key=\"org.eclipse.jdt.core.compiler.problem.typeParameterHiding\" value=\"warning\"/>\n" +
1873	" <option key=\"org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems\" value=\"enabled\"/>\n" +	1877	" <option key=\"org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems\" value=\"enabled\"/>\n" +
1874	" <option key=\"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation\" value=\"warning\"/>\n" +	1878	" <option key=\"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation\" value=\"warning\"/>\n" +
		1879	" <option key=\"org.eclipse.jdt.core.compiler.problem.unclosedCloseable\" value=\"warning\"/>\n" +
1875	" <option key=\"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock\" value=\"ignore\"/>\n" +	1880	" <option key=\"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock\" value=\"ignore\"/>\n" +
1876	" <option key=\"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken\" value=\"warning\"/>\n" +	1881	" <option key=\"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken\" value=\"warning\"/>\n" +
1877	" <option key=\"org.eclipse.jdt.core.compiler.problem.unnecessaryElse\" value=\"ignore\"/>\n" +	1882	" <option key=\"org.eclipse.jdt.core.compiler.problem.unnecessaryElse\" value=\"ignore\"/>\n" +

Lines 8-14 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java (-1 / +13 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Benjamin Muskalla - Contribution for bug 239066	10	* Benjamin Muskalla - Contribution for bug 239066
11	* Stephan Herrmann - Contribution for bug 236385	11	* Stephan Herrmann - Contributions for
		12	* bug 236385: [compiler] Warn for potential programming problem if an object is created but not used
		13	* bug 349326 - [1.7] new warning for missing try-with-resources
12	*******************************************************************************/	14	*******************************************************************************/
13	package org.eclipse.jdt.core.tests.compiler.regression;	15	package org.eclipse.jdt.core.tests.compiler.regression;
14		16
Lines 440-445 Link Here
440	expectedProblemAttributes.put("ExceptionTypeInternalNameProvided", DEPRECATED);	442	expectedProblemAttributes.put("ExceptionTypeInternalNameProvided", DEPRECATED);
441	expectedProblemAttributes.put("ExceptionTypeNotFound", DEPRECATED);	443	expectedProblemAttributes.put("ExceptionTypeNotFound", DEPRECATED);
442	expectedProblemAttributes.put("ExceptionTypeNotVisible", DEPRECATED);	444	expectedProblemAttributes.put("ExceptionTypeNotVisible", DEPRECATED);
		445	expectedProblemAttributes.put("ExplicitlyClosedAutoCloseable", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
443	expectedProblemAttributes.put("ExpressionShouldBeAVariable", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	446	expectedProblemAttributes.put("ExpressionShouldBeAVariable", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
444	expectedProblemAttributes.put("ExternalProblemFixable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	447	expectedProblemAttributes.put("ExternalProblemFixable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
445	expectedProblemAttributes.put("ExternalProblemNotFixable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	448	expectedProblemAttributes.put("ExternalProblemNotFixable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
Lines 765-770 Link Here
765	expectedProblemAttributes.put("PolymorphicMethodNotBelow17", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	768	expectedProblemAttributes.put("PolymorphicMethodNotBelow17", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
766	expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	769	expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
767	expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(CategorizedProblem.CAT_UNCHECKED_RAW));	770	expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(CategorizedProblem.CAT_UNCHECKED_RAW));
		771	expectedProblemAttributes.put("PotentiallyUnclosedCloseable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		772	expectedProblemAttributes.put("PotentiallyUnclosedCloseableAtExit", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
768	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	773	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
769	expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	774	expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
770	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	775	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
Lines 828-833 Link Here
828	expectedProblemAttributes.put("TypeMissingDeprecatedAnnotation", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	833	expectedProblemAttributes.put("TypeMissingDeprecatedAnnotation", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
829	expectedProblemAttributes.put("TypeParameterHidingType", new ProblemAttributes(CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT));	834	expectedProblemAttributes.put("TypeParameterHidingType", new ProblemAttributes(CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT));
830	expectedProblemAttributes.put("UnboxingConversion", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	835	expectedProblemAttributes.put("UnboxingConversion", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		836	expectedProblemAttributes.put("UnclosedCloseable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		837	expectedProblemAttributes.put("UnclosedCloseableAtExit", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
831	expectedProblemAttributes.put("UndefinedAnnotationMember", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	838	expectedProblemAttributes.put("UndefinedAnnotationMember", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
832	expectedProblemAttributes.put("UndefinedConstructor", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	839	expectedProblemAttributes.put("UndefinedConstructor", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
833	expectedProblemAttributes.put("UndefinedConstructorInDefaultConstructor", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	840	expectedProblemAttributes.put("UndefinedConstructorInDefaultConstructor", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
Lines 1108-1113 Link Here
1108	expectedProblemAttributes.put("ExceptionTypeInternalNameProvided", SKIP);	1115	expectedProblemAttributes.put("ExceptionTypeInternalNameProvided", SKIP);
1109	expectedProblemAttributes.put("ExceptionTypeNotFound", SKIP);	1116	expectedProblemAttributes.put("ExceptionTypeNotFound", SKIP);