org.eclipse.jdt.core.dom.PostfixExpression Java Examples

private PostfixExpr visit(PostfixExpression node) {
	int startLine = _cunit.getLineNumber(node.getStartPosition());
	int endLine = _cunit.getLineNumber(node.getStartPosition() + node.getLength());
	PostfixExpr postfixExpr = new PostfixExpr(startLine, endLine, node);
	
	Expr expression = (Expr) process(node.getOperand());
	expression.setParent(postfixExpr);
	postfixExpr.setExpression(expression);
	
	postfixExpr.setOperator(node.getOperator());
	
	Type exprType = NodeUtils.parseExprType(expression, node.getOperator().toString(), null);
	postfixExpr.setType(exprType);
	
	return postfixExpr;
}
 

private boolean isUpdated(Expression expr) {
	if(expr.getParent() instanceof Assignment) {
		Assignment assignment = (Assignment)expr.getParent();
		if(assignment.getLeftHandSide().equals(expr)) {
			return true;
		}
	}
	else if(expr.getParent() instanceof PostfixExpression) {
		return true;
	}
	else if(expr.getParent() instanceof PrefixExpression) {
		PrefixExpression prefix = (PrefixExpression)expr.getParent();
		if(prefix.getOperator().equals(PrefixExpression.Operator.INCREMENT) ||
				prefix.getOperator().equals(PrefixExpression.Operator.DECREMENT)) {
			return true;
		}
	}
	return false;
}
 

@Override
public boolean visit(PostfixExpression node) {
	Expression operand= node.getOperand();
	if (!considerBinding(resolveBinding(operand), operand))
		return true;

	ASTNode parent= node.getParent();
	if (!(parent instanceof ExpressionStatement)) {
		fStatus.addError(RefactoringCoreMessages.SelfEncapsulateField_AccessAnalyzer_cannot_convert_postfix_expression,
			JavaStatusContext.create(fCUnit, SourceRangeFactory.create(node)));
		return false;
	}
	fRewriter.replace(node,
		createInvocation(node.getAST(), node.getOperand(), node.getOperator().toString()),
		createGroupDescription(POSTFIX_ACCESS));
	return false;
}
 

private static boolean isLeftValue(ASTNode node) {
	ASTNode parent = node.getParent();
	if (parent instanceof Assignment) {
		Assignment assignment = (Assignment) parent;
		if (assignment.getLeftHandSide() == node) {
			return true;
		}
	}
	if (parent instanceof PostfixExpression) {
		return true;
	}
	if (parent instanceof PrefixExpression) {
		PrefixExpression.Operator op = ((PrefixExpression) parent).getOperator();
		if (op.equals(PrefixExpression.Operator.DECREMENT)) {
			return true;
		}
		if (op.equals(PrefixExpression.Operator.INCREMENT)) {
			return true;
		}
		return false;
	}
	return false;
}
 

private static boolean isLeftValue(ASTNode node) {
	ASTNode parent = node.getParent();
	if (parent instanceof Assignment) {
		Assignment assignment = (Assignment) parent;
		if (assignment.getLeftHandSide() == node) {
			return true;
		}
	}
	if (parent instanceof PostfixExpression) {
		return true;
	}
	if (parent instanceof PrefixExpression) {
		PrefixExpression.Operator op = ((PrefixExpression) parent).getOperator();
		if (op.equals(PrefixExpression.Operator.DECREMENT)) {
			return true;
		}
		if (op.equals(PrefixExpression.Operator.INCREMENT)) {
			return true;
		}
		return false;
	}
	return false;
}
 

public static boolean isUpdatingVariable(Expression updater, SimpleName variable)
{
	if (updater instanceof PrefixExpression)
	{
		PrefixExpression prefixExpression = (PrefixExpression) updater;
		return isSameVariable(prefixExpression.getOperand(), variable);
	}
	else if (updater instanceof PostfixExpression)
	{
		PostfixExpression postfixExpression = (PostfixExpression) updater;
		return isSameVariable(postfixExpression.getOperand(), variable);			
	}
	else if (updater instanceof Assignment)
	{
		Assignment assignment = (Assignment) updater;
		return isSameVariable(assignment.getLeftHandSide(), variable);
	}
	else if (updater instanceof MethodInvocation)
	{
		MethodInvocation methodInvocation = (MethodInvocation) updater;
		return isSameVariable(methodInvocation.getExpression(), variable);
	}
	return false;
}
 

