public void traverse(ASTVisitor visitor, BlockScope scope) {
if (visitor.visit(this, scope)) {
lhs.traverse(visitor, scope);
expression.traverse(visitor, scope);
}
visitor.endVisit(this, scope);
}
public Assignment(Expression lhs, Expression expression, int sourceEnd) {
// lhs is always a reference by construction ,
// but is build as an expression ==> the checkcast cannot fail
this.lhs = lhs;
lhs.bits |= IsStrictlyAssigned; // tag lhs as assigned
this.expression = expression;
this.sourceStart = lhs.sourceStart;
this.sourceEnd = sourceEnd;
}
public TypeBinding resolveType(BlockScope scope) {
// due to syntax lhs may be only a NameReference, a FieldReference or an ArrayReference
this.constant = Constant.NotAConstant;
if (!(this.lhs instanceof Reference) || this.lhs.isThis()) {
scope.problemReporter().expressionShouldBeAVariable(this.lhs);
return null;
}
TypeBinding lhsType = lhs.resolveType(scope);
this.expression.setExpectedType(lhsType); // needed in case of generic method invocation
if (lhsType != null) {
this.resolvedType = lhsType.capture(scope, this.sourceEnd);
}
TypeBinding rhsType = this.expression.resolveType(scope);
if (lhsType == null || rhsType == null) {
return null;
}
// check for assignment with no effect
Binding left = getDirectBinding(this.lhs);
if (left != null && left == getDirectBinding(this.expression)) {
scope.problemReporter().assignmentHasNoEffect(this, left.shortReadableName());
}
// Compile-time conversion of base-types : implicit narrowing integer into byte/short/character
// may require to widen the rhs expression at runtime
if (lhsType != rhsType) { // must call before computeConversion() and typeMismatchError()
scope.compilationUnitScope().recordTypeConversion(lhsType, rhsType);
}
if ((this.expression.isConstantValueOfTypeAssignableToType(rhsType, lhsType)
|| (lhsType.isBaseType() && BaseTypeBinding.isWidening(lhsType.id, rhsType.id)))
|| rhsType.isCompatibleWith(lhsType)) {
this.expression.computeConversion(scope, lhsType, rhsType);
checkAssignment(scope, lhsType, rhsType);
if (this.expression instanceof CastExpression
&& (this.expression.bits & ASTNode.UnnecessaryCast) == 0) {
CastExpression.checkNeedForAssignedCast(scope, lhsType, (CastExpression) this.expression);
}
return this.resolvedType;
} else if (scope.isBoxingCompatibleWith(rhsType, lhsType)
|| (rhsType.isBaseType() // narrowing then boxing ?
&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
&& !lhsType.isBaseType()
&& this.expression.isConstantValueOfTypeAssignableToType(
rhsType, scope.environment().computeBoxingType(lhsType)))) {
this.expression.computeConversion(scope, lhsType, rhsType);
if (this.expression instanceof CastExpression
&& (this.expression.bits & ASTNode.UnnecessaryCast) == 0) {
CastExpression.checkNeedForAssignedCast(scope, lhsType, (CastExpression) this.expression);
}
return this.resolvedType;
}
scope.problemReporter().typeMismatchError(rhsType, lhsType, this.expression, this.lhs);
return lhsType;
}
// expression.implicitConversion holds the cast for baseType casting
public CastExpression(Expression expression, Expression type) {
this.expression = expression;
this.type = type;
type.bits |= ASTNode.IgnoreRawTypeCheck; // no need to worry about raw type usage
}
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 TypeBinding[] genericTypeArguments() {
return null;
}
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) {
int argumentLength = originalArgumentTypes.length;
if (binding.isVarargs()) {
int paramLength = binding.parameters.length;
if (paramLength == argumentLength) {
int varargsIndex = paramLength - 1;
ArrayBinding varargsType = (ArrayBinding) binding.parameters[varargsIndex];
TypeBinding lastArgType = alternateArgumentTypes[varargsIndex];
// originalType may be compatible already, but cast mandated
// to clarify between varargs/non-varargs call
if (varargsType.dimensions != lastArgType.dimensions()) {
return;
}
if (lastArgType.isCompatibleWith(varargsType.elementsType())
&& lastArgType.isCompatibleWith(varargsType)) {
return;
}
}
}
for (int i = 0; i < argumentLength; i++) {
if (originalArgumentTypes[i] != alternateArgumentTypes[i]) {
scope.problemReporter().unnecessaryCast((CastExpression) arguments[i]);
}
}
}
}
public LocalVariableBinding localVariableBinding() {
return lhs.localVariableBinding();
}
public StringBuffer printExpressionNoParenthesis(int indent, StringBuffer output) {
lhs.printExpression(indent, output).append(" = "); // $NON-NLS-1$
return expression.printExpression(0, output);
}