Java Code Examples for org.eclipse.jdt.core.dom.Assignment#getOperator()

@Override
public void endVisit(Assignment node) {
	if (skipNode(node)) {
		return;
	}
	FlowInfo lhs = getFlowInfo(node.getLeftHandSide());
	FlowInfo rhs = getFlowInfo(node.getRightHandSide());
	if (lhs instanceof LocalFlowInfo) {
		LocalFlowInfo llhs = (LocalFlowInfo) lhs;
		llhs.setWriteAccess(fFlowContext);
		if (node.getOperator() != Assignment.Operator.ASSIGN) {
			GenericSequentialFlowInfo tmp = createSequential();
			tmp.merge(new LocalFlowInfo(llhs, FlowInfo.READ, fFlowContext), fFlowContext);
			tmp.merge(rhs, fFlowContext);
			rhs = tmp;
		}
	}
	GenericSequentialFlowInfo info = createSequential(node);
	// first process right and side and then left hand side.
	info.merge(rhs, fFlowContext);
	info.merge(lhs, fFlowContext);
}
 

@Override
public void endVisit(Assignment node) {
	Expression lhs= node.getLeftHandSide();
	Expression rhs= node.getRightHandSide();

	ConstraintVariable2 left= getConstraintVariable(lhs);
	ConstraintVariable2 right= getConstraintVariable(rhs);
	if (node.resolveBoxing()) {
		ImmutableTypeVariable2 boxed= fTCModel.makeImmutableTypeVariable(node.resolveTypeBinding(), node);
		setConstraintVariable(node, boxed);
	} else {
		setConstraintVariable(node, left); // type of assignement is type of 'left'
	}
	if (left == null || right == null)
		return;

	Assignment.Operator op= node.getOperator();
	if (op == Assignment.Operator.PLUS_ASSIGN && (lhs.resolveTypeBinding() == node.getAST().resolveWellKnownType("java.lang.String"))) { //$NON-NLS-1$
		//Special handling for automatic String conversion: do nothing; the RHS can be anything.
	} else {
		fTCModel.createElementEqualsConstraints(left, right);
		fTCModel.createSubtypeConstraint(right, left); // left= right;  -->  [right] <= [left]
	}
	//TODO: other implicit conversions: numeric promotion, autoboxing?
}
 

@Override
public void endVisit(Assignment node) {
	if (skipNode(node))
		return;
	FlowInfo lhs= getFlowInfo(node.getLeftHandSide());
	FlowInfo rhs= getFlowInfo(node.getRightHandSide());
	if (lhs instanceof LocalFlowInfo) {
		LocalFlowInfo llhs= (LocalFlowInfo)lhs;
		llhs.setWriteAccess(fFlowContext);
		if (node.getOperator() != Assignment.Operator.ASSIGN) {
			GenericSequentialFlowInfo tmp= createSequential();
			tmp.merge(new LocalFlowInfo(llhs, FlowInfo.READ, fFlowContext), fFlowContext);
			tmp.merge(rhs, fFlowContext);
			rhs= tmp;
		}
	}
	GenericSequentialFlowInfo info= createSequential(node);
	// first process right and side and then left hand side.
	info.merge(rhs, fFlowContext);
	info.merge(lhs, fFlowContext);
}
 

@Override
public void write(Assignment assignment) {
    Assignment.Operator operator = assignment.getOperator();

    writeNode(assignment.getLeftHandSide());

    copySpaceAndComments();
    if (operator == Assignment.Operator.ASSIGN)
        matchAndWrite("=");
    else if (operator == Assignment.Operator.PLUS_ASSIGN)
        matchAndWrite("+=");
    else if (operator == Assignment.Operator.MINUS_ASSIGN)
        matchAndWrite("-=");
    else if (operator == Assignment.Operator.TIMES_ASSIGN)
        matchAndWrite("*=");
    else if (operator == Assignment.Operator.DIVIDE_ASSIGN)
        matchAndWrite("/=");
    else if (operator == Assignment.Operator.BIT_AND_ASSIGN)
        matchAndWrite("&=");
    else if (operator == Assignment.Operator.BIT_OR_ASSIGN)
        matchAndWrite("|=");
    else if (operator == Assignment.Operator.BIT_XOR_ASSIGN)
        matchAndWrite("^=");
    else if (operator == Assignment.Operator.REMAINDER_ASSIGN)
        matchAndWrite("%=");
    else if (operator == Assignment.Operator.LEFT_SHIFT_ASSIGN)
        matchAndWrite("<<=");
    else if (operator == Assignment.Operator.RIGHT_SHIFT_SIGNED_ASSIGN)
        matchAndWrite(">>=");
    else if (operator == Assignment.Operator.RIGHT_SHIFT_UNSIGNED_ASSIGN)
        throw sourceNotSupported(">>>= operator not supported; change Java of the form 'a >>>= b' to 'a = a >>> b' instead, which is supported");

    copySpaceAndComments();
    writeNode(assignment.getRightHandSide());
}
 

