Java PsiUtil.getVariableCodeBlock方法代码示例

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
public static boolean isVariableAssignedInLoop(@NotNull PsiReferenceExpression expression, PsiElement resolved) {
  if (!(expression.getParent() instanceof PsiAssignmentExpression)
      || ((PsiAssignmentExpression)expression.getParent()).getLExpression() != expression) {
    return false;
  }
  PsiExpression qualifier = expression.getQualifierExpression();
  if (qualifier != null && !(qualifier instanceof PsiThisExpression)) return false;

  if (!(resolved instanceof PsiVariable)) return false;
  PsiVariable variable = (PsiVariable)resolved;

  final PsiElement codeBlock = PsiUtil.getVariableCodeBlock(variable, expression);
  if (codeBlock == null) return false;
  final ControlFlow flow;
  try {
    flow = ControlFlowFactory.getInstance(codeBlock.getProject()).getControlFlow(codeBlock, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), false);
  }
  catch (AnalysisCanceledException e) {
    return false;
  }
  final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)expression.getParent();
  int startOffset = flow.getStartOffset(assignmentExpression);
  return startOffset != -1 && isInstructionReachable(flow, startOffset, startOffset);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private PsiElement getStatementToInsertBefore() {
  PsiElement declarationScope = myVariable instanceof PsiParameter
                                ? ((PsiParameter)myVariable).getDeclarationScope() : PsiUtil.getVariableCodeBlock(myVariable, null);
  if (declarationScope == null) return null;

  PsiElement statement = myContext;
  nextInnerClass:
  do {
    statement = RefactoringUtil.getParentStatement(statement, false);

    if (statement == null || statement.getParent() == null) {
      return null;
    }
    PsiElement element = statement;
    while (element != declarationScope && !(element instanceof PsiFile)) {
      if (element instanceof PsiClass) {
        statement = statement.getParent();
        continue nextInnerClass;
      }
      element = element.getParent();
    }
    return statement;
  }
  while (true);
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
public static boolean isEffectivelyFinal(@NotNull PsiVariable variable, @NotNull PsiElement scope, @Nullable PsiJavaCodeReferenceElement context) {
  boolean effectivelyFinal;
  if (variable instanceof PsiParameter) {
    effectivelyFinal = notAccessedForWriting(variable, new LocalSearchScope(((PsiParameter)variable).getDeclarationScope()));
  }
  else {
    final ControlFlow controlFlow;
    try {
      PsiElement codeBlock = PsiUtil.getVariableCodeBlock(variable, context);
      if (codeBlock == null) return true;
      controlFlow = getControlFlow(codeBlock);
    }
    catch (AnalysisCanceledException e) {
      return true;
    }

    final List<PsiReferenceExpression> readBeforeWriteLocals = ControlFlowUtil.getReadBeforeWriteLocals(controlFlow);
    for (PsiReferenceExpression expression : readBeforeWriteLocals) {
      if (expression.resolve() == variable) {
        return PsiUtil.isAccessedForReading(expression);
      }
    }

    final Collection<ControlFlowUtil.VariableInfo> initializedTwice = ControlFlowUtil.getInitializedTwice(controlFlow);
    effectivelyFinal = !initializedTwice.contains(new ControlFlowUtil.VariableInfo(variable, null));
    if (effectivelyFinal) {
      effectivelyFinal = notAccessedForWriting(variable, new LocalSearchScope(scope));
    }
  }
  return effectivelyFinal;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private static int getQuickFixType(@NotNull PsiVariable variable) {
  PsiElement outerCodeBlock = PsiUtil.getVariableCodeBlock(variable, null);
  if (outerCodeBlock == null) return -1;
  List<PsiReferenceExpression> outerReferences = new ArrayList<PsiReferenceExpression>();
  collectReferences(outerCodeBlock, variable, outerReferences);

  int type = MAKE_FINAL;
  for (PsiReferenceExpression expression : outerReferences) {
    // if it happens that variable referenced from another inner class, make sure it can be make final from there
    PsiElement innerScope = HighlightControlFlowUtil.getInnerClassVariableReferencedFrom(variable, expression);

    if (innerScope != null) {
      int thisType = MAKE_FINAL;
      if (writtenInside(variable, innerScope)) {
        // cannot make parameter array
        if (variable instanceof PsiParameter) return -1;
        thisType = MAKE_ARRAY;
      }
      if (thisType == MAKE_FINAL
          && !canBeFinal(variable, outerReferences)) {
        thisType = COPY_TO_FINAL;
      }
      type = Math.max(type, thisType);
    }
  }
  return type;
}
 

import com.intellij.psi.util.PsiUtil; //导入方法依赖的package包/类
private void deferLocalVariable(PsiLocalVariable variable) throws IncorrectOperationException {
  PsiElement outerCodeBlock = PsiUtil.getVariableCodeBlock(variable, null);
  deferVariable(outerCodeBlock, variable, variable.getParent());
}