Attachment #199385 for bug #349326




	int UnhandledExceptionOnAutoClose =  TypeRelated + 882;
	/** @since 3.7 */
	int DiamondNotBelow17 =  TypeRelated + 883;
	/** @since 3.7 */
	int PotentiallyUnclosedCloseable = Internal + 884;
	/** @since 3.7 */
	int PotentiallyUnclosedCloseableAtExit = Internal + 885;
	/** @since 3.7 */
	int UnclosedCloseable = Internal + 886;
	/** @since 3.7 */
	int UnclosedCloseableAtExit = Internal + 887;
	/** @since 3.7 */
	int ExplicitlyClosedAutoCloseable = Internal + 888;

	/**
	 * External problems -- These are problems defined by other plugins
	 */

Lines 43-48 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (+7 lines)
43	// process arguments	43	// process arguments
44	if (this.arguments != null) {	44	if (this.arguments != null) {
45	for (int i = 0, count = this.arguments.length; i < count; i++) {	45	for (int i = 0, count = this.arguments.length; i < count; i++) {
		46	FakedTrackingVariable trackVar = FakedTrackingVariable.getCloseTrackingVariable(this.arguments[i]);
		47	if (trackVar != null) {
		48	// insert info that the tracked resource may be closed (by the target method, i.e.)
		49	FlowInfo infoResourceIsClosed = flowInfo.copy();
		50	infoResourceIsClosed.markAsDefinitelyNonNull(trackVar.binding);
		51	flowInfo = FlowInfo.conditional(flowInfo, infoResourceIsClosed);
		52	}
46	flowInfo =	53	flowInfo =
47	this.arguments[i]	54	this.arguments[i]
48	.analyseCode(currentScope, flowContext, flowInfo)	55	.analyseCode(currentScope, flowContext, flowInfo)




	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);
			}
		}
	}
	int nullStatus = this.expression.nullStatus(flowInfo);
	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
		if (nullStatus == FlowInfo.NULL) {

Lines 36-41 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Block.java (+2 lines)
36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);	36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);
37	}	37	}
38	}	38	}
		39	if (this.explicitDeclarations > 0) // if block has its own scope analyze tracking vars now:
		40	this.scope.checkUnclosedCloseables(flowInfo, flowContext, null);
39	return flowInfo;	41	return flowInfo;
40	}	42	}
41	/**	43	/**




/*******************************************************************************
 * 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:
 *     GK Software AG - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;

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

/**
 * A faked local variable declaration used for keeping track of data flows of a
 * special variable. Certain events will be recorded by changing the null info
 * for this variable.
 * 
 * @author Stephan Herrmann
 */
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;
	}

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




	}
	if ((this.initialization.implicitConversion & TypeIds.UNBOXING) != 0) {
		this.initialization.checkNPE(currentScope, flowContext, flowInfo);
	}	
	
	flowInfo =
		this.initialization
			.analyseCode(currentScope, flowContext, flowInfo)
			.unconditionalInits();
	if (FakedTrackingVariable.isAutoCloseable(this.initialization.resolvedType)) {
		this.binding.closeTracker = new FakedTrackingVariable(this.binding, this);
		flowInfo.markAsDefinitelyNull(this.binding.closeTracker.binding);
	}
	int nullStatus = this.initialization.nullStatus(flowInfo);
	if (!flowInfo.isDefinitelyAssigned(this.binding)){// for local variable debug attributes
		this.bits |= FirstAssignmentToLocal;




import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;


public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
	boolean nonStatic = !this.binding.isStatic();
	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic).unconditionalInits();
	// recording the closing of AutoCloseable resources:
	if (CharOperation.equals(TypeConstants.CLOSE, this.selector)) 
	{
		FakedTrackingVariable trackingVariable = FakedTrackingVariable.getCloseTrackingVariable(this.receiver);
		if (trackingVariable != null) { // null happens if receiver is not a local variable or not an AutoCloseable
			if (trackingVariable.methodScope == currentScope.methodScope()) {
				flowInfo.markAsDefinitelyNonNull(trackingVariable.binding);
				if (flowContext.initsOnFinally != null)
					flowContext.initsOnFinally.markAsDefinitelyNonNull(trackingVariable.binding);
			} else {
				trackingVariable.closedInNestedMethod = true;
			}
		}
	}
	if (nonStatic) {
		this.receiver.checkNPE(currentScope, flowContext, flowInfo);
		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682

			if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {
				this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);
			}
			FakedTrackingVariable trackVar = FakedTrackingVariable.getCloseTrackingVariable(this.arguments[i]);
			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);
				flowInfo = FlowInfo.conditional(flowInfo, infoResourceIsClosed);
			}
			flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
		}
	}

Lines 134-139 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MethodDeclaration.java (+1 lines)
134	}	134	}
135		135
136	}	136	}
		137	this.scope.checkUnclosedCloseables(flowInfo, methodContext, null);
137	} catch (AbortMethod e) {	138	} catch (AbortMethod e) {
138	this.ignoreFurtherInvestigation = true;	139	this.ignoreFurtherInvestigation = true;
139	}	140	}

Lines 76-81 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (+7 lines)
76	// process arguments	76	// process arguments
77	if (this.arguments != null) {	77	if (this.arguments != null) {
78	for (int i = 0, count = this.arguments.length; i < count; i++) {	78	for (int i = 0, count = this.arguments.length; i < count; i++) {
		79	FakedTrackingVariable trackVar = FakedTrackingVariable.getCloseTrackingVariable(this.arguments[i]);
		80	if (trackVar != null) {
		81	// insert info that the tracked resource may be closed (by the target method, i.e.)
		82	FlowInfo infoResourceIsClosed = flowInfo.copy();
		83	infoResourceIsClosed.markAsDefinitelyNonNull(trackVar.binding);
		84	flowInfo = FlowInfo.conditional(flowInfo, infoResourceIsClosed);
		85	}
79	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo);	86	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo);
80	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {	87	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {
81	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	88	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);

Lines 40-45 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java (+8 lines)
40	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {	40	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
41	this.expression.checkNPE(currentScope, flowContext, flowInfo);	41	this.expression.checkNPE(currentScope, flowContext, flowInfo);
42	}	42	}
		43	FakedTrackingVariable trackingVariable = FakedTrackingVariable.getCloseTrackingVariable(this.expression);
		44	if (trackingVariable != null) {
		45	// don't report issues concerning this local, since by returning
		46	// the method passes the responsibility to the caller:
		47	flowInfo.markAsDefinitelyNonNull(trackingVariable.binding);
		48	trackingVariable.hasReportedProblem = true;
		49	}
43	}	50	}
44	this.initStateIndex =	51	this.initStateIndex =
45	currentScope.methodScope().recordInitializationStates(flowInfo);	52	currentScope.methodScope().recordInitializationStates(flowInfo);
Lines 104-109 Link Here
104	this.expression.bits \|= ASTNode.IsReturnedValue;	111	this.expression.bits \|= ASTNode.IsReturnedValue;
105	}	112	}
106	}	113	}
		114	currentScope.checkUnclosedCloseables(flowInfo, null/ignore exception exits from flowContext/, this);
107	return FlowInfo.DEAD_END;	115	return FlowInfo.DEAD_END;
108	}	116	}
109		117

Lines 15-20 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TryStatement.java (-4 / +25 lines)
15	*******************************************************************************/	15	*******************************************************************************/
16	package org.eclipse.jdt.internal.compiler.ast;	16	package org.eclipse.jdt.internal.compiler.ast;
17		17
		18	import java.util.ArrayList;
		19	import java.util.List;
		20
18	import org.eclipse.jdt.core.compiler.CharOperation;	21	import org.eclipse.jdt.core.compiler.CharOperation;
19	import org.eclipse.jdt.internal.compiler.ASTVisitor;	22	import org.eclipse.jdt.internal.compiler.ASTVisitor;
20	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	23	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
Lines 120-127 Link Here
120		123
121	for (int i = 0, max = this.resources.length; i < max; i++) {	124	for (int i = 0, max = this.resources.length; i < max; i++) {
122	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());	125	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());
123	this.resources[i].binding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.	126	LocalVariableBinding resourceBinding = this.resources[i].binding;
124	TypeBinding type = this.resources[i].binding.type;	127	resourceBinding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.
		128	if (resourceBinding.closeTracker != null) {
		129	resourceBinding.closeTracker.isInsideTryWithResources = true;
		130	flowInfo.markAsDefinitelyNonNull(resourceBinding.closeTracker.binding);
		131	}
		132	TypeBinding type = resourceBinding.type;
125	if (type != null && type.isValidBinding()) {	133	if (type != null && type.isValidBinding()) {
126	ReferenceBinding binding = (ReferenceBinding) type;	134	ReferenceBinding binding = (ReferenceBinding) type;
127	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter	135	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter
Lines 227-232 Link Here
227	this.scope.problemReporter().finallyMustCompleteNormally(this.finallyBlock);	235	this.scope.problemReporter().finallyMustCompleteNormally(this.finallyBlock);
228	}	236	}
229	this.subRoutineInits = subInfo;	237	this.subRoutineInits = subInfo;
		238
