Java Code Examples for com.intellij.psi.util.PsiTreeUtil#getContextOfType()

@Nonnull
@RequiredReadAction
private static List<DotNetTypeDeclaration> collectAllTypes(@Nonnull PsiElement place)
{
	List<DotNetTypeDeclaration> typeDeclarations = new SmartList<>();
	if(place instanceof CSharpTypeDeclaration)
	{
		typeDeclarations.add((DotNetTypeDeclaration) place);
	}
	PsiElement type = place;
	while((type = PsiTreeUtil.getContextOfType(type, DotNetTypeDeclaration.class)) != null)
	{
		typeDeclarations.add((DotNetTypeDeclaration) type);
	}
	return typeDeclarations;
}
 

@RequiredReadAction
@Override
public void process(@Nonnull CSharpResolveOptions options,
		@Nonnull DotNetGenericExtractor defaultExtractor,
		@Nullable PsiElement forceQualifierElement,
		@Nonnull Processor<ResolveResult> processor)
{
	DotNetTypeDeclaration thisTypeDeclaration = PsiTreeUtil.getContextOfType(options.getElement(), DotNetTypeDeclaration.class);
	if(thisTypeDeclaration != null)
	{
		thisTypeDeclaration = CSharpCompositeTypeDeclaration.selectCompositeOrSelfType(thisTypeDeclaration);

		DotNetGenericExtractor genericExtractor = DotNetGenericExtractor.EMPTY;
		int genericParametersCount = thisTypeDeclaration.getGenericParametersCount();
		if(genericParametersCount > 0)
		{
			Map<DotNetGenericParameter, DotNetTypeRef> map = new THashMap<>(genericParametersCount);
			for(DotNetGenericParameter genericParameter : thisTypeDeclaration.getGenericParameters())
			{
				map.put(genericParameter, new CSharpTypeRefFromGenericParameter(genericParameter));
			}
			genericExtractor = CSharpGenericExtractor.create(map);
		}
		processor.process(new CSharpResolveResultWithExtractor(thisTypeDeclaration, genericExtractor));
	}
}
 

@Nullable
public PsiFile getContainingFile() {
    if (!isValid()) {
        return null;
    }

    PsiFile file = originalElement.getContainingFile();
    final PsiElement context = originalElement.getContext();
    if (file == null && context != null) {
        file = context.getContainingFile();
    }
    PsiFile f;
    if ((f = PsiTreeUtil.getContextOfType(file, PsiFile.class, true)) instanceof XQueryFile) {
        return f;
    }
    return file;
}
 

@Nullable
@RequiredReadAction
private static LookupElementWeigher recursiveSorter(CompletionParameters completionParameters, CompletionResultSet result)
{
	PsiElement position = completionParameters.getPosition();


	Set<PsiElement> elements = new THashSet<>();

	PsiElement argumentListOwner = PsiTreeUtil.getContextOfType(position, CSharpCallArgumentListOwner.class, DotNetVariable.class);
	if(argumentListOwner instanceof CSharpMethodCallExpressionImpl)
	{
		ContainerUtil.addIfNotNull(elements, ((CSharpMethodCallExpressionImpl) argumentListOwner).resolveToCallable());
	}
	else if(argumentListOwner instanceof DotNetVariable)
	{
		elements.add(argumentListOwner);
	}

	List<CSharpForeachStatementImpl> foreachStatements = SyntaxTraverser.psiApi().parents(position).filter(CSharpForeachStatementImpl.class).addAllTo(new ArrayList<>());
	for(CSharpForeachStatementImpl foreachStatement : foreachStatements)
	{
		DotNetExpression iterableExpression = foreachStatement.getIterableExpression();
		if(iterableExpression instanceof CSharpReferenceExpression)
		{
			ContainerUtil.addIfNotNull(elements, ((CSharpReferenceExpression) iterableExpression).resolve());
		}
	}

	if(!elements.isEmpty())
	{
		return new CSharpRecursiveGuardWeigher(elements);
	}
	return null;
}
 

