Java VariableAccessUtils.variableIsUsed方法代码示例

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包/类
private void checkVariableUsage(PsiReferenceExpression referenceExpression, PsiElement thenContext, PsiElement elseContext) {
  if (thenContext == null) {
    return;
  }
  final PsiElement target = referenceExpression.resolve();
  if (!(target instanceof PsiVariable)) {
    return;
  }
  final PsiVariable variable = (PsiVariable)target;
  if (contextExits(thenContext) || VariableAccessUtils.variableIsAssigned(variable, thenContext)) {
    return;
  }
  if (elseContext != null && (contextExits(elseContext) || VariableAccessUtils.variableIsUsed(variable, elseContext))) {
    return;
  }
  registerError(referenceExpression);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入方法依赖的package包/类
private void checkVariableUsage(PsiReferenceExpression referenceExpression,
                                PsiElement thenContext, PsiElement elseContext) {
  if (thenContext == null) {
    return;
  }
  final PsiElement target = referenceExpression.resolve();
  if (!(target instanceof PsiVariable)) {
    return;
  }
  final PsiVariable variable = (PsiVariable)target;
  if (contextExits(thenContext) || VariableAccessUtils.variableIsAssigned(variable, thenContext)) {
    return;
  }
  if (elseContext != null &&
      (contextExits(elseContext) || VariableAccessUtils.variableIsUsed(variable, elseContext))) {
    return;
  }
  registerError(referenceExpression);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入方法依赖的package包/类
@Override
public void visitAssignmentExpression(@NotNull PsiAssignmentExpression expression) {
  super.visitAssignmentExpression(expression);
  final PsiExpression lhs = expression.getLExpression();
  final PsiParameter parameter = getParameter(lhs);
  if (parameter == null) {
    return;
  }
  if (ignoreTransformationOfOriginalParameter) {
    final PsiExpression rhs = expression.getRExpression();
    if (rhs != null && VariableAccessUtils.variableIsUsed(parameter, rhs)) {
      return;
    }
    final IElementType tokenType =
      expression.getOperationTokenType();
    if (tokenType == JavaTokenType.PLUSEQ ||
        tokenType == JavaTokenType.MINUSEQ ||
        tokenType == JavaTokenType.ASTERISKEQ ||
        tokenType == JavaTokenType.DIVEQ ||
        tokenType == JavaTokenType.ANDEQ ||
        tokenType == JavaTokenType.OREQ ||
        tokenType == JavaTokenType.XOREQ ||
        tokenType == JavaTokenType.PERCEQ ||
        tokenType == JavaTokenType.LTLTEQ ||
        tokenType == JavaTokenType.GTGTEQ ||
        tokenType == JavaTokenType.GTGTGTEQ) {
      return;
    }
  }
  registerError(lhs);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入方法依赖的package包/类
private boolean isAppendedRepeatedly(PsiExpression expression) {
  PsiElement parent = expression.getParent();
  while (parent instanceof PsiParenthesizedExpression || parent instanceof PsiPolyadicExpression) {
    parent = parent.getParent();
  }
  if (!(parent instanceof PsiAssignmentExpression)) {
    return false;
  }
  final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)parent;
  PsiExpression lhs = assignmentExpression.getLExpression();
  while (lhs instanceof PsiParenthesizedExpression) {
    final PsiParenthesizedExpression parenthesizedExpression = (PsiParenthesizedExpression)lhs;
    lhs = parenthesizedExpression.getExpression();
  }
  if (!(lhs instanceof PsiReferenceExpression)) {
    return false;
  }
  if (assignmentExpression.getOperationTokenType() == JavaTokenType.PLUSEQ) {
    return true;
  }
  final PsiReferenceExpression referenceExpression = (PsiReferenceExpression)lhs;
  final PsiElement element = referenceExpression.resolve();
  if (!(element instanceof PsiVariable)) {
    return false;
  }
  final PsiVariable variable = (PsiVariable)element;
  final PsiExpression rhs = assignmentExpression.getRExpression();
  return rhs != null && VariableAccessUtils.variableIsUsed(variable, rhs);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入方法依赖的package包/类
private boolean checkVariableUsage(PsiReferenceExpression referenceExpression, PsiElement thenContext, PsiElement elseContext) {
  final PsiElement target = referenceExpression.resolve();
  if (!(target instanceof PsiVariable)) {
    return false;
  }
  final PsiVariable variable = (PsiVariable)target;
  if (thenContext != null && (contextExits(thenContext) || VariableAccessUtils.variableIsAssigned(variable, thenContext))) {
    return false;
  }
  if (elseContext == null || VariableAccessUtils.variableIsUsed(variable, elseContext)) {
    return false;
  }
  return true;
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入方法依赖的package包/类
@Override
public void visitAssignmentExpression(
  @NotNull PsiAssignmentExpression expression) {
  super.visitAssignmentExpression(expression);
  final PsiExpression rhs = expression.getRExpression();
  if (rhs == null) {
    return;
  }
  final PsiExpression lhs = expression.getLExpression();
  final PsiField volatileField = findNonSynchronizedVolatileField(lhs);
  if (volatileField == null) {
    return;
  }
  final IElementType tokenType = expression.getOperationTokenType();
  if (tokenType.equals(JavaTokenType.PLUSEQ) ||
      tokenType.equals(JavaTokenType.MINUSEQ) ||
      tokenType.equals(JavaTokenType.ASTERISKEQ) ||
      tokenType.equals(JavaTokenType.DIVEQ) ||
      tokenType.equals(JavaTokenType.ANDEQ) ||
      tokenType.equals(JavaTokenType.OREQ) ||
      tokenType.equals(JavaTokenType.XOREQ) ||
      tokenType.equals(JavaTokenType.PERCEQ) ||
      tokenType.equals(JavaTokenType.LTLTEQ) ||
      tokenType.equals(JavaTokenType.GTGTEQ) ||
      tokenType.equals(JavaTokenType.GTGTGTEQ)) {
    registerError(lhs);
    return;
  }
  if (VariableAccessUtils.variableIsUsed(volatileField, rhs)) {
    registerError(lhs);
  }
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入方法依赖的package包/类
@Override
public void visitAssignmentExpression(
  @NotNull PsiAssignmentExpression expression) {
  super.visitAssignmentExpression(expression);
  final PsiExpression lhs = expression.getLExpression();
  final PsiParameter parameter = getMethodParameter(lhs);
  if (parameter == null) {
    return;
  }
  if (ignoreTransformationOfOriginalParameter) {
    final PsiExpression rhs = expression.getRExpression();
    if (rhs != null && VariableAccessUtils.variableIsUsed(parameter, rhs)) {
      return;
    }
    final IElementType tokenType =
      expression.getOperationTokenType();
    if (tokenType == JavaTokenType.PLUSEQ ||
        tokenType == JavaTokenType.MINUSEQ ||
        tokenType == JavaTokenType.ASTERISKEQ ||
        tokenType == JavaTokenType.DIVEQ ||
        tokenType == JavaTokenType.ANDEQ ||
        tokenType == JavaTokenType.OREQ ||
        tokenType == JavaTokenType.XOREQ ||
        tokenType == JavaTokenType.PERCEQ ||
        tokenType == JavaTokenType.LTLTEQ ||
        tokenType == JavaTokenType.GTGTEQ ||
        tokenType == JavaTokenType.GTGTGTEQ) {
      return;
    }
  }
  registerError(lhs);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入方法依赖的package包/类
private boolean isImmediatelyAssigned(PsiVariable variable) {
  final PsiCodeBlock containingScope = PsiTreeUtil.getParentOfType(variable, PsiCodeBlock.class, true, PsiClass.class);
  if (containingScope == null) {
    return false;
  }
  final PsiElement parent = variable.getParent();
  if (!(parent instanceof PsiDeclarationStatement)) {
    return false;
  }
  final PsiDeclarationStatement declarationStatement = (PsiDeclarationStatement)parent;
  PsiStatement nextStatement = null;
  int followingStatementNumber = 0;
  final PsiStatement[] statements = containingScope.getStatements();
  for (int i = 0; i < (statements.length - 1); i++) {
    if (statements[i].equals(declarationStatement)) {
      nextStatement = statements[i + 1];
      followingStatementNumber = i + 2;
      break;
    }
  }
  if (!(nextStatement instanceof PsiExpressionStatement)) {
    return false;
  }
  final PsiExpressionStatement expressionStatement = (PsiExpressionStatement)nextStatement;
  final PsiExpression expression = expressionStatement.getExpression();
  if (!(expression instanceof PsiAssignmentExpression)) {
    return false;
  }
  final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)expression;
  final IElementType tokenType = assignmentExpression.getOperationTokenType();
  if (tokenType != JavaTokenType.EQ) {
    return false;
  }
  final PsiExpression rhs = ParenthesesUtils.stripParentheses(assignmentExpression.getRExpression());
  if (!(rhs instanceof PsiReferenceExpression)) {
    return false;
  }
  final PsiReferenceExpression reference = (PsiReferenceExpression)rhs;
  final PsiElement referent = reference.resolve();
  if (referent == null || !referent.equals(variable)) {
    return false;
  }
  final PsiExpression lhs = assignmentExpression.getLExpression();
  if (lhs instanceof PsiArrayAccessExpression) {
    return false;
  }
  if (isVariableUsedInFollowingDeclarations(variable, declarationStatement)) {
    return false;
  }
  for (int i = followingStatementNumber; i < statements.length; i++) {
    if (VariableAccessUtils.variableIsUsed(variable, statements[i])) {
      return false;
    }
  }
  return true;
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入方法依赖的package包/类
@Override
public void visitAssignmentExpression(
  @NotNull PsiAssignmentExpression assignment) {
  super.visitAssignmentExpression(assignment);
  final PsiElement assignmentParent = assignment.getParent();
  if (!(assignmentParent instanceof PsiExpressionStatement)) {
    return;
  }
  final PsiExpression lhs = assignment.getLExpression();
  if (!(lhs instanceof PsiReferenceExpression)) {
    return;
  }
  final PsiReferenceExpression reference =
    (PsiReferenceExpression)lhs;
  final PsiElement referent = reference.resolve();
  if (!(referent instanceof PsiLocalVariable)) {
    return;
  }
  final PsiVariable variable = (PsiVariable)referent;

  //TODO: this is safe, but can be weakened
  if (variable.getInitializer() == null) {
    return;
  }
  final IElementType tokenType = assignment.getOperationTokenType();
  if (!JavaTokenType.EQ.equals(tokenType)) {
    return;
  }
  final PsiExpression rhs = assignment.getRExpression();
  if (rhs != null &&
      VariableAccessUtils.variableIsUsed(variable, rhs)) {
    return;
  }
  final PsiCodeBlock variableBlock =
    PsiTreeUtil.getParentOfType(variable, PsiCodeBlock.class);
  if (variableBlock == null) {
    return;
  }

  if (loopExistsBetween(assignment, variableBlock)) {
    return;
  }
  if (tryExistsBetween(assignment, variableBlock)) {
    // this could be weakened, slightly, if it could be verified
    // that a variable is used in only one branch of a try statement
    return;
  }
  final PsiElement assignmentBlock =
    assignmentParent.getParent();
  if (assignmentBlock == null) {
    return;
  }
  if (variableBlock.equals(assignmentBlock)) {
    registerError(lhs);
  }
  final PsiStatement[] statements = variableBlock.getStatements();
  final PsiElement containingStatement =
    getChildWhichContainsElement(variableBlock, assignment);
  int statementPosition = -1;
  for (int i = 0; i < statements.length; i++) {
    if (statements[i].equals(containingStatement)) {
      statementPosition = i;
      break;
    }
  }
  if (statementPosition == -1) {
    return;
  }
  for (int i = statementPosition + 1; i < statements.length; i++) {
    if (VariableAccessUtils.variableIsUsed(variable, statements[i])) {
      return;
    }
  }
  registerError(lhs);
}
 

import com.siyeh.ig.psiutils.VariableAccessUtils; //导入方法依赖的package包/类
private boolean isImmediatelyAssigned(PsiVariable variable) {
  final PsiCodeBlock containingScope = PsiTreeUtil.getParentOfType(variable, PsiCodeBlock.class, true, PsiClass.class);
  if (containingScope == null) {
    return false;
  }
  final PsiElement parent = variable.getParent();
  if (!(parent instanceof PsiDeclarationStatement)) {
    return false;
  }
  final PsiDeclarationStatement declarationStatement = (PsiDeclarationStatement)parent;
  PsiStatement nextStatement = null;
  int followingStatementNumber = 0;
  final PsiStatement[] statements = containingScope.getStatements();
  for (int i = 0; i < (statements.length - 1); i++) {
    if (statements[i].equals(declarationStatement)) {
      nextStatement = statements[i + 1];
      followingStatementNumber = i + 2;
      break;
    }
  }
  if (!(nextStatement instanceof PsiExpressionStatement)) {
    return false;
  }
  final PsiExpressionStatement expressionStatement = (PsiExpressionStatement)nextStatement;
  final PsiExpression expression = expressionStatement.getExpression();
  if (!(expression instanceof PsiAssignmentExpression)) {
    return false;
  }
  final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)expression;
  final IElementType tokenType = assignmentExpression.getOperationTokenType();
  if (tokenType != JavaTokenType.EQ) {
    return false;
  }
  final PsiExpression rhs = assignmentExpression.getRExpression();
  if (!(rhs instanceof PsiReferenceExpression)) {
    return false;
  }
  final PsiReferenceExpression reference = (PsiReferenceExpression)rhs;
  final PsiElement referent = reference.resolve();
  if (referent == null || !referent.equals(variable)) {
    return false;
  }
  final PsiExpression lhs = assignmentExpression.getLExpression();
  if (lhs instanceof PsiArrayAccessExpression) {
    return false;
  }
  if (isVariableUsedInFollowingDeclarations(variable, declarationStatement)) {
    return false;
  }
  for (int i = followingStatementNumber; i < statements.length; i++) {
    if (VariableAccessUtils.variableIsUsed(variable, statements[i])) {
      return false;
    }
  }
  return true;
}