Attachment #209472 for bug #358903

Lines 6020-6025 public void test0561_try_catch_unchecked_exception() { Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullReferenceTest.java (-1 / +2 lines)
6020	public void test0562_try_catch_unchecked_exception() {	6020	public void test0562_try_catch_unchecked_exception() {
6021	Map options = getCompilerOptions();	6021	Map options = getCompilerOptions();
6022	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.WARNING);	6022	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.WARNING);
		6023	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
6023	this.runNegativeTest(	6024	this.runNegativeTest(
6024	true,	6025	true,
6025	new String[] {	6026	new String[] {
Lines 6042-6048 public void test0562_try_catch_unchecked_exception() { Link Here
6042	"1. WARNING in X.java (at line 6)\n" +	6043	"1. WARNING in X.java (at line 6)\n" +
6043	" o = new LineNumberReader(new FileReader(\"dummy\"));\n" +	6044	" o = new LineNumberReader(new FileReader(\"dummy\"));\n" +
6044	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +	6045	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
6045	"Resource leak: 'o' is never closed\n" +	6046	"Potential resource leak: \'o\' may not be closed\n" +
6046	"----------\n" +	6047	"----------\n" +
6047	"2. ERROR in X.java (at line 8)\n" +	6048	"2. ERROR in X.java (at line 8)\n" +
6048	" o.toString();\n" +	6049	" o.toString();\n" +




			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void zork() throws IOException {\n" +
			"		try {\n" +
			"			OutputStream os = null;\n" +
			"			try {\n" +
			"				os = new BufferedOutputStream(new FileOutputStream(\"somefile\"));\n" +
			"				String externalForm = \"externalPath\";\n" +
			"			} finally {\n" +
			"				if (os != null)\n" +
			"					os.close();\n" +
			"			}\n" +
			"		} catch (IOException e) {\n" +
			"			e.printStackTrace();\n" +
			"		}\n" +
			"    }\n" +
			"}\n"

			"import java.io.InputStream;\n" +
			"import java.io.BufferedInputStream;\n" +
			"public class X {\n" +
			"    String loadProfile(File profileFile) {\n" +
			"		try {\n" +
			"			InputStream stream = new BufferedInputStream(new FileInputStream(profileFile));\n" +
			"			return loadProfile(stream);\n" +
			"		} catch (FileNotFoundException e) {\n" +
			"			//null\n" +
			"		}\n" +
			"		return null;\n" +
			"	}\n" +
			"	private String loadProfile(InputStream stream) {\n" +
			"		return null;\n" +
			"	}\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 10)\n" +
		"	return loadProfile(stream);\n" +
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		"Potential resource leak: \'stream\' may not be closed at this location\n" +
		"----------\n",
		null,
		true,

			"    }\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 5)\n" +
		"	PrintWriter writer = new PrintWriter(\"filename\");\n" +
		"	            ^^^^^^\n" +
		"Resource leak: \'writer\' is never closed\n" +
		"----------\n",
		null,
		true,

			"import java.io.BufferedInputStream;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean bar) throws IOException {\n" +
			"        File file = new File(\"somefil\");\n" +
			"        FileInputStream fileStream  = new FileInputStream(file);\n" +
			"        BufferedInputStream bis = new BufferedInputStream(fileStream);   \n" +
			"        if (bar) {\n" +
			"            BufferedInputStream doubleWrap = new BufferedInputStream(bis);\n" +
			"            doubleWrap.close();\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" +

			"import java.io.InputStream;\n" +
			"import java.io.BufferedInputStream;\n" +
			"public class X {\n" +
			"    	void foo(File location, String adviceFilePath) throws FileNotFoundException {\n" +
			"		InputStream stream = null;\n" +
			"		if (location.isDirectory()) {\n" +
			"			File adviceFile = new File(location, adviceFilePath);\n" +
			"			stream = new BufferedInputStream(new FileInputStream(adviceFile));\n" +
			"		}\n" +
			"	}\n" +
			"}\n"
		},
		"----------\n" +

		true,
		options);
}
// Bug 358903 - Filter practically unimportant resource leak warnings
// a t-w-r wraps an existing resource
public void test061p() {
	if (this.complianceLevel < ClassFileConstants.JDK1_7) return;
	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.PrintWriter;\n" +
			"import java.io.BufferedWriter;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        PrintWriter writer = new PrintWriter(\"filename\");\n" +
			"        try (BufferedWriter bw = new BufferedWriter(writer)) {\n" +
			"            bw.write(1);\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"",
		null,
		true,
		null,
		options,
		null);
}
// Bug 358903 - Filter practically unimportant resource leak warnings
// a t-w-r potentially wraps an existing resource
// DISABLED, fails because we currently don't include t-w-r managed resources in the analysis
public void _test061q() {
	if (this.complianceLevel < ClassFileConstants.JDK1_7) return;
	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.PrintWriter;\n" +
			"import java.io.BufferedWriter;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean b) throws IOException {\n" +
			"        PrintWriter writer = new PrintWriter(\"filename\");\n" +
			"        if (b)\n" +
			"            try (BufferedWriter bw = new BufferedWriter(writer)) {\n" +
			"                bw.write(1);\n" +
			"            }\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 6)\n" +
		"	PrintWriter writer = new PrintWriter(\\\"filename\\\");\n" +
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		"Potential resource leak: \'writer\' may not be closed\n" +
		"----------\n",
		null,
		true,
		options);
}
// Bug 358903 - Filter practically unimportant resource leak warnings
// the inner from a wrapper is returned
public void test061r() {
	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.FileInputStream;\n" +
			"import java.io.File;\n" +
			"import java.io.BufferedInputStream;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    FileInputStream foo() throws IOException {\n" +
			"        File file = new File(\"somefil\");\n" +
			"        FileInputStream fileStream  = new FileInputStream(file);\n" +
			"        BufferedInputStream bis = new BufferedInputStream(fileStream);   \n" +
			"        return fileStream;\n" +
			"    }\n" +
			"}\n"
		},
		"",
		null,
		true,
		null,
		options,
		null);
}
// Bug 358903 - Filter practically unimportant resource leak warnings
// a wrapper is forgotten, the inner is closed afterwards
public void test061s() {
	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.FileInputStream;\n" +
			"import java.io.File;\n" +
			"import java.io.BufferedInputStream;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefil\");\n" +
			"        FileInputStream fileStream  = new FileInputStream(file);\n" +
			"        BufferedInputStream bis = new BufferedInputStream(fileStream);\n" +
			"        bis = null;\n" +
			"        fileStream.close();\n" +
			"    }\n" +
			"}\n"
		},
		"",
		null,
		true,
		null,
		options,
		null);
}
// Bug 362331 - Resource leak not detected when closeable not assigned to variable
// a resource is never assigned
public void test062a() throws IOException {

			"    }\n" +
			"}\n"
		},
		"----------\n" +
		"1. ERROR in X.java (at line 7)\n" +
		"	FileInputStream stream = new FileInputStream(file);\n" +
		"	                ^^^^^^\n" +
		"Resource leak: \'stream\' is never closed\n" +
		"----------\n" +
		"2. ERROR in X.java (at line 9)\n" +
		"	FileInputStream stream2 = new FileInputStream(file); // unsure since passed to method\n" +
		"	                ^^^^^^^\n" +
		"Potential resource leak: \'stream2\' may not be closed\n" +
		"----------\n" +
		"3. ERROR in X.java (at line 10)\n" +
		"	bis = getReader(stream2); // unsure since obtained from method\n" +
		"	^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		"Potential resource leak: \'bis\' may not be closed\n" +
		"----------\n",
		null,
		true,





	// process arguments
	if (this.arguments != null) {
		boolean hasResourceWrapperType = this.resolvedType instanceof ReferenceBinding 
				&& ((ReferenceBinding)this.resolvedType).hasTypeBit(TypeIds.BitWrapperCloseable);
		for (int i = 0, count = this.arguments.length; i < count; i++) {
			flowInfo =
				this.arguments[i]
					.analyseCode(currentScope, flowContext, flowInfo)
					.unconditionalInits();
			// if argument is an AutoCloseable insert info that it *may* be closed (by the target method, i.e.)
			if (!hasResourceWrapperType) { // allocation of wrapped closeables is analyzed specially
					&& ((ReferenceBinding)this.resolvedType).hasTypeBit(TypeIds.BitWrapperCloseable))) { // allocation of wrapped closeables is analyzed specially
				flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo);
			}
			if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {




	 * @param location the assignment/local declaration being analyzed
	 * @param local the local variable being assigned to
	 * @param rhs the rhs of the assignment resp. the initialization of the local variable declaration.
	 * 		<strong>Precondition:</strong> client has already checked that the resolved type of this expression is either a closeable type or NULL.
	 */
	public static void preConnectTrackerAcrossAssignment(ASTNode location, LocalVariableBinding local, Expression rhs) {
		FakedTrackingVariable closeTracker = null;

		return trackingVar;
	}

	/** 
	 * If current is the same as 'returnedResource' or a wrapper thereof,
	 * mark as reported and return true, otherwise false.
	 */
	public boolean isResourceBeingReturned(FakedTrackingVariable returnedResource) {
		FakedTrackingVariable current = this;
		do {
			if (current == returnedResource) {
				this.globalClosingState |= REPORTED_DEFINITIVE_LEAK;
				return true;
			}
			current = current.innerTracker;
		} while (current != null);
		return false;
	}

	public void recordErrorLocation(ASTNode location, int nullStatus) {
		if (this.recordedLocations == null)
			this.recordedLocations = new HashMap();

Lines 52-60 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, Fl Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java (-3 / +2 lines)
52	if (trackingVariable != null) {	52	if (trackingVariable != null) {
53	if (methodScope != trackingVariable.methodScope)	53	if (methodScope != trackingVariable.methodScope)
54	trackingVariable.markClosedInNestedMethod();	54	trackingVariable.markClosedInNestedMethod();
55	// don't report issues concerning this local, since by returning	55	// by returning the method passes the responsibility to the caller:
56	// the method passes the responsibility to the caller:	56	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.expression, flowInfo);
57	currentScope.removeTrackingVar(trackingVariable);
58	}	57	}
59	}	58	}
60	this.initStateIndex =	59	this.initStateIndex =

