Attachment #202189 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
				if (flowInfo.isDefinitelyNull(trackerBinding)) 
					currentScope.problemReporter().unclosedCloseable(local.closeTracker, this);
				else if (flowInfo.isPotentiallyNull(trackerBinding)) 
					currentScope.problemReporter().potentiallyUnclosedCloseable(local.closeTracker, this);
			}
		}
		if (FakedTrackingVariable.isAutoCloseable(this.expression.resolvedType)) {
			if (local.closeTracker != null && local.closeTracker.isInsideTryWithResources) { 
				// re-assigning resource of try-with-resources is a different error
			} else {
				// new value is AutoCloseable, start tracking, possibly re-using existing tracker var:
				if (trackerBinding == null) {
					local.closeTracker = new FakedTrackingVariable(local, this);
					trackerBinding = local.closeTracker.binding;
				}
				flowInfo.markAsDefinitelyNull(trackerBinding);
// TODO(stephan): this might be useful, but I could not find a test case for it: 
//				if (flowContext.initsOnFinally != null)
//					flowContext.initsOnFinally.markAsDefinitelyNonNull(trackerBinding);
			}
		}
	}
	int nullStatus = this.expression.nullStatus(flowInfo);
	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
		if (nullStatus == FlowInfo.NULL) {

Lines 1-5 Link Here

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




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

import org.eclipse.jdt.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;

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

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

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

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

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

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

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

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

	/** 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);
	}
}

Lines 7-13 Link Here

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

Lines 11-16 Link Here

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

Lines 8-14 Link Here

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

Lines 7-12 Link Here

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

Lines 7-13 Link Here

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

Lines 7-13 Link Here

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

Lines 7-13 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TryStatement.java (-5 / +17 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	resourceBinding.closeTracker.isInsideTryWithResources = true;
		133	flowInfo.markAsDefinitelyNonNull(resourceBinding.closeTracker.binding); // all is well
		134	}
		135	TypeBinding type = resourceBinding.type;
129	if (type != null && type.isValidBinding()) {	136	if (type != null && type.isValidBinding()) {
130	ReferenceBinding binding = (ReferenceBinding) type;	137	ReferenceBinding binding = (ReferenceBinding) type;
131	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter	138	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++) {	257	for (int i = 0; i < resourcesLength; i++) {
251	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());	258	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());
252	this.postResourcesInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(flowInfo);	259	this.postResourcesInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(flowInfo);
253	this.resources[i].binding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.	260	LocalVariableBinding resourceBinding = this.resources[i].binding;
254	TypeBinding type = this.resources[i].binding.type;	261	resourceBinding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.
		262	if (resourceBinding.closeTracker != null) {
		263	resourceBinding.closeTracker.isInsideTryWithResources = true;
		264	flowInfo.markAsDefinitelyNonNull(resourceBinding.closeTracker.binding); // all is well
		265	}
		266	TypeBinding type = resourceBinding.type;
255	if (type != null && type.isValidBinding()) {	267	if (type != null && type.isValidBinding()) {
256	ReferenceBinding binding = (ReferenceBinding) type;	268	ReferenceBinding binding = (ReferenceBinding) type;
257	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter	269	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter




 *
 * 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 status = (flowContext != null) 
					? flowContext.getNullStatusAfter(local, flowInfo)
					: flowInfo.nullStatus(local);
	// 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 971-976 Link Here
971	variable.resolve();	972	variable.resolve();
972	return variable;	973	return variable;
973	}	974	}
		975	public boolean hasTypeBit(int bit) {
		976	// ensure hierarchy is resolved, which will propagate bits down to us
		977	superclass();
		978	superInterfaces();
		979	return (this.typeBits & bit) != 0;
		980	}
974	private void initializeTypeVariable(TypeVariableBinding variable, TypeVariableBinding[] existingVariables, SignatureWrapper wrapper, char[][][] missingTypeNames) {	981	private void initializeTypeVariable(TypeVariableBinding variable, TypeVariableBinding[] existingVariables, SignatureWrapper wrapper, char[][][] missingTypeNames) {
975	// ParameterSignature = Identifier ':' TypeSignature	982	// ParameterSignature = Identifier ':' TypeSignature
976	// or Identifier ':' TypeSignature(optional) InterfaceBound(s)	983	// or Identifier ':' TypeSignature(optional) InterfaceBound(s)
Lines 1139-1146 Link Here
1139	// finish resolving the type	1146	// finish resolving the type
1140	this.superclass = (ReferenceBinding) resolveType(this.superclass, this.environment, true /* raw conversion */);	1147	this.superclass = (ReferenceBinding) resolveType(this.superclass, this.environment, true /* raw conversion */);
1141	this.tagBits &= ~TagBits.HasUnresolvedSuperclass;	1148	this.tagBits &= ~TagBits.HasUnresolvedSuperclass;
1142	if (this.superclass.problemId() == ProblemReasons.NotFound)	1149	if (this.superclass.problemId() == ProblemReasons.NotFound) {
1143	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency	1150	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency
		1151	} else {
		1152	// make super-type resolving recursive for propagating typeBits downwards
		1153	this.superclass.superclass();
		1154	this.superclass.superInterfaces();
		1155	}
		1156	this.typeBits \|= this.superclass.typeBits;
