Attachment #209179 for bug #358903

Lines 11-21 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/TryWithResourcesStatementTest.java (-7 / +775 lines)
11	* bug 358827 - [1.7] exception analysis for t-w-r spoils null analysis	11	* bug 358827 - [1.7] exception analysis for t-w-r spoils null analysis
12	* bug 349326 - [1.7] new warning for missing try-with-resources	12	* bug 349326 - [1.7] new warning for missing try-with-resources
13	* bug 359334 - Analysis for resource leak warnings does not consider exceptions as method exit points	13	* bug 359334 - Analysis for resource leak warnings does not consider exceptions as method exit points
		14	* bug 358903 - Filter practically unimportant resource leak warnings
		15	* bug 360908 - Avoid resource leak warning when the underlying/chained resource is closed explicitly
		16	* bug 361073 - Avoid resource leak warning when the top level resource is closed explicitly
		17	* bug 362331 - Resource leak not detected when closeable not assigned to variable
		18	* bug 362332 - Only report potential leak when closeable not created in the local scope
14	*******************************************************************************/	19	*******************************************************************************/
15	package org.eclipse.jdt.core.tests.compiler.regression;	20	package org.eclipse.jdt.core.tests.compiler.regression;
16		21
		22	import java.io.IOException;
		23	import java.net.URL;
17	import java.util.Map;	24	import java.util.Map;
18		25
		26	import org.eclipse.core.runtime.FileLocator;
		27	import org.eclipse.core.runtime.Path;
		28	import org.eclipse.core.runtime.Platform;
19	import org.eclipse.jdt.core.JavaCore;	29	import org.eclipse.jdt.core.JavaCore;
20	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	30	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
21		31
Lines 23-29 Link Here
23	public class TryWithResourcesStatementTest extends AbstractRegressionTest {	33	public class TryWithResourcesStatementTest extends AbstractRegressionTest {
24		34
25	static {	35	static {
26	// TESTS_NAMES = new String[] { "test056throw"};	36	// TESTS_NAMES = new String[] { "test061a"};
27	// TESTS_NUMBERS = new int[] { 50 };	37	// TESTS_NUMBERS = new int[] { 50 };
28	// TESTS_RANGE = new int[] { 11, -1 };	38	// TESTS_RANGE = new int[] { 11, -1 };
29	}	39	}
Lines 3713-3723 Link Here
3713	options);	3723	options);
3714	}	3724	}
3715	// Bug 349326 - [1.7] new warning for missing try-with-resources	3725	// Bug 349326 - [1.7] new warning for missing try-with-resources
		3726	// Bug 362332 - Only report potential leak when closeable not created in the local scope
3716	// one method returns an AutoCleasble, a second method uses this object without ever closing it.	3727	// one method returns an AutoCleasble, a second method uses this object without ever closing it.
3717	public void test056e() {	3728	public void test056e() {
3718	Map options = getCompilerOptions();	3729	Map options = getCompilerOptions();
3719	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);	3730	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
3720	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);	3731	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
3721	this.runNegativeTest(	3732	this.runNegativeTest(
3722	new String[] {	3733	new String[] {
3723	"X.java",	3734	"X.java",
Lines 3744-3750 Link Here
3744	"1. ERROR in X.java (at line 11)\n" +	3755	"1. ERROR in X.java (at line 11)\n" +
3745	" FileReader reader = getReader(\"somefile\");\n" +	3756	" FileReader reader = getReader(\"somefile\");\n" +
3746	" ^^^^^^\n" +	3757	" ^^^^^^\n" +
3747	"Resource leak: 'reader' is never closed\n" +	3758	"Potential resource leak: \'reader\' may not be closed\n" +
3748	"----------\n",	3759	"----------\n",
3749	null,	3760	null,
3750	true,	3761	true,
Lines 3964-3969 Link Here
3964	null,	3975	null,
3965	true,	3976	true,
3966	options);	3977	options);
		3978	}
		3979	// Bug 349326 - [1.7] new warning for missing try-with-resources
		3980	// three AutoCloseables in different blocks of the same method - problems ignored
		3981	public void test056i_ignore() {
		3982	Map options = getCompilerOptions();
		3983	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.IGNORE);
		3984	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.IGNORE);
		3985	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
		3986	this.runConformTest(
		3987	new String[] {
		3988	"X.java",
		3989	"import java.io.File;\n" +
		3990	"import java.io.FileReader;\n" +
		3991	"import java.io.IOException;\n" +
		3992	"public class X {\n" +
		3993	" void foo(boolean f1, boolean f2) throws IOException {\n" +
		3994	" File file = new File(\"somefile\");\n" +
		3995	" if (f1) {\n" +
		3996	" FileReader fileReader = new FileReader(file); // err: not closed\n" +
		3997	" char[] in = new char[50];\n" +
		3998	" fileReader.read(in);\n" +
		3999	" while (true) {\n" +
		4000	" FileReader loopReader = new FileReader(file); // don't warn, properly closed\n" +
		4001	" loopReader.close();" +
		4002	" break;\n" +
		4003	" }\n" +
		4004	" } else {\n" +
		4005	" FileReader fileReader = new FileReader(file); // warn: not closed on all paths\n" +
		4006	" if (f2)\n" +
		4007	" fileReader.close();\n" +
		4008	" }\n" +
		4009	" }\n" +
		4010	"}\n"
		4011	},
		4012	"",
		4013	null,
		4014	true,
		4015	null,
		4016	options,
		4017	null);
3967	}	4018	}
3968	// Bug 349326 - [1.7] new warning for missing try-with-resources	4019	// Bug 349326 - [1.7] new warning for missing try-with-resources
3969	// three AutoCloseables in different blocks of the same method	4020	// three AutoCloseables in different blocks of the same method
Lines 4358-4368 Link Here
4358	null/requestor/);	4409	null/requestor/);
4359	}	4410	}
4360	// Bug 349326 - [1.7] new warning for missing try-with-resources	4411	// Bug 349326 - [1.7] new warning for missing try-with-resources
		4412	// Bug 362332 - Only report potential leak when closeable not created in the local scope
