+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2000, 2004 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Common Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/cpl-v10.html
- *
- * Contributors:
- * IBM Corporation - initial API and implementation
- * Nick Teryaev - fix for bug (https://bugs.eclipse.org/bugs/show_bug.cgi?id=40752)
- *******************************************************************************/
-package org.eclipse.jdt.internal.compiler.ast;
-
-import org.eclipse.jdt.core.compiler.CharOperation;
-import org.eclipse.jdt.internal.compiler.ASTVisitor;
-import org.eclipse.jdt.internal.compiler.impl.*;
-import org.eclipse.jdt.internal.compiler.codegen.*;
-import org.eclipse.jdt.internal.compiler.flow.*;
-import org.eclipse.jdt.internal.compiler.lookup.*;
-import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
-
-public class CastExpression extends Expression {
-
- public Expression expression;
- public Expression type;
-
- //expression.implicitConversion holds the cast for baseType casting
- public CastExpression(Expression expression, Expression type) {
- this.expression = expression;
- this.type = type;
-
- //due to the fact an expression may start with ( and that a cast also start with (
- //the field is an expression....it can be a TypeReference OR a NameReference Or
- //an expression <--this last one is invalid.......
-
- //if (type instanceof TypeReference )
- // flag = IsTypeReference ;
- //else
- // if (type instanceof NameReference)
- // flag = IsNameReference ;
- // else
- // flag = IsExpression ;
-
- }
-
- public FlowInfo analyseCode(
- BlockScope currentScope,
- FlowContext flowContext,
- FlowInfo flowInfo) {
-
- return expression
- .analyseCode(currentScope, flowContext, flowInfo)
- .unconditionalInits();
- }
-
- /**
- * Returns false if the cast is unnecessary
- */
- public final boolean checkCastTypesCompatibility(
- BlockScope scope,
- TypeBinding castType,
- TypeBinding expressionType) {
-
- // see specifications 5.5
- // handle errors and process constant when needed
-
- // if either one of the type is null ==>
- // some error has been already reported some where ==>
- // we then do not report an obvious-cascade-error.
-
- if (castType == null || expressionType == null) return true;
-
- // identity conversion cannot be performed upfront, due to side-effects
- // like constant propagation
-
- if (castType.isBaseType()) {
- if (expressionType.isBaseType()) {
- if (expressionType == castType) {
- expression.implicitWidening(castType, expressionType);
- constant = expression.constant; //use the same constant
- return false;
- }
- boolean necessary = false;
- if (expressionType.isCompatibleWith(castType)
- || (necessary = BaseTypeBinding.isNarrowing(castType.id, expressionType.id))) {
- expression.implicitConversion = (castType.id << 4) + expressionType.id;
- if (expression.constant != Constant.NotAConstant) {
- constant = expression.constant.castTo(expression.implicitConversion);
- }
- return necessary;
-
- }
- }
- scope.problemReporter().typeCastError(this, castType, expressionType);
- return true;
- }
-
- //-----------cast to something which is NOT a base type--------------------------
- if (expressionType == NullBinding) {
- // if (castType.isArrayType()){ // 26903 - need checkcast when casting null to array type
- // needRuntimeCheckcast = true;
- // }
- return false; //null is compatible with every thing
- }
- if (expressionType.isBaseType()) {
- scope.problemReporter().typeCastError(this, castType, expressionType);
- return true;
- }
-
- if (expressionType.isArrayType()) {
- if (castType == expressionType) return false; // identity conversion
-
- if (castType.isArrayType()) {
- //------- (castType.isArray) expressionType.isArray -----------
- TypeBinding exprElementType = ((ArrayBinding) expressionType).elementsType(scope);
- if (exprElementType.isBaseType()) {
- // <---stop the recursion-------
- if (((ArrayBinding) castType).elementsType(scope) == exprElementType) {
- this.bits |= NeedRuntimeCheckCastMASK;
- } else {
- scope.problemReporter().typeCastError(this, castType, expressionType);
- }
- return true;
- }
- // recursively on the elements...
- return checkCastTypesCompatibility(
- scope,
- ((ArrayBinding) castType).elementsType(scope),
- exprElementType);
- } else if (
- castType.isClass()) {
- //------(castType.isClass) expressionType.isArray ---------------
- if (castType.id == T_Object) {
- return false;
- }
- } else { //------- (castType.isInterface) expressionType.isArray -----------
- if (castType.id == T_JavaLangCloneable || castType.id == T_JavaIoSerializable) {
- this.bits |= NeedRuntimeCheckCastMASK;
- return true;
- }
- }
- scope.problemReporter().typeCastError(this, castType, expressionType);
- return true;
- }
-
- if (expressionType.isClass()) {
- if (castType.isArrayType()) {
- // ---- (castType.isArray) expressionType.isClass -------
- if (expressionType.id == T_Object) { // potential runtime error
- this.bits |= NeedRuntimeCheckCastMASK;
- return true;
- }
- } else if (castType.isClass()) { // ----- (castType.isClass) expressionType.isClass ------
- if (expressionType.isCompatibleWith(castType)){ // no runtime error
- if (castType.id == T_String) constant = expression.constant; // (String) cst is still a constant
- return false;
- }
- if (castType.isCompatibleWith(expressionType)) {
- // potential runtime error
- this.bits |= NeedRuntimeCheckCastMASK;
- return true;
- }
- } else { // ----- (castType.isInterface) expressionType.isClass -------
- if (expressionType.isCompatibleWith(castType))
- return false;
- if (!((ReferenceBinding) expressionType).isFinal()) {
- // a subclass may implement the interface ==> no check at compile time
- this.bits |= NeedRuntimeCheckCastMASK;
- return true;
- }
- // no subclass for expressionType, thus compile-time check is valid
- }
- scope.problemReporter().typeCastError(this, castType, expressionType);
- return true;
- }
-
- // if (expressionType.isInterface()) { cannot be anything else
- if (castType.isArrayType()) {
- // ----- (castType.isArray) expressionType.isInterface ------
- if (expressionType.id == T_JavaLangCloneable
- || expressionType.id == T_JavaIoSerializable) {// potential runtime error
- this.bits |= NeedRuntimeCheckCastMASK;
- } else {
- scope.problemReporter().typeCastError(this, castType, expressionType);
- }
- return true;
- } else if (castType.isClass()) { // ----- (castType.isClass) expressionType.isInterface --------
- if (castType.id == T_Object) { // no runtime error
- return false;
- }
- if (((ReferenceBinding) castType).isFinal()) {
- // no subclass for castType, thus compile-time check is valid
- if (!castType.isCompatibleWith(expressionType)) {
- // potential runtime error
- scope.problemReporter().typeCastError(this, castType, expressionType);
- return true;
- }
- }
- } else { // ----- (castType.isInterface) expressionType.isInterface -------
- if (expressionType.isCompatibleWith(castType)) {
- return false;
- }
- if (!castType.isCompatibleWith(expressionType)) {
- MethodBinding[] castTypeMethods = ((ReferenceBinding) castType).methods();
- MethodBinding[] expressionTypeMethods =
- ((ReferenceBinding) expressionType).methods();
- int exprMethodsLength = expressionTypeMethods.length;
- for (int i = 0, castMethodsLength = castTypeMethods.length; i < castMethodsLength; i++)
- for (int j = 0; j < exprMethodsLength; j++) {
- if ((castTypeMethods[i].returnType != expressionTypeMethods[j].returnType)
- && (CharOperation.equals(castTypeMethods[i].selector, expressionTypeMethods[j].selector))
- && castTypeMethods[i].areParametersEqual(expressionTypeMethods[j])) {
- scope.problemReporter().typeCastError(this, castType, expressionType);
- }
- }
- }
- }
- this.bits |= NeedRuntimeCheckCastMASK;
- return true;
- }
-
- /**
- * Casting an enclosing instance will considered as useful if removing it would actually bind to a different type
- */
- public static void checkNeedForEnclosingInstanceCast(BlockScope scope, Expression enclosingInstance, TypeBinding enclosingInstanceType, TypeBinding memberType) {
-
- if (scope.environment().options.getSeverity(CompilerOptions.UnnecessaryTypeCheck) == ProblemSeverities.Ignore) return;
-
- TypeBinding castedExpressionType = ((CastExpression)enclosingInstance).expression.resolvedType;
- if (castedExpressionType == null) return; // cannot do better
- // obvious identity cast
- if (castedExpressionType == enclosingInstanceType) {
- scope.problemReporter().unnecessaryCast((CastExpression)enclosingInstance);
- } else if (castedExpressionType == NullBinding){
- return; // tolerate null enclosing instance cast
- } else {
- TypeBinding alternateEnclosingInstanceType = castedExpressionType;
- if (castedExpressionType.isBaseType() || castedExpressionType.isArrayType()) return; // error case
- if (memberType == scope.getMemberType(memberType.sourceName(), (ReferenceBinding) alternateEnclosingInstanceType)) {
- scope.problemReporter().unnecessaryCast((CastExpression)enclosingInstance);
- }
- }
- }
-
- /**
- * Only complain for identity cast, since other type of casts may be useful: e.g. ~((~(long) 0) << 32) is different from: ~((~0) << 32)
- */
- public static void checkNeedForArgumentCast(BlockScope scope, int operator, int operatorSignature, Expression expression, int expressionTypeId) {
-
- if (scope.environment().options.getSeverity(CompilerOptions.UnnecessaryTypeCheck) == ProblemSeverities.Ignore) return;
-
- // check need for left operand cast
- int alternateLeftTypeId = expressionTypeId;
- if ((expression.bits & UnnecessaryCastMask) == 0 && expression.resolvedType.isBaseType()) {
- // narrowing conversion on base type may change value, thus necessary
- return;
- } else {
- TypeBinding alternateLeftType = ((CastExpression)expression).expression.resolvedType;
- if (alternateLeftType == null) return; // cannot do better
- if ((alternateLeftTypeId = alternateLeftType.id) == expressionTypeId) { // obvious identity cast
- scope.problemReporter().unnecessaryCast((CastExpression)expression);
- return;
- } else if (alternateLeftTypeId == T_null) {
- alternateLeftTypeId = expressionTypeId; // tolerate null argument cast
- return;
- }
- }
-/* tolerate widening cast in unary expressions, as may be used when combined in binary expressions (41680)
- int alternateOperatorSignature = OperatorExpression.OperatorSignatures[operator][(alternateLeftTypeId << 4) + alternateLeftTypeId];
- // (cast) left Op (cast) right --> result
- // 1111 0000 1111 0000 1111
- // <<16 <<12 <<8 <<4 <<0
- final int CompareMASK = (0xF<<16) + (0xF<<8) + 0xF; // mask hiding compile-time types
- if ((operatorSignature & CompareMASK) == (alternateOperatorSignature & CompareMASK)) { // same promotions and result
- scope.problemReporter().unnecessaryCastForArgument((CastExpression)expression, TypeBinding.wellKnownType(scope, expression.implicitConversion >> 4));
- }
-*/
- }
-
- /**
- * Cast expressions will considered as useful if removing them all would actually bind to a different method
- * (no fine grain analysis on per casted argument basis, simply separate widening cast from narrowing ones)
- */
- public static void checkNeedForArgumentCasts(BlockScope scope, Expression receiver, TypeBinding receiverType, MethodBinding binding, Expression[] arguments, TypeBinding[] argumentTypes, final InvocationSite invocationSite) {
-
- if (scope.environment().options.getSeverity(CompilerOptions.UnnecessaryTypeCheck) == ProblemSeverities.Ignore) return;
-
- int length = argumentTypes.length;
-
- // iterate over arguments, and retrieve original argument types (before cast)
- TypeBinding[] rawArgumentTypes = argumentTypes;
- for (int i = 0; i < length; i++) {
- Expression argument = arguments[i];
- if (argument instanceof CastExpression) {
- // narrowing conversion on base type may change value, thus necessary
- if ((argument.bits & UnnecessaryCastMask) == 0 && argument.resolvedType.isBaseType()) {
- continue;
- }
- TypeBinding castedExpressionType = ((CastExpression)argument).expression.resolvedType;
- if (castedExpressionType == null) return; // cannot do better
- // obvious identity cast
- if (castedExpressionType == argumentTypes[i]) {
- scope.problemReporter().unnecessaryCast((CastExpression)argument);
- } else if (castedExpressionType == NullBinding){
- continue; // tolerate null argument cast
- } else {
- if (rawArgumentTypes == argumentTypes) {
- System.arraycopy(rawArgumentTypes, 0, rawArgumentTypes = new TypeBinding[length], 0, length);
- }
- // retain original argument type
- rawArgumentTypes[i] = castedExpressionType;
- }
- }
- }
- // perform alternate lookup with original types
- if (rawArgumentTypes != argumentTypes) {
- checkAlternateBinding(scope, receiver, receiverType, binding, arguments, argumentTypes, rawArgumentTypes, invocationSite);
- }
- }
-
- /**
- * Check binary operator casted arguments
- */
- public static void checkNeedForArgumentCasts(BlockScope scope, int operator, int operatorSignature, Expression left, int leftTypeId, boolean leftIsCast, Expression right, int rightTypeId, boolean rightIsCast) {
-
- if (scope.environment().options.getSeverity(CompilerOptions.UnnecessaryTypeCheck) == ProblemSeverities.Ignore) return;
-
- // check need for left operand cast
- int alternateLeftTypeId = leftTypeId;
- if (leftIsCast) {
- if ((left.bits & UnnecessaryCastMask) == 0 && left.resolvedType.isBaseType()) {
- // narrowing conversion on base type may change value, thus necessary
- leftIsCast = false;
- } else {
- TypeBinding alternateLeftType = ((CastExpression)left).expression.resolvedType;
- if (alternateLeftType == null) return; // cannot do better
- if ((alternateLeftTypeId = alternateLeftType.id) == leftTypeId) { // obvious identity cast
- scope.problemReporter().unnecessaryCast((CastExpression)left);
- leftIsCast = false;
- } else if (alternateLeftTypeId == T_null) {
- alternateLeftTypeId = leftTypeId; // tolerate null argument cast
- leftIsCast = false;
- }
- }
- }
- // check need for right operand cast
- int alternateRightTypeId = rightTypeId;
- if (rightIsCast) {
- if ((right.bits & UnnecessaryCastMask) == 0 && right.resolvedType.isBaseType()) {
- // narrowing conversion on base type may change value, thus necessary
- rightIsCast = false;
- } else {
- TypeBinding alternateRightType = ((CastExpression)right).expression.resolvedType;
- if (alternateRightType == null) return; // cannot do better
- if ((alternateRightTypeId = alternateRightType.id) == rightTypeId) { // obvious identity cast
- scope.problemReporter().unnecessaryCast((CastExpression)right);
- rightIsCast = false;
- } else if (alternateRightTypeId == T_null) {
- alternateRightTypeId = rightTypeId; // tolerate null argument cast
- rightIsCast = false;
- }
- }
- }
- if (leftIsCast || rightIsCast) {
- if (alternateLeftTypeId > 15 || alternateRightTypeId > 15) { // must convert String + Object || Object + String
- if (alternateLeftTypeId == T_String) {
- alternateRightTypeId = T_Object;
- } else if (alternateRightTypeId == T_String) {
- alternateLeftTypeId = T_Object;
- } else {
- return; // invalid operator
- }
- }
- int alternateOperatorSignature = OperatorExpression.OperatorSignatures[operator][(alternateLeftTypeId << 4) + alternateRightTypeId];
- // (cast) left Op (cast) right --> result
- // 1111 0000 1111 0000 1111
- // <<16 <<12 <<8 <<4 <<0
- final int CompareMASK = (0xF<<16) + (0xF<<8) + 0xF; // mask hiding compile-time types
- if ((operatorSignature & CompareMASK) == (alternateOperatorSignature & CompareMASK)) { // same promotions and result
- if (leftIsCast) scope.problemReporter().unnecessaryCastForArgument((CastExpression)left, TypeBinding.wellKnownType(scope, left.implicitConversion >> 4));
- if (rightIsCast) scope.problemReporter().unnecessaryCastForArgument((CastExpression)right, TypeBinding.wellKnownType(scope, right.implicitConversion >> 4));
- }
- }
- }
-
- private static void checkAlternateBinding(BlockScope scope, Expression receiver, TypeBinding receiverType, MethodBinding binding, Expression[] arguments, TypeBinding[] originalArgumentTypes, TypeBinding[] alternateArgumentTypes, final InvocationSite invocationSite) {
-
- InvocationSite fakeInvocationSite = new InvocationSite(){
- public boolean isSuperAccess(){ return invocationSite.isSuperAccess(); }
- public boolean isTypeAccess() { return invocationSite.isTypeAccess(); }
- public void setActualReceiverType(ReferenceBinding actualReceiverType) { /* ignore */}
- public void setDepth(int depth) { /* ignore */}
- public void setFieldIndex(int depth){ /* ignore */}
- public int sourceStart() { return 0; }
- public int sourceEnd() { return 0; }
- };
- MethodBinding bindingIfNoCast;
- if (binding.isConstructor()) {
- bindingIfNoCast = scope.getConstructor((ReferenceBinding)receiverType, alternateArgumentTypes, fakeInvocationSite);
- } else {
- bindingIfNoCast = receiver.isImplicitThis()
- ? scope.getImplicitMethod(binding.selector, alternateArgumentTypes, fakeInvocationSite)
- : scope.getMethod(receiverType, binding.selector, alternateArgumentTypes, fakeInvocationSite);
- }
- if (bindingIfNoCast == binding) {
- for (int i = 0, length = originalArgumentTypes.length; i < length; i++) {
- if (originalArgumentTypes[i] != alternateArgumentTypes[i]) {
- scope.problemReporter().unnecessaryCastForArgument((CastExpression)arguments[i], binding.parameters[i]);
- }
- }
- }
- }
- /**
- * Cast expression code generation
- *
- * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
- * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
- * @param valueRequired boolean
- */
- public void generateCode(
- BlockScope currentScope,
- CodeStream codeStream,
- boolean valueRequired) {
-
- int pc = codeStream.position;
- boolean needRuntimeCheckcast = (this.bits & NeedRuntimeCheckCastMASK) != 0;
- if (constant != NotAConstant) {
- if (valueRequired || needRuntimeCheckcast) { // Added for: 1F1W9IG: IVJCOM:WINNT - Compiler omits casting check
- codeStream.generateConstant(constant, implicitConversion);
- if (needRuntimeCheckcast) {
- codeStream.checkcast(this.resolvedType);
- if (!valueRequired)
- codeStream.pop();
- }
- }
- codeStream.recordPositionsFrom(pc, this.sourceStart);
- return;
- }
- expression.generateCode(
- currentScope,
- codeStream,
- valueRequired || needRuntimeCheckcast);
- if (needRuntimeCheckcast) {
- codeStream.checkcast(this.resolvedType);
- if (!valueRequired)
- codeStream.pop();
- } else {
- if (valueRequired)
- codeStream.generateImplicitConversion(implicitConversion);
- }
- codeStream.recordPositionsFrom(pc, this.sourceStart);
- }
-
- public Expression innermostCastedExpression(){
- Expression current = this.expression;
- while (current instanceof CastExpression) {
- current = ((CastExpression) current).expression;
- }
- return current;
- }
-
- public StringBuffer printExpression(int indent, StringBuffer output) {
-
- output.append('(');
- type.print(0, output).append(") "); //$NON-NLS-1$
- return expression.printExpression(0, output);
- }
-
- public TypeBinding resolveType(BlockScope scope) {
- // compute a new constant if the cast is effective
-
- // due to the fact an expression may start with ( and that a cast can also start with (
- // the field is an expression....it can be a TypeReference OR a NameReference Or
- // any kind of Expression <-- this last one is invalid.......
-
- constant = Constant.NotAConstant;
- implicitConversion = T_undefined;
-
- if ((type instanceof TypeReference) || (type instanceof NameReference)
- && ((type.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) == 0) { // no extra parenthesis around type: ((A))exp
-
- this.resolvedType = type.resolveType(scope);
- TypeBinding expressionType = expression.resolveType(scope);
- if (this.resolvedType != null && expressionType != null) {
- boolean necessary = checkCastTypesCompatibility(scope, this.resolvedType, expressionType);
- if (!necessary && this.expression.resolvedType != null) { // cannot do better if expression is not bound
- this.bits |= UnnecessaryCastMask;
- if ((this.bits & IgnoreNeedForCastCheckMASK) == 0) {
- scope.problemReporter().unnecessaryCast(this);
- }
- }
- }
- return this.resolvedType;
- } else { // expression as a cast !!!!!!!!
- TypeBinding expressionType = expression.resolveType(scope);
- if (expressionType == null) return null;
- scope.problemReporter().invalidTypeReference(type);
- return null;
- }
- }
-
- public void traverse(
- ASTVisitor visitor,
- BlockScope blockScope) {
-
- if (visitor.visit(this, blockScope)) {
- type.traverse(visitor, blockScope);
- expression.traverse(visitor, blockScope);
- }
- visitor.endVisit(this, blockScope);
- }
-}
projects / org.ibex.tool.git / blobdiff