/**
* Complain if cast expression is cast, but not actually needed, int i = (int)(Integer) 12; Note
* that this (int) cast is however needed: Integer i = 0; char c = (char)((int) i);
*/
public static void checkNeedForCastCast(BlockScope scope, CastExpression enclosingCast) {
if (scope.compilerOptions().getSeverity(CompilerOptions.UnnecessaryTypeCheck)
== ProblemSeverities.Ignore) return;
CastExpression nestedCast = (CastExpression) enclosingCast.expression;
if ((nestedCast.bits & ASTNode.UnnecessaryCast) == 0) return;
// check if could cast directly to enclosing cast type, without intermediate type cast
CastExpression alternateCast = new CastExpression(null, enclosingCast.type);
alternateCast.resolvedType = enclosingCast.resolvedType;
if (!alternateCast.checkCastTypesCompatibility(
scope,
enclosingCast.resolvedType,
nestedCast.expression.resolvedType,
null /* no expr to avoid side-effects*/)) return;
scope.problemReporter().unnecessaryCast(nestedCast);
}
/** Give 2 clones! */
private Expression longToIntForHashCode(Expression ref1, Expression ref2, ASTNode source) {
int pS = source.sourceStart, pE = source.sourceEnd;
/* (int)(ref >>> 32 ^ ref) */
IntLiteral int32 = new IntLiteral("32".toCharArray(), pS, pE);
Eclipse.setGeneratedBy(int32, source);
BinaryExpression higherBits =
new BinaryExpression(ref1, int32, OperatorIds.UNSIGNED_RIGHT_SHIFT);
Eclipse.setGeneratedBy(higherBits, source);
BinaryExpression xorParts = new BinaryExpression(ref2, higherBits, OperatorIds.XOR);
Eclipse.setGeneratedBy(xorParts, source);
TypeReference intRef = TypeReference.baseTypeReference(TypeIds.T_int, 0);
intRef.sourceStart = pS;
intRef.sourceEnd = pE;
Eclipse.setGeneratedBy(intRef, source);
CastExpression expr = new CastExpression(xorParts, intRef);
expr.sourceStart = pS;
expr.sourceEnd = pE;
Eclipse.setGeneratedBy(expr, source);
return expr;
}
public void resolve(MethodScope var1) {
if ((this.field_446 & 16) == 0) {
if (this.binding != null && this.binding.isValidBinding()) {
this.field_446 |= 16;
ClassScope var2 = var1.method_582();
if (var2 != null) {
label338:
{
SourceTypeBinding var3 = var2.enclosingSourceType();
if (var3.superclass != null) {
FieldBinding var4 = var2.findField(var3.superclass, this.name, this, false);
if (var4 != null && var4.isValidBinding()) {
label334:
{
if (var4 instanceof FieldBinding) {
FieldBinding var5 = (FieldBinding) var4;
if (var5.original() == this.binding || !var5.canBeSeenBy(var3, this, var1)) {
break label334;
}
}
var1.problemReporter().fieldHiding(this, var4);
break label338;
}
}
}
Scope var13 = var2.parent;
if (var13.kind != 4) {
Binding var15 = var13.getBinding(this.name, 3, this, false);
if (var15 != null && var15.isValidBinding() && var15 != this.binding) {
label323:
{
if (var15 instanceof FieldBinding) {
FieldBinding var6 = (FieldBinding) var15;
if (var6.original() == this.binding
|| !var6.method_431() && var3.method_226()) {
break label323;
}
}
var1.problemReporter().fieldHiding(this, var15);
}
}
}
}
}
if (this.type != null) {
this.type.resolvedType = this.binding.type;
}
FieldBinding var12 = var1.initializedField;
int var14 = var1.field_407;
try {
var1.initializedField = this.binding;
var1.field_407 = this.binding.field_304;
method_761(var1, this.annotations, this.binding);
if ((this.binding.getAnnotationTagBits() & 70368744177664L) == 0L
&& (this.binding.field_300 & 1048576) != 0
&& var1.compilerOptions().field_1928 >= 3211264L) {
var1.problemReporter().method_1675(this);
}
if (this.initialization == null) {
this.binding.setConstant(Constant.NotAConstant);
} else {
this.binding.setConstant(Constant.NotAConstant);
TypeBinding var17 = this.binding.type;
this.initialization.setExpectedType(var17);
TypeBinding var18;
if (this.initialization instanceof ArrayInitializer) {
if ((var18 = this.initialization.resolveTypeExpecting(var1, var17)) != null) {
((ArrayInitializer) this.initialization).binding = (ArrayBinding) var18;
this.initialization.computeConversion(var1, var17, var18);
}
} else if ((var18 = this.initialization.resolveType(var1)) != null) {
if (var17 != var18) {
var1.compilationUnitScope().recordTypeConversion(var17, var18);
}
if (!this.initialization.isConstantValueOfTypeAssignableToType(var18, var17)
&& (!var17.method_148() || !BaseTypeBinding.method_185(var17.id, var18.id))
&& !var18.isCompatibleWith(var17)) {
if (!var1.isBoxingCompatibleWith(var18, var17)
&& (!var18.method_148()
|| var1.compilerOptions().field_1928 < 3211264L
|| var17.method_148()
|| !this.initialization.isConstantValueOfTypeAssignableToType(
var18, var1.environment().method_486(var17)))) {
if ((var17.tagBits & 128L) == 0L) {
var1.problemReporter()
.typeMismatchError(var18, var17, this.initialization, (ASTNode) null);
}
} else {
this.initialization.computeConversion(var1, var17, var18);
if (this.initialization instanceof CastExpression
&& (this.initialization.field_446 & 16384) == 0) {
CastExpression.checkNeedForAssignedCast(
var1, var17, (CastExpression) this.initialization);
}
}
} else {
this.initialization.computeConversion(var1, var17, var18);
if (var18.method_174(var17)) {
var1.problemReporter().method_1806(this.initialization, var18, var17);
}
if (this.initialization instanceof CastExpression
&& (this.initialization.field_446 & 16384) == 0) {
CastExpression.checkNeedForAssignedCast(
var1, var17, (CastExpression) this.initialization);
}
}
if (this.binding.method_409()) {
this.binding.setConstant(
this.initialization.constant.castTo(
(this.binding.type.id << 4) + this.initialization.constant.typeID()));
}
} else {
this.binding.setConstant(Constant.NotAConstant);
}
if (this.binding == Assignment.method_944(this.initialization)) {
var1.problemReporter().assignmentHasNoEffect(this, this.name);
}
}
if (this.binding != null
&& this.binding.declaringClass != null
&& !this.binding.declaringClass.method_158()) {
int var16 = this.binding.field_300 & 7;
ProblemReporter var19 = var1.problemReporter();
int var7 = var19.computeSeverity(-1610612250);
if (var7 != -1) {
if (var2 != null) {
var16 = Util.computeOuterMostVisibility(var2.referenceType(), var16);
}
int var8 = this.binding.field_300 & -8 | var16;
}
}
} finally {
var1.initializedField = var12;
var1.field_407 = var14;
if (this.binding.constant() == null) {
this.binding.setConstant(Constant.NotAConstant);
}
}
}
}
}
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 static boolean checkInvocationArguments(
BlockScope scope,
Expression receiver,
TypeBinding receiverType,
MethodBinding method,
Expression[] arguments,
TypeBinding[] argumentTypes,
boolean argsContainCast,
InvocationSite invocationSite) {
TypeBinding[] params = method.parameters;
int paramLength = params.length;
boolean isRawMemberInvocation =
!method.isStatic()
&& !receiverType.isUnboundWildcard()
&& method.declaringClass.isRawType()
&& method.hasSubstitutedParameters();
boolean uncheckedBoundCheck =
(method.tagBits & TagBits.HasUncheckedTypeArgumentForBoundCheck) != 0;
MethodBinding rawOriginalGenericMethod = null;
if (!isRawMemberInvocation) {
if (method instanceof ParameterizedGenericMethodBinding) {
ParameterizedGenericMethodBinding paramMethod = (ParameterizedGenericMethodBinding) method;
if (paramMethod.isRaw && method.hasSubstitutedParameters()) {
rawOriginalGenericMethod = method.original();
}
}
}
int invocationStatus = INVOCATION_ARGUMENT_OK;
if (arguments == null) {
if (method.isVarargs()) {
TypeBinding parameterType =
((ArrayBinding) params[paramLength - 1])
.elementsType(); // no element was supplied for vararg parameter
if (!parameterType.isReifiable()) {
scope
.problemReporter()
.unsafeGenericArrayForVarargs(parameterType, (ASTNode) invocationSite);
}
}
} else {
if (method.isVarargs()) {
// 4 possibilities exist for a call to the vararg method foo(int i, long ... value) :
// foo(1), foo(1, 2), foo(1, 2, 3, 4) & foo(1, new long[] {1, 2})
int lastIndex = paramLength - 1;
for (int i = 0; i < lastIndex; i++) {
TypeBinding originalRawParam =
rawOriginalGenericMethod == null ? null : rawOriginalGenericMethod.parameters[i];
invocationStatus |=
checkInvocationArgument(
scope, arguments[i], params[i], argumentTypes[i], originalRawParam);
}
int argLength = arguments.length;
if (lastIndex < argLength) { // vararg argument was provided
TypeBinding parameterType = params[lastIndex];
TypeBinding originalRawParam = null;
if (paramLength != argLength
|| parameterType.dimensions() != argumentTypes[lastIndex].dimensions()) {
parameterType =
((ArrayBinding) parameterType)
.elementsType(); // single element was provided for vararg parameter
if (!parameterType.isReifiable()) {
scope
.problemReporter()
.unsafeGenericArrayForVarargs(parameterType, (ASTNode) invocationSite);
}
originalRawParam =
rawOriginalGenericMethod == null
? null
: ((ArrayBinding) rawOriginalGenericMethod.parameters[lastIndex])
.elementsType();
}
for (int i = lastIndex; i < argLength; i++) {
invocationStatus |=
checkInvocationArgument(
scope, arguments[i], parameterType, argumentTypes[i], originalRawParam);
}
}
if (paramLength == argLength) { // 70056
int varargsIndex = paramLength - 1;
ArrayBinding varargsType = (ArrayBinding) params[varargsIndex];
TypeBinding lastArgType = argumentTypes[varargsIndex];
int dimensions;
if (lastArgType == TypeBinding.NULL) {
if (!(varargsType.leafComponentType().isBaseType() && varargsType.dimensions() == 1))
scope.problemReporter().varargsArgumentNeedCast(method, lastArgType, invocationSite);
} else if (varargsType.dimensions <= (dimensions = lastArgType.dimensions())) {
if (lastArgType.leafComponentType().isBaseType()) {
dimensions--;
}
if (varargsType.dimensions < dimensions) {
scope.problemReporter().varargsArgumentNeedCast(method, lastArgType, invocationSite);
} else if (varargsType.dimensions == dimensions
&& lastArgType != varargsType
&& lastArgType.leafComponentType().erasure()
!= varargsType.leafComponentType.erasure()
&& lastArgType.isCompatibleWith(varargsType.elementsType())
&& lastArgType.isCompatibleWith(varargsType)) {
scope.problemReporter().varargsArgumentNeedCast(method, lastArgType, invocationSite);
}
}
}
} else {
for (int i = 0; i < paramLength; i++) {
TypeBinding originalRawParam =
rawOriginalGenericMethod == null ? null : rawOriginalGenericMethod.parameters[i];
invocationStatus |=
checkInvocationArgument(
scope, arguments[i], params[i], argumentTypes[i], originalRawParam);
}
}
if (argsContainCast) {
CastExpression.checkNeedForArgumentCasts(
scope, receiver, receiverType, method, arguments, argumentTypes, invocationSite);
}
}
if ((invocationStatus & INVOCATION_ARGUMENT_WILDCARD) != 0) {
scope
.problemReporter()
.wildcardInvocation((ASTNode) invocationSite, receiverType, method, argumentTypes);
} else if (!method.isStatic()
&& !receiverType.isUnboundWildcard()
&& method.declaringClass.isRawType()
&& method.hasSubstitutedParameters()) {
scope.problemReporter().unsafeRawInvocation((ASTNode) invocationSite, method);
} else if (rawOriginalGenericMethod != null
|| uncheckedBoundCheck
|| ((invocationStatus & INVOCATION_ARGUMENT_UNCHECKED) != 0
&& method instanceof ParameterizedGenericMethodBinding
/*&& method.returnType != scope.environment().convertToRawType(method.returnType.erasure(), true)*/ )) {
scope
.problemReporter()
.unsafeRawGenericMethodInvocation((ASTNode) invocationSite, method, argumentTypes);
return true;
}
return false;
}
private MethodDeclaration createEquals(
EclipseNode type,
Collection<EclipseNode> fields,
boolean callSuper,
ASTNode source,
FieldAccess fieldAccess,
boolean needsCanEqual) {
int pS = source.sourceStart;
int pE = source.sourceEnd;
long p = (long) pS << 32 | pE;
TypeDeclaration typeDecl = (TypeDeclaration) type.get();
MethodDeclaration method =
new MethodDeclaration(((CompilationUnitDeclaration) type.top().get()).compilationResult);
Eclipse.setGeneratedBy(method, source);
method.modifiers = EclipseHandlerUtil.toEclipseModifier(AccessLevel.PUBLIC);
method.returnType = TypeReference.baseTypeReference(TypeIds.T_boolean, 0);
method.returnType.sourceStart = pS;
method.returnType.sourceEnd = pE;
Eclipse.setGeneratedBy(method.returnType, source);
method.annotations =
new Annotation[] {makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, source)};
method.selector = "equals".toCharArray();
method.thrownExceptions = null;
method.typeParameters = null;
method.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
method.bodyStart = method.declarationSourceStart = method.sourceStart = source.sourceStart;
method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = source.sourceEnd;
TypeReference objectRef =
new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, new long[] {p, p, p});
Eclipse.setGeneratedBy(objectRef, source);
method.arguments =
new Argument[] {new Argument(new char[] {'o'}, 0, objectRef, Modifier.FINAL)};
method.arguments[0].sourceStart = pS;
method.arguments[0].sourceEnd = pE;
Eclipse.setGeneratedBy(method.arguments[0], source);
List<Statement> statements = new ArrayList<Statement>();
/* if (o == this) return true; */ {
SingleNameReference oRef = new SingleNameReference(new char[] {'o'}, p);
Eclipse.setGeneratedBy(oRef, source);
ThisReference thisRef = new ThisReference(pS, pE);
Eclipse.setGeneratedBy(thisRef, source);
EqualExpression otherEqualsThis = new EqualExpression(oRef, thisRef, OperatorIds.EQUAL_EQUAL);
Eclipse.setGeneratedBy(otherEqualsThis, source);
TrueLiteral trueLiteral = new TrueLiteral(pS, pE);
Eclipse.setGeneratedBy(trueLiteral, source);
ReturnStatement returnTrue = new ReturnStatement(trueLiteral, pS, pE);
Eclipse.setGeneratedBy(returnTrue, source);
IfStatement ifOtherEqualsThis = new IfStatement(otherEqualsThis, returnTrue, pS, pE);
Eclipse.setGeneratedBy(ifOtherEqualsThis, source);
statements.add(ifOtherEqualsThis);
}
/* if (!(o instanceof MyType) return false; */ {
SingleNameReference oRef = new SingleNameReference(new char[] {'o'}, p);
Eclipse.setGeneratedBy(oRef, source);
SingleTypeReference typeReference = new SingleTypeReference(typeDecl.name, p);
Eclipse.setGeneratedBy(typeReference, source);
InstanceOfExpression instanceOf = new InstanceOfExpression(oRef, typeReference);
instanceOf.sourceStart = pS;
instanceOf.sourceEnd = pE;
Eclipse.setGeneratedBy(instanceOf, source);
Expression notInstanceOf = new UnaryExpression(instanceOf, OperatorIds.NOT);
Eclipse.setGeneratedBy(notInstanceOf, source);
FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
Eclipse.setGeneratedBy(falseLiteral, source);
ReturnStatement returnFalse = new ReturnStatement(falseLiteral, pS, pE);
Eclipse.setGeneratedBy(returnFalse, source);
IfStatement ifNotInstanceOf = new IfStatement(notInstanceOf, returnFalse, pS, pE);
Eclipse.setGeneratedBy(ifNotInstanceOf, source);
statements.add(ifNotInstanceOf);
}
char[] otherName = "other".toCharArray();
/* MyType<?> other = (MyType<?>) o; */ {
if (!fields.isEmpty() || needsCanEqual) {
LocalDeclaration other = new LocalDeclaration(otherName, pS, pE);
other.modifiers |= ClassFileConstants.AccFinal;
Eclipse.setGeneratedBy(other, source);
char[] typeName = typeDecl.name;
Expression targetType;
if (typeDecl.typeParameters == null || typeDecl.typeParameters.length == 0) {
targetType = new SingleNameReference(((TypeDeclaration) type.get()).name, p);
Eclipse.setGeneratedBy(targetType, source);
other.type = new SingleTypeReference(typeName, p);
Eclipse.setGeneratedBy(other.type, source);
} else {
TypeReference[] typeArgs = new TypeReference[typeDecl.typeParameters.length];
for (int i = 0; i < typeArgs.length; i++) {
typeArgs[i] = new Wildcard(Wildcard.UNBOUND);
typeArgs[i].sourceStart = pS;
typeArgs[i].sourceEnd = pE;
Eclipse.setGeneratedBy(typeArgs[i], source);
}
targetType = new ParameterizedSingleTypeReference(typeName, typeArgs, 0, p);
Eclipse.setGeneratedBy(targetType, source);
other.type =
new ParameterizedSingleTypeReference(typeName, copyTypes(typeArgs, source), 0, p);
Eclipse.setGeneratedBy(other.type, source);
}
NameReference oRef = new SingleNameReference(new char[] {'o'}, p);
Eclipse.setGeneratedBy(oRef, source);
other.initialization = new CastExpression(oRef, targetType);
Eclipse.setGeneratedBy(other.initialization, source);
statements.add(other);
}
}
/* if (!other.canEqual((java.lang.Object) this)) return false; */ {
if (needsCanEqual) {
MessageSend otherCanEqual = new MessageSend();
otherCanEqual.sourceStart = pS;
otherCanEqual.sourceEnd = pE;
Eclipse.setGeneratedBy(otherCanEqual, source);
otherCanEqual.receiver = new SingleNameReference(otherName, p);
Eclipse.setGeneratedBy(otherCanEqual.receiver, source);
otherCanEqual.selector = "canEqual".toCharArray();
ThisReference thisReference = new ThisReference(pS, pE);
Eclipse.setGeneratedBy(thisReference, source);
CastExpression castThisRef =
new CastExpression(
thisReference, generateQualifiedNameRef(source, TypeConstants.JAVA_LANG_OBJECT));
Eclipse.setGeneratedBy(castThisRef, source);
castThisRef.sourceStart = pS;
castThisRef.sourceEnd = pE;
otherCanEqual.arguments = new Expression[] {castThisRef};
Expression notOtherCanEqual = new UnaryExpression(otherCanEqual, OperatorIds.NOT);
Eclipse.setGeneratedBy(notOtherCanEqual, source);
FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
Eclipse.setGeneratedBy(falseLiteral, source);
ReturnStatement returnFalse = new ReturnStatement(falseLiteral, pS, pE);
Eclipse.setGeneratedBy(returnFalse, source);
IfStatement ifNotCanEqual = new IfStatement(notOtherCanEqual, returnFalse, pS, pE);
Eclipse.setGeneratedBy(ifNotCanEqual, source);
statements.add(ifNotCanEqual);
}
}
/* if (!super.equals(o)) return false; */
if (callSuper) {
MessageSend callToSuper = new MessageSend();
callToSuper.sourceStart = pS;
callToSuper.sourceEnd = pE;
Eclipse.setGeneratedBy(callToSuper, source);
callToSuper.receiver = new SuperReference(pS, pE);
Eclipse.setGeneratedBy(callToSuper.receiver, source);
callToSuper.selector = "equals".toCharArray();
SingleNameReference oRef = new SingleNameReference(new char[] {'o'}, p);
Eclipse.setGeneratedBy(oRef, source);
callToSuper.arguments = new Expression[] {oRef};
Expression superNotEqual = new UnaryExpression(callToSuper, OperatorIds.NOT);
Eclipse.setGeneratedBy(superNotEqual, source);
FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
Eclipse.setGeneratedBy(falseLiteral, source);
ReturnStatement returnFalse = new ReturnStatement(falseLiteral, pS, pE);
Eclipse.setGeneratedBy(returnFalse, source);
IfStatement ifSuperEquals = new IfStatement(superNotEqual, returnFalse, pS, pE);
Eclipse.setGeneratedBy(ifSuperEquals, source);
statements.add(ifSuperEquals);
}
for (EclipseNode field : fields) {
TypeReference fType = getFieldType(field, fieldAccess);
char[] token = fType.getLastToken();
Expression thisFieldAccessor = createFieldAccessor(field, fieldAccess, source);
Expression otherFieldAccessor = createFieldAccessor(field, fieldAccess, source, otherName);
if (fType.dimensions() == 0 && token != null) {
if (Arrays.equals(TypeConstants.FLOAT, token)) {
statements.add(
generateCompareFloatOrDouble(
thisFieldAccessor, otherFieldAccessor, "Float".toCharArray(), source));
} else if (Arrays.equals(TypeConstants.DOUBLE, token)) {
statements.add(
generateCompareFloatOrDouble(
thisFieldAccessor, otherFieldAccessor, "Double".toCharArray(), source));
} else if (BUILT_IN_TYPES.contains(new String(token))) {
EqualExpression fieldsNotEqual =
new EqualExpression(thisFieldAccessor, otherFieldAccessor, OperatorIds.NOT_EQUAL);
Eclipse.setGeneratedBy(fieldsNotEqual, source);
FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
Eclipse.setGeneratedBy(falseLiteral, source);
ReturnStatement returnStatement = new ReturnStatement(falseLiteral, pS, pE);
Eclipse.setGeneratedBy(returnStatement, source);
IfStatement ifStatement = new IfStatement(fieldsNotEqual, returnStatement, pS, pE);
Eclipse.setGeneratedBy(ifStatement, source);
statements.add(ifStatement);
} else /* objects */ {
NullLiteral nullLiteral = new NullLiteral(pS, pE);
Eclipse.setGeneratedBy(nullLiteral, source);
EqualExpression fieldIsNull =
new EqualExpression(thisFieldAccessor, nullLiteral, OperatorIds.EQUAL_EQUAL);
nullLiteral = new NullLiteral(pS, pE);
Eclipse.setGeneratedBy(nullLiteral, source);
EqualExpression otherFieldIsntNull =
new EqualExpression(otherFieldAccessor, nullLiteral, OperatorIds.NOT_EQUAL);
MessageSend equalsCall = new MessageSend();
equalsCall.sourceStart = pS;
equalsCall.sourceEnd = pE;
Eclipse.setGeneratedBy(equalsCall, source);
equalsCall.receiver = createFieldAccessor(field, fieldAccess, source);
equalsCall.selector = "equals".toCharArray();
Expression equalsArg = createFieldAccessor(field, fieldAccess, source, otherName);
CastExpression castEqualsArg =
new CastExpression(
equalsArg, generateQualifiedNameRef(source, TypeConstants.JAVA_LANG_OBJECT));
Eclipse.setGeneratedBy(castEqualsArg, source);
castEqualsArg.sourceStart = pS;
castEqualsArg.sourceEnd = pE;
equalsCall.arguments = new Expression[] {castEqualsArg};
UnaryExpression fieldsNotEqual = new UnaryExpression(equalsCall, OperatorIds.NOT);
fieldsNotEqual.sourceStart = pS;
fieldsNotEqual.sourceEnd = pE;
Eclipse.setGeneratedBy(fieldsNotEqual, source);
ConditionalExpression fullEquals =
new ConditionalExpression(fieldIsNull, otherFieldIsntNull, fieldsNotEqual);
fullEquals.sourceStart = pS;
fullEquals.sourceEnd = pE;
Eclipse.setGeneratedBy(fullEquals, source);
FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
Eclipse.setGeneratedBy(falseLiteral, source);
ReturnStatement returnStatement = new ReturnStatement(falseLiteral, pS, pE);
Eclipse.setGeneratedBy(returnStatement, source);
IfStatement ifStatement = new IfStatement(fullEquals, returnStatement, pS, pE);
Eclipse.setGeneratedBy(ifStatement, source);
statements.add(ifStatement);
}
} else if (fType.dimensions() > 0 && token != null) {
MessageSend arraysEqualCall = new MessageSend();
arraysEqualCall.sourceStart = pS;
arraysEqualCall.sourceEnd = pE;
Eclipse.setGeneratedBy(arraysEqualCall, source);
arraysEqualCall.receiver =
generateQualifiedNameRef(
source, TypeConstants.JAVA, TypeConstants.UTIL, "Arrays".toCharArray());
if (fType.dimensions() > 1 || !BUILT_IN_TYPES.contains(new String(token))) {
arraysEqualCall.selector = "deepEquals".toCharArray();
} else {
arraysEqualCall.selector = "equals".toCharArray();
}
arraysEqualCall.arguments = new Expression[] {thisFieldAccessor, otherFieldAccessor};
UnaryExpression arraysNotEqual = new UnaryExpression(arraysEqualCall, OperatorIds.NOT);
arraysNotEqual.sourceStart = pS;
arraysNotEqual.sourceEnd = pE;
Eclipse.setGeneratedBy(arraysNotEqual, source);
FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
Eclipse.setGeneratedBy(falseLiteral, source);
ReturnStatement returnStatement = new ReturnStatement(falseLiteral, pS, pE);
Eclipse.setGeneratedBy(returnStatement, source);
IfStatement ifStatement = new IfStatement(arraysNotEqual, returnStatement, pS, pE);
Eclipse.setGeneratedBy(ifStatement, source);
statements.add(ifStatement);
}
}
/* return true; */ {
TrueLiteral trueLiteral = new TrueLiteral(pS, pE);
Eclipse.setGeneratedBy(trueLiteral, source);
ReturnStatement returnStatement = new ReturnStatement(trueLiteral, pS, pE);
Eclipse.setGeneratedBy(returnStatement, source);
statements.add(returnStatement);
}
method.statements = statements.toArray(new Statement[statements.size()]);
return method;
}
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;
}