4361	// a method uses an AutoCloseable without ever closing it, type from a type variable	4413	// a method uses an AutoCloseable without ever closing it, type from a type variable
4362	public void test056p() {	4414	public void test056p() {
4363	Map options = getCompilerOptions();	4415	Map options = getCompilerOptions();
4364	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);	4416	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
4365	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);	4417	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
4366	this.runNegativeTest(	4418	this.runNegativeTest(
4367	new String[] {	4419	new String[] {
4368	"X.java",	4420	"X.java",
Lines 4389-4395 Link Here
4389	"1. ERROR in X.java (at line 8)\n" +	4441	"1. ERROR in X.java (at line 8)\n" +
4390	" T fileReader = newReader(file);\n" +	4442	" T fileReader = newReader(file);\n" +
4391	" ^^^^^^^^^^\n" +	4443	" ^^^^^^^^^^\n" +
4392	"Resource leak: 'fileReader' is never closed\n" +	4444	"Potential resource leak: \'fileReader\' may not be closed\n" +
4393	"----------\n",	4445	"----------\n",
4394	null,	4446	null,
4395	true,	4447	true,
Lines 4444-4450 Link Here
4444	options);	4496	options);
4445	}	4497	}
4446	// Bug 349326 - [1.7] new warning for missing try-with-resources	4498	// Bug 349326 - [1.7] new warning for missing try-with-resources
4447	// closed in dead code	4499	// properly closed, dead code in between
4448	public void test056r() {	4500	public void test056r() {
4449	Map options = getCompilerOptions();	4501	Map options = getCompilerOptions();
4450	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);	4502	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
Lines 5354-5360 Link Here
5354	"X::~X\n" +	5406	"X::~X\n" +
5355	"true");	5407	"true");
5356	}	5408	}
5357		5409	// Bug 358903 - Filter practically unimportant resource leak warnings
		5410	// Bug 360908 - Avoid resource leak warning when the underlying/chained resource is closed explicitly
		5411	// a resource wrapper is not closed but the underlying resource is
		5412	public void test061a() {
		5413	Map options = getCompilerOptions();
		5414	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
		5415	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
		5416	this.runConformTest(
		5417	new String[] {
		5418	"X.java",
		5419	"import java.io.File;\n" +
		5420	"import java.io.BufferedInputStream;\n" +
		5421	"import java.io.FileInputStream;\n" +
		5422	"import java.io.IOException;\n" +
		5423	"public class X {\n" +
		5424	" void foo() throws IOException {\n" +
		5425	" File file = new File(\"somefile\");\n" +
		5426	" FileInputStream fileStream = new FileInputStream(file);\n" +
		5427	" BufferedInputStream bis = new BufferedInputStream(fileStream);\n" +
		5428	" BufferedInputStream doubleWrap = new BufferedInputStream(bis);\n" +
		5429	" System.out.println(bis.available());\n" +
		5430	" fileStream.close();\n" +
		5431	" }\n" +
		5432	" void inline() throws IOException {\n" +
		5433	" File file = new File(\"somefile\");\n" +
		5434	" FileInputStream fileStream;\n" +
		5435	" BufferedInputStream bis = new BufferedInputStream(fileStream = new FileInputStream(file));\n" +
		5436	" System.out.println(bis.available());\n" +
		5437	" fileStream.close();\n" +
		5438	" }\n" +
		5439	" public static void main(String[] args) throws IOException {\n" +
		5440	" try {\n" +
		5441	" new X().foo();\n" +
		5442	" } catch (IOException ex) {" +
		5443	" System.out.println(\"Got IO Exception\");\n" +
		5444	" }\n" +
		5445	" }\n" +
		5446	"}\n"
		5447	},
		5448	"Got IO Exception",
		5449	null,
		5450	true,
		5451	null,
		5452	options,
		5453	null);
		5454	}
		5455	// Bug 358903 - Filter practically unimportant resource leak warnings
		5456	// a closeable without OS resource is not closed
		5457	public void test061b() {
		5458	Map options = getCompilerOptions();
		5459	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
		5460	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
		5461	this.runConformTest(
		5462	new String[] {
		5463	"X.java",
		5464	"import java.io.StringReader;\n" +
		5465	"import java.io.IOException;\n" +
		5466	"public class X {\n" +
		5467	" void foo() throws IOException {\n" +
		5468	" StringReader string = new StringReader(\"content\");\n" +
		5469	" System.out.println(string.read());\n" +
		5470	" }\n" +
		5471	" public static void main(String[] args) throws IOException {\n" +
		5472	" new X().foo();\n" +
		5473	" }\n" +
5474	"}\n"
5475	},
5476	"99", // character 'c'
5477	null,
5478	true,
5479	null,
5480	options,
5481	null);
5482	}
5483	// Bug 358903 - Filter practically unimportant resource leak warnings
5484	// a resource wrapper is not closed but the underlying closeable is resource-free
5485	public void test061c() {
5486	Map options = getCompilerOptions();
5487	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5488	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5489	this.runConformTest(
5490	new String[] {
5491	"X.java",
5492	"import java.io.BufferedReader;\n" +
5493	"import java.io.StringReader;\n" +
5494	"import java.io.IOException;\n" +
5495	"public class X {\n" +
5496	" void foo() throws IOException {\n" +
5497	" StringReader input = new StringReader(\"content\");\n" +
5498	" BufferedReader br = new BufferedReader(input);\n" +
5499	" BufferedReader doubleWrap = new BufferedReader(br);\n" +
5500	" System.out.println(br.read());\n" +
5501	" }\n" +
5502	" void inline() throws IOException {\n" +
5503	" BufferedReader br = new BufferedReader(new StringReader(\"content\"));\n" +
5504	" System.out.println(br.read());\n" +
5505	" }\n" +
5506	" public static void main(String[] args) throws IOException {\n" +
5507	" new X().foo();\n" +
5508	" }\n" +
5509	"}\n"
5510	},
5511	"99",
5512	null,
5513	true,
5514	null,
5515	options,
5516	null);
5517	}
5518	// Bug 358903 - Filter practically unimportant resource leak warnings
5519	// a resource wrapper is not closed neither is the underlying resource
5520	public void test061d() {
5521	Map options = getCompilerOptions();
5522	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5523	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
5524	this.runNegativeTest(
5525	new String[] {
5526	"X.java",
5527	"import java.io.File;\n" +
5528	"import java.io.BufferedInputStream;\n" +
5529	"import java.io.FileInputStream;\n" +
5530	"import java.io.IOException;\n" +
5531	"public class X {\n" +
5532	" void foo() throws IOException {\n" +
5533	" File file = new File(\"somefile\");\n" +
5534	" FileInputStream fileStream = new FileInputStream(file);\n" +
5535	" BufferedInputStream bis = new BufferedInputStream(fileStream);\n" +
5536	" BufferedInputStream doubleWrap = new BufferedInputStream(bis);\n" +
5537	" System.out.println(bis.available());\n" +
5538	" }\n" +
5539	" void inline() throws IOException {\n" +
5540	" File file = new File(\"somefile\");\n" +
5541	" BufferedInputStream bis2 = new BufferedInputStream(new FileInputStream(file));\n" +
5542	" System.out.println(bis2.available());\n" +
5543	" }\n" +
5544	" public static void main(String[] args) throws IOException {\n" +
5545	" try {\n" +
5546	" new X().foo();\n" +
5547	" } catch (IOException ex) {" +
5548	" System.out.println(\"Got IO Exception\");\n" +
5549	" }\n" +
5550	" }\n" +
5551	"}\n"
5552	},
5553	"----------\n" +
5554	"1. ERROR in X.java (at line 10)\n" +
5555	" BufferedInputStream doubleWrap = new BufferedInputStream(bis);\n" +
5556	" ^^^^^^^^^^\n" +
5557	"Resource leak: \'doubleWrap\' is never closed\n" +
5558	"----------\n" +
5559	"2. ERROR in X.java (at line 15)\n" +
5560	" BufferedInputStream bis2 = new BufferedInputStream(new FileInputStream(file));\n" +
5561	" ^^^^\n" +
5562	"Resource leak: \'bis2\' is never closed\n" +
5563	"----------\n",
5564	null,
5565	true,
5566	options);
5567	}
5568	// Bug 358903 - Filter practically unimportant resource leak warnings
5569	// Bug 361073 - Avoid resource leak warning when the top level resource is closed explicitly
5570	// a resource wrapper is closed closing also the underlying resource
5571	public void test061e() {
5572	Map options = getCompilerOptions();
5573	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5574	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5575	this.runConformTest(
5576	new String[] {
5577	"X.java",
5578	"import java.io.File;\n" +
5579	"import java.io.BufferedInputStream;\n" +
5580	"import java.io.FileInputStream;\n" +
5581	"import java.io.IOException;\n" +
5582	"public class X {\n" +
5583	" FileInputStream fis;" +
5584	" void foo() throws IOException {\n" +
5585	" File file = new File(\"somefile\");\n" +
5586	" FileInputStream fileStream = new FileInputStream(file);\n" +
5587	" BufferedInputStream bis = new BufferedInputStream(fileStream);\n" +
5588	" BufferedInputStream doubleWrap = new BufferedInputStream(bis);\n" +
5589	" System.out.println(bis.available());\n" +
5590	" bis.close();\n" +
5591	" }\n" +
5592	" void inline() throws IOException {\n" +
5593	" File file = new File(\"somefile\");\n" +
5594	" BufferedInputStream bis2 = new BufferedInputStream(fis = new FileInputStream(file));\n" + // field assignment
5595	" System.out.println(bis2.available());\n" +
5596	" bis2.close();\n" +
5597	" FileInputStream fileStream = null;\n" +
5598	" BufferedInputStream bis3 = new BufferedInputStream(fileStream = new FileInputStream(file));\n" +
5599	" System.out.println(bis3.available());\n" +
5600	" bis3.close();\n" +
5601	" }\n" +
5602	" public static void main(String[] args) throws IOException {\n" +
5603	" try {\n" +
5604	" new X().foo();\n" +
5605	" } catch (IOException ex) {" +
5606	" System.out.println(\"Got IO Exception\");\n" +
5607	" }\n" +
5608	" }\n" +
5609	"}\n"
5610	},
5611	"Got IO Exception",
5612	null,
5613	true,
5614	null,
5615	options,
5616	null);
5617	}
5618	// Bug 358903 - Filter practically unimportant resource leak warnings
5619	// Bug 361073 - Avoid resource leak warning when the top level resource is closed explicitly
5620	// a resource wrapper is closed closing also the underlying resource - original test case
5621	public void test061f() throws IOException {
5622	Map options = getCompilerOptions();
5623	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5624	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5625	URL url = FileLocator.toFileURL(FileLocator.find(Platform.getBundle("org.eclipse.jdt.core.tests.compiler"), new Path("META-INF/MANIFEST.MF"), null));
5626	this.runConformTest(
5627	new String[] {
5628	"X.java",
5629	"import java.io.InputStream;\n" +
5630	"import java.io.InputStreamReader;\n" +
5631	"import java.io.BufferedReader;\n" +
5632	"import java.io.IOException;\n" +
5633	"import java.net.URL;\n" +
5634	"public class X {\n" +
5635	" boolean loadURL(final URL url) throws IOException {\n" +
5636	" InputStream stream = null;\n" +
5637	" BufferedReader reader = null;\n" +
5638	" try {\n" +
5639	" stream = url.openStream();\n" +
5640	" reader = new BufferedReader(new InputStreamReader(stream));\n" +
5641	" System.out.println(reader.readLine());\n" +
5642	" } finally {\n" +
5643	" try {\n" +
5644	" if (reader != null)\n" +
5645	" reader.close();\n" +
5646	" } catch (IOException x) {\n" +
5647	" }\n" +
5648	" }\n" +
5649	" return false; // 'stream' may not be closed at this location\n" +
5650	" }\n" +
5651	" public static void main(String[] args) throws IOException {\n" +
5652	" try {\n" +
5653	" new X().loadURL(new URL(\""+url.toString()+"\"));\n" +
5654	" } catch (IOException ex) {\n" +
5655	" System.out.println(\"Got IO Exception\"+ex);\n" +
5656	" }\n" +
5657	" }\n" +
5658	"}\n"
5659	},
5660	"Manifest-Version: 1.0",
5661	null,
5662	true,
5663	null,
5664	options,
5665	null);
5666	}
5667	// Bug 358903 - Filter practically unimportant resource leak warnings
5668	// Bug 360908 - Avoid resource leak warning when the underlying/chained resource is closed explicitly
5669	// Different points in a resource chain are closed
5670	public void test061g() {
5671	Map options = getCompilerOptions();
5672	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5673	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5674	this.runNegativeTest(
5675	new String[] {
5676	"X.java",
5677	"import java.io.File;\n" +
5678	"import java.io.BufferedInputStream;\n" +
5679	"import java.io.FileInputStream;\n" +
5680	"import java.io.IOException;\n" +
5681	"public class X {\n" +
5682	" void closeMiddle() throws IOException {\n" +
5683	" File file = new File(\"somefile\");\n" +
5684	" FileInputStream fileStream = new FileInputStream(file);\n" +
5685	" BufferedInputStream bis = new BufferedInputStream(fileStream);\n" +
5686	" BufferedInputStream doubleWrap = new BufferedInputStream(bis);\n" +
5687	" System.out.println(bis.available());\n" +
5688	" bis.close();\n" +
5689	" }\n" +
5690	" void closeOuter() throws IOException {\n" +
5691	" File file2 = new File(\"somefile\");\n" +
5692	" FileInputStream fileStream2 = new FileInputStream(file2);\n" +
5693	" BufferedInputStream bis2 = new BufferedInputStream(fileStream2);\n" +
5694	" BufferedInputStream doubleWrap2 = new BufferedInputStream(bis2);\n" +
5695	" System.out.println(bis2.available());\n" +
5696	" doubleWrap2.close();\n" +
5697	" }\n" +
5698	" void neverClosed() throws IOException {\n" +
5699	" File file3 = new File(\"somefile\");\n" +
5700	" FileInputStream fileStream3 = new FileInputStream(file3);\n" +
5701	" BufferedInputStream bis3 = new BufferedInputStream(fileStream3);\n" +
5702	" BufferedInputStream doubleWrap3 = new BufferedInputStream(bis3);\n" +
5703	" System.out.println(doubleWrap3.available());\n" +
5704	" }\n" +
5705	"}\n"
5706	},
5707	"----------\n" +
5708	"1. ERROR in X.java (at line 26)\n" +
5709	" BufferedInputStream doubleWrap3 = new BufferedInputStream(bis3);\n" +
5710	" ^^^^^^^^^^^\n" +
5711	"Resource leak: \'doubleWrap3\' is never closed\n" +
5712	"----------\n",
5713	null,
5714	true,
5715	options);
5716	}
5717	// Bug 358903 - Filter practically unimportant resource leak warnings
5718	// Bug 360908 - Avoid resource leak warning when the underlying/chained resource is closed explicitly
5719	// Different points in a resource chain are potentially closed
5720	public void test061h() {
5721	Map options = getCompilerOptions();
5722	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5723	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5724	this.runNegativeTest(
5725	new String[] {
5726	"X.java",
5727	"import java.io.File;\n" +
5728	"import java.io.BufferedInputStream;\n" +
5729	"import java.io.FileInputStream;\n" +
5730	"import java.io.IOException;\n" +
5731	"public class X {\n" +
5732	" void closeMiddle(boolean b) throws IOException {\n" +
5733	" File file = new File(\"somefile\");\n" +
5734	" FileInputStream fileStream = new FileInputStream(file);\n" +
5735	" BufferedInputStream bis = new BufferedInputStream(fileStream);\n" +
5736	" BufferedInputStream doubleWrap = new BufferedInputStream(bis);\n" +
5737	" System.out.println(bis.available());\n" +
5738	" if (b)\n" +
5739	" bis.close();\n" +
5740	" }\n" +
5741	" void closeOuter(boolean b) throws IOException {\n" +
5742	" File file2 = new File(\"somefile\");\n" +
5743	" FileInputStream fileStream2 = new FileInputStream(file2);\n" +
5744	" BufferedInputStream dummy;\n" +
5745	" BufferedInputStream bis2 = (dummy = new BufferedInputStream(fileStream2));\n" +
5746	" BufferedInputStream doubleWrap2 = new BufferedInputStream(bis2);\n" +
5747	" System.out.println(bis2.available());\n" +
5748	" if (b)\n" +
5749	" doubleWrap2.close();\n" +
5750	" }\n" +
5751	" void potAndDef(boolean b) throws IOException {\n" +
5752	" File file3 = new File(\"somefile\");\n" +
5753	" FileInputStream fileStream3 = new FileInputStream(file3);\n" +
5754	" BufferedInputStream bis3 = new BufferedInputStream(fileStream3);\n" +
5755	" BufferedInputStream doubleWrap3 = new BufferedInputStream(bis3);\n" +
5756	" System.out.println(doubleWrap3.available());\n" +
5757	" if (b) bis3.close();\n" +
5758	" fileStream3.close();\n" +
5759	" }\n" +
5760	"}\n"
5761	},
5762	"----------\n" +
5763	"1. ERROR in X.java (at line 10)\n" +
5764	" BufferedInputStream doubleWrap = new BufferedInputStream(bis);\n" +
5765	" ^^^^^^^^^^\n" +
5766	"Potential resource leak: \'doubleWrap\' may not be closed\n" +
5767	"----------\n" +
5768	"2. ERROR in X.java (at line 20)\n" +
5769	" BufferedInputStream doubleWrap2 = new BufferedInputStream(bis2);\n" +
5770	" ^^^^^^^^^^^\n" +
5771	"Potential resource leak: \'doubleWrap2\' may not be closed\n" +
5772	"----------\n",
5773	null,
5774	true,
5775	options);
5776	}
5777	// Bug 358903 - Filter practically unimportant resource leak warnings
5778	// local var is re-used for two levels of wrappers
5779	public void test061i() {
5780	Map options = getCompilerOptions();
5781	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5782	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5783	this.runNegativeTest(
5784	new String[] {
5785	"X.java",
5786	"import java.io.File;\n" +
5787	"import java.io.InputStream;\n" +
5788	"import java.io.BufferedInputStream;\n" +
5789	"import java.io.FileInputStream;\n" +
5790	"import java.io.IOException;\n" +
5791	"public class X {\n" +
5792	" void closeMiddle() throws IOException {\n" +
5793	" File file = new File(\"somefile\");\n" +
5794	" InputStream stream = new FileInputStream(file);\n" +
5795	" stream = new BufferedInputStream(stream);\n" +
5796	" InputStream middle;\n" +
5797	" stream = new BufferedInputStream(middle = stream);\n" +
5798	" System.out.println(stream.available());\n" +
5799	" middle.close();\n" +
5800	" }\n" +
5801	" void closeOuter() throws IOException {\n" +
5802	" File file = new File(\"somefile\");\n" +
5803	" InputStream stream2 = new FileInputStream(file);\n" +
5804	" stream2 = new BufferedInputStream(stream2);\n" +
5805	" stream2 = new BufferedInputStream(stream2);\n" +
5806	" System.out.println(stream2.available());\n" +
5807	" stream2.close();\n" +
5808	" }\n" +
5809	" void neverClosed() throws IOException {\n" +
5810	" File file = new File(\"somefile\");\n" +
5811	" InputStream stream3 = new FileInputStream(file);\n" +
5812	" stream3 = new BufferedInputStream(stream3);\n" +
5813	" stream3 = new BufferedInputStream(stream3);\n" +
5814	" System.out.println(stream3.available());\n" +
5815	" }\n" +
5816	"}\n"
5817	},
5818	"----------\n" +
5819	"1. ERROR in X.java (at line 26)\n" +
5820	" InputStream stream3 = new FileInputStream(file);\n" +
5821	" ^^^^^^^\n" +
5822	"Resource leak: \'stream3\' is never closed\n" +
5823	"----------\n",
5824	null,
5825	true,
5826	options);
5827	}
5828	// Bug 358903 - Filter practically unimportant resource leak warnings
5829	// self-wrapping a method argument (caused NPE UnconditionalFlowInfo.markAsDefinitelyNull(..)).
5830	public void test061j() {
5831	Map options = getCompilerOptions();
5832	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5833	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5834	this.runConformTest(
5835	new String[] {
5836	"X.java",
5837	"import java.io.InputStream;\n" +
5838	"import java.io.BufferedInputStream;\n" +
5839	"import java.io.IOException;\n" +
5840	"public class X {\n" +
5841	" void foo(InputStream stream) throws IOException {\n" +
5842	" stream = new BufferedInputStream(stream);\n" +
5843	" System.out.println(stream.available());\n" +
5844	" stream.close();\n" +
5845	" }\n" +
5846	" void boo(InputStream stream2) throws IOException {\n" +
5847	" stream2 = new BufferedInputStream(stream2);\n" +
5848	" System.out.println(stream2.available());\n" +
5849	" }\n" +
5850	"}\n"
5851	},
5852	"",
5853	null,
5854	true,
5855	null,
5856	options,
5857	null);
5858	}
5859	// Bug 358903 - Filter practically unimportant resource leak warnings
5860	// a wrapper is created in a return statement
5861	public void test061k() throws IOException {
5862	Map options = getCompilerOptions();
5863	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5864	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5865	this.runConformTest(
5866	new String[] {
5867	"X.java",
5868	"import java.io.File;\n" +
5869	"import java.io.FileInputStream;\n" +
5870	"import java.io.BufferedInputStream;\n" +
5871	"import java.io.IOException;\n" +
5872	"public class X {\n" +
5873	" BufferedInputStream getReader(File file) throws IOException {\n" +
5874	" FileInputStream stream = new FileInputStream(file);\n" +
5875	" return new BufferedInputStream(stream);\n" +
5876	" }\n" +
5877	"}\n"
5878	},
5879	"",
5880	null,
5881	true,
5882	null,
5883	options,
5884	null);
5885	}
5886	// Bug 358903 - Filter practically unimportant resource leak warnings
5887	// a closeable is assigned to a field
5888	public void test061l() throws IOException {
5889	Map options = getCompilerOptions();
5890	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5891	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5892	this.runConformTest(
5893	new String[] {
5894	"X.java",
5895	"import java.io.File;\n" +
5896	"import java.io.FileInputStream;\n" +
5897	"import java.io.BufferedInputStream;\n" +
5898	"import java.io.IOException;\n" +
5899	"public class X {\n" +
5900	" BufferedInputStream stream;\n" +
5901	" void foo(File file) throws IOException {\n" +
5902	" FileInputStream s = new FileInputStream(file);\n" +
5903	" stream = new BufferedInputStream(s);\n" +
5904	" }\n" +
5905	"}\n"
5906	},
5907	"",
5908	null,
5909	true,
5910	null,
5911	options,
5912	null);
5913	}
5914	// Bug 362331 - Resource leak not detected when closeable not assigned to variable
5915	// a resource is never assigned
5916	public void test062a() throws IOException {
5917	Map options = getCompilerOptions();
5918	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5919	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5920	this.runNegativeTest(
5921	new String[] {
5922	"X.java",
5923	"import java.io.File;\n" +
5924	"import java.io.FileOutputStream;\n" +
5925	"import java.io.IOException;\n" +
5926	"public class X {\n" +
5927	" void foo() throws IOException {\n" +
5928	" new FileOutputStream(new File(\"C:\\temp\\foo.txt\")).write(1);\n" +
5929	" }\n" +
5930	"}\n"
5931	},
5932	"----------\n" +
5933	"1. ERROR in X.java (at line 6)\n" +
5934	" new FileOutputStream(new File(\"C:\\temp\\foo.txt\")).write(1);\n" +
5935	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
5936	"Resource leak: \'<unassigned Closeable value>\' is never closed\n" +
5937	"----------\n",
5938	null,
5939	true,
5940	options);
5941	}
5942	// Bug 362331 - Resource leak not detected when closeable not assigned to variable
5943	// a freshly allocated resource is immediately closed
5944	public void test062b() throws IOException {
5945	Map options = getCompilerOptions();
5946	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5947	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5948	this.runConformTest(
5949	new String[] {
5950	"X.java",
5951	"import java.io.File;\n" +
5952	"import java.io.FileOutputStream;\n" +
5953	"import java.io.IOException;\n" +
5954	"public class X {\n" +
5955	" void foo() throws IOException {\n" +
5956	" new FileOutputStream(new File(\"C:\\temp\\foo.txt\")).close();\n" +
5957	" }\n" +
5958	"}\n"
5959	},
5960	"",
5961	null,
5962	true,
5963	null,
5964	options,
5965	null);
5966	}
5967	// Bug 362331 - Resource leak not detected when closeable not assigned to variable
5968	// a resource is directly passed to another method
5969	public void test062c() throws IOException {
5970	Map options = getCompilerOptions();
5971	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
5972	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
5973	this.runConformTest(
5974	new String[] {
5975	"X.java",
5976	"import java.io.File;\n" +
5977	"import java.io.FileOutputStream;\n" +
5978	"import java.io.IOException;\n" +
5979	"public class X {\n" +
5980	" void foo() throws IOException {\n" +
5981	" writeIt(new FileOutputStream(new File(\"C:\\temp\\foo.txt\")));\n" +
5982	" }\n" +
5983	" void writeIt(FileOutputStream fos) throws IOException {\n" +
5984	" fos.write(1);\n" +
5985	" fos.close();\n" +
5986	" }\n" +
5987	"}\n"
5988	},
5989	"",
5990	null,
5991	true,
5992	null,
5993	options,
5994	null);
5995	}
5996	// Bug 362331 - Resource leak not detected when closeable not assigned to variable
5997	// a resource is not used
5998	public void test062d() throws IOException {
5999	Map options = getCompilerOptions();
6000	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
6001	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
6002	this.runNegativeTest(
6003	new String[] {
6004	"X.java",
6005	"import java.io.File;\n" +
6006	"import java.io.FileOutputStream;\n" +
6007	"import java.io.IOException;\n" +
6008	"public class X {\n" +
6009	" void foo() throws IOException {\n" +
6010	" new FileOutputStream(new File(\"C:\\temp\\foo.txt\"));\n" +
6011	" }\n" +
6012	"}\n"
6013	},
6014	"----------\n" +
6015	"1. ERROR in X.java (at line 6)\n" +
6016	" new FileOutputStream(new File(\"C:\\temp\\foo.txt\"));\n" +
6017	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
6018	"Resource leak: \'<unassigned Closeable value>\' is never closed\n" +
6019	"----------\n",
6020	null,
6021	true,
6022	options);
6023	}
6024	// Bug 362332 - Only report potential leak when closeable not created in the local scope
6025	// a wrapper is obtained from another method
6026	public void test063a() throws IOException {
6027	Map options = getCompilerOptions();
6028	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
6029	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
6030	this.runNegativeTest(
6031	new String[] {
6032	"X.java",
6033	"import java.io.File;\n" +
6034	"import java.io.FileInputStream;\n" +
6035	"import java.io.BufferedInputStream;\n" +
6036	"import java.io.IOException;\n" +
6037	"public class X {\n" +
6038	" void read(File file) throws IOException {\n" +
6039	" FileInputStream stream = new FileInputStream(file);\n" +
6040	" BufferedInputStream bis = new BufferedInputStream(stream); // never since reassigned\n" +
6041	" FileInputStream stream2 = new FileInputStream(file); // unsure since passed to method\n" +
6042	" bis = getReader(stream2); // unsure since obtained from method\n" +
6043	" bis.available();\n" +
6044	" }\n" +
6045	" BufferedInputStream getReader(FileInputStream stream) throws IOException {\n" +
6046	" return new BufferedInputStream(stream);\n" +
6047	" }\n" +
6048	"}\n"
6049	},
6050	"----------\n" +
6051	"1. ERROR in X.java (at line 8)\n" +
6052	" BufferedInputStream bis = new BufferedInputStream(stream); // never since reassigned\n" +
6053	" ^^^\n" +
6054	"Resource leak: \'bis\' is never closed\n" +
6055	"----------\n" +
6056	"2. ERROR in X.java (at line 9)\n" +
6057	" FileInputStream stream2 = new FileInputStream(file); // unsure since passed to method\n" +
6058	" ^^^^^^^\n" +
6059	"Potential resource leak: \'stream2\' may not be closed\n" +
6060	"----------\n" +
6061	"3. ERROR in X.java (at line 10)\n" +
6062	" bis = getReader(stream2); // unsure since obtained from method\n" +
6063	" ^^^^^^^^^^^^^^^^^^^^^^^^\n" +
6064	"Potential resource leak: \'bis\' may not be closed\n" +
6065	"----------\n",
6066	null,
6067	true,
6068	options);
6069	}
6070	// Bug 362332 - Only report potential leak when closeable not created in the local scope
6071	// a wrapper is obtained from a field read
6072	public void test063b() throws IOException {
6073	Map options = getCompilerOptions();
6074	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
6075	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
6076	this.runConformTest(
6077	new String[] {
6078	"X.java",
6079	"import java.io.FileInputStream;\n" +
6080	"import java.io.BufferedInputStream;\n" +
6081	"import java.io.IOException;\n" +
6082	"public class X {\n" +
6083	" FileInputStream stream;\n" +
6084	" void read() throws IOException {\n" +
6085	" FileInputStream s = this.stream;\n" +
6086	" BufferedInputStream bis = new BufferedInputStream(s); // don't complain since s is obtained from a field\n" +
6087	" bis.available();\n" +
6088	" }\n" +
6089	"}\n"
6090	},
6091	"",
6092	null,
6093	true,
6094	null,
6095	options,
6096	null);
6097	}
6098	// Bug 362332 - Only report potential leak when closeable not created in the local scope
6099	// a wrapper is assigned to a field
6100	public void test063c() throws IOException {
6101	Map options = getCompilerOptions();
6102	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
6103	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
6104	this.runConformTest(
6105	new String[] {
6106	"X.java",
6107	"import java.io.FileInputStream;\n" +
6108	"import java.io.BufferedInputStream;\n" +
6109	"import java.io.IOException;\n" +
6110	"public class X {\n" +
6111	" BufferedInputStream stream;\n" +
6112	" void read() throws IOException {\n" +
6113	" FileInputStream s = new FileInputStream(\"somefile\");\n" +
6114	" BufferedInputStream bis = new BufferedInputStream(s);\n" +
6115	" this.stream = bis;\n" +
6116	" }\n" +
6117	"}\n"
6118	},
6119	"",
6120	null,
6121	true,
6122	null,
6123	options,
6124	null);
6125	}
5358	public static Class testClass() {	6126	public static Class testClass() {
5359	return TryWithResourcesStatementTest.class;	6127	return TryWithResourcesStatementTest.class;
5360	}	6128	}

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (-3 / +10 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 12-17 Link Here
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	* bug 349326 - [1.7] new warning for missing try-with-resources
14	* bug 186342 - [compiler][null] Using annotations for null checking	14	* bug 186342 - [compiler][null] Using annotations for null checking
		15	* bug 358903 - Filter practically unimportant resource leak warnings
15	*******************************************************************************/	16	*******************************************************************************/
16	package org.eclipse.jdt.internal.compiler.ast;	17	package org.eclipse.jdt.internal.compiler.ast;
17		18
Lines 37-42 Link Here
37	protected TypeBinding typeExpected; // for <> inference	38	protected TypeBinding typeExpected; // for <> inference
38	public boolean inferredReturnType;	39	public boolean inferredReturnType;
39		40
		41	public FakedTrackingVariable closeTracker; // when allocation a Closeable store a pre-liminary tracking variable here
		42
40	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	43	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
41	// check captured variables are initialized in current context (26134)	44	// check captured variables are initialized in current context (26134)
42	checkCapturedLocalInitializationIfNecessary((ReferenceBinding)this.binding.declaringClass.erasure(), currentScope, flowInfo);	45	checkCapturedLocalInitializationIfNecessary((ReferenceBinding)this.binding.declaringClass.erasure(), currentScope, flowInfo);
Lines 44-61 Link Here
44	// process arguments	47	// process arguments
45	if (this.arguments != null) {	48	if (this.arguments != null) {
46	for (int i = 0, count = this.arguments.length; i < count; i++) {	49	for (int i = 0, count = this.arguments.length; i < count; i++) {
47	// if argument is an AutoCloseable insert info that it may be closed (by the target method, i.e.)
48	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo);
49	flowInfo =	50	flowInfo =
50	this.arguments[i]	51	this.arguments[i]
51	.analyseCode(currentScope, flowContext, flowInfo)	52	.analyseCode(currentScope, flowContext, flowInfo)
52	.unconditionalInits();	53	.unconditionalInits();
		54	// if argument is an AutoCloseable insert info that it may be closed (by the target method, i.e.)
		55	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo, this.resolvedType);
53	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {	56	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {
54	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	57	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);
55	}	58	}
56	}	59	}
57	analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);	60	analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);
58	}	61	}
		62
		63	if (FakedTrackingVariable.isAutoCloseable(this.resolvedType))
		64	FakedTrackingVariable.analyseCloseableAllocation(currentScope, flowInfo, this);
		65
