public void resolve(BlockScope scope) {
if (this.expression != null) {
if (this.expression.resolveType(scope) != null) {
TypeBinding javaLangClass = scope.getJavaLangClass();
if (!javaLangClass.isValidBinding()) {
scope
.problemReporter()
.codeSnippetMissingClass(
"java.lang.Class", this.sourceStart, this.sourceEnd); // $NON-NLS-1$
return;
}
TypeBinding javaLangObject = scope.getJavaLangObject();
if (!javaLangObject.isValidBinding()) {
scope
.problemReporter()
.codeSnippetMissingClass(
"java.lang.Object", this.sourceStart, this.sourceEnd); // $NON-NLS-1$
return;
}
TypeBinding[] argumentTypes = new TypeBinding[] {javaLangObject, javaLangClass};
this.setResultMethod = scope.getImplicitMethod(SETRESULT_SELECTOR, argumentTypes, this);
if (!this.setResultMethod.isValidBinding()) {
scope
.problemReporter()
.codeSnippetMissingMethod(
ROOT_FULL_CLASS_NAME,
new String(SETRESULT_SELECTOR),
new String(SETRESULT_ARGUMENTS),
this.sourceStart,
this.sourceEnd);
return;
}
// in constant case, the implicit conversion cannot be left uninitialized
if (this.expression.constant != Constant.NotAConstant) {
// fake 'no implicit conversion' (the return type is always void)
this.expression.implicitConversion = this.expression.constant.typeID() << 4;
}
}
}
}
public void resolve(BlockScope upperScope) {
// special scope for secret locals optimization.
this.scope = new BlockScope(upperScope);
BlockScope tryScope = new BlockScope(scope);
BlockScope finallyScope = null;
if (finallyBlock != null) {
if (finallyBlock.isEmptyBlock()) {
if ((finallyBlock.bits & UndocumentedEmptyBlockMASK) != 0) {
scope
.problemReporter()
.undocumentedEmptyBlock(finallyBlock.sourceStart, finallyBlock.sourceEnd);
}
} else {
finallyScope = new BlockScope(scope, false); // don't add it yet to parent scope
// provision for returning and forcing the finally block to run
MethodScope methodScope = scope.methodScope();
// the type does not matter as long as it is not a base type
if (!upperScope.compilerOptions().inlineJsrBytecode) {
this.returnAddressVariable =
new LocalVariableBinding(
SecretReturnName, upperScope.getJavaLangObject(), AccDefault, false);
finallyScope.addLocalVariable(returnAddressVariable);
this.returnAddressVariable.setConstant(NotAConstant); // not inlinable
}
this.subRoutineStartLabel = new Label();
this.anyExceptionVariable =
new LocalVariableBinding(
SecretAnyHandlerName, scope.getJavaLangThrowable(), AccDefault, false);
finallyScope.addLocalVariable(this.anyExceptionVariable);
this.anyExceptionVariable.setConstant(NotAConstant); // not inlinable
if (!methodScope.isInsideInitializer()) {
MethodBinding methodBinding =
((AbstractMethodDeclaration) methodScope.referenceContext).binding;
if (methodBinding != null) {
TypeBinding methodReturnType = methodBinding.returnType;
if (methodReturnType.id != T_void) {
this.secretReturnValue =
new LocalVariableBinding(
SecretLocalDeclarationName, methodReturnType, AccDefault, false);
finallyScope.addLocalVariable(this.secretReturnValue);
this.secretReturnValue.setConstant(NotAConstant); // not inlinable
}
}
}
finallyBlock.resolveUsing(finallyScope);
// force the finally scope to have variable positions shifted after its try scope and catch
// ones
finallyScope.shiftScopes =
new BlockScope[catchArguments == null ? 1 : catchArguments.length + 1];
finallyScope.shiftScopes[0] = tryScope;
}
}
this.tryBlock.resolveUsing(tryScope);
// arguments type are checked against JavaLangThrowable in resolveForCatch(..)
if (this.catchBlocks != null) {
int length = this.catchArguments.length;
TypeBinding[] argumentTypes = new TypeBinding[length];
boolean catchHasError = false;
for (int i = 0; i < length; i++) {
BlockScope catchScope = new BlockScope(scope);
if (finallyScope != null) {
finallyScope.shiftScopes[i + 1] = catchScope;
}
// side effect on catchScope in resolveForCatch(..)
if ((argumentTypes[i] = catchArguments[i].resolveForCatch(catchScope)) == null) {
catchHasError = true;
}
catchBlocks[i].resolveUsing(catchScope);
}
if (catchHasError) {
return;
}
// Verify that the catch clause are ordered in the right way:
// more specialized first.
this.caughtExceptionTypes = new ReferenceBinding[length];
for (int i = 0; i < length; i++) {
caughtExceptionTypes[i] = (ReferenceBinding) argumentTypes[i];
for (int j = 0; j < i; j++) {
if (caughtExceptionTypes[i].isCompatibleWith(argumentTypes[j])) {
scope
.problemReporter()
.wrongSequenceOfExceptionTypesError(
this, caughtExceptionTypes[i], i, argumentTypes[j]);
}
}
}
} else {
caughtExceptionTypes = new ReferenceBinding[0];
}
if (finallyScope != null) {
// add finallyScope as last subscope, so it can be shifted behind try/catch subscopes.
// the shifting is necessary to achieve no overlay in between the finally scope and its
// sibling in term of local variable positions.
this.scope.addSubscope(finallyScope);
}
}
public TypeBinding resolveTypeExpecting(BlockScope scope, TypeBinding expectedType) {
// Array initializers can only occur on the right hand side of an assignment
// expression, therefore the expected type contains the valid information
// concerning the type that must be enforced by the elements of the array initializer.
// this method is recursive... (the test on isArrayType is the stop case)
this.constant = Constant.NotAConstant;
if (expectedType instanceof ArrayBinding) {
// allow new List<?>[5]
if ((this.bits & IsAnnotationDefaultValue)
== 0) { // annotation default value need only to be commensurate JLS9.7
// allow new List<?>[5] - only check for generic array when no initializer, since also
// checked inside initializer resolution
TypeBinding leafComponentType = expectedType.leafComponentType();
if (!leafComponentType.isReifiable()) {
scope.problemReporter().illegalGenericArray(leafComponentType, this);
}
}
this.resolvedType = this.binding = (ArrayBinding) expectedType;
if (this.expressions == null) return this.binding;
TypeBinding elementType = this.binding.elementsType();
for (int i = 0, length = this.expressions.length; i < length; i++) {
Expression expression = this.expressions[i];
expression.setExpectedType(elementType);
TypeBinding expressionType =
expression instanceof ArrayInitializer
? expression.resolveTypeExpecting(scope, elementType)
: expression.resolveType(scope);
if (expressionType == null) continue;
// Compile-time conversion required?
if (elementType
!= expressionType) // must call before computeConversion() and typeMismatchError()
scope.compilationUnitScope().recordTypeConversion(elementType, expressionType);
if (expression.isConstantValueOfTypeAssignableToType(expressionType, elementType)
|| expressionType.isCompatibleWith(elementType)) {
expression.computeConversion(scope, elementType, expressionType);
} else if (scope.isBoxingCompatibleWith(expressionType, elementType)
|| (expressionType.isBaseType() // narrowing then boxing ?
&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
&& !elementType.isBaseType()
&& expression.isConstantValueOfTypeAssignableToType(
expressionType, scope.environment().computeBoxingType(elementType)))) {
expression.computeConversion(scope, elementType, expressionType);
} else {
scope.problemReporter().typeMismatchError(expressionType, elementType, expression, null);
}
}
return this.binding;
}
// infer initializer type for error reporting based on first element
TypeBinding leafElementType = null;
int dim = 1;
if (this.expressions == null) {
leafElementType = scope.getJavaLangObject();
} else {
Expression expression = this.expressions[0];
while (expression != null && expression instanceof ArrayInitializer) {
dim++;
Expression[] subExprs = ((ArrayInitializer) expression).expressions;
if (subExprs == null) {
leafElementType = scope.getJavaLangObject();
expression = null;
break;
}
expression = ((ArrayInitializer) expression).expressions[0];
}
if (expression != null) {
leafElementType = expression.resolveType(scope);
}
// fault-tolerance - resolve other expressions as well
for (int i = 1, length = this.expressions.length; i < length; i++) {
expression = this.expressions[i];
if (expression != null) {
expression.resolveType(scope);
}
}
}
if (leafElementType != null) {
this.resolvedType = scope.createArrayType(leafElementType, dim);
if (expectedType != null)
scope.problemReporter().typeMismatchError(this.resolvedType, expectedType, this, null);
}
return null;
}
public TypeBinding resolveType(BlockScope scope) {
// added for code assist...cannot occur with 'normal' code
if (this.anonymousType == null && this.enclosingInstance == null) {
return super.resolveType(scope);
}
// Propagate the type checking to the arguments, and checks if the constructor is defined.
// ClassInstanceCreationExpression ::= Primary '.' 'new' SimpleName '(' ArgumentListopt ')'
// ClassBodyopt
// ClassInstanceCreationExpression ::= Name '.' 'new' SimpleName '(' ArgumentListopt ')'
// ClassBodyopt
this.constant = Constant.NotAConstant;
TypeBinding enclosingInstanceType = null;
ReferenceBinding enclosingInstanceReference = null;
TypeBinding receiverType = null;
boolean hasError = false;
boolean enclosingInstanceContainsCast = false;
boolean argsContainCast = false;
if (this.enclosingInstance != null) {
if (this.enclosingInstance instanceof CastExpression) {
this.enclosingInstance.bits |= ASTNode.DisableUnnecessaryCastCheck; // will check later on
enclosingInstanceContainsCast = true;
}
if ((enclosingInstanceType = this.enclosingInstance.resolveType(scope)) == null) {
hasError = true;
} else if (enclosingInstanceType.isBaseType() || enclosingInstanceType.isArrayType()) {
scope
.problemReporter()
.illegalPrimitiveOrArrayTypeForEnclosingInstance(
enclosingInstanceType, this.enclosingInstance);
hasError = true;
} else if (this.type instanceof QualifiedTypeReference) {
scope
.problemReporter()
.illegalUsageOfQualifiedTypeReference((QualifiedTypeReference) this.type);
hasError = true;
} else if (!(enclosingInstanceReference = (ReferenceBinding) enclosingInstanceType)
.canBeSeenBy(scope)) {
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=317212
enclosingInstanceType =
new ProblemReferenceBinding(
enclosingInstanceReference.compoundName,
enclosingInstanceReference,
ProblemReasons.NotVisible);
scope.problemReporter().invalidType(this.enclosingInstance, enclosingInstanceType);
hasError = true;
} else {
receiverType =
((SingleTypeReference) this.type)
.resolveTypeEnclosing(scope, (ReferenceBinding) enclosingInstanceType);
if (receiverType != null && enclosingInstanceContainsCast) {
CastExpression.checkNeedForEnclosingInstanceCast(
scope, this.enclosingInstance, enclosingInstanceType, receiverType);
}
}
} else {
if (this.type == null) {
// initialization of an enum constant
receiverType = scope.enclosingSourceType();
} else {
receiverType = this.type.resolveType(scope, true /* check bounds*/);
checkParameterizedAllocation:
{
if (receiverType == null || !receiverType.isValidBinding())
break checkParameterizedAllocation;
if (this.type
instanceof
ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
ReferenceBinding currentType = (ReferenceBinding) receiverType;
do {
// isStatic() is answering true for toplevel types
if ((currentType.modifiers & ClassFileConstants.AccStatic) != 0)
break checkParameterizedAllocation;
if (currentType.isRawType()) break checkParameterizedAllocation;
} while ((currentType = currentType.enclosingType()) != null);
ParameterizedQualifiedTypeReference qRef =
(ParameterizedQualifiedTypeReference) this.type;
for (int i = qRef.typeArguments.length - 2; i >= 0; i--) {
if (qRef.typeArguments[i] != null) {
scope
.problemReporter()
.illegalQualifiedParameterizedTypeAllocation(this.type, receiverType);
break;
}
}
}
}
}
}
if (receiverType == null || !receiverType.isValidBinding()) {
hasError = true;
}
// resolve type arguments (for generic constructor call)
final boolean isDiamond = this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0;
if (this.typeArguments != null) {
int length = this.typeArguments.length;
boolean argHasError = scope.compilerOptions().sourceLevel < ClassFileConstants.JDK1_5;
this.genericTypeArguments = new TypeBinding[length];
for (int i = 0; i < length; i++) {
TypeReference typeReference = this.typeArguments[i];
if ((this.genericTypeArguments[i] =
typeReference.resolveType(scope, true /* check bounds*/))
== null) {
argHasError = true;
}
if (argHasError && typeReference instanceof Wildcard) {
scope.problemReporter().illegalUsageOfWildcard(typeReference);
}
}
if (isDiamond) {
scope.problemReporter().diamondNotWithExplicitTypeArguments(this.typeArguments);
return null;
}
if (argHasError) {
if (this.arguments != null) { // still attempt to resolve arguments
for (int i = 0, max = this.arguments.length; i < max; i++) {
this.arguments[i].resolveType(scope);
}
}
return null;
}
}
// will check for null after args are resolved
TypeBinding[] argumentTypes = Binding.NO_PARAMETERS;
if (this.arguments != null) {
int length = this.arguments.length;
argumentTypes = new TypeBinding[length];
for (int i = 0; i < length; i++) {
Expression argument = this.arguments[i];
if (argument instanceof CastExpression) {
argument.bits |= ASTNode.DisableUnnecessaryCastCheck; // will check later on
argsContainCast = true;
}
if ((argumentTypes[i] = argument.resolveType(scope)) == null) {
hasError = true;
}
}
}
// limit of fault-tolerance
if (hasError) {
/* https://bugs.eclipse.org/bugs/show_bug.cgi?id=345359, if arguments have errors, completely bail out in the <> case.
No meaningful type resolution is possible since inference of the elided types is fully tied to argument types. Do
not return the partially resolved type.
*/
if (isDiamond) {
return null; // not the partially cooked this.resolvedType
}
if (receiverType instanceof ReferenceBinding) {
ReferenceBinding referenceReceiver = (ReferenceBinding) receiverType;
if (receiverType.isValidBinding()) {
// record a best guess, for clients who need hint about possible contructor match
int length = this.arguments == null ? 0 : this.arguments.length;
TypeBinding[] pseudoArgs = new TypeBinding[length];
for (int i = length; --i >= 0; ) {
pseudoArgs[i] =
argumentTypes[i] == null
? TypeBinding.NULL
: argumentTypes[i]; // replace args with errors with null type
}
this.binding = scope.findMethod(referenceReceiver, TypeConstants.INIT, pseudoArgs, this);
if (this.binding != null && !this.binding.isValidBinding()) {
MethodBinding closestMatch = ((ProblemMethodBinding) this.binding).closestMatch;
// record the closest match, for clients who may still need hint about possible method
// match
if (closestMatch != null) {
if (closestMatch.original().typeVariables
!= Binding.NO_TYPE_VARIABLES) { // generic method
// shouldn't return generic method outside its context, rather convert it to raw
// method (175409)
closestMatch =
scope
.environment()
.createParameterizedGenericMethod(
closestMatch.original(), (RawTypeBinding) null);
}
this.binding = closestMatch;
MethodBinding closestMatchOriginal = closestMatch.original();
if (closestMatchOriginal.isOrEnclosedByPrivateType()
&& !scope.isDefinedInMethod(closestMatchOriginal)) {
// ignore cases where method is used from within inside itself (e.g. direct
// recursions)
closestMatchOriginal.modifiers |= ExtraCompilerModifiers.AccLocallyUsed;
}
}
}
}
if (this.anonymousType != null) {
// insert anonymous type in scope (see
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=210070)
scope.addAnonymousType(this.anonymousType, referenceReceiver);
this.anonymousType.resolve(scope);
return this.resolvedType = this.anonymousType.binding;
}
}
return this.resolvedType = receiverType;
}
if (this.anonymousType == null) {
// qualified allocation with no anonymous type
if (!receiverType.canBeInstantiated()) {
scope.problemReporter().cannotInstantiate(this.type, receiverType);
return this.resolvedType = receiverType;
}
if (isDiamond) {
TypeBinding[] inferredTypes =
inferElidedTypes(
((ParameterizedTypeBinding) receiverType).genericType(),
receiverType.enclosingType(),
argumentTypes,
scope);
if (inferredTypes == null) {
scope.problemReporter().cannotInferElidedTypes(this);
return this.resolvedType = null;
}
receiverType =
this.type.resolvedType =
scope
.environment()
.createParameterizedType(
((ParameterizedTypeBinding) receiverType).genericType(),
inferredTypes,
((ParameterizedTypeBinding) receiverType).enclosingType());
}
ReferenceBinding allocationType = (ReferenceBinding) receiverType;
if ((this.binding = scope.getConstructor(allocationType, argumentTypes, this))
.isValidBinding()) {
if (isMethodUseDeprecated(this.binding, scope, true)) {
scope.problemReporter().deprecatedMethod(this.binding, this);
}
if (checkInvocationArguments(
scope,
null,
allocationType,
this.binding,
this.arguments,
argumentTypes,
argsContainCast,
this)) {
this.bits |= ASTNode.Unchecked;
}
if (this.typeArguments != null
&& this.binding.original().typeVariables == Binding.NO_TYPE_VARIABLES) {
scope
.problemReporter()
.unnecessaryTypeArgumentsForMethodInvocation(
this.binding, this.genericTypeArguments, this.typeArguments);
}
} else {
if (this.binding.declaringClass == null) {
this.binding.declaringClass = allocationType;
}
if (this.type != null && !this.type.resolvedType.isValidBinding()) {
// problem already got signaled on type reference, do not report secondary problem
return null;
}
scope.problemReporter().invalidConstructor(this, this.binding);
return this.resolvedType = receiverType;
}
if ((this.binding.tagBits & TagBits.HasMissingType) != 0) {
scope.problemReporter().missingTypeInConstructor(this, this.binding);
}
if (!isDiamond && receiverType.isParameterizedTypeWithActualArguments()) {
checkTypeArgumentRedundancy(
(ParameterizedTypeBinding) receiverType,
receiverType.enclosingType(),
argumentTypes,
scope);
}
// The enclosing instance must be compatible with the innermost enclosing type
ReferenceBinding expectedType = this.binding.declaringClass.enclosingType();
if (expectedType
!= enclosingInstanceType) // must call before computeConversion() and typeMismatchError()
scope.compilationUnitScope().recordTypeConversion(expectedType, enclosingInstanceType);
if (enclosingInstanceType.isCompatibleWith(expectedType)
|| scope.isBoxingCompatibleWith(enclosingInstanceType, expectedType)) {
this.enclosingInstance.computeConversion(scope, expectedType, enclosingInstanceType);
return this.resolvedType = receiverType;
}
scope
.problemReporter()
.typeMismatchError(enclosingInstanceType, expectedType, this.enclosingInstance, null);
return this.resolvedType = receiverType;
} else {
if (isDiamond) {
scope.problemReporter().diamondNotWithAnoymousClasses(this.type);
return null;
}
}
ReferenceBinding superType = (ReferenceBinding) receiverType;
if (superType.isTypeVariable()) {
superType =
new ProblemReferenceBinding(
new char[][] {superType.sourceName()},
superType,
ProblemReasons.IllegalSuperTypeVariable);
scope.problemReporter().invalidType(this, superType);
return null;
} else if (this.type != null && superType.isEnum()) { // tolerate enum constant body
scope.problemReporter().cannotInstantiate(this.type, superType);
return this.resolvedType = superType;
}
// anonymous type scenario
// an anonymous class inherits from java.lang.Object when declared "after" an interface
ReferenceBinding anonymousSuperclass =
superType.isInterface() ? scope.getJavaLangObject() : superType;
// insert anonymous type in scope
scope.addAnonymousType(this.anonymousType, superType);
this.anonymousType.resolve(scope);
// find anonymous super constructor
this.resolvedType = this.anonymousType.binding; // 1.2 change
if ((this.resolvedType.tagBits & TagBits.HierarchyHasProblems) != 0) {
return null; // stop secondary errors
}
MethodBinding inheritedBinding = scope.getConstructor(anonymousSuperclass, argumentTypes, this);
if (!inheritedBinding.isValidBinding()) {
if (inheritedBinding.declaringClass == null) {
inheritedBinding.declaringClass = anonymousSuperclass;
}
if (this.type != null && !this.type.resolvedType.isValidBinding()) {
// problem already got signaled on type reference, do not report secondary problem
return null;
}
scope.problemReporter().invalidConstructor(this, inheritedBinding);
return this.resolvedType;
}
if ((inheritedBinding.tagBits & TagBits.HasMissingType) != 0) {
scope.problemReporter().missingTypeInConstructor(this, inheritedBinding);
}
if (this.enclosingInstance != null) {
ReferenceBinding targetEnclosing = inheritedBinding.declaringClass.enclosingType();
if (targetEnclosing == null) {
scope
.problemReporter()
.unnecessaryEnclosingInstanceSpecification(this.enclosingInstance, superType);
return this.resolvedType;
} else if (!enclosingInstanceType.isCompatibleWith(targetEnclosing)
&& !scope.isBoxingCompatibleWith(enclosingInstanceType, targetEnclosing)) {
scope
.problemReporter()
.typeMismatchError(
enclosingInstanceType, targetEnclosing, this.enclosingInstance, null);
return this.resolvedType;
}
this.enclosingInstance.computeConversion(scope, targetEnclosing, enclosingInstanceType);
}
if (this.arguments != null) {
if (checkInvocationArguments(
scope,
null,
anonymousSuperclass,
inheritedBinding,
this.arguments,
argumentTypes,
argsContainCast,
this)) {
this.bits |= ASTNode.Unchecked;
}
}
if (this.typeArguments != null
&& inheritedBinding.original().typeVariables == Binding.NO_TYPE_VARIABLES) {
scope
.problemReporter()
.unnecessaryTypeArgumentsForMethodInvocation(
inheritedBinding, this.genericTypeArguments, this.typeArguments);
}
// Update the anonymous inner class : superclass, interface
this.binding =
this.anonymousType.createDefaultConstructorWithBinding(
inheritedBinding,
(this.bits & ASTNode.Unchecked) != 0 && this.genericTypeArguments == null);
return this.resolvedType;
}
public TypeBinding resolveType(BlockScope scope) {
boolean leftIsCast, rightIsCast;
if ((leftIsCast = this.left instanceof CastExpression) == true)
this.left.bits |= DisableUnnecessaryCastCheck; // will check later on
TypeBinding originalLeftType = this.left.resolveType(scope);
if ((rightIsCast = this.right instanceof CastExpression) == true)
this.right.bits |= DisableUnnecessaryCastCheck; // will check later on
TypeBinding originalRightType = this.right.resolveType(scope);
// always return BooleanBinding
if (originalLeftType == null || originalRightType == null) {
this.constant = Constant.NotAConstant;
return null;
}
// autoboxing support
boolean use15specifics = scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5;
TypeBinding leftType = originalLeftType, rightType = originalRightType;
if (use15specifics) {
if (leftType != TypeBinding.NULL && leftType.isBaseType()) {
if (!rightType.isBaseType()) {
rightType = scope.environment().computeBoxingType(rightType);
}
} else {
if (rightType != TypeBinding.NULL && rightType.isBaseType()) {
leftType = scope.environment().computeBoxingType(leftType);
}
}
}
// both base type
if (leftType.isBaseType() && rightType.isBaseType()) {
int leftTypeID = leftType.id;
int rightTypeID = rightType.id;
// the code is an int
// (cast) left == (cast) right --> result
// 0000 0000 0000 0000 0000
// <<16 <<12 <<8 <<4 <<0
int operatorSignature = OperatorSignatures[EQUAL_EQUAL][(leftTypeID << 4) + rightTypeID];
this.left.computeConversion(
scope,
TypeBinding.wellKnownType(scope, (operatorSignature >>> 16) & 0x0000F),
originalLeftType);
this.right.computeConversion(
scope,
TypeBinding.wellKnownType(scope, (operatorSignature >>> 8) & 0x0000F),
originalRightType);
this.bits |= operatorSignature & 0xF;
if ((operatorSignature & 0x0000F) == T_undefined) {
this.constant = Constant.NotAConstant;
scope.problemReporter().invalidOperator(this, leftType, rightType);
return null;
}
// check need for operand cast
if (leftIsCast || rightIsCast) {
CastExpression.checkNeedForArgumentCasts(
scope,
EQUAL_EQUAL,
operatorSignature,
this.left,
leftType.id,
leftIsCast,
this.right,
rightType.id,
rightIsCast);
}
computeConstant(leftType, rightType);
// check whether comparing identical expressions
Binding leftDirect = Expression.getDirectBinding(this.left);
if (leftDirect != null && leftDirect == Expression.getDirectBinding(this.right)) {
if (leftTypeID != TypeIds.T_double
&& leftTypeID != TypeIds.T_float
&& (!(this.right
instanceof Assignment))) // https://bugs.eclipse.org/bugs/show_bug.cgi?id=281776
scope.problemReporter().comparingIdenticalExpressions(this);
} else if (this.constant != Constant.NotAConstant) {
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=276740
int operator = (this.bits & OperatorMASK) >> OperatorSHIFT;
if ((operator == EQUAL_EQUAL && this.constant == BooleanConstant.fromValue(true))
|| (operator == NOT_EQUAL && this.constant == BooleanConstant.fromValue(false)))
scope.problemReporter().comparingIdenticalExpressions(this);
}
return this.resolvedType = TypeBinding.BOOLEAN;
}
// Object references
// spec 15.20.3
if ((!leftType.isBaseType() || leftType == TypeBinding.NULL) // cannot compare: Object == (int)0
&& (!rightType.isBaseType() || rightType == TypeBinding.NULL)
&& (checkCastTypesCompatibility(scope, leftType, rightType, null)
|| checkCastTypesCompatibility(scope, rightType, leftType, null))) {
// (special case for String)
if ((rightType.id == T_JavaLangString) && (leftType.id == T_JavaLangString)) {
computeConstant(leftType, rightType);
} else {
this.constant = Constant.NotAConstant;
}
TypeBinding objectType = scope.getJavaLangObject();
this.left.computeConversion(scope, objectType, leftType);
this.right.computeConversion(scope, objectType, rightType);
// check need for operand cast
boolean unnecessaryLeftCast = (this.left.bits & UnnecessaryCast) != 0;
boolean unnecessaryRightCast = (this.right.bits & UnnecessaryCast) != 0;
if (unnecessaryLeftCast || unnecessaryRightCast) {
TypeBinding alternateLeftType =
unnecessaryLeftCast ? ((CastExpression) this.left).expression.resolvedType : leftType;
TypeBinding alternateRightType =
unnecessaryRightCast
? ((CastExpression) this.right).expression.resolvedType
: rightType;
if (checkCastTypesCompatibility(scope, alternateLeftType, alternateRightType, null)
|| checkCastTypesCompatibility(scope, alternateRightType, alternateLeftType, null)) {
if (unnecessaryLeftCast)
scope.problemReporter().unnecessaryCast((CastExpression) this.left);
if (unnecessaryRightCast)
scope.problemReporter().unnecessaryCast((CastExpression) this.right);
}
}
// check whether comparing identical expressions
Binding leftDirect = Expression.getDirectBinding(this.left);
if (leftDirect != null && leftDirect == Expression.getDirectBinding(this.right)) {
if (!(this.right instanceof Assignment)) {
scope.problemReporter().comparingIdenticalExpressions(this);
}
}
return this.resolvedType = TypeBinding.BOOLEAN;
}
this.constant = Constant.NotAConstant;
scope.problemReporter().notCompatibleTypesError(this, leftType, rightType);
return null;
}