@RequiredReadAction
@Nullable
@Override
public HighlightInfoFactory checkImpl(@Nonnull CSharpLanguageVersion languageVersion, @Nonnull CSharpHighlightContext highlightContext, @Nonnull CSharpReferenceExpression element)
{
	if(element.kind() == CSharpReferenceExpression.ResolveToKind.THIS)
	{
		DotNetModifierListOwner modifierListOwner = (DotNetModifierListOwner) PsiTreeUtil.getContextOfType(element, DotNetQualifiedElement.class);
		if(modifierListOwner == null || modifierListOwner.hasModifier(DotNetModifier.STATIC))
		{
			return newBuilder(element, "this");
		}
	}
	return null;
}
 

protected void doTest(String newName) throws Exception {
  myFixture.configureByFile(getBasePath() + "/before" + getTestName(false) + ".java");

  PsiElement psiElement = myFixture.getFile().findElementAt(myFixture.getEditor().getCaretModel().getOffset());
  PsiElement psiClass = PsiTreeUtil.getContextOfType(psiElement, PsiClass.class, true);
  myFixture.renameElement(psiClass, newName);

  checkResultByFile(getBasePath() + "/after" + getTestName(false) + ".java");
}
 

/** Called upon jump to def for this rule ref */
@Nullable
@Override
public PsiElement resolve() {
	PsiFile tokenVocabFile = TokenVocabResolver.resolveTokenVocabFile(getElement());

	if (tokenVocabFile != null) {
		return tokenVocabFile;
	}

	PsiFile importedFile = ImportResolver.resolveImportedFile(getElement());
	if ( importedFile!=null ) {
		return importedFile;
	}

	GrammarSpecNode grammar = PsiTreeUtil.getContextOfType(getElement(), GrammarSpecNode.class);
	PsiElement specNode = MyPsiUtils.findSpecNode(grammar, ruleName);

	if (specNode != null) {
		return specNode;
	}

	// Look for a rule defined in an imported grammar
	specNode = ImportResolver.resolveInImportedFiles(getElement().getContainingFile(), ruleName);

	if (specNode != null) {
		return specNode;
	}

	// Look for a lexer rule in the tokenVocab file if it exists
	if (getElement() instanceof LexerRuleRefNode) {
		return TokenVocabResolver.resolveInTokenVocab(getElement(), ruleName);
	}

	return null;
}
 

public JSGraphQLEndpointDocCompletionContributor() {

		CompletionProvider<CompletionParameters> provider = new CompletionProvider<CompletionParameters>() {
			@SuppressWarnings("unchecked")
			@Override
			protected void addCompletions(@NotNull final CompletionParameters parameters, ProcessingContext context, @NotNull CompletionResultSet result) {

				final PsiFile file = parameters.getOriginalFile();

				if (!(file instanceof JSGraphQLEndpointDocFile)) {
					return;
				}

				final PsiElement completionElement = Optional.ofNullable(parameters.getOriginalPosition()).orElse(parameters.getPosition());
				if (completionElement != null) {
					final PsiComment comment = PsiTreeUtil.getContextOfType(completionElement, PsiComment.class);
					if (comment != null && JSGraphQLEndpointDocPsiUtil.isDocumentationComment(comment)) {

						if (completionElement.getNode().getElementType() == JSGraphQLEndpointDocTokenTypes.DOCVALUE) {
							final JSGraphQLEndpointFieldDefinition fieldDefinition = PsiTreeUtil.getNextSiblingOfType(comment, JSGraphQLEndpointFieldDefinition.class);
							if (fieldDefinition != null && fieldDefinition.getArgumentsDefinition() != null) {
								final List<String> otherDocTagValues = JSGraphQLEndpointDocPsiUtil.getOtherDocTagValues(comment);
								for (JSGraphQLEndpointInputValueDefinition arg : PsiTreeUtil.findChildrenOfType(fieldDefinition.getArgumentsDefinition(), JSGraphQLEndpointInputValueDefinition.class)) {
									final String argName = arg.getInputValueDefinitionIdentifier().getText();
									if (!otherDocTagValues.contains(argName)) {
										result.addElement(LookupElementBuilder.create(argName).withInsertHandler(AddSpaceInsertHandler.INSTANCE));
									}
								}
							}
							return;
						}

						final JSGraphQLEndpointDocTag tagBefore = PsiTreeUtil.getPrevSiblingOfType(completionElement, JSGraphQLEndpointDocTag.class);
						final JSGraphQLEndpointDocTag tagParent = PsiTreeUtil.getParentOfType(completionElement, JSGraphQLEndpointDocTag.class);
						if (tagBefore == null || tagParent != null) {
							String completion = "param";
							final boolean includeAt = completionElement.getNode().getElementType() != JSGraphQLEndpointDocTokenTypes.DOCNAME;
							if (includeAt) {
								completion = "@" + completion;
							}
							result.addElement(LookupElementBuilder.create(completion).withInsertHandler(AddSpaceInsertHandler.INSTANCE_WITH_AUTO_POPUP));
						}
					}
				}
			}
		};

		extend(CompletionType.BASIC, PlatformPatterns.psiElement(), provider);

	}
 