59	// record some dependency information for exception types	66	// record some dependency information for exception types
60	ReferenceBinding[] thrownExceptions;	67	ReferenceBinding[] thrownExceptions;
61	if (((thrownExceptions = this.binding.thrownExceptions).length) != 0) {	68	if (((thrownExceptions = this.binding.thrownExceptions).length) != 0) {




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *     						bug 335093 - [compiler][null] minimal hook for future null annotation support
 *     						bug 349326 - [1.7] new warning for missing try-with-resources
 *							bug 186342 - [compiler][null] Using annotations for null checking
 *							bug 358903 - Filter practically unimportant resource leak warnings
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;


	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
		this.expression.checkNPE(currentScope, flowContext, flowInfo);
	}
	
	FlowInfo preInitInfo = null;
	boolean shouldAnalyseResource = local != null 
			&& flowInfo.reachMode() == FlowInfo.REACHABLE 
			&& (FakedTrackingVariable.isAutoCloseable(this.expression.resolvedType)
					|| this.expression.resolvedType == TypeBinding.NULL);
	if (shouldAnalyseResource) {
		preInitInfo = flowInfo.unconditionalCopy();
		// analysis of resource leaks needs additional context while analyzing the RHS:
		FakedTrackingVariable.preConnectTrackerAcrossAssignment(this, local, this.expression);
	}
	
	flowInfo = ((Reference) this.lhs)
		.analyseAssignment(currentScope, flowContext, flowInfo, this, false)
		.unconditionalInits();

	if (shouldAnalyseResource)
		FakedTrackingVariable.handleResourceAssignment(preInitInfo, flowInfo, this, this.expression, local);
	else
		FakedTrackingVariable.cleanUpAfterAssignment(currentScope, this.lhs.bits, this.expression);

				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) {




/*******************************************************************************
 * Copyright (c) 2011, 2012 GK Software AG and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

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;

	private static final int CLOSED_IN_NESTED_METHOD = 4;
	// a location independent issue has been reported already against this resource:
	private static final int REPORTED = 8;
	// a resource is wrapped in another resource:
	private static final int WRAPPED = 16;

	private static final int DOUBT_MASK = CLOSE_SEEN | PASSED_TO_OUTSIDE | CLOSED_IN_NESTED_METHOD | REPORTED; // not WRAPPED

	/**
	 * Bitset of {@link #CLOSE_SEEN}, {@link #PASSED_TO_OUTSIDE}, {@link #CLOSED_IN_NESTED_METHOD}, {@link #REPORTED} and {@link #WRAPPED}.
	 */
	private int globalClosingState = 0;

	public LocalVariableBinding originalBinding; // the real local being tracked, can be null for preliminary track vars for allocation expressions
	
	public FakedTrackingVariable innerTracker; // chained tracking variable of a chained (wrapped) resource

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

	private HashMap recordedLocations; // initially null, ASTNode -> Integer

	// temporary storage while analyzing "res = new Res();":
	private ASTNode currentAssignment; // temporarily store the assignment as the location for error reporting

	public FakedTrackingVariable(LocalVariableBinding original, ASTNode location) {
		super(original.name, location.sourceStart, location.sourceEnd);
		this.type = new SingleTypeReference(
				TypeConstants.OBJECT,

		this.methodScope = original.declaringScope.methodScope();
		this.originalBinding = original;
		resolve(original.declaringScope);
	}

	/* Create an unassigned tracking variable while analyzing an allocation expression: */
	private FakedTrackingVariable(BlockScope scope, ASTNode location) {
		super("<unassigned Closeable value>".toCharArray(), location.sourceStart, location.sourceEnd); //$NON-NLS-1$
		this.type = new SingleTypeReference(
				TypeConstants.OBJECT,
				((long)this.sourceStart <<32)+this.sourceEnd);
		this.methodScope = scope.methodScope();
		this.originalBinding = null;
		resolve(scope);
	}
	
	public void generateCode(BlockScope currentScope, CodeStream codeStream)

	}

	/**
	 * If expression resolves to a value of type AutoCloseable answer the variable that tracks closing of that local.
	 * Covers two cases:
	 * <ul>
	 * <li>value is a local variable reference, create tracking variable it if needed.
	 * <li>value is an allocation expression, return a preliminary tracking variable if set.
	 * </ul>
	 * @param expression
	 * @return a new {@link FakedTrackingVariable} or null.
	 */

				Statement location = local.declaration;
				return local.closeTracker = new FakedTrackingVariable(local, location);
			}
		} else if (expression instanceof AllocationExpression) {
			// return any preliminary tracking variable from analyseCloseableAllocation 
			return ((AllocationExpression) expression).closeTracker;
		}		
		return null;
	}

	/**
	 * Before analyzing an assignment of this shape: <code>singleName = new Allocation()</code>
	 * connect any tracking variable of the LHS with the allocation on the RHS.
	 * Also the assignment is temporarily stored in the tracking variable in case we need to
	 * report errors because the assignment leaves the old LHS value unclosed.
	 * In this case the assignment should be used as the error location.
	 * 
	 * @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.
	 */
	public static void preConnectTrackerAcrossAssignment(ASTNode location, LocalVariableBinding local, Expression rhs) {
		FakedTrackingVariable closeTracker = null;
		if (rhs instanceof AllocationExpression) {
			closeTracker = local.closeTracker;
			if (closeTracker == null) {
				if (isAutoCloseable(rhs.resolvedType)) {
					closeTracker = new FakedTrackingVariable(local, location);
				}					
			}
			if (closeTracker != null) {
				closeTracker.currentAssignment = location;
				((AllocationExpression)rhs).closeTracker = closeTracker;
			}
		}
	}

	/** 
	 * Compute/assign a tracking variable for a freshly allocated closeable value, using information from our white lists.
	 * See  Bug 358903 - Filter practically unimportant resource leak warnings 
	 */
	public static void analyseCloseableAllocation(BlockScope scope, FlowInfo flowInfo, AllocationExpression allocation) {
		// client has checked that the resolvedType is an AutoCloseable, hence the following cast is safe:
		if (((ReferenceBinding)allocation.resolvedType).hasTypeBit(TypeIds.BitResourceFreeCloseable)) {
			// remove unnecessary attempts (closeable is not relevant)
			if (allocation.closeTracker != null) {
				scope.removeTrackingVar(allocation.closeTracker);
				allocation.closeTracker = null;
			}
		} else if (((ReferenceBinding)allocation.resolvedType).hasTypeBit(TypeIds.BitWrapperCloseable)) {
			if (allocation.arguments != null &&  allocation.arguments.length > 0) {
				// find the wrapped resource represented by its tracking var:
				FakedTrackingVariable innerTracker = analyseCloseableAllocationArgument(scope, flowInfo, allocation, allocation.arguments[0]);
				if (innerTracker != null) {
					if (innerTracker == allocation.closeTracker)
						return; // self wrap (res = new Res(res)) -> neither change (here) nor remove (below)
					if (allocation.closeTracker == null) {
						allocation.closeTracker = new FakedTrackingVariable(scope, allocation); // no local available, closeable is unassigned
					}
					allocation.closeTracker.innerTracker = innerTracker;
					innerTracker.globalClosingState |= WRAPPED;
					flowInfo.markAsDefinitelyNull(allocation.closeTracker.binding);
					return; // keep chaining wrapper
				}
			}
			// remove unnecessary attempts (wrapper has no relevant inner)
			if (allocation.closeTracker != null) {
				scope.removeTrackingVar(allocation.closeTracker);
				allocation.closeTracker = null;
			}
		} else { // regular resource
			FakedTrackingVariable presetTracker = allocation.closeTracker;
			if (presetTracker != null && presetTracker.originalBinding != null) {
				int closeStatus = flowInfo.nullStatus(presetTracker.binding);
				if (closeStatus != FlowInfo.NON_NULL
						&& !flowInfo.isDefinitelyNull(presetTracker.originalBinding)
						&& !(presetTracker.currentAssignment instanceof LocalDeclaration))
					allocation.closeTracker.recordErrorLocation(presetTracker.currentAssignment, closeStatus);
			} else {
				allocation.closeTracker = new FakedTrackingVariable(scope, allocation); // no local available, closeable is unassigned
			}
			flowInfo.markAsDefinitelyNull(allocation.closeTracker.binding);
		}
	}

	/** Find an existing tracking variable for the argument of an allocation for a resource wrapper. */
	public static FakedTrackingVariable analyseCloseableAllocationArgument(BlockScope scope, FlowInfo flowInfo, AllocationExpression allocation, Expression arg)
	{
		while (arg instanceof Assignment) {
			Assignment assign = (Assignment)arg;
			LocalVariableBinding innerLocal = assign.localVariableBinding();
			if (innerLocal != null) {
				// nested assignment has already been processed
				return innerLocal.closeTracker;
			} else {
				arg = assign.expression; // unwrap assignment and fall through
			}
		}
		if (arg instanceof SingleNameReference) {
			// is allocation arg a reference to an existing closeable?
			LocalVariableBinding local = arg.localVariableBinding();
			if (local != null) {
				return local.closeTracker;
			}
		} else if (arg instanceof AllocationExpression && arg.resolvedType instanceof ReferenceBinding) {
			// nested allocation
			return ((AllocationExpression)arg).closeTracker;
		}
		return null; // not a tracked expression
	}

	/** 
	 * 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.
	 * @param upstreamInfo info without analysis of the rhs, use this to determine the status of a resource being disconnected
	 * @param flowInfo info with analysis of the rhs, use this for recording resource status because this will be passed downstream
	 * @param location where to report warnigs/errors against
	 * @param rhs the right hand side of the assignment, this expression is to be analyzed.
	 *			The caller has already checked that the rhs is either of a closeable type or null.
	 * @param local the local variable into which the rhs is being assigned
	 */
	public static void handleResourceAssignment(FlowInfo upstreamInfo, FlowInfo flowInfo, ASTNode location, Expression rhs, LocalVariableBinding local)
				LocalVariableBinding previousTrackerBinding) 
	{
		// does the LHS (local) already have a tracker, indicating we may leak a resource by the assignment?
		FakedTrackingVariable previousTracker = null;
		FakedTrackingVariable disconnectedTracker = null;
		if (local.closeTracker != null) {
			// assigning to a variable already holding an AutoCloseable, has it been closed before?
			previousTracker = local.closeTracker;
			int nullStatus = upstreamInfo.nullStatus(local);
			if (nullStatus != FlowInfo.NULL && nullStatus != FlowInfo.UNKNOWN) // only if previous value may be relevant
				disconnectedTracker = previousTracker; // report error below, unless we have a self-wrap assignment
		}

		if (rhs.resolvedType != TypeBinding.NULL) {
			// new value is AutoCloseable, start tracking, possibly re-using existing tracker var:
	
			FakedTrackingVariable rhsTrackVar = getCloseTrackingVariable(rhs);
			if (rhsTrackVar != null) {								// 1. if RHS has a tracking variable...
				if (local.closeTracker == null) {
					// null shouldn't occur but let's play safe
					if (rhsTrackVar.originalBinding != null)
						local.closeTracker = rhsTrackVar;			//		a.: let fresh LHS share it 
				} else {
					if (rhsTrackVar == disconnectedTracker && rhs instanceof AllocationExpression)
						return; 									// 		b.: self wrapper: res = new Wrap(res); -> done!
					local.closeTracker = rhsTrackVar;				//		c.: conflicting LHS and RHS, proceed with recordErrorLocation below
				}
				// keep close-status of RHS unchanged across this assignment
			} else if (previousTracker != null) {					// 2. re-use tracking variable from the LHS?
				// re-assigning from a fresh value, mark as not-closed again:
				flowInfo.markAsDefinitelyNull(previousTracker.binding);
				local.closeTracker = analyseCloseableExpression(flowInfo, local, location, rhs, previousTracker);
			} else {												// 3. no re-use, create a fresh tracking variable:
				rhsTrackVar = analyseCloseableExpression(flowInfo, local, location, rhs, null);
				if (rhsTrackVar != null) {
					local.closeTracker = rhsTrackVar;
					// a fresh resource, mark as not-closed:
					if ((rhsTrackVar.globalClosingState & PASSED_TO_OUTSIDE) == 0)
						flowInfo.markAsDefinitelyNull(rhsTrackVar.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);
				}
			}
		}

		if (disconnectedTracker != null)
			disconnectedTracker.recordErrorLocation(location, upstreamInfo.nullStatus(disconnectedTracker.binding));
	}
	/**
	 * Analyze structure of a closeable expression, matching (chained) resources against our white lists.
	 * @param flowInfo where to record close status
	 * @param local local variable to which the closeable is being assigned
	 * @param location where to flag errors/warnings against
	 * @param expression expression to be analyzed
	 * @param previousTracker when analyzing a re-assignment we may already have a tracking variable for local,
	 *  		which we should then re-use
	 * @return a tracking variable associated with local or null if no need to track
	 */
	private static FakedTrackingVariable analyseCloseableExpression(FlowInfo flowInfo, LocalVariableBinding local, 
									ASTNode location, Expression expression, FakedTrackingVariable previousTracker) 
	{
		// unwrap uninteresting nodes:
		while (true) {
			if (expression instanceof Assignment)
				expression = ((Assignment)expression).expression;
			else if (expression instanceof CastExpression)
				expression = ((CastExpression) expression).expression;
			else
				break;
		}

		// analyze by node type:
		if (expression instanceof AllocationExpression) {
			// allocation expressions already have their tracking variables analyzed by analyseCloseableAllocation(..)
			FakedTrackingVariable tracker = ((AllocationExpression) expression).closeTracker;
			if (tracker != null && tracker.originalBinding == null) {
				// tracker without original binding (unassigned closeable) shouldn't reach here but let's play safe
				return null;
			}
			return tracker;
		} else if (expression instanceof MessageSend 
				|| expression instanceof ArrayReference) 
		{
			// we *might* be responsible for the resource obtained
			FakedTrackingVariable tracker = new FakedTrackingVariable(local, location);
			tracker.globalClosingState |= PASSED_TO_OUTSIDE;
			flowInfo.markPotentiallyNullBit(tracker.binding);
			return tracker;			
		} else if (expression instanceof FieldReference 
				|| expression instanceof QualifiedNameReference) 
		{
			// responsibility for this resource probably lies at a higher level
			FakedTrackingVariable tracker = new FakedTrackingVariable(local, location);
			tracker.globalClosingState |= PASSED_TO_OUTSIDE;
			flowInfo.markPotentiallyNonNullBit(tracker.binding);
			return tracker;			
		}

		if (expression.resolvedType instanceof ReferenceBinding) {
			ReferenceBinding resourceType = (ReferenceBinding) expression.resolvedType;
			if (resourceType.hasTypeBit(TypeIds.BitResourceFreeCloseable)) {
				// (a) resource-free closeable: -> null
				return null;
			}
		}
		if (local.closeTracker != null)
			// (c): inner has already been analyzed: -> re-use track var
			return local.closeTracker;
		return new FakedTrackingVariable(local, location);
	}

	public static void cleanUpAfterAssignment(BlockScope currentScope, int lhsBits, Expression expression) {
		// remove all remaining track vars with no original binding

		// unwrap uninteresting nodes:
		while (true) {
			if (expression instanceof Assignment)
				expression = ((Assignment)expression).expression;
			else if (expression instanceof CastExpression)
				expression = ((CastExpression) expression).expression;
			else
				break;
		}
		if (expression instanceof AllocationExpression) {
			FakedTrackingVariable tracker = ((AllocationExpression) expression).closeTracker;
			if (tracker != null && tracker.originalBinding == null) {
				currentScope.removeTrackingVar(tracker);
				((AllocationExpression) expression).closeTracker = null;
			}
		} else {
			// assignment passing a local into a field?
			LocalVariableBinding local = expression.localVariableBinding();
			if (local != null && local.closeTracker != null && ((lhsBits & Binding.FIELD) != 0))
				currentScope.removeTrackingVar(local.closeTracker);
		}
	}


	public static boolean isAutoCloseable(TypeBinding typeBinding) {
		return typeBinding instanceof ReferenceBinding
			&& ((ReferenceBinding)typeBinding).hasTypeBit(TypeIds.BitAutoCloseable|TypeIds.BitCloseable);
	}

	public int findMostSpecificStatus(FlowInfo flowInfo, BlockScope currentScope, BlockScope locationScope) {
		int status = FlowInfo.UNKNOWN;
		FakedTrackingVariable currentTracker = this;
		// loop as to consider wrappers (per white list) encapsulating an inner resource.
		while (currentTracker != null) {
			LocalVariableBinding currentVar = currentTracker.binding;
			int currentStatus = getNullStatusAggressively(currentVar, flowInfo);
			if (locationScope != null) // only check at method exit points
				currentStatus = mergeCloseStatus(locationScope, currentStatus, currentVar, currentScope);
			if (currentStatus == FlowInfo.NON_NULL) {
				status = currentStatus;
				break; // closed -> stop searching
			} else if (status == FlowInfo.NULL || status == FlowInfo.UNKNOWN) {
				status = currentStatus; // improved although not yet safe -> keep searching for better
			}
			currentTracker = currentTracker.innerTracker;
		}
		return status;
	}

	/**
	 * Get the null status looking even into unreachable flows
	 * @param local
	 * @param flowInfo
	 * @return one of the constants FlowInfo.{NULL,POTENTIALLY_NULL,POTENTIALLY_NON_NULL,NON_NULL}.
	 */
	private int getNullStatusAggressively(LocalVariableBinding local, FlowInfo flowInfo) {
		int reachMode = flowInfo.reachMode();
		int status = 0;
		try {
			// unreachable flowInfo is too shy in reporting null-issues, temporarily forget reachability:
			if (reachMode != FlowInfo.REACHABLE)
				flowInfo.tagBits &= ~FlowInfo.UNREACHABLE;
			status = flowInfo.nullStatus(local);
		} finally {
			// reset
			flowInfo.tagBits |= reachMode;
		}
		// at this point some combinations are not useful so flatten to a single bit:
		if ((status & FlowInfo.NULL) != 0) {
			if ((status & (FlowInfo.NON_NULL | FlowInfo.POTENTIALLY_NON_NULL)) != 0)
				return FlowInfo.POTENTIALLY_NULL; 	// null + doubt = pot null
			return FlowInfo.NULL;
		} else if ((status & FlowInfo.NON_NULL) != 0) {
			if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
				return FlowInfo.POTENTIALLY_NULL;	// non-null + doubt = pot null
			return FlowInfo.NON_NULL;
		} else if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
			return FlowInfo.POTENTIALLY_NULL;
		return status;
	}

	public int mergeCloseStatus(BlockScope currentScope, int status, LocalVariableBinding local, BlockScope outerScope) {
		// get the most suitable null status representing whether resource 'binding' has been closed
		// start at 'currentScope' and potentially travel out until 'outerScope'
		// at each scope consult any recorded 'finallyInfo'.
		if (status != FlowInfo.NON_NULL) {
			if (currentScope.finallyInfo != null) {
				int finallyStatus = currentScope.finallyInfo.nullStatus(local);
				if (finallyStatus == FlowInfo.NON_NULL)
					return finallyStatus;
				if (finallyStatus != FlowInfo.NULL) // neither is NON_NULL, but not both are NULL => call it POTENTIALLY_NULL
					status = FlowInfo.POTENTIALLY_NULL;
			}
			if (currentScope != outerScope && currentScope.parent instanceof BlockScope)
				return mergeCloseStatus(((BlockScope) currentScope.parent), status, local, outerScope);
		}
		return status;
	}

	/** Mark that this resource is closed locally. */

	 * (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, TypeBinding allocatedType) {	
		if ((allocatedType instanceof ReferenceBinding) // only set when called from AllocationExpression
				&& ((ReferenceBinding) allocatedType).hasTypeBit(TypeIds.BitWrapperCloseable))
			return flowInfo; // allocation of wrapped closeables is analyzed specially
		
		FakedTrackingVariable trackVar = getCloseTrackingVariable(expression);
		if (trackVar != null) {
			if (trackVar.originalBinding == null) {
				// an allocation that never was assigned to a local variable -> drop it completely as we're not responsible
				scope.removeTrackingVar(trackVar);
				return flowInfo;
			}
			trackVar.globalClosingState |= PASSED_TO_OUTSIDE;
			if (scope.methodScope() != trackVar.methodScope)
				trackVar.globalClosingState |= CLOSED_IN_NESTED_METHOD;

	}

	public boolean reportRecordedErrors(Scope scope) {
		FakedTrackingVariable current = this;
		while ((current.globalClosingState & DOUBT_MASK) == 0) {
			current = current.innerTracker;
			if (current == null) {
				// no relevant state found -> report:
				reportError(scope.problemReporter(), null, FlowInfo.NULL);
				return true;
			}
		}
		boolean hasReported = false;
		if (this.recordedLocations != null) {

	}
	
	public void reportError(ProblemReporter problemReporter, ASTNode location, int nullStatus) {
		if ((this.globalClosingState & WRAPPED) != 0)
			return;
		if (nullStatus == FlowInfo.NULL) {
			if ((this.globalClosingState & CLOSED_IN_NESTED_METHOD) != 0)
				problemReporter.potentiallyUnclosedCloseable(this, location);

				problemReporter.unclosedCloseable(this, location);
		} else if (nullStatus == FlowInfo.POTENTIALLY_NULL) {
			problemReporter.potentiallyUnclosedCloseable(this, location);
		}
	}

	public void reportExplicitClosing(ProblemReporter problemReporter) {




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *							bug 335093 - [compiler][null] minimal hook for future null annotation support
 *							bug 349326 - [1.7] new warning for missing try-with-resources
 *							bug 186342 - [compiler][null] Using annotations for null checking
 *							bug 358903 - Filter practically unimportant resource leak warnings
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;


		this.initialization.checkNPE(currentScope, flowContext, flowInfo);
	}
	
	FlowInfo preInitInfo = null;
	boolean shouldAnalyseResource = this.binding != null 
			&& flowInfo.reachMode() == FlowInfo.REACHABLE 
			&& FakedTrackingVariable.isAutoCloseable(this.initialization.resolvedType);
	if (shouldAnalyseResource) {
		preInitInfo = flowInfo.unconditionalCopy();
		// analysis of resource leaks needs additional context while analyzing the RHS:
		FakedTrackingVariable.preConnectTrackerAcrossAssignment(this, this.binding, this.initialization);
	}

	flowInfo =
		this.initialization
			.analyseCode(currentScope, flowContext, flowInfo)
			.unconditionalInits();

	if (shouldAnalyseResource)
		FakedTrackingVariable.handleResourceAssignment(preInitInfo, flowInfo, this, this.initialization, this.binding);
	else
		FakedTrackingVariable.cleanUpAfterAssignment(currentScope, Binding.LOCAL, this.initialization);

	int nullStatus = this.initialization.nullStatus(flowInfo);
	if (!flowInfo.isDefinitelyAssigned(this.binding)){// for local variable debug attributes
		this.bits |= FirstAssignmentToLocal;




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *								bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
 *								bug 349326 - [1.7] new warning for missing try-with-resources
 *								bug 186342 - [compiler][null] Using annotations for null checking
 *								bug 358903 - Filter practically unimportant resource leak warnings
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;


			if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {
				this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);
			}
			// if argument is an AutoCloseable insert info that it *may* be closed (by the target method, i.e.)
			flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo);
			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.)
			flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo, null);
		}
		analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);
	}

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java (-1 / +1 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at




 *     							bug 358827 - [1.7] exception analysis for t-w-r spoils null analysis
 *     							bug 349326 - [1.7] new warning for missing try-with-resources
 *     							bug 359334 - Analysis for resource leak warnings does not consider exceptions as method exit points
 *								bug 358903 - Filter practically unimportant resource leak warnings
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;


			if (resourceBinding.closeTracker != null) {
				// this was false alarm, we don't need to track the resource
				this.tryBlock.scope.removeTrackingVar(resourceBinding.closeTracker);
				// keep the tracking variable in the resourceBinding in order to prevent creating a new one while analyzing the try block
			}
			TypeBinding type = resourceBinding.type;
			if (type != null && type.isValidBinding()) {

			if (resourceBinding.closeTracker != null) {
				// this was false alarm, we don't need to track the resource
				this.tryBlock.scope.removeTrackingVar(resourceBinding.closeTracker);
				// keep the tracking variable in the resourceBinding in order to prevent creating a new one while analyzing the try block
			} 
			TypeBinding type = resourceBinding.type;
			if (type != null && type.isValidBinding()) {

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java (-3 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 11-16 Link Here
11	* bug 349326 - [1.7] new warning for missing try-with-resources	11	* bug 349326 - [1.7] new warning for missing try-with-resources
12	* bug 186342 - [compiler][null] Using annotations for null checking	12	* bug 186342 - [compiler][null] Using annotations for null checking
13	* bug 364890 - BinaryTypeBinding should use char constants from Util	13	* bug 364890 - BinaryTypeBinding should use char constants from Util
		14	* bug 358903 - Filter practically unimportant resource leak warnings
14	*******************************************************************************/	15	*******************************************************************************/
15	package org.eclipse.jdt.internal.compiler.lookup;	16	package org.eclipse.jdt.internal.compiler.lookup;
16		17
Lines 1275-1281 Link Here
1275	this.environment.mayTolerateMissingType = wasToleratingMissingTypeProcessingAnnotations;	1276	this.environment.mayTolerateMissingType = wasToleratingMissingTypeProcessingAnnotations;
1276	}	1277	}
1277	}	1278	}
1278	this.typeBits \|= this.superclass.typeBits;	1279	this.typeBits \|= (this.superclass.typeBits & TypeIds.InheritableBits);
		1280	if ((this.typeBits & (TypeIds.BitAutoCloseable\|TypeIds.BitCloseable)) != 0) // avoid the side-effects of hasTypeBit()!
		1281	this.typeBits \|= applyCloseableWhitelists();
