/** * Returns all extension for given target message. */ public Collection<ExtendNode> getExtenstions(MessageNode target) { return getExtensions().stream() .filter(node -> { TypeReferenceNode extendTarget = node.getTarget(); if (extendTarget == null) { return false; } PsiReference extendTargetReference = extendTarget.getReference(); return extendTargetReference.isReferenceTo(target); }) .collect(Collectors.toList()); }
@Override public void visitElement(PsiElement element) { if (element instanceof BashVarDef) { visited.incrementAndGet(); Assert.assertFalse("A var def must not be a valid definition for the variable used.", psiReference.isReferenceTo(element)); } super.visitElement(element); } });
@Override public void processQuery(@NotNull ReferencesSearch.SearchParameters queryParameters, @NotNull final Processor<PsiReference> consumer) { final PsiElement target = queryParameters.getElementToSearch(); if (!(target instanceof BnfRule)) return; SearchScope scope = queryParameters.getEffectiveSearchScope(); if (!(scope instanceof LocalSearchScope)) return; PsiFile file = target.getContainingFile(); if (!(file instanceof BnfFile)) return; for (BnfAttrs attrs : ((BnfFile)file).getAttributes()) { for (BnfAttr attr : attrs.getAttrList()) { BnfAttrPattern pattern = attr.getAttrPattern(); if (pattern == null) continue; BnfStringLiteralExpression patternExpression = pattern.getLiteralExpression(); PsiReference ref = BnfStringImpl.matchesElement(patternExpression, target) ? patternExpression.getReference() : null; if (ref != null && ref.isReferenceTo(target)) { if (!consumer.process(ref)) return; } } } } }
private BashVarDef assertIsValidVarDef() throws Exception { PsiReference ref = configure(); PsiElement element = ref.resolve(); Assert.assertNotNull("The definition could not be resolved.", element); Assert.assertTrue("The resolved definition is not a BashVarDef: " + element, element instanceof BashVarDef); Assert.assertFalse("The variable must not resolve to itself.", ref.equals(element)); Assert.assertTrue("isReferenceTo is not working properly.", ref.isReferenceTo(element)); return (BashVarDef) element; }
@Test public void testRecursiveInclude() throws Exception { PsiReference reference = configure(); Assert.assertNotNull(reference); //the var has to resolve to the definition in the included file PsiElement def = reference.resolve(); Assert.assertNotNull("Variable is not properly resolved", def); Assert.assertTrue(reference.isReferenceTo(def)); }
variableNameElement1.getReference().isReferenceTo(declarationWrapper) ) {
@NotNull private PsiElement doAssertIsWellDefined(boolean dumMode) throws Exception { DumbServiceImpl instance = DumbServiceImpl.getInstance(myProject); boolean oldDumb = instance.isDumb(); instance.setDumb(dumMode); try { PsiReference start = configure(); PsiElement varDef = start.resolve(); //Assert.assertTrue("The reference is NOT a var reference", start.getElement() instanceof BashVarUse); Assert.assertNotNull("Could not find a definition for the reference: " + start.getElement().getText(), varDef); Assert.assertTrue("The definition is NOT a variable definition: " + varDef, varDef instanceof BashVarDef); Assert.assertTrue("The reference is NOT a reference to the definition", start.isReferenceTo(varDef)); return varDef; } finally { instance.setDumb(oldDumb); } }
@NotNull private PsiElement doCheckFunctionReference(boolean dumbMode) throws Exception { boolean oldDumb = DumbService.isDumb(myProject); DumbServiceImpl.getInstance(myProject).setDumb(dumbMode); try { PsiReference psiReference = configure(); Assert.assertTrue(psiReference.getElement() instanceof BashCommand); BashCommand commandElement = (BashCommand) psiReference.getElement(); Assert.assertTrue(psiReference.resolve() instanceof BashFunctionDef); Assert.assertTrue(commandElement.isFunctionCall()); Assert.assertFalse(commandElement.isVarDefCommand()); Assert.assertFalse(commandElement.isExternalCommand()); Assert.assertTrue(commandElement.getReference().isReferenceTo(psiReference.resolve())); return psiReference.resolve(); } finally { DumbServiceImpl.getInstance(myProject).setDumb(oldDumb); } }