Attachment #201450 for bug #349326

Lines 116-122 Link Here

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

Lines 10-15 Link Here

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




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


	flowInfo = ((Reference) this.lhs)
		.analyseAssignment(currentScope, flowContext, flowInfo, this, false)
		.unconditionalInits();
	if (local != null) {
		LocalVariableBinding trackerBinding = null;
		if (local.closeTracker != null) {
			// Assigning to a variable already holding an AutoCloseable, has it been closed before?
			trackerBinding = local.closeTracker.binding;
			if (!flowInfo.isDefinitelyNull(local)) { // only if previous value may be non-null
				if (flowInfo.isDefinitelyNull(trackerBinding)) 
					currentScope.problemReporter().unclosedCloseable(local.closeTracker, this);
				else if (flowInfo.isPotentiallyNull(trackerBinding)) 
					currentScope.problemReporter().potentiallyUnclosedCloseable(local.closeTracker, this);
			}
		}
		if (FakedTrackingVariable.isAutoCloseable(this.expression.resolvedType)) {
			if (local.closeTracker != null && local.closeTracker.isInsideTryWithResources) { 
				// re-assigning resource of try-with-resources is a different error
			} else {
				// new value is AutoCloseable, start tracking, possibly re-using existing tracker var:
				if (trackerBinding == null) {
					local.closeTracker = new FakedTrackingVariable(local, this);
					trackerBinding = local.closeTracker.binding;
				}
				flowInfo.markAsDefinitelyNull(trackerBinding);
// TODO(stephan): this might be useful, but I could not find a test case for it: 
//				if (flowContext.initsOnFinally != null)
//					flowContext.initsOnFinally.markAsDefinitelyNonNull(trackerBinding);
			}
		}
	}
	int nullStatus = this.expression.nullStatus(flowInfo);
	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
		if (nullStatus == FlowInfo.NULL) {

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Block.java (-1 / +4 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	12	package org.eclipse.jdt.internal.compiler.ast;
12		13
Lines 36-41 Link Here
36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);	37	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);
37	}	38	}
38	}	39	}
		40	if (this.explicitDeclarations > 0) // if block has its own scope analyze tracking vars now:
		41	this.scope.checkUnclosedCloseables(flowInfo, flowContext, null);
39	return flowInfo;	42	return flowInfo;
40	}	43	}
41	/**	44	/**




/*******************************************************************************
 * Copyright (c) 2011 GK Software AG and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Stephan Herrmann - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;

import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

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

	/** If resource is already managed by try-with-resources don't complain. */
	public boolean isInsideTryWithResources;

	/** 
	 * If close() is invoked from a nested method (inside a local type) 
	 * report remaining problems only as potential.
	 */
	public boolean closedInNestedMethod; 

	/** If a problem has already been reported don't complain again. */
	public boolean hasReportedProblem;

	MethodScope methodScope; // designates the method declaring this variable
	
	public LocalVariableBinding originalBinding; // the real local being tracked

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

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

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

	public static FlowInfo markPotentialClosing(Expression expression, FlowInfo flowInfo) {
		FakedTrackingVariable trackVar = getCloseTrackingVariable(expression);
		if (trackVar != null) {
			// insert info that the tracked resource *may* be closed (by the target method, i.e.)
			FlowInfo infoResourceIsClosed = flowInfo.copy();
			infoResourceIsClosed.markAsDefinitelyNonNull(trackVar.binding);
			return FlowInfo.conditional(flowInfo, infoResourceIsClosed);
		}
		return flowInfo;
	}

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

Lines 7-13 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/IfStatement.java (-1 / +5 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	10	* Stephan Herrmann - Contributions for
		11	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
Lines 124-129 Link Here
124	}	126	}
125	elseFlowInfo = this.elseStatement.analyseCode(currentScope, flowContext, elseFlowInfo);	127	elseFlowInfo = this.elseStatement.analyseCode(currentScope, flowContext, elseFlowInfo);
126	}	128	}
		129	// process AutoCloseable resources closed in only one branch:
		130	currentScope.correlateTrackingVarsIfElse(thenFlowInfo, elseFlowInfo);
127	// merge THEN & ELSE initializations	131	// merge THEN & ELSE initializations
128	FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranchesIfElse(	132	FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranchesIfElse(
129	thenFlowInfo,	133	thenFlowInfo,

Lines 11-16 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (+8 lines)
11	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	11	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
12	* bug 292478 - Report potentially null across variable assignment	12	* bug 292478 - Report potentially null across variable assignment
13	* bug 335093 - [compiler][null] minimal hook for future null annotation support	13	* bug 335093 - [compiler][null] minimal hook for future null annotation support
		14	* bug 349326 - [1.7] new warning for missing try-with-resources
14	*******************************************************************************/	15	*******************************************************************************/
15	package org.eclipse.jdt.internal.compiler.ast;	16	package org.eclipse.jdt.internal.compiler.ast;
16		17
Lines 76-81 Link Here
76	this.initialization	77	this.initialization
77	.analyseCode(currentScope, flowContext, flowInfo)	78	.analyseCode(currentScope, flowContext, flowInfo)
78	.unconditionalInits();	79	.unconditionalInits();
		80	if (FakedTrackingVariable.isAutoCloseable(this.initialization.resolvedType)) {
		81	this.binding.closeTracker = new FakedTrackingVariable(this.binding, this);
		82	flowInfo.markAsDefinitelyNull(this.binding.closeTracker.binding);
		83	// TODO(stephan): this might be useful, but I could not find a test case for it:
		84	// if (flowContext.initsOnFinally != null)
		85	// flowContext.initsOnFinally.markAsDefinitelyNonNull(this.binding.closeTracker.binding);
		86	}
79	int nullStatus = this.initialization.nullStatus(flowInfo);	87	int nullStatus = this.initialization.nullStatus(flowInfo);
80	if (!flowInfo.isDefinitelyAssigned(this.binding)){// for local variable debug attributes	88	if (!flowInfo.isDefinitelyAssigned(this.binding)){// for local variable debug attributes
81	this.bits \|= FirstAssignmentToLocal;	89	this.bits \|= FirstAssignmentToLocal;

Lines 8-14 Link Here

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

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MethodDeclaration.java (+2 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	12	package org.eclipse.jdt.internal.compiler.ast;
12		13
Lines 134-139 Link Here
134	}	135	}
135		136
136	}	137	}
		138	this.scope.checkUnclosedCloseables(flowInfo, methodContext, null/don't report against a specific location/);
137	} catch (AbortMethod e) {	139	} catch (AbortMethod e) {
138	this.ignoreFurtherInvestigation = true;	140	this.ignoreFurtherInvestigation = true;
139	}	141	}