Lines 1009-1019 public void checkUnclosedCloseables(FlowInfo flowInfo, ASTNode location, BlockSc Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java (+8 lines)
1009	return;	1009	return;
1010	}	1010	}
1011	if (location != null && flowInfo.reachMode() != 0) return;	1011	if (location != null && flowInfo.reachMode() != 0) return;
		1012
		1013	FakedTrackingVariable returnVar = (location instanceof ReturnStatement) ?
		1014	FakedTrackingVariable.getCloseTrackingVariable(((ReturnStatement)location).expression) : null;
		1015
1012	Set varSet = new HashSet(this.trackingVariables);	1016	Set varSet = new HashSet(this.trackingVariables);
1013	FakedTrackingVariable trackingVar;	1017	FakedTrackingVariable trackingVar;
1014	// pick one outer-most variable from the set at a time	1018	// pick one outer-most variable from the set at a time
1015	while ((trackingVar = FakedTrackingVariable.pickVarForReporting(varSet, this, location != null)) != null) {	1019	while ((trackingVar = FakedTrackingVariable.pickVarForReporting(varSet, this, location != null)) != null) {
1016		1020
		1021	if (returnVar != null && trackingVar.isResourceBeingReturned(returnVar)) {
		1022	continue;
		1023	}
		1024
1017	if (location != null && trackingVar.originalBinding != null && flowInfo.isDefinitelyNull(trackingVar.originalBinding))	1025	if (location != null && trackingVar.originalBinding != null && flowInfo.isDefinitelyNull(trackingVar.originalBinding))
1018	continue; // reporting against a specific location, resource is null at this flow, don't complain	1026	continue; // reporting against a specific location, resource is null at this flow, don't complain
1019		1027

Return to bug 358903

Lines 169-174 public class FakedTrackingVariable extends LocalDeclaration { Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java (+17 lines)
169	* @param location the assignment/local declaration being analyzed	169	* @param location the assignment/local declaration being analyzed
170	* @param local the local variable being assigned to	170	* @param local the local variable being assigned to
171	* @param rhs the rhs of the assignment resp. the initialization of the local variable declaration.	171	* @param rhs the rhs of the assignment resp. the initialization of the local variable declaration.
		172	* <strong>Precondition:</strong> client has already checked that the resolved type of this expression is either a closeable type or NULL.
172	*/	173	*/
173	public static void preConnectTrackerAcrossAssignment(ASTNode location, LocalVariableBinding local, Expression rhs) {	174	public static void preConnectTrackerAcrossAssignment(ASTNode location, LocalVariableBinding local, Expression rhs) {
174	FakedTrackingVariable closeTracker = null;	175	FakedTrackingVariable closeTracker = null;
Lines 615-620 public class FakedTrackingVariable extends LocalDeclaration { Link Here
615	return trackingVar;	616	return trackingVar;
616	}	617	}
617		618
		619	/**
		620	* If current is the same as 'returnedResource' or a wrapper thereof,
		621	* mark as reported and return true, otherwise false.
		622	*/
		623	public boolean isResourceBeingReturned(FakedTrackingVariable returnedResource) {
		624	FakedTrackingVariable current = this;
		625	do {
		626	if (current == returnedResource) {
		627	this.globalClosingState \|= REPORTED_DEFINITIVE_LEAK;
		628	return true;
		629	}
		630	current = current.innerTracker;
		631	} while (current != null);
		632	return false;
		633	}
		634
618	public void recordErrorLocation(ASTNode location, int nullStatus) {	635	public void recordErrorLocation(ASTNode location, int nullStatus) {
619	if (this.recordedLocations == null)	636	if (this.recordedLocations == null)
620	this.recordedLocations = new HashMap();	637	this.recordedLocations = new HashMap();

Lines 2112-2128 public void test061f2() throws IOException { Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/ResourceLeakTests.java (-63 / +185 lines)
2112	"import java.io.IOException;\n" +	2112	"import java.io.IOException;\n" +
2113	"public class X {\n" +	2113	"public class X {\n" +
2114	" void zork() throws IOException {\n" +	2114	" void zork() throws IOException {\n" +
2115	" try {\n" +	2115	" try {\n" +
2116	" OutputStream os = null;\n" +	2116	" OutputStream os = null;\n" +
2117	" try {\n" +	2117	" try {\n" +
2118	" os = new BufferedOutputStream(new FileOutputStream(\"somefile\"));\n" +	2118	" os = new BufferedOutputStream(new FileOutputStream(\"somefile\"));\n" +
2119	" String externalForm = \"externalPath\";\n" +	2119	" String externalForm = \"externalPath\";\n" +
2120	" } finally {\n" +	2120	" } finally {\n" +
2121	" if (os != null)\n" +	2121	" if (os != null)\n" +
2122	" os.close();\n" +	2122	" os.close();\n" +
2123	" }\n" +	2123	" }\n" +
2124	" } catch (IOException e) {\n" +	2124	" } catch (IOException e) {\n" +
2125	" e.printStackTrace();\n" +	2125	" e.printStackTrace();\n" +
2126	" }\n" +	2126	" }\n" +
2127	" }\n" +	2127	" }\n" +
2128	"}\n"	2128	"}\n"
Lines 2150-2174 public void test061f3() throws IOException { Link Here
2150	"import java.io.InputStream;\n" +	2150	"import java.io.InputStream;\n" +
2151	"import java.io.BufferedInputStream;\n" +	2151	"import java.io.BufferedInputStream;\n" +
2152	"public class X {\n" +	2152	"public class X {\n" +
2153	" String loadProfile(File profileFile) {\n" +	2153	" String loadProfile(File profileFile) {\n" +
2154	" try {\n" +	2154	" try {\n" +
2155	" InputStream stream = new BufferedInputStream(new FileInputStream(profileFile));\n" +	2155	" InputStream stream = new BufferedInputStream(new FileInputStream(profileFile));\n" +
2156	" return loadProfile(stream);\n" +	2156	" return loadProfile(stream);\n" +
2157	" } catch (FileNotFoundException e) {\n" +	2157	" } catch (FileNotFoundException e) {\n" +
2158	" //null\n" +	2158	" //null\n" +
2159	" }\n" +	2159	" }\n" +
2160	" return null;\n" +	2160	" return null;\n" +
2161	" }\n" +	2161	" }\n" +
2162	" private String loadProfile(InputStream stream) {\n" +	2162	" private String loadProfile(InputStream stream) {\n" +
2163	" return null;\n" +	2163	" return null;\n" +
2164	" }\n" +	2164	" }\n" +
2165	"}\n"	2165	"}\n"
2166	},	2166	},
2167	"----------\n" +	2167	"----------\n" +
2168	"1. ERROR in X.java (at line 10)\n" +	2168	"1. ERROR in X.java (at line 10)\n" +
2169	" return loadProfile(stream);\n" +	2169	" return loadProfile(stream);\n" +
2170	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +	2170	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
2171	"Potential resource leak: \'stream\' may not be closed at this location\n" +	2171	"Potential resource leak: \'stream\' may not be closed at this location\n" +
2172	"----------\n",	2172	"----------\n",
2173	null,	2173	null,
2174	true,	2174	true,
Lines 2487-2497 public void test061n() { Link Here
2487	" }\n" +	2487	" }\n" +
2488	"}\n"	2488	"}\n"
2489	},	2489	},
2490	"----------\n" +	2490	"----------\n" +
2491	"1. ERROR in X.java (at line 5)\n" +	2491	"1. ERROR in X.java (at line 5)\n" +
2492	" PrintWriter writer = new PrintWriter(\"filename\");\n" +	2492	" PrintWriter writer = new PrintWriter(\"filename\");\n" +
2493	" ^^^^^^\n" +	2493	" ^^^^^^\n" +
2494	"Resource leak: \'writer\' is never closed\n" +	2494	"Resource leak: \'writer\' is never closed\n" +
2495	"----------\n",	2495	"----------\n",
2496	null,	2496	null,
2497	true,	2497	true,
Lines 2511-2525 public void test061o() { Link Here
2511	"import java.io.BufferedInputStream;\n" +	2511	"import java.io.BufferedInputStream;\n" +
2512	"import java.io.IOException;\n" +	2512	"import java.io.IOException;\n" +
2513	"public class X {\n" +	2513	"public class X {\n" +
2514	" void foo(boolean bar) throws IOException {\n" +	2514	" void foo(boolean bar) throws IOException {\n" +
2515	" File file = new File(\"somefil\");\n" +	2515	" File file = new File(\"somefil\");\n" +
2516	" FileInputStream fileStream = new FileInputStream(file);\n" +	2516	" FileInputStream fileStream = new FileInputStream(file);\n" +
2517	" BufferedInputStream bis = new BufferedInputStream(fileStream); \n" +	2517	" BufferedInputStream bis = new BufferedInputStream(fileStream); \n" +
2518	" if (bar) {\n" +	2518	" if (bar) {\n" +
2519	" BufferedInputStream doubleWrap = new BufferedInputStream(bis);\n" +	2519	" BufferedInputStream doubleWrap = new BufferedInputStream(bis);\n" +
2520	" doubleWrap.close();\n" +	2520	" doubleWrap.close();\n" +
2521	" }\n" +	2521	" }\n" +
2522	" }\n" +	2522	" }\n" +
2523	"}\n"	2523	"}\n"
2524	},	2524	},
2525	"----------\n" +	2525	"----------\n" +
Lines 2547-2559 public void test061f4() throws IOException { Link Here
2547	"import java.io.InputStream;\n" +	2547	"import java.io.InputStream;\n" +
2548	"import java.io.BufferedInputStream;\n" +	2548	"import java.io.BufferedInputStream;\n" +
2549	"public class X {\n" +	2549	"public class X {\n" +
2550	" void foo(File location, String adviceFilePath) throws FileNotFoundException {\n" +	2550	" void foo(File location, String adviceFilePath) throws FileNotFoundException {\n" +
2551	" InputStream stream = null;\n" +	2551	" InputStream stream = null;\n" +
2552	" if (location.isDirectory()) {\n" +	2552	" if (location.isDirectory()) {\n" +
2553	" File adviceFile = new File(location, adviceFilePath);\n" +	2553	" File adviceFile = new File(location, adviceFilePath);\n" +
2554	" stream = new BufferedInputStream(new FileInputStream(adviceFile));\n" +	2554	" stream = new BufferedInputStream(new FileInputStream(adviceFile));\n" +
2555	" }\n" +	2555	" }\n" +
2556	" }\n" +	2556	" }\n" +
2557	"}\n"	2557	"}\n"
2558	},	2558	},
2559	"----------\n" +	2559	"----------\n" +
Lines 2566-2571 public void test061f4() throws IOException { Link Here
2566	true,	2566	true,
2567	options);	2567	options);
2568	}	2568	}
		2569	// Bug 358903 - Filter practically unimportant resource leak warnings
		2570	// a t-w-r wraps an existing resource
		2571	public void test061p() {
		2572	if (this.complianceLevel < ClassFileConstants.JDK1_7) return;
		2573	Map options = getCompilerOptions();
		2574	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
		2575	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
		2576	this.runConformTest(
		2577	new String[] {
		2578	"X.java",
		2579	"import java.io.PrintWriter;\n" +
		2580	"import java.io.BufferedWriter;\n" +
		2581	"import java.io.IOException;\n" +
		2582	"public class X {\n" +
		2583	" void foo() throws IOException {\n" +
		2584	" PrintWriter writer = new PrintWriter(\"filename\");\n" +
		2585	" try (BufferedWriter bw = new BufferedWriter(writer)) {\n" +
		2586	" bw.write(1);\n" +
		2587	" }\n" +
		2588	" }\n" +
		2589	"}\n"
		2590	},
		2591	"",
		2592	null,
		2593	true,
		2594	null,
		2595	options,
		2596	null);
		2597	}
		2598	// Bug 358903 - Filter practically unimportant resource leak warnings
		2599	// a t-w-r potentially wraps an existing resource
		2600	// DISABLED, fails because we currently don't include t-w-r managed resources in the analysis
		2601	public void _test061q() {
		2602	if (this.complianceLevel < ClassFileConstants.JDK1_7) return;
		2603	Map options = getCompilerOptions();
		2604	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
		2605	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
		2606	this.runNegativeTest(
		2607	new String[] {
		2608	"X.java",
		2609	"import java.io.PrintWriter;\n" +
		2610	"import java.io.BufferedWriter;\n" +
		2611	"import java.io.IOException;\n" +
		2612	"public class X {\n" +
		2613	" void foo(boolean b) throws IOException {\n" +
		2614	" PrintWriter writer = new PrintWriter(\"filename\");\n" +
		2615	" if (b)\n" +
		2616	" try (BufferedWriter bw = new BufferedWriter(writer)) {\n" +
		2617	" bw.write(1);\n" +
		2618	" }\n" +
		2619	" }\n" +
		2620	"}\n"
		2621	},
		2622	"----------\n" +
		2623	"1. ERROR in X.java (at line 6)\n" +
		2624	" PrintWriter writer = new PrintWriter(\\\"filename\\\");\n" +
		2625	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		2626	"Potential resource leak: \'writer\' may not be closed\n" +
		2627	"----------\n",
		2628	null,
		2629	true,
		2630	options);
		2631	}
		2632	// Bug 358903 - Filter practically unimportant resource leak warnings