@Override
public boolean visit(Assignment node) {
	Expression leftHandSide = node.getLeftHandSide();
	if (!considerBinding(resolveBinding(leftHandSide), leftHandSide)) {
		return true;
	}

	checkParent(node);
	Expression rightHandSide = node.getRightHandSide();
	if (!fIsFieldFinal) {
		// Write access.
		AST ast = node.getAST();
		MethodInvocation invocation = ast.newMethodInvocation();
		invocation.setName(ast.newSimpleName(fSetter));
		fReferencingSetter = true;
		Expression receiver = getReceiver(leftHandSide);
		if (receiver != null) {
			invocation.setExpression((Expression) fRewriter.createCopyTarget(receiver));
		}
		List<Expression> arguments = invocation.arguments();
		if (node.getOperator() == Assignment.Operator.ASSIGN) {
			arguments.add((Expression) fRewriter.createCopyTarget(rightHandSide));
		} else {
			// This is the compound assignment case: field+= 10;
			InfixExpression exp = ast.newInfixExpression();
			exp.setOperator(ASTNodes.convertToInfixOperator(node.getOperator()));
			MethodInvocation getter = ast.newMethodInvocation();
			getter.setName(ast.newSimpleName(fGetter));
			fReferencingGetter = true;
			if (receiver != null) {
				getter.setExpression((Expression) fRewriter.createCopyTarget(receiver));
			}
			exp.setLeftOperand(getter);
			Expression rhs = (Expression) fRewriter.createCopyTarget(rightHandSide);
			if (NecessaryParenthesesChecker.needsParenthesesForRightOperand(rightHandSide, exp, leftHandSide.resolveTypeBinding())) {
				ParenthesizedExpression p = ast.newParenthesizedExpression();
				p.setExpression(rhs);
				rhs = p;
			}
			exp.setRightOperand(rhs);
			arguments.add(exp);
		}
		fRewriter.replace(node, invocation, createGroupDescription(WRITE_ACCESS));
	}
	rightHandSide.accept(this);
	return false;
}
 

@Override
public boolean visit(Assignment node) {
	Expression leftHandSide= node.getLeftHandSide();
	if (!considerBinding(resolveBinding(leftHandSide), leftHandSide))
		return true;

	checkParent(node);
	Expression rightHandSide= node.getRightHandSide();
	if (!fIsFieldFinal) {
		// Write access.
		AST ast= node.getAST();
		MethodInvocation invocation= ast.newMethodInvocation();
		invocation.setName(ast.newSimpleName(fSetter));
		fReferencingSetter= true;
		Expression receiver= getReceiver(leftHandSide);
		if (receiver != null)
			invocation.setExpression((Expression)fRewriter.createCopyTarget(receiver));
		List<Expression> arguments= invocation.arguments();
		if (node.getOperator() == Assignment.Operator.ASSIGN) {
			arguments.add((Expression)fRewriter.createCopyTarget(rightHandSide));
		} else {
			// This is the compound assignment case: field+= 10;
			InfixExpression exp= ast.newInfixExpression();
			exp.setOperator(ASTNodes.convertToInfixOperator(node.getOperator()));
			MethodInvocation getter= ast.newMethodInvocation();
			getter.setName(ast.newSimpleName(fGetter));
			fReferencingGetter= true;
			if (receiver != null)
				getter.setExpression((Expression)fRewriter.createCopyTarget(receiver));
			exp.setLeftOperand(getter);
			Expression rhs= (Expression)fRewriter.createCopyTarget(rightHandSide);
			if (NecessaryParenthesesChecker.needsParenthesesForRightOperand(rightHandSide, exp, leftHandSide.resolveTypeBinding())) {
				ParenthesizedExpression p= ast.newParenthesizedExpression();
				p.setExpression(rhs);
				rhs= p;
			}
			exp.setRightOperand(rhs);
			arguments.add(exp);
		}
		fRewriter.replace(node, invocation, createGroupDescription(WRITE_ACCESS));
	}
	rightHandSide.accept(this);
	return false;
}
 