Lines 7-13 Link Here

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

Lines 7-13 Link Here

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

Lines 7-16 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TryStatement.java (-5 / +27 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 332637 - Dead Code detection removing code that isn't dead	10	* Stephan Herrmann - Contributions for
		11	* bug 332637 - Dead Code detection removing code that isn't dead
		12	* bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
		16	import java.util.ArrayList;
		17	import java.util.List;
		18
14	import org.eclipse.jdt.core.compiler.CharOperation;	19	import org.eclipse.jdt.core.compiler.CharOperation;
15	import org.eclipse.jdt.internal.compiler.ASTVisitor;	20	import org.eclipse.jdt.internal.compiler.ASTVisitor;
16	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	21	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
Lines 116-123 Link Here
116		121
117	for (int i = 0, max = this.resources.length; i < max; i++) {	122	for (int i = 0, max = this.resources.length; i < max; i++) {
118	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());	123	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());
119	this.resources[i].binding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.	124	LocalVariableBinding resourceBinding = this.resources[i].binding;
120	TypeBinding type = this.resources[i].binding.type;	125	resourceBinding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.
		126	if (resourceBinding.closeTracker != null) {
		127	resourceBinding.closeTracker.isInsideTryWithResources = true;
		128	flowInfo.markAsDefinitelyNonNull(resourceBinding.closeTracker.binding); // all is well
		129	}
		130	TypeBinding type = resourceBinding.type;
121	if (type != null && type.isValidBinding()) {	131	if (type != null && type.isValidBinding()) {
122	ReferenceBinding binding = (ReferenceBinding) type;	132	ReferenceBinding binding = (ReferenceBinding) type;
123	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter	133	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter
Lines 241-248 Link Here
241		251
242	for (int i = 0, max = this.resources.length; i < max; i++) {	252	for (int i = 0, max = this.resources.length; i < max; i++) {
243	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());	253	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());
244	this.resources[i].binding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.	254	LocalVariableBinding resourceBinding = this.resources[i].binding;
245	TypeBinding type = this.resources[i].binding.type;	255	resourceBinding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.
		256	if (resourceBinding.closeTracker != null) {
		257	resourceBinding.closeTracker.isInsideTryWithResources = true;
		258	flowInfo.markAsDefinitelyNonNull(resourceBinding.closeTracker.binding); // all is well
		259	}
		260	TypeBinding type = resourceBinding.type;
246	if (type != null && type.isValidBinding()) {	261	if (type != null && type.isValidBinding()) {
247	ReferenceBinding binding = (ReferenceBinding) type;	262	ReferenceBinding binding = (ReferenceBinding) type;
248	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter	263	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter
Lines 263-268 Link Here
263	this.bits \|= ASTNode.IsTryBlockExiting;	278	this.bits \|= ASTNode.IsTryBlockExiting;
264	}	279	}
265		280
		281	// superimpose status for tracking variables:
		282	// don't complain on initsOnException if finally has a better state.
		283	List trackVars = new ArrayList();
		284	currentScope.getTrackVars(trackVars, subInfo);
		285	if (trackVars.size() > 0)
		286	flowContext.improveNullInfoForExceptionExits(trackVars, subInfo);
		287
266	// check unreachable catch blocks	288	// check unreachable catch blocks
267	handlingContext.complainIfUnusedExceptionHandlers(this.scope, this);	289	handlingContext.complainIfUnusedExceptionHandlers(this.scope, this);
268		290




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

import java.util.ArrayList;
import java.util.List;

import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.FakedTrackingVariable;
import org.eclipse.jdt.internal.compiler.ast.SubRoutineStatement;
import org.eclipse.jdt.internal.compiler.ast.TryStatement;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.ast.UnionTypeReference;
import org.eclipse.jdt.internal.compiler.codegen.ObjectCache;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.CatchParameterBinding;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;

	return node;
}

public int getNullStatusAfter(LocalVariableBinding local, FlowInfo flowInfo) {
	// collect info from normal flow and exceptional flows:
	int status = flowInfo.nullStatus(local);
	if (this.initsOnExceptions != null)
		for (int i = 0; i < this.initsOnExceptions.length; i++)
			status |= (this.initsOnExceptions[i].nullStatus(local) & (FlowInfo.NULL|FlowInfo.POTENTIALLY_NULL));
	return status;
}

public String individualToString() {
	StringBuffer buffer = new StringBuffer("Exception flow context"); //$NON-NLS-1$

	}
	return null;
}
/**
 * {@inheritDoc}
 */
public void improveNullInfoForExceptionExits(List moreTrackVars, FlowInfo otherInfo) {
	if (this.initsOnExceptions == null) return;
	for (int j = 0; j < this.initsOnExceptions.length; j++) {
		UnconditionalFlowInfo copy = null;
		for (int i = 0; i < moreTrackVars.size(); i++) {
			LocalVariableBinding trackVar = ((FakedTrackingVariable) moreTrackVars.get(i)).binding;
			int status = otherInfo.nullStatus(trackVar);
			if ((status & FlowInfo.NULL) == 0) {
				if ((status & FlowInfo.NON_NULL) != 0) {
					this.initsOnExceptions[j].markAsDefinitelyNonNull(trackVar);
				} else if ((status & FlowInfo.POTENTIALLY_NON_NULL) != 0) {
					if (this.initsOnExceptions[j].isDefinitelyNull(trackVar)) {
						// cannot directly set to pot.nn, need to construct and merge infos for this task:
						if (copy == null)
							copy = this.initsOnExceptions[j].unconditionalCopy();
						copy.markAsDefinitelyNonNull(trackVar);
					}
				}
			}
		}
		if (copy != null)
			this.initsOnExceptions[j] = this.initsOnExceptions[j].mergedWith(copy);
	}
}
}

