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());
}
 

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 String getTextForElement(PsiElement element) {
  final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)element;
  final PsiJavaToken sign = assignmentExpression.getOperationSign();
  final String operator = sign.getText();
  return IntentionPowerPackBundle.message("replace.operator.assignment.with.assignment.intention.name", operator);
}
 

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包/类
public void processIntention(PsiElement element)
  throws IncorrectOperationException {
  if (element instanceof PsiBinaryExpression) {
    replaceMultiplyOrDivideWithShift((PsiBinaryExpression)element);
  }
  else {
    replaceMultiplyOrDivideAssignWithShiftAssign(
      (PsiAssignmentExpression)element);
  }
}
 

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);
}