Attachment #203866 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 1394-1399 Link Here
1394	int DiamondNotBelow17 = TypeRelated + 883;	1399	int DiamondNotBelow17 = TypeRelated + 883;
1395	/** @since 3.7.1 */	1400	/** @since 3.7.1 */
1396	int RedundantSpecificationOfTypeArguments = TypeRelated + 884;	1401	int RedundantSpecificationOfTypeArguments = TypeRelated + 884;
		1402	/** @since 3.8 */
		1403	int PotentiallyUnclosedCloseable = Internal + 885;
		1404	/** @since 3.8 */
		1405	int PotentiallyUnclosedCloseableAtExit = Internal + 886;
		1406	/** @since 3.8 */
		1407	int UnclosedCloseable = Internal + 887;
		1408	/** @since 3.8 */
		1409	int UnclosedCloseableAtExit = Internal + 888;
		1410	/** @since 3.8 */
		1411	int ExplicitlyClosedAutoCloseable = Internal + 889;
1397	/**	1412	/**
1398	* External problems -- These are problems defined by other plugins	1413	* External problems -- These are problems defined by other plugins
1399	*/	1414	*/

Lines 10-15 Link Here

(-)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
				local.closeTracker.recordErrorLocation(this, flowInfo.nullStatus(trackerBinding));
			}
		}
		if (FakedTrackingVariable.isAutoCloseable(this.expression.resolvedType)) {
			// 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 (-2 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for bug 349326 - [1.7] new warning for missing try-with-resources
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	12	package org.eclipse.jdt.internal.compiler.ast;
12		13
Lines 32-41 Link Here
32	int complaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;	33	int complaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;
33	for (int i = 0, max = this.statements.length; i < max; i++) {	34	for (int i = 0, max = this.statements.length; i < max; i++) {
34	Statement stat = this.statements[i];	35	Statement stat = this.statements[i];
35	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {	36	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, flowContext, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {
36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);	37	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);
37	}	38	}
38	}	39	}
		40	if (this.explicitDeclarations > 0) // if block has its own scope analyze tracking vars now:
		41	this.scope.checkUnclosedCloseables(flowInfo, flowContext, null);
