Only search within the same module when looking up symbols

waleedyaseen · Aug 29, 2024 · 9d94f06 · 9d94f06
1 parent 6866405
commit 9d94f06
Show file tree

Hide file tree

Showing 17 changed files with 53 additions and 28 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -21,6 +21,7 @@
 - Allow for clientscript/command to be looked up in "Search Everywhere".
 - Fixed namedobj vs obj when type checking multiple args.
 - Allow '<' to be escaped in string literals.
+- Only search within the same module when looking up symbols.
 
 ## [1.5.1] - 2024-04-15
 

diff --git a/src/main/kotlin/io/runescript/plugin/ide/doc/RsDocReference.kt b/src/main/kotlin/io/runescript/plugin/ide/doc/RsDocReference.kt
@@ -1,5 +1,8 @@
 package io.runescript.plugin.ide.doc
 
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.module.ModuleUtil
+import com.intellij.openapi.module.ModuleUtilCore
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
@@ -22,7 +25,8 @@ class RsDocReference(element: RsDocName) : PsiPolyVariantReferenceBase<RsDocName
     override fun multiResolve(incompleteCode: Boolean): Array<ResolveResult> {
         val typeName = (element.firstChild as? RsDocName)?.text
         val elementName = element.lastChild.text
-        return resolve(element.project, element.getContainingDoc().owner, typeName, elementName)
+        val module = ModuleUtil.findModuleForPsiElement(element) ?: return emptyArray()
+        return resolve(element.project, module, element.getContainingDoc().owner, typeName, elementName)
             .map { PsiElementResolveResult(it) }
             .toTypedArray()
     }
@@ -40,7 +44,7 @@ class RsDocReference(element: RsDocName) : PsiPolyVariantReferenceBase<RsDocName
     }
 
     companion object {
-        fun resolve(project: Project, owner: RsScript?, typeName: String?, elementName: String): Array<PsiElement> {
+        fun resolve(project: Project, module: Module, owner: RsScript?, typeName: String?, elementName: String): Array<PsiElement> {
             if (typeName == null) {
                 return owner
                     ?.parameterList
@@ -61,7 +65,7 @@ class RsDocReference(element: RsDocName) : PsiPolyVariantReferenceBase<RsDocName
                     scriptIndexKey,
                     elementName,
                     project,
-                    GlobalSearchScope.allScope(project),
+                    GlobalSearchScope.moduleScope(module),
                     RsScript::class.java
                 )
                 return scripts.toTypedArray()
@@ -70,7 +74,7 @@ class RsDocReference(element: RsDocName) : PsiPolyVariantReferenceBase<RsDocName
                 RsSymbolIndex.KEY,
                 elementName,
                 project,
-                GlobalSearchScope.allScope(project),
+                GlobalSearchScope.moduleScope(module),
                 RsSymSymbol::class.java
             )
             return configs

diff --git a/src/main/kotlin/io/runescript/plugin/ide/doc/RsDocumentationProvider.kt b/src/main/kotlin/io/runescript/plugin/ide/doc/RsDocumentationProvider.kt
@@ -7,6 +7,7 @@ import com.intellij.lang.documentation.DocumentationMarkup.DEFINITION_START
 import com.intellij.lang.documentation.DocumentationSettings
 import com.intellij.openapi.editor.colors.TextAttributesKey
 import com.intellij.openapi.editor.richcopy.HtmlSyntaxInfoUtil
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.psi.*
 import com.intellij.psi.util.childrenOfType
 import com.intellij.psi.util.parentOfType
@@ -150,13 +151,14 @@ class RsDocumentationProvider : AbstractDocumentationProvider() {
         }
         val typeName = parts[0]
         val elementName = parts[1]
+        val module = ModuleUtil.findModuleForPsiElement(context) ?: return null
         if (typeName == "parameter") {
             // TODO(Walied): Find a better way to do this
             val doc = context.containingFile.findElementAt(parts[2].toInt())?.parentOfType<RsDoc>() ?: return null
             val owner = doc.owner
-            return RsDocReference.resolve(context.project, owner, null, elementName).singleOrNull()
+            return RsDocReference.resolve(context.project, module, owner, null, elementName).singleOrNull()
         } else {
-            return RsDocReference.resolve(context.project, null, typeName, elementName).singleOrNull()
+            return RsDocReference.resolve(context.project, module, null, typeName, elementName).singleOrNull()
         }
     }
 }

