Add support for direct Twig extension symbol usage detection in "Find Usages" and improve handler delegations

Author: Haehnchen

src/main/java/fr/adrienbrault/idea/symfony2plugin/templating/util/TwigExtensionParser.java

@@ -433,6 +433,14 @@ private static void visitNewExpression(@NotNull NewExpression element, @NotNull
                             signature = getCallableSignature(psiElement[1], method);
                         }
 
+                        if (signature == null && psiElement.length > 2 && psiElement[2] instanceof ArrayCreationExpression arrayCreationExpression) {
+                            PhpPsiElement nodeClassValue = PhpElementsUtil.getArrayValue(arrayCreationExpression, "node_class");
+                            String nodeClass = nodeClassValue != null ? PhpElementsUtil.getStringValue(nodeClassValue) : null;
+                            if (StringUtils.isNotBlank(nodeClass)) {
+                                signature = String.format("#M#C\\%s.%s", StringUtils.stripStart(nodeClass, "\\"), "compile");
+                            }
+                        }
+
                         // creation options like: needs_environment
                         Map<String, String> options;
                         if (psiElement.length > 2 && psiElement[2] instanceof ArrayCreationExpression) {
@@ -555,6 +563,14 @@ private static void visitNewExpression(@NotNull NewExpression element, @NotNull
                             signature = getCallableSignature(psiElement[1], method);
                         }
 
+                        if (signature == null && psiElement.length > 2 && psiElement[2] instanceof ArrayCreationExpression arrayCreationExpression) {
+                            PhpPsiElement nodeClassValue = PhpElementsUtil.getArrayValue(arrayCreationExpression, "node_class");
+                            String nodeClass = nodeClassValue != null ? PhpElementsUtil.getStringValue(nodeClassValue) : null;
+                            if (StringUtils.isNotBlank(nodeClass)) {
+                                signature = String.format("#M#C\\%s.%s", StringUtils.stripStart(nodeClass, "\\"), "compile");
+                            }
+                        }
+
                         if (signature == null && psiElement.length > 2 && psiElement[2] instanceof ArrayCreationExpression arrayCreationExpression) {
                             PhpPsiElement phpPsiElement = PhpElementsUtil.getArrayValue(arrayCreationExpression, "parser_callable");
                             if (phpPsiElement != null) {

src/main/kotlin/fr/adrienbrault/idea/symfony2plugin/templating/usages/TwigExtensionUsageUtil.kt

@@ -11,25 +11,10 @@ import fr.adrienbrault.idea.symfony2plugin.templating.util.TwigExtensionParser
  */
 object TwigExtensionUsageUtil {
     /**
-     * Resolves a Twig function usage leaf like `importmap` in `{{ importmap() }}` to PHP method targets.
+     * Resolves the current Twig caret leaf to one logical Twig extension symbol.
      */
-    fun getFunctionTargets(element: PsiElement): List<Method> {
-        if (!TwigPattern.getPrintBlockFunctionPattern().accepts(element)) {
-            return emptyList()
-        }
-
-        return getMethodTargetsForName(element, TwigExtensionParser.getFunctions(element.project))
-    }
-
-    /**
-     * Resolves a Twig filter usage leaf like `foo` in `{{ value|foo }}` or `{% apply foo %}` to PHP method targets.
-     */
-    fun getFilterTargets(element: PsiElement): List<Method> {
-        if (!TwigPattern.getFilterPattern().accepts(element) && !TwigPattern.getApplyFilterPattern().accepts(element)) {
-            return emptyList()
-        }
-
-        return getMethodTargetsForName(element, TwigExtensionParser.getFilters(element.project))
+    fun getTwigExtensionSymbol(element: PsiElement): TwigExtensionUsageSymbol? {
+        return getFunctionSymbol(element) ?: getFilterSymbol(element)
     }
 
     /**
@@ -54,28 +39,27 @@ object TwigExtensionUsageUtil {
     }
 
     /**
-     * Resolves one concrete Twig extension name to all matching PHP methods. Multiple matches are preserved.
+     * Resolves a Twig function usage leaf to its canonical function symbol name.
      */
-    private fun getMethodTargetsForName(
-        element: PsiElement,
-        extensions: Map<String, TwigExtension>,
-    ): List<Method> {
-        val methods = linkedSetOf<Method>()
-        val twigName = element.text
-        if (twigName.isBlank()) {
-            return emptyList()
+    fun getFunctionSymbol(element: PsiElement): TwigExtensionUsageSymbol? {
+        if (!TwigPattern.getPrintBlockFunctionPattern().accepts(element)) {
+            return null
         }
 
-        for ((extensionName, twigExtension) in extensions) {
-            if (!extensionName.equals(twigName, ignoreCase = true)) {
-                continue
-            }
+        val name = getRegisteredExtensionName(element.text, TwigExtensionParser.getFunctions(element.project)) ?: return null
+        return TwigExtensionUsageSymbol(TwigExtensionUsageKind.FUNCTION, name)
+    }
 
-            val target = TwigExtensionParser.getExtensionTarget(element.project, twigExtension) as? Method ?: continue
-            methods.add(target)
+    /**
+     * Resolves a Twig filter usage leaf to its canonical filter symbol name.
+     */
+    fun getFilterSymbol(element: PsiElement): TwigExtensionUsageSymbol? {
+        if (!TwigPattern.getFilterPattern().accepts(element) && !TwigPattern.getApplyFilterPattern().accepts(element)) {
+            return null
         }
 
-        return methods.toList()
+        val name = getRegisteredExtensionName(element.text, TwigExtensionParser.getFilters(element.project)) ?: return null
+        return TwigExtensionUsageSymbol(TwigExtensionUsageKind.FILTER, name)
     }
 
     /**
@@ -97,6 +81,20 @@ object TwigExtensionUsageUtil {
         return names
     }
 
+    /**
+     * Finds the canonical registered Twig extension name for one symbol leaf.
+     */
+    private fun getRegisteredExtensionName(
+        twigName: String,
+        extensions: Map<String, TwigExtension>,
+    ): String? {
+        if (twigName.isBlank()) {
+            return null
+        }
+
+        return extensions.keys.firstOrNull { it.equals(twigName, ignoreCase = true) }
+    }
+
     /**
      * Compares PHP methods by PSI identity first and then by method name plus containing class.
      */
@@ -115,3 +113,13 @@ object TwigExtensionUsageUtil {
         return candidateClass.isEquivalentTo(targetClass) || candidateClass.fqn == targetClass.fqn
     }
 }
+
+enum class TwigExtensionUsageKind {
+    FUNCTION,
+    FILTER,
+}
+
+data class TwigExtensionUsageSymbol(
+    val kind: TwigExtensionUsageKind,
+    val name: String,
+)

src/main/kotlin/fr/adrienbrault/idea/symfony2plugin/templating/usages/TwigFindUsagesHandler.kt

@@ -2,42 +2,51 @@ package fr.adrienbrault.idea.symfony2plugin.templating.usages
 
 import com.intellij.find.findUsages.FindUsagesHandler
 import com.intellij.find.findUsages.FindUsagesOptions
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiRecursiveElementWalkingVisitor
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.usageView.UsageInfo
 import com.intellij.util.Processor
+import com.jetbrains.twig.TwigFileType
+import fr.adrienbrault.idea.symfony2plugin.templating.TwigPattern
 
 /**
- * Delegates Twig-started Find Usages to the resolved PHP targets instead of searching the raw Twig PSI locally.
+ * Handles Find Usages started from Twig, either by delegating to resolved PHP targets or by
+ * searching exact Twig extension symbol names when the Twig symbol itself is the usage identity.
  *
  * @author Daniel Espendiller <daniel@espendiller.net>
  */
 class TwigFindUsagesHandler(
-    twigElement: PsiElement,
-    private val phpTargets: List<PsiElement>,
-) : FindUsagesHandler(twigElement) {
+    private val target: TwigFindUsagesTarget,
+) : FindUsagesHandler(target.primaryElement) {
     /**
-     * Exposes the resolved PHP targets as the primary search targets for the Usage View.
+     * Exposes the effective primary search targets for the Usage View.
      */
-    override fun getPrimaryElements(): Array<PsiElement> = phpTargets.toTypedArray()
+    override fun getPrimaryElements(): Array<PsiElement> = target.primaryElements.toTypedArray()
 
     /**
-     * Delegates the actual search work to the PHP targets so existing PHP and Twig reference search logic is reused.
+     * Delegates member/class usages to PHP targets and searches Twig extension symbols directly by name.
      */
     override fun processElementUsages(
         element: PsiElement,
         processor: Processor<in UsageInfo>,
         options: FindUsagesOptions,
     ): Boolean {
-        val targets = getEffectiveTargets(element)
+        return when (target) {
+            is TwigPhpFindUsagesTarget -> {
+                val targets = getEffectivePhpTargets(element, target.phpTargets)
 
-        for (target in targets) {
-            if (!super.processElementUsages(target, processor, options)) {
-                return false
+                for (phpTarget in targets) {
+                    if (!super.processElementUsages(phpTarget, processor, options)) {
+                        return false
+                    }
+                }
+
+                true
             }
+            is TwigExtensionSymbolFindUsagesTarget -> processTwigExtensionUsages(target.symbol, processor, options)
         }
-
-        return true
     }
 
     /**
@@ -48,21 +57,107 @@ class TwigFindUsagesHandler(
         processor: Processor<in UsageInfo>,
         searchScope: GlobalSearchScope,
     ): Boolean {
-        val targets = getEffectiveTargets(element)
+        return when (target) {
+            is TwigPhpFindUsagesTarget -> {
+                val targets = getEffectivePhpTargets(element, target.phpTargets)
+
+                for (phpTarget in targets) {
+                    if (!super.processUsagesInText(phpTarget, processor, searchScope)) {
+                        return false
+                    }
+                }
 
-        for (target in targets) {
-            if (!super.processUsagesInText(target, processor, searchScope)) {
-                return false
+                true
             }
+            is TwigExtensionSymbolFindUsagesTarget -> true
         }
-
-        return true
     }
 
     /**
      * Supports both direct calls with the original Twig PSI and platform calls with one of the primary PHP targets.
      */
-    private fun getEffectiveTargets(element: PsiElement): List<PsiElement> {
+    private fun getEffectivePhpTargets(element: PsiElement, phpTargets: List<PsiElement>): List<PsiElement> {
         return phpTargets.firstOrNull { it.isEquivalentTo(element) }?.let { listOf(it) } ?: phpTargets
     }
+
+    /**
+     * Searches Twig templates directly for the exact extension symbol name under Find Usages.
+     */
+    private fun processTwigExtensionUsages(
+        symbol: TwigExtensionUsageSymbol,
+        processor: Processor<in UsageInfo>,
+        options: FindUsagesOptions,
+    ): Boolean {
+        return ApplicationManager.getApplication().runReadAction<Boolean> {
+            val project = target.primaryElement.project
+            val searchScope = options.searchScope as? GlobalSearchScope ?: GlobalSearchScope.projectScope(project)
+            val twigScope = GlobalSearchScope.getScopeRestrictedByFileTypes(searchScope, TwigFileType.INSTANCE)
+
+            for (twigFile in TwigMethodReferencesSearchExecutor().collectTwigFiles(project, twigScope, setOf(symbol.name))) {
+                twigFile.accept(object : PsiRecursiveElementWalkingVisitor() {
+                    override fun visitElement(element: PsiElement) {
+                        if (matchesTwigExtensionSymbol(element, symbol)) {
+                            processor.process(UsageInfo(element))
+                        }
+
+                        super.visitElement(element)
+                    }
+                })
+            }
+
+            true
+        }
+    }
+}
+
+/**
+ * Describes the effective identity of a Twig Find Usages session.
+ */
+sealed interface TwigFindUsagesTarget {
+    /**
+     * Anchor PSI element used to create the handler and open the Usage View.
+     */
+    val primaryElement: PsiElement
+
+    /**
+     * Effective search targets exposed to the Usage View, either PHP delegates or the Twig symbol itself.
+     */
+    val primaryElements: List<PsiElement>
+}
+
+/**
+ * Twig usage target that delegates the search to one or more resolved PHP elements.
+ */
+data class TwigPhpFindUsagesTarget(
+    override val primaryElement: PsiElement,
+    val phpTargets: List<PsiElement>,
+) : TwigFindUsagesTarget {
+    override val primaryElements: List<PsiElement> = phpTargets
+}
+
+/**
+ * Twig extension usage target that keeps the Twig symbol itself as the usage identity, for example `form_start` or `trans`.
+ */
+data class TwigExtensionSymbolFindUsagesTarget(
+    override val primaryElement: PsiElement,
+    val symbol: TwigExtensionUsageSymbol,
+) : TwigFindUsagesTarget {
+    override val primaryElements: List<PsiElement> = listOf(primaryElement)
+}
+
+/**
+ * Matches only the exact Twig extension symbol leaf, such as `form_start` in `{{ form_start() }}` or `trans` in `{% apply trans %}`.
+ */
+private fun matchesTwigExtensionSymbol(
+    element: PsiElement,
+    symbol: TwigExtensionUsageSymbol,
+): Boolean {
+    if (!element.text.equals(symbol.name, ignoreCase = true)) {
+        return false
+    }
+
+    return when (symbol.kind) {
+        TwigExtensionUsageKind.FUNCTION -> TwigPattern.getPrintBlockFunctionPattern().accepts(element)
+        TwigExtensionUsageKind.FILTER -> TwigPattern.getFilterPattern().accepts(element) || TwigPattern.getApplyFilterPattern().accepts(element)
+    }
 }

src/main/kotlin/fr/adrienbrault/idea/symfony2plugin/templating/usages/TwigFindUsagesHandlerFactory.kt

@@ -28,10 +28,12 @@ import com.jetbrains.twig.TwigFileType
  */
 class TwigFindUsagesHandlerFactory : FindUsagesHandlerFactory(), UsageTargetProvider {
     /**
-     * Allows Find Usages to start directly on Twig usage PSI by first exposing the resolved PHP targets.
+     * Allows Find Usages to start directly on Twig usage PSI by exposing either Twig symbol targets
+     * or delegated PHP targets depending on the resolved usage identity.
      */
     override fun getTargets(element: PsiElement): Array<UsageTarget> {
-        val usageTargets: Array<UsageTarget> = getTwigFindUsagesPhpTargets(element)
+        val target = getTwigFindUsagesTarget(element) ?: return UsageTarget.EMPTY_ARRAY
+        val usageTargets: Array<UsageTarget> = target.primaryElements
             .map { PsiElement2UsageTargetAdapter(it, true) }
             .toTypedArray()
 
@@ -47,33 +49,35 @@ class TwigFindUsagesHandlerFactory : FindUsagesHandlerFactory(), UsageTargetProv
     }
 
     /**
-     * Activates the custom handler only when the Twig caret resolves to PHP class/member targets.
+     * Activates the custom handler only when the Twig caret resolves to a supported Twig/PHP usage identity.
      */
-    override fun canFindUsages(element: PsiElement): Boolean = getTwigFindUsagesPhpTargets(element).isNotEmpty()
+    override fun canFindUsages(element: PsiElement): Boolean = getTwigFindUsagesTarget(element) != null
 
     /**
-     * Stores the PHP delegation targets that should be searched instead of the raw Twig PSI.
+     * Stores the effective Twig or PHP search targets for the Find Usages session.
      */
     override fun createFindUsagesHandler(element: PsiElement, forHighlightUsages: Boolean): FindUsagesHandler? {
-        val targets = getTwigFindUsagesPhpTargets(element)
-
-        return targets.takeIf { it.isNotEmpty() }?.let { TwigFindUsagesHandler(element, it) }
+        return getTwigFindUsagesTarget(element)?.let { TwigFindUsagesHandler(it) }
     }
 }
 
 /**
- * Reuses Twig goto resolution and keeps only PHP Find Usages targets.
- * Twig member lookups can arrive on a composite field reference, so nearby leaf candidates are probed as well.
+ * Resolves the Find Usages identity for one Twig caret position.
+ * Extension symbols stay Twig-symbol based, while all other cases keep delegating to PHP.
  */
-private fun getTwigFindUsagesPhpTargets(element: PsiElement): List<PsiElement> {
+private fun getTwigFindUsagesTarget(element: PsiElement): TwigFindUsagesTarget? {
     if (element.containingFile?.fileType != TwigFileType.INSTANCE) {
-        return emptyList()
+        return null
     }
 
     val resolvedCandidates = mutableListOf<Pair<PsiElement, List<PsiElement>>>()
     val candidateElements = getTwigFindUsagesCaretElement(element)?.let(::listOf) ?: listOf(element)
 
     for (candidate in candidateElements) {
+        TwigExtensionUsageUtil.getTwigExtensionSymbol(candidate)?.let { symbol ->
+            return TwigExtensionSymbolFindUsagesTarget(candidate, symbol)
+        }
+
         val resolvedTargets = TwigUsageTargetUtil.getTwigFindUsagesTargets(candidate)
             .filter { it is PhpClass || it is Method || it is Field || it is PhpEnumCase }
 
@@ -82,15 +86,12 @@ private fun getTwigFindUsagesPhpTargets(element: PsiElement): List<PsiElement> {
         }
     }
 
-    val preferredTargets = resolvedCandidates
+    return resolvedCandidates
         .maxWithOrNull(compareBy<Pair<PsiElement, List<PsiElement>>>(
             { it.first.textOffset },
             { if (it.second.any { target -> target !is PhpClass }) 1 else 0 },
         ))
-        ?.second
-        ?: emptyList()
-
-    return preferredTargets
+        ?.let { TwigPhpFindUsagesTarget(it.first, it.second) }
 }
 
 /**