39	return flowInfo;	42	return flowInfo;
40	}	43	}
41	/**	44	/**




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


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

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

Lines 7-13 Link Here

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




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

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


	}

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

	public void generateCode(BlockScope currentScope, CodeStream codeStream){




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

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

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

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

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

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

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

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

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

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

	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);
	}
	
	public void recordErrorLocation(ASTNode location, int nullStatus) {
		if (this.recordedLocations == null)
			this.recordedLocations = new HashMap();
		this.recordedLocations.put(location, new Integer(nullStatus));
	}

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

Lines 7-13 Link Here

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

Lines 7-12 Link Here

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

Lines 7-13 Link Here

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

Lines 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	}




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


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

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

Lines 7-13 Link Here

(-)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 / +10 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	currentScope.removeTrackingVar(trackingVariable);
		50	}
43	}	51	}
44	this.initStateIndex =	52	this.initStateIndex =
45	currentScope.methodScope().recordInitializationStates(flowInfo);	53	currentScope.methodScope().recordInitializationStates(flowInfo);
Lines 104-109 Link Here
104	this.expression.bits \|= ASTNode.IsReturnedValue;	112	this.expression.bits \|= ASTNode.IsReturnedValue;
105	}	113	}
106	}	114	}
		115	currentScope.checkUnclosedCloseables(flowInfo, null/ignore exception exits from flowContext/, this);
107	return FlowInfo.DEAD_END;	116	return FlowInfo.DEAD_END;
108	}	117	}
109		118




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contributions for 
 *     							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;



// Report an error if necessary (if even more unreachable than previously reported
// complaintLevel = 0 if was reachable up until now, 1 if fake reachable (deadcode), 2 if fatal unreachable (error)
public int complainIfUnreachable(FlowInfo flowInfo, FlowContext flowContext, BlockScope scope, int previousComplaintLevel) {
	if ((flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0) {
		if ((flowInfo.reachMode() & FlowInfo.UNREACHABLE_OR_DEAD) != 0)
			this.bits &= ~ASTNode.IsReachable;
		if (flowInfo == FlowInfo.DEAD_END) {
			if (previousComplaintLevel < COMPLAINED_UNREACHABLE) {
				scope.problemReporter().unreachableCode(this);
				scope.checkUnclosedCloseables(flowInfo, flowContext, null);
			}
			return COMPLAINED_UNREACHABLE;
		} else {
			if (previousComplaintLevel < COMPLAINED_FAKE_REACHABLE) {
				scope.problemReporter().fakeReachable(this);
				scope.checkUnclosedCloseables(flowInfo, flowContext, null);
			}
			return COMPLAINED_FAKE_REACHABLE;
		}

Lines 7-13 Link Here

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

Lines 7-13 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TryStatement.java (-5 / +19 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
Lines 124-131 Link Here
124	for (int i = 0; i < resourcesLength; i++) {	126	for (int i = 0; i < resourcesLength; i++) {
125	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());	127	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());
126	this.postResourcesInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(flowInfo);	128	this.postResourcesInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(flowInfo);
127	this.resources[i].binding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.	129	LocalVariableBinding resourceBinding = this.resources[i].binding;
128	TypeBinding type = this.resources[i].binding.type;	130	resourceBinding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.
		131	if (resourceBinding.closeTracker != null) {
		132	// this was false alarm, we don't need to track the resource
		133	this.tryBlock.scope.removeTrackingVar(resourceBinding.closeTracker);
		134	resourceBinding.closeTracker = null;
		135	}
		136	TypeBinding type = resourceBinding.type;
129	if (type != null && type.isValidBinding()) {	137	if (type != null && type.isValidBinding()) {
130	ReferenceBinding binding = (ReferenceBinding) type;	138	ReferenceBinding binding = (ReferenceBinding) type;
131	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter	139	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter
Lines 250-257 Link Here
250	for (int i = 0; i < resourcesLength; i++) {	258	for (int i = 0; i < resourcesLength; i++) {
251	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());	259	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());
252	this.postResourcesInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(flowInfo);	260	this.postResourcesInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(flowInfo);
253	this.resources[i].binding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.	261	LocalVariableBinding resourceBinding = this.resources[i].binding;
254	TypeBinding type = this.resources[i].binding.type;	262	resourceBinding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.
		263	if (resourceBinding.closeTracker != null) {
		264	// this was false alarm, we don't need to track the resource
		265	this.tryBlock.scope.removeTrackingVar(resourceBinding.closeTracker);
		266	resourceBinding.closeTracker = null;
		267	}
		268	TypeBinding type = resourceBinding.type;
255	if (type != null && type.isValidBinding()) {	269	if (type != null && type.isValidBinding()) {
256	ReferenceBinding binding = (ReferenceBinding) type;	270	ReferenceBinding binding = (ReferenceBinding) type;
257	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter	271	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter

Lines 7-13 Link Here

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




 *
 * 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 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$

		TypeBinding raisedException,
		TypeBinding caughtException,
		ASTNode invocationSite,
		boolean wasAlreadyDefinitelyCaught,
		boolean isFirstException) {

	int index = this.indexes.get(exceptionType);
	int cacheIndex = index / ExceptionHandlingFlowContext.BitCacheSize;

		CatchParameterBinding catchParameter = (CatchParameterBinding) this.catchArguments[catchBlock].binding;
		catchParameter.setPreciseType(caughtException);
	}
	UnconditionalFlowInfo mergedInfo =
			(this.initsOnExceptions[catchBlock].tagBits & FlowInfo.UNREACHABLE) == 0 ?
					this.initsOnExceptions[catchBlock].mergedWith(flowInfo):
						flowInfo.unconditionalCopy();
	if (isFirstException) {
		LocalVariableBinding trackBinding = FakedTrackingVariable.getTrackerForCloseCall(invocationSite);
		if (trackBinding != null)
			// if the first statement throwing an exception is a close() call, consider the corresponding resource as closed despite the exception
			mergedInfo.markAsDefinitelyNonNull(trackBinding);
	}
	this.initsOnExceptions[catchBlock] = mergedInfo;
}

public void recordReturnFrom(UnconditionalFlowInfo flowInfo) {




 *
 * 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.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;


	Expression[] nullReferences;
	int[] nullCheckTypes;
	int nullCount;
	boolean hasSeenExceptions;

	public FinallyFlowContext(FlowContext parent, ASTNode associatedNode) {
		super(parent, associatedNode);
	}

	public void checkExceptionHandlers(TypeBinding[] raisedExceptions, ASTNode location, FlowInfo flowInfo, BlockScope scope) {
		checkExceptionHandlers(raisedExceptions, location, flowInfo, scope, !this.hasSeenExceptions);
		this.hasSeenExceptions = true;
	}

/**
 * Given some contextual initialization info (derived from a try block or a catch block), this
 * code will check that the subroutine context does not also initialize a final variable potentially set




 * 
 * 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 org.eclipse.jdt.core.compiler.CharOperation;
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.Expression;
import org.eclipse.jdt.internal.compiler.ast.LabeledStatement;
import org.eclipse.jdt.internal.compiler.ast.Reference;

								raisedException,
								raisedException, // precise exception that will be caught
								location,
								definitelyCaught,
								false/* not first exception in finally block*/);
							// was it already definitely caught ?
							definitelyCaught = true;
							break;

								raisedException,
								caughtException,
								location,
								false,
								false/* not first exception in finally block*/);
							// was not caught already per construction
					}
				}

		scope.problemReporter().unhandledException(raisedException, location);
	}
}

public void checkExceptionHandlers(TypeBinding[] raisedExceptions, ASTNode location, FlowInfo flowInfo, BlockScope scope) {
	checkExceptionHandlers(raisedExceptions, location, flowInfo, scope, false/*not known to be first in finally*/);
}

public void checkExceptionHandlers(TypeBinding[] raisedExceptions, ASTNode location, FlowInfo flowInfo, BlockScope scope, boolean isFirstExceptionInFinally) {
	// check that all the argument exception types are handled
	// JDK Compatible implementation - when an exception type is thrown,
	// all related catch blocks are marked as reachable... instead of those only

										raisedException,
										raisedException, // precise exception that will be caught
										location,
										locallyCaught[raisedIndex],
										isFirstExceptionInFinally);
									// was already definitely caught ?
									if (!locallyCaught[raisedIndex]) {
										locallyCaught[raisedIndex] = true;

										raisedException,
										caughtException, 
										location,
										false,
										isFirstExceptionInFinally);
									// was not caught already per construction
							}
						}

	return null;
}

/**
 * Answer the combined null status that local will have after this flow context.
 * Subclasses will respect break and exception exits.
 */
public int getNullStatusAfter(LocalVariableBinding local, FlowInfo flowInfo) {
	return flowInfo.nullStatus(local);
}

/*
 * lookup through break labels
 */

	buffer.append(individualToString()).append('\n');
	return buffer.toString();
}