1279	return this.superclass;	1282	return this.superclass;
1280	}	1283	}
1281	// NOTE: superInterfaces of binary types are resolved when needed	1284	// NOTE: superInterfaces of binary types are resolved when needed
Lines 1298-1304 Link Here
1298	this.environment.mayTolerateMissingType = wasToleratingMissingTypeProcessingAnnotations;	1301	this.environment.mayTolerateMissingType = wasToleratingMissingTypeProcessingAnnotations;
1299	}	1302	}
1300	}	1303	}
1301	this.typeBits \|= this.superInterfaces[i].typeBits;	1304	this.typeBits \|= (this.superInterfaces[i].typeBits & TypeIds.InheritableBits);
1302	}	1305	}
1303	this.tagBits &= ~TagBits.HasUnresolvedSuperinterfaces;	1306	this.tagBits &= ~TagBits.HasUnresolvedSuperinterfaces;
1304	return this.superInterfaces;	1307	return this.superInterfaces;

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java (-55 / +12 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 10-15 Link Here
10	* Stephan Herrmann - Contributions for	10	* Stephan Herrmann - Contributions for
11	* bug 349326 - [1.7] new warning for missing try-with-resources	11	* bug 349326 - [1.7] new warning for missing try-with-resources
12	* bug 359334 - Analysis for resource leak warnings does not consider exceptions as method exit points	12	* bug 359334 - Analysis for resource leak warnings does not consider exceptions as method exit points
		13	* bug 358903 - Filter practically unimportant resource leak warnings
13	*******************************************************************************/	14	*******************************************************************************/
14	package org.eclipse.jdt.internal.compiler.lookup;	15	package org.eclipse.jdt.internal.compiler.lookup;
15		16
Lines 981-986 Link Here
981	}	982	}
982	/** When are no longer interested in this tracking variable - remove it. */	983	/** When are no longer interested in this tracking variable - remove it. */
983	public void removeTrackingVar(FakedTrackingVariable trackingVariable) {	984	public void removeTrackingVar(FakedTrackingVariable trackingVariable) {
		985	if (trackingVariable.innerTracker != null) {
		986	removeTrackingVar(trackingVariable.innerTracker);
		987	trackingVariable.innerTracker = null;
		988	}
984	if (this.trackingVariables != null)	989	if (this.trackingVariables != null)
985	if (this.trackingVariables.remove(trackingVariable))	990	if (this.trackingVariables.remove(trackingVariable))
986	return;	991	return;
Lines 1003-1012 Link Here
1003	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);	1008	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
1004	if (location != null && trackingVar.originalBinding != null && flowInfo.isDefinitelyNull(trackingVar.originalBinding))	1009	if (location != null && trackingVar.originalBinding != null && flowInfo.isDefinitelyNull(trackingVar.originalBinding))
1005	continue; // reporting against a specific location, resource is null at this flow, don't complain	1010	continue; // reporting against a specific location, resource is null at this flow, don't complain
1006	int status = getNullStatusAggressively(trackingVar.binding, flowInfo);	1011
1007	// try to improve info if a close() inside finally was observed:	1012	// compute the most specific null status for this resource,
1008	if (locationScope != null) // only check at method exit points	1013	int status = trackingVar.findMostSpecificStatus(flowInfo, this, locationScope);
1009	status = locationScope.mergeCloseStatus(status, trackingVar.binding, this);	1014
1010	if (status == FlowInfo.NULL) {	1015	if (status == FlowInfo.NULL) {
1011	// definitely unclosed: highest priority	1016	// definitely unclosed: highest priority
1012	reportResourceLeak(trackingVar, location, status);	1017	reportResourceLeak(trackingVar, location, status);
Lines 1033-1056 Link Here
1033	this.locals[i].closeTracker = null;	1038	this.locals[i].closeTracker = null;
1034	this.trackingVariables = null;	1039	this.trackingVariables = null;
1035	}	1040	}
1036	}
1037
1038	private int mergeCloseStatus(int status, LocalVariableBinding binding, BlockScope outerScope) {
1039	// get the most suitable null status representing whether resource 'binding' has been closed
1040	// start at this scope and potentially travel out until 'outerScope'
1041	// at each scope consult any recorded 'finallyInfo'.
1042	if (status != FlowInfo.NON_NULL) {
1043	if (this.finallyInfo != null) {
1044	int finallyStatus = this.finallyInfo.nullStatus(binding);
1045	if (finallyStatus == FlowInfo.NON_NULL)
1046	return finallyStatus;
1047	if (finallyStatus != FlowInfo.NULL) // neither is NON_NULL, but not both are NULL => call it POTENTIALLY_NULL
1048	status = FlowInfo.POTENTIALLY_NULL;
1049	}
1050	if (this != outerScope && this.parent instanceof BlockScope)
1051	return ((BlockScope) this.parent).mergeCloseStatus(status, binding, outerScope);
1052	}
1053	return status;
1054	}	1041	}
1055		1042
1056	private void reportResourceLeak(FakedTrackingVariable trackingVar, ASTNode location, int nullStatus) {	1043	private void reportResourceLeak(FakedTrackingVariable trackingVar, ASTNode location, int nullStatus) {
Lines 1083-1088 Link Here
1083	if (this.trackingVariables != null) {	1070	if (this.trackingVariables != null) {
1084	for (int i=0; i<this.trackingVariables.size(); i++) {	1071	for (int i=0; i<this.trackingVariables.size(); i++) {
1085	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);	1072	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
		1073	if (trackingVar.originalBinding == null)
		1074	continue;
1086	if ( thenFlowInfo.isDefinitelyNonNull(trackingVar.binding) // closed in then branch	1075	if ( thenFlowInfo.isDefinitelyNonNull(trackingVar.binding) // closed in then branch
1087	&& elseFlowInfo.isDefinitelyNull(trackingVar.originalBinding)) // null in else branch	1076	&& elseFlowInfo.isDefinitelyNull(trackingVar.originalBinding)) // null in else branch
1088	{	1077	{
Lines 1097-1133 Link Here
1097	}	1086	}
1098	if (this.parent instanceof BlockScope)	1087	if (this.parent instanceof BlockScope)
1099	((BlockScope) this.parent).correlateTrackingVarsIfElse(thenFlowInfo, elseFlowInfo);	1088	((BlockScope) this.parent).correlateTrackingVarsIfElse(thenFlowInfo, elseFlowInfo);
1100	}
1101
1102	/**
1103	* Get the null status looking even into unreachable flows
1104	* @param local
1105	* @param flowInfo
1106	* @return one of the constants FlowInfo.{NULL,POTENTIALLY_NULL,POTENTIALLY_NON_NULL,NON_NULL}.
1107	*/
1108	private int getNullStatusAggressively(LocalVariableBinding local, FlowInfo flowInfo) {
1109	int reachMode = flowInfo.reachMode();
1110	int status = 0;
1111	try {
1112	// unreachable flowInfo is too shy in reporting null-issues, temporarily forget reachability:
1113	if (reachMode != FlowInfo.REACHABLE)
1114	flowInfo.tagBits &= ~FlowInfo.UNREACHABLE;
1115	status = flowInfo.nullStatus(local);
1116	} finally {
1117	// reset
1118	flowInfo.tagBits \|= reachMode;
1119	}
1120	// at this point some combinations are not useful so flatten to a single bit:
1121	if ((status & FlowInfo.NULL) != 0) {
1122	if ((status & (FlowInfo.NON_NULL \| FlowInfo.POTENTIALLY_NON_NULL)) != 0)
1123	return FlowInfo.POTENTIALLY_NULL; // null + doubt = pot null
1124	return FlowInfo.NULL;
1125	} else if ((status & FlowInfo.NON_NULL) != 0) {
1126	if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
1127	return FlowInfo.POTENTIALLY_NULL; // non-null + doubt = pot null
1128	return FlowInfo.NON_NULL;
1129	} else if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
1130	return FlowInfo.POTENTIALLY_NULL;
1131	return status;
1132	}	1089	}
1133	}	1090	}

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java (-3 / +7 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 12-17 Link Here
12	* Bug 300576 - NPE Computing type hierarchy when compliance doesn't match libraries	12	* Bug 300576 - NPE Computing type hierarchy when compliance doesn't match libraries
13	* Bug 354536 - compiling package-info.java still depends on the order of compilation units	13	* Bug 354536 - compiling package-info.java still depends on the order of compilation units
14	* Bug 349326 - [1.7] new warning for missing try-with-resources	14	* Bug 349326 - [1.7] new warning for missing try-with-resources
		15	* Bug 358903 - Filter practically unimportant resource leak warnings
15	*******************************************************************************/	16	*******************************************************************************/
16	package org.eclipse.jdt.internal.compiler.lookup;	17	package org.eclipse.jdt.internal.compiler.lookup;
17		18
Lines 909-915 Link Here
909	} else {	910	} else {
910	// only want to reach here when no errors are reported	911	// only want to reach here when no errors are reported
911	sourceType.superclass = superclass;	912	sourceType.superclass = superclass;
912	sourceType.typeBits \|= superclass.typeBits;	913	sourceType.typeBits \|= (superclass.typeBits & TypeIds.InheritableBits);
		914	// further analysis against white lists for the unlikely case we are compiling java.io.*:
		915	if ((sourceType.typeBits & (TypeIds.BitAutoCloseable\|TypeIds.BitCloseable)) != 0)
		916	sourceType.typeBits \|= sourceType.applyCloseableWhitelists();
913	return true;	917	return true;
914	}	918	}
915	}	919	}
Lines 1025-1031 Link Here
1025	noProblems &= superInterfaceRef.resolvedType.isValidBinding();	1029	noProblems &= superInterfaceRef.resolvedType.isValidBinding();
1026	}	1030	}
1027	// only want to reach here when no errors are reported	1031	// only want to reach here when no errors are reported
1028	sourceType.typeBits \|= superInterface.typeBits;	1032	sourceType.typeBits \|= (superInterface.typeBits & TypeIds.InheritableBits);
1029	interfaceBindings[count++] = superInterface;	1033	interfaceBindings[count++] = superInterface;
1030	}	1034	}
1031	// hold onto all correctly resolved superinterfaces	1035	// hold onto all correctly resolved superinterfaces




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *     Stephan Herrmann - Contributions for
 *								bug 349326 - [1.7] new warning for missing try-with-resources
 *								bug 186342 - [compiler][null] Using annotations for null checking
 *								bug 358903 - Filter practically unimportant resource leak warnings
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;