Lines 7-19 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/FlowContext.java (-1 / +49 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.flow;	12	package org.eclipse.jdt.internal.compiler.flow;
12		13
13	import java.util.ArrayList;	14	import java.util.ArrayList;
		15	import java.util.List;
		16
14	import org.eclipse.jdt.core.compiler.CharOperation;	17	import org.eclipse.jdt.core.compiler.CharOperation;
15	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
16	import org.eclipse.jdt.internal.compiler.ast.ASTNode;	18	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
		19	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
17	import org.eclipse.jdt.internal.compiler.ast.Expression;	20	import org.eclipse.jdt.internal.compiler.ast.Expression;
18	import org.eclipse.jdt.internal.compiler.ast.LabeledStatement;	21	import org.eclipse.jdt.internal.compiler.ast.LabeledStatement;
19	import org.eclipse.jdt.internal.compiler.ast.Reference;	22	import org.eclipse.jdt.internal.compiler.ast.Reference;
Lines 391-396 Link Here
391	return null;	394	return null;
392	}	395	}
393		396
		397	/**
		398	* Answer the combined null status that local will have after this flow context.
		399	* Subclasses will respect break and exception exits.
		400	*/
		401	public int getNullStatusAfter(LocalVariableBinding local, FlowInfo flowInfo) {
		402	return flowInfo.nullStatus(local);
		403	}
		404
394	/*	405	/*
395	* lookup through break labels	406	* lookup through break labels
396	*/	407	*/
Lines 732-735 Link Here
732	buffer.append(individualToString()).append('\n');	743	buffer.append(individualToString()).append('\n');
733	return buffer.toString();	744	return buffer.toString();
734	}	745	}
		746	/**
		747	* For all tracking variables in the given list improve the null info in initsOnException (if existent)
		748	* with information from the given otherInfo.
		749	*/
		750	public void improveNullInfoForExceptionExits(List moreTrackVars, FlowInfo otherInfo) {
		751	// nothing here, overridden in ExceptionHandlingFlowContext
		752	}
		753
		754	/**
		755	* Get the null status that local will have after the current point as indicated by flowInfo and flowContext
		756	* @param local
		757	* @param flowInfo
		758	* @param flowContext may be null
		759	* @return a bitset from the constants FlowInfo.{NULL,POTENTIALLY_NULL,POTENTIALLY_NON_NULL,NON_NULL}.
		760	*/
		761	public static int getNullStatusAfter(LocalVariableBinding local, FlowInfo flowInfo, FlowContext flowContext) {
		762	int status = (flowContext != null)
		763	? flowContext.getNullStatusAfter(local, flowInfo)
		764	: flowInfo.nullStatus(local);
		765	// at this point some combinations are not useful so flatten to a single bit:
		766	return mergeNullStatus(status);
		767	}
		768
		769	/* Merge the bits NULL, NON_NULL, POTENTIALLY_NULL, POTENTIALLY_NON_NULL to a one-bit answer. */
		770	private static int mergeNullStatus(int status) {
		771	if ((status & FlowInfo.NULL) != 0) {
		772	if ((status & (FlowInfo.NON_NULL \| FlowInfo.POTENTIALLY_NON_NULL)) != 0)
		773	return FlowInfo.POTENTIALLY_NULL; // null + doubt = pot null
		774	return FlowInfo.NULL;
		775	} else if ((status & FlowInfo.NON_NULL) != 0) {
		776	if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
		777	return FlowInfo.POTENTIALLY_NULL; // non-null + doubt = pot null
		778	return FlowInfo.NON_NULL;
		779	} else if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
		780	return FlowInfo.POTENTIALLY_NULL;
		781	return status;
		782	}
735	}	783	}




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

import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.codegen.BranchLabel;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;