/**
 * Get the null status that local will have after the current point as indicated by flowInfo and flowContext
 * @param local
 * @param flowInfo
 * @param flowContext may be null
 * @return a bitset from the constants FlowInfo.{NULL,POTENTIALLY_NULL,POTENTIALLY_NON_NULL,NON_NULL}.
 */
public static int getNullStatusAfter(LocalVariableBinding local, FlowInfo flowInfo, FlowContext flowContext) {
	int reachMode = flowInfo.reachMode();
	int status = 0;
	try {
		// unreachable flowInfo is too shy in reporting null-issues, temporarily forget reachability:
		if (reachMode != FlowInfo.REACHABLE)
			flowInfo.tagBits &= ~FlowInfo.UNREACHABLE;
		status = (flowContext != null) 
						? flowContext.getNullStatusAfter(local, flowInfo)
						: flowInfo.nullStatus(local);
	} finally {
		// reset
		flowInfo.tagBits |= reachMode;
	}
	// at this point some combinations are not useful so flatten to a single bit:
	return mergeNullStatus(status);
}

/* Merge the bits NULL, NON_NULL, POTENTIALLY_NULL, POTENTIALLY_NON_NULL to a one-bit answer. */
private static int mergeNullStatus(int status) {
	if ((status & FlowInfo.NULL) != 0) {
		if ((status & (FlowInfo.NON_NULL | FlowInfo.POTENTIALLY_NON_NULL)) != 0)
			return FlowInfo.POTENTIALLY_NULL; 	// null + doubt = pot null
		return FlowInfo.NULL;
	} else if ((status & FlowInfo.NON_NULL) != 0) {
		if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
			return FlowInfo.POTENTIALLY_NULL;	// non-null + doubt = pot null
		return FlowInfo.NON_NULL;
	} else if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
		return FlowInfo.POTENTIALLY_NULL;
	return status;
}
}

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/InitializationFlowContext.java (-1 / +3 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
Lines 67-73 Link Here
67	TypeBinding raisedException,	68	TypeBinding raisedException,
68	TypeBinding caughtException,	69	TypeBinding caughtException,
69	ASTNode invocationSite,	70	ASTNode invocationSite,
70	boolean wasMasked) {	71	boolean wasMasked,
		72	boolean isFirstExceptionInFinally) {
71		73
72	// even if unreachable code, need to perform unhandled exception diagnosis	74	// even if unreachable code, need to perform unhandled exception diagnosis
73	int size = this.thrownExceptions.length;	75	int size = this.thrownExceptions.length;

Lines 7-13 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/LoopingFlowContext.java (-2 / +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 336428 - [compiler][null] bogus warning "redundant null check" in condition of do {} while() loop	10	* Stephan Herrmann - contributions for
		11	* Bug 336428 - [compiler][null] bogus warning "redundant null check" in condition of do {} while() loop
		12	* Bug 349326 - [1.7] new warning for missing try-with-resources
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.flow;	14	package org.eclipse.jdt.internal.compiler.flow;
13		15
Lines 59-65 Link Here
59	void simulateThrowAfterLoopBack(FlowInfo flowInfo) {	61	void simulateThrowAfterLoopBack(FlowInfo flowInfo) {
60	this.catchingContext.recordHandlingException(this.caughtException,	62	this.catchingContext.recordHandlingException(this.caughtException,
61	flowInfo.unconditionalInits(), null, // raised exception, irrelevant here,	63	flowInfo.unconditionalInits(), null, // raised exception, irrelevant here,
62	null, null, /* invocation site, irrelevant here */ true // we have no business altering the needed status.	64	null,
		65	null, // invocation site, irrelevant here
		66	true, // we have no business altering the needed status.
		67	false // not known to be the first exception in a finally block
63	);	68	);
64	}	69	}
65	}	70	}




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




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

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

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

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

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

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

Lines 7-12 Link Here

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