230	// process the try block in a context handling the local exceptions.	239	// process the try block in a context handling the local exceptions.
231	ExceptionHandlingFlowContext handlingContext =	240	ExceptionHandlingFlowContext handlingContext =
232	new ExceptionHandlingFlowContext(	241	new ExceptionHandlingFlowContext(
Lines 245-252 Link Here
245		254
246	for (int i = 0, max = this.resources.length; i < max; i++) {	255	for (int i = 0, max = this.resources.length; i < max; i++) {
247	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());	256	flowInfo = this.resources[i].analyseCode(currentScope, handlingContext, flowInfo.copy());
248	this.resources[i].binding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.	257	LocalVariableBinding resourceBinding = this.resources[i].binding;
249	TypeBinding type = this.resources[i].binding.type;	258	resourceBinding.useFlag = LocalVariableBinding.USED; // Is implicitly used anyways.
		259	if (resourceBinding.closeTracker != null) {
		260	resourceBinding.closeTracker.isInsideTryWithResources = true;
		261	flowInfo.markAsDefinitelyNonNull(resourceBinding.closeTracker.binding);
		262	}
		263	TypeBinding type = resourceBinding.type;
250	if (type != null && type.isValidBinding()) {	264	if (type != null && type.isValidBinding()) {
251	ReferenceBinding binding = (ReferenceBinding) type;	265	ReferenceBinding binding = (ReferenceBinding) type;
252	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter	266	MethodBinding closeMethod = binding.getExactMethod(ConstantPool.Close, new TypeBinding [0], this.scope.compilationUnitScope()); // scope needs to be tighter
Lines 267-272 Link Here
267	this.bits \|= ASTNode.IsTryBlockExiting;	281	this.bits \|= ASTNode.IsTryBlockExiting;
268	}	282	}
269		283
		284	// superimpose status for tracking variables:
		285	// don't complain on initsOnException if finally has a better state.
		286	List moreTrackVars = new ArrayList();
		287	long trackVarsMask = currentScope.getTrackVars(moreTrackVars, subInfo);
		288	if (trackVarsMask != 0 \|\| moreTrackVars.size() > 0)
		289	flowContext.replaceNullInfoForExceptionExits(trackVarsMask, moreTrackVars, subInfo);
		290
270	// check unreachable catch blocks	291	// check unreachable catch blocks
271	handlingContext.complainIfUnusedExceptionHandlers(this.scope, this);	292	handlingContext.complainIfUnusedExceptionHandlers(this.scope, this);
272		293




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

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

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

	return node;
}

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

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

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

Lines 15-23 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/FlowContext.java (-1 / +58 lines)
15	package org.eclipse.jdt.internal.compiler.flow;	15	package org.eclipse.jdt.internal.compiler.flow;
16		16
17	import java.util.ArrayList;	17	import java.util.ArrayList;
		18	import java.util.List;
		19
18	import org.eclipse.jdt.core.compiler.CharOperation;	20	import org.eclipse.jdt.core.compiler.CharOperation;
19	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
20	import org.eclipse.jdt.internal.compiler.ast.ASTNode;	21	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
		22	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
21	import org.eclipse.jdt.internal.compiler.ast.Expression;	23	import org.eclipse.jdt.internal.compiler.ast.Expression;
22	import org.eclipse.jdt.internal.compiler.ast.LabeledStatement;	24	import org.eclipse.jdt.internal.compiler.ast.LabeledStatement;
23	import org.eclipse.jdt.internal.compiler.ast.Reference;	25	import org.eclipse.jdt.internal.compiler.ast.Reference;
Lines 395-400 Link Here
395	return null;	397	return null;
396	}	398	}
397		399
		400	/**
		401	* Answer the combined null status that local will have after this flow context.
		402	* Subclasses will respect break and exception exits.
		403	*/
		404	public int getNullStatusAfter(LocalVariableBinding local, FlowInfo flowInfo) {
		405	return flowInfo.nullStatus(local);
		406	}
		407
398	/*	408	/*
399	* lookup through break labels	409	* lookup through break labels
400	*/	410	*/
Lines 736-739 Link Here
736	buffer.append(individualToString()).append('\n');	746	buffer.append(individualToString()).append('\n');
737	return buffer.toString();	747	return buffer.toString();
738	}	748	}
		749	/**
		750	* For all tracking variables as identified by the given mask plus the given list
		751	* replace the null info in initsOnException (if existent) with those given in finallyInfo.
		752	*/
		753	public void replaceNullInfoForExceptionExits(long trackVarsMask, List moreTrackVars, FlowInfo flowInfo) {
		754	// nothing here, overridden in ExceptionHandlingFlowContext
		755	}
		756
		757	/**
		758	* Get the null status that local will have after the current point as indicated by flowInfo and flowContext
		759	* @param local
		760	* @param flowInfo
		761	* @param flowContext may be null
		762	* @return a bitset from the constants FlowInfo.{NULL,POTENTIALLY_NULL,POTENTIALLY_NON_NULL,NON_NULL}.
		763	*/
		764	public static int getNullStatusAfter(LocalVariableBinding local, FlowInfo flowInfo, FlowContext flowContext) {
		765	int NULL_MASK = FlowInfo.NULL \| FlowInfo.POTENTIALLY_NULL \| FlowInfo.POTENTIALLY_NON_NULL;
		766	int status = 0;
		767	if (flowContext != null) {
		768	// if we have info for finally use that:
		769	NullInfoRegistry finallyInfo = flowContext.initsOnFinally;
		770	if (finallyInfo != null) {
		771	int finallyStatus = finallyInfo.nullStatus(local);
		772	if ((finallyStatus & NULL_MASK) != 0)
		773	return mergeNullStatus(finallyStatus);
		774	}
		775	status = flowContext.getNullStatusAfter(local, flowInfo);
		776	} else {
		777	status = flowInfo.nullStatus(local);
		778	}
		779	return mergeNullStatus(status);
		780	}
		781
		782	/** Merge the bits NULL, NON_NULL, POTENTIALLY_NULL, POTENTIALLY_NON_NULL to a one-bit answer. */
		783	protected static int mergeNullStatus(int status) {
		784	if ((status & FlowInfo.NULL) != 0) {
		785	if ((status & (FlowInfo.NON_NULL \| FlowInfo.POTENTIALLY_NON_NULL)) != 0)
		786	return FlowInfo.POTENTIALLY_NULL; // null + doubt = pot null
		787	return FlowInfo.NULL;
		788	} else if ((status & FlowInfo.NON_NULL) != 0) {
		789	if ((status & FlowInfo.POTENTIALLY_NULL) != 0)
		790	return FlowInfo.POTENTIALLY_NULL; // non-null + doubt = pot null
		791	return FlowInfo.NON_NULL;
		792	} else if ((status & FlowInfo.POTENTIALLY_NON_NULL) != 0)
		793	return FlowInfo.POTENTIALLY_NON_NULL;
		794	return status;
		795	}