/**
 * Reflects the context of code analysis, keeping track of enclosing

	return this.breakLabel;
}

public int getNullStatusAfter(LocalVariableBinding local, FlowInfo flowInfo) {
	// collect info from normal flow and breaks flows:
	int status = flowInfo.nullStatus(local);
	if (this.initsOnBreak != null)
		status |= this.initsOnBreak.nullStatus(local);
	return status;
}

public String individualToString() {
	StringBuffer buffer = new StringBuffer("Switch flow context"); //$NON-NLS-1$
	buffer.append("[initsOnBreak -").append(this.initsOnBreak.toString()).append(']'); //$NON-NLS-1$




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


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

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

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

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

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

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

Lines 8-15 Link Here

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




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

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

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

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

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

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

Lines 7-12 Link Here

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

Lines 7-19 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java (+101 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
		14	import java.util.ArrayList;
		15	import java.util.List;
		16
13	import org.eclipse.jdt.core.compiler.CharOperation;	17	import org.eclipse.jdt.core.compiler.CharOperation;
14	import org.eclipse.jdt.internal.compiler.ast.*;	18	import org.eclipse.jdt.internal.compiler.ast.*;
15	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	19	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;	20	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
		21	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
		22	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
17	import org.eclipse.jdt.internal.compiler.impl.Constant;	23	import org.eclipse.jdt.internal.compiler.impl.Constant;
18	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;	24	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
19		25
Lines 957-960 Link Here
957	}	963	}
958	}	964	}
959	}	965	}
		966
		967	private List trackingVariables; // can be null if no resources are tracked
		968	/**
		969	* Register a tracking variable and compute its id.
		970	*/
		971	public int registerTrackingVariable(FakedTrackingVariable fakedTrackingVariable) {
		972	if (this.trackingVariables == null)
		973	this.trackingVariables = new ArrayList();
		974	this.trackingVariables.add(fakedTrackingVariable);
		975	MethodScope outerMethodScope = outerMostMethodScope();
		976	return outerMethodScope.analysisIndex + (++outerMethodScope.trackVarCount);
		977
		978	}
		979	/**
		980	* At the end of a block check the closing-status of all tracked closeables that are declared in this block.
		981	*/
		982	public void checkUnclosedCloseables(FlowInfo flowInfo, FlowContext flowContext, ASTNode location) {
		983	if (this.trackingVariables == null) return;
		984	for (int i=0; i<this.trackingVariables.size(); i++) {
		985	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
		986	if (trackingVar.hasReportedProblem)
		987	continue;
		988	if (trackingVar.originalBinding != null && flowInfo.isDefinitelyNull(trackingVar.originalBinding))
		989	continue; // resource is null at this flow, don't complain
		990	int status = FlowContext.getNullStatusAfter(trackingVar.binding, flowInfo, flowContext);
		991	if (status == FlowInfo.NULL) {
		992	if (trackingVar.closedInNestedMethod)
		993	problemReporter().potentiallyUnclosedCloseable(trackingVar, location);
		994	else
		995	problemReporter().unclosedCloseable(trackingVar, location);
		996	} else if (status == FlowInfo.POTENTIALLY_NULL) {
		997	problemReporter().potentiallyUnclosedCloseable(trackingVar, location);
		998	} else if (status == FlowInfo.NON_NULL) {
		999	if (environment().globalOptions.complianceLevel >= ClassFileConstants.JDK1_7
		1000	&& !trackingVar.isInsideTryWithResources)
		1001	problemReporter().explicitlyClosedAutoCloseable(trackingVar);
		1002	}
		1003	}
		1004	}
		1005	/**
		1006	* Find all tracking variables in scope that have relevant null status.
		1007	* @param moreTrackVars list for collecting all found tracking variables
		1008	* @param flowInfo use to check if tracking variable has interesting status
		1009	*/
		1010	public void getTrackVars(List moreTrackVars, FlowInfo flowInfo) {
		1011	if (this.trackingVariables != null) {
		1012	for (int i=0; i<this.trackingVariables.size(); i++) {
		1013	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
		1014	if (flowInfo.nullStatus(trackingVar.binding) == FlowInfo.UNKNOWN)
		1015	continue;
		1016	moreTrackVars.add(trackingVar);
		1017	}
		1018	}
		1019	if (this.parent instanceof BlockScope)
		1020	((BlockScope) this.parent).getTrackVars(moreTrackVars, flowInfo);
		1021	}
		1022
		1023	/**
		1024	* If one branch of an if-else closes any AutoCloseable resource, and if the same
		1025	* resource is known to be null on the other branch mark it as closed, too,
		1026	* so that merging both branches indicates that the resource is always closed.
		1027	* Example:
		1028	* FileReader fr1 = null;
		1029	* try {\n" +
1030	* fr1 = new FileReader(someFile);" +
1031	* fr1.read(buf);\n" +
1032	* } finally {\n" +
1033	* if (fr1 != null)\n" +
1034	* try {\n" +
1035	* fr1.close();\n" +
1036	* } catch (IOException e) {
1037	* // do nothing
1038	* }
1039	* // after this if statement fr1 is definitely not leaked
1040	* }
1041	*/
1042	public void correlateTrackingVarsIfElse(FlowInfo thenFlowInfo, FlowInfo elseFlowInfo) {
1043	if (this.trackingVariables != null) {
1044	for (int i=0; i<this.trackingVariables.size(); i++) {
1045	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
1046	if ( thenFlowInfo.isDefinitelyNonNull(trackingVar.binding) // closed in then branch
1047	&& elseFlowInfo.isDefinitelyNull(trackingVar.originalBinding)) // null in else branch
1048	{
1049	elseFlowInfo.markAsDefinitelyNonNull(trackingVar.binding); // -> always closed
1050	}
1051	else if ( elseFlowInfo.isDefinitelyNonNull(trackingVar.binding) // closed in else branch
1052	&& thenFlowInfo.isDefinitelyNull(trackingVar.originalBinding)) // null in then branch
1053	{
1054	thenFlowInfo.markAsDefinitelyNonNull(trackingVar.binding); // -> always closed
1055	}
1056	}
1057	}
1058	if (this.parent instanceof BlockScope)
1059	((BlockScope) this.parent).correlateTrackingVarsIfElse(thenFlowInfo, elseFlowInfo);
1060	}
960	}	1061	}




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


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

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

Lines 7-12 Link Here

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

Lines 7-12 Link Here

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