Lines 7-19 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java (+110 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(3);
		974	this.trackingVariables.add(fakedTrackingVariable);
		975	MethodScope outerMethodScope = outerMostMethodScope();
		976	return outerMethodScope.analysisIndex + (outerMethodScope.trackVarCount++);
		977
		978	}
		979	/** When no longer interested in this tracking variable remove it. */
		980	public void removeTrackingVar(FakedTrackingVariable trackingVariable) {
		981	if (this.trackingVariables != null)
		982	if (this.trackingVariables.remove(trackingVariable))
		983	return;
		984	if (this.parent instanceof BlockScope)
		985	((BlockScope)this.parent).removeTrackingVar(trackingVariable);
		986	}
		987	/**
		988	* At the end of a block check the closing-status of all tracked closeables that are declared in this block.
		989	* Also invoked when entering unreachable code.
		990	*/
		991	public void checkUnclosedCloseables(FlowInfo flowInfo, FlowContext flowContext, ASTNode location) {
		992	if (this.trackingVariables == null) return;
		993	if (location != null && flowInfo.reachMode() != 0) return;
		994	for (int i=0; i<this.trackingVariables.size(); i++) {
		995	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
		996	if (location != null && trackingVar.originalBinding != null && flowInfo.isDefinitelyNull(trackingVar.originalBinding))
		997	continue; // reporting against a specific location, resource is null at this flow, don't complain
		998	int status = FlowContext.getNullStatusAfter(trackingVar.binding, flowInfo, flowContext);
		999	if (status == FlowInfo.NULL) {
		1000	// definitely unclosed: highest priority
		1001	reportResourceLeak(trackingVar, location, status);
		1002	if (location == null) {
		1003	// definitely done with this trackingVar, remove it
		1004	this.trackingVariables.remove(trackingVar);
		1005	i--; // ... but don't disturb the enclosing loop.
		1006	}
		1007	continue;
		1008	}
		1009	if (location == null) // at end of block an not definitely unclosed
		1010	{
		1011	// problems at specific locations: medium priority
		1012	if (trackingVar.reportRecordedErrors(problemReporter())) // ... report previously recorded errors
		1013	continue;
		1014	}
		1015	if (status == FlowInfo.POTENTIALLY_NULL) {
		1016	// potentially unclosed: lower priority
		1017	reportResourceLeak(trackingVar, location, status);
		1018	} else if (status == FlowInfo.NON_NULL) {
		1019	// properly closed but not managed by t-w-r: lowest priority
		1020	if (environment().globalOptions.complianceLevel >= ClassFileConstants.JDK1_7)
		1021	problemReporter().explicitlyClosedAutoCloseable(trackingVar);
		1022	}
		1023	}
		1024	}
		1025	private void reportResourceLeak(FakedTrackingVariable trackingVar, ASTNode location, int nullStatus) {
		1026	if (location != null)
		1027	trackingVar.recordErrorLocation(location, nullStatus);
		1028	else
		1029	trackingVar.reportError(problemReporter(), null, nullStatus);
1030	}
1031
1032	/**
1033	* If one branch of an if-else closes any AutoCloseable resource, and if the same
1034	* resource is known to be null on the other branch mark it as closed, too,
1035	* so that merging both branches indicates that the resource is always closed.
1036	* Example:
1037	* FileReader fr1 = null;
1038	* try {\n" +
1039	* fr1 = new FileReader(someFile);" +
1040	* fr1.read(buf);\n" +
1041	* } finally {\n" +
1042	* if (fr1 != null)\n" +
1043	* try {\n" +
1044	* fr1.close();\n" +
1045	* } catch (IOException e) {
1046	* // do nothing
1047	* }
1048	* // after this if statement fr1 is definitely not leaked
1049	* }
1050	*/
1051	public void correlateTrackingVarsIfElse(FlowInfo thenFlowInfo, FlowInfo elseFlowInfo) {
1052	if (this.trackingVariables != null) {
1053	for (int i=0; i<this.trackingVariables.size(); i++) {
1054	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
1055	if ( thenFlowInfo.isDefinitelyNonNull(trackingVar.binding) // closed in then branch
1056	&& elseFlowInfo.isDefinitelyNull(trackingVar.originalBinding)) // null in else branch
1057	{
1058	elseFlowInfo.markAsDefinitelyNonNull(trackingVar.binding); // -> always closed
1059	}
1060	else if ( elseFlowInfo.isDefinitelyNonNull(trackingVar.binding) // closed in else branch
1061	&& thenFlowInfo.isDefinitelyNull(trackingVar.originalBinding)) // null in then branch
1062	{
1063	thenFlowInfo.markAsDefinitelyNonNull(trackingVar.binding); // -> always closed
1064	}
1065	}
1066	}
1067	if (this.parent instanceof BlockScope)
1068	((BlockScope) this.parent).correlateTrackingVarsIfElse(thenFlowInfo, elseFlowInfo);
1069	}
960	}	1070	}




 *     						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 = 0;
		55
52	public MethodScope(ClassScope parent, ReferenceContext context, boolean isStatic) {	56	public MethodScope(ClassScope parent, ReferenceContext context, boolean isStatic) {
53	super(METHOD_SCOPE, parent);	57	super(METHOD_SCOPE, parent);
54	this.locals = new LocalVariableBinding[5];	58	this.locals = new LocalVariableBinding[5];

Lines 7-12 Link Here

(-)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 438-445 Link Here
438	case 'A' :	443	case 'A' :
439	switch(typeName.length) {	444	switch(typeName.length) {
440	case 13 :	445	case 13 :
441	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2]))	446	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2])) {
442	this.id = TypeIds.T_JavaLangAutoCloseable;	447	this.id = TypeIds.T_JavaLangAutoCloseable;
		448	this.typeBits \|= TypeIds.BitAutoCloseable;
		449	}
443	return;	450	return;
444	case 14:	451	case 14:
445	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))	452	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))
Lines 937-942 Link Here
937	public final boolean hasRestrictedAccess() {	944	public final boolean hasRestrictedAccess() {
938	return (this.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0;	945	return (this.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0;
939	}	946	}
		947	/** Answer an additional bit characterizing this type, like {@link TypeIds#BitAutoCloseable}. */
		948	abstract public boolean hasTypeBit(int bit);
940		949
941	/** Answer true if the receiver implements anInterface or is identical to anInterface.	950	/** Answer true if the receiver implements anInterface or is identical to anInterface.
942	* If searchHierarchy is true, then also search the receiver's superclasses.	951	* 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 151-156 Link Here
151	"MethodHandle$PolymorphicSignature".toCharArray() //$NON-NLS-1$	152	"MethodHandle$PolymorphicSignature".toCharArray() //$NON-NLS-1$
152	};	153	};
153	char[][] JAVA_LANG_AUTOCLOSEABLE = {JAVA, LANG, "AutoCloseable".toCharArray()}; //$NON-NLS-1$	154	char[][] JAVA_LANG_AUTOCLOSEABLE = {JAVA, LANG, "AutoCloseable".toCharArray()}; //$NON-NLS-1$
		155	char[] CLOSE = "close".toCharArray(); //$NON-NLS-1$
154		156
155	// Constraints for generic type argument inference	157	// Constraints for generic type argument inference
156	int CONSTRAINT_EQUAL = 0; // Actual = Formal	158	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 182-185 Link Here
182	final int Object2boolean = T_JavaLangObject + (T_boolean << 4);	183	final int Object2boolean = T_JavaLangObject + (T_boolean << 4);
183	final int BOXING = 0x200;	184	final int BOXING = 0x200;
184	final int UNBOXING = 0x400;	185	final int UNBOXING = 0x400;
		186
		187	/**
		188	* Marks all sub-types of java.lang.AutoCloseable.
		189	* @see ReferenceBinding#hasTypeBit(int)
		190	*/
		191	final int BitAutoCloseable = 1;
185	}	192	}

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);
	}
}
public void unclosedCloseable(FakedTrackingVariable trackVar, ASTNode location) {
	String[] args = { String.valueOf(trackVar.name) };
	if (location == null) {
		this.handle(
			IProblem.UnclosedCloseable,
			args,
			args,
			trackVar.sourceStart,
			trackVar.sourceEnd);
	} else {
		this.handle(
			IProblem.UnclosedCloseableAtExit,
			args,
			args,
			location.sourceStart,
			location.sourceEnd);
	}
}
public void explicitlyClosedAutoCloseable(FakedTrackingVariable trackVar) {
	String[] args = { String.valueOf(trackVar.name) };
	this.handle(
		IProblem.ExplicitlyClosedAutoCloseable,
		args,
		args,
		trackVar.sourceStart,
		trackVar.sourceEnd);	
}
}

