org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/ExceptionHandlingFlowContext.java - jdt/eclipse.jdt.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2009 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.eclipse.jdt.internal.compiler.flow;

 import java.util.ArrayList;

 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.SubRoutineStatement;
 import org.eclipse.jdt.internal.compiler.ast.TryStatement;
 import org.eclipse.jdt.internal.compiler.codegen.ObjectCache;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
 import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
 import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
 import org.eclipse.jdt.internal.compiler.lookup.Scope;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

 /**
  * Reflects the context of code analysis, keeping track of enclosing
  *	try statements, exception handlers, etc...
  */
 public class ExceptionHandlingFlowContext extends FlowContext {

 	public final static int BitCacheSize = 32; // 32 bits per int

 	public ReferenceBinding[] handledExceptions;
 	int[] isReached;
 	int[] isNeeded;
 	UnconditionalFlowInfo[] initsOnExceptions;
 	ObjectCache indexes = new ObjectCache();
 	boolean isMethodContext;

 	public UnconditionalFlowInfo initsOnReturn;
 	public FlowContext initializationParent; // special parent relationship only for initialization purpose

 	// for dealing with anonymous constructor thrown exceptions
 	public ArrayList extendedExceptions;

 public ExceptionHandlingFlowContext(
 		FlowContext parent,
 		ASTNode associatedNode,
 		ReferenceBinding[] handledExceptions,
 		FlowContext initializationParent,
 		BlockScope scope,
 		UnconditionalFlowInfo flowInfo) {

 	super(parent, associatedNode);
 	this.isMethodContext = scope == scope.methodScope();
 	this.handledExceptions = handledExceptions;
 	int count = handledExceptions.length, cacheSize = (count / ExceptionHandlingFlowContext.BitCacheSize) + 1;
 	this.isReached = new int[cacheSize]; // none is reached by default
 	this.isNeeded = new int[cacheSize]; // none is needed by default
 	this.initsOnExceptions = new UnconditionalFlowInfo[count];
 	boolean markExceptionsAndThrowableAsReached =
 		!this.isMethodContext || scope.compilerOptions().reportUnusedDeclaredThrownExceptionExemptExceptionAndThrowable;
 	for (int i = 0; i < count; i++) {
 		ReferenceBinding handledException = handledExceptions[i];
 		this.indexes.put(handledException, i); // key type  -> value index
 		if (handledException.isUncheckedException(true)) {
 			if (markExceptionsAndThrowableAsReached ||
 					handledException.id != TypeIds.T_JavaLangThrowable &&
 					handledException.id != TypeIds.T_JavaLangException) {
 				this.isReached[i / ExceptionHandlingFlowContext.BitCacheSize] |= 1 << (i % ExceptionHandlingFlowContext.BitCacheSize);
 			}
 			this.initsOnExceptions[i] = flowInfo.unconditionalCopy();
 		} else {
 			this.initsOnExceptions[i] = FlowInfo.DEAD_END;
 		}
 	}
 	if (!this.isMethodContext) {
 		System.arraycopy(this.isReached, 0, this.isNeeded, 0, cacheSize);
 	}
 	this.initsOnReturn = FlowInfo.DEAD_END;
 	this.	initializationParent = initializationParent;
 }

 public void complainIfUnusedExceptionHandlers(AbstractMethodDeclaration method) {
 	MethodScope scope = method.scope;
 	// can optionally skip overriding methods
 	if ((method.binding.modifiers & (ExtraCompilerModifiers.AccOverriding | ExtraCompilerModifiers.AccImplementing)) != 0
 	        && !scope.compilerOptions().reportUnusedDeclaredThrownExceptionWhenOverriding) {
 	    return;
 	}

 	// report errors for unreachable exception handlers
 	TypeBinding[] docCommentReferences = null;
 	int docCommentReferencesLength = 0;
 	if (scope.compilerOptions().
 				reportUnusedDeclaredThrownExceptionIncludeDocCommentReference &&
 			method.javadoc != null &&
 			method.javadoc.exceptionReferences != null &&
 			(docCommentReferencesLength = method.javadoc.exceptionReferences.length) > 0) {
 		docCommentReferences = new TypeBinding[docCommentReferencesLength];
 		for (int i = 0; i < docCommentReferencesLength; i++) {
 			docCommentReferences[i] = method.javadoc.exceptionReferences[i].resolvedType;
 		}
 	}
 	nextHandledException: for (int i = 0, count = this.handledExceptions.length; i < count; i++) {
 		int index = this.indexes.get(this.handledExceptions[i]);
 		if ((this.isReached[index / ExceptionHandlingFlowContext.BitCacheSize] & 1 << (index % ExceptionHandlingFlowContext.BitCacheSize)) == 0) {
 			for (int j = 0; j < docCommentReferencesLength; j++) {
 				if (docCommentReferences[j] == this.handledExceptions[i]) {
 					continue nextHandledException;
 				}
 			}
 			scope.problemReporter().unusedDeclaredThrownException(
 				this.handledExceptions[index],
 				method,
 				method.thrownExceptions[index]);
 		}
 	}
 }

 public void complainIfUnusedExceptionHandlers(BlockScope scope,TryStatement tryStatement) {
 	// report errors for unreachable exception handlers
 	for (int i = 0, count = this.handledExceptions.length; i < count; i++) {
 		int index = this.indexes.get(this.handledExceptions[i]);
 		int cacheIndex = index / ExceptionHandlingFlowContext.BitCacheSize;
 		int bitMask = 1 << (index % ExceptionHandlingFlowContext.BitCacheSize);
 		if ((this.isReached[cacheIndex] & bitMask) == 0) {
 			scope.problemReporter().unreachableCatchBlock(
 				this.handledExceptions[index],
 				tryStatement.catchArguments[index].type);
 		} else {
 			if ((this.isNeeded[cacheIndex] & bitMask) == 0) {
 				scope.problemReporter().hiddenCatchBlock(
 					this.handledExceptions[index],
 					tryStatement.catchArguments[index].type);
 			}
 		}
 	}
 }

 public String individualToString() {
 	StringBuffer buffer = new StringBuffer("Exception flow context"); //$NON-NLS-1$
 	int length = this.handledExceptions.length;
 	for (int i = 0; i < length; i++) {
 		int cacheIndex = i / ExceptionHandlingFlowContext.BitCacheSize;
 		int bitMask = 1 << (i % ExceptionHandlingFlowContext.BitCacheSize);
 		buffer.append('[').append(this.handledExceptions[i].readableName());
 		if ((this.isReached[cacheIndex] & bitMask) != 0) {
 			if ((this.isNeeded[cacheIndex] & bitMask) == 0) {
 				buffer.append("-masked"); //$NON-NLS-1$
 			} else {
 				buffer.append("-reached"); //$NON-NLS-1$
 			}
 		} else {
 			buffer.append("-not reached"); //$NON-NLS-1$
 		}
 		buffer.append('-').append(this.initsOnExceptions[i].toString()).append(']');
 	}
 	buffer.append("[initsOnReturn -").append(this.initsOnReturn.toString()).append(']'); //$NON-NLS-1$
 	return buffer.toString();
 }

 public UnconditionalFlowInfo initsOnException(ReferenceBinding exceptionType) {
 	int index;
 	if ((index = this.indexes.get(exceptionType)) < 0) {
 		return FlowInfo.DEAD_END;
 	}
 	return this.initsOnExceptions[index];
 }

 public UnconditionalFlowInfo initsOnReturn(){
 	return this.initsOnReturn;
 }

 /*
  * Compute a merged list of unhandled exception types (keeping only the most generic ones).
  * This is necessary to add synthetic thrown exceptions for anonymous type constructors (JLS 8.6).
  */
 public void mergeUnhandledException(TypeBinding newException){
 	if (this.extendedExceptions == null){
 		this.extendedExceptions = new ArrayList(5);
 		for (int i = 0; i < this.handledExceptions.length; i++){
 			this.extendedExceptions.add(this.handledExceptions[i]);
 		}
 	}
 	boolean isRedundant = false;

 	for(int i = this.extendedExceptions.size()-1; i >= 0; i--){
 		switch(Scope.compareTypes(newException, (TypeBinding)this.extendedExceptions.get(i))){
 			case Scope.MORE_GENERIC :
 				this.extendedExceptions.remove(i);
 				break;
 			case Scope.EQUAL_OR_MORE_SPECIFIC :
 				isRedundant = true;
 				break;
 			case Scope.NOT_RELATED :
 				break;
 		}
 	}
 	if (!isRedundant){
 		this.extendedExceptions.add(newException);
 	}
 }

 public void recordHandlingException(
 		ReferenceBinding exceptionType,
 		UnconditionalFlowInfo flowInfo,
 		TypeBinding raisedException,
 		ASTNode invocationSite,
 		boolean wasAlreadyDefinitelyCaught) {

 	int index = this.indexes.get(exceptionType);
 	int cacheIndex = index / ExceptionHandlingFlowContext.BitCacheSize;
 	int bitMask = 1 << (index % ExceptionHandlingFlowContext.BitCacheSize);
 	if (!wasAlreadyDefinitelyCaught) {
 		this.isNeeded[cacheIndex] |= bitMask;
 	}
 	this.isReached[cacheIndex] |= bitMask;

 	this.initsOnExceptions[index] =
 		(this.initsOnExceptions[index].tagBits & FlowInfo.UNREACHABLE) == 0 ?
 			this.initsOnExceptions[index].mergedWith(flowInfo):
 			flowInfo.unconditionalCopy();
 }

 public void recordReturnFrom(UnconditionalFlowInfo flowInfo) {
 	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {
 		if ((this.initsOnReturn.tagBits & FlowInfo.UNREACHABLE) == 0) {
 			this.initsOnReturn = this.initsOnReturn.mergedWith(flowInfo);
 		}
 		else {
 			this.initsOnReturn = (UnconditionalFlowInfo) flowInfo.copy();
 		}
 	}
 }

 /**
  * Exception handlers (with no finally block) are also included with subroutine
  * only once (in case parented with true InsideSubRoutineFlowContext).
  * Standard management of subroutines need to also operate on intermediate
  * exception handlers.
  * @see org.eclipse.jdt.internal.compiler.flow.FlowContext#subroutine()
  */
 public SubRoutineStatement subroutine() {
 	if (this.associatedNode instanceof SubRoutineStatement) {
 		// exception handler context may be child of InsideSubRoutineFlowContext, which maps to same handler
 		if (this.parent.subroutine() == this.associatedNode)
 			return null;
 		return (SubRoutineStatement) this.associatedNode;
 	}
 	return null;
 }
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2009 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.eclipse.jdt.internal.compiler.flow;

	import java.util.ArrayList;

	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
	import org.eclipse.jdt.internal.compiler.ast.SubRoutineStatement;
	import org.eclipse.jdt.internal.compiler.ast.TryStatement;
	import org.eclipse.jdt.internal.compiler.codegen.ObjectCache;
	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
	import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
	import org.eclipse.jdt.internal.compiler.lookup.Scope;
	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

	/**
	* Reflects the context of code analysis, keeping track of enclosing
	* try statements, exception handlers, etc...
	*/
	public class ExceptionHandlingFlowContext extends FlowContext {

	public final static int BitCacheSize = 32; // 32 bits per int

	public ReferenceBinding[] handledExceptions;
	int[] isReached;
	int[] isNeeded;
	UnconditionalFlowInfo[] initsOnExceptions;
	ObjectCache indexes = new ObjectCache();
	boolean isMethodContext;

	public UnconditionalFlowInfo initsOnReturn;
	public FlowContext initializationParent; // special parent relationship only for initialization purpose

	// for dealing with anonymous constructor thrown exceptions
	public ArrayList extendedExceptions;

	public ExceptionHandlingFlowContext(
	FlowContext parent,
	ASTNode associatedNode,
	ReferenceBinding[] handledExceptions,
	FlowContext initializationParent,
	BlockScope scope,
	UnconditionalFlowInfo flowInfo) {

	super(parent, associatedNode);
	this.isMethodContext = scope == scope.methodScope();
	this.handledExceptions = handledExceptions;
	int count = handledExceptions.length, cacheSize = (count / ExceptionHandlingFlowContext.BitCacheSize) + 1;
	this.isReached = new int[cacheSize]; // none is reached by default
	this.isNeeded = new int[cacheSize]; // none is needed by default
	this.initsOnExceptions = new UnconditionalFlowInfo[count];
	boolean markExceptionsAndThrowableAsReached =
	!this.isMethodContext \|\| scope.compilerOptions().reportUnusedDeclaredThrownExceptionExemptExceptionAndThrowable;
	for (int i = 0; i < count; i++) {
	ReferenceBinding handledException = handledExceptions[i];
	this.indexes.put(handledException, i); // key type -> value index
	if (handledException.isUncheckedException(true)) {
	if (markExceptionsAndThrowableAsReached \|\|
	handledException.id != TypeIds.T_JavaLangThrowable &&
	handledException.id != TypeIds.T_JavaLangException) {
	this.isReached[i / ExceptionHandlingFlowContext.BitCacheSize] \|= 1 << (i % ExceptionHandlingFlowContext.BitCacheSize);
	}
	this.initsOnExceptions[i] = flowInfo.unconditionalCopy();
	} else {
	this.initsOnExceptions[i] = FlowInfo.DEAD_END;
	}
	}
	if (!this.isMethodContext) {
	System.arraycopy(this.isReached, 0, this.isNeeded, 0, cacheSize);
	}
	this.initsOnReturn = FlowInfo.DEAD_END;
	this. initializationParent = initializationParent;
	}

	public void complainIfUnusedExceptionHandlers(AbstractMethodDeclaration method) {
	MethodScope scope = method.scope;
	// can optionally skip overriding methods
	if ((method.binding.modifiers & (ExtraCompilerModifiers.AccOverriding \| ExtraCompilerModifiers.AccImplementing)) != 0
	&& !scope.compilerOptions().reportUnusedDeclaredThrownExceptionWhenOverriding) {
	return;
	}

	// report errors for unreachable exception handlers
	TypeBinding[] docCommentReferences = null;
	int docCommentReferencesLength = 0;
	if (scope.compilerOptions().
	reportUnusedDeclaredThrownExceptionIncludeDocCommentReference &&
	method.javadoc != null &&
	method.javadoc.exceptionReferences != null &&
	(docCommentReferencesLength = method.javadoc.exceptionReferences.length) > 0) {
	docCommentReferences = new TypeBinding[docCommentReferencesLength];
	for (int i = 0; i < docCommentReferencesLength; i++) {
	docCommentReferences[i] = method.javadoc.exceptionReferences[i].resolvedType;
	}
	}
	nextHandledException: for (int i = 0, count = this.handledExceptions.length; i < count; i++) {
	int index = this.indexes.get(this.handledExceptions[i]);
	if ((this.isReached[index / ExceptionHandlingFlowContext.BitCacheSize] & 1 << (index % ExceptionHandlingFlowContext.BitCacheSize)) == 0) {
	for (int j = 0; j < docCommentReferencesLength; j++) {
	if (docCommentReferences[j] == this.handledExceptions[i]) {
	continue nextHandledException;
	}
	}
	scope.problemReporter().unusedDeclaredThrownException(
	this.handledExceptions[index],
	method,
	method.thrownExceptions[index]);
	}
	}
	}

	public void complainIfUnusedExceptionHandlers(BlockScope scope,TryStatement tryStatement) {
	// report errors for unreachable exception handlers
	for (int i = 0, count = this.handledExceptions.length; i < count; i++) {
	int index = this.indexes.get(this.handledExceptions[i]);
	int cacheIndex = index / ExceptionHandlingFlowContext.BitCacheSize;
	int bitMask = 1 << (index % ExceptionHandlingFlowContext.BitCacheSize);
	if ((this.isReached[cacheIndex] & bitMask) == 0) {
	scope.problemReporter().unreachableCatchBlock(
	this.handledExceptions[index],
	tryStatement.catchArguments[index].type);
	} else {
	if ((this.isNeeded[cacheIndex] & bitMask) == 0) {
	scope.problemReporter().hiddenCatchBlock(
	this.handledExceptions[index],
	tryStatement.catchArguments[index].type);
	}
	}
	}
	}

	public String individualToString() {
	StringBuffer buffer = new StringBuffer("Exception flow context"); //$NON-NLS-1$
	int length = this.handledExceptions.length;
	for (int i = 0; i < length; i++) {
	int cacheIndex = i / ExceptionHandlingFlowContext.BitCacheSize;
	int bitMask = 1 << (i % ExceptionHandlingFlowContext.BitCacheSize);
	buffer.append('[').append(this.handledExceptions[i].readableName());
	if ((this.isReached[cacheIndex] & bitMask) != 0) {
	if ((this.isNeeded[cacheIndex] & bitMask) == 0) {
	buffer.append("-masked"); //$NON-NLS-1$
	} else {
	buffer.append("-reached"); //$NON-NLS-1$
	}
	} else {
	buffer.append("-not reached"); //$NON-NLS-1$
	}
	buffer.append('-').append(this.initsOnExceptions[i].toString()).append(']');
	}
	buffer.append("[initsOnReturn -").append(this.initsOnReturn.toString()).append(']'); //$NON-NLS-1$
	return buffer.toString();
	}

	public UnconditionalFlowInfo initsOnException(ReferenceBinding exceptionType) {
	int index;
	if ((index = this.indexes.get(exceptionType)) < 0) {
	return FlowInfo.DEAD_END;
	}
	return this.initsOnExceptions[index];
	}

	public UnconditionalFlowInfo initsOnReturn(){
	return this.initsOnReturn;
	}

	/*
	* Compute a merged list of unhandled exception types (keeping only the most generic ones).
	* This is necessary to add synthetic thrown exceptions for anonymous type constructors (JLS 8.6).
	*/
	public void mergeUnhandledException(TypeBinding newException){
	if (this.extendedExceptions == null){
	this.extendedExceptions = new ArrayList(5);
	for (int i = 0; i < this.handledExceptions.length; i++){
	this.extendedExceptions.add(this.handledExceptions[i]);
	}
	}
	boolean isRedundant = false;

	for(int i = this.extendedExceptions.size()-1; i >= 0; i--){
	switch(Scope.compareTypes(newException, (TypeBinding)this.extendedExceptions.get(i))){
	case Scope.MORE_GENERIC :
	this.extendedExceptions.remove(i);
	break;
	case Scope.EQUAL_OR_MORE_SPECIFIC :
	isRedundant = true;
	break;
	case Scope.NOT_RELATED :
	break;
	}
	}
	if (!isRedundant){
	this.extendedExceptions.add(newException);
	}
	}

	public void recordHandlingException(
	ReferenceBinding exceptionType,
	UnconditionalFlowInfo flowInfo,
	TypeBinding raisedException,
	ASTNode invocationSite,
	boolean wasAlreadyDefinitelyCaught) {

	int index = this.indexes.get(exceptionType);
	int cacheIndex = index / ExceptionHandlingFlowContext.BitCacheSize;
	int bitMask = 1 << (index % ExceptionHandlingFlowContext.BitCacheSize);
	if (!wasAlreadyDefinitelyCaught) {
	this.isNeeded[cacheIndex] \|= bitMask;
	}
	this.isReached[cacheIndex] \|= bitMask;

	this.initsOnExceptions[index] =
	(this.initsOnExceptions[index].tagBits & FlowInfo.UNREACHABLE) == 0 ?
	this.initsOnExceptions[index].mergedWith(flowInfo):
	flowInfo.unconditionalCopy();
	}

	public void recordReturnFrom(UnconditionalFlowInfo flowInfo) {
	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {
	if ((this.initsOnReturn.tagBits & FlowInfo.UNREACHABLE) == 0) {
	this.initsOnReturn = this.initsOnReturn.mergedWith(flowInfo);
	}
	else {
	this.initsOnReturn = (UnconditionalFlowInfo) flowInfo.copy();
	}
	}
	}

	/**
	* Exception handlers (with no finally block) are also included with subroutine
	* only once (in case parented with true InsideSubRoutineFlowContext).
	* Standard management of subroutines need to also operate on intermediate
	* exception handlers.
	* @see org.eclipse.jdt.internal.compiler.flow.FlowContext#subroutine()
	*/
	public SubRoutineStatement subroutine() {
	if (this.associatedNode instanceof SubRoutineStatement) {
	// exception handler context may be child of InsideSubRoutineFlowContext, which maps to same handler
	if (this.parent.subroutine() == this.associatedNode)
	return null;
	return (SubRoutineStatement) this.associatedNode;
	}
	return null;
	}
	}