private static boolean isLeftValue(ASTNode node) {
	ASTNode parent= node.getParent();
	if (parent instanceof Assignment) {
		Assignment assignment= (Assignment) parent;
		if (assignment.getLeftHandSide() == node)
			return true;
	}
	if (parent instanceof PostfixExpression)
		return true;
	if (parent instanceof PrefixExpression) {
		PrefixExpression.Operator op= ((PrefixExpression) parent).getOperator();
		if (op.equals(PrefixExpression.Operator.DECREMENT))
			return true;
		if (op.equals(PrefixExpression.Operator.INCREMENT))
			return true;
		return false;
	}
	return false;
}
 

public static Integer getUpdateValue(Expression updater)
{
	if (updater instanceof PrefixExpression || updater instanceof PostfixExpression)
	{
		return AbstractLoopUtilities.getIncrementValue(updater);
	}
	else if (updater instanceof Assignment)
	{
		Assignment assignment = (Assignment) updater;
		return assignmentUpdateValue(assignment);
	}
	else if (updater instanceof MethodInvocation)
	{
		MethodInvocation methodInvocation = (MethodInvocation) updater;
		AbstractLoopBindingInformation bindingInformation = AbstractLoopBindingInformation.getInstance();
		return bindingInformation.getUpdateMethodValue(methodInvocation.resolveMethodBinding().getMethodDeclaration().getKey());
	}
	return null;
}
 

private static Integer getIncrementValue(Expression expression)
{
	Integer incrementValue = null;
	String operator = null;
	if (expression instanceof PrefixExpression)
	{
		PrefixExpression prefixExpression  = (PrefixExpression) expression;
		operator = prefixExpression.getOperator().toString();
	}
	else if (expression instanceof PostfixExpression)
	{
		PostfixExpression postfixExpression = (PostfixExpression) expression;
		operator = postfixExpression.getOperator().toString();
	}
	if (operator != null && operator.equals("++"))
	{
		incrementValue = 1;
	}
	else if (operator != null && operator.equals("--"))
	{
		incrementValue = (-1);
	}
	return incrementValue;
}
 

@Override
public boolean visit(PostfixExpression node) {
	SimpleName name= getSimpleName(node.getOperand());
	if (name != null)
		addWrite(name, name.resolveBinding());
	return true;
}
 

/**
 * Creates a {@link PostfixExpression} used to increment the loop variable of a <code>for</code>
 * loop to iterate over an array.
 * 
 * @param rewrite the current {@link ASTRewrite} instance
 * @param variableToIncrement the name of the variable to increment
 * @return a filled {@link PostfixExpression} realizing an incrementation of the specified
 *         variable
 */
private Expression getLinkedIncrementExpression(ASTRewrite rewrite, String variableToIncrement) {
	AST ast= rewrite.getAST();
	PostfixExpression incrementLoopVariable= ast.newPostfixExpression();
	SimpleName name= ast.newSimpleName(variableToIncrement);
	addLinkedPosition(rewrite.track(name), LinkedPositionGroup.NO_STOP, name.getIdentifier());
	incrementLoopVariable.setOperand(name);
	incrementLoopVariable.setOperator(PostfixExpression.Operator.INCREMENT);
	return incrementLoopVariable;
}
 

private Set<PostfixExpression> getMatchingPostfixAssignments(SimpleName simpleName, List<Expression> postfixExpressions) {
	Set<PostfixExpression> matchingPostfixAssignments = new LinkedHashSet<PostfixExpression>();
	for(Expression expression : postfixExpressions) {
		PostfixExpression postfixExpression = (PostfixExpression)expression;
		Expression operand = postfixExpression.getOperand();
		SimpleName operandName = MethodDeclarationUtility.getRightMostSimpleName(operand);
		if(operandName != null && operandName.equals(simpleName)) {
			matchingPostfixAssignments.add(postfixExpression);
		}
	}
	return matchingPostfixAssignments;
}
 