/**
 * Converts an assignment, postfix expression or prefix expression into an assignable equivalent expression using the getter.
 *
 * @param node the assignment/prefix/postfix node
 * @param astRewrite the astRewrite to use
 * @param getterExpression the expression to insert for read accesses or <code>null</code> if such an expression does not exist
 * @param variableType the type of the variable that the result will be assigned to
 * @param is50OrHigher <code>true</code> if a 5.0 or higher environment can be used
 * @return an expression that can be assigned to the type variableType with node being replaced by a equivalent expression using the getter
 */
public static Expression getAssignedValue(ASTNode node, ASTRewrite astRewrite, Expression getterExpression, ITypeBinding variableType, boolean is50OrHigher) {
	InfixExpression.Operator op= null;
	AST ast= astRewrite.getAST();
	if (isNotInBlock(node))
		return null;
	if (node.getNodeType() == ASTNode.ASSIGNMENT) {
		Assignment assignment= ((Assignment) node);
		Expression rightHandSide= assignment.getRightHandSide();
		Expression copiedRightOp= (Expression) astRewrite.createCopyTarget(rightHandSide);
		if (assignment.getOperator() == Operator.ASSIGN) {
			ITypeBinding rightHandSideType= rightHandSide.resolveTypeBinding();
			copiedRightOp= createNarrowCastIfNessecary(copiedRightOp, rightHandSideType, ast, variableType, is50OrHigher);
			return copiedRightOp;
		}
		if (getterExpression != null) {
			InfixExpression infix= ast.newInfixExpression();
			infix.setLeftOperand(getterExpression);
			infix.setOperator(ASTNodes.convertToInfixOperator(assignment.getOperator()));
			ITypeBinding infixType= infix.resolveTypeBinding();
			if (NecessaryParenthesesChecker.needsParenthesesForRightOperand(rightHandSide, infix, variableType)) {
				ParenthesizedExpression p= ast.newParenthesizedExpression();
				p.setExpression(copiedRightOp);
				copiedRightOp= p;
			}
			infix.setRightOperand(copiedRightOp);
			return createNarrowCastIfNessecary(infix, infixType, ast, variableType, is50OrHigher);
		}
	} else if (node.getNodeType() == ASTNode.POSTFIX_EXPRESSION) {
		PostfixExpression po= (PostfixExpression) node;
		if (po.getOperator() == PostfixExpression.Operator.INCREMENT)
			op= InfixExpression.Operator.PLUS;
		if (po.getOperator() == PostfixExpression.Operator.DECREMENT)
			op= InfixExpression.Operator.MINUS;
	} else if (node.getNodeType() == ASTNode.PREFIX_EXPRESSION) {
		PrefixExpression pe= (PrefixExpression) node;
		if (pe.getOperator() == PrefixExpression.Operator.INCREMENT)
			op= InfixExpression.Operator.PLUS;
		if (pe.getOperator() == PrefixExpression.Operator.DECREMENT)
			op= InfixExpression.Operator.MINUS;
	}
	if (op != null && getterExpression != null) {
		return createInfixInvocationFromPostPrefixExpression(op, getterExpression, ast, variableType, is50OrHigher);
	}
	return null;
}
 