1144	return this.superclass;	1157	return this.superclass;
1145	}	1158	}
1146	// NOTE: superInterfaces of binary types are resolved when needed	1159	// NOTE: superInterfaces of binary types are resolved when needed
Lines 1150-1157 Link Here
1150		1163
1151	for (int i = this.superInterfaces.length; --i >= 0;) {	1164	for (int i = this.superInterfaces.length; --i >= 0;) {
1152	this.superInterfaces[i] = (ReferenceBinding) resolveType(this.superInterfaces[i], this.environment, true /* raw conversion */);	1165	this.superInterfaces[i] = (ReferenceBinding) resolveType(this.superInterfaces[i], this.environment, true /* raw conversion */);
1153	if (this.superInterfaces[i].problemId() == ProblemReasons.NotFound)	1166	if (this.superInterfaces[i].problemId() == ProblemReasons.NotFound) {
1154	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency	1167	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency
		1168	} else {
		1169	// make super-type resolving recursive for propagating typeBits downwards
		1170	this.superInterfaces[i].superclass();
		1171	this.superInterfaces[i].superInterfaces();
		1172	}
		1173	this.typeBits \|= this.superInterfaces[i].typeBits;
1155	}	1174	}
1156	this.tagBits &= ~TagBits.HasUnresolvedSuperinterfaces;	1175	this.tagBits &= ~TagBits.HasUnresolvedSuperinterfaces;
1157	return this.superInterfaces;	1176	return this.superInterfaces;

Lines 7-19 Link Here

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




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


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

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

Lines 7-12 Link Here

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

Lines 7-12 Link Here

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

Lines 7-12 Link Here

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

Lines 7-12 Link Here

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

Lines 7-13 Link Here

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

Lines 7-12 Link Here

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

Lines 7-12 Link Here

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

Lines 1-5 Link Here

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

Lines 1-5 Link Here

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

Lines 1-5 Link Here

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




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


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

			
		case IProblem.MethodCanBePotentiallyStatic:
			return CompilerOptions.MethodCanBePotentiallyStatic;

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

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

			case CompilerOptions.MaskedCatchBlock :

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

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

Lines 8-14 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (-1 / +8 lines)
8	# Contributors:	8	# Contributors:
9	# IBM Corporation - initial API and implementation	9	# IBM Corporation - initial API and implementation
10	# Benjamin Muskalla - Contribution for bug 239066	10	# Benjamin Muskalla - Contribution for bug 239066
11	# Stephan Herrmann <stephan@cs.tu-berlin.de> - Contribution for bug 185682 - Increment/decrement operators mark local variables as read	11	# Stephan Herrmann <stephan@cs.tu-berlin.de> - Contributions for
		12	# bug 185682 - Increment/decrement operators mark local variables as read
		13	# bug 349326 - [1.7] new warning for missing try-with-resources
12	###############################################################################	14	###############################################################################
13	0 = {0}	15	0 = {0}
14	1 = super cannot be used in java.lang.Object	16	1 = super cannot be used in java.lang.Object
Lines 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;

		"	               ^^\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" +
			"    }\n" +
			"    public static void main(String[] args) throws IOException {\n" +
			"        new X().foo();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	fileReader = new FileReader(file);\n" + 
		"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Leaking resource \'fileReader\': is not closed at this location\n" + 
		"----------\n",
		null,
		true,
		options);
}
// Bug 349326 - [1.7] new warning for missing try-with-resources
// two AutoCloseables at different nesting levels (anonymous local type)
public void 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
// 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);
}
public static Class testClass() {
	return TryWithResourcesStatementTest.class;
}

Return to bug 349326

Added Link Here

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

Lines 8-16 Link Here

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

Lines 8-14 Link Here

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