2633	// the inner from a wrapper is returned
2634	public void test061r() {
2635	Map options = getCompilerOptions();
2636	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
2637	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
2638	this.runConformTest(
2639	new String[] {
2640	"X.java",
2641	"import java.io.FileInputStream;\n" +
2642	"import java.io.File;\n" +
2643	"import java.io.BufferedInputStream;\n" +
2644	"import java.io.IOException;\n" +
2645	"public class X {\n" +
2646	" FileInputStream foo() throws IOException {\n" +
2647	" File file = new File(\"somefil\");\n" +
2648	" FileInputStream fileStream = new FileInputStream(file);\n" +
2649	" BufferedInputStream bis = new BufferedInputStream(fileStream); \n" +
2650	" return fileStream;\n" +
2651	" }\n" +
2652	"}\n"
2653	},
2654	"",
2655	null,
2656	true,
2657	null,
2658	options,
2659	null);
2660	}
2661	// Bug 358903 - Filter practically unimportant resource leak warnings
2662	// a wrapper is forgotten, the inner is closed afterwards
2663	public void test061s() {
2664	Map options = getCompilerOptions();
2665	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
2666	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
2667	this.runConformTest(
2668	new String[] {
2669	"X.java",
2670	"import java.io.FileInputStream;\n" +
2671	"import java.io.File;\n" +
2672	"import java.io.BufferedInputStream;\n" +
2673	"import java.io.IOException;\n" +
2674	"public class X {\n" +
2675	" void foo() throws IOException {\n" +
2676	" File file = new File(\"somefil\");\n" +
2677	" FileInputStream fileStream = new FileInputStream(file);\n" +
2678	" BufferedInputStream bis = new BufferedInputStream(fileStream);\n" +
2679	" bis = null;\n" +
2680	" fileStream.close();\n" +
2681	" }\n" +
2682	"}\n"
2683	},
2684	"",
2685	null,
2686	true,
2687	null,
2688	options,
2689	null);
2690	}
2569	// Bug 362331 - Resource leak not detected when closeable not assigned to variable	2691	// Bug 362331 - Resource leak not detected when closeable not assigned to variable
2570	// a resource is never assigned	2692	// a resource is never assigned
2571	public void test062a() throws IOException {	2693	public void test062a() throws IOException {
Lines 2702-2722 public void test063a() throws IOException { Link Here
2702	" }\n" +	2824	" }\n" +
2703	"}\n"	2825	"}\n"
2704	},	2826	},
2705	"----------\n" +	2827	"----------\n" +
2706	"1. ERROR in X.java (at line 7)\n" +	2828	"1. ERROR in X.java (at line 7)\n" +
2707	" FileInputStream stream = new FileInputStream(file);\n" +	2829	" FileInputStream stream = new FileInputStream(file);\n" +
2708	" ^^^^^^\n" +	2830	" ^^^^^^\n" +
2709	"Resource leak: \'stream\' is never closed\n" +	2831	"Resource leak: \'stream\' is never closed\n" +
2710	"----------\n" +	2832	"----------\n" +
2711	"2. ERROR in X.java (at line 9)\n" +	2833	"2. ERROR in X.java (at line 9)\n" +
2712	" FileInputStream stream2 = new FileInputStream(file); // unsure since passed to method\n" +	2834	" FileInputStream stream2 = new FileInputStream(file); // unsure since passed to method\n" +
2713	" ^^^^^^^\n" +	2835	" ^^^^^^^\n" +
2714	"Potential resource leak: \'stream2\' may not be closed\n" +	2836	"Potential resource leak: \'stream2\' may not be closed\n" +
2715	"----------\n" +	2837	"----------\n" +
2716	"3. ERROR in X.java (at line 10)\n" +	2838	"3. ERROR in X.java (at line 10)\n" +
2717	" bis = getReader(stream2); // unsure since obtained from method\n" +	2839	" bis = getReader(stream2); // unsure since obtained from method\n" +
2718	" ^^^^^^^^^^^^^^^^^^^^^^^^\n" +	2840	" ^^^^^^^^^^^^^^^^^^^^^^^^\n" +
2719	"Potential resource leak: \'bis\' may not be closed\n" +	2841	"Potential resource leak: \'bis\' may not be closed\n" +
2720	"----------\n",	2842	"----------\n",
2721	null,	2843	null,
2722	true,	2844	true,

Lines 46-59 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, Fl Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (-2 / +3 lines)
46		46
47	// process arguments	47	// process arguments
48	if (this.arguments != null) {	48	if (this.arguments != null) {
		49	boolean hasResourceWrapperType = this.resolvedType instanceof ReferenceBinding
		50	&& ((ReferenceBinding)this.resolvedType).hasTypeBit(TypeIds.BitWrapperCloseable);
49	for (int i = 0, count = this.arguments.length; i < count; i++) {	51	for (int i = 0, count = this.arguments.length; i < count; i++) {
50	flowInfo =	52	flowInfo =
51	this.arguments[i]	53	this.arguments[i]
52	.analyseCode(currentScope, flowContext, flowInfo)	54	.analyseCode(currentScope, flowContext, flowInfo)
53	.unconditionalInits();	55	.unconditionalInits();
54	// if argument is an AutoCloseable insert info that it may be closed (by the target method, i.e.)	56	// if argument is an AutoCloseable insert info that it may be closed (by the target method, i.e.)
55	if (!(this.resolvedType instanceof ReferenceBinding	57	if (!hasResourceWrapperType) { // allocation of wrapped closeables is analyzed specially
56	&& ((ReferenceBinding)this.resolvedType).hasTypeBit(TypeIds.BitWrapperCloseable))) { // allocation of wrapped closeables is analyzed specially
57	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo);	58	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo);
58	}	59	}
59	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {	60	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {