Java VariableAccessUtils类代码示例

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
private static boolean isEquality(PsiExpression expression, boolean equals, PsiVariable variable1, PsiVariable variable2) {
  expression = ParenthesesUtils.stripParentheses(expression);
  if (!(expression instanceof PsiBinaryExpression)) {
    return false;
  }
  final PsiBinaryExpression binaryExpression = (PsiBinaryExpression)expression;
  if (equals) {
    if (!JavaTokenType.EQEQ.equals(binaryExpression.getOperationTokenType())) {
      return false;
    }
  }
  else {
    if (!JavaTokenType.NE.equals(binaryExpression.getOperationTokenType())) {
      return false;
    }
  }
  final PsiExpression lhs = binaryExpression.getLOperand();
  final PsiExpression rhs = binaryExpression.getROperand();
  return (VariableAccessUtils.evaluatesToVariable(lhs, variable1) && VariableAccessUtils.evaluatesToVariable(rhs, variable2)) ||
         (VariableAccessUtils.evaluatesToVariable(lhs, variable2) && VariableAccessUtils.evaluatesToVariable(rhs, variable1));
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
private static PsiVariable getArgumentFromEqualsCallOn(PsiExpression expression, @NotNull PsiVariable variable) {
  expression = ParenthesesUtils.stripParentheses(expression);
  if (!(expression instanceof PsiMethodCallExpression)) {
    return null;
  }
  final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)expression;
  final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression();
  final String methodName = methodExpression.getReferenceName();
  if (!HardcodedMethodConstants.EQUALS.equals(methodName)) {
    return null;
  }
  final PsiExpression qualifier = methodExpression.getQualifierExpression();
  if (!VariableAccessUtils.evaluatesToVariable(qualifier, variable)) {
    return null;
  }
  final PsiExpressionList argumentList = methodCallExpression.getArgumentList();
  final PsiExpression[] expressions = argumentList.getExpressions();
  if (expressions.length != 1) {
    return null;
  }
  return ExpressionUtils.getVariable(expressions[0]);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
private static int findInitialization(PsiElement[] elements, PsiVariable variable, boolean hasInitializer) {
  int result = -1;
  final int statementsLength = elements.length;
  for (int i = 0; i < statementsLength; i++) {
    final PsiElement element = elements[i];
    if (isNormalAssignment(element, variable)) {
      if (result >= 0 && !hasInitializer) {
        return -1;
      }
      if (hasInitializer) {
        return i;
      }
      result = i;
    }
    else if (VariableAccessUtils.variableIsAssigned(variable, element)) {
      return hasInitializer ? i : -1;
    }
  }
  return result;
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
private static boolean isNullComparison(PsiExpression condition, PsiVariable variable) {
  if (!(condition instanceof PsiBinaryExpression)) {
    return false;
  }
  final PsiBinaryExpression comparison = (PsiBinaryExpression)condition;
  final IElementType tokenType = comparison.getOperationTokenType();
  if (!tokenType.equals(JavaTokenType.EQEQ)) {
    return false;
  }
  final PsiExpression lhs = comparison.getLOperand();
  final PsiExpression rhs = comparison.getROperand();
  if (ExpressionUtils.isNullLiteral(rhs)) {
    return VariableAccessUtils.evaluatesToVariable(lhs, variable);
  }
  else if (ExpressionUtils.isNullLiteral(lhs)) {
    return VariableAccessUtils.evaluatesToVariable(rhs, variable);
  }
  return false;
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
private static boolean checkVariable(PsiVariable variable,
                                     PsiElement context) {
  if (context == null) {
    return false;
  }
  final PsiType type = variable.getType();
  if (type.getArrayDimensions() == 0) {
    return false;
  }
  if (VariableAccessUtils.variableIsAssigned(variable, context)) {
    return false;
  }
  if (VariableAccessUtils.variableIsAssignedFrom(variable, context)) {
    return false;
  }
  if (VariableAccessUtils.variableIsReturned(variable, context)) {
    return false;
  }
  return !VariableAccessUtils.variableIsUsedInArrayInitializer(variable, context);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
@Override
public void visitBinaryExpression(PsiBinaryExpression expression) {
  super.visitBinaryExpression(expression);
  if (write || passed) {
    return;
  }
  final IElementType tokenType = expression.getOperationTokenType();
  if (!JavaTokenType.EQEQ.equals(tokenType) && !JavaTokenType.NE.equals(tokenType)) {
    return;
  }
  final PsiExpression lhs = expression.getLOperand();
  if (!(lhs instanceof PsiBinaryExpression)) {
    if (VariableAccessUtils.mayEvaluateToVariable(lhs, variable)) {
      passed = true;
    }
  }
  final PsiExpression rhs = expression.getROperand();
  if (!(rhs instanceof PsiBinaryExpression)) {
    if (VariableAccessUtils.mayEvaluateToVariable(rhs, variable)) {
      passed = true;
    }
  }
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
@Override
public void visitMethodCallExpression(
  @NotNull PsiMethodCallExpression call) {
  if (passed) {
    return;
  }
  super.visitMethodCallExpression(call);
  final PsiExpressionList argumentList = call.getArgumentList();
  final PsiExpression[] arguments = argumentList.getExpressions();
  for (int i = 0; i < arguments.length; i++) {
    final PsiExpression argument = arguments[i];
    if (VariableAccessUtils.mayEvaluateToVariable(argument, variable)) {
      if (write && i == 0 && isCallToSystemArraycopy(call)) {
        return;
      }
      if (!write && i == 2 && isCallToSystemArraycopy(call)) {
        return;
      }
      passed = true;
    }
  }
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
@Override
public void visitAssignmentExpression(@NotNull PsiAssignmentExpression assignment) {
  if (mayBeQueried) {
    return;
  }
  super.visitAssignmentExpression(assignment);
  final PsiExpression lhs = assignment.getLExpression();
  if (!VariableAccessUtils.mayEvaluateToVariable(lhs, variable)) {
    return;
  }
  final PsiExpression rhs = assignment.getRExpression();
  if (isEmptyCollectionInitializer(rhs)) {
    return;
  }
  mayBeQueried = true;
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
private boolean checkVariable(PsiVariable variable, PsiElement context) {
  if (context == null) {
    return false;
  }
  final PsiType type = variable.getType();
  if (!CollectionUtils.isCollectionClassOrInterface(type)) {
    return false;
  }
  if (VariableAccessUtils.variableIsAssignedFrom(variable, context)) {
    return false;
  }
  if (VariableAccessUtils.variableIsReturned(variable, context)) {
    return false;
  }
  return !VariableAccessUtils.variableIsUsedInArrayInitializer(variable, context);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
private boolean collectionContentsAreUpdated(PsiVariable variable, PsiElement context) {
  if (VariableAccessUtils.variableIsPassedAsMethodArgument(variable, context, new UpdateCallProcessor()) ||
      collectionUpdateCalled(variable, context)) {
    return true;
  }
  final PsiExpression initializer = variable.getInitializer();
  if (initializer != null && !isEmptyCollectionInitializer(initializer)) {
    return true;
  }
  if (initializer instanceof PsiNewExpression) {
    final PsiNewExpression newExpression = (PsiNewExpression)initializer;
    final PsiAnonymousClass anonymousClass = newExpression.getAnonymousClass();
    if (anonymousClass != null) {
      if (collectionUpdateCalled(null, anonymousClass)) {
        return true;
      }
      final ThisPassedAsArgumentVisitor visitor = new ThisPassedAsArgumentVisitor();
      anonymousClass.accept(visitor);
      if (visitor.isPassed()) {
        return true;
      }
    }
  }
  return VariableAccessUtils.variableIsAssigned(variable, context);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
private static boolean checkVariable(PsiVariable variable, PsiElement context) {
  if (context == null) {
    return false;
  }
  if (!TypeUtils.variableHasTypeOrSubtype(variable, CommonClassNames.JAVA_LANG_ABSTRACT_STRING_BUILDER)) {
    return false;
  }
  if (VariableAccessUtils.variableIsAssigned(variable, context)) {
    return false;
  }
  if (VariableAccessUtils.variableIsAssignedFrom(variable, context)) {
    return false;
  }
  if (VariableAccessUtils.variableIsReturned(variable, context)) {
    return false;
  }
  if (VariableAccessUtils.variableIsPassedAsMethodArgument(variable, context)) {
    return false;
  }
  return !VariableAccessUtils.variableIsUsedInArrayInitializer(variable, context);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
private boolean isVariableUsedInFollowingDeclarations(PsiVariable variable, PsiDeclarationStatement declarationStatement) {
  final PsiElement[] declaredElements = declarationStatement.getDeclaredElements();
  if (declaredElements.length == 1) {
    return false;
  }
  boolean check = false;
  for (PsiElement declaredElement : declaredElements) {
    if (!check && variable.equals(declaredElement)) {
      check = true;
    } else {
      if (VariableAccessUtils.variableIsUsed(variable, declaredElement)) {
        return true;
      }
    }
  }
  return false;
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
@Override
public void visitWhileStatement(@NotNull PsiWhileStatement statement) {
  super.visitWhileStatement(statement);
  final PsiStatement body = statement.getBody();
  if (ignoreNonEmtpyLoops && !statementIsEmpty(body)) {
    return;
  }
  final PsiExpression condition = statement.getCondition();
  final PsiField field = getFieldIfSimpleFieldComparison(condition);
  if (field == null) {
    return;
  }
  if (body != null && (VariableAccessUtils.variableIsAssigned(field, body) ||
                       containsWaitCall(body))) {
    return;
  }
  registerStatementError(statement);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
private static boolean isNullComparison(PsiExpression expression, @NotNull PsiVariable variable, boolean equal) {
  expression = ParenthesesUtils.stripParentheses(expression);
  if (!(expression instanceof PsiBinaryExpression)) {
    return false;
  }
  final PsiBinaryExpression binaryExpression = (PsiBinaryExpression)expression;
  final IElementType tokenType = binaryExpression.getOperationTokenType();
  if (equal) {
    if (!JavaTokenType.EQEQ.equals(tokenType)) {
      return false;
    }
  }
  else {
    if (!JavaTokenType.NE.equals(tokenType)) {
      return false;
    }
  }
  final PsiExpression lhs = binaryExpression.getLOperand();
  final PsiExpression rhs = binaryExpression.getROperand();
  if (rhs == null) {
    return false;
  }
  return PsiType.NULL.equals(rhs.getType()) && VariableAccessUtils.evaluatesToVariable(lhs, variable) ||
         PsiType.NULL.equals(lhs.getType()) && VariableAccessUtils.evaluatesToVariable(rhs, variable);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入依赖的package包/类
public static boolean isVariableCompared(
  @NotNull PsiVariable variable, @Nullable PsiExpression expression) {
  if (!(expression instanceof PsiBinaryExpression)) {
    return false;
  }
  final PsiBinaryExpression binaryExpression =
    (PsiBinaryExpression)expression;
  final IElementType tokenType = binaryExpression.getOperationTokenType();
  if (!ComparisonUtils.isComparisonOperation(tokenType)) {
    return false;
  }
  final PsiExpression lhs = binaryExpression.getLOperand();
  final PsiExpression rhs = binaryExpression.getROperand();
  if (rhs == null) {
    return false;
  }
  if (VariableAccessUtils.evaluatesToVariable(lhs, variable)) {
    return true;
  }
  else if (VariableAccessUtils.evaluatesToVariable(rhs, variable)) {
    return true;
  }
  return false;
}