diff --git a/...in/kotlin/io/runescript/plugin/ide/inspections/RuneScriptMissingScriptSymbolInspection.kt b/...in/kotlin/io/runescript/plugin/ide/inspections/RuneScriptMissingScriptSymbolInspection.kt
@@ -22,7 +22,7 @@ class RuneScriptMissingScriptSymbolInspection : LocalInspectionTool() {
                 val name = o.qualifiedName
                 val length = o.rbracket.endOffset - o.lbracket.startOffset
                 val range = TextRange.from(o.lbracket.startOffsetInParent, length)
-                if (RsSymbolIndex.lookup(o.project, RsPrimitiveType.CLIENTSCRIPT, name) == null) {
+                if (RsSymbolIndex.lookup(o, RsPrimitiveType.CLIENTSCRIPT, name) == null) {
                     holder.registerProblem(
                         o,
                         RsBundle.message("inspection.error.script.symbol.not.found", name),

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/mixin/RsScopedVariableExpressionMixin.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/mixin/RsScopedVariableExpressionMixin.kt
@@ -2,6 +2,7 @@ package io.runescript.plugin.lang.psi.mixin
 
 import com.intellij.extapi.psi.StubBasedPsiElementBase
 import com.intellij.lang.ASTNode
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiReference
 import com.intellij.psi.search.GlobalSearchScope
@@ -21,7 +22,8 @@ abstract class RsScopedVariableExpressionMixin : StubBasedPsiElementBase<RsScope
     constructor(stub: RsScopedVariableExpressionStub?, type: IElementType?, node: ASTNode?) : super(stub, type, node)
 
     override fun getUseScope(): SearchScope {
-        return GlobalSearchScope.projectScope(project)
+        val module = ModuleUtil.findModuleForPsiElement(this) ?: return super.getUseScope()
+        return GlobalSearchScope.moduleScope(module)
     }
 
     override fun getReference(): PsiReference? {

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/mixin/RsScriptMixin.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/mixin/RsScriptMixin.kt
@@ -4,6 +4,7 @@ import com.intellij.extapi.psi.StubBasedPsiElementBase
 import com.intellij.ide.projectView.PresentationData
 import com.intellij.lang.ASTNode
 import com.intellij.navigation.ItemPresentation
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.psi.PsiElement
 import com.intellij.psi.ResolveState
 import com.intellij.psi.scope.PsiScopeProcessor
@@ -55,7 +56,8 @@ abstract class RsScriptMixin : StubBasedPsiElementBase<RsScriptStub>, RsScript {
     }
 
     override fun getUseScope(): SearchScope {
-        return GlobalSearchScope.projectScope(project)
+        val module = ModuleUtil.findModuleForPsiElement(this) ?: return super.getUseScope()
+        return GlobalSearchScope.moduleScope(module)
     }
 
     override fun setName(name: String): PsiElement {

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsCommandExpressionReference.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsCommandExpressionReference.kt
@@ -1,6 +1,7 @@
 package io.runescript.plugin.lang.psi.refs
 
 import com.intellij.codeInsight.lookup.LookupElement
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementResolveResult
 import com.intellij.psi.PsiPolyVariantReferenceBase
@@ -14,7 +15,8 @@ import io.runescript.plugin.lang.stubs.index.RsCommandScriptIndex
 class RsCommandExpressionReference(element: RsCommandExpression) : PsiPolyVariantReferenceBase<RsCommandExpression>(element, element.nameLiteral.textRangeInParent) {
 
     override fun multiResolve(incompleteCode: Boolean): Array<ResolveResult> {
-        val elements = StubIndex.getElements(RsCommandScriptIndex.KEY, element.nameLiteral.text, element.project, GlobalSearchScope.allScope(element.project), RsScript::class.java)
+        val module = ModuleUtil.findModuleForPsiElement(element) ?: return emptyArray()
+        val elements = StubIndex.getElements(RsCommandScriptIndex.KEY, element.nameLiteral.text, element.project, GlobalSearchScope.moduleScope(module), RsScript::class.java)
         return elements.map { PsiElementResolveResult(it) }.toTypedArray()
     }
 

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsConstantReference.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsConstantReference.kt
@@ -14,7 +14,7 @@ class RsConstantReference(element: RsConstantExpression) :
     }
 
     override fun multiResolve(incompleteCode: Boolean): Array<ResolveResult> {
-        val symbol = RsSymbolIndex.lookup(element.project, RsPrimitiveType.CONSTANT, element.name!!)
+        val symbol = RsSymbolIndex.lookup(element, RsPrimitiveType.CONSTANT, element.name!!)
             ?: return emptyArray()
         return arrayOf(PsiElementResolveResult(symbol))
     }

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsDynamicExpressionReference.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsDynamicExpressionReference.kt
@@ -1,6 +1,7 @@
 package io.runescript.plugin.lang.psi.refs
 
 import com.intellij.codeInsight.lookup.LookupElement
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.psi.*
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StubIndex
@@ -13,6 +14,7 @@ import io.runescript.plugin.lang.psi.type.RsPrimitiveType
 import io.runescript.plugin.lang.psi.type.RsType
 import io.runescript.plugin.lang.psi.type.type
 import io.runescript.plugin.lang.stubs.index.RsCommandScriptIndex
+import io.runescript.plugin.lang.stubs.index.RsProcScriptIndex
 import io.runescript.plugin.symbollang.psi.index.RsSymbolIndex
 
 class RsDynamicExpressionReference(element: RsDynamicExpression) : PsiPolyVariantReferenceBase<RsDynamicExpression>(element, element.nameLiteral.textRangeInParent) {
@@ -42,14 +44,16 @@ class RsDynamicExpressionReference(element: RsDynamicExpression) : PsiPolyVarian
             // Try to resolve the element as a config reference.
             val project = element.project
             if (type is RsPrimitiveType) {
-                val resolvedConfig = RsSymbolIndex.lookup(project, type, elementName)
+                val resolvedConfig = RsSymbolIndex.lookup(element, type, elementName)
                 if (resolvedConfig != null) {
                     return arrayOf(PsiElementResolveResult(resolvedConfig))
                 }
             }
 
             // Try to resolve the element as a command reference.
-            val searchScope = GlobalSearchScope.allScope(project)
+            val module = ModuleUtil.findModuleForPsiElement(element) ?: return emptyArray()
+            val searchScope = GlobalSearchScope.moduleScope(module)
+
             return StubIndex.getElements(RsCommandScriptIndex.KEY, elementName, project, searchScope, RsScript::class.java)
                     .map { PsiElementResolveResult(it) }
                     .toTypedArray()

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsGosubReference.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsGosubReference.kt
@@ -1,6 +1,7 @@
 package io.runescript.plugin.lang.psi.refs
 
 import com.intellij.codeInsight.lookup.LookupElement
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementResolveResult
 import com.intellij.psi.PsiPolyVariantReferenceBase
@@ -9,12 +10,14 @@ import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StubIndex
 import io.runescript.plugin.lang.psi.RsGosubExpression
 import io.runescript.plugin.lang.psi.RsScript
+import io.runescript.plugin.lang.stubs.index.RsCommandScriptIndex
 import io.runescript.plugin.lang.stubs.index.RsProcScriptIndex
 
 class RsGosubReference(element: RsGosubExpression) : PsiPolyVariantReferenceBase<RsGosubExpression>(element, element.nameLiteral.textRangeInParent) {
 
     override fun multiResolve(incompleteCode: Boolean): Array<ResolveResult> {
-        val elements = StubIndex.getElements(RsProcScriptIndex.KEY, element.nameLiteral.text, element.project, GlobalSearchScope.allScope(element.project), RsScript::class.java)
+        val module = ModuleUtil.findModuleForPsiElement(element) ?: return emptyArray()
+        val elements = StubIndex.getElements(RsProcScriptIndex.KEY, element.nameLiteral.text, element.project, GlobalSearchScope.moduleScope(module), RsScript::class.java)
         return elements.map { PsiElementResolveResult(it) }.toTypedArray()
     }
 

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsHookFragmentReference.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsHookFragmentReference.kt
@@ -1,6 +1,7 @@
 package io.runescript.plugin.lang.psi.refs
 
 import com.intellij.codeInsight.lookup.LookupElement
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementResolveResult
 import com.intellij.psi.PsiPolyVariantReferenceBase
@@ -14,7 +15,8 @@ import io.runescript.plugin.lang.stubs.index.RsClientScriptIndex
 class RsHookFragmentReference(element: RsHookFragment) : PsiPolyVariantReferenceBase<RsHookFragment>(element, element.nameLiteral.textRangeInParent) {
 
     override fun multiResolve(incompleteCode: Boolean): Array<ResolveResult> {
-        val elements = StubIndex.getElements(RsClientScriptIndex.KEY, element.nameLiteral.text, element.project, GlobalSearchScope.allScope(element.project), RsScript::class.java)
+        val module = ModuleUtil.findModuleForPsiElement(element) ?: return emptyArray()
+        val elements = StubIndex.getElements(RsClientScriptIndex.KEY, element.nameLiteral.text, element.project, GlobalSearchScope.moduleScope(module), RsScript::class.java)
         return elements.map { PsiElementResolveResult(it) }.toTypedArray()
     }
 

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsScopedVariableReference.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsScopedVariableReference.kt
@@ -15,7 +15,7 @@ class RsScopedVariableReference(element: RsScopedVariableExpression) :
 
     override fun multiResolve(incompleteCode: Boolean): Array<ResolveResult> {
         return scopedVarTypes
-            .mapNotNull { RsSymbolIndex.lookup(element.project, it, element.name!!) }
+            .mapNotNull { RsSymbolIndex.lookup(element, it, element.name!!) }
             .map { PsiElementResolveResult(it) }
             .toTypedArray()
     }

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsStringLiteralReference.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/refs/RsStringLiteralReference.kt
@@ -32,9 +32,8 @@ class RsStringLiteralReference(element: RsStringLiteralExpression) :
             }
             val elementName = element.stringLiteralContent.text
 
-            val project = element.project
             if (type is RsPrimitiveType) {
-                val resolvedConfig = RsSymbolIndex.lookup(project, type, elementName)
+                val resolvedConfig = RsSymbolIndex.lookup(element, type, elementName)
                 if (resolvedConfig != null) {
                     return arrayOf(PsiElementResolveResult(resolvedConfig))
                 }

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/type/inference/CommandHandler.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/type/inference/CommandHandler.kt
@@ -45,7 +45,7 @@ class ParamCommandHandler(private val subjectType: RsPrimitiveType) : CommandHan
             arguments[1].accept(this)
             if (arguments[1] is RsDynamicExpression) {
                 val parameterSymbol =
-                    RsSymbolIndex.lookup(arguments[1].project, RsPrimitiveType.PARAM, arguments[1].text)
+                    RsSymbolIndex.lookup(arguments[1], RsPrimitiveType.PARAM, arguments[1].text)
                 if (parameterSymbol == null || parameterSymbol.fieldList.size < 3) {
                     arguments[1].error("Reference to a parameter with an invalid definition.")
                 } else {
@@ -80,7 +80,7 @@ class DbFindCommandHandler(private val withCount: Boolean) : CommandHandler {
         val arguments = o.argumentList.expressionList
         var keyType: RsType? = null
         if (arguments[0] is RsDynamicExpression) {
-            val dbTableSym = RsSymbolIndex.lookup(arguments[0].project, RsPrimitiveType.DBCOLUMN, arguments[0].text)
+            val dbTableSym = RsSymbolIndex.lookup(arguments[0], RsPrimitiveType.DBCOLUMN, arguments[0].text)
             if (dbTableSym == null || dbTableSym.fieldList.size < 3) {
                 arguments[0].error("Reference to a dbtable with an invalid definition.")
             } else {
@@ -127,7 +127,7 @@ data object DbGetFieldCommandHandler : CommandHandler {
         val arguments = o.argumentList.expressionList
         var outputType: RsType? = null
         if (arguments[1] is RsDynamicExpression) {
-            val dbTableSym = RsSymbolIndex.lookup(arguments[1].project, RsPrimitiveType.DBCOLUMN, arguments[1].text)
+            val dbTableSym = RsSymbolIndex.lookup(arguments[1], RsPrimitiveType.DBCOLUMN, arguments[1].text)
             if (dbTableSym == null || dbTableSym.fieldList.size < 3) {
                 arguments[1].error("Reference to a dbtable with an invalid definition.")
             } else {

diff --git a/src/main/kotlin/io/runescript/plugin/lang/psi/type/inference/RsTypeInferenceVisitor.kt b/src/main/kotlin/io/runescript/plugin/lang/psi/type/inference/RsTypeInferenceVisitor.kt
@@ -35,15 +35,14 @@ class RsTypeInferenceVisitor(private val myInferenceData: RsTypeInference) : RsV
         }
         val subjectExpression = o.scriptNameExpression
         if (triggerType.subjectType != null) {
-            val project = subjectExpression.project
             var subjectType = triggerType.subjectType
             var subjectName = subjectExpression.text
             if (subjectName != "_") {
                 if (subjectName[0] == '_') {
                     subjectName = subjectName.substring(1)
                     subjectType = RsPrimitiveType.CATEGORY
                 }
-                val reference = RsSymbolIndex.lookup(project, subjectType, subjectName)
+                val reference = RsSymbolIndex.lookup(subjectExpression, subjectType, subjectName)
                 if (reference == null) {
                     subjectExpression.error(
                         RsBundle.message(
@@ -620,7 +619,7 @@ class RsTypeInferenceVisitor(private val myInferenceData: RsTypeInference) : RsV
             }
 
             else -> {
-                val configReference = RsSymbolIndex.lookup(o.project, type, value)
+                val configReference = RsSymbolIndex.lookup(o, type, value)
                 if (configReference == null) {
                     o.error("Could not resolve constant value '${value} to a reference.'")
                 }

diff --git a/src/main/kotlin/io/runescript/plugin/symbollang/psi/index/RsSymbolIndex.kt b/src/main/kotlin/io/runescript/plugin/symbollang/psi/index/RsSymbolIndex.kt
@@ -1,6 +1,8 @@
 package io.runescript.plugin.symbollang.psi.index
 
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.stubs.StringStubIndexExtension
@@ -21,10 +23,11 @@ class RsSymbolIndex : StringStubIndexExtension<RsSymSymbol>() {
     companion object {
         val KEY = StubIndexKey.createIndexKey<String, RsSymSymbol>("io.runescript.plugin.symbollang.psi.index.RsSymbolIndex")
 
-        fun lookup(project: Project, type: RsPrimitiveType, name: String): RsSymSymbol? {
+        fun lookup(context: PsiElement, type: RsPrimitiveType, name: String): RsSymSymbol? {
             val lookupType = if (type == RsPrimitiveType.NAMEDOBJ) RsPrimitiveType.OBJ else type
-            val scope = GlobalSearchScope.allScope(project)
-            val configs = StubIndex.getElements(KEY, name, project, scope, RsSymSymbol::class.java)
+            val module = ModuleUtil.findModuleForPsiElement(context) ?: return null
+            val scope = GlobalSearchScope.moduleScope(module)
+            val configs = StubIndex.getElements(KEY, name, context.project, scope, RsSymSymbol::class.java)
             return configs.singleOrNull {
                 it.containingFile.virtualFile.isSymbolFileOfTypeLiteral(lookupType.literal)
             }

diff --git a/src/main/kotlin/io/runescript/plugin/symbollang/psi/mixin/RsSymSymbolMixin.kt b/src/main/kotlin/io/runescript/plugin/symbollang/psi/mixin/RsSymSymbolMixin.kt
@@ -2,6 +2,7 @@ package io.runescript.plugin.symbollang.psi.mixin
 
 import com.intellij.extapi.psi.StubBasedPsiElementBase
 import com.intellij.lang.ASTNode
+import com.intellij.openapi.module.ModuleUtil
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.SearchScope
@@ -20,7 +21,8 @@ abstract class RsSymSymbolMixin : StubBasedPsiElementBase<RsSymSymbolStub>, RsSy
     constructor(stub: RsSymSymbolStub?, type: IElementType?, node: ASTNode?) : super(stub, type, node)
 
     override fun getUseScope(): SearchScope {
-        return GlobalSearchScope.projectScope(project)
+        val module = ModuleUtil.findModuleForPsiElement(this) ?: return super.getUseScope()
+        return GlobalSearchScope.moduleScope(module)
     }
 
     override fun setName(name: String) = RsSymPsiImplUtil.setName(fieldList[getNameFieldIndex()], name)