Java Code Examples for com.intellij.psi.PsiElement#accept()

public final Map<String, Set<String>> getImportInLines(final Editor projectEditor,
                                                       final Pair<Integer, Integer> pair) {
    PsiDocumentManager psiInstance =
            PsiDocumentManager.getInstance(windowObjects.getProject());
    PsiJavaFile psiJavaFile =
            (PsiJavaFile) psiInstance.getPsiFile(projectEditor.getDocument());
    PsiJavaElementVisitor psiJavaElementVisitor =
            new PsiJavaElementVisitor(pair.getFirst(), pair.getSecond());
    Map<String, Set<String>> finalImports = new HashMap<>();
    if (psiJavaFile != null && psiJavaFile.findElementAt(pair.getFirst()) != null) {
        PsiElement psiElement = psiJavaFile.findElementAt(pair.getFirst());
        final PsiElement psiMethod = PsiTreeUtil.getParentOfType(psiElement, PsiMethod.class);
        if (psiMethod != null) {
            psiMethod.accept(psiJavaElementVisitor);
        } else {
            final PsiClass psiClass = PsiTreeUtil.getParentOfType(psiElement, PsiClass.class);
            if (psiClass != null) {
                psiClass.accept(psiJavaElementVisitor);
            }
        }
        Map<String, Set<String>> importVsMethods = psiJavaElementVisitor.getImportVsMethods();
        finalImports = getImportsAndMethodsAfterValidation(psiJavaFile, importVsMethods);
    }
    return removeImplicitImports(finalImports);
}
 

@Override
protected void buildLanguageFoldRegions(@Nonnull final List<FoldingDescriptor> descriptors, @Nonnull PsiElement root, @Nonnull Document document, boolean quick)
{
	root.accept(new SharpLabElementVisitor()
	{
		@Override
		public void visitElement(PsiElement element)
		{
			if(element instanceof ShaderBraceOwner)
			{
				descriptors.add(new FoldingDescriptor(element, element.getTextRange()));
			}
			element.acceptChildren(this);
		}
	});
}
 

@Override
@RequiredReadAction
public void visitElement(PsiElement element)
{
	ProgressManager.checkCanceled();
	if(myValue != null)
	{
		return;
	}
	PsiElement child = element.getFirstChild();
	while(child != null)
	{
		if(myValue != null)
		{
			return;
		}
		child.accept(this);
		child = child.getNextSibling();
	}
}
 

@Nonnull
public static UnusedUsingVisitor accept(@Nonnull PsiFile file)
{
	final UnusedUsingVisitor unusedUsingVisitor = new UnusedUsingVisitor();
	PsiRecursiveElementVisitor visitor = new PsiRecursiveElementVisitor()
	{
		@Override
		public void visitElement(PsiElement element)
		{
			element.accept(unusedUsingVisitor);
			super.visitElement(element);
		}
	};
	file.accept(visitor);
	return unusedUsingVisitor;
}
 

@RequiredReadAction
@Nonnull
@Override
public Set<PsiElement> getAllExecutableChildren(@Nonnull PsiElement root)
{
	final Set<PsiElement> lambdas = new LinkedHashSet<>();
	root.accept(new CSharpRecursiveElementVisitor()
	{
		@Override
		public void visitAnonymMethodExpression(CSharpDelegateExpressionImpl method)
		{
			lambdas.add(method);
		}

		@Override
		public void visitLambdaExpression(CSharpLambdaExpressionImpl expression)
		{
			lambdas.add(expression);
		}
	});
	return lambdas;
}
 

private void annotatePattern() {
  for (final PsiElement patternComponent : myPattern) {
    patternComponent.accept(new PsiRecursiveElementWalkingVisitor() {
      @Override
      public void visitElement(PsiElement element) {
        super.visitElement(element);
        if (myParameters.contains(element.getText())) {
          element.putUserData(PARAMETER, element);
        }

      }
    });
  }
}
 

@Override
public synchronized void annotate(PsiElement element, AnnotationHolder holder) {
  this.holder = holder;
  try {
    element.accept(this);
  } finally {
    this.holder = null;
  }
}
 

private void deannotatePattern() {
  for (final PsiElement patternComponent : myPattern) {
    patternComponent.accept(new PsiRecursiveElementWalkingVisitor() {
      @Override public void visitElement(PsiElement element) {
        if (element.getUserData(PARAMETER) != null) {
          element.putUserData(PARAMETER, null);
        }
      }
    });
  }
}
 

