/*******************************************************************************
* Copyright (c) 2000, 2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.aspectj.org.eclipse.jdt.internal.compiler.flow;
import org.aspectj.org.eclipse.jdt.core.compiler.CharOperation;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.LabeledStatement;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.Reference;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.SubRoutineStatement;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.TryStatement;
import org.aspectj.org.eclipse.jdt.internal.compiler.codegen.BranchLabel;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
import org.aspectj.org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
/**
* Reflects the context of code analysis, keeping track of enclosing
* try statements, exception handlers, etc...
*/
public class FlowContext implements TypeConstants {
// preempt marks looping contexts
public final static FlowContext NotContinuableContext = new FlowContext(null, null);
public ASTNode associatedNode;
public FlowContext parent;
public NullInfoRegistry initsOnFinally;
// only used within try blocks; remembers upstream flow info mergedWith
// any null related operation happening within the try block
boolean deferNullDiagnostic, preemptNullDiagnostic;
public FlowContext(FlowContext parent, ASTNode associatedNode) {
this.parent = parent;
this.associatedNode = associatedNode;
if (parent != null) {
this.deferNullDiagnostic =
parent.deferNullDiagnostic || parent.preemptNullDiagnostic;
this.initsOnFinally = parent.initsOnFinally;
}
}
public BranchLabel breakLabel() {
return null;
}
public void checkExceptionHandlers(TypeBinding raisedException, ASTNode location, FlowInfo flowInfo, BlockScope scope) {
// LIGHT-VERSION OF THE EQUIVALENT WITH AN ARRAY OF EXCEPTIONS
// check that all the argument exception types are handled
// JDK Compatible implementation - when an exception type is thrown,
// all related catch blocks are marked as reachable... instead of those only
// until the point where it is safely handled (Smarter - see comment at the end)
FlowContext traversedContext = this;
while (traversedContext != null) {
SubRoutineStatement sub;
if (((sub = traversedContext.subroutine()) != null) && sub.isSubRoutineEscaping()) {
// traversing a non-returning subroutine means that all unhandled
// exceptions will actually never get sent...
return;
}
// filter exceptions that are locally caught from the innermost enclosing
// try statement to the outermost ones.
if (traversedContext instanceof ExceptionHandlingFlowContext) {
ExceptionHandlingFlowContext exceptionContext =
(ExceptionHandlingFlowContext) traversedContext;
ReferenceBinding[] caughtExceptions;
if ((caughtExceptions = exceptionContext.handledExceptions) != Binding.NO_EXCEPTIONS) {
boolean definitelyCaught = false;
for (int caughtIndex = 0, caughtCount = caughtExceptions.length;
caughtIndex < caughtCount;
caughtIndex++) {
ReferenceBinding caughtException = caughtExceptions[caughtIndex];
int state = caughtException == null
? Scope.EQUAL_OR_MORE_SPECIFIC /* any exception */
: Scope.compareTypes(raisedException, caughtException);
switch (state) {
case Scope.EQUAL_OR_MORE_SPECIFIC :
exceptionContext.recordHandlingException(
caughtException,
flowInfo.unconditionalInits(),
raisedException,
location,
definitelyCaught);
// was it already definitely caught ?
definitelyCaught = true;
break;
case Scope.MORE_GENERIC :
exceptionContext.recordHandlingException(
caughtException,
flowInfo.unconditionalInits(),
raisedException,
location,
false);
// was not caught already per construction
}
}
if (definitelyCaught)
return;
}
// method treatment for unchecked exceptions
if (exceptionContext.isMethodContext) {
if (raisedException.isUncheckedException(false))
return;
// anonymous constructors are allowed to throw any exceptions (their thrown exceptions
// clause will be fixed up later as per JLS 8.6).
if (exceptionContext.associatedNode instanceof AbstractMethodDeclaration){
AbstractMethodDeclaration method = (AbstractMethodDeclaration)exceptionContext.associatedNode;
if (method.isConstructor() && method.binding.declaringClass.isAnonymousType()){
exceptionContext.mergeUnhandledException(raisedException);
return; // no need to complain, will fix up constructor exceptions
}
}
break; // not handled anywhere, thus jump to error handling
}
}
traversedContext.recordReturnFrom(flowInfo.unconditionalInits());
if (traversedContext instanceof InsideSubRoutineFlowContext) {
ASTNode node = traversedContext.associatedNode;
if (node instanceof TryStatement) {
TryStatement tryStatement = (TryStatement) node;
flowInfo.addInitializationsFrom(tryStatement.subRoutineInits); // collect inits
}
}
traversedContext = traversedContext.parent;
}
// New AspectJ Extension - see pr151772
// old code:
// scope.problemReporter().unhandledException(raisedException, location);
// new code:
ProblemReporter problemReporter = scope.referenceCompilationUnit().problemReporter;
problemReporter.referenceContext = scope.referenceContext();
problemReporter.unhandledException(raisedException, location);
// AspectJ Extension End
}
public void checkExceptionHandlers(TypeBinding[] raisedExceptions, ASTNode location, FlowInfo flowInfo, BlockScope scope) {
// check that all the argument exception types are handled
// JDK Compatible implementation - when an exception type is thrown,
// all related catch blocks are marked as reachable... instead of those only
// until the point where it is safely handled (Smarter - see comment at the end)
int remainingCount; // counting the number of remaining unhandled exceptions
int raisedCount; // total number of exceptions raised
if ((raisedExceptions == null)
|| ((raisedCount = raisedExceptions.length) == 0))
return;
remainingCount = raisedCount;
// duplicate the array of raised exceptions since it will be updated
// (null replaces any handled exception)
System.arraycopy(
raisedExceptions,
0,
(raisedExceptions = new TypeBinding[raisedCount]),
0,
raisedCount);
FlowContext traversedContext = this;
while (traversedContext != null) {
SubRoutineStatement sub;
if (((sub = traversedContext.subroutine()) != null) && sub.isSubRoutineEscaping()) {
// traversing a non-returning subroutine means that all unhandled
// exceptions will actually never get sent...
return;
}
// filter exceptions that are locally caught from the innermost enclosing
// try statement to the outermost ones.
if (traversedContext instanceof ExceptionHandlingFlowContext) {
ExceptionHandlingFlowContext exceptionContext =
(ExceptionHandlingFlowContext) traversedContext;
ReferenceBinding[] caughtExceptions;
if ((caughtExceptions = exceptionContext.handledExceptions) != Binding.NO_EXCEPTIONS) {
int caughtCount = caughtExceptions.length;
boolean[] locallyCaught = new boolean[raisedCount]; // at most
for (int caughtIndex = 0; caughtIndex < caughtCount; caughtIndex++) {
ReferenceBinding caughtException = caughtExceptions[caughtIndex];
for (int raisedIndex = 0; raisedIndex < raisedCount; raisedIndex++) {
TypeBinding raisedException;
if ((raisedException = raisedExceptions[raisedIndex]) != null) {
int state = caughtException == null
? Scope.EQUAL_OR_MORE_SPECIFIC /* any exception */
: Scope.compareTypes(raisedException, caughtException);
switch (state) {
case Scope.EQUAL_OR_MORE_SPECIFIC :
exceptionContext.recordHandlingException(
caughtException,
flowInfo.unconditionalInits(),
raisedException,
location,
locallyCaught[raisedIndex]);
// was already definitely caught ?
if (!locallyCaught[raisedIndex]) {
locallyCaught[raisedIndex] = true;
// remember that this exception has been definitely caught
remainingCount--;
}
break;
case Scope.MORE_GENERIC :
exceptionContext.recordHandlingException(
caughtException,
flowInfo.unconditionalInits(),
raisedException,
location,
false);
// was not caught already per construction
}
}
}
}
// remove locally caught exceptions from the remaining ones
for (int i = 0; i < raisedCount; i++) {
if (locallyCaught[i]) {
raisedExceptions[i] = null; // removed from the remaining ones.
}
}
}
// method treatment for unchecked exceptions
if (exceptionContext.isMethodContext) {
for (int i = 0; i < raisedCount; i++) {
TypeBinding raisedException;
if ((raisedException = raisedExceptions[i]) != null) {
if (raisedException.isUncheckedException(false)) {
remainingCount--;
raisedExceptions[i] = null;
}
}
}
// anonymous constructors are allowed to throw any exceptions (their thrown exceptions
// clause will be fixed up later as per JLS 8.6).
if (exceptionContext.associatedNode instanceof AbstractMethodDeclaration){
AbstractMethodDeclaration method = (AbstractMethodDeclaration)exceptionContext.associatedNode;
if (method.isConstructor() && method.binding.declaringClass.isAnonymousType()){
for (int i = 0; i < raisedCount; i++) {
TypeBinding raisedException;
if ((raisedException = raisedExceptions[i]) != null) {
exceptionContext.mergeUnhandledException(raisedException);
}
}
return; // no need to complain, will fix up constructor exceptions
}
}
break; // not handled anywhere, thus jump to error handling
}
}
if (remainingCount == 0)
return;
traversedContext.recordReturnFrom(flowInfo.unconditionalInits());
if (traversedContext instanceof InsideSubRoutineFlowContext) {
ASTNode node = traversedContext.associatedNode;
if (node instanceof TryStatement) {
TryStatement tryStatement = (TryStatement) node;
flowInfo.addInitializationsFrom(tryStatement.subRoutineInits); // collect inits
}
}
traversedContext = traversedContext.parent;
}
// if reaches this point, then there are some remaining unhandled exception types.
nextReport: for (int i = 0; i < raisedCount; i++) {
TypeBinding exception;
if ((exception = raisedExceptions[i]) != null) {
// only one complaint if same exception declared to be thrown more than once
for (int j = 0; j < i; j++) {
if (raisedExceptions[j] == exception) continue nextReport; // already reported
}
// AspectJ Extension Begin
// was scope.problemReporter().unhandledException(exception, location); see pr151772
ProblemReporter problemReporter = scope.referenceCompilationUnit().problemReporter;
problemReporter.referenceContext = scope.referenceContext();
problemReporter.unhandledException(exception, location);
// AspectJ Extension End
}
}
}
public BranchLabel continueLabel() {
return null;
}
/*
* lookup through break labels
*/
public FlowContext getTargetContextForBreakLabel(char[] labelName) {
FlowContext current = this, lastNonReturningSubRoutine = null;
while (current != null) {
if (current.isNonReturningContext()) {
lastNonReturningSubRoutine = current;
}
char[] currentLabelName;
if (((currentLabelName = current.labelName()) != null)
&& CharOperation.equals(currentLabelName, labelName)) {
((LabeledStatement)current.associatedNode).bits |= ASTNode.LabelUsed;
if (lastNonReturningSubRoutine == null)
return current;
return lastNonReturningSubRoutine;
}
current = current.parent;
}
// not found
return null;
}
/*
* lookup through continue labels
*/
public FlowContext getTargetContextForContinueLabel(char[] labelName) {
FlowContext current = this;
FlowContext lastContinuable = null;
FlowContext lastNonReturningSubRoutine = null;
while (current != null) {
if (current.isNonReturningContext()) {
lastNonReturningSubRoutine = current;
} else {
if (current.isContinuable()) {
lastContinuable = current;
}
}
char[] currentLabelName;
if ((currentLabelName = current.labelName()) != null && CharOperation.equals(currentLabelName, labelName)) {
((LabeledStatement)current.associatedNode).bits |= ASTNode.LabelUsed;
// matching label found
if ((lastContinuable != null)
&& (current.associatedNode.concreteStatement() == lastContinuable.associatedNode)) {
if (lastNonReturningSubRoutine == null) return lastContinuable;
return lastNonReturningSubRoutine;
}
// label is found, but not a continuable location
return FlowContext.NotContinuableContext;
}
current = current.parent;
}
// not found
return null;
}
/*
* lookup a default break through breakable locations
*/
public FlowContext getTargetContextForDefaultBreak() {
FlowContext current = this, lastNonReturningSubRoutine = null;
while (current != null) {
if (current.isNonReturningContext()) {
lastNonReturningSubRoutine = current;
}
if (current.isBreakable() && current.labelName() == null) {
if (lastNonReturningSubRoutine == null) return current;
return lastNonReturningSubRoutine;
}
current = current.parent;
}
// not found
return null;
}
/*
* lookup a default continue amongst continuable locations
*/
public FlowContext getTargetContextForDefaultContinue() {
FlowContext current = this, lastNonReturningSubRoutine = null;
while (current != null) {
if (current.isNonReturningContext()) {
lastNonReturningSubRoutine = current;
}
if (current.isContinuable()) {
if (lastNonReturningSubRoutine == null)
return current;
return lastNonReturningSubRoutine;
}
current = current.parent;
}
// not found
return null;
}
public String individualToString() {
return "Flow context"; //$NON-NLS-1$
}
public FlowInfo initsOnBreak() {
return FlowInfo.DEAD_END;
}
public UnconditionalFlowInfo initsOnReturn() {
return FlowInfo.DEAD_END;
}
public boolean isBreakable() {
return false;
}
public boolean isContinuable() {
return false;
}
public boolean isNonReturningContext() {
return false;
}
public boolean isSubRoutine() {
return false;
}
public char[] labelName() {
return null;
}
public void recordBreakFrom(FlowInfo flowInfo) {
// default implementation: do nothing
}
public void recordBreakTo(FlowContext targetContext) {
// default implementation: do nothing
}
public void recordContinueFrom(FlowContext innerFlowContext, FlowInfo flowInfo) {
// default implementation: do nothing
}
protected boolean recordFinalAssignment(VariableBinding variable, Reference finalReference) {
return true; // keep going
}
/**
* Record a null reference for use by deferred checks. Only looping or
* finally contexts really record that information.
* @param local the local variable involved in the check
* @param expression the expression within which local lays
* @param status the status against which the check must be performed; one of
* {@link #CAN_ONLY_NULL CAN_ONLY_NULL}, {@link #CAN_ONLY_NULL_NON_NULL
* CAN_ONLY_NULL_NON_NULL}, {@link #MAY_NULL MAY_NULL},
* {@link #CAN_ONLY_NON_NULL CAN_ONLY_NON_NULL}, potentially
* combined with a context indicator (one of {@link #IN_COMPARISON_NULL},
* {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})
*/
protected void recordNullReference(LocalVariableBinding local,
Expression expression, int status) {
// default implementation: do nothing
}
public void recordReturnFrom(UnconditionalFlowInfo flowInfo) {
// default implementation: do nothing
}
public void recordSettingFinal(VariableBinding variable, Reference finalReference, FlowInfo flowInfo) {
if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {
// for initialization inside looping statement that effectively loops
FlowContext context = this;
while (context != null) {
if (!context.recordFinalAssignment(variable, finalReference)) {
break; // no need to keep going
}
context = context.parent;
}
}
}
public static final int
CAN_ONLY_NULL_NON_NULL = 0x0000,
// check against null and non null, with definite values -- comparisons
CAN_ONLY_NULL = 0x0001,
// check against null, with definite values -- comparisons
CAN_ONLY_NON_NULL = 0x0002,
// check against non null, with definite values -- comparisons
MAY_NULL = 0x0003,
// check against null, with potential values -- NPE guard
CHECK_MASK = 0x00FF,
IN_COMPARISON_NULL = 0x0100,
IN_COMPARISON_NON_NULL = 0x0200,
// check happened in a comparison
IN_ASSIGNMENT = 0x0300,
// check happened in an assignment
IN_INSTANCEOF = 0x0400,
// check happened in an instanceof expression
CONTEXT_MASK = ~CHECK_MASK;
/**
* Record a null reference for use by deferred checks. Only looping or
* finally contexts really record that information. The context may
* emit an error immediately depending on the status of local against
* flowInfo and its nature (only looping of finally contexts defer part
* of the checks; nonetheless, contexts that are nested into a looping or a
* finally context get affected and delegate some checks to their enclosing
* context).
* @param scope the scope into which the check is performed
* @param local the local variable involved in the check
* @param reference the expression within which local lies
* @param checkType the status against which the check must be performed; one
* of {@link #CAN_ONLY_NULL CAN_ONLY_NULL}, {@link #CAN_ONLY_NULL_NON_NULL
* CAN_ONLY_NULL_NON_NULL}, {@link #MAY_NULL MAY_NULL}, potentially
* combined with a context indicator (one of {@link #IN_COMPARISON_NULL},
* {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})
* @param flowInfo the flow info at the check point; deferring contexts will
* perform supplementary checks against flow info instances that cannot
* be known at the time of calling this method (they are influenced by
* code that follows the current point)
*/
public void recordUsingNullReference(Scope scope, LocalVariableBinding local,
Expression reference, int checkType, FlowInfo flowInfo) {
if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 ||
flowInfo.isDefinitelyUnknown(local)) {
return;
}
switch (checkType) {
case CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NULL:
case CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL:
if (flowInfo.isDefinitelyNonNull(local)) {
if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
scope.problemReporter().localVariableRedundantCheckOnNonNull(local, reference);
} else {
scope.problemReporter().localVariableNonNullComparedToNull(local, reference);
}
return;
}
else if (flowInfo.cannotBeDefinitelyNullOrNonNull(local)) {
return;
}
case CAN_ONLY_NULL | IN_COMPARISON_NULL:
case CAN_ONLY_NULL | IN_COMPARISON_NON_NULL:
case CAN_ONLY_NULL | IN_ASSIGNMENT:
case CAN_ONLY_NULL | IN_INSTANCEOF:
if (flowInfo.isDefinitelyNull(local)) {
switch(checkType & CONTEXT_MASK) {
case FlowContext.IN_COMPARISON_NULL:
scope.problemReporter().localVariableRedundantCheckOnNull(local, reference);
return;
case FlowContext.IN_COMPARISON_NON_NULL:
scope.problemReporter().localVariableNullComparedToNonNull(local, reference);
return;
case FlowContext.IN_ASSIGNMENT:
scope.problemReporter().localVariableRedundantNullAssignment(local, reference);
return;
case FlowContext.IN_INSTANCEOF:
scope.problemReporter().localVariableNullInstanceof(local, reference);
return;
}
} else if (flowInfo.cannotBeDefinitelyNullOrNonNull(local)) {
return;
}
break;
case MAY_NULL :
if (flowInfo.isDefinitelyNull(local)) {
scope.problemReporter().localVariableNullReference(local, reference);
return;
}
if (flowInfo.isPotentiallyNull(local)) {
scope.problemReporter().localVariablePotentialNullReference(local, reference);
return;
}
break;
default:
// never happens
}
if (this.parent != null) {
this.parent.recordUsingNullReference(scope, local, reference, checkType,
flowInfo);
}
}
void removeFinalAssignmentIfAny(Reference reference) {
// default implementation: do nothing
}
public SubRoutineStatement subroutine() {
return null;
}
public String toString() {
StringBuffer buffer = new StringBuffer();
FlowContext current = this;
int parentsCount = 0;
while ((current = current.parent) != null) {
parentsCount++;
}
FlowContext[] parents = new FlowContext[parentsCount + 1];
current = this;
int index = parentsCount;
while (index >= 0) {
parents[index--] = current;
current = current.parent;
}
for (int i = 0; i < parentsCount; i++) {
for (int j = 0; j < i; j++)
buffer.append('\t');
buffer.append(parents[i].individualToString()).append('\n');
}
buffer.append('*');
for (int j = 0; j < parentsCount + 1; j++)
buffer.append('\t');
buffer.append(individualToString()).append('\n');
return buffer.toString();
}
}