739	}	796	}





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);
	// merge collected info:
	return mergeNullStatus(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$




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

	}
	return count;
}
/** Replace the null info for all variables in mask by values from otherInfo. */
public void replaceNullInfo(long mask, UnconditionalFlowInfo otherInfo) {
	this.nullBit1 &= ~mask;
	this.nullBit1 |= (otherInfo.nullBit1 & mask);
	this.nullBit2 &= ~mask;
	this.nullBit2 |= (otherInfo.nullBit2 & mask);
	this.nullBit3 &= ~mask;
	this.nullBit3 |= (otherInfo.nullBit3 & mask);
	this.nullBit4 &= ~mask;
	this.nullBit4 |= (otherInfo.nullBit4 & mask);
}
public UnconditionalFlowInfo nullInfoLessUnconditionalCopy() {
	if (this == DEAD_END) {
		return this;

Lines 136-141 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java (+21 lines)
136	public static final String OPTION_IncludeNullInfoFromAsserts = "org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"; //$NON-NLS-1$	136	public static final String OPTION_IncludeNullInfoFromAsserts = "org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"; //$NON-NLS-1$
137	public static final String OPTION_ReportMethodCanBeStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"; //$NON-NLS-1$	137	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$	138	public static final String OPTION_ReportMethodCanBePotentiallyStatic = "org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$
		139	public static final String OPTION_ReportUnclosedCloseable = "org.eclipse.jdt.core.compiler.problem.unclosedCloseable"; //$NON-NLS-1$
		140	public static final String OPTION_ReportPotentiallyUnclosedCloseable = "org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable"; //$NON-NLS-1$
		141	public static final String OPTION_ReportExplicitlyClosedAutoCloseable = "org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable"; //$NON-NLS-1$
139	/**	142	/**
140	* Possible values for configurable options	143	* Possible values for configurable options
141	*/	144	*/
Lines 238-243 Link Here
238	public static final int UnusedObjectAllocation = IrritantSet.GROUP2 \| ASTNode.Bit4;	241	public static final int UnusedObjectAllocation = IrritantSet.GROUP2 \| ASTNode.Bit4;
239	public static final int MethodCanBeStatic = IrritantSet.GROUP2 \| ASTNode.Bit5;	242	public static final int MethodCanBeStatic = IrritantSet.GROUP2 \| ASTNode.Bit5;
240	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 \| ASTNode.Bit6;	243	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 \| ASTNode.Bit6;
		244	public static final int UnclosedCloseable = IrritantSet.GROUP2 \| ASTNode.Bit7;
		245	public static final int PotentiallyUnclosedCloseable = IrritantSet.GROUP2 \| ASTNode.Bit8;
		246	public static final int ExplicitlyClosedAutoCloseable = IrritantSet.GROUP2 \| ASTNode.Bit9;
241		247
242	// Severity level for handlers	248	// Severity level for handlers
243	/**	249	/**
Lines 547-552 Link Here
547	return OPTION_ReportMethodCanBeStatic;	553	return OPTION_ReportMethodCanBeStatic;
548	case MethodCanBePotentiallyStatic :	554	case MethodCanBePotentiallyStatic :
549	return OPTION_ReportMethodCanBePotentiallyStatic;	555	return OPTION_ReportMethodCanBePotentiallyStatic;
		556	case UnclosedCloseable :
		557	return OPTION_ReportUnclosedCloseable;
		558	case PotentiallyUnclosedCloseable :
		559	return OPTION_ReportPotentiallyUnclosedCloseable;
		560	case ExplicitlyClosedAutoCloseable :
		561	return OPTION_ReportExplicitlyClosedAutoCloseable;
550	}	562	}
551	return null;	563	return null;
552	}	564	}
Lines 709-714 Link Here
709	OPTION_ReportUnusedTypeArgumentsForMethodInvocation,	721	OPTION_ReportUnusedTypeArgumentsForMethodInvocation,
710	OPTION_ReportUnusedWarningToken,	722	OPTION_ReportUnusedWarningToken,
711	OPTION_ReportVarargsArgumentNeedCast,	723	OPTION_ReportVarargsArgumentNeedCast,
		724	OPTION_ReportUnclosedCloseable,
		725	OPTION_ReportPotentiallyUnclosedCloseable,
		726	OPTION_ReportExplicitlyClosedAutoCloseable,
712	};	727	};
713	return result;	728	return result;
714	}	729	}
Lines 973-978 Link Here
973	optionsMap.put(OPTION_IncludeNullInfoFromAsserts, this.includeNullInfoFromAsserts ? ENABLED : DISABLED);	988	optionsMap.put(OPTION_IncludeNullInfoFromAsserts, this.includeNullInfoFromAsserts ? ENABLED : DISABLED);
974	optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic));	989	optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic));
975	optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic));	990	optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic));
		991	optionsMap.put(OPTION_ReportUnclosedCloseable, getSeverityString(UnclosedCloseable));
		992	optionsMap.put(OPTION_ReportPotentiallyUnclosedCloseable, getSeverityString(PotentiallyUnclosedCloseable));
		993	optionsMap.put(OPTION_ReportExplicitlyClosedAutoCloseable, getSeverityString(ExplicitlyClosedAutoCloseable));
976	return optionsMap;	994	return optionsMap;
977	}	995	}
978		996
Lines 1402-1407 Link Here
1402	if ((optionValue = optionsMap.get(OPTION_ReportUnusedObjectAllocation)) != null) updateSeverity(UnusedObjectAllocation, optionValue);	1420	if ((optionValue = optionsMap.get(OPTION_ReportUnusedObjectAllocation)) != null) updateSeverity(UnusedObjectAllocation, optionValue);
1403	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBeStatic)) != null) updateSeverity(MethodCanBeStatic, optionValue);	1421	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBeStatic)) != null) updateSeverity(MethodCanBeStatic, optionValue);
1404	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBePotentiallyStatic)) != null) updateSeverity(MethodCanBePotentiallyStatic, optionValue);	1422	if ((optionValue = optionsMap.get(OPTION_ReportMethodCanBePotentiallyStatic)) != null) updateSeverity(MethodCanBePotentiallyStatic, optionValue);
		1423	if ((optionValue = optionsMap.get(OPTION_ReportUnclosedCloseable)) != null) updateSeverity(UnclosedCloseable, optionValue);
		1424	if ((optionValue = optionsMap.get(OPTION_ReportPotentiallyUnclosedCloseable)) != null) updateSeverity(PotentiallyUnclosedCloseable, optionValue);
		1425	if ((optionValue = optionsMap.get(OPTION_ReportExplicitlyClosedAutoCloseable)) != null) updateSeverity(ExplicitlyClosedAutoCloseable, optionValue);
1405		1426
1406	// Javadoc options	1427	// Javadoc options
1407	if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {	1428	if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {

Lines 99-105 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java (-1 / +2 lines)
99	// group-2 warnings enabled by default	99	// group-2 warnings enabled by default
100	.set(	100	.set(
101	CompilerOptions.DeadCode	101	CompilerOptions.DeadCode
102	\|CompilerOptions.Tasks);	102	\|CompilerOptions.Tasks
		103	\|CompilerOptions.UnclosedCloseable);
103		104
104	ALL.setAll();	105	ALL.setAll();
105	HIDING	106	HIDING

Lines 971-976 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java (-2 / +18 lines)
971	variable.resolve();	971	variable.resolve();
972	return variable;	972	return variable;
973	}	973	}
		974	public boolean hasTypeBit(int bit) {
		975	// ensure hierarchy is resolved
		976	superclass();
		977	superInterfaces();
		978	return (this.typeBits & bit) != 0;
		979	}
974	private void initializeTypeVariable(TypeVariableBinding variable, TypeVariableBinding[] existingVariables, SignatureWrapper wrapper, char[][][] missingTypeNames) {	980	private void initializeTypeVariable(TypeVariableBinding variable, TypeVariableBinding[] existingVariables, SignatureWrapper wrapper, char[][][] missingTypeNames) {
975	// ParameterSignature = Identifier ':' TypeSignature	981	// ParameterSignature = Identifier ':' TypeSignature
976	// or Identifier ':' TypeSignature(optional) InterfaceBound(s)	982	// or Identifier ':' TypeSignature(optional) InterfaceBound(s)
Lines 1139-1146 Link Here
1139	// finish resolving the type	1145	// finish resolving the type
1140	this.superclass = (ReferenceBinding) resolveType(this.superclass, this.environment, true /* raw conversion */);	1146	this.superclass = (ReferenceBinding) resolveType(this.superclass, this.environment, true /* raw conversion */);
1141	this.tagBits &= ~TagBits.HasUnresolvedSuperclass;	1147	this.tagBits &= ~TagBits.HasUnresolvedSuperclass;
1142	if (this.superclass.problemId() == ProblemReasons.NotFound)	1148	if (this.superclass.problemId() == ProblemReasons.NotFound) {
1143	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency	1149	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency
		1150	} else {
		1151	this.superclass.superclass();
		1152	this.superclass.superInterfaces();
		1153	}
		1154	this.typeBits \|= this.superclass.typeBits;
1144	return this.superclass;	1155	return this.superclass;
1145	}	1156	}
1146	// NOTE: superInterfaces of binary types are resolved when needed	1157	// NOTE: superInterfaces of binary types are resolved when needed
Lines 1150-1157 Link Here
1150		1161
1151	for (int i = this.superInterfaces.length; --i >= 0;) {	1162	for (int i = this.superInterfaces.length; --i >= 0;) {
1152	this.superInterfaces[i] = (ReferenceBinding) resolveType(this.superInterfaces[i], this.environment, true /* raw conversion */);	1163	this.superInterfaces[i] = (ReferenceBinding) resolveType(this.superInterfaces[i], this.environment, true /* raw conversion */);
1153	if (this.superInterfaces[i].problemId() == ProblemReasons.NotFound)	1164	if (this.superInterfaces[i].problemId() == ProblemReasons.NotFound) {
1154	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency	1165	this.tagBits \|= TagBits.HierarchyHasProblems; // propagate type inconsistency
		1166	} else {
		1167	this.superInterfaces[i].superclass();
		1168	this.superInterfaces[i].superInterfaces();
		1169	}
		1170	this.typeBits \|= this.superInterfaces[i].typeBits;
1155	}	1171	}
1156	this.tagBits &= ~TagBits.HasUnresolvedSuperinterfaces;	1172	this.tagBits &= ~TagBits.HasUnresolvedSuperinterfaces;
1157	return this.superInterfaces;	1173	return this.superInterfaces;