private static List<ASTNode> getValueContributingModifiers(SimpleName variable)
{
	List<ASTNode> allVariableModifiers  = getAllVariableModifiersInParentMethod(variable);
	List<ASTNode> contributingModifiers = new ArrayList<ASTNode>();
	boolean noModifierInLowerScope      = true;
	MethodDeclaration parentMethod      = AbstractLoopUtilities.findParentMethodDeclaration(variable);
	// create a list of all parents of the specified variable until the root method
	List<ASTNode> variableParents = new ArrayList<ASTNode>();
	ASTNode currentVariableParent = variable.getParent();
	while (currentVariableParent != null && currentVariableParent != parentMethod)
	{
		variableParents.add(currentVariableParent);
		currentVariableParent = currentVariableParent.getParent();
	}
	variableParents.add(parentMethod);
	// we traverse allVariableModifiers and build a list of nodes that will influence the final value
	Iterator<ASTNode> it = allVariableModifiers.iterator();
	while (it.hasNext())
	{
		ASTNode currentNode = it.next();
		boolean currentNodeAdded = false;
		// if the current node is the declaration or an assignment, the list restarts the modifiers. if it is a plus, minus, times, or divide equals, then it adds to the modifiers
		if (currentNode instanceof VariableDeclaration)
		{
			contributingModifiers = new ArrayList<ASTNode>();
			contributingModifiers.add(currentNode);
			currentNodeAdded = true;
			noModifierInLowerScope = true;
		}
		else if (currentNode instanceof Assignment)
		{
			Assignment assignment = (Assignment) currentNode;
			Assignment.Operator operator = assignment.getOperator();
			if (operator == Assignment.Operator.ASSIGN)
			{
				contributingModifiers = new ArrayList<ASTNode>();
				contributingModifiers.add(currentNode);
				currentNodeAdded = true;
				noModifierInLowerScope = true;
			}
			else if (operator == Assignment.Operator.PLUS_ASSIGN ||
					operator == Assignment.Operator.MINUS_ASSIGN ||
					operator == Assignment.Operator.TIMES_ASSIGN ||
					operator == Assignment.Operator.DIVIDE_ASSIGN)
			{
				contributingModifiers.add(currentNode);
				currentNodeAdded = true;
			}				
		}
		else if (currentNode instanceof PrefixExpression || currentNode instanceof PostfixExpression)
		{
			contributingModifiers.add(currentNode);
			currentNodeAdded = true;
		}
		else if (currentNode instanceof MethodInvocation)
		{
			MethodInvocation currentMethodInvocation = (MethodInvocation) currentNode;
			AbstractLoopBindingInformation bindingInformation = AbstractLoopBindingInformation.getInstance();
			String currentMethodBindingKey = currentMethodInvocation.resolveMethodBinding().getMethodDeclaration().getKey();
			if (bindingInformation.updateMethodValuesContains(currentMethodBindingKey))
			{
				contributingModifiers.add(currentNode);
				currentNodeAdded = true;
			}
		}
		// if currentNode was added, move up through it's parents until the first block or conditional parent and check if it is in the variableParents list, if not, it is in a lower scope
		if (currentNodeAdded)
		{
			ASTNode currentNodeParent = currentNode.getParent();
			while (currentNodeParent != null)
			{
				if ((currentNodeParent instanceof MethodDeclaration || currentNodeParent instanceof IfStatement || currentNodeParent instanceof ForStatement ||
						currentNodeParent instanceof WhileStatement || currentNodeParent instanceof DoStatement || currentNodeParent instanceof EnhancedForStatement ||
						currentNodeParent instanceof SwitchStatement || currentNodeParent instanceof TryStatement))
				{
					if (!variableParents.contains(currentNodeParent))
					{
						noModifierInLowerScope = false;
					}
					break;
				}
				currentNodeParent = currentNodeParent.getParent();
			}
		}
	}
	// return constructed list if all modifiers are in same or higher scope
	if (noModifierInLowerScope)
	{
		return contributingModifiers;
	}
	return new ArrayList<ASTNode>();
}
 