public FieldBinding[] unResolvedFields() {
	return Binding.NO_FIELDS;
}

/*
 * If a type - known to be a Closeable - is mentioned in one of our white lists
 * answer the typeBit for the white list (BitWrapperCloseable or BitResourceFreeCloseable).
 */
protected int applyCloseableWhitelists() {
	switch (this.compoundName.length) {
		case 3:
			if (CharOperation.equals(TypeConstants.JAVA, this.compoundName[0])) {
				if (CharOperation.equals(TypeConstants.IO, this.compoundName[1])) {
					char[] simpleName = this.compoundName[2];
					int l = TypeConstants.JAVA_IO_WRAPPER_CLOSEABLES.length;
					for (int i = 0; i < l; i++) {
						if (CharOperation.equals(simpleName, TypeConstants.JAVA_IO_WRAPPER_CLOSEABLES[i]))
							return TypeIds.BitWrapperCloseable;
					}
					l = TypeConstants.JAVA_IO_RESOURCE_FREE_CLOSEABLES.length;
					for (int i = 0; i < l; i++) {
						if (CharOperation.equals(simpleName, TypeConstants.JAVA_IO_RESOURCE_FREE_CLOSEABLES[i]))
							return TypeIds.BitResourceFreeCloseable;
					}
				}
			}
			break;
	}
	int l = TypeConstants.OTHER_WRAPPER_CLOSEABLES.length;
	for (int i = 0; i < l; i++) {
		if (CharOperation.equals(this.compoundName, TypeConstants.OTHER_WRAPPER_CLOSEABLES[i]))
			return TypeIds.BitWrapperCloseable;
	}	
	return 0;
}
}

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeConstants.java (-2 / +31 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 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 - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources	10	* Stephan Herrmann - Contributions for
		11	* bug 349326 - [1.7] new warning for missing try-with-resources
		12	* bug 358903 - Filter practically unimportant resource leak warnings
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.lookup;	14	package org.eclipse.jdt.internal.compiler.lookup;
13		15
Lines 154-159 Link Here
154	};	156	};
155	char[][] JAVA_LANG_AUTOCLOSEABLE = {JAVA, LANG, "AutoCloseable".toCharArray()}; //$NON-NLS-1$	157	char[][] JAVA_LANG_AUTOCLOSEABLE = {JAVA, LANG, "AutoCloseable".toCharArray()}; //$NON-NLS-1$
156	char[] CLOSE = "close".toCharArray(); //$NON-NLS-1$	158	char[] CLOSE = "close".toCharArray(); //$NON-NLS-1$
		159	// white lists of closeables:
		160	char[][] JAVA_IO_WRAPPER_CLOSEABLES = new char[][] {
		161	"BufferedInputStream".toCharArray(), //$NON-NLS-1$
		162	"BufferedOutputStream".toCharArray(), //$NON-NLS-1$
		163	"BufferedReader".toCharArray(), //$NON-NLS-1$
		164	"BufferedWriter".toCharArray(), //$NON-NLS-1$
		165	"InputStreamReader".toCharArray(), //$NON-NLS-1$
		166	"PrintWriter".toCharArray(), //$NON-NLS-1$
		167	"LineNumberReader".toCharArray(), //$NON-NLS-1$
		168	"DataInputStream".toCharArray(), //$NON-NLS-1$
		169	"DataOutputStream".toCharArray(), //$NON-NLS-1$
		170	"ObjectInputStream".toCharArray(), //$NON-NLS-1$
		171	"ObjectOutputStream".toCharArray(), //$NON-NLS-1$
		172	"FilterInputStream".toCharArray(), //$NON-NLS-1$
		173	"FilterOutputStream".toCharArray(), //$NON-NLS-1$
		174	};
		175	char[][][] OTHER_WRAPPER_CLOSEABLES = new char[][][] { // NOTE: if this list should ever grow large we should think of smarter data structure
		176	{JAVA, UTIL, "zip".toCharArray(), "InflaterInputStream".toCharArray()}, //$NON-NLS-1$ //$NON-NLS-2$
		177	};
		178	char[][] JAVA_IO_RESOURCE_FREE_CLOSEABLES = new char[][] {
		179	"StringReader".toCharArray(), //$NON-NLS-1$
		180	"StringWriter".toCharArray(), //$NON-NLS-1$
		181	"ByteArrayInputStream".toCharArray(), //$NON-NLS-1$
		182	"ByteArrayOutputStream".toCharArray(), //$NON-NLS-1$
		183	"CharArrayReader".toCharArray(), //$NON-NLS-1$
		184	"CharArrayWriter".toCharArray(), //$NON-NLS-1$
		185	};