Lines 10-19 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java (+62 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	11	package org.eclipse.jdt.internal.compiler.lookup;
12		12
		13	import java.util.ArrayList;
		14	import java.util.List;
		15
13	import org.eclipse.jdt.core.compiler.CharOperation;	16	import org.eclipse.jdt.core.compiler.CharOperation;
14	import org.eclipse.jdt.internal.compiler.ast.*;	17	import org.eclipse.jdt.internal.compiler.ast.*;
15	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	18	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;	19	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
		20	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
		21	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
17	import org.eclipse.jdt.internal.compiler.impl.Constant;	22	import org.eclipse.jdt.internal.compiler.impl.Constant;
18	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;	23	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
19		24
Lines 957-960 Link Here
957	}	962	}
958	}	963	}
959	}	964	}
		965
		966	private List trackingVariables;
		967	public int registerTrackingVariable(FakedTrackingVariable fakedTrackingVariable) {
		968	if (this.trackingVariables == null)
		969	this.trackingVariables = new ArrayList();
		970	this.trackingVariables.add(fakedTrackingVariable);
		971	MethodScope outerMethodScope = outerMostMethodScope();
		972	return outerMethodScope.analysisIndex + (++outerMethodScope.trackVarCount);
		973
		974	}
		975	public void checkUnclosedCloseables(FlowInfo flowInfo, FlowContext flowContext, ASTNode location) {
		976	if (this.trackingVariables == null) return;
		977	for (int i=0; i<this.trackingVariables.size(); i++) {
		978	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
		979	if (trackingVar.hasReportedProblem)
		980	continue;
		981	if (trackingVar.originalBinding != null && flowInfo.isDefinitelyNull(trackingVar.originalBinding))
		982	continue; // resource is null at this flow, don't complain
		983	int status = FlowContext.getNullStatusAfter(trackingVar.binding, flowInfo, flowContext);
		984	if (status == FlowInfo.NULL) {
		985	if (trackingVar.closedInNestedMethod)
		986	problemReporter().potentiallyUnclosedCloseable(trackingVar, location);
		987	else
		988	problemReporter().unclosedCloseable(trackingVar, location);
		989	} else if (status != FlowInfo.NON_NULL) {
		990	problemReporter().potentiallyUnclosedCloseable(trackingVar, location);
		991	} else { // status == FlowInfo.NON_NULL
		992	if (environment().globalOptions.complianceLevel >= ClassFileConstants.JDK1_7
		993	&& !trackingVar.isInsideTryWithResources)
		994	problemReporter().explicitlyClosedAutoCloseable(trackingVar);
		995	}
		996	}
		997	}
		998	/**
		999	* Find all tracking variables in scope that have relevant null status.
		1000	* Answer a mask of ids for those vars with id < 64 and store those
		1001	* with a high id in the given list.
		1002	* @param moreTrackVars list for collecting tracking variables with high id
		1003	* @param flowInfo
		1004	* @return a bitset of variable ids
		1005	*/
		1006	public long getTrackVars(List moreTrackVars, FlowInfo flowInfo) {
		1007	if (this.trackingVariables == null) return 0;
		1008	long mask = 0;
		1009	for (int i=0; i<this.trackingVariables.size(); i++) {
		1010	FakedTrackingVariable trackingVar = (FakedTrackingVariable) this.trackingVariables.get(i);
		1011	if (flowInfo.nullStatus(trackingVar.binding) == FlowInfo.UNKNOWN)
		1012	continue;
		1013	if (trackingVar.binding.id < 64)
		1014	mask \|= (1 << trackingVar.binding.id);
		1015	else
		1016	moreTrackVars.add(trackingVar);
		1017	}
		1018	if (this.parent instanceof BlockScope)
		1019	mask \|= ((BlockScope) this.parent).getTrackVars(moreTrackVars, flowInfo);
		1020	return mask;
		1021	}
960	}	1022	}

Lines 907-912 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java (+2 lines)
907	} else {	907	} else {
908	// only want to reach here when no errors are reported	908	// only want to reach here when no errors are reported
909	sourceType.superclass = superclass;	909	sourceType.superclass = superclass;
		910	sourceType.typeBits \|= superclass.typeBits;
910	return true;	911	return true;
911	}	912	}
912	}	913	}
Lines 1017-1022 Link Here
1017	noProblems &= superInterfaceRef.resolvedType.isValidBinding();	1018	noProblems &= superInterfaceRef.resolvedType.isValidBinding();
1018	}	1019	}
1019	// only want to reach here when no errors are reported	1020	// only want to reach here when no errors are reported
		1021	sourceType.typeBits \|= superInterface.typeBits;
1020	interfaceBindings[count++] = superInterface;	1022	interfaceBindings[count++] = superInterface;
1021	}	1023	}
1022	// hold onto all correctly resolved superinterfaces	1024	// hold onto all correctly resolved superinterfaces

Lines 49-54 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodScope.java (+3 lines)
49	// inner-emulation	49	// inner-emulation
50	public SyntheticArgumentBinding[] extraSyntheticArguments;	50	public SyntheticArgumentBinding[] extraSyntheticArguments;
51		51
		52	// count number of tracking variables, see FakedTrackingVariable
		53	int trackVarCount;
		54
52	public MethodScope(ClassScope parent, ReferenceContext context, boolean isStatic) {	55	public MethodScope(ClassScope parent, ReferenceContext context, boolean isStatic) {
53	super(METHOD_SCOPE, parent);	56	super(METHOD_SCOPE, parent);
54	this.locals = new LocalVariableBinding[5];	57	this.locals = new LocalVariableBinding[5];

Lines 629-634 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java (+7 lines)
629	return this.type.hasMemberTypes();	629	return this.type.hasMemberTypes();
630	}	630	}
631		631
		632	public boolean hasTypeBit(int bit) {
		633	TypeBinding erasure = erasure();
		634	if (erasure instanceof ReferenceBinding)
		635	return ((ReferenceBinding) erasure).hasTypeBit(bit);
		636	return false;
		637	}
		638
632	/**	639	/**
633	* @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#implementsMethod(MethodBinding)	640	* @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#implementsMethod(MethodBinding)
634	*/	641	*/

Lines 40-45 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ProblemReferenceBinding.java (+6 lines)
40	return this.closestMatch;	40	return this.closestMatch;
41	}	41	}
42		42
		43	public boolean hasTypeBit(int bit) {
		44	if (this.closestMatch != null)
		45	return this.closestMatch.hasTypeBit(bit);
		46	return false;
		47	}
		48
43	/* API	49	/* API
44	* Answer the problem id associated with the receiver.	50	* Answer the problem id associated with the receiver.
45	* NoError if the receiver is a valid binding.	51	* NoError if the receiver is a valid binding.

Lines 17-22 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java (-1 / +12 lines)
17	import java.util.Arrays;	17	import java.util.Arrays;
18	import java.util.Comparator;	18	import java.util.Comparator;
19		19
		20	import org.eclipse.core.runtime.Assert;
20	import org.eclipse.jdt.core.compiler.CharOperation;	21	import org.eclipse.jdt.core.compiler.CharOperation;
21	import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;	22	import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
22	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	23	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
Lines 45-50 Link Here
45		46
46	private SimpleLookupTable compatibleCache;	47	private SimpleLookupTable compatibleCache;
47		48
		49	int typeBits;
		50
48	public static final ReferenceBinding LUB_GENERIC = new ReferenceBinding() { /* used for lub computation */};	51	public static final ReferenceBinding LUB_GENERIC = new ReferenceBinding() { /* used for lub computation */};
49		52
50	private static final Comparator FIELD_COMPARATOR = new Comparator() {	53	private static final Comparator FIELD_COMPARATOR = new Comparator() {
Lines 428-435 Link Here
428	case 'A' :	431	case 'A' :
429	switch(typeName.length) {	432	switch(typeName.length) {
430	case 13 :	433	case 13 :
431	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2]))	434	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2])) {
432	this.id = TypeIds.T_JavaLangAutoCloseable;	435	this.id = TypeIds.T_JavaLangAutoCloseable;
		436	this.typeBits \|= TypeIds.BitAutoCloseable;
		437	}
433	return;	438	return;
434	case 14:	439	case 14:
435	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))	440	if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))
Lines 928-933 Link Here
928	return (this.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0;	933	return (this.modifiers & ExtraCompilerModifiers.AccRestrictedAccess) != 0;
929	}	934	}
930		935
		936	public boolean hasTypeBit(int bit) {
		937	// overridden in relevant subclasses
		938	Assert.isTrue(false, "Unsupported query for type "+getClass().getName()); //$NON-NLS-1$
		939	return false; // never reached
		940	}
		941
931	/** Answer true if the receiver implements anInterface or is identical to anInterface.	942	/** Answer true if the receiver implements anInterface or is identical to anInterface.
932	* If searchHierarchy is true, then also search the receiver's superclasses.	943	* If searchHierarchy is true, then also search the receiver's superclasses.
933	*	944	*

Lines 18-23 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java (+8 lines)
18	import java.util.HashMap;	18	import java.util.HashMap;
19	import java.util.Iterator;	19	import java.util.Iterator;
20		20
		21	import org.eclipse.core.runtime.Assert;
21	import org.eclipse.jdt.core.compiler.CharOperation;	22	import org.eclipse.jdt.core.compiler.CharOperation;
22	import org.eclipse.jdt.internal.compiler.ast.ASTNode;	23	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
23	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;	24	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
Lines 1066-1071 Link Here
1066	return accessors[1];	1067	return accessors[1];
1067	}	1068	}
1068		1069
		1070	public boolean hasTypeBit(int bit) {
		1071	// source types initialize type bits during connectSuperclass/interfaces()
		1072	if (!isLocalType())
		1073	Assert.isTrue((this.tagBits & TagBits.EndHierarchyCheck) != 0, "Hierarchy should be connected"); //$NON-NLS-1$
		1074	return (this.typeBits & bit) != 0;
		1075	}
		1076
1069	/**	1077	/**
1070	* @see org.eclipse.jdt.internal.compiler.lookup.Binding#initializeDeprecatedAnnotationTagBits()	1078	* @see org.eclipse.jdt.internal.compiler.lookup.Binding#initializeDeprecatedAnnotationTagBits()
1071	*/	1079	*/