private static Integer assignmentUpdateValue(Assignment assignment)
{
	Integer updateValue          = null;
	Expression leftHandSide      = assignment.getLeftHandSide();
	Assignment.Operator operator = assignment.getOperator();
	Expression rightHandSide     = assignment.getRightHandSide();
	if (operator == Assignment.Operator.PLUS_ASSIGN)
	{			
		updateValue = AbstractLoopUtilities.getIntegerValue(rightHandSide);
	}
	else if (operator == Assignment.Operator.MINUS_ASSIGN)
	{
		Integer rightHandSideIntegerValue = AbstractLoopUtilities.getIntegerValue(rightHandSide);
		if (rightHandSideIntegerValue != null)
		{
			updateValue = (-1) * rightHandSideIntegerValue;
		}
	}
	else if (leftHandSide instanceof SimpleName && operator == Assignment.Operator.ASSIGN && rightHandSide instanceof InfixExpression)
	{
		SimpleName leftHandSideSimpleName      = (SimpleName) leftHandSide;
		IBinding leftHandSideBinding           = leftHandSideSimpleName.resolveBinding();
		InfixExpression infixExpression        = (InfixExpression) rightHandSide;
		InfixExpression.Operator infixOperator = infixExpression.getOperator();
		Expression rightOperand                = infixExpression.getRightOperand();
		Expression leftOperand                 = infixExpression.getLeftOperand();
		if (infixOperator.toString().equals("+") || infixOperator.toString().equals("-"))
		{
			if (leftOperand instanceof SimpleName)
			{
				SimpleName leftOperandSimpleName = (SimpleName) leftOperand;
				IBinding leftOperandBinding      = leftOperandSimpleName.resolveBinding();
				if (leftOperandBinding.isEqualTo(leftHandSideBinding))
				{
					Integer rightOperandIntegerValue = AbstractLoopUtilities.getIntegerValue(rightOperand);
					if (infixOperator.toString().equals("+") && rightOperandIntegerValue != null)
					{
						updateValue = rightOperandIntegerValue;
					}
					else if (infixOperator.toString().equals("-") && rightOperandIntegerValue != null)
					{
						updateValue = (-1) * rightOperandIntegerValue;
					}
				}
			}
			else if (rightOperand instanceof SimpleName)
			{
				SimpleName rightOperandSimpleName = (SimpleName) rightOperand;
				IBinding rightOperandBinding      = rightOperandSimpleName.resolveBinding();
				if (rightOperandBinding.isEqualTo(leftHandSideBinding))
				{
					Integer leftOperandIntegerValue = AbstractLoopUtilities.getIntegerValue(leftOperand);
					if (infixOperator.toString().equals("+") && leftOperandIntegerValue != null)
					{
						updateValue = leftOperandIntegerValue;
					}
				}
			}
		}
	}
	return updateValue;
}
 

@Override
public void write(Assignment assignment) {
    Assignment.Operator operator = assignment.getOperator();

    if (operator == Assignment.Operator.RIGHT_SHIFT_UNSIGNED_ASSIGN) {
        writeNode(assignment.getLeftHandSide());

        copySpaceAndComments();
        matchAndWrite(">>>=", "=");

        copySpaceAndComments();
        write("rightShiftUnsigned(");
        writeNodeAtDifferentPosition(assignment.getLeftHandSide());
        write(", ");
        writeNode(assignment.getRightHandSide());
        write(")");
    } else {
        writeNode(assignment.getLeftHandSide());

        copySpaceAndComments();
        if (operator == Assignment.Operator.ASSIGN)
            matchAndWrite("=");
        else if (operator == Assignment.Operator.PLUS_ASSIGN)
            matchAndWrite("+=");
        else if (operator == Assignment.Operator.MINUS_ASSIGN)
            matchAndWrite("-=");
        else if (operator == Assignment.Operator.TIMES_ASSIGN)
            matchAndWrite("*=");
        else if (operator == Assignment.Operator.DIVIDE_ASSIGN)
            matchAndWrite("/=");
        else if (operator == Assignment.Operator.BIT_AND_ASSIGN)
            matchAndWrite("&=");
        else if (operator == Assignment.Operator.BIT_OR_ASSIGN)
            matchAndWrite("|=");
        else if (operator == Assignment.Operator.BIT_XOR_ASSIGN)
            matchAndWrite("^=");
        else if (operator == Assignment.Operator.REMAINDER_ASSIGN)
            matchAndWrite("%=");
        else if (operator == Assignment.Operator.LEFT_SHIFT_ASSIGN)
            matchAndWrite("<<=");
        else if (operator == Assignment.Operator.RIGHT_SHIFT_SIGNED_ASSIGN)
            matchAndWrite(">>=");
        else if (operator == Assignment.Operator.RIGHT_SHIFT_UNSIGNED_ASSIGN)
            matchAndWrite(">>>=");

        copySpaceAndComments();
        writeNode(assignment.getRightHandSide());
    }
}