@Nonnull
@RequiredReadAction
public static List<StubBlock> buildBlocks(PsiElement qualifiedElement, boolean compiled)
{
	CSharpStubBuilderVisitor visitor = new CSharpStubBuilderVisitor(compiled);
	qualifiedElement.accept(visitor);
	return visitor.getBlocks();
}
 

@Nonnull
public static List<ExpectedTypeInfo> findExpectedTypeRefs(@Nonnull PsiElement psiElement)
{
	PsiElement parent = psiElement.getParent();
	if(parent == null)
	{
		return Collections.emptyList();
	}

	ExpectedTypeVisitor expectedTypeVisitor = new ExpectedTypeVisitor(psiElement);

	parent.accept(expectedTypeVisitor);

	return ContainerUtil.filter(expectedTypeVisitor.getExpectedTypeInfos(), it -> it.getTypeRef() != DotNetTypeRef.ERROR_TYPE);
}
 

private static boolean processScopeRootForAllClasses(PsiElement scopeRoot, final Processor<? super DotNetTypeDeclaration> processor)
{
	if(scopeRoot == null)
	{
		return true;
	}
	final boolean[] stopped = new boolean[]{false};

	scopeRoot.accept(new CSharpRecursiveElementVisitor()
	{
		@Override
		public void visitElement(PsiElement element)
		{
			if(!stopped[0])
			{
				super.visitElement(element);
			}
		}

		@Override
		public void visitTypeDeclaration(CSharpTypeDeclaration aClass)
		{
			stopped[0] = !processor.process(aClass);
			super.visitTypeDeclaration(aClass);
		}
	});

	return !stopped[0];
}
 

private void visitRecursively(PsiElement element) {
  PsiElement child = element.getFirstChild();
  while (child != null && !foundGtestMacroCall) {
    child.accept(this);
    child = child.getNextSibling();
  }
}
 

@Override
@RequiredReadAction
public void visitMethodCallExpression(CSharpMethodCallExpressionImpl expression)
{
	DotNetExpression callExpression = expression.getCallExpression();

	ResolveResult resolveResult = CSharpResolveUtil.findFirstValidResult(expression.multiResolve(false));
	if(resolveResult == null || !(resolveResult instanceof MethodResolveResult) || !(resolveResult.getElement() instanceof CSharpMethodDeclaration))
	{
		cantEvaluateExpression();
	}

	CSharpMethodDeclaration methodDeclaration = (CSharpMethodDeclaration) resolveResult.getElement();

	if(callExpression instanceof CSharpReferenceExpression)
	{
		CSharpTypeDeclaration typeDeclaration = null;

		PsiElement qualifier = ((CSharpReferenceExpression) callExpression).getQualifier();
		if(qualifier != null)
		{
			qualifier.accept(this);
		}
		else
		{
			if(methodDeclaration.hasModifier(DotNetModifier.STATIC))
			{
				typeDeclaration = (CSharpTypeDeclaration) methodDeclaration.getParent();
				myEvaluators.add(StaticObjectEvaluator.INSTANCE);
			}
			else
			{
				myEvaluators.add(ThisObjectEvaluator.INSTANCE);
			}
		}

		String referenceName = ((CSharpReferenceExpression) callExpression).getReferenceName();
		if(referenceName == null)
		{
			cantEvaluateExpression();
		}

		pushNArguments((MethodResolveResult) resolveResult);

		pushMethodEvaluator(expression, methodDeclaration, typeDeclaration, referenceName);
	}
}
 

@Override
public void visit(@Nonnull PsiElement element)
{
	element.accept(this);
}
 

private AnalyzeContext(PsiElement e)
{
	e.accept(this);
}
 

@Override
public void visit(@Nonnull PsiElement element)
{
	element.accept(this);
}
 

/**
 * Visit all possible elements for render clements, scope shop be the class or a file itself
 */
public static void visitRenderTemplateFunctions(@NotNull PsiElement context, @NotNull Consumer<Triple<String, PhpNamedElement, FunctionReference>> consumer) {
    context.accept(new TemplateRenderPsiRecursiveElementWalkingVisitor(context, consumer));
}
 

public static Collection<Pair<String, PsiElement>> getViewTemplatesPairScope(@NotNull PsiElement psiElement) {
    Collection<Pair<String, PsiElement>> views = new ArrayList<>();

    psiElement.accept(new MyViewRecursiveElementWalkingVisitor(views));

    return views;
}