Lines 154-159 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeConstants.java (+1 lines)
154	"MethodHandle$PolymorphicSignature".toCharArray() //$NON-NLS-1$	154	"MethodHandle$PolymorphicSignature".toCharArray() //$NON-NLS-1$
155	};	155	};
156	char[][] JAVA_LANG_AUTOCLOSEABLE = {JAVA, LANG, "AutoCloseable".toCharArray()}; //$NON-NLS-1$	156	char[][] JAVA_LANG_AUTOCLOSEABLE = {JAVA, LANG, "AutoCloseable".toCharArray()}; //$NON-NLS-1$
		157	char[] CLOSE = "close".toCharArray(); //$NON-NLS-1$
157		158
158	// Constraints for generic type argument inference	159	// Constraints for generic type argument inference
159	int CONSTRAINT_EQUAL = 0; // Actual = Formal	160	int CONSTRAINT_EQUAL = 0; // Actual = Formal

Lines 173-176 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeIds.java (+2 lines)
173	final int Object2Object = T_JavaLangObject + (T_JavaLangObject << 4);	173	final int Object2Object = T_JavaLangObject + (T_JavaLangObject << 4);
174	final int BOXING = 0x200;	174	final int BOXING = 0x200;
175	final int UNBOXING = 0x400;	175	final int UNBOXING = 0x400;
		176
		177	final int BitAutoCloseable = 1;
176	}	178	}




		this.modifiers = ClassFileConstants.AccPublic | ExtraCompilerModifiers.AccGenericSignature; // treat type var as public
		this.tagBits |= TagBits.HasTypeVariable;
		this.environment = environment;
		this.typeBits = -1;
	}

	/**

		return true;
	}

	public boolean hasTypeBit(int bit) {
		if (this.typeBits == -1) {
			// initialize from bounds
			this.typeBits = 0;
			if (this.superclass != null)
				this.typeBits |= this.superclass.typeBits;
			if (this.superInterfaces != null)
				for (int i = 0, l = this.superInterfaces.length; i < l; i++)
					this.typeBits |= this.superInterfaces[i].typeBits;
		}
		return (this.typeBits & bit) != 0;
	}

	/**
	 * Returns true if the type variable is directly bound to a given type
	 */




		if (bound instanceof UnresolvedReferenceBinding)
			((UnresolvedReferenceBinding) bound).addWrapper(this, environment);
		this.tagBits |=  TagBits.HasUnresolvedTypeVariables; // cleared in resolve()
		this.typeBits = -1;
	}

	public int kind() {

		return this.genericType.hashCode();
	}

	public boolean hasTypeBit(int bit) {
		if (this.typeBits == -1) {
			// initialize from upper bounds
			this.typeBits = 0;
			if (this.superclass != null)
				this.typeBits |= this.superclass.typeBits;
			if (this.superInterfaces != null)
				for (int i = 0, l = this.superInterfaces.length; i < l; i++)
					this.typeBits |= this.superInterfaces[i].typeBits;
		}
		return (this.typeBits & bit) != 0;
	}

	void initialize(ReferenceBinding someGenericType, TypeBinding someBound, TypeBinding[] someOtherBounds) {
		this.genericType = someGenericType;
		this.bound = someBound;

Lines 55-60 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (+60 lines)
55	import org.eclipse.jdt.internal.compiler.ast.EqualExpression;	55	import org.eclipse.jdt.internal.compiler.ast.EqualExpression;
56	import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;	56	import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;
57	import org.eclipse.jdt.internal.compiler.ast.Expression;	57	import org.eclipse.jdt.internal.compiler.ast.Expression;
		58	import org.eclipse.jdt.internal.compiler.ast.FakedTrackingVariable;
58	import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;	59	import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
59	import org.eclipse.jdt.internal.compiler.ast.FieldReference;	60	import org.eclipse.jdt.internal.compiler.ast.FieldReference;
60	import org.eclipse.jdt.internal.compiler.ast.ImportReference;	61	import org.eclipse.jdt.internal.compiler.ast.ImportReference;
Lines 430-435 Link Here
430		431
431	case IProblem.MethodCanBePotentiallyStatic:	432	case IProblem.MethodCanBePotentiallyStatic:
432	return CompilerOptions.MethodCanBePotentiallyStatic;	433	return CompilerOptions.MethodCanBePotentiallyStatic;
		434
		435	case IProblem.UnclosedCloseable:
		436	case IProblem.UnclosedCloseableAtExit:
		437	return CompilerOptions.UnclosedCloseable;
		438	case IProblem.PotentiallyUnclosedCloseable:
		439	case IProblem.PotentiallyUnclosedCloseableAtExit:
		440	return CompilerOptions.PotentiallyUnclosedCloseable;
		441	case IProblem.ExplicitlyClosedAutoCloseable:
		442	return CompilerOptions.ExplicitlyClosedAutoCloseable;
433	}	443	}
434	return 0;	444	return 0;
435	}	445	}
Lines 462-467 Link Here
462	case CompilerOptions.ParameterAssignment :	472	case CompilerOptions.ParameterAssignment :
463	case CompilerOptions.MethodCanBeStatic :	473	case CompilerOptions.MethodCanBeStatic :
464	case CompilerOptions.MethodCanBePotentiallyStatic :	474	case CompilerOptions.MethodCanBePotentiallyStatic :
		475	case CompilerOptions.ExplicitlyClosedAutoCloseable :
465	return CategorizedProblem.CAT_CODE_STYLE;	476	return CategorizedProblem.CAT_CODE_STYLE;
466		477
467	case CompilerOptions.MaskedCatchBlock :	478	case CompilerOptions.MaskedCatchBlock :
Lines 483-488 Link Here
483	case CompilerOptions.ShouldImplementHashcode :	494	case CompilerOptions.ShouldImplementHashcode :
484	case CompilerOptions.DeadCode :	495	case CompilerOptions.DeadCode :
485	case CompilerOptions.UnusedObjectAllocation :	496	case CompilerOptions.UnusedObjectAllocation :
		497	case CompilerOptions.UnclosedCloseable :
		498	case CompilerOptions.PotentiallyUnclosedCloseable :
486	return CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM;	499	return CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM;
487		500
488	case CompilerOptions.OverriddenPackageDefaultMethod :	501	case CompilerOptions.OverriddenPackageDefaultMethod :
Lines 7884-7887 Link Here
7884	type.sourceStart,	7897	type.sourceStart,
7885	type.sourceEnd);	7898	type.sourceEnd);
7886	}	7899	}
		7900	public void potentiallyUnclosedCloseable(FakedTrackingVariable trackVar, ASTNode location) {
		7901	if (location == null) {
		7902	this.handle(
		7903	IProblem.PotentiallyUnclosedCloseable,
		7904	NoArgument,
		7905	NoArgument,
		7906	trackVar.sourceStart,
		7907	trackVar.sourceEnd);
		7908	} else {
		7909	String[] args = { String.valueOf(trackVar.name) };
		7910	this.handle(
		7911	IProblem.PotentiallyUnclosedCloseableAtExit,
		7912	args,
		7913	args,
		7914	location.sourceStart,
		7915	location.sourceEnd);
		7916	}
		7917	trackVar.hasReportedProblem = true;
		7918	}
		7919	public void unclosedCloseable(FakedTrackingVariable trackVar, ASTNode location) {
		7920	if (location == null) {
		7921	this.handle(
		7922	IProblem.UnclosedCloseable,
		7923	NoArgument,
		7924	NoArgument,
		7925	trackVar.sourceStart,
		7926	trackVar.sourceEnd);
		7927	} else {
		7928	String[] args = { String.valueOf(trackVar.name) };
		7929	this.handle(
		7930	IProblem.UnclosedCloseableAtExit,
		7931	args,
		7932	args,
		7933	location.sourceStart,
		7934	location.sourceEnd);
		7935	}
		7936	trackVar.hasReportedProblem = true;
		7937	}
		7938	public void explicitlyClosedAutoCloseable(FakedTrackingVariable trackVar) {
		7939	String[] args = { String.valueOf(trackVar.name) };
		7940	this.handle(
		7941	IProblem.ExplicitlyClosedAutoCloseable,
		7942	args,
		7943	args,
		7944	trackVar.sourceStart,
		7945	trackVar.sourceEnd);
		7946	}
7887	}	7947	}

Lines 646-651 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (+5 lines)
646	881 = Cannot switch on a value of type String for source level below 1.7. Only convertible int values or enum constants are permitted	646	881 = Cannot switch on a value of type String for source level below 1.7. Only convertible int values or enum constants are permitted
647	882 = Unhandled exception type {0} thrown by automatic close() invocation on {1}	647	882 = Unhandled exception type {0} thrown by automatic close() invocation on {1}
648	883 = '<>' operator is not allowed for source level below 1.7	648	883 = '<>' operator is not allowed for source level below 1.7
		649	884 = Value of type AutoCloseable is not closed on all paths.
		650	885 = Instance '{0}' of type AutoCloseable may be unclosed at this point.
		651	886 = Value of type AutoCloseable is not closed neither explicitly nor using a try-with-resources.
		652	887 = Instance '{0}' of type AutoCloseable is not closed at this point.
		653	888 = Instance '{0}' should be managed by try-with-resource.