@SuppressWarnings("unchecked")
@Override
public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder) {

	final IElementType elementType = element.getNode().getElementType();

       // highlight TO-DO items
       if(elementType == JSGraphQLEndpointDocTokenTypes.DOCTEXT) {
		final String elementText = element.getText().toLowerCase();
		if(isTodoToken(elementText)) {
			setTextAttributes(element, holder, CodeInsightColors.TODO_DEFAULT_ATTRIBUTES);
               holder.getCurrentAnnotationSession().putUserData(TODO_ELEMENT, element);
			return;
		} else {
               PsiElement prevSibling = element.getPrevSibling();
               while (prevSibling != null) {
                   if(prevSibling == holder.getCurrentAnnotationSession().getUserData(TODO_ELEMENT)) {
                       setTextAttributes(element, holder, CodeInsightColors.TODO_DEFAULT_ATTRIBUTES);
                       return;
                   }
                   prevSibling = prevSibling.getPrevSibling();
               }
           }
	}

	final PsiComment comment = PsiTreeUtil.getContextOfType(element, PsiComment.class);
	if (comment != null && JSGraphQLEndpointDocPsiUtil.isDocumentationComment(comment)) {
		final TextAttributesKey textAttributesKey = ATTRIBUTES.get(elementType);
		if (textAttributesKey != null) {
			setTextAttributes(element, holder, textAttributesKey);
		}
		// highlight invalid argument names after @param
		if(elementType == JSGraphQLEndpointDocTokenTypes.DOCVALUE) {
			final JSGraphQLEndpointFieldDefinition field = PsiTreeUtil.getNextSiblingOfType(comment, JSGraphQLEndpointFieldDefinition.class);
			if(field != null) {
				final JSGraphQLEndpointDocTag tag = PsiTreeUtil.getParentOfType(element, JSGraphQLEndpointDocTag.class);
				if(tag != null && tag.getDocName().getText().equals("@param")) {
					final String paramName = element.getText();
					final JSGraphQLEndpointInputValueDefinitions arguments = PsiTreeUtil.findChildOfType(field, JSGraphQLEndpointInputValueDefinitions.class);
					if(arguments == null) {
						// no arguments so invalid use of @param
						holder.createErrorAnnotation(element, "Invalid use of @param. The property has no arguments");
					} else {
						final JSGraphQLEndpointInputValueDefinition[] inputValues = PsiTreeUtil.getChildrenOfType(arguments, JSGraphQLEndpointInputValueDefinition.class);
						boolean found = false;
						if(inputValues != null) {
							for (JSGraphQLEndpointInputValueDefinition inputValue: inputValues) {
								if(inputValue.getInputValueDefinitionIdentifier().getText().equals(paramName)) {
									found = true;
									break;
								}
							}
						}
						if(!found) {
							holder.createErrorAnnotation(element, "@param name '" + element.getText() + "' doesn't match any of the field arguments");
						}

					}
				}
			}
		}
	}
}
 