Lines 7-12 Link Here

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

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java (-2 / +11 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 41-47 Link Here
41		42
42	private SimpleLookupTable compatibleCache;	43	private SimpleLookupTable compatibleCache;
43		44
44	public static final ReferenceBinding LUB_GENERIC = new ReferenceBinding() { /* used for lub computation */};	45	int typeBits; // additional bits characterizing this type
		46
		47	public static final ReferenceBinding LUB_GENERIC = new ReferenceBinding() { /* used for lub computation */
		48	public boolean hasTypeBit(int bit) { return false; }
		49	};
45		50
46	private static final Comparator FIELD_COMPARATOR = new Comparator() {	51	private static final Comparator FIELD_COMPARATOR = new Comparator() {
47	public int compare(Object o1, Object o2) {	52	public int compare(Object o1, Object o2) {
Lines 424-431 Link Here
424	case 'A' :	429	case 'A' :
425	switch(typeName.length) {	430	switch(typeName.length) {
426	case 13 :	431	case 13 :
427	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2]))	432	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2])) {
428	this.id = TypeIds.T_JavaLangAutoCloseable;	433	this.id = TypeIds.T_JavaLangAutoCloseable;
		434	this.typeBits \|= TypeIds.BitAutoCloseable;
		435	}
429	return;	436	return;
430	case 14:	437	case 14:
431	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))	438	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))
Lines 923-928 Link Here
923	public final boolean hasRestrictedAccess() {	930	public final boolean hasRestrictedAccess() {
924	return (this.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0;	931	return (this.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0;
925	}	932	}
		933	/** Answer an additional bit characterizing this type, like {@link TypeIds#BitAutoCloseable}. */
		934	abstract public boolean hasTypeBit(int bit);
926		935
927	/** Answer true if the receiver implements anInterface or is identical to anInterface.	936	/** Answer true if the receiver implements anInterface or is identical to anInterface.
928	* If searchHierarchy is true, then also search the receiver's superclasses.	937	* If searchHierarchy is true, then also search the receiver's superclasses.

Lines 7-13 Link Here

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

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeConstants.java (+2 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 150-155 Link Here
150	"MethodHandle$PolymorphicSignature".toCharArray() //$NON-NLS-1$	151	"MethodHandle$PolymorphicSignature".toCharArray() //$NON-NLS-1$
151	};	152	};
152	char[][] JAVA_LANG_AUTOCLOSEABLE = {JAVA, LANG, "AutoCloseable".toCharArray()}; //$NON-NLS-1$	153	char[][] JAVA_LANG_AUTOCLOSEABLE = {JAVA, LANG, "AutoCloseable".toCharArray()}; //$NON-NLS-1$
		154	char[] CLOSE = "close".toCharArray(); //$NON-NLS-1$
153		155
154	// Constraints for generic type argument inference	156	// Constraints for generic type argument inference
155	int CONSTRAINT_EQUAL = 0; // Actual = Formal	157	int CONSTRAINT_EQUAL = 0; // Actual = Formal

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeIds.java (+7 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 177-180 Link Here
177	final int Object2boolean = T_JavaLangObject + (T_boolean << 4);	178	final int Object2boolean = T_JavaLangObject + (T_boolean << 4);
178	final int BOXING = 0x200;	179	final int BOXING = 0x200;
179	final int UNBOXING = 0x400;	180	final int UNBOXING = 0x400;
		181
		182	/**
		183	* Marks all sub-types of java.lang.AutoCloseable.
		184	* @see ReferenceBinding#hasTypeBit(int)
		185	*/
		186	final int BitAutoCloseable = 1;
180	}	187	}