649		654
650	### ELABORATIONS	655	### ELABORATIONS
651	## Access restrictions	656	## Access restrictions




	 */
	public static final String COMPILER_PB_POTENTIALLY_MISSING_STATIC_ON_METHOD = PLUGIN_ID + ".compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$
	/**
	 * Compiler option ID: Reporting a resource that is not closed properly.
	 * <p>When enabled, that compiler will issue an error or a warning if a local variable 
	 * 	  holds a value of type AutoCloseable (or Closeable if compliance is &lt; 1.7)
	 *    and if flow analysis shows that the method <code>close()</code> is not invoked locally on that value.
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportUnclosedCloseable"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.7
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.unclosedCloseable"; //$NON-NLS-1$
	/**
	 * Compiler option ID: Reporting a resource that may not be closed properly.
	 * <p>When enabled, that compiler will issue an error or a warning if a local variable 
	 * 	  holds a value of type AutoCloseable (or Closeable if compliance is &lt; 1.7)
	 *    and if flow analysis shows that the method <code>close()</code> is not invoked locally 
	 *    on that value for all execution paths.
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportPotentiallyUnclosedCloseable"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.7
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.potentiallyUnclosedCloseable"; //$NON-NLS-1$
	/**
	 * Compiler option ID: Reporting a resource that is not managed by try-with-resources.
	 * <p>When enabled, that compiler will issue an error or a warning if a local variable 
	 * 	  holds a value of type AutoCloseable, and if the method <code>close()</code> is
	 * 	  explicitly invoked on that resource, but the resource is not managed by a
	 * 	  try-with-resources block.
	 * <p>Note that this option is not surfaced in the UI, as it is intended only for internal 
	 * 	  use for computing quick assists / cleanups. 
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportPotentiallyUnclosedCloseable"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.7
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE = PLUGIN_ID + ".compiler.problem.explicitlyClosedAutoCloseable"; //$NON-NLS-1$
	/**
	 * Compiler option ID: Setting Source Compatibility Mode.
	 * <p>Specify whether which source level compatibility is used. From 1.4 on, <code>'assert'</code> is a keyword
	 *    reserved for assertion support. Also note, than when toggling to 1.4 mode, the target VM




			"		<option key=\"org.eclipse.jdt.core.compiler.problem.discouragedReference\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.emptyStatement\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.enumIdentifier\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.fallthroughCase\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.fatalOptionalError\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.fieldHiding\" value=\"ignore\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.parameterAssignment\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.potentialNullReference\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.rawTypeReference\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.redundantNullCheck\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface\" value=\"ignore\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.typeParameterHiding\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems\" value=\"enabled\"/>\n" +
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unclosedCloseable\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unnecessaryElse\" value=\"ignore\"/>\n" + 





import java.util.Map;

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

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

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

		"	               ^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 5)\n" + 
		"	Y why = new Y();\n" + 
		"	  ^^^\n" + 
		"Value of type AutoCloseable is not closed neither explicitly nor using a try-with-resources.\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" + 
		"Value of type AutoCloseable is not closed neither explicitly nor using a try-with-resources.\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 5)\n" + 
		"	Y why = new Y();\n" + 
		"	        ^^^^^^^\n" + 
		"Unhandled exception type WeirdException\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 20)\n" + 
		"	class WeirdException extends Throwable {}\n" + 
		"	      ^^^^^^^^^^^^^^\n" + 
		"The serializable class WeirdException does not declare a static final serialVersionUID field of type long\n" + 

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

Return to bug 349326

Lines 1394-1399 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (+11 lines)
1394	int UnhandledExceptionOnAutoClose = TypeRelated + 882;	1394	int UnhandledExceptionOnAutoClose = TypeRelated + 882;
1395	/** @since 3.7 */	1395	/** @since 3.7 */
1396	int DiamondNotBelow17 = TypeRelated + 883;	1396	int DiamondNotBelow17 = TypeRelated + 883;
		1397	/** @since 3.7 */
		1398	int PotentiallyUnclosedCloseable = Internal + 884;
		1399	/** @since 3.7 */
		1400	int PotentiallyUnclosedCloseableAtExit = Internal + 885;
		1401	/** @since 3.7 */
		1402	int UnclosedCloseable = Internal + 886;
		1403	/** @since 3.7 */
		1404	int UnclosedCloseableAtExit = Internal + 887;
		1405	/** @since 3.7 */
		1406	int ExplicitlyClosedAutoCloseable = Internal + 888;
		1407
1397	/**	1408	/**
1398	* External problems -- These are problems defined by other plugins	1409	* External problems -- These are problems defined by other plugins
1399	*/	1410	*/

Lines 51-56 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java (+25 lines)
51	flowInfo = ((Reference) this.lhs)	51	flowInfo = ((Reference) this.lhs)
52	.analyseAssignment(currentScope, flowContext, flowInfo, this, false)	52	.analyseAssignment(currentScope, flowContext, flowInfo, this, false)
53	.unconditionalInits();	53	.unconditionalInits();
		54	if (local != null) {
		55	LocalVariableBinding trackerBinding = null;
		56	if (local.closeTracker != null) {
		57	// Assigning to a variable already holding an AutoCloseable, has it been closed before?
		58	trackerBinding = local.closeTracker.binding;
		59	if (!flowInfo.isDefinitelyNull(local)) { // only if previous value may be non-null
		60	if (flowInfo.isDefinitelyNull(trackerBinding))
		61	currentScope.problemReporter().unclosedCloseable(local.closeTracker, this);
		62	else if (flowInfo.isPotentiallyNull(trackerBinding))
		63	currentScope.problemReporter().potentiallyUnclosedCloseable(local.closeTracker, this);
		64	}
		65	}
		66	if (FakedTrackingVariable.isAutoCloseable(this.expression.resolvedType)) {
		67	if (local.closeTracker != null && local.closeTracker.isInsideTryWithResources) {
		68	// re-assigning resource of try-with-resources is a different error
		69	} else {
		70	// new value is AutoCloseable, start tracking, possibly re-using existing tracker var:
		71	if (trackerBinding == null) {
		72	local.closeTracker = new FakedTrackingVariable(local, this);
		73	trackerBinding = local.closeTracker.binding;
		74	}
		75	flowInfo.markAsDefinitelyNull(trackerBinding);
		76	}
		77	}
		78	}
54	int nullStatus = this.expression.nullStatus(flowInfo);	79	int nullStatus = this.expression.nullStatus(flowInfo);
55	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	80	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
56	if (nullStatus == FlowInfo.NULL) {	81	if (nullStatus == FlowInfo.NULL) {

Added Link Here

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

Lines 70-81 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (-2 / +5 lines)
70	}	70	}
71	if ((this.initialization.implicitConversion & TypeIds.UNBOXING) != 0) {	71	if ((this.initialization.implicitConversion & TypeIds.UNBOXING) != 0) {
72	this.initialization.checkNPE(currentScope, flowContext, flowInfo);	72	this.initialization.checkNPE(currentScope, flowContext, flowInfo);
73	}	73	}
74
75	flowInfo =	74	flowInfo =
76	this.initialization	75	this.initialization
77	.analyseCode(currentScope, flowContext, flowInfo)	76	.analyseCode(currentScope, flowContext, flowInfo)
78	.unconditionalInits();	77	.unconditionalInits();
		78	if (FakedTrackingVariable.isAutoCloseable(this.initialization.resolvedType)) {
		79	this.binding.closeTracker = new FakedTrackingVariable(this.binding, this);
		80	flowInfo.markAsDefinitelyNull(this.binding.closeTracker.binding);
		81	}
