Java PsiAssignmentExpression.getLExpression方法代码示例

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
private static void replaceMultiplyOrDivideAssignWithShiftAssign(
  PsiAssignmentExpression expression)
  throws IncorrectOperationException {
  final PsiExpression lhs = expression.getLExpression();
  final PsiExpression rhs = expression.getRExpression();
  final IElementType tokenType = expression.getOperationTokenType();
  final String assignString;
  if (tokenType.equals(JavaTokenType.ASTERISKEQ)) {
    assignString = "<<=";
  }
  else {
    assignString = ">>=";
  }
  final String expString =
    lhs.getText() + assignString + ShiftUtils.getLogBase2(rhs);
  replaceExpression(expString, expression);
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
private static void replaceShiftAssignWithMultiplyOrDivideAssign(
  PsiElement element)
  throws IncorrectOperationException {
  final PsiAssignmentExpression exp =
    (PsiAssignmentExpression)element;
  final PsiExpression lhs = exp.getLExpression();
  final PsiExpression rhs = exp.getRExpression();
  final IElementType tokenType = exp.getOperationTokenType();
  final String assignString;
  if (tokenType.equals(JavaTokenType.LTLTEQ)) {
    assignString = "*=";
  }
  else {
    assignString = "/=";
  }
  final String expString =
    lhs.getText() + assignString + ShiftUtils.getExpBase2(rhs);
  replaceExpression(expString, exp);
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
@Override
public void doFix(@NotNull Project project, ProblemDescriptor descriptor)
  throws IncorrectOperationException {
  final PsiElement element = descriptor.getPsiElement();
  if (!(element instanceof PsiAssignmentExpression)) {
    return;
  }
  final PsiAssignmentExpression expression = (PsiAssignmentExpression)element;
  final PsiExpression lhs = expression.getLExpression();
  PsiExpression rhs = ParenthesesUtils.stripParentheses(expression.getRExpression());
  if (rhs instanceof PsiTypeCastExpression) {
    final PsiTypeCastExpression typeCastExpression = (PsiTypeCastExpression)rhs;
    final PsiType castType = typeCastExpression.getType();
    if (castType == null || !castType.equals(lhs.getType())) {
      return;
    }
    rhs = ParenthesesUtils.stripParentheses(typeCastExpression.getOperand());
  }
  if (!(rhs instanceof PsiPolyadicExpression)) {
    return;
  }
  final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression)rhs;
  final String newExpression = calculateReplacementExpression(lhs, polyadicExpression);
  replaceExpression(expression, newExpression);
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
private static void replaceSimplifiableAssignment(
  PsiIfStatement statement)
  throws IncorrectOperationException {
  final PsiExpression condition = statement.getCondition();
  if (condition == null) {
    return;
  }
  final String conditionText = condition.getText();
  final PsiStatement thenBranch = statement.getThenBranch();
  final PsiExpressionStatement assignmentStatement =
    (PsiExpressionStatement)
      ControlFlowUtils.stripBraces(thenBranch);
  final PsiAssignmentExpression assignmentExpression =
    (PsiAssignmentExpression)assignmentStatement.getExpression();
  final PsiJavaToken operator =
    assignmentExpression.getOperationSign();
  final String operand = operator.getText();
  final PsiExpression lhs = assignmentExpression.getLExpression();
  final String lhsText = lhs.getText();
  replaceStatement(statement,
                   lhsText + operand + conditionText + ';');
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
private static void replaceSimplifiableAssignmentNegated(
  PsiIfStatement statement)
  throws IncorrectOperationException {
  final PsiExpression condition = statement.getCondition();
  if (condition == null) {
    return;
  }
  final String conditionText =
    BoolUtils.getNegatedExpressionText(condition);
  final PsiStatement thenBranch = statement.getThenBranch();
  final PsiExpressionStatement assignmentStatement =
    (PsiExpressionStatement)
      ControlFlowUtils.stripBraces(thenBranch);
  final PsiAssignmentExpression assignmentExpression =
    (PsiAssignmentExpression)
      assignmentStatement.getExpression();
  final PsiJavaToken operator =
    assignmentExpression.getOperationSign();
  final String operand = operator.getText();
  final PsiExpression lhs = assignmentExpression.getLExpression();
  final String lhsText = lhs.getText();
  replaceStatement(statement,
                   lhsText + operand + conditionText + ';');
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
public boolean satisfiedBy(PsiElement element) {
  if (!(element instanceof PsiAssignmentExpression)) {
    return false;
  }
  final PsiAssignmentExpression assignment = (PsiAssignmentExpression)element;
  final IElementType tokenType = assignment.getOperationTokenType();
  if (!JavaTokenType.EQ.equals(tokenType)) {
    return false;
  }
  final PsiExpression rhs = assignment.getRExpression();
  final PsiExpression expression = PsiUtil.deparenthesizeExpression(rhs);
  if (!(expression instanceof PsiPolyadicExpression)) {
    return false;
  }
  final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression)expression;
  final PsiExpression[] operands = polyadicExpression.getOperands();
  if (operands.length < 2) {
    return false;
  }
  final IElementType rhsTokenType = polyadicExpression.getOperationTokenType();
  if (JavaTokenType.OROR.equals(rhsTokenType) || JavaTokenType.ANDAND.equals(rhsTokenType) ||
      JavaTokenType.EQEQ.equals(rhsTokenType) || JavaTokenType.NE.equals(rhsTokenType)) {
    return false;
  }
  final PsiExpression lhs = assignment.getLExpression();
  if (SideEffectChecker.mayHaveSideEffects(lhs)) {
    return false;
  }
  if (!EquivalenceChecker.expressionsAreEquivalent(lhs, operands[0])) {
    return false;
  }
  return !ErrorUtil.containsError(element);
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
@Override
protected void processIntention(@NotNull PsiElement element) {
  final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)element;
  final PsiJavaToken sign = assignmentExpression.getOperationSign();
  final PsiExpression lhs = assignmentExpression.getLExpression();
  final PsiExpression rhs = assignmentExpression.getRExpression();
  final String operator = sign.getText();
  final String newOperator = operator.substring(0, operator.length() - 1);
  final String lhsText = lhs.getText();
  final String rhsText = (rhs == null) ? "" : rhs.getText();
  final boolean parentheses;
  if (rhs instanceof PsiPolyadicExpression) {
    final PsiPolyadicExpression binaryExpression = (PsiPolyadicExpression)rhs;
    final int precedence1 = ParenthesesUtils.getPrecedenceForOperator(binaryExpression.getOperationTokenType());
    final IElementType signTokenType = sign.getTokenType();
    final IElementType newOperatorToken = tokenMap.get(signTokenType);
    final int precedence2 = ParenthesesUtils.getPrecedenceForOperator(newOperatorToken);
    parentheses = precedence1 >= precedence2 || !ParenthesesUtils.isCommutativeOperator(newOperatorToken);
  }
  else {
    parentheses = false;
  }
  final String cast = getCastString(lhs, rhs);
  final StringBuilder newExpression = new StringBuilder(lhsText);
  newExpression.append('=').append(cast);
  if (!cast.isEmpty()) {
    newExpression.append('(');
  }
  newExpression.append(lhsText).append(newOperator);
  if (parentheses) {
    newExpression.append('(').append(rhsText).append(')');
  }
  else {
    newExpression.append(rhsText);
  }
  if (!cast.isEmpty()) {
    newExpression.append(')');
  }
  replaceExpression(newExpression.toString(), assignmentExpression);
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
private static void replaceSimplifiableImplicitAssignment(
  PsiIfStatement statement) throws IncorrectOperationException {
  final PsiElement prevStatement =
    PsiTreeUtil.skipSiblingsBackward(statement,
                                     PsiWhiteSpace.class);
  if (prevStatement == null) {
    return;
  }
  final PsiExpression condition = statement.getCondition();
  if (condition == null) {
    return;
  }
  final String conditionText = condition.getText();
  final PsiStatement thenBranch = statement.getThenBranch();
  final PsiExpressionStatement assignmentStatement =
    (PsiExpressionStatement)
      ControlFlowUtils.stripBraces(thenBranch);
  final PsiAssignmentExpression assignmentExpression =
    (PsiAssignmentExpression)assignmentStatement.getExpression();
  final PsiJavaToken operator =
    assignmentExpression.getOperationSign();
  final String operand = operator.getText();
  final PsiExpression lhs = assignmentExpression.getLExpression();
  final String lhsText = lhs.getText();
  replaceStatement(statement,
                   lhsText + operand + conditionText + ';');
  deleteElement(prevStatement);
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
public static boolean isSimplifiableAssignment(PsiIfStatement ifStatement) {
  PsiStatement thenBranch = ifStatement.getThenBranch();
  thenBranch = ControlFlowUtils.stripBraces(thenBranch);
  PsiStatement elseBranch = ifStatement.getElseBranch();
  elseBranch = ControlFlowUtils.stripBraces(elseBranch);
  if (ConditionalUtils.isAssignment(thenBranch, PsiKeyword.TRUE) &&
      ConditionalUtils.isAssignment(elseBranch, PsiKeyword.FALSE)) {
    final PsiExpressionStatement thenExpressionStatement =
      (PsiExpressionStatement)thenBranch;
    final PsiAssignmentExpression thenExpression =
      (PsiAssignmentExpression)
        thenExpressionStatement.getExpression();
    final PsiExpressionStatement elseExpressionStatement =
      (PsiExpressionStatement)elseBranch;
    final PsiAssignmentExpression elseExpression =
      (PsiAssignmentExpression)
        elseExpressionStatement.getExpression();
    final IElementType thenTokenType = thenExpression.getOperationTokenType();
    if (!thenTokenType.equals(elseExpression.getOperationTokenType())) {
      return false;
    }
    final PsiExpression thenLhs = thenExpression.getLExpression();
    final PsiExpression elseLhs = elseExpression.getLExpression();
    return EquivalenceChecker.getCanonicalPsiEquivalence().expressionsAreEquivalent(thenLhs,
                                                       elseLhs);
  }
  else {
    return false;
  }
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
public static boolean isSimplifiableAssignmentNegated(
  PsiIfStatement ifStatement) {
  PsiStatement thenBranch = ifStatement.getThenBranch();
  thenBranch = ControlFlowUtils.stripBraces(thenBranch);
  PsiStatement elseBranch = ifStatement.getElseBranch();
  elseBranch = ControlFlowUtils.stripBraces(elseBranch);
  if (ConditionalUtils.isAssignment(thenBranch, PsiKeyword.FALSE) &&
      ConditionalUtils.isAssignment(elseBranch, PsiKeyword.TRUE)) {
    final PsiExpressionStatement thenExpressionStatement =
      (PsiExpressionStatement)thenBranch;
    final PsiAssignmentExpression thenExpression =
      (PsiAssignmentExpression)
        thenExpressionStatement.getExpression();
    final PsiExpressionStatement elseExpressionStatement =
      (PsiExpressionStatement)elseBranch;
    final PsiAssignmentExpression elseExpression =
      (PsiAssignmentExpression)
        elseExpressionStatement.getExpression();
    final IElementType thenTokenType = thenExpression.getOperationTokenType();
    if (!thenTokenType.equals(elseExpression.getOperationTokenType())) {
      return false;
    }
    final PsiExpression thenLhs = thenExpression.getLExpression();
    final PsiExpression elseLhs = elseExpression.getLExpression();
    return EquivalenceChecker.getCanonicalPsiEquivalence().expressionsAreEquivalent(thenLhs,
                                                       elseLhs);
  }
  else {
    return false;
  }
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
public static boolean isSimplifiableImplicitAssignment(
  PsiIfStatement ifStatement) {
  if (ifStatement.getElseBranch() != null) {
    return false;
  }
  PsiStatement thenBranch = ifStatement.getThenBranch();
  thenBranch = ControlFlowUtils.stripBraces(thenBranch);
  final PsiElement nextStatement =
    PsiTreeUtil.skipSiblingsBackward(ifStatement,
                                     PsiWhiteSpace.class);
  if (!(nextStatement instanceof PsiStatement)) {
    return false;
  }
  PsiStatement elseBranch = (PsiStatement)nextStatement;
  elseBranch = ControlFlowUtils.stripBraces(elseBranch);
  if (ConditionalUtils.isAssignment(thenBranch, PsiKeyword.TRUE) &&
      ConditionalUtils.isAssignment(elseBranch, PsiKeyword.FALSE)) {
    final PsiExpressionStatement thenExpressionStatement =
      (PsiExpressionStatement)thenBranch;
    final PsiAssignmentExpression thenExpression =
      (PsiAssignmentExpression)
        thenExpressionStatement.getExpression();
    final PsiExpressionStatement elseExpressionStatement =
      (PsiExpressionStatement)elseBranch;
    final PsiAssignmentExpression elseExpression =
      (PsiAssignmentExpression)
        elseExpressionStatement.getExpression();
    final IElementType thenTokenType = thenExpression.getOperationTokenType();
    if (!thenTokenType.equals(elseExpression.getOperationTokenType())) {
      return false;
    }
    final PsiExpression thenLhs = thenExpression.getLExpression();
    final PsiExpression elseLhs = elseExpression.getLExpression();
    return EquivalenceChecker.getCanonicalPsiEquivalence().expressionsAreEquivalent(thenLhs,
                                                       elseLhs);
  }
  else {
    return false;
  }
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
public static boolean isSimplifiableImplicitAssignmentNegated(
  PsiIfStatement ifStatement) {
  if (ifStatement.getElseBranch() != null) {
    return false;
  }
  PsiStatement thenBranch = ifStatement.getThenBranch();
  thenBranch = ControlFlowUtils.stripBraces(thenBranch);
  final PsiElement nextStatement =
    PsiTreeUtil.skipSiblingsBackward(ifStatement,
                                     PsiWhiteSpace.class);
  if (!(nextStatement instanceof PsiStatement)) {
    return false;
  }
  PsiStatement elseBranch = (PsiStatement)nextStatement;
  elseBranch = ControlFlowUtils.stripBraces(elseBranch);
  if (ConditionalUtils.isAssignment(thenBranch, PsiKeyword.FALSE) &&
      ConditionalUtils.isAssignment(elseBranch, PsiKeyword.TRUE)) {
    final PsiExpressionStatement thenExpressionStatement =
      (PsiExpressionStatement)thenBranch;
    final PsiAssignmentExpression thenExpression =
      (PsiAssignmentExpression)
        thenExpressionStatement.getExpression();
    final PsiExpressionStatement elseExpressionStatement =
      (PsiExpressionStatement)elseBranch;
    final PsiAssignmentExpression elseExpression =
      (PsiAssignmentExpression)
        elseExpressionStatement.getExpression();
    final IElementType thenTokenType = thenExpression.getOperationTokenType();
    if (!thenTokenType.equals(elseExpression.getOperationTokenType())) {
      return false;
    }
    final PsiExpression thenLhs = thenExpression.getLExpression();
    final PsiExpression elseLhs = elseExpression.getLExpression();
    return EquivalenceChecker.getCanonicalPsiEquivalence().expressionsAreEquivalent(thenLhs,
                                                       elseLhs);
  }
  else {
    return false;
  }
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入方法依赖的package包/类
@Override
public void visitAssignmentExpression(@NotNull PsiAssignmentExpression assignment) {
  super.visitAssignmentExpression(assignment);
  final IElementType assignmentTokenType = assignment.getOperationTokenType();
  if (!assignmentTokenType.equals(JavaTokenType.EQ)) {
    return;
  }
  final PsiExpression lhs = assignment.getLExpression();
  PsiExpression rhs = ParenthesesUtils.stripParentheses(assignment.getRExpression());
  if (rhs instanceof PsiTypeCastExpression) {
    final PsiTypeCastExpression typeCastExpression = (PsiTypeCastExpression)rhs;
    final PsiType castType = typeCastExpression.getType();
    if (castType == null || !castType.equals(lhs.getType())) {
      return;
    }
    rhs = ParenthesesUtils.stripParentheses(typeCastExpression.getOperand());
  }
  if (!(rhs instanceof PsiPolyadicExpression)) {
    return;
  }
  final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression)rhs;
  final PsiExpression[] operands = polyadicExpression.getOperands();
  if (operands.length < 2) {
    return;
  }
  if (operands.length > 2 && !ParenthesesUtils.isAssociativeOperation(polyadicExpression)) {
    return;
  }
  for (PsiExpression operand : operands) {
    if (operand == null) {
      return;
    }
  }
  final IElementType expressionTokenType = polyadicExpression.getOperationTokenType();
  if (JavaTokenType.EQEQ.equals(expressionTokenType) || JavaTokenType.NE.equals(expressionTokenType)) {
    return;
  }
  if (ignoreLazyOperators) {
    if (JavaTokenType.ANDAND.equals(expressionTokenType) || JavaTokenType.OROR.equals(expressionTokenType)) {
      return;
    }
  }
  if (ignoreObscureOperators) {
    if (JavaTokenType.XOR.equals(expressionTokenType) || JavaTokenType.PERC.equals(expressionTokenType)) {
      return;
    }
  }
  if (!EquivalenceChecker.getCanonicalPsiEquivalence().expressionsAreEquivalent(lhs, operands[0])) {
    return;
  }
  registerError(assignment, lhs, polyadicExpression);
}