@Override
protected void addBashCompletions(String currentText, CompletionParameters parameters, ProcessingContext context, CompletionResultSet result) {
    PsiElement element = parameters.getPosition();

    BashVar varElement = PsiTreeUtil.getContextOfType(element, BashVar.class, false);
    boolean dollarPrefix = currentText != null && currentText.startsWith("$");
    boolean insideExpansion = element.getParent() != null && element.getParent().getParent() instanceof BashParameterExpansion;
    if (varElement == null && !dollarPrefix && !insideExpansion) {
        return;
    }

    int invocationCount = parameters.getInvocationCount();
    int resultLength = 0;

    PsiElement original = parameters.getOriginalPosition();
    BashVar varElementOriginal = original != null ? PsiTreeUtil.getContextOfType(original, BashVar.class, false) : null;

    if (varElement != null) {
        // only keep vars of included files when starting in the original file
        PsiElement originalRef = varElementOriginal != null ? varElementOriginal : original;
        if (originalRef != null) {
            resultLength += addCollectedVariables(original, result, new BashVarVariantsProcessor(originalRef, false, true));
        }

        // only keep vars of the dummy file when starting in the dummy file
        resultLength += addCollectedVariables(element, result, new BashVarVariantsProcessor(varElement, true, false));
    } else {
        // not in a variable element, but collect all known variable names at this offset in the current file
        if (original != null) {
            resultLength += addCollectedVariables(original, result, new BashVarVariantsProcessor(original, false, true));
        }
        resultLength += addCollectedVariables(element, result, new BashVarVariantsProcessor(element, false, true));
    }

    if (currentText != null && (dollarPrefix || insideExpansion) && (invocationCount >= 2 || resultLength == 0)) {
        Project project = element.getProject();
        addBuiltInVariables(result, project);
        addGlobalVariables(result, project);
    } else {
        result.addLookupAdvertisement("Press twice for global variables");
    }
}
 

/** Using for completion. Returns list of rules and tokens; the prefix
	 *  of current element is used as filter by IDEA later.
	 */
	@NotNull
	@Override
	public Object[] getVariants() {
		String prefix = myElement.getText();
		RulesNode rules = PsiTreeUtil.getContextOfType(myElement, RulesNode.class);
		// find all rule defs (token, parser)
		Collection<? extends RuleSpecNode> ruleSpecNodes =
			PsiTreeUtil.findChildrenOfAnyType(rules,
											  new Class[] {
												ParserRuleSpecNode.class,
											  	LexerRuleSpecNode.class}
											 );

		return ruleSpecNodes.toArray();
//
//		final ArrayList<LookupElement> list = new ArrayList<LookupElement>();
//		PsiFile containingFile = myElement.getContainingFile();
//		List<BnfRule> rules = containingFile instanceof BnfFile ? ((BnfFile)containingFile).getRules() : Collections.<BnfRule>emptyList();
//		for (BnfRule rule : rules) {
//			boolean fakeRule = ParserGeneratorUtil.Rule.isFake(rule);
//			boolean privateRule = ParserGeneratorUtil.Rule.isPrivate(rule);
//			list.add(LookupElementBuilder.createWithIcon(rule).withBoldness(!privateRule).withStrikeoutness(fakeRule));
//		}
//		if (GrammarUtil.isExternalReference(myElement)) {
//			BnfRule rule = PsiTreeUtil.getParentOfType(myElement, BnfRule.class);
//			String parserClass = ParserGeneratorUtil.getAttribute(rule, KnownAttribute.PARSER_UTIL_CLASS);
//			if (StringUtil.isNotEmpty(parserClass)) {
//				JavaHelper javaHelper = JavaHelper.getJavaHelper(myElement.getProject());
//				for (NavigatablePsiElement element : javaHelper.getClassMethods(parserClass, true)) {
//					List<String> methodTypes = javaHelper.getMethodTypes(element);
//					if (methodTypes.size() > 3 &&
//						methodTypes.get(0).equals("boolean") &&
//						methodTypes.get(1).equals("com.intellij.lang.PsiBuilder") &&
//						methodTypes.get(3).equals("int")) {
//						list.add(LookupElementBuilder.createWithIcon((PsiNamedElement)element));
//					}
//				}
//			}
//		}
//		return ArrayUtil.toObjectArray(list);
	}