Merge pull request #3818 from sh41/split/pr3808-5-psi-resolver

PSI / Resolver / Code Insight Fixes

Author: joshuataylor

CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## v23.2.0
+
+### Enhancements
+* [#3818](https://github.com/KronicDeth/intellij-elixir/pull/3818) - [@sh41](https://github.com/sh41)
+  * Code completion deduplication: multi-clause functions (e.g. `Enum.map_every` with 5 clauses) now appear once in completion results instead of once per clause head. Shared `PreferFunctionHead` logic selects bare function heads over implementation clauses.
+  * Parameter info deduplication: parameter hints grouped by `(name, arity)` -- separate arities still show distinct hints, but multiple clauses of the same arity no longer produce duplicate entries.
+  * Completion prefers source-defined modulars over BEAM stubs when both are available, eliminating duplicate completion entries.
+  * Transitive alias resolution: when stub-index lookup finds nothing for a module name that is itself a `QualifiableAlias`, resolution now follows alias chains transitively. Possibly addresses [#1806](https://github.com/KronicDeth/intellij-elixir/issues/1806).
+  * `DefinitionsScopedSearch` cancellation: added `ProgressManager.checkCanceled()` at loop boundaries and honour `Processor.process()` return value for early-exit, preventing hangs during large-project searches.
+
+### Bug Fixes
+* [#3818](https://github.com/KronicDeth/intellij-elixir/pull/3818) - [@sh41](https://github.com/sh41)
+  * **Breaking change**: removed `nameArityInAnyModule` global fallback from resolver. Previously, when `resolveInScope` found no results, the resolver fell back to a global stub-index search returning every function with a matching name from every module (all marked `validResult=false`). This polluted parameter hints with unrelated modules (e.g. hovering `Enum.map()` showed hints from `Stream.Reducers`, `Ecto`, `Phoenix`), caused Go-to-Definition to navigate to wrong-module definitions, and filled the resolution cache with irrelevant results. Calls that were previously "resolved" to functions in unrelated modules will now correctly appear as unresolved references.
+  * Infinite loop in `UnaliasedName.up` when resolving `QualifiedMultipleAliases` -- function overload ordering caused mutual recursion.
+  * Infinite recursion and NPE prevention in PSI resolve/tree-walk paths via `RecursionManager.doPreventingRecursion()` and null-safe `VISITED_ELEMENT_SET` access in `ResolveState`.
+  * `@spec` line marker grouping checked arity equality before name equality -- specs for different functions with the same arity were incorrectly grouped together.
+  * Gutter icons anchored to leaf `PsiElement`s per the `LineMarkerProvider` contract. Non-leaf elements caused markers to blink or appear in wrong positions after edits.
+  * Removed redundant `computeReadAction`/`runReadAction` wrappers from `CallImpl` getters (`functionName`, `moduleName`, `resolvedPrimaryArity`) and `PsiNamedElementImpl` name getters. These trivial PSI reads were called from paths already holding a read lock; under 2025.3+ writer-preference locking, re-acquiring blocks the EDT when a write action is pending. Partially fixes [#3790](https://github.com/KronicDeth/intellij-elixir/issues/3790).
+  * `Elixir.` prefix stripping for module name resolution -- stub index stores names without the prefix, so `Elixir.Enum` lookups now match correctly.
+
 ## v23.1.0
 
 ### Enhancements

gen/org/elixir_lang/psi/scope/module/MultiResolve.kt

@@ -8,6 +8,7 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.elixir_lang.Module.concat
 import org.elixir_lang.Module.split
 import org.elixir_lang.psi.NamedElement
+import org.elixir_lang.psi.QualifiableAlias
 import org.elixir_lang.psi.call.Named
 import org.elixir_lang.psi.impl.ElixirPsiImplUtil.ENTRANCE
 import org.elixir_lang.psi.impl.call.finalArguments
@@ -67,7 +68,7 @@ class MultiResolve internal constructor(private val name: String, private val in
                                 )
                             }
                         }
-            } else if (requireCall != null) {
+            } else {
                 resolveResultOrderedSet.add(match, requireCall.text, true, state.visitedElementSet())
             }
         } else {
@@ -106,6 +107,8 @@ class MultiResolve internal constructor(private val name: String, private val in
         val project = match.project
 
         if (!DumbService.isDumb(project)) {
+            var found = false
+
             StubIndex
                     .getInstance()
                     .processElements(
@@ -115,9 +118,29 @@ class MultiResolve internal constructor(private val name: String, private val in
                             GlobalSearchScope.allScope(project),
                             NamedElement::class.java) {
                 resolveResultOrderedSet.add(it, unaliasedName, true, visitedElementSet)
+                found = true
 
                 true
             }
+
+            // Transitive alias fallback: if stub lookup found nothing and match is a QualifiableAlias,
+            // resolve it through the module scope to follow alias chains
+            // (e.g., `alias MyNamespace.Referenced; alias Referenced, as: Refd` — resolving `Refd` needs
+            // to follow Referenced → MyNamespace.Referenced transitively)
+            if (!found && match is QualifiableAlias) {
+                val transitiveResults = resolveResults(match.fullyQualifiedName(), incompleteCode, match)
+                for (result in transitiveResults) {
+                    val resolvedElement = result.element
+                    if (resolvedElement is NamedElement) {
+                        resolveResultOrderedSet.add(
+                            resolvedElement,
+                            resolvedElement.name ?: unaliasedName,
+                            result.isValidResult,
+                            visitedElementSet + result.visitedElementSet
+                        )
+                    }
+                }
+            }
         }
     }
 

gradle.properties

@@ -6,7 +6,7 @@
 # --- Plugin Metadata ---
 pluginGroup=org.elixir_lang
 pluginName=Elixir
-pluginVersion=23.1.0
+pluginVersion=23.2.0
 pluginRepositoryUrl=https://github.com/KronicDeth/intellij-elixir/
 vendorName=Elle Imhoff
 vendorEmail=Kronic.Deth@gmail.com

resources/META-INF/changelog.html

@@ -1,6 +1,30 @@
 <html>
 <body>
 
+<h1>v23.2.0</h1>
+<ul>
+    <li>
+        <p>Enhancements</p>
+        <ul>
+            <li>Code completion no longer shows duplicate entries for functions with multiple clauses or guards (e.g. <code>Enum.map_every</code> previously appeared 5 times).</li>
+            <li>Parameter hints deduplicated -- hovering a function call shows one set of hints per arity, not one per clause.</li>
+            <li>Module alias resolution now follows alias chains transitively, improving Go-to-Declaration and completion for aliased modules.</li>
+            <li>Large-project searches (Find Usages, Go-to-Definition) can now be cancelled mid-search and exit early when results are found, preventing UI hangs.</li>
+        </ul>
+    </li>
+    <li>
+        <p>Bug Fixes</p>
+        <ul>
+            <li><b>Breaking change</b>: parameter hints and Go-to-Definition no longer show results from unrelated modules. Previously, unresolvable calls fell back to a global search returning every function with the same name across the entire project. Calls that cannot be resolved now correctly show no results instead of misleading ones.</li>
+            <li>Fixed infinite loop when resolving multi-aliases (e.g. <code>alias Foo.{Bar, Baz}</code>).</li>
+            <li>Fixed infinite recursion and potential crashes in reference resolution.</li>
+            <li>Fixed <code>@spec</code> gutter icons grouping specs for different functions together when they shared the same arity.</li>
+            <li>Fixed gutter icons (line markers) blinking or appearing in wrong positions after editing code.</li>
+            <li>Reduced UI freezes caused by redundant read-lock acquisition in frequently called PSI accessors under IntelliJ 2025.3+ writer-preference locking.</li>
+        </ul>
+    </li>
+</ul>
+
 <h1>v23.1.0</h1>
 <ul>
     <li>

src/org/elixir_lang/DefinitionsScopedSearch.kt

@@ -1,7 +1,7 @@
 package org.elixir_lang
 
-import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.QueryExecutorBase
+import com.intellij.openapi.progress.ProgressManager
 import com.intellij.psi.PsiElement
 import com.intellij.psi.ResolveState
 import com.intellij.psi.search.searches.DefinitionsScopedSearch
@@ -23,23 +23,21 @@ class DefinitionsScopedSearch :
         queryParameters: DefinitionsScopedSearch.SearchParameters,
         consumer: Processor<in PsiElement>
     ) {
-        ApplicationManager.getApplication().assertReadAccessAllowed()
         when (val element = queryParameters.element) {
             is Call -> processQuery(element, consumer)
             is QualifiableAlias -> processQuery(element, consumer)
         }
     }
 
     private fun processQuery(qualifiableAlias: QualifiableAlias, consumer: Processor<in PsiElement>) {
-        ApplicationManager.getApplication().assertReadAccessAllowed()
+        ProgressManager.checkCanceled()
         qualifiableAlias.outerMostQualifiableAlias().maybeModularNameToModulars(qualifiableAlias.containingFile)
             .map { modular ->
                 processQuery(modular, consumer)
             }
     }
 
     private fun processQuery(psiElement: PsiElement, consumer: Processor<in PsiElement>) {
-        ApplicationManager.getApplication().assertReadAccessAllowed()
         when (psiElement) {
             is Call -> processQuery(psiElement, consumer)
             is ModuleImpl<*> -> processQuery(psiElement, consumer)
@@ -48,28 +46,63 @@ class DefinitionsScopedSearch :
     }
 
     private fun processQuery(call: Call, consumer: Processor<in PsiElement>) {
-        ApplicationManager.getApplication().assertReadAccessAllowed()
         if (Protocol.`is`(call)) {
             Protocol.processImplementations(call, consumer)
         } else if (CallDefinitionClause.`is`(call)) {
             enclosingModularMacroCall(call)?.let { modularCall ->
                 CallDefinitionClause.nameArityInterval(call, ResolveState.initial())?.let { protocolNameArityInterval ->
                     if (Protocol.`is`(modularCall)) {
                         Protocol.processImplementations(modularCall) { defimpl ->
-                            for (defimplChild in (defimpl as Call).macroChildCallList()) {
-                                if (CallDefinitionClause.`is`(defimplChild)) {
-                                    CallDefinitionClause.nameArityInterval(defimplChild, ResolveState.initial())
-                                        ?.let { implNameArityInterval ->
-                                            if (implNameArityInterval.name == protocolNameArityInterval.name &&
-                                                implNameArityInterval.arityInterval.overlaps(protocolNameArityInterval.arityInterval)
-                                            ) {
-                                                consumer.process(defimplChild)
+                            ProgressManager.checkCanceled()
+
+                            var continueProcessing = true
+
+                            when (defimpl) {
+                                is Call -> {
+                                    for (defimplChild in defimpl.macroChildCallList()) {
+                                        ProgressManager.checkCanceled()
+
+                                        if (CallDefinitionClause.`is`(defimplChild)) {
+                                            CallDefinitionClause.nameArityInterval(defimplChild, ResolveState.initial())
+                                                ?.let { implNameArityInterval ->
+                                                    if (implNameArityInterval.name == protocolNameArityInterval.name &&
+                                                        implNameArityInterval.arityInterval.overlaps(protocolNameArityInterval.arityInterval)
+                                                    ) {
+                                                        if (!consumer.process(defimplChild)) {
+                                                            continueProcessing = false
+                                                        }
+                                                    }
+                                                }
+                                        }
+
+                                        if (!continueProcessing) {
+                                            break
+                                        }
+                                    }
+                                }
+
+                                is ModuleImpl<*> -> {
+                                    for (callDefinition in defimpl.callDefinitions()) {
+                                        ProgressManager.checkCanceled()
+
+                                        val implNameArityInterval = callDefinition.nameArityInterval
+
+                                        if (implNameArityInterval.name == protocolNameArityInterval.name &&
+                                            implNameArityInterval.arityInterval.overlaps(protocolNameArityInterval.arityInterval)
+                                        ) {
+                                            if (!consumer.process(callDefinition)) {
+                                                continueProcessing = false
                                             }
                                         }
+
+                                        if (!continueProcessing) {
+                                            break
+                                        }
+                                    }
                                 }
                             }
 
-                            true
+                            continueProcessing
                         }
                     }
                 }
@@ -78,49 +111,67 @@ class DefinitionsScopedSearch :
     }
 
     private fun processQuery(moduleImpl: ModuleImpl<*>, consumer: Processor<in PsiElement>) {
-        ApplicationManager.getApplication().assertReadAccessAllowed()
         if (Protocol.`is`(moduleImpl)) {
             Protocol.processImplementations(moduleImpl, consumer)
         }
     }
 
     private fun processQuery(callDefinitionImpl: CallDefinitionImpl<*>, consumer: Processor<in PsiElement>) {
-        ApplicationManager.getApplication().assertReadAccessAllowed()
         val moduleImpl = callDefinitionImpl.parent
 
         if (Protocol.`is`(moduleImpl)) {
             val name = callDefinitionImpl.name
             val arity = callDefinitionImpl.exportedArity(ResolveState.initial())
 
             Protocol.processImplementations(moduleImpl) { defimpl ->
+                ProgressManager.checkCanceled()
+
+                var continueProcessing = true
+
                 when (defimpl) {
                     is Call -> {
                         for (defimplChild in defimpl.macroChildCallList()) {
+                            ProgressManager.checkCanceled()
+
                             if (CallDefinitionClause.`is`(defimplChild)) {
                                 CallDefinitionClause.nameArityInterval(defimplChild, ResolveState.initial())
                                     ?.let { implNameArityInterval ->
                                         if (implNameArityInterval.name == name &&
                                             implNameArityInterval.arityInterval.contains(arity)
                                         ) {
-                                            consumer.process(defimplChild)
+                                            if (!consumer.process(defimplChild)) {
+                                                continueProcessing = false
+                                            }
                                         }
                                     }
                             }
+
+                            if (!continueProcessing) {
+                                break
+                            }
                         }
                     }
                     is ModuleImpl<*> ->
                         for (callDefinition in defimpl.callDefinitions()) {
+                            ProgressManager.checkCanceled()
+
                             val implNameArityInterval = callDefinition.nameArityInterval
 
                             if (implNameArityInterval.name == name &&
                                 implNameArityInterval.arityInterval.contains(arity)
                             ) {
-                                consumer.process(callDefinition)
+                                if (!consumer.process(callDefinition)) {
+                                    continueProcessing = false
+                                }
+                            }
+
+                            if (!continueProcessing) {
+                                break
                             }
                         }
                 }
 
-                true
+                continueProcessing
             }
         }
     }

src/org/elixir_lang/beam/psi/Modular.java

@@ -20,7 +20,7 @@ class ParameterInfo : ParameterInfoHandler<Arguments, Any> {
 
     override fun showParameterInfo(element: Arguments, context: CreateParameterInfoContext) {
         PsiTreeUtil.getParentOfType(element, Call::class.java)?.let { call ->
-            val itemToShowList = call.references.flatMap { reference ->
+            val allClauses = call.references.flatMap { reference ->
                 if (reference is PsiPolyVariantReference) {
                     reference.multiResolve(true).flatMap { resolveResult ->
                         resolveResult.element?.let {
@@ -38,10 +38,15 @@ class ParameterInfo : ParameterInfoHandler<Arguments, Any> {
                         } else {
                             null
                         }
-                    } ?: emptyList<Any>()
+                    } ?: emptyList()
                 }
             }
 
+            // Deduplicate by (name, arity), preferring bare function heads (no do block)
+            // over implementation clauses.  Uses arity-aware grouping so that
+            // genuinely different arities (e.g. foo/1 vs foo/2) each get their own hint.
+            val itemToShowList = preferFunctionHeadsByArity(allClauses)
+
             if (itemToShowList.isNotEmpty()) {
                 context.itemsToShow = itemToShowList.toTypedArray()
                 context.showHint(element, element.textRange.startOffset, this)
@@ -115,9 +120,6 @@ class ParameterInfo : ParameterInfoHandler<Arguments, Any> {
         }
     }
 
-    private fun findArguments(context: ParameterInfoContext): Arguments? {
-        val elementAtOffset = context.file.findElementAt(context.offset)
-
-        return PsiTreeUtil.getParentOfType<Arguments>(elementAtOffset, Arguments::class.java)
-    }
+    private fun findArguments(context: ParameterInfoContext): Arguments? =
+        ParameterInfoUtils.findParentOfType(context.file, context.offset, Arguments::class.java)
 }