Java PsiAssignmentExpression类代码示例

import com.intellij.psi.PsiAssignmentExpression; //导入依赖的package包/类
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor)
{
	final PsiElement psiElement = descriptor.getPsiElement();
	if(psiElement == null)
	{
		return;
	}

	final PsiAssignmentExpression assignmentExpression = PsiTreeUtil.getParentOfType(psiElement, PsiAssignmentExpression.class);
	if(assignmentExpression == null)
	{
		return;
	}

	final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
	final String lExpressionText = assignmentExpression.getLExpression().getText();
	final PsiExpression rExpression = assignmentExpression.getRExpression();
	final String rExpressionText = rExpression != null ? rExpression.getText() : "";
	assignmentExpression.replace(factory.createExpressionFromText(lExpressionText + " = " + rExpressionText, psiElement));
}
 

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包/类
/**
 * メソッドが変更するフィールド変数(状態)を解析
 * @param allFields クラスが所持するすべてのフィールド
 * @return メソッドが変更する全てのフィールド
 */
private Map<String, PsiField> parse(@NonNull Map<String, PsiField> allFields) {

    Map<String, PsiField> writeFields = new HashMap<>();

    // メソッド内の全代入式を抽出
    List<PsiAssignmentExpression> assignments = ElementUtil.extractAssignments(mMethod);
    for (PsiAssignmentExpression assignment : assignments) {

        // 左辺から変数名を取得
        List<PsiIdentifier> ids =
                ElementUtil.extractIdentifiers(assignment.getLExpression());
        PsiIdentifier id = ids.get(ids.size()-1);

        if (allFields.containsKey(id.getText())) {

            // フィールドと同名のクラス変数やインスタンス変数か否かをチェック
            boolean isInstance = ElementUtil.isThisExpression(id) || ElementUtil.isRefExpression(id);

            // フィールドと同名のローカル変数やパラメータか否かをチェック
            PsiElement element =
                    ElementUtil.ScopeBacktrack
                            .seek(assignment, allFields.get(id.getText()).getNameIdentifier());
            if (element != null && !isInstance) continue;

            writeFields.put(id.getText(), allFields.get(id.getText()));
        }
    }
    return writeFields;
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入依赖的package包/类
private static void extractAssignments(@NonNull PsiElement element, List<PsiAssignmentExpression> assignments) {
    for (PsiElement child : element.getChildren()) {
        if (child instanceof PsiAssignmentExpression) {
            assignments.add((PsiAssignmentExpression) child);
            continue;
        }
        extractAssignments(child, assignments);
    }
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入依赖的package包/类
public static void debugAssignments(String tag, PsiElement root, List<PsiAssignmentExpression> assignments) {
    System.out.println(tag + " :root=>>>>\n" + root.getText() + "\n<<<");
    for (PsiAssignmentExpression assignment : assignments) {
        System.out.println("assignment -> " + assignment.getText());
    }
    System.out.println();
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入依赖的package包/类
public boolean satisfiedBy(PsiElement element) {
  if (!(element instanceof PsiAssignmentExpression)) {
    return false;
  }
  final PsiAssignmentExpression assignmentExpression =
    (PsiAssignmentExpression)element;
  final IElementType tokenType =
    assignmentExpression.getOperationTokenType();
  return OPERATOR_ASSIGNMENT_TOKENS.contains(tokenType);
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入依赖的package包/类
@Override
public void visitAssignmentExpression(
  @NotNull PsiAssignmentExpression expression) {
  super.visitAssignmentExpression(expression);
  final PsiElement parent = expression.getParent();
  if (parent == null) {
    return;
  }
  final PsiElement grandparent = parent.getParent();
  if (parent instanceof PsiExpressionStatement ||
      grandparent instanceof PsiExpressionListStatement) {
    return;
  }
  registerError(expression);
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入依赖的package包/类
private boolean constructorAssignsAllFields(final PsiMethod constructor, List<PsiField> allFields) {
	final Set<PsiField> unassignedFields = new HashSet<PsiField>(allFields);
	final PsiParameter copyParameter = constructor.getParameterList().getParameters()[0];
	constructor.accept(new JavaRecursiveElementVisitor() {
		@Override
		public void visitAssignmentExpression(PsiAssignmentExpression expression) {
			PsiExpression left = expression.getLExpression();
			PsiExpression right = expression.getRExpression();
			PsiReference assignee = left.getReference();
			if (assignee != null) {
				PsiElement leftReference = assignee.resolve();
				if (leftReference != null && leftReference instanceof PsiField) {
					PsiField referencedField = (PsiField) leftReference;
					if (isReferenceToFieldInInstance(left, referencedField, null)) {
						if (isReferenceToFieldInInstance(right, referencedField, copyParameter)) {
							unassignedFields.remove(referencedField);
						} else if (right != null) {
							// report problem: suspicious assignment copies value from wrong field: "this.x = copy.y"
							holder.registerProblem(expression,
									String.format("Suspicious assignment in copy constructor of '%s' to field %s", right.getText(),
											referencedField.getName()), ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
						}
					}
				}
			}
		}
	});
	return unassignedFields.isEmpty();
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入依赖的package包/类
@Nullable
public PsiExpression getLExpression()
{
	if(myRExpression == null)
	{
		return null;
	}
	if(myRExpression.getParent() instanceof PsiAssignmentExpression)
	{
		return ((PsiAssignmentExpression) myRExpression.getParent()).getLExpression();
	}
	return null;
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入依赖的package包/类
@Override
public void visitAssignmentExpression(
  @NotNull PsiAssignmentExpression assignment) {
  if (assignedFrom) {
    return;
  }
  super.visitAssignmentExpression(assignment);
  final PsiExpression arg = assignment.getRExpression();
  if (VariableAccessUtils.mayEvaluateToVariable(arg, variable)) {
    assignedFrom = true;
  }
}
 

import com.intellij.psi.PsiAssignmentExpression; //导入依赖的package包/类
@Override
protected boolean shouldShowExplicitLambdaType(@NotNull PsiAnonymousClass anonymousClass, @NotNull PsiNewExpression expression)
{
	PsiElement parent = expression.getParent();
	if(parent instanceof PsiReferenceExpression || parent instanceof PsiAssignmentExpression)
	{
		return true;
	}

	ExpectedTypeInfo[] types = ExpectedTypesProvider.getExpectedTypes(expression, false);
	return types.length != 1 || !types[0].getType().equals(anonymousClass.getBaseClassType());
}