/**
 * Returns the precedence of the expression. Expression
 * with higher precedence are executed before expressions
 * with lower precedence.
 * i.e. in:
 * <br><code> int a= ++3--;</code></br>
 *
 * the  precedence order is
 * <ul>
 * <li>3</li>
 * <li>++</li>
 * <li>--</li>
 * <li>=</li>
 * </ul>
 * 1. 3 -(++)-> 4<br>
 * 2. 4 -(--)-> 3<br>
 * 3. 3 -(=)-> a<br>
 *
 * @param expression the expression to determine the precedence for
 * @return the precedence the higher to stronger the binding to its operand(s)
 */
public static int getExpressionPrecedence(Expression expression) {
	if (expression instanceof InfixExpression) {
		return getOperatorPrecedence(((InfixExpression)expression).getOperator());
	} else if (expression instanceof Assignment) {
		return ASSIGNMENT;
	} else if (expression instanceof ConditionalExpression) {
		return CONDITIONAL;
	} else if (expression instanceof InstanceofExpression) {
		return RELATIONAL;
	} else if (expression instanceof CastExpression) {
		return TYPEGENERATION;
	} else if (expression instanceof ClassInstanceCreation) {
		return POSTFIX;
	} else if (expression instanceof PrefixExpression) {
		return PREFIX;
	} else if (expression instanceof FieldAccess) {
		return POSTFIX;
	} else if (expression instanceof MethodInvocation) {
		return POSTFIX;
	} else if (expression instanceof ArrayAccess) {
		return POSTFIX;
	} else if (expression instanceof PostfixExpression) {
		return POSTFIX;
	}
	return Integer.MAX_VALUE;
}
 

@Override
public boolean visit(PostfixExpression postfixExpression) {
	if (postfixExpression.getOperand() == null)
		return true;
	if (! (postfixExpression.getOperand() instanceof SimpleName))
		return true;
	SimpleName simpleName= (SimpleName)postfixExpression.getOperand();
	if (! isNameReferenceToTemp(simpleName))
		return true;

	fFirstAssignment= postfixExpression;
	return false;
}
 

@Override
public final boolean visit(final PostfixExpression node) {
	final IVariableBinding binding= getFieldBinding(node.getOperand());
	if (binding != null)
		fWritten.add(binding.getKey());
	return true;
}
 

public static String buildASTLabel(ASTNode node) {
	String label = node.getClass().getSimpleName();
	if (node instanceof Expression) {
		if (node.getClass().getSimpleName().endsWith("Literal")) {
			return label + "(" + node.toString() + ")";
		}
		int type = node.getNodeType();
		switch (type) {
		case ASTNode.INFIX_EXPRESSION:
			return label + "(" + ((InfixExpression) node).getOperator().toString() + ")";
		case ASTNode.SIMPLE_NAME:
			return label + "(" + node.toString() + ")";
		case ASTNode.POSTFIX_EXPRESSION:
			return label + "(" + ((PostfixExpression) node).getOperator().toString() + ")";
		case ASTNode.PREFIX_EXPRESSION:
			return label + "(" + ((PrefixExpression) node).getOperator().toString() + ")";
		default:
			break;
		}
	} else if (node instanceof Modifier) {
		return label + "(" + node.toString() + ")";
	} else if (node instanceof Type) {
		if (node instanceof PrimitiveType)
			return label + "(" + node.toString() + ")";
	} else if (node instanceof TextElement) {
		return label + "(" + node.toString() + ")";
	} else if (node instanceof TagElement) {
		String tag = ((TagElement) node).getTagName();
		if (tag == null)
			return label;
		return label + "(" + tag + ")";
	}
	return label;
}
 

public static char buildLabelForVector(ASTNode node) {
	char label = (char) node.getNodeType();
	if (node instanceof Expression) {
		if (node.getClass().getSimpleName().endsWith("Literal")) {
			return (char) (label | (node.toString().hashCode() << 7));
		}
		int type = node.getNodeType();
		switch (type) {
		case ASTNode.INFIX_EXPRESSION:
			return (char) (label | (((InfixExpression) node).getOperator().toString().hashCode() << 7));
		case ASTNode.SIMPLE_NAME:
			return (char) (label | (node.toString().hashCode() << 7));
		case ASTNode.POSTFIX_EXPRESSION:
			return (char) (label | (((PostfixExpression) node).getOperator().toString().hashCode() << 7));
		case ASTNode.PREFIX_EXPRESSION:
			return (char) (label | (((PrefixExpression) node).getOperator().toString().hashCode() << 7));
		default:
			break;
		}
	} else if (node instanceof Modifier) {
		return (char) (label | (node.toString().hashCode() << 7));
	} else if (node instanceof Type) {
		if (node instanceof PrimitiveType)
			return (char) (label | (node.toString().hashCode() << 7));
	} else if (node instanceof TextElement) {
		return (char) (label | (node.toString().hashCode() << 7));
	} else if (node instanceof TagElement) {
		String tag = ((TagElement) node).getTagName();
		if (tag != null)
			return (char) (label | (((TagElement) node).getTagName().hashCode() << 7));
	}
	return label;
}
 