79	int nullStatus = this.initialization.nullStatus(flowInfo);	82	int nullStatus = this.initialization.nullStatus(flowInfo);
80	if (!flowInfo.isDefinitelyAssigned(this.binding)){// for local variable debug attributes	83	if (!flowInfo.isDefinitelyAssigned(this.binding)){// for local variable debug attributes
81	this.bits \|= FirstAssignmentToLocal;	84	this.bits \|= FirstAssignmentToLocal;

Lines 770-776 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/UnconditionalFlowInfo.java (-7 / +17 lines)
770	}	770	}
771	int vectorIndex;	771	int vectorIndex;
772	if ((vectorIndex = (position / BitCacheSize) - 1)	772	if ((vectorIndex = (position / BitCacheSize) - 1)
773	>= this.extra[0].length) {	773	>= this.extra[2].length) {
774	return false; // if not enough room in vector, then not initialized	774	return false; // if not enough room in vector, then not initialized
775	}	775	}
776	return ((this.extra[2][vectorIndex] & this.extra[4][vectorIndex]	776	return ((this.extra[2][vectorIndex] & this.extra[4][vectorIndex]
Lines 797-803 Link Here
797	}	797	}
798	int vectorIndex;	798	int vectorIndex;
799	if ((vectorIndex = (position / BitCacheSize) - 1) >=	799	if ((vectorIndex = (position / BitCacheSize) - 1) >=
800	this.extra[0].length) {	800	this.extra[2].length) {
801	return false; // if not enough room in vector, then not initialized	801	return false; // if not enough room in vector, then not initialized
802	}	802	}
803	return ((this.extra[2][vectorIndex] & this.extra[3][vectorIndex]	803	return ((this.extra[2][vectorIndex] & this.extra[3][vectorIndex]
Lines 822-828 Link Here
822	}	822	}
823	int vectorIndex;	823	int vectorIndex;
824	if ((vectorIndex = (position / BitCacheSize) - 1) >=	824	if ((vectorIndex = (position / BitCacheSize) - 1) >=
825	this.extra[0].length) {	825	this.extra[2].length) {
826	return false; // if not enough room in vector, then not initialized	826	return false; // if not enough room in vector, then not initialized
827	}	827	}
828	return ((this.extra[2][vectorIndex] & this.extra[5][vectorIndex]	828	return ((this.extra[2][vectorIndex] & this.extra[5][vectorIndex]
Lines 882-888 Link Here
882	}	882	}
883	int vectorIndex;	883	int vectorIndex;
884	if ((vectorIndex = (position / BitCacheSize) - 1) >=	884	if ((vectorIndex = (position / BitCacheSize) - 1) >=
885	this.extra[0].length) {	885	this.extra[2].length) {
886	return false; // if not enough room in vector, then not initialized	886	return false; // if not enough room in vector, then not initialized
887	}	887	}
888	return ((this.extra[4][vectorIndex]	888	return ((this.extra[4][vectorIndex]
Lines 908-914 Link Here
908	}	908	}
909	int vectorIndex;	909	int vectorIndex;
910	if ((vectorIndex = (position / BitCacheSize) - 1) >=	910	if ((vectorIndex = (position / BitCacheSize) - 1) >=
911	this.extra[0].length) {	911	this.extra[2].length) {
912	return false; // if not enough room in vector, then not initialized	912	return false; // if not enough room in vector, then not initialized
913	}	913	}
914	return ((this.extra[3][vectorIndex]	914	return ((this.extra[3][vectorIndex]
Lines 934-940 Link Here
934	}	934	}
935	int vectorIndex;	935	int vectorIndex;
936	if ((vectorIndex = (position / BitCacheSize) - 1) >=	936	if ((vectorIndex = (position / BitCacheSize) - 1) >=
937	this.extra[0].length) {	937	this.extra[2].length) {
938	return false; // if not enough room in vector, then not initialized	938	return false; // if not enough room in vector, then not initialized
939	}	939	}
940	return (this.extra[5][vectorIndex]	940	return (this.extra[5][vectorIndex]
Lines 1889-1895 Link Here
1889	}	1889	}
1890	return count;	1890	return count;
1891	}	1891	}
1892		1892	/** Replace the null info for all variables in mask by values from otherInfo. */
		1893	public void replaceNullInfo(long mask, UnconditionalFlowInfo otherInfo) {
		1894	this.nullBit1 &= ~mask;
		1895	this.nullBit1 \|= (otherInfo.nullBit1 & mask);
		1896	this.nullBit2 &= ~mask;
		1897	this.nullBit2 \|= (otherInfo.nullBit2 & mask);
		1898	this.nullBit3 &= ~mask;
		1899	this.nullBit3 \|= (otherInfo.nullBit3 & mask);
		1900	this.nullBit4 &= ~mask;
		1901	this.nullBit4 \|= (otherInfo.nullBit4 & mask);
		1902	}
1893	public UnconditionalFlowInfo nullInfoLessUnconditionalCopy() {	1903	public UnconditionalFlowInfo nullInfoLessUnconditionalCopy() {
1894	if (this == DEAD_END) {	1904	if (this == DEAD_END) {
1895	return this;	1905	return this;

Lines 42-47 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java (+14 lines)
42	this.modifiers = ClassFileConstants.AccPublic \| ExtraCompilerModifiers.AccGenericSignature; // treat type var as public	42	this.modifiers = ClassFileConstants.AccPublic \| ExtraCompilerModifiers.AccGenericSignature; // treat type var as public
43	this.tagBits \|= TagBits.HasTypeVariable;	43	this.tagBits \|= TagBits.HasTypeVariable;
44	this.environment = environment;	44	this.environment = environment;
		45	this.typeBits = -1;
45	}	46	}
46		47
47	/**	48	/**
Lines 307-312 Link Here
307	return true;	308	return true;
308	}	309	}
309		310
		311	public boolean hasTypeBit(int bit) {
		312	if (this.typeBits == -1) {
		313	// initialize from bounds
		314	this.typeBits = 0;
		315	if (this.superclass != null)
		316	this.typeBits \|= this.superclass.typeBits;
		317	if (this.superInterfaces != null)
		318	for (int i = 0, l = this.superInterfaces.length; i < l; i++)
		319	this.typeBits \|= this.superInterfaces[i].typeBits;
		320	}
		321	return (this.typeBits & bit) != 0;
		322	}
		323
310	/**	324	/**
311	* Returns true if the type variable is directly bound to a given type	325	* Returns true if the type variable is directly bound to a given type
312	*/	326	*/

Lines 54-59 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java (+14 lines)
54	if (bound instanceof UnresolvedReferenceBinding)	54	if (bound instanceof UnresolvedReferenceBinding)
55	((UnresolvedReferenceBinding) bound).addWrapper(this, environment);	55	((UnresolvedReferenceBinding) bound).addWrapper(this, environment);
56	this.tagBits \|= TagBits.HasUnresolvedTypeVariables; // cleared in resolve()	56	this.tagBits \|= TagBits.HasUnresolvedTypeVariables; // cleared in resolve()
		57	this.typeBits = -1;
57	}	58	}
58		59
59	public int kind() {	60	public int kind() {
Lines 420-425 Link Here
420	return this.genericType.hashCode();	421	return this.genericType.hashCode();
421	}	422	}
422		423
		424	public boolean hasTypeBit(int bit) {
		425	if (this.typeBits == -1) {
		426	// initialize from upper bounds
		427	this.typeBits = 0;
		428	if (this.superclass != null)
		429	this.typeBits \|= this.superclass.typeBits;
		430	if (this.superInterfaces != null)
		431	for (int i = 0, l = this.superInterfaces.length; i < l; i++)
		432	this.typeBits \|= this.superInterfaces[i].typeBits;
		433	}
		434	return (this.typeBits & bit) != 0;
		435	}
		436
423	void initialize(ReferenceBinding someGenericType, TypeBinding someBound, TypeBinding[] someOtherBounds) {	437	void initialize(ReferenceBinding someGenericType, TypeBinding someBound, TypeBinding[] someOtherBounds) {
424	this.genericType = someGenericType;	438	this.genericType = someGenericType;
425	this.bound = someBound;	439	this.bound = someBound;

Lines 1357-1362 Link Here

(-)model/org/eclipse/jdt/core/JavaCore.java (+46 lines)
1357	*/	1357	*/
1358	public static final String COMPILER_PB_POTENTIALLY_MISSING_STATIC_ON_METHOD = PLUGIN_ID + ".compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$	1358	public static final String COMPILER_PB_POTENTIALLY_MISSING_STATIC_ON_METHOD = PLUGIN_ID + ".compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$
1359	/**	1359	/**
		1360	* Compiler option ID: Reporting a resource that is not closed properly.
		1361	* <p>When enabled, that compiler will issue an error or a warning if a local variable
		1362	* holds a value of type AutoCloseable (or Closeable if compliance is < 1.7)
		1363	* and if flow analysis shows that the method <code>close()</code> is not invoked locally on that value.
		1364	* <dl>
		1365	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportUnclosedCloseable"</code></dd>
		1366	* <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
		1367	* <dt>Default:</dt><dd><code>"warning"</code></dd>
		1368	* </dl>
		1369	* @since 3.7
		1370	* @category CompilerOptionID
		1371	*/
		1372	public static final String COMPILER_PB_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.unclosedCloseable"; //$NON-NLS-1$
		1373	/**
		1374	* Compiler option ID: Reporting a resource that may not be closed properly.
		1375	* <p>When enabled, that compiler will issue an error or a warning if a local variable
		1376	* holds a value of type AutoCloseable (or Closeable if compliance is < 1.7)
		1377	* and if flow analysis shows that the method <code>close()</code> is not invoked locally
		1378	* on that value for all execution paths.
		1379	* <dl>
		1380	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportPotentiallyUnclosedCloseable"</code></dd>
		1381	* <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
		1382	* <dt>Default:</dt><dd><code>"ignore"</code></dd>
		1383	* </dl>
		1384	* @since 3.7
		1385	* @category CompilerOptionID
		1386	*/
		1387	public static final String COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.potentiallyUnclosedCloseable"; //$NON-NLS-1$
		1388	/**
		1389	* Compiler option ID: Reporting a resource that is not managed by try-with-resources.
		1390	* <p>When enabled, that compiler will issue an error or a warning if a local variable
		1391	* holds a value of type AutoCloseable, and if the method <code>close()</code> is
		1392	* explicitly invoked on that resource, but the resource is not managed by a
		1393	* try-with-resources block.
		1394	* <p>Note that this option is not surfaced in the UI, as it is intended only for internal
		1395	* use for computing quick assists / cleanups.
		1396	* <dl>
		1397	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportPotentiallyUnclosedCloseable"</code></dd>
		1398	* <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
		1399	* <dt>Default:</dt><dd><code>"ignore"</code></dd>
		1400	* </dl>
		1401	* @since 3.7
		1402	* @category CompilerOptionID
		1403	*/
		1404	public static final String COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE = PLUGIN_ID + ".compiler.problem.explicitlyClosedAutoCloseable"; //$NON-NLS-1$
		1405	/**
1360	* Compiler option ID: Setting Source Compatibility Mode.	1406	* 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	1407	* <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	1408	* reserved for assertion support. Also note, than when toggling to 1.4 mode, the target VM

Lines 1816-1821 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java (+3 lines)
1816	" <option key=\"org.eclipse.jdt.core.compiler.problem.discouragedReference\" value=\"warning\"/>\n" +	1816	" <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" +	1817	" <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" +	1818	" <option key=\"org.eclipse.jdt.core.compiler.problem.enumIdentifier\" value=\"warning\"/>\n" +
		1819	" <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" +	1820	" <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" +	1821	" <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" +	1822	" <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" +	1858	" <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" +	1859	" <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" +	1860	" <option key=\"org.eclipse.jdt.core.compiler.problem.potentialNullReference\" value=\"ignore\"/>\n" +
		1861	" <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" +	1862	" <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" +	1863	" <option key=\"org.eclipse.jdt.core.compiler.problem.redundantNullCheck\" value=\"ignore\"/>\n" +
1862	" <option key=\"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface\" value=\"ignore\"/>\n" +	1864	" <option key=\"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface\" value=\"ignore\"/>\n" +
Lines 1871-1876 Link Here
1871	" <option key=\"org.eclipse.jdt.core.compiler.problem.typeParameterHiding\" value=\"warning\"/>\n" +	1873	" <option key=\"org.eclipse.jdt.core.compiler.problem.typeParameterHiding\" value=\"warning\"/>\n" +
1872	" <option key=\"org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems\" value=\"enabled\"/>\n" +	1874	" <option key=\"org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems\" value=\"enabled\"/>\n" +
1873	" <option key=\"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation\" value=\"warning\"/>\n" +	1875	" <option key=\"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation\" value=\"warning\"/>\n" +
		1876	" <option key=\"org.eclipse.jdt.core.compiler.problem.unclosedCloseable\" value=\"warning\"/>\n" +
1874	" <option key=\"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock\" value=\"ignore\"/>\n" +	1877	" <option key=\"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock\" value=\"ignore\"/>\n" +
1875	" <option key=\"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken\" value=\"warning\"/>\n" +	1878	" <option key=\"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken\" value=\"warning\"/>\n" +
1876	" <option key=\"org.eclipse.jdt.core.compiler.problem.unnecessaryElse\" value=\"ignore\"/>\n" +	1879	" <option key=\"org.eclipse.jdt.core.compiler.problem.unnecessaryElse\" value=\"ignore\"/>\n" +

Lines 444-449 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java (+10 lines)
444	expectedProblemAttributes.put("ExceptionTypeInternalNameProvided", DEPRECATED);	444	expectedProblemAttributes.put("ExceptionTypeInternalNameProvided", DEPRECATED);
445	expectedProblemAttributes.put("ExceptionTypeNotFound", DEPRECATED);	445	expectedProblemAttributes.put("ExceptionTypeNotFound", DEPRECATED);
446	expectedProblemAttributes.put("ExceptionTypeNotVisible", DEPRECATED);	446	expectedProblemAttributes.put("ExceptionTypeNotVisible", DEPRECATED);
		447	expectedProblemAttributes.put("ExplicitlyClosedAutoCloseable", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
447	expectedProblemAttributes.put("ExpressionShouldBeAVariable", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	448	expectedProblemAttributes.put("ExpressionShouldBeAVariable", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
448	expectedProblemAttributes.put("ExternalProblemFixable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	449	expectedProblemAttributes.put("ExternalProblemFixable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
449	expectedProblemAttributes.put("ExternalProblemNotFixable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	450	expectedProblemAttributes.put("ExternalProblemNotFixable", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
Lines 768-773 Link Here
768	expectedProblemAttributes.put("PolymorphicMethodNotBelow17", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	769	expectedProblemAttributes.put("PolymorphicMethodNotBelow17", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
769	expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	770	expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
770	expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(CategorizedProblem.CAT_UNCHECKED_RAW));	771	expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(CategorizedProblem.CAT_UNCHECKED_RAW));
		772	expectedProblemAttributes.put("PotentiallyUnclosedCloseable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		773	expectedProblemAttributes.put("PotentiallyUnclosedCloseableAtExit", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
771	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	774	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
772	expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	775	expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
773	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	776	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
Lines 830-835 Link Here
830	expectedProblemAttributes.put("TypeMissingDeprecatedAnnotation", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	833	expectedProblemAttributes.put("TypeMissingDeprecatedAnnotation", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
831	expectedProblemAttributes.put("TypeParameterHidingType", new ProblemAttributes(CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT));	834	expectedProblemAttributes.put("TypeParameterHidingType", new ProblemAttributes(CategorizedProblem.CAT_NAME_SHADOWING_CONFLICT));
832	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));
833	expectedProblemAttributes.put("UndefinedAnnotationMember", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	838	expectedProblemAttributes.put("UndefinedAnnotationMember", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
834	expectedProblemAttributes.put("UndefinedConstructor", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	839	expectedProblemAttributes.put("UndefinedConstructor", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
835	expectedProblemAttributes.put("UndefinedConstructorInDefaultConstructor", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	840	expectedProblemAttributes.put("UndefinedConstructorInDefaultConstructor", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
Lines 1110-1115 Link Here
1110	expectedProblemAttributes.put("ExceptionTypeInternalNameProvided", SKIP);	1115	expectedProblemAttributes.put("ExceptionTypeInternalNameProvided", SKIP);
1111	expectedProblemAttributes.put("ExceptionTypeNotFound", SKIP);	1116	expectedProblemAttributes.put("ExceptionTypeNotFound", SKIP);
1112	expectedProblemAttributes.put("ExceptionTypeNotVisible", SKIP);	1117	expectedProblemAttributes.put("ExceptionTypeNotVisible", SKIP);
		1118	expectedProblemAttributes.put("ExplicitlyClosedAutoCloseable", new ProblemAttributes(JavaCore.COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE));
1113	expectedProblemAttributes.put("ExpressionShouldBeAVariable", SKIP);	1119	expectedProblemAttributes.put("ExpressionShouldBeAVariable", SKIP);
1114	expectedProblemAttributes.put("ExternalProblemFixable", SKIP);	1120	expectedProblemAttributes.put("ExternalProblemFixable", SKIP);
1115	expectedProblemAttributes.put("ExternalProblemNotFixable", SKIP);	1121	expectedProblemAttributes.put("ExternalProblemNotFixable", SKIP);
Lines 1434-1439 Link Here
1434	expectedProblemAttributes.put("PolymorphicMethodNotBelow17", SKIP);	1440	expectedProblemAttributes.put("PolymorphicMethodNotBelow17", SKIP);
1435	expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT));	1441	expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT));
1436	expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(JavaCore.COMPILER_PB_UNCHECKED_TYPE_OPERATION));	1442	expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(JavaCore.COMPILER_PB_UNCHECKED_TYPE_OPERATION));
		1443	expectedProblemAttributes.put("PotentiallyUnclosedCloseable", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE));
		1444	expectedProblemAttributes.put("PotentiallyUnclosedCloseableAtExit", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE));
1437	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE));	1445	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE));
1438	expectedProblemAttributes.put("PublicClassMustMatchFileName", SKIP);	1446	expectedProblemAttributes.put("PublicClassMustMatchFileName", SKIP);
1439	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", SKIP);	1447	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", SKIP);
Lines 1496-1501 Link Here
1496	expectedProblemAttributes.put("TypeMissingDeprecatedAnnotation", new ProblemAttributes(JavaCore.COMPILER_PB_MISSING_DEPRECATED_ANNOTATION));	1504	expectedProblemAttributes.put("TypeMissingDeprecatedAnnotation", new ProblemAttributes(JavaCore.COMPILER_PB_MISSING_DEPRECATED_ANNOTATION));
1497	expectedProblemAttributes.put("TypeParameterHidingType", new ProblemAttributes(JavaCore.COMPILER_PB_TYPE_PARAMETER_HIDING));	1505	expectedProblemAttributes.put("TypeParameterHidingType", new ProblemAttributes(JavaCore.COMPILER_PB_TYPE_PARAMETER_HIDING));
1498	expectedProblemAttributes.put("UnboxingConversion", new ProblemAttributes(JavaCore.COMPILER_PB_AUTOBOXING));	1506	expectedProblemAttributes.put("UnboxingConversion", new ProblemAttributes(JavaCore.COMPILER_PB_AUTOBOXING));
		1507	expectedProblemAttributes.put("UnclosedCloseable", new ProblemAttributes(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE));
		1508	expectedProblemAttributes.put("UnclosedCloseableAtExit", new ProblemAttributes(JavaCore.COMPILER_PB_UNCLOSED_CLOSEABLE));
1499	expectedProblemAttributes.put("UndefinedAnnotationMember", SKIP);	1509	expectedProblemAttributes.put("UndefinedAnnotationMember", SKIP);
1500	expectedProblemAttributes.put("UndefinedConstructor", SKIP);	1510	expectedProblemAttributes.put("UndefinedConstructor", SKIP);
1501	expectedProblemAttributes.put("UndefinedConstructorInDefaultConstructor", SKIP);	1511	expectedProblemAttributes.put("UndefinedConstructorInDefaultConstructor", SKIP);