157		186
158	// Constraints for generic type argument inference	187	// Constraints for generic type argument inference
159	int CONSTRAINT_EQUAL = 0; // Actual = Formal	188	int CONSTRAINT_EQUAL = 0; // Actual = Formal




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *     							bug 349326 - [1.7] new warning for missing try-with-resources
 *     							bug 359362 - FUP of bug 349326: Resource leak on non-Closeable resource
 *								bug 186342 - [compiler][null] Using annotations for null checking
 *								bug 358903 - Filter practically unimportant resource leak warnings
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;


	 * @see ReferenceBinding#hasTypeBit(int)
	 */
	final int BitCloseable = 2;
	/**
	 * Bit for members of a white list:
	 * Subtypes of Closeable that wrap another resource without directly holding any OS resources. 
	 */
	final int BitWrapperCloseable = 4;
	/**
	 * Bit for members of a white list:
	 * Subtypes of Closeable that do not hold an OS resource that needs to be released.
	 */
	final int BitResourceFreeCloseable = 8;
	
	/**
	 * Set of type bits that should be inherited by any sub types.
	 */
	final int InheritableBits = BitAutoCloseable | BitCloseable;
}




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *     							bug 282152 - [1.5][compiler] Generics code rejected by Eclipse but accepted by javac
 *     							bug 349326 - [1.7] new warning for missing try-with-resources
 *     							bug 359362 - FUP of bug 349326: Resource leak on non-Closeable resource
 *								bug 358903 - Filter practically unimportant resource leak warnings
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;


			// initialize from bounds
			this.typeBits = 0;
			if (this.superclass != null && this.superclass.hasTypeBit(~TypeIds.BitUninitialized))
				this.typeBits |= (this.superclass.typeBits & TypeIds.InheritableBits);
			if (this.superInterfaces != null)
				for (int i = 0, l = this.superInterfaces.length; i < l; i++)
					if (this.superInterfaces[i].hasTypeBit(~TypeIds.BitUninitialized))
						this.typeBits |= (this.superInterfaces[i].typeBits & TypeIds.InheritableBits);
		}
		return (this.typeBits & bit) != 0;
	}




/*******************************************************************************
 * Copyright (c) 2005, 2012 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *     Stephan Herrmann - Contribution for
 *     							bug 349326 - [1.7] new warning for missing try-with-resources
 *     							bug 359362 - FUP of bug 349326: Resource leak on non-Closeable resource
 *								bug 358903 - Filter practically unimportant resource leak warnings
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;


			// initialize from upper bounds
			this.typeBits = 0;
			if (this.superclass != null && this.superclass.hasTypeBit(~TypeIds.BitUninitialized))
				this.typeBits |= (this.superclass.typeBits & TypeIds.InheritableBits);
			if (this.superInterfaces != null)
				for (int i = 0, l = this.superInterfaces.length; i < l; i++)
					if (this.superInterfaces[i].hasTypeBit(~TypeIds.BitUninitialized))
						this.typeBits |= (this.superInterfaces[i].typeBits & TypeIds.InheritableBits);
		}
		return (this.typeBits & bit) != 0;
	}

Return to bug 358903