Lines 1-5 Link Here

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

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/UnresolvedReferenceBinding.java (-1 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 41-46 Link Here
41	public String debugName() {	42	public String debugName() {
42	return toString();	43	return toString();
43	}	44	}
		45	public boolean hasTypeBit(int bit) {
		46	// shouldn't happen since we are not called before analyseCode(), but play safe:
		47	return false;
		48	}
44	ReferenceBinding resolve(LookupEnvironment environment, boolean convertGenericToRawType) {	49	ReferenceBinding resolve(LookupEnvironment environment, boolean convertGenericToRawType) {
45	ReferenceBinding targetType = this.resolvedType;	50	ReferenceBinding targetType = this.resolvedType;
46	if (targetType == null) {	51	if (targetType == null) {

Lines 1-5 Link Here

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




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


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

			
		case IProblem.MethodCanBePotentiallyStatic:
			return CompilerOptions.MethodCanBePotentiallyStatic;

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

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

			case CompilerOptions.MaskedCatchBlock :

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

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

Lines 8-14 Link Here

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

Lines 83-88 Link Here

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




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

import java.util.Map;

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

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

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

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

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

		"Object.Integer cannot be resolved to a type\n" + 
		"----------\n");
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable without ever closing it.
public void test055() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
// not invoking any methods on FileReader, try to avoid necessary call to superclass() in the compiler
//			"        char[] in = new char[50];\n" +
//			"        fileReader.read(in);\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Leaking resource 'fileReader': is never closed\n" +
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable and closes it but exception may occur earlier.
public void test055a() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"		 fileReader.close();\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        try {\n" +
			"            new X().foo();\n" +
			"        } catch (IOException ioex) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Potentially leaking resource 'fileReader': is not closed on all paths\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable and closes it properly in a finally block
public void test055b() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        try {\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"        } finally {\n" +
			"		     fileReader.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        try {\n" +
			"            new X().foo();\n" +
			"        } catch (IOException ioex) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable properly within try-with-resources.
public void test055c() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        try (FileReader fileReader = new FileReader(file)) {\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"		 }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        try {\n" +
			"            new X().foo();\n" +
			"        } catch (IOException ioex) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses two AutoCloseables (testing independent analysis)
// - one closeable may be unclosed at a conditional return
// - the other is only conditionally closed
public void test055d() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean flag1, boolean flag2) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        char[] in = new char[50];\n" +
			"        FileReader fileReader1 = new FileReader(file);\n" +
			"        fileReader1.read(in);\n" +
			"        FileReader fileReader2 = new FileReader(file);\n" +
			"        fileReader2.read(in);\n" +
			"        if (flag1) {\n" +
			"            fileReader2.close();\n" +
			"            return;\n" +
			"        } else if (flag2) {\n" +
			"            fileReader2.close();\n" +
			"        }\n" +
			"        fileReader1.close();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(false, true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 10)\n" + 
		"	FileReader fileReader2 = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^^\n" + 
		"Potentially leaking resource 'fileReader2': is not closed on all paths\n" +
		"----------\n" + 
		"2. ERROR in X.java (at line 14)\n" + 
		"	return;\n" + 
		"	^^^^^^^\n" + 
		"Leaking resource \'fileReader1\': is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
//Bug 349326 - [1.7] new warning for missing try-with-resources
//a method uses two AutoCloseables (testing independent analysis)
//- one closeable may be unclosed at a conditional return
//- the other is only conditionally closed
public void test055d_suppress() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	options.put(CompilerOptions.OPTION_SuppressOptionalErrors, CompilerOptions.ENABLED);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean flag1, boolean flag2) throws IOException {\n" +
			"        @SuppressWarnings(\"resource\") File file = new File(\"somefile\"); // unnecessary suppress\n" +
			"        char[] in = new char[50];\n" +
			"        FileReader fileReader1 = new FileReader(file);\n" +
			"        fileReader1.read(in);\n" +
			"        @SuppressWarnings(\"resource\") FileReader fileReader2 = new FileReader(file); // useful suppress\n" +
			"        fileReader2.read(in);\n" +
			"        if (flag1) {\n" +
			"            fileReader2.close();\n" +
			"            return; // not suppressed\n" +
			"        } else if (flag2) {\n" +
			"            fileReader2.close();\n" +
			"        }\n" +
			"        fileReader1.close();\n" +
			"    }\n" +
			"    @SuppressWarnings(\"resource\") // useful suppress\n" +
			"    void bar() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(false, true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 6)\n" + 
		"	@SuppressWarnings(\"resource\") File file = new File(\"somefile\"); // unnecessary suppress\n" + 
		"	                  ^^^^^^^^^^\n" + 
		"Unnecessary @SuppressWarnings(\"resource\")\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 14)\n" + 
		"	return; // not suppressed\n" + 
		"	^^^^^^^\n" + 
		"Leaking resource \'fileReader1\': is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// one method returns an AutoCleasble, a second method uses this object without ever closing it.
public void test055e() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    FileReader getReader(String filename) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        return fileReader;\n" + 		// don't complain here, pass responsibility to caller
			"    }\n" +
			"    void foo() throws IOException {\n" +
			"        FileReader reader = getReader(\"somefile\");\n" +
			"        char[] in = new char[50];\n" +
			"        reader.read(in);\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 11)\n" + 
		"	FileReader reader = getReader(\"somefile\");\n" + 
		"	           ^^^^^^\n" + 
		"Leaking resource 'reader': is never closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method explicitly closes its AutoCloseable rather than using t-w-r
public void test055f() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	options.put(CompilerOptions.OPTION_ReportExplicitlyClosedAutoCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = null;\n" +
			"        try {\n" +
			"            fileReader = new FileReader(file);\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"        } finally {\n" +
			"            fileReader.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = null;\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Resource \'fileReader\' should be managed by try-with-resource\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// an AutoCloseable local is re-assigned
public void test055g() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"        fileReader = new FileReader(file);\n" +
			"        fileReader.read(in);\n" +
			"        fileReader.close();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	fileReader = new FileReader(file);\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Leaking resource \'fileReader\': is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// two AutoCloseables at different nesting levels (anonymous local type)
public void test055h() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        final File file = new File(\"somefile\");\n" +
			"        final FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"        new Runnable() {\n public void run() {\n" +
			"            try {\n" +
			"                fileReader.close();\n" +
			"                FileReader localReader = new FileReader(file);\n" +
			"            } catch (IOException ex) { /* nop */ }\n" +
			"        }}.run();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 7)\n" + 
		"	final FileReader fileReader = new FileReader(file);\n" + 
		"	                 ^^^^^^^^^^\n" + 
		"Potentially leaking resource 'fileReader': is not closed on all paths\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 14)\n" + 
		"	FileReader localReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^^\n" + 
		"Leaking resource 'localReader': is never closed\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// three AutoCloseables in different blocks of the same method
public void test055i() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean f1, boolean f2) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        if (f1) {\n" +
			"            FileReader fileReader = new FileReader(file); // err: not closed\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"            while (true) {\n" +
			"                 FileReader loopReader = new FileReader(file); // don't warn, properly closed\n" +
			"                 loopReader.close();" +
			"                 break;\n" +
			"            }\n" +
			"        } else {\n" +
			"            FileReader fileReader = new FileReader(file); // warn: not closed on all paths\n" +
			"            if (f2)\n" +
			"                fileReader.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(true, true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	FileReader fileReader = new FileReader(file); // err: not closed\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Leaking resource 'fileReader': is never closed\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 16)\n" + 
		"	FileReader fileReader = new FileReader(file); // warn: not closed on all paths\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Potentially leaking resource 'fileReader': is not closed on all paths\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable without closing it locally but passing as arg to another method
public void test055j() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        read(fileReader);\n" +
			"    }\n" +
			"    void read(FileReader reader) { }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Potentially leaking resource 'fileReader': is not closed on all paths\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// many locals, some are AutoCloseable.
// Unfortunately analysis cannot respect how exception exits may affect ra3 and rb3,
// doing so would create false positives.
public void test055k() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	options.put(CompilerOptions.OPTION_ReportExplicitlyClosedAutoCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        int i01, i02, i03, i04, i05, i06, i07, i08, i09,\n" +
			"            i11, i12, i13, i14, i15, i16, i17, i18, i19,\n" +
			"            i21, i22, i23, i24, i25, i26, i27, i28, i29,\n" +
			"            i31, i32, i33, i34, i35, i36, i37, i38, i39,\n" +
			"            i41, i42, i43, i44, i45, i46, i47, i48, i49;\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader ra1 = null, ra2 = null;\n" +
			"        try {\n" +
			"            ra1 = new FileReader(file);\n" +
			"            ra2 = new FileReader(file);\n" +
			"            FileReader ra3 = new FileReader(file);\n" +
			"            char[] in = new char[50];\n" +
			"            ra1.read(in);\n" +
			"            ra2.read(in);\n" +
			"            ra3.close();\n" +
			"        } finally {\n" +
			"            ra1.close();\n" +
			"        }\n" +
			"        int i51, i52, i53, i54, i55, i56, i57, i58, i59, i60;\n" + // beyond this point locals are analyzed using extraBits
			"        FileReader rb1 = null, rb2 = null;\n" +
			"        try {\n" +
			"            rb1 = new FileReader(file);\n" +
			"            rb2 = new FileReader(file);\n" +
			"            FileReader rb3 = new FileReader(file);\n" +
			"            char[] in = new char[50];\n" +
			"            rb1.read(in);\n" +
			"            rb2.read(in);\n" +
			"            rb3.close();\n" +
			"        } finally {\n" +
			"            rb1.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 12)\n" + 
		"	FileReader ra1 = null, ra2 = null;\n" + 
		"	           ^^^\n" + 
		"Resource \'ra1\' should be managed by try-with-resource\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 15)\n" + 
		"	ra2 = new FileReader(file);\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Leaking resource 'ra2': is never closed\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 16)\n" + 
		"	FileReader ra3 = new FileReader(file);\n" + 
		"	           ^^^\n" + 
		"Resource \'ra3\' should be managed by try-with-resource\n" +
		"----------\n" + 
		"4. ERROR in X.java (at line 25)\n" + 
		"	FileReader rb1 = null, rb2 = null;\n" + 
		"	           ^^^\n" + 
		"Resource \'rb1\' should be managed by try-with-resource\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 28)\n" + 
		"	rb2 = new FileReader(file);\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Leaking resource 'rb2': is never closed\n" + 
		"----------\n" + 
		"6. ERROR in X.java (at line 29)\n" + 
		"	FileReader rb3 = new FileReader(file);\n" + 
		"	           ^^^\n" + 
		"Resource \'rb3\' should be managed by try-with-resource\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// various non-problems
public void test055l() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportExplicitlyClosedAutoCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    X(FileReader r0) {}\n" + // don't complain against argument
			"    FileReader getReader() { return null; }\n" +
			"    void foo(FileReader r1) throws IOException {\n" +
			"        FileReader fileReader = getReader();\n" +
			"        if (fileReader == null)\n" +
			"            return;\n" + // don't complain, resource is actually null
			"        FileReader r3 = getReader();\n" +
			"        if (r3 == null)\n" +
			"            r3 = new FileReader(new File(\"absent\"));\n" + // don't complain, previous resource is actually null
			"        try {\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"            r1.read(in);\n" +
			"        } finally {\n" +
			"            fileReader.close();\n" +
			"            r3.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        FileReader r2 = new FileReader(new File(\"inexist\")); // only potential problem: ctor X below might close r2\n" +
			"        new X(r2).foo(new FileReader(new File(\"notthere\")));\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	FileReader fileReader = getReader();\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Resource \'fileReader\' should be managed by try-with-resource\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 11)\n" + 
		"	FileReader r3 = getReader();\n" + 
		"	           ^^\n" + 
		"Resource \'r3\' should be managed by try-with-resource\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 24)\n" + 
		"	FileReader r2 = new FileReader(new File(\"inexist\")); // only potential problem: ctor X below might close r2\n" + 
		"	           ^^\n" + 
		"Potentially leaking resource 'r2': is not closed on all paths\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// nested try with early exit
public void test055m() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() {\n" +
			"        File file = new File(\"somefile\");" +
			"        try {\n" +
			"            FileReader fileReader = new FileReader(file);\n" +
			"            try {\n" +
			"                char[] in = new char[50];\n" +
			"                if (fileReader.read(in)==0)\n" +
			"                    return;\n" +
			"            } finally {\n" +
			"		         fileReader.close();\n" +
			"            }\n" +
			"        } catch (IOException e) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// nested try should not interfere with earlier analysis.
public void test055n() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"import java.io.FileNotFoundException;\n" +
			"public class X {\n" +
			"    void foo(File someFile, char[] buf) throws IOException {\n" + 
			"		FileReader fr1 = new FileReader(someFile);\n" + 
			"		try {\n" + 
			"			fr1.read(buf);\n" + 
			"		} finally {\n" + 
			"			fr1.close();\n" + 
			"		}\n" + 
			"		try {\n" + 
			"			FileReader fr3 = new FileReader(someFile);\n" + 
			"			try {\n" + 
			"			} finally {\n" + 
			"				fr3.close();\n" + 
			"			}\n" + 
			"		} catch (IOException e) {\n" + 
			"		}\n" + 
			"	 }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        try {\n" +
			"            new X().foo(new File(\"missing\"), new char[100]);\n" +
			"        } catch (FileNotFoundException e) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// if close is guarded by null check this should still be recognized as definitely closed
public void test055o() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"import java.io.FileNotFoundException;\n" +
			"public class X {\n" +
			"    void foo(File someFile, char[] buf) throws IOException {\n" + 
			"		FileReader fr1 = null;\n" + 
			"		try {\n" +
			"           fr1 = new FileReader(someFile);" + 
			"			fr1.read(buf);\n" + 
			"		} finally {\n" + 
			"			if (fr1 != null)\n" +
			"               try {\n" +
			"                   fr1.close();\n" +
			"               } catch (IOException e) { /*do nothing*/ }\n" + 
			"		}\n" + 
			"	 }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        try {\n" +
			"            new X().foo(new File(\"missing\"), new char[100]);\n" +
			"        } catch (FileNotFoundException e) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable without ever closing it, type from a type variable
public void test055p() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.Reader;\n" +
			"import java.io.IOException;\n" +
			"public abstract class X <T extends Reader> {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        T fileReader = newReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"    }\n" +
			"    abstract T newReader(File file) throws IOException;\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X<FileReader>() {\n" +
			"            FileReader newReader(File f) throws IOException { return new FileReader(f); }\n" +
			"        }.foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	T fileReader = newReader(file);\n" + 
		"	  ^^^^^^^^^^\n" + 
		"Leaking resource 'fileReader': is never closed\n" +
		"----------\n",
		null,
		true,
		options);
}
public static Class testClass() {
	return TryWithResourcesStatementTest.class;
}

Return to bug 349326

Added Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java (+115 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 GK Software AG and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Stephan Herrmann - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;
12
13	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
14	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
15	import org.eclipse.jdt.internal.compiler.impl.Constant;
16	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
17	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
18	import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
19	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
20	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
21	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
22	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
23
24	/**
25	* A faked local variable declaration used for keeping track of data flows of a
26	* special variable. Certain events will be recorded by changing the null info
27	* for this variable.
28	*
29	* See bug 349326 - [1.7] new warning for missing try-with-resources
30	*/
31	public class FakedTrackingVariable extends LocalDeclaration {
32
33	/** If resource is already managed by try-with-resources don't complain. */
34	public boolean isInsideTryWithResources;
35
36	/**
37	* If close() is invoked from a nested method (inside a local type)
38	* report remaining problems only as potential.
39	*/
40	public boolean closedInNestedMethod;
41
42	/** If a problem has already been reported don't complain again. */
43	public boolean hasReportedProblem;
44
45	MethodScope methodScope; // designates the method declaring this variable
46
47	public LocalVariableBinding originalBinding; // the real local being tracked
48
49	public FakedTrackingVariable(LocalVariableBinding original, Statement location) {
50	super(original.name, location.sourceStart, location.sourceEnd);
51	this.type = new SingleTypeReference(
52	TypeConstants.OBJECT,
53	((long)this.sourceStart <<32)+this.sourceEnd);
54	this.methodScope = original.declaringScope.methodScope();
55	this.originalBinding = original;
56	resolve(original.declaringScope);
57	}
58
59	public void generateCode(BlockScope currentScope, CodeStream codeStream)
60	{ /* NOP - this variable is completely dummy, ie. for analysis only. */ }
61
62	public void resolve (BlockScope scope) {
63	// only need the binding, which is used as reference in FlowInfo methods.
64	this.binding = new LocalVariableBinding(
65	this.name,
66	scope.getJavaLangObject(), // dummy, just needs to be a reference type
67	0,
68	false);
69	this.binding.setConstant(Constant.NotAConstant);
70	this.binding.useFlag = LocalVariableBinding.USED;
71	// use a free slot without assigning it:
72	this.binding.id = scope.registerTrackingVariable(this);
73	}
74
75	/**
76	* If expression resolves to a local variable binding of type AutoCloseable,
77	* answer the variable that tracks closing of that local, creating it if needed.
78	* @param expression
79	* @return a new {@link FakedTrackingVariable} or null.
80	*/
81	public static FakedTrackingVariable getCloseTrackingVariable(Expression expression) {
82	if (expression instanceof SingleNameReference) {
83	SingleNameReference name = (SingleNameReference) expression;
84	if (name.binding instanceof LocalVariableBinding) {
85	LocalVariableBinding local = (LocalVariableBinding)name.binding;
86	if (local.closeTracker != null)
87	return local.closeTracker;
88	if (local.isParameter() \|\| !isAutoCloseable(expression.resolvedType))
89	return null;
90	// tracking var doesn't yet exist. This happens in finally block
91	// which is analyzed before the corresponding try block
92	Statement location = local.declaration;
93	return local.closeTracker = new FakedTrackingVariable(local, location);
94	}
95	}
96	return null;
97	}
98
99	public static FlowInfo markPotentialClosing(Expression expression, FlowInfo flowInfo) {
100	FakedTrackingVariable trackVar = getCloseTrackingVariable(expression);
101	if (trackVar != null) {
102	// insert info that the tracked resource may be closed (by the target method, i.e.)
103	FlowInfo infoResourceIsClosed = flowInfo.copy();
104	infoResourceIsClosed.markAsDefinitelyNonNull(trackVar.binding);
105	return FlowInfo.conditional(flowInfo, infoResourceIsClosed);
106	}
107	return flowInfo;
108	}
109
110	/** Answer wither the given type binding is a subtype of java.lang.AutoCloseable. */
111	public static boolean isAutoCloseable(TypeBinding typeBinding) {
112	return typeBinding instanceof ReferenceBinding
113	&& ((ReferenceBinding)typeBinding).hasTypeBit(TypeIds.BitAutoCloseable);
114	}
115	}

Lines 8-16 Link Here

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

Lines 8-14 Link Here

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