Lines 8-14 Link Here

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

Lines 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[] { "test056i2" };
//	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" + 

		},
		"Done");
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable without ever closing it.
public void test056() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
// not invoking any methods on FileReader, try to avoid necessary call to superclass() in the compiler
//			"        char[] in = new char[50];\n" +
//			"        fileReader.read(in);\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"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 test056a() {
	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 test056b() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        try {\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"        } finally {\n" +
			"		     fileReader.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        try {\n" +
			"            new X().foo();\n" +
			"        } catch (IOException ioex) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable properly within try-with-resources.
public void test056c() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        try (FileReader fileReader = new FileReader(file)) {\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"		 }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        try {\n" +
			"            new X().foo();\n" +
			"        } catch (IOException ioex) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses two AutoCloseables (testing independent analysis)
// - one closeable may be unclosed at a conditional return
// - the other is only conditionally closed
public void test056d() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean flag1, boolean flag2) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        char[] in = new char[50];\n" +
			"        FileReader fileReader1 = new FileReader(file);\n" +
			"        fileReader1.read(in);\n" +
			"        FileReader fileReader2 = new FileReader(file);\n" +
			"        fileReader2.read(in);\n" +
			"        if (flag1) {\n" +
			"            fileReader2.close();\n" +
			"            return;\n" +
			"        } else if (flag2) {\n" +
			"            fileReader2.close();\n" +
			"        }\n" +
			"        fileReader1.close();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(false, true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 10)\n" + 
		"	FileReader fileReader2 = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^^\n" + 
		"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 test056d_suppress() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	options.put(CompilerOptions.OPTION_SuppressOptionalErrors, CompilerOptions.ENABLED);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean flag1, boolean flag2) throws IOException {\n" +
			"        @SuppressWarnings(\"resource\") File file = new File(\"somefile\"); // unnecessary suppress\n" +
			"        char[] in = new char[50];\n" +
			"        FileReader fileReader1 = new FileReader(file);\n" +
			"        fileReader1.read(in);\n" +
			"        @SuppressWarnings(\"resource\") FileReader fileReader2 = new FileReader(file); // useful suppress\n" +
			"        fileReader2.read(in);\n" +
			"        if (flag1) {\n" +
			"            fileReader2.close();\n" +
			"            return; // not suppressed\n" +
			"        } else if (flag2) {\n" +
			"            fileReader2.close();\n" +
			"        }\n" +
			"        fileReader1.close();\n" +
			"    }\n" +
			"    @SuppressWarnings(\"resource\") // useful suppress\n" +
			"    void bar() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(false, true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 6)\n" + 
		"	@SuppressWarnings(\"resource\") File file = new File(\"somefile\"); // unnecessary suppress\n" + 
		"	                  ^^^^^^^^^^\n" + 
		"Unnecessary @SuppressWarnings(\"resource\")\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 14)\n" + 
		"	return; // not suppressed\n" + 
		"	^^^^^^^\n" + 
		"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 test056e() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    FileReader getReader(String filename) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        return fileReader;\n" + 		// don't complain here, pass responsibility to caller
			"    }\n" +
			"    void foo() throws IOException {\n" +
			"        FileReader reader = getReader(\"somefile\");\n" +
			"        char[] in = new char[50];\n" +
			"        reader.read(in);\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 11)\n" + 
		"	FileReader reader = getReader(\"somefile\");\n" + 
		"	           ^^^^^^\n" + 
		"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 test056f() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	options.put(CompilerOptions.OPTION_ReportExplicitlyClosedAutoCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = null;\n" +
			"        try {\n" +
			"            fileReader = new FileReader(file);\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"        } finally {\n" +
			"            fileReader.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = null;\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Resource \'fileReader\' should be managed by try-with-resource\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// an AutoCloseable local is re-assigned
public void test056g() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"        fileReader = new FileReader(file);\n" +
			"        fileReader.read(in);\n" +
			"        fileReader.close();\n" +
			"        fileReader = null;\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	fileReader = new FileReader(file);\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"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
// an AutoCloseable local is re-assigned after null-assigned
public void test056g2() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"        fileReader = null;\n" +
			"        fileReader = new FileReader(file);\n" + // don't complain again, fileReader is null, so nothing can leak here
			"        fileReader.read(in);\n" +
			"        fileReader.close();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	fileReader = null;\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"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 test056h() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        final File file = new File(\"somefile\");\n" +
			"        final FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"        new Runnable() {\n public void run() {\n" +
			"            try {\n" +
			"                fileReader.close();\n" +
			"                FileReader localReader = new FileReader(file);\n" +
			"            } catch (IOException ex) { /* nop */ }\n" +
			"        }}.run();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 7)\n" + 
		"	final FileReader fileReader = new FileReader(file);\n" + 
		"	                 ^^^^^^^^^^\n" + 
		"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 test056i() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean f1, boolean f2) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        if (f1) {\n" +
			"            FileReader fileReader = new FileReader(file); // err: not closed\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"            while (true) {\n" +
			"                 FileReader loopReader = new FileReader(file); // don't warn, properly closed\n" +
			"                 loopReader.close();" +
			"                 break;\n" +
			"            }\n" +
			"        } else {\n" +
			"            FileReader fileReader = new FileReader(file); // warn: not closed on all paths\n" +
			"            if (f2)\n" +
			"                fileReader.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(true, true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	FileReader fileReader = new FileReader(file); // err: not closed\n" + 
		"	           ^^^^^^^^^^\n" + 
		"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 test056j() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        read(fileReader);\n" +
			"    }\n" +
			"    void read(FileReader reader) { }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"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 test056jconditional() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo(boolean b) throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        synchronized (b ? this : new X()) {\n" +
			"            new ReadDelegator(fileReader);\n" +
			"        }\n" +
			"    }\n" +
			"    class ReadDelegator { ReadDelegator(FileReader reader) { } }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo(true);\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"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 test056k() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	options.put(CompilerOptions.OPTION_ReportExplicitlyClosedAutoCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        int i01, i02, i03, i04, i05, i06, i07, i08, i09,\n" +
			"            i11, i12, i13, i14, i15, i16, i17, i18, i19,\n" +
			"            i21, i22, i23, i24, i25, i26, i27, i28, i29,\n" +
			"            i31, i32, i33, i34, i35, i36, i37, i38, i39,\n" +
			"            i41, i42, i43, i44, i45, i46, i47, i48, i49;\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader ra1 = null, ra2 = null;\n" +
			"        try {\n" +
			"            ra1 = new FileReader(file);\n" +
			"            ra2 = new FileReader(file);\n" +
			"            FileReader ra3 = new FileReader(file);\n" +
			"            char[] in = new char[50];\n" +
			"            ra1.read(in);\n" +
			"            ra2.read(in);\n" +
			"            ra3.close();\n" +
			"        } finally {\n" +
			"            ra1.close();\n" +
			"        }\n" +
			"        int i51, i52, i53, i54, i55, i56, i57, i58, i59, i60;\n" + // beyond this point locals are analyzed using extraBits
			"        FileReader rb1 = null, rb2 = null;\n" +
			"        try {\n" +
			"            rb1 = new FileReader(file);\n" +
			"            rb2 = new FileReader(file);\n" +
			"            FileReader rb3 = new FileReader(file);\n" +
			"            char[] in = new char[50];\n" +
			"            rb1.read(in);\n" +
			"            rb2.read(in);\n" +
			"            rb3.close();\n" +
			"        } finally {\n" +
			"            rb1.close();\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 12)\n" + 
		"	FileReader ra1 = null, ra2 = null;\n" + 
		"	           ^^^\n" + 
		"Resource \'ra1\' should be managed by try-with-resource\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 15)\n" + 
		"	ra2 = new FileReader(file);\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"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 test056l() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportExplicitlyClosedAutoCloseable, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    X(FileReader r0) {}\n" + // don't complain against argument
			"    FileReader getReader() { return null; }\n" +
			"    void foo(FileReader r1) throws IOException {\n" +
			"        FileReader fileReader = getReader();\n" +
			"        if (fileReader == null)\n" +
			"            return;\n" + // don't complain, resource is actually null
			"        FileReader r3 = getReader();\n" +
			"        if (r3 == null)\n" +
			"            r3 = new FileReader(new File(\"absent\"));\n" + // don't complain, previous resource is actually null
			"        try {\n" +
			"            char[] in = new char[50];\n" +
			"            fileReader.read(in);\n" +
			"            r1.read(in);\n" +
			"        } finally {\n" +
			"            fileReader.close();\n" +
			"            r3.close();\n" +  // the effect of this close() call might be spoiled by exception in fileReader.close() above
			"        }\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" + 
		"Potentially leaking resource 'r3': is not closed on all paths\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 test056m() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() {\n" +
			"        File file = new File(\"somefile\");" +
			"        try {\n" +
			"            FileReader fileReader = new FileReader(file);\n" +
			"            try {\n" +
			"                char[] in = new char[50];\n" +
			"                if (fileReader.read(in)==0)\n" +
			"                    return;\n" +
			"            } finally {\n" +
			"		         fileReader.close();\n" +
			"            }\n" +
			"        } catch (IOException e) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// nested try should not interfere with earlier analysis.
public void test056n() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"import java.io.FileNotFoundException;\n" +
			"public class X {\n" +
			"    void foo(File someFile, char[] buf) throws IOException {\n" + 
			"		FileReader fr1 = new FileReader(someFile);\n" + 
			"		try {\n" + 
			"			fr1.read(buf);\n" + 
			"		} finally {\n" + 
			"			fr1.close();\n" + 
			"		}\n" + 
			"		try {\n" + 
			"			FileReader fr3 = new FileReader(someFile);\n" + 
			"			try {\n" + 
			"			} finally {\n" + 
			"				fr3.close();\n" + 
			"			}\n" + 
			"		} catch (IOException e) {\n" + 
			"		}\n" + 
			"	 }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        try {\n" +
			"            new X().foo(new File(\"missing\"), new char[100]);\n" +
			"        } catch (FileNotFoundException e) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// if close is guarded by null check this should still be recognized as definitely closed
public void test056o() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"import java.io.FileNotFoundException;\n" +
			"public class X {\n" +
			"    void foo(File someFile, char[] buf) throws IOException {\n" + 
			"		FileReader fr1 = null;\n" + 
			"		try {\n" +
			"           fr1 = new FileReader(someFile);" + 
			"			fr1.read(buf);\n" + 
			"		} finally {\n" + 
			"			if (fr1 != null)\n" +
			"               try {\n" +
			"                   fr1.close();\n" +
			"               } catch (IOException e) { /*do nothing*/ }\n" + 
			"		}\n" + 
			"	 }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        try {\n" +
			"            new X().foo(new File(\"missing\"), new char[100]);\n" +
			"        } catch (FileNotFoundException e) {\n" +
			"            System.out.println(\"caught\");\n" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		"caught", /*output*/
		null/*classLibs*/,
		true/*shouldFlush*/,
		null/*vmargs*/,
		options,
		null/*requestor*/);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// a method uses an AutoCloseable without ever closing it, type from a type variable
public void test056p() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportUnclosedCloseable, CompilerOptions.ERROR);
	options.put(CompilerOptions.OPTION_ReportPotentiallyUnclosedCloseable, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.Reader;\n" +
			"import java.io.IOException;\n" +
			"public abstract class X <T extends Reader> {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        T fileReader = newReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"    }\n" +
			"    abstract T newReader(File file) throws IOException;\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X<FileReader>() {\n" +
			"            FileReader newReader(File f) throws IOException { return new FileReader(f); }\n" +
			"        }.foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	T fileReader = newReader(file);\n" + 
		"	  ^^^^^^^^^^\n" + 
		"Leaking resource 'fileReader': is never closed\n" +
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// closed in dead code
public void test056q() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fileReader = new FileReader(file);\n" +
			"        char[] in = new char[50];\n" +
			"        fileReader.read(in);\n" +
			"        if (2*2 == 4)\n" +
			"        	return;\n" +
			"        fileReader.close();\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	FileReader fileReader = new FileReader(file);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Leaking resource \'fileReader\': is never closed\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 10)\n" + 
		"	if (2*2 == 4)\n" + 
		"	    ^^^^^^^^\n" + 
		"Comparing identical expressions\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 12)\n" + 
		"	fileReader.close();\n" + 
		"	^^^^^^^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// closed in dead code
public void test056r() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	options.put(JavaCore.COMPILER_PB_DEAD_CODE, CompilerOptions.ERROR);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" +
			"import java.io.FileReader;\n" +
			"import java.io.IOException;\n" +
			"public class X {\n" +
			"    void foo() throws IOException {\n" +
			"        File file = new File(\"somefile\");\n" +
			"        FileReader fr = new FileReader(file);\n" +
			"  		 Object b = null;\n" + 
			"        fr.close();\n" + 
			"        if (b != null) {\n" + 
			"            fr = new FileReader(file);\n" + 
			"            return;\n" + 
			"        } else {\n" + 
			"            System.out.print(42);\n" + 
			"        }\n" + 
			"        return;     // Should not complain about fr\n" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	if (b != null) {\n" + 
		"            fr = new FileReader(file);\n" + 
		"            return;\n" + 
		"        } else {\n" + 
		"	               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 13)\n" + 
		"	} else {\n" + 
		"            System.out.print(42);\n" + 
		"        }\n" + 
		"	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Statement unnecessarily nested within else clause. The corresponding then clause does not complete normally\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// resource inside t-w-r is re-assigned, shouldn't even record an errorLocation
public void test056s() {
	Map options = getCompilerOptions();
	options.put(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE, CompilerOptions.ERROR);
	options.put(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE, CompilerOptions.WARNING);
	options.put(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE, CompilerOptions.IGNORE);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.io.File;\n" + 
			"import java.io.FileReader;\n" + 
			"import java.io.IOException;\n" + 
			"public class X {\n" + 
			"    void foo() throws IOException {\n" + 
			"        File file = new File(\"somefile\");\n" + 
			"        try (FileReader fileReader = new FileReader(file);) {\n" + 
			"            char[] in = new char[50];\n" + 
			"            fileReader.read(in);\n" + 
			"            fileReader = new FileReader(file);  // debug here\n" + 
			"            fileReader.read(in);\n" + 
			"        }\n" + 
			"    }\n" + 
			"    public static void main(String[] args) throws IOException {\n" + 
			"        new X().foo();\n" + 
			"    }\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	fileReader = new FileReader(file);  // debug here\n" + 
		"	^^^^^^^^^^\n" + 
		"The resource fileReader of a try-with-resources statement cannot be assigned\n" + 
		"----------\n",
		null,
		true,
		options);
}
public static Class testClass() {
	return TryWithResourcesStatementTest.class;
}

Return to bug 349326

Added Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java (+165 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 GK Software AG and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Stephan Herrmann - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;
12
13	import java.util.HashMap;
14	import java.util.Iterator;
15	import java.util.Map;
16	import java.util.Map.Entry;
17
18	import org.eclipse.jdt.core.compiler.CharOperation;
19	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
20	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
21	import org.eclipse.jdt.internal.compiler.impl.Constant;
22	import org.eclipse.jdt.internal.compiler.lookup.Binding;
23	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
24	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
25	import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
26	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
27	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
28	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
29	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
30	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
31
32	/**
33	* A faked local variable declaration used for keeping track of data flows of a
34	* special variable. Certain events will be recorded by changing the null info
35	* for this variable.
36	*
37	* See bug 349326 - [1.7] new warning for missing try-with-resources
38	*/
39	public class FakedTrackingVariable extends LocalDeclaration {
40
41	/**
42	* If close() is invoked from a nested method (inside a local type)
43	* report remaining problems only as potential.
44	*/
45	public boolean closedInNestedMethod;
46
47	MethodScope methodScope; // designates the method declaring this variable
48
49	public LocalVariableBinding originalBinding; // the real local being tracked
50
51	HashMap recordedLocations; // initially null, ASTNode -> Integer
52
53	public FakedTrackingVariable(LocalVariableBinding original, Statement location) {
54	super(original.name, location.sourceStart, location.sourceEnd);
55	this.type = new SingleTypeReference(
56	TypeConstants.OBJECT,
57	((long)this.sourceStart <<32)+this.sourceEnd);
58	this.methodScope = original.declaringScope.methodScope();
59	this.originalBinding = original;
60	resolve(original.declaringScope);
61	}
62
63	public void generateCode(BlockScope currentScope, CodeStream codeStream)
64	{ /* NOP - this variable is completely dummy, ie. for analysis only. */ }
65
66	public void resolve (BlockScope scope) {
67	// only need the binding, which is used as reference in FlowInfo methods.
68	this.binding = new LocalVariableBinding(
69	this.name,
70	scope.getJavaLangObject(), // dummy, just needs to be a reference type
71	0,
72	false);
73	this.binding.setConstant(Constant.NotAConstant);
74	this.binding.useFlag = LocalVariableBinding.USED;
75	// use a free slot without assigning it:
76	this.binding.id = scope.registerTrackingVariable(this);
77	}
78
79	/**
80	* If expression resolves to a local variable binding of type AutoCloseable,
81	* answer the variable that tracks closing of that local, creating it if needed.
82	* @param expression
83	* @return a new {@link FakedTrackingVariable} or null.
84	*/
85	public static FakedTrackingVariable getCloseTrackingVariable(Expression expression) {
86	if (expression instanceof SingleNameReference) {
87	SingleNameReference name = (SingleNameReference) expression;
88	if (name.binding instanceof LocalVariableBinding) {
89	LocalVariableBinding local = (LocalVariableBinding)name.binding;
90	if (local.closeTracker != null)
91	return local.closeTracker;
92	if (local.isParameter() \|\| !isAutoCloseable(expression.resolvedType))
93	return null;
94	// tracking var doesn't yet exist. This happens in finally block
95	// which is analyzed before the corresponding try block
96	Statement location = local.declaration;
97	return local.closeTracker = new FakedTrackingVariable(local, location);
98	}
99	}
100	return null;
101	}
102
103	/** if 'invocationSite' is a call to close() that has a registered tracking variable, answer that variable's binding. */
104	public static LocalVariableBinding getTrackerForCloseCall(ASTNode invocationSite) {
105	if (invocationSite instanceof MessageSend) {
106	MessageSend send = (MessageSend) invocationSite;
107	if (CharOperation.equals(TypeConstants.CLOSE, send.selector) && send.receiver instanceof SingleNameReference) {
108	Binding receiverBinding = ((SingleNameReference)send.receiver).binding;
109	if (receiverBinding instanceof LocalVariableBinding) {
110	FakedTrackingVariable trackingVariable = ((LocalVariableBinding)receiverBinding).closeTracker;
111	if (trackingVariable != null)
112	return trackingVariable.binding;
113	}
114	}
115	}
116	return null;
117	}
118
119	public static FlowInfo markPotentialClosing(Expression expression, FlowInfo flowInfo) {
120	FakedTrackingVariable trackVar = getCloseTrackingVariable(expression);
121	if (trackVar != null) {
122	// insert info that the tracked resource may be closed (by the target method, i.e.)
123	FlowInfo infoResourceIsClosed = flowInfo.copy();
124	infoResourceIsClosed.markAsDefinitelyNonNull(trackVar.binding);
125	return FlowInfo.conditional(flowInfo, infoResourceIsClosed);
126	}
127	return flowInfo;
128	}
129
130	/** Answer wither the given type binding is a subtype of java.lang.AutoCloseable. */
131	public static boolean isAutoCloseable(TypeBinding typeBinding) {
132	return typeBinding instanceof ReferenceBinding
133	&& ((ReferenceBinding)typeBinding).hasTypeBit(TypeIds.BitAutoCloseable);
134	}
135
136	public void recordErrorLocation(ASTNode location, int nullStatus) {
137	if (this.recordedLocations == null)
138	this.recordedLocations = new HashMap();
139	this.recordedLocations.put(location, new Integer(nullStatus));
140	}
141
142	public boolean reportRecordedErrors(ProblemReporter problemReporter) {
143	boolean hasReported = false;
144	if (this.recordedLocations != null) {
145	Iterator locations = this.recordedLocations.entrySet().iterator();
146	while (locations.hasNext()) {
147	Map.Entry entry = (Entry) locations.next();
148	reportError(problemReporter, (ASTNode)entry.getKey(), ((Integer)entry.getValue()).intValue());
149	hasReported = true;
150	}
151	}
152	return hasReported;
153	}
154
155	public void reportError(ProblemReporter problemReporter, ASTNode location, int nullStatus) {
156	if (nullStatus == FlowInfo.NULL) {
157	if (this.closedInNestedMethod)
158	problemReporter.potentiallyUnclosedCloseable(this, location);
159	else
160	problemReporter.unclosedCloseable(this, location);
161	} else if (nullStatus == FlowInfo.POTENTIALLY_NULL) {
162	problemReporter.potentiallyUnclosedCloseable(this, location);
163	}
164	}
165	}

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" +