private boolean labelMatch(ASTNode nodeM, ASTNode nodeN) {
	if (nodeM.getNodeType() != nodeN.getNodeType())
		return false;
	if (nodeM instanceof Assignment)
		return labelMatch((Assignment) nodeM, (Assignment) nodeN);
	if (nodeM instanceof InfixExpression)
		return labelMatch((InfixExpression) nodeM, (InfixExpression) nodeN);
	if (nodeM instanceof PostfixExpression)
		return labelMatch((PostfixExpression) nodeM, (PostfixExpression) nodeN);
	if (nodeM instanceof PrefixExpression)
		return labelMatch((PrefixExpression) nodeM, (PrefixExpression) nodeN);
	return true;
}
 

public boolean visit(PostfixExpression node) {
	postfixExpressions.add(node.toString());
	if(current.getUserObject() != null) {
		AnonymousClassDeclarationObject anonymous = (AnonymousClassDeclarationObject)current.getUserObject();
		anonymous.getPostfixExpressions().add(node.toString());
	}
	return super.visit(node);
}
 

public Boolean isAssignedInBody(final Block scope, final SimpleName nameToLookFor) {
  final Function1<Expression, Boolean> _function = (Expression it) -> {
    Expression simpleName = null;
    boolean _matched = false;
    if (it instanceof Assignment) {
      _matched=true;
      simpleName = ((Assignment)it).getLeftHandSide();
    }
    if (!_matched) {
      if (it instanceof PrefixExpression) {
        _matched=true;
        simpleName = ((PrefixExpression)it).getOperand();
      }
    }
    if (!_matched) {
      if (it instanceof PostfixExpression) {
        _matched=true;
        simpleName = ((PostfixExpression)it).getOperand();
      }
    }
    if ((simpleName instanceof SimpleName)) {
      return Boolean.valueOf(((simpleName != null) && nameToLookFor.getIdentifier().equals(((SimpleName)simpleName).getIdentifier())));
    }
    return Boolean.valueOf(false);
  };
  boolean _isEmpty = IterableExtensions.isEmpty(this.findAssignmentsInBlock(scope, _function));
  return Boolean.valueOf((!_isEmpty));
}
 

public Iterable<Expression> findAssignmentsInBlock(final Block scope, final VariableDeclaration varDecl) {
  final Function1<Expression, Boolean> _function = (Expression it) -> {
    Expression name = null;
    boolean _matched = false;
    if (it instanceof Assignment) {
      _matched=true;
      name = ((Assignment)it).getLeftHandSide();
    }
    if (!_matched) {
      if (it instanceof PrefixExpression) {
        _matched=true;
        name = ((PrefixExpression)it).getOperand();
      }
    }
    if (!_matched) {
      if (it instanceof PostfixExpression) {
        _matched=true;
        name = ((PostfixExpression)it).getOperand();
      }
    }
    if ((name instanceof Name)) {
      final IBinding binding = ((Name)name).resolveBinding();
      if ((binding instanceof IVariableBinding)) {
        final IVariableBinding declBinding = varDecl.resolveBinding();
        return Boolean.valueOf((varDecl.getName().getIdentifier().equals(this.toSimpleName(((Name)name))) && ((IVariableBinding)binding).equals(declBinding)));
      }
    }
    return Boolean.valueOf(false);
  };
  return this.findAssignmentsInBlock(scope, _function);
}
 

@Override
public boolean visit(PostfixExpression node) {
	Expression operand = node.getOperand();
	if (!considerBinding(resolveBinding(operand), operand)) {
		return true;
	}

	ASTNode parent = node.getParent();
	if (!(parent instanceof ExpressionStatement)) {
		fStatus.addError(RefactoringCoreMessages.SelfEncapsulateField_AccessAnalyzer_cannot_convert_postfix_expression, JavaStatusContext.create(fCUnit, SourceRangeFactory.create(node)));
		return false;
	}
	fRewriter.replace(node, createInvocation(node.getAST(), node.getOperand(), node.getOperator().toString()), createGroupDescription(POSTFIX_ACCESS));
	return false;
}
 

public boolean visit(PostfixExpression expr) {
	/*
	 * PostfixExpression: Expression PostfixOperator
	 */
	activateDiffStyle(expr);
	handleExpression(expr.getOperand());
	styledString.append(expr.getOperator().toString(), determineDiffStyle(expr, new StyledStringStyler(ordinaryStyle)));
	deactivateDiffStyle(expr);
	return false;
}
 

public static PostfixOperator getPostfixOperator(PostfixExpression.Operator operator) {
  switch (operator.toString()) {
    case "++":
      return PostfixOperator.INCREMENT;
    case "--":
      return PostfixOperator.DECREMENT;
    default:
      return null;
  }
}
 

public boolean visit(PostfixExpression expr) {
	handleExpression(expr.getOperand());
	bindingKeys.add(expr.getOperator().toString());
	return false;
}
 

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 void handleExpression(Expression expression) {
	if (expression instanceof ArrayAccess) {
		visit((ArrayAccess) expression);
	} else if (expression instanceof ArrayCreation) {
		visit((ArrayCreation) expression);
	} else if (expression instanceof ArrayInitializer) {
		visit((ArrayInitializer) expression);
	} else if (expression instanceof Assignment) {
		visit((Assignment) expression);
	} else if (expression instanceof BooleanLiteral) {
		visit((BooleanLiteral) expression);
	} else if (expression instanceof CastExpression) {
		visit((CastExpression) expression);
	} else if (expression instanceof CharacterLiteral) {
		visit((CharacterLiteral) expression);
	} else if (expression instanceof ClassInstanceCreation) {
		visit((ClassInstanceCreation) expression);
	} else if (expression instanceof ConditionalExpression) {
		visit((ConditionalExpression) expression);
	} else if (expression instanceof FieldAccess) {
		visit((FieldAccess) expression);
	} else if (expression instanceof InfixExpression) {
		visit((InfixExpression) expression);
	} else if (expression instanceof InstanceofExpression) {
		visit((InstanceofExpression) expression);
	} else if (expression instanceof MethodInvocation) {
		visit((MethodInvocation) expression);
	} else if (expression instanceof NullLiteral) {
		visit((NullLiteral) expression);
	} else if (expression instanceof NumberLiteral) {
		visit((NumberLiteral) expression);
	} else if (expression instanceof ParenthesizedExpression) {
		visit((ParenthesizedExpression) expression);
	} else if (expression instanceof PostfixExpression) {
		visit((PostfixExpression) expression);
	} else if (expression instanceof PrefixExpression) {
		visit((PrefixExpression) expression);
	} else if ((expression instanceof QualifiedName)) {
		visit((QualifiedName) expression);
	} else if (expression instanceof SimpleName) {
		visit((SimpleName) expression);
	} else if (expression instanceof StringLiteral) {
		visit((StringLiteral) expression);
	} else if (expression instanceof SuperFieldAccess) {
		visit((SuperFieldAccess) expression);
	} else if (expression instanceof SuperMethodInvocation) {
		visit((SuperMethodInvocation) expression);
	} else if (expression instanceof ThisExpression) {
		visit((ThisExpression) expression);
	} else if (expression instanceof TypeLiteral) {
		visit((TypeLiteral) expression);
	} else if (expression instanceof VariableDeclarationExpression) {
		visit((VariableDeclarationExpression) expression);
	}
}
 

public boolean instanceOf(Expression expression) {
	if(expression instanceof Assignment || expression instanceof PrefixExpression || expression instanceof PostfixExpression || expression instanceof MethodInvocation)
		return true;
	else
		return false;
}
 

public boolean instanceOf(Expression expression) {
	if(expression instanceof PostfixExpression)
		return true;
	else
		return false;
}
 

@Override
public boolean visit(PostfixExpression node) {
	fSideEffectNodes.add(node);
	return false;
}