Java PsiDeclarationStatement.getDeclaredElements方法代码示例

import com.intellij.psi.PsiDeclarationStatement; //导入方法依赖的package包/类
private PsiMethodCallExpression findMethodCall(PsiElement element) {
    // This covers the case if there is a method being used to initialize a variable..
    // i.e int a = random();
    if (element instanceof PsiDeclarationStatement) {
        PsiDeclarationStatement declarationStatement = (PsiDeclarationStatement) element;
        for (PsiElement declarationElement : declarationStatement.getDeclaredElements()) {
            if (declarationElement instanceof PsiVariable) {
                PsiVariable variable = (PsiVariable) declarationElement;
                PsiExpression initializer = variable.getInitializer();
                if (initializer instanceof PsiMethodCallExpression) {
                    return (PsiMethodCallExpression) initializer;
                }
            }
        }
    }
    if (element instanceof PsiExpressionStatement) {
        PsiExpression expression = ((PsiExpressionStatement) element).getExpression();
        if (expression instanceof PsiMethodCallExpression) {
            return (PsiMethodCallExpression) expression;
        }
    }
    return null;
}
 

import com.intellij.psi.PsiDeclarationStatement; //导入方法依赖的package包/类
@Override
public void visitDeclarationStatement(
  @NotNull PsiDeclarationStatement statement) {
  if (assignedFrom) {
    return;
  }
  super.visitDeclarationStatement(statement);
  final PsiElement[] declaredElements = statement.getDeclaredElements();
  for (PsiElement declaredElement : declaredElements) {
    if (declaredElement instanceof PsiVariable) {
      final PsiVariable declaredVariable =
        (PsiVariable)declaredElement;
      final PsiExpression initializer =
        declaredVariable.getInitializer();
      if (initializer != null &&
          VariableAccessUtils.mayEvaluateToVariable(initializer,
                                                    variable)) {
        assignedFrom = true;
        return;
      }
    }
  }
}
 

import com.intellij.psi.PsiDeclarationStatement; //导入方法依赖的package包/类
/**
 * ローカル変数取得 (宣言文で定義された変数)
 * @param declaration ルートノード
 * @return ローカル変数 (空要素の場合もあります)
 */
public static @Nullable PsiLocalVariable getVariable(PsiDeclarationStatement declaration) {
    PsiElement[] elements = declaration.getDeclaredElements();
    for (PsiElement element : elements) {
        if (element instanceof PsiLocalVariable) {
            PsiLocalVariable valiable = (PsiLocalVariable) element;
            return valiable;
        }
    }
    return null;
}
 

import com.intellij.psi.PsiDeclarationStatement; //导入方法依赖的package包/类
@Nullable
public static CountingLoop from(PsiForStatement forStatement)
{
	// check that initialization is for(int/long i = <initial_value>;...;...)
	PsiDeclarationStatement initialization = tryCast(forStatement.getInitialization(), PsiDeclarationStatement.class);
	if(initialization == null || initialization.getDeclaredElements().length != 1)
	{
		return null;
	}
	PsiLocalVariable counter = tryCast(initialization.getDeclaredElements()[0], PsiLocalVariable.class);
	if(counter == null)
	{
		return null;
	}
	if(!counter.getType().equals(PsiType.INT) && !counter.getType().equals(PsiType.LONG))
	{
		return null;
	}

	PsiExpression initializer = PsiUtil.skipParenthesizedExprDown(counter.getInitializer());
	if(initializer == null)
	{
		return null;
	}

	// check that increment is like for(...;...;i++)
	if(!VariableAccessUtils.variableIsIncremented(counter, forStatement.getUpdate()))
	{
		return null;
	}

	// check that condition is like for(...;i<bound;...) or for(...;i<=bound;...)
	PsiBinaryExpression condition = tryCast(forStatement.getCondition(), PsiBinaryExpression.class);
	if(condition == null)
	{
		return null;
	}
	IElementType type = condition.getOperationTokenType();
	boolean closed = false;
	PsiExpression bound;
	PsiExpression ref;
	if(type.equals(JavaTokenType.LE))
	{
		bound = condition.getROperand();
		ref = condition.getLOperand();
		closed = true;
	}
	else if(type.equals(JavaTokenType.LT))
	{
		bound = condition.getROperand();
		ref = condition.getLOperand();
	}
	else if(type.equals(JavaTokenType.GE))
	{
		bound = condition.getLOperand();
		ref = condition.getROperand();
		closed = true;
	}
	else if(type.equals(JavaTokenType.GT))
	{
		bound = condition.getLOperand();
		ref = condition.getROperand();
	}
	else
	{
		return null;
	}
	if(bound == null || !ExpressionUtils.isReferenceTo(ref, counter))
	{
		return null;
	}
	if(!TypeConversionUtil.areTypesAssignmentCompatible(counter.getType(), bound))
	{
		return null;
	}
	return new CountingLoop(forStatement, counter, initializer, bound, closed);
}