[polySymbols] WEB-73291 PolySymbols: remove dependency on PolySymbolsScope from PolySymbol interface

GitOrigin-RevId: b8e3431d9fe4452c8ab957fe3acb802ec0f61482
2026-09-27 10:03:11 +07:00 · 2025-06-13 09:07:19 +00:00
parent d384c5d8a3
commit 65bc09235f
49 changed files with 501 additions and 391 deletions
@@ -4,7 +4,6 @@
 *:com.intellij.polySymbols.PolySymbol
 - com.intellij.model.Symbol
 - com.intellij.navigation.NavigatableSymbol
- com.intellij.polySymbols.PolySymbolsScope
 - com.intellij.polySymbols.utils.PolySymbolsPrioritizedScope
 - *sf:Companion:com.intellij.polySymbols.PolySymbol$Companion
 - sf:PROP_DOC_HIDE_PATTERN:com.intellij.polySymbols.PolySymbolProperty
@@ -18,7 +17,6 @@
 - getApiStatus():com.intellij.polySymbols.PolySymbolApiStatus
 - getDocumentationTarget(com.intellij.psi.PsiElement):com.intellij.platform.backend.documentation.DocumentationTarget
 - getIcon():javax.swing.Icon
- getModificationCount():J
 - getModifiers():java.util.Set
 - a:getName():java.lang.String
 - getNavigationTargets(com.intellij.openapi.project.Project):java.util.Collection
@@ -251,13 +249,6 @@
 - sf:BUNDLE:java.lang.String
 - s:message(java.lang.String,java.lang.Object[]):java.lang.String
 - s:messagePointer(java.lang.String,java.lang.Object[]):java.util.function.Supplier
-*:com.intellij.polySymbols.PolySymbolsScope
- com.intellij.openapi.util.ModificationTracker
- a:createPointer():com.intellij.model.Pointer
- getCodeCompletions(com.intellij.polySymbols.PolySymbolQualifiedName,com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams,com.intellij.util.containers.Stack):java.util.List
- getMatchingSymbols(com.intellij.polySymbols.PolySymbolQualifiedName,com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams,com.intellij.util.containers.Stack):java.util.List
- getSymbols(com.intellij.polySymbols.PolySymbolQualifiedKind,com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams,com.intellij.util.containers.Stack):java.util.List
- isExclusiveFor(com.intellij.polySymbols.PolySymbolQualifiedKind):Z
 *:com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 - *sf:Companion:com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem$Companion
 - a:addToResult(com.intellij.codeInsight.completion.CompletionParameters,com.intellij.codeInsight.completion.CompletionResultSet,D):V
@@ -449,7 +440,10 @@
 - sf:PROP_CSS_ARGUMENTS:com.intellij.polySymbols.PolySymbolProperty
 *:com.intellij.polySymbols.customElements.CustomElementsSymbol
 - com.intellij.polySymbols.documentation.PolySymbolWithDocumentation
+- com.intellij.polySymbols.query.PolySymbolsScope
 - *sf:Companion:com.intellij.polySymbols.customElements.CustomElementsSymbol$Companion
+- a:createPointer():com.intellij.model.Pointer
+- getModificationCount():J
 *f:com.intellij.polySymbols.customElements.CustomElementsSymbol$Companion
 - f:getCEM_DECLARATIONS():com.intellij.polySymbols.PolySymbolQualifiedKind
 - f:getCEM_MODULES():com.intellij.polySymbols.PolySymbolQualifiedKind
@@ -701,7 +695,7 @@
 - f:create(com.intellij.polySymbols.query.PolySymbolsQueryExecutor,I,kotlin.jvm.functions.Function1):com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams
 - bs:create$default(com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams$Companion,com.intellij.polySymbols.query.PolySymbolsQueryExecutor,I,kotlin.jvm.functions.Function1,I,java.lang.Object):com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams
 *a:com.intellij.polySymbols.query.PolySymbolsCompoundScope
- com.intellij.polySymbols.PolySymbolsScope
+- com.intellij.polySymbols.query.PolySymbolsScope
 - <init>():V
 - pa:build(com.intellij.polySymbols.query.PolySymbolsQueryExecutor,kotlin.jvm.functions.Function1):V
 - a:createPointer():com.intellij.model.Pointer
@@ -794,13 +788,13 @@
 - a:run():java.util.List
 *:com.intellij.polySymbols.query.PolySymbolsQueryExecutor$QueryBuilder
 - com.intellij.polySymbols.query.PolySymbolsQueryParams$Builder
- a:additionalScope(com.intellij.polySymbols.PolySymbolsScope):java.lang.Object
+- a:additionalScope(com.intellij.polySymbols.query.PolySymbolsScope):java.lang.Object
 - a:additionalScope(java.util.Collection):java.lang.Object
- a:additionalScope(com.intellij.polySymbols.PolySymbolsScope[]):java.lang.Object
+- a:additionalScope(com.intellij.polySymbols.query.PolySymbolsScope[]):java.lang.Object
 *:com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory
 - com.intellij.openapi.Disposable
 - *sf:Companion:com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory$Companion
- a:addScope(com.intellij.polySymbols.PolySymbolsScope,com.intellij.openapi.vfs.VirtualFile,com.intellij.openapi.Disposable):V
+- a:addScope(com.intellij.polySymbols.query.PolySymbolsScope,com.intellij.openapi.vfs.VirtualFile,com.intellij.openapi.Disposable):V
 - a:create(com.intellij.psi.PsiElement,Z):com.intellij.polySymbols.query.PolySymbolsQueryExecutor
 - bs:create$default(com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory,com.intellij.psi.PsiElement,Z,I,java.lang.Object):com.intellij.polySymbols.query.PolySymbolsQueryExecutor
 - s:getInstance(com.intellij.openapi.project.Project):com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory
@@ -814,7 +808,7 @@
 - a:addCustomizer(com.intellij.polySymbols.query.PolySymbolsQueryResultsCustomizer):com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory$PolySymbolsQueryExecutorBuilder
 - a:addNameConversionRules(com.intellij.polySymbols.query.PolySymbolNameConversionRules):com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory$PolySymbolsQueryExecutorBuilder
 - a:addPolyContext(java.lang.String,java.lang.String):com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory$PolySymbolsQueryExecutorBuilder
- a:addRootScope(com.intellij.polySymbols.PolySymbolsScope):com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory$PolySymbolsQueryExecutorBuilder
+- a:addRootScope(com.intellij.polySymbols.query.PolySymbolsScope):com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory$PolySymbolsQueryExecutorBuilder
 - a:addRootScopes(java.util.List):com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory$PolySymbolsQueryExecutorBuilder
 - a:allowResolve(Z):com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory$PolySymbolsQueryExecutorBuilder
 - a:create():com.intellij.polySymbols.query.PolySymbolsQueryExecutor
@@ -856,6 +850,13 @@
 - s:getQueryResultsCustomizer(com.intellij.psi.PsiElement,com.intellij.polySymbols.context.PolyContext):com.intellij.polySymbols.query.PolySymbolsQueryResultsCustomizer
 *f:com.intellij.polySymbols.query.PolySymbolsQueryResultsCustomizerFactory$Companion
 - f:getQueryResultsCustomizer(com.intellij.psi.PsiElement,com.intellij.polySymbols.context.PolyContext):com.intellij.polySymbols.query.PolySymbolsQueryResultsCustomizer
+*:com.intellij.polySymbols.query.PolySymbolsScope
+- com.intellij.openapi.util.ModificationTracker
+- a:createPointer():com.intellij.model.Pointer
+- getCodeCompletions(com.intellij.polySymbols.PolySymbolQualifiedName,com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams,com.intellij.util.containers.Stack):java.util.List
+- getMatchingSymbols(com.intellij.polySymbols.PolySymbolQualifiedName,com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams,com.intellij.util.containers.Stack):java.util.List
+- getSymbols(com.intellij.polySymbols.PolySymbolQualifiedKind,com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams,com.intellij.util.containers.Stack):java.util.List
+- isExclusiveFor(com.intellij.polySymbols.PolySymbolQualifiedKind):Z
 *:com.intellij.polySymbols.refactoring.PolySymbolRenameTarget
 - com.intellij.refactoring.rename.api.RenameTarget
 - *sf:Companion:com.intellij.polySymbols.refactoring.PolySymbolRenameTarget$Companion
@@ -910,7 +911,9 @@
 - navigationRequest():com.intellij.platform.backend.navigation.NavigationRequest
 *:com.intellij.polySymbols.utils.PolySymbolDelegate
 - com.intellij.polySymbols.PolySymbol
+- com.intellij.polySymbols.query.PolySymbolsScope
 - *sf:Companion:com.intellij.polySymbols.utils.PolySymbolDelegate$Companion
+- a:createPointer():com.intellij.model.Pointer
 - get(com.intellij.polySymbols.PolySymbolProperty):java.lang.Object
 - getAccessModifier():com.intellij.polySymbols.PolySymbolAccessModifier
 - getApiStatus():com.intellij.polySymbols.PolySymbolApiStatus
@@ -942,6 +945,7 @@
 - com.intellij.polySymbols.documentation.PolySymbolWithDocumentation
 - com.intellij.polySymbols.utils.PolySymbolDelegate
 - createDocumentation(com.intellij.psi.PsiElement):com.intellij.polySymbols.documentation.PolySymbolDocumentation
+- a:createPointer():com.intellij.model.Pointer
 - getDefaultValue():java.lang.String
 - getDescription():java.lang.String
 - getDescriptionSections():java.util.Map
@@ -965,7 +969,7 @@
 - sf:coalesceWith(com.intellij.polySymbols.PolySymbolApiStatus,com.intellij.polySymbols.PolySymbolApiStatus):com.intellij.polySymbols.PolySymbolApiStatus
 - sf:createPsiRangeNavigationItem(com.intellij.platform.backend.navigation.NavigationTarget,com.intellij.psi.PsiElement,I):com.intellij.pom.Navigatable
 - sf:getCompleteMatch(com.intellij.polySymbols.PolySymbol):Z
- sf:getDefaultCodeCompletions(com.intellij.polySymbols.PolySymbolsScope,com.intellij.polySymbols.PolySymbolQualifiedName,com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams,com.intellij.util.containers.Stack):java.util.List
+- sf:getDefaultCodeCompletions(com.intellij.polySymbols.query.PolySymbolsScope,com.intellij.polySymbols.PolySymbolQualifiedName,com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams,com.intellij.util.containers.Stack):java.util.List
 - sf:getHideFromCompletion(com.intellij.polySymbols.PolySymbol):Z
 - sf:getKind(com.intellij.polySymbols.PolySymbol):java.lang.String
 - sf:getNameSegments(com.intellij.polySymbols.PolySymbol):java.util.List
@@ -981,12 +985,12 @@
 - sf:unwrapMatchedSymbols(com.intellij.polySymbols.PolySymbol):kotlin.sequences.Sequence
 - sf:withMatchedKind(com.intellij.polySymbols.PolySymbol,com.intellij.polySymbols.PolySymbolQualifiedKind):com.intellij.polySymbols.PolySymbol
 - sf:withMatchedName(com.intellij.polySymbols.PolySymbol,java.lang.String):com.intellij.polySymbols.PolySymbol
- sf:withNavigationTarget(com.intellij.polySymbols.PolySymbol,com.intellij.psi.PsiElement):com.intellij.polySymbols.PolySymbol
+- sf:withNavigationTarget(com.intellij.polySymbols.PolySymbol,com.intellij.psi.PsiElement):com.intellij.polySymbols.utils.PolySymbolDelegate
 - sf:withOffset(java.util.List,I):java.util.List
 - sf:withSegments(com.intellij.polySymbols.query.PolySymbolMatch,java.util.List):com.intellij.polySymbols.query.PolySymbolMatch
 - sf:withSymbols(com.intellij.polySymbols.PolySymbolNameSegment,java.util.List):com.intellij.polySymbols.PolySymbolNameSegment
 *a:com.intellij.polySymbols.utils.PolySymbolsIsolatedMappingScope
- com.intellij.polySymbols.PolySymbolsScope
+- com.intellij.polySymbols.query.PolySymbolsScope
 - <init>(java.util.Map,java.lang.String,com.intellij.psi.PsiElement):V
 - pa:acceptSymbol(com.intellij.polySymbols.PolySymbol):Z
 - f:equals(java.lang.Object):Z
@@ -1002,7 +1006,7 @@
 *:com.intellij.polySymbols.utils.PolySymbolsPrioritizedScope
 - a:getPriority():com.intellij.polySymbols.PolySymbol$Priority
 *a:com.intellij.polySymbols.utils.PolySymbolsScopeWithCache
- com.intellij.polySymbols.PolySymbolsScope
+- com.intellij.polySymbols.query.PolySymbolsScope
 - <init>(java.lang.String,com.intellij.openapi.project.Project,com.intellij.openapi.util.UserDataHolder,java.lang.Object):V
 - a:createPointer():com.intellij.model.Pointer
 - equals(java.lang.Object):Z
@@ -1032,7 +1036,7 @@
 - pa:getScopesBuilderProvider():kotlin.jvm.functions.Function2
 - hashCode():I
 *p:com.intellij.polySymbols.utils.PolySymbolsStructuredScope$PolySymbolsPsiScope
- com.intellij.polySymbols.PolySymbolsScope
+- com.intellij.polySymbols.query.PolySymbolsScope
 - a:getAllSymbols(com.intellij.polySymbols.PolySymbolQualifiedKind):java.util.List
 - a:getChildren():java.util.List
 - a:getLocalSymbols():java.util.List
@@ -1056,11 +1060,13 @@
 *:com.intellij.polySymbols.utils.PsiSourcedPolySymbolDelegate
 - com.intellij.polySymbols.search.PsiSourcedPolySymbol
 - com.intellij.polySymbols.utils.PolySymbolDelegate
+- a:createPointer():com.intellij.model.Pointer
 - getNavigationTargets(com.intellij.openapi.project.Project):java.util.Collection
 - getPsiContext():com.intellij.psi.PsiElement
 - getSource():com.intellij.psi.PsiElement
 *:com.intellij.polySymbols.webTypes.WebTypesSymbol
 - com.intellij.polySymbols.documentation.PolySymbolWithDocumentation
+- com.intellij.polySymbols.query.PolySymbolsScope
 - com.intellij.polySymbols.search.PsiSourcedPolySymbol
 - *sf:Companion:com.intellij.polySymbols.webTypes.WebTypesSymbol$Companion
 - sf:PROP_NO_DOC:com.intellij.polySymbols.PolySymbolProperty
@@ -1118,6 +1124,7 @@
 - f:getIcon():javax.swing.Icon
 - f:getLocation():com.intellij.polySymbols.webTypes.WebTypesSymbol$Location
 - f:getMatchingSymbols(com.intellij.polySymbols.PolySymbolQualifiedName,com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams,com.intellij.util.containers.Stack):java.util.List
+- getModificationCount():J
 - getModifiers():java.util.Set
 - f:getName():java.lang.String
 - f:getOrigin():com.intellij.polySymbols.PolySymbolOrigin
@@ -13,10 +13,10 @@ import com.intellij.openapi.util.getAndUpdateUserData
 import com.intellij.patterns.StandardPatterns
 import com.intellij.polySymbols.FrameworkId
 import com.intellij.polySymbols.PolySymbolQualifiedKind
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItemCustomizer.Companion.customizeItems
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.startOffset
 import com.intellij.util.ProcessingContext
@@ -72,6 +72,7 @@ abstract class PolySymbolsCompletionProviderBase<T : PsiElement> : CompletionPro
    fun isFurtherCodeCompletionPreventedFor(parameters: CompletionParameters, vararg qualifiedKind: PolySymbolQualifiedKind): Boolean =
      (parameters.process as CompletionProcessEx).getUserData(preventedCodeCompletionsKey)
        ?.let { prevented -> qualifiedKind.any { prevented.contains(it) } } == true
+
    @JvmStatic
    fun processCompletionQueryResults(
      queryExecutor: PolySymbolsQueryExecutor,
@@ -1,12 +1,16 @@
 // Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.patterns

-import com.intellij.polySymbols.*
+import com.intellij.polySymbols.PolySymbol
+import com.intellij.polySymbols.PolySymbolModifier
+import com.intellij.polySymbols.PolySymbolQualifiedKind
+import com.intellij.polySymbols.PolySymbolQualifiedName
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.impl.canUnwrapSymbols
 import com.intellij.polySymbols.query.PolySymbolMatch
 import com.intellij.polySymbols.query.PolySymbolNameConversionRules
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.webTypes.filters.PolySymbolsFilter
 import com.intellij.util.containers.Stack
 import org.jetbrains.annotations.ApiStatus
@@ -1,11 +1,16 @@
 // Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.customElements

+import com.intellij.model.Pointer
 import com.intellij.polySymbols.PolySymbolQualifiedKind
 import com.intellij.polySymbols.documentation.PolySymbolWithDocumentation
+import com.intellij.polySymbols.query.PolySymbolsScope

-interface CustomElementsSymbol : PolySymbolWithDocumentation {
+interface CustomElementsSymbol : PolySymbolWithDocumentation, PolySymbolsScope {

+  override fun createPointer(): Pointer<out CustomElementsSymbol>
+
+  override fun getModificationCount(): Long = 0

  companion object {

@@ -14,10 +14,7 @@ import com.intellij.polySymbols.customElements.json.toApiStatus
 import com.intellij.polySymbols.documentation.PolySymbolWithDocumentation
 import com.intellij.polySymbols.impl.StaticPolySymbolsScopeBase
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
-import com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams
-import com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams
-import com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams
-import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.*
 import com.intellij.polySymbols.search.PsiSourcedPolySymbol
 import com.intellij.psi.PsiElement
 import com.intellij.util.containers.Stack
@@ -70,6 +67,8 @@ class CustomElementsClassOrMixinDeclarationAdapter private constructor(
                .toList()
                .also { contributions -> _superContributions = contributions }

+    override fun getModificationCount(): Long = 0
+
    override val origin: CustomElementsJsonOrigin
      get() = base.origin

@@ -121,7 +120,7 @@ class CustomElementsClassOrMixinDeclarationAdapter private constructor(
      qualifiedKind: PolySymbolQualifiedKind,
      params: PolySymbolsListSymbolsQueryParams,
      scope: Stack<PolySymbolsScope>,
-    ): List<PolySymbolsScope> =
+    ): List<PolySymbol> =
      base.rootScope
        .getSymbols(base.declaration, this.origin, qualifiedKind, params)
        .toList()
@@ -2,11 +2,9 @@
 package com.intellij.polySymbols.customElements.impl

 import com.intellij.model.Pointer
-import com.intellij.util.containers.Stack
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolQualifiedKind
 import com.intellij.polySymbols.PolySymbolQualifiedName
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.customElements.CustomElementsJsonOrigin
 import com.intellij.polySymbols.customElements.CustomElementsManifestScopeBase
@@ -14,7 +12,8 @@ import com.intellij.polySymbols.customElements.json.CustomElementsContribution
 import com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams
 import com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams
 import com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams
-import java.util.*
+import com.intellij.polySymbols.query.PolySymbolsScope
+import com.intellij.util.containers.Stack

 abstract class CustomElementsContainerSymbolBase<Container : CustomElementsContribution> protected constructor(
  name: String,
@@ -23,23 +22,29 @@ abstract class CustomElementsContainerSymbolBase<Container : CustomElementsContr
  private val rootScope: CustomElementsManifestScopeBase,
 ) : CustomElementsContributionSymbol<Container>(name, container, origin) {

-  override fun getMatchingSymbols(qualifiedName: PolySymbolQualifiedName,
-                                  params: PolySymbolsNameMatchQueryParams,
-                                  scope: Stack<PolySymbolsScope>): List<PolySymbol> =
+  override fun getMatchingSymbols(
+    qualifiedName: PolySymbolQualifiedName,
+    params: PolySymbolsNameMatchQueryParams,
+    scope: Stack<PolySymbolsScope>,
+  ): List<PolySymbol> =
    rootScope
      .getMatchingSymbols(contribution, this.origin, qualifiedName, params, scope)
      .toList()

-  override fun getSymbols(qualifiedKind: PolySymbolQualifiedKind,
-                          params: PolySymbolsListSymbolsQueryParams,
-                          scope: Stack<PolySymbolsScope>): List<PolySymbolsScope> =
+  override fun getSymbols(
+    qualifiedKind: PolySymbolQualifiedKind,
+    params: PolySymbolsListSymbolsQueryParams,
+    scope: Stack<PolySymbolsScope>,
+  ): List<PolySymbol> =
    rootScope
      .getSymbols(contribution, this.origin, qualifiedKind, params)
      .toList()

-  override fun getCodeCompletions(qualifiedName: PolySymbolQualifiedName,
-                                  params: PolySymbolsCodeCompletionQueryParams,
-                                  scope: Stack<PolySymbolsScope>): List<PolySymbolCodeCompletionItem> =
+  override fun getCodeCompletions(
+    qualifiedName: PolySymbolQualifiedName,
+    params: PolySymbolsCodeCompletionQueryParams,
+    scope: Stack<PolySymbolsScope>,
+  ): List<PolySymbolCodeCompletionItem> =
    rootScope
      .getCodeCompletions(contribution, this.origin, qualifiedName, params, scope)
      .toList()
@@ -9,10 +9,11 @@ import com.intellij.polySymbols.documentation.PolySymbolWithDocumentation
 import com.intellij.polySymbols.documentation.impl.PolySymbolDocumentationTargetImpl
 import com.intellij.polySymbols.js.JS_PROPERTIES
 import com.intellij.polySymbols.js.JS_STRING_LITERALS
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.search.PsiSourcedPolySymbol
 import com.intellij.psi.PsiElement

-interface WebTypesSymbol : PsiSourcedPolySymbol, PolySymbolWithDocumentation {
+interface WebTypesSymbol : PsiSourcedPolySymbol, PolySymbolWithDocumentation, PolySymbolsScope {

  val location: Location?

@@ -11,10 +11,7 @@ import com.intellij.polySymbols.html.PROP_HTML_ATTRIBUTE_VALUE
 import com.intellij.polySymbols.html.PolySymbolHtmlAttributeValue
 import com.intellij.polySymbols.html.htmlAttributeValue
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
-import com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams
-import com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams
-import com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams
-import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.*
 import com.intellij.polySymbols.utils.merge
 import com.intellij.polySymbols.webTypes.impl.WebTypesJsonContributionAdapter
 import com.intellij.polySymbols.webTypes.impl.wrap
@@ -72,6 +69,8 @@ open class WebTypesSymbolBase : WebTypesSymbol {
  override fun toString(): String =
    base.toString()

+  override fun getModificationCount(): Long = 0
+
  override fun equals(other: Any?): Boolean =
    other === this
    || other is WebTypesSymbolBase
@@ -110,7 +109,7 @@ open class WebTypesSymbolBase : WebTypesSymbol {
    qualifiedKind: PolySymbolQualifiedKind,
    params: PolySymbolsListSymbolsQueryParams,
    scope: Stack<PolySymbolsScope>,
-  ): List<PolySymbolsScope> =
+  ): List<PolySymbol> =
    base.rootScope
      .getSymbols(base.contributionForQuery, this.origin as WebTypesJsonOrigin, qualifiedKind, params)
      .toList()
@@ -210,7 +209,7 @@ open class WebTypesSymbolBase : WebTypesSymbol {

  final override fun isExclusiveFor(qualifiedKind: PolySymbolQualifiedKind): Boolean =
    base.isExclusiveFor(qualifiedKind)
-    || superContributions.any { it.isExclusiveFor(qualifiedKind) }
+    || superContributions.flatMap { it.queryScope }.any { it.isExclusiveFor(qualifiedKind) }

  override fun matchContext(context: PolyContext): Boolean =
    super.matchContext(context) && base.contribution.requiredContext.evaluate(context)
@@ -2,22 +2,26 @@
 package com.intellij.polySymbols.webTypes.filters

 import com.intellij.polySymbols.PolySymbol
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.webTypes.impl.PolySymbolsFilterEP

 interface PolySymbolsFilter {

-  fun filterCodeCompletions(codeCompletions: List<PolySymbolCodeCompletionItem>,
-                            queryExecutor: PolySymbolsQueryExecutor,
-                            scope: List<PolySymbolsScope>,
-                            properties: Map<String, Any>): List<PolySymbolCodeCompletionItem>
+  fun filterCodeCompletions(
+    codeCompletions: List<PolySymbolCodeCompletionItem>,
+    queryExecutor: PolySymbolsQueryExecutor,
+    scope: List<PolySymbolsScope>,
+    properties: Map<String, Any>,
+  ): List<PolySymbolCodeCompletionItem>

-  fun filterNameMatches(matches: List<PolySymbol>,
-                        queryExecutor: PolySymbolsQueryExecutor,
-                        scope: List<PolySymbolsScope>,
-                        properties: Map<String, Any>): List<PolySymbol>
+  fun filterNameMatches(
+    matches: List<PolySymbol>,
+    queryExecutor: PolySymbolsQueryExecutor,
+    scope: List<PolySymbolsScope>,
+    properties: Map<String, Any>,
+  ): List<PolySymbol>


  companion object {
@@ -2,26 +2,30 @@
 package com.intellij.polySymbols.webTypes.filters

 import com.intellij.polySymbols.PolySymbol
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
 import org.jetbrains.annotations.ApiStatus

@ApiStatus.Internal
 class PolySymbolsMatchPrefixFilter : PolySymbolsFilter {

-  override fun filterCodeCompletions(codeCompletions: List<PolySymbolCodeCompletionItem>,
-                                     queryExecutor: PolySymbolsQueryExecutor,
-                                     scope: List<PolySymbolsScope>,
-                                     properties: Map<String, Any>): List<PolySymbolCodeCompletionItem> {
+  override fun filterCodeCompletions(
+    codeCompletions: List<PolySymbolCodeCompletionItem>,
+    queryExecutor: PolySymbolsQueryExecutor,
+    scope: List<PolySymbolsScope>,
+    properties: Map<String, Any>,
+  ): List<PolySymbolCodeCompletionItem> {
    val prefix = properties["prefix"] as? String ?: return codeCompletions
    return codeCompletions.filter { it.name.startsWith(prefix) }
  }

-  override fun filterNameMatches(matches: List<PolySymbol>,
-                                 queryExecutor: PolySymbolsQueryExecutor,
-                                 scope: List<PolySymbolsScope>,
-                                 properties: Map<String, Any>): List<PolySymbol> {
+  override fun filterNameMatches(
+    matches: List<PolySymbol>,
+    queryExecutor: PolySymbolsQueryExecutor,
+    scope: List<PolySymbolsScope>,
+    properties: Map<String, Any>,
+  ): List<PolySymbol> {
    val prefix = properties["prefix"] as? String ?: return matches
    return matches.filter { it.name.startsWith(prefix) }
  }
@@ -3,12 +3,12 @@ package com.intellij.polySymbols.webTypes.impl

 import com.intellij.openapi.extensions.CustomLoadingExtensionPointBean
 import com.intellij.openapi.extensions.ExtensionPointName
-import com.intellij.util.xmlb.annotations.Attribute
 import com.intellij.polySymbols.PolySymbol
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.webTypes.filters.PolySymbolsFilter
+import com.intellij.util.xmlb.annotations.Attribute

 class PolySymbolsFilterEP() : CustomLoadingExtensionPointBean<PolySymbolsFilter>() {

@@ -5,7 +5,6 @@ import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolApiStatus.Companion.isDeprecatedOrObsolete
 import com.intellij.polySymbols.PolySymbolModifier
 import com.intellij.polySymbols.PolySymbolQualifiedKind
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.impl.canUnwrapSymbols
 import com.intellij.polySymbols.patterns.ComplexPatternOptions
@@ -14,6 +13,7 @@ import com.intellij.polySymbols.patterns.impl.*
 import com.intellij.polySymbols.query.PolySymbolMatch
 import com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.utils.namespace
 import com.intellij.polySymbols.webTypes.WebTypesJsonOrigin
 import com.intellij.polySymbols.webTypes.json.*
@@ -19,10 +19,7 @@ import com.intellij.polySymbols.html.NAMESPACE_HTML
 import com.intellij.polySymbols.html.PolySymbolHtmlAttributeValue
 import com.intellij.polySymbols.impl.canUnwrapSymbols
 import com.intellij.polySymbols.js.*
-import com.intellij.polySymbols.query.PolySymbolMatch
-import com.intellij.polySymbols.query.PolySymbolNameConversionRules
-import com.intellij.polySymbols.query.PolySymbolNameConverter
-import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.*
 import com.intellij.polySymbols.utils.NameCaseUtils
 import com.intellij.polySymbols.utils.PolySymbolTypeSupport
 import com.intellij.polySymbols.utils.lastPolySymbol
@@ -7,6 +7,7 @@ import com.intellij.model.Pointer
 import com.intellij.model.Symbol
 import com.intellij.navigation.NavigatableSymbol
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.ModificationTracker
 import com.intellij.openapi.util.NlsSafe
 import com.intellij.platform.backend.documentation.DocumentationTarget
 import com.intellij.platform.backend.navigation.NavigationTarget
@@ -15,6 +16,7 @@ import com.intellij.polySymbols.context.PolyContext
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.query.PolySymbolMatch
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.refactoring.PolySymbolRenameTarget
 import com.intellij.polySymbols.search.PolySymbolSearchTarget
 import com.intellij.polySymbols.utils.*
@@ -43,7 +45,7 @@ import javax.swing.Icon
 * INAPPLICABLE_JVM_NAME -> https://youtrack.jetbrains.com/issue/KT-31420
 **/
@Suppress("INAPPLICABLE_JVM_NAME")
-interface PolySymbol : PolySymbolsScope, Symbol, NavigatableSymbol, PolySymbolsPrioritizedScope {
+interface PolySymbol : Symbol, NavigatableSymbol, PolySymbolsPrioritizedScope {

  /**
   * Specifies where this symbol comes from. Besides descriptive information like
@@ -115,10 +117,10 @@ interface PolySymbol : PolySymbolsScope, Symbol, NavigatableSymbol, PolySymbolsP

  /**
   * When pattern is being evaluated, matched symbols can provide additional scope for further resolution in the pattern.
-   * By default, the `queryScope` returns the symbol itself
+   * By default, the `queryScope` returns the symbol itself if it is a [PolySymbolsScope]
   */
  val queryScope: List<PolySymbolsScope>
-    get() = listOf(this)
+    get() = listOfNotNull(this as? PolySymbolsScope)

  /**
   * Specifies whether the symbol is an extension.
@@ -218,12 +220,6 @@ interface PolySymbol : PolySymbolsScope, Symbol, NavigatableSymbol, PolySymbolsP
  override fun getNavigationTargets(project: Project): Collection<NavigationTarget> =
    emptyList()

-  /**
-   * Symbols can be used in [CachedValue]s as dependencies.
-   * If a symbol instance can mutate over time, it should properly implement this method.
-   */
-  override fun getModificationCount(): Long = 0
-
  /**
   * Returns the pointer to the symbol, which can survive between read actions.
   * The dereferenced symbol should be valid, i.e. any PSI based properties should return valid PsiElements.
@@ -2,28 +2,17 @@
 package com.intellij.polySymbols.impl

 import com.intellij.openapi.util.text.StringUtil
-import com.intellij.polySymbols.PolySymbol
-import com.intellij.polySymbols.PolySymbolKind
-import com.intellij.polySymbols.PolySymbolNamespace
-import com.intellij.polySymbols.PolySymbolQualifiedKind
-import com.intellij.polySymbols.PolySymbolQualifiedName
-import com.intellij.polySymbols.PolySymbolsScope
+import com.intellij.polySymbols.*
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
-import com.intellij.polySymbols.query.PolySymbolNamesProvider
-import com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams
-import com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams
-import com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams
-import com.intellij.polySymbols.query.PolySymbolsQueryParams
+import com.intellij.polySymbols.query.*
 import com.intellij.polySymbols.utils.match
 import com.intellij.polySymbols.utils.toCodeCompletionItems
 import com.intellij.polySymbols.utils.withMatchedName
 import com.intellij.util.SmartList
 import com.intellij.util.containers.Stack
 import com.intellij.util.text.CharSequenceSubSequence
-import java.util.TreeMap
-import kotlin.sequences.flatMap
-import kotlin.sequences.plus
+import java.util.*

 internal abstract class SearchMap<T> internal constructor(
  private val namesProvider: PolySymbolNamesProvider,
@@ -71,7 +60,7 @@ internal abstract class SearchMap<T> internal constructor(
      .map { it.withMatchedName(qualifiedName.name) }
      .plus(collectPatternContributions(qualifiedName, params, scope))

-  internal fun getSymbols(qualifiedKind: PolySymbolQualifiedKind, params: PolySymbolsListSymbolsQueryParams): Sequence<PolySymbolsScope> =
+  internal fun getSymbols(qualifiedKind: PolySymbolQualifiedKind, params: PolySymbolsListSymbolsQueryParams): Sequence<PolySymbol> =
    statics.subMap(SearchMapEntry(qualifiedKind), SearchMapEntry(qualifiedKind, kindExclusive = true))
      .values.asSequence()
      .plus(patterns.subMap(SearchMapEntry(qualifiedKind), SearchMapEntry(qualifiedKind, kindExclusive = true)).values)
@@ -3,9 +3,9 @@ package com.intellij.polySymbols.impl

 import com.intellij.model.Pointer
 import com.intellij.polySymbols.FrameworkId
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.context.PolyContextRulesProvider
 import com.intellij.polySymbols.query.PolySymbolNameConversionRulesProvider
+import com.intellij.polySymbols.query.PolySymbolsScope

 interface StaticPolySymbolsScope : PolySymbolsScope, PolyContextRulesProvider {

@@ -7,7 +7,6 @@ import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.context.PolyContext
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.query.*
-import com.intellij.polySymbols.impl.SearchMap
 import com.intellij.util.containers.ContainerUtil
 import com.intellij.util.containers.Stack
 import org.jetbrains.annotations.ApiStatus.Internal
@@ -45,7 +44,7 @@ abstract class StaticPolySymbolsScopeBase<Root : Any, Contribution : Any, Origin
    qualifiedKind: PolySymbolQualifiedKind,
    params: PolySymbolsListSymbolsQueryParams,
    scope: Stack<PolySymbolsScope>,
-  ): List<PolySymbolsScope> =
+  ): List<PolySymbol> =
    getMaps(params).flatMap {
      it.getSymbols(qualifiedKind, params)
    }.toList()
@@ -75,7 +74,7 @@ abstract class StaticPolySymbolsScopeBase<Root : Any, Contribution : Any, Origin
    origin: Origin,
    qualifiedKind: PolySymbolQualifiedKind,
    params: PolySymbolsListSymbolsQueryParams,
-  ): List<PolySymbolsScope> =
+  ): List<PolySymbol> =
    getMap(params.queryExecutor, contribution, origin)
      .getSymbols(qualifiedKind, params)
      .toList()
@@ -1,14 +1,14 @@
 // Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.patterns

-import com.intellij.util.containers.Stack
 import com.intellij.polySymbols.PolySymbol
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.patterns.impl.*
 import com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams
 import com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams
 import com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams
+import com.intellij.polySymbols.query.PolySymbolsScope
+import com.intellij.util.containers.Stack
 import org.jetbrains.annotations.ApiStatus

@ApiStatus.NonExtendable
@@ -18,39 +18,51 @@ abstract class PolySymbolsPattern internal constructor() {

  internal open fun isStaticAndRequired(): Boolean = true

-  internal fun match(owner: PolySymbol?,
-                     scope: Stack<PolySymbolsScope>,
-                     name: String,
-                     params: PolySymbolsNameMatchQueryParams): List<MatchResult> =
+  internal fun match(
+    owner: PolySymbol?,
+    scope: Stack<PolySymbolsScope>,
+    name: String,
+    params: PolySymbolsNameMatchQueryParams,
+  ): List<MatchResult> =
    match(owner, scope, null, MatchParameters(name, params), 0, name.length)
      .map { it.removeEmptySegments() }

-  internal fun list(owner: PolySymbol?,
-                    scope: Stack<PolySymbolsScope>,
-                    params: PolySymbolsListSymbolsQueryParams): List<ListResult> =
+  internal fun list(
+    owner: PolySymbol?,
+    scope: Stack<PolySymbolsScope>,
+    params: PolySymbolsListSymbolsQueryParams,
+  ): List<ListResult> =
    list(owner, scope, null, ListParameters(params))
      .map { it.removeEmptySegments() }

-  internal fun complete(owner: PolySymbol?,
-                        scope: Stack<PolySymbolsScope>,
-                        name: String,
-                        params: PolySymbolsCodeCompletionQueryParams): List<PolySymbolCodeCompletionItem> =
+  internal fun complete(
+    owner: PolySymbol?,
+    scope: Stack<PolySymbolsScope>,
+    name: String,
+    params: PolySymbolsCodeCompletionQueryParams,
+  ): List<PolySymbolCodeCompletionItem> =
    complete(owner, Stack(scope), null,
             CompletionParameters(name, params), 0, name.length).items

-  internal abstract fun match(owner: PolySymbol?,
-                              scopeStack: Stack<PolySymbolsScope>,
-                              symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                              params: MatchParameters, start: Int, end: Int): List<MatchResult>
+  internal abstract fun match(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: MatchParameters, start: Int, end: Int,
+  ): List<MatchResult>

-  internal abstract fun list(owner: PolySymbol?,
-                             scopeStack: Stack<PolySymbolsScope>,
-                             symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                             params: ListParameters): List<ListResult>
+  internal abstract fun list(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: ListParameters,
+  ): List<ListResult>

-  internal abstract fun complete(owner: PolySymbol?,
-                                 scopeStack: Stack<PolySymbolsScope>,
-                                 symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                                 params: CompletionParameters, start: Int, end: Int): CompletionResults
+  internal abstract fun complete(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: CompletionParameters, start: Int, end: Int,
+  ): CompletionResults

 }
@@ -1,19 +1,21 @@
 // Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.patterns

-import com.intellij.util.containers.Stack
 import com.intellij.polySymbols.PolySymbolQualifiedName
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.patterns.impl.*
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
+import com.intellij.util.containers.Stack
 import org.jetbrains.annotations.ApiStatus

@ApiStatus.Internal
 object PolySymbolsPatternFactory {

-  fun createComplexPattern(optionsProvider: (queryExecutor: PolySymbolsQueryExecutor, contextStack: Stack<PolySymbolsScope>) -> ComplexPatternOptions,
-                           isStaticAndRequiredProvider: () -> Boolean,
-                           patternsProvider: () -> List<PolySymbolsPattern>): PolySymbolsPattern =
+  fun createComplexPattern(
+    optionsProvider: (queryExecutor: PolySymbolsQueryExecutor, contextStack: Stack<PolySymbolsScope>) -> ComplexPatternOptions,
+    isStaticAndRequiredProvider: () -> Boolean,
+    patternsProvider: () -> List<PolySymbolsPattern>,
+  ): PolySymbolsPattern =
    ComplexPattern(object : ComplexPatternConfigProvider {
      override fun getPatterns(): List<PolySymbolsPattern> =
        patternsProvider()
@@ -26,9 +28,11 @@ object PolySymbolsPatternFactory {

    })

-  fun createComplexPattern(options: ComplexPatternOptions,
-                           isStaticAndRequired: Boolean,
-                           vararg patterns: PolySymbolsPattern): PolySymbolsPattern =
+  fun createComplexPattern(
+    options: ComplexPatternOptions,
+    isStaticAndRequired: Boolean,
+    vararg patterns: PolySymbolsPattern,
+  ): PolySymbolsPattern =

    ComplexPattern(object : ComplexPatternConfigProvider {
      override fun getPatterns(): List<PolySymbolsPattern> =
@@ -1,12 +1,12 @@
 // Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.patterns

-import com.intellij.util.containers.Stack
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolQualifiedKind
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
+import com.intellij.util.containers.Stack
 import org.jetbrains.annotations.ApiStatus

@ApiStatus.Internal
@@ -16,17 +16,23 @@ interface PolySymbolsPatternSymbolsResolver {

  val delegate: PolySymbol?

-  fun codeCompletion(name: String,
-                     position: Int,
-                     scopeStack: Stack<PolySymbolsScope>,
-                     queryExecutor: PolySymbolsQueryExecutor): List<PolySymbolCodeCompletionItem>
+  fun codeCompletion(
+    name: String,
+    position: Int,
+    scopeStack: Stack<PolySymbolsScope>,
+    queryExecutor: PolySymbolsQueryExecutor,
+  ): List<PolySymbolCodeCompletionItem>

-  fun listSymbols(scopeStack: Stack<PolySymbolsScope>,
-                  queryExecutor: PolySymbolsQueryExecutor,
-                  expandPatterns: Boolean): List<PolySymbol>
+  fun listSymbols(
+    scopeStack: Stack<PolySymbolsScope>,
+    queryExecutor: PolySymbolsQueryExecutor,
+    expandPatterns: Boolean,
+  ): List<PolySymbol>

-  fun matchName(name: String,
-                scopeStack: Stack<PolySymbolsScope>,
-                queryExecutor: PolySymbolsQueryExecutor): List<PolySymbol>
+  fun matchName(
+    name: String,
+    scopeStack: Stack<PolySymbolsScope>,
+    queryExecutor: PolySymbolsQueryExecutor,
+  ): List<PolySymbol>

 }
@@ -1,39 +1,45 @@
 // Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.patterns.impl

-import com.intellij.util.containers.Stack
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolNameSegment
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.patterns.PolySymbolsPatternSymbolsResolver
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.utils.hideFromCompletion
+import com.intellij.util.containers.Stack

 internal class CompletionAutoPopupPattern(val isSticky: Boolean) : PolySymbolsPattern() {

  override fun getStaticPrefixes(): Sequence<String> = sequenceOf("")

-  override fun match(owner: PolySymbol?,
-                     scopeStack: Stack<PolySymbolsScope>,
-                     symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                     params: MatchParameters,
-                     start: Int,
-                     end: Int): List<MatchResult> =
+  override fun match(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: MatchParameters,
+    start: Int,
+    end: Int,
+  ): List<MatchResult> =
    listOf(MatchResult(PolySymbolNameSegment.create(start, start)))

-  override fun list(owner: PolySymbol?,
-                    scopeStack: Stack<PolySymbolsScope>,
-                    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                    params: ListParameters): List<ListResult> =
+  override fun list(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: ListParameters,
+  ): List<ListResult> =
    emptyList()

-  override fun complete(owner: PolySymbol?,
-                        scopeStack: Stack<PolySymbolsScope>,
-                        symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                        params: CompletionParameters,
-                        start: Int,
-                        end: Int): CompletionResults =
+  override fun complete(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: CompletionParameters,
+    start: Int,
+    end: Int,
+  ): CompletionResults =
    if (symbolsResolver == null || symbolsResolver.delegate?.hideFromCompletion == true) {
      CompletionResults(emptyList(), true)
    }
@@ -6,12 +6,12 @@ import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolApiStatus
 import com.intellij.polySymbols.PolySymbolApiStatus.Companion.isDeprecatedOrObsolete
 import com.intellij.polySymbols.PolySymbolNameSegment
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.impl.copy
 import com.intellij.polySymbols.impl.selectBest
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.patterns.PolySymbolsPatternSymbolsResolver
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.utils.coalesceWith
 import com.intellij.polySymbols.utils.isCritical
 import com.intellij.util.SmartList
@@ -174,18 +174,15 @@ internal class ComplexPattern(private val configProvider: ComplexPatternConfigPr
  ): T {
    val options = configProvider.getOptions(queryExecutor, scopeStack)

-    val additionalScope = options.additionalScope
-    if (additionalScope != null) {
-      scopeStack.push(additionalScope)
-    }
+    val additionalScope = options.additionalScope?.queryScope
+    additionalScope?.forEach { scopeStack.push(it) }
+
    try {
      return action(patterns, options.symbolsResolver, options.apiStatus, options.isRequired, options.priority,
                    options.repeats, options.unique)
    }
    finally {
-      if (additionalScope != null) {
-        scopeStack.pop()
-      }
+      additionalScope?.forEach { _ -> scopeStack.pop() }
    }
  }

@@ -1,11 +1,11 @@
 // Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.patterns.impl

-import com.intellij.util.containers.Stack
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.patterns.ComplexPatternOptions
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
+import com.intellij.util.containers.Stack

 internal interface ComplexPatternConfigProvider {

@@ -2,14 +2,14 @@
 package com.intellij.polySymbols.patterns.impl

 import com.intellij.openapi.progress.ProgressManager
-import com.intellij.util.containers.Stack
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolApiStatus
 import com.intellij.polySymbols.PolySymbolNameSegment
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.completion.impl.PolySymbolCodeCompletionItemImpl
 import com.intellij.polySymbols.impl.copy
+import com.intellij.polySymbols.query.PolySymbolsScope
+import com.intellij.util.containers.Stack

 internal fun PolySymbolCodeCompletionItem.withStopSequencePatternEvaluation(stop: Boolean): PolySymbolCodeCompletionItem =
  if ((this as PolySymbolCodeCompletionItemImpl).stopSequencePatternEvaluation != stop)
@@ -1,14 +1,14 @@
 // Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.patterns.impl

-import com.intellij.util.containers.Stack
-import com.intellij.util.text.CharSequenceSubSequence
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolNameSegment
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.patterns.PolySymbolsPatternSymbolsResolver
+import com.intellij.polySymbols.query.PolySymbolsScope
+import com.intellij.util.containers.Stack
+import com.intellij.util.text.CharSequenceSubSequence
 import java.util.regex.Pattern

 internal class RegExpPattern(private val regex: String, private val caseSensitive: Boolean = false) : PolySymbolsPattern() {
@@ -23,12 +23,14 @@ internal class RegExpPattern(private val regex: String, private val caseSensitiv

  override fun isStaticAndRequired(): Boolean = false

-  override fun match(owner: PolySymbol?,
-                     scopeStack: Stack<PolySymbolsScope>,
-                     symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                     params: MatchParameters,
-                     start: Int,
-                     end: Int): List<MatchResult> {
+  override fun match(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: MatchParameters,
+    start: Int,
+    end: Int,
+  ): List<MatchResult> {
    val matcher = pattern.matcher(CharSequenceSubSequence(params.name, start, end))
    return if (matcher.find(0) && matcher.start() == 0)
      listOf(MatchResult(PolySymbolNameSegment.create(
@@ -39,18 +41,22 @@ internal class RegExpPattern(private val regex: String, private val caseSensitiv
    else emptyList()
  }

-  override fun list(owner: PolySymbol?,
-                    scopeStack: Stack<PolySymbolsScope>,
-                    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                    params: ListParameters): List<ListResult> =
+  override fun list(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: ListParameters,
+  ): List<ListResult> =
    emptyList()

-  override fun complete(owner: PolySymbol?,
-                        scopeStack: Stack<PolySymbolsScope>,
-                        symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                        params: CompletionParameters,
-                        start: Int,
-                        end: Int): CompletionResults =
+  override fun complete(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: CompletionParameters,
+    start: Int,
+    end: Int,
+  ): CompletionResults =
    getPatternCompletablePrefix(regex)
      .takeIf { it.isNotBlank() }
      ?.let {
@@ -2,13 +2,17 @@
 package com.intellij.polySymbols.patterns.impl

 import com.intellij.openapi.util.text.StringUtil
-import com.intellij.polySymbols.*
+import com.intellij.polySymbols.PolySymbol
+import com.intellij.polySymbols.PolySymbolNameSegment
+import com.intellij.polySymbols.PolySymbolOrigin
+import com.intellij.polySymbols.PolySymbolQualifiedKind
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.completion.impl.CompoundInsertHandler
 import com.intellij.polySymbols.html.NAMESPACE_HTML
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.patterns.PolySymbolsPatternSymbolsResolver
 import com.intellij.polySymbols.query.PolySymbolMatch
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.utils.asSingleSymbol
 import com.intellij.polySymbols.utils.coalesceWith
 import com.intellij.polySymbols.utils.nameSegments
@@ -1,33 +1,35 @@
 // Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.patterns.impl

-import com.intellij.util.containers.Stack
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolModifier
 import com.intellij.polySymbols.PolySymbolNameSegment
 import com.intellij.polySymbols.PolySymbolQualifiedName
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.patterns.PolySymbolsPatternSymbolsResolver
 import com.intellij.polySymbols.query.PolySymbolNamesProvider
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.utils.asSingleSymbol
 import com.intellij.polySymbols.utils.nameMatches
 import com.intellij.polySymbols.utils.qualifiedName
+import com.intellij.util.containers.Stack

 class SingleSymbolReferencePattern(
  private val path: List<PolySymbolQualifiedName>,
-                                   private val excludeModifiers: List<PolySymbolModifier> = listOf(PolySymbolModifier.ABSTRACT)
+  private val excludeModifiers: List<PolySymbolModifier> = listOf(PolySymbolModifier.ABSTRACT),
 ) : PolySymbolsPattern() {
  override fun getStaticPrefixes(): Sequence<String> =
    emptySequence()

-  override fun match(owner: PolySymbol?,
-                     scopeStack: Stack<PolySymbolsScope>,
-                     symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                     params: MatchParameters,
-                     start: Int,
-                     end: Int): List<MatchResult> =
+  override fun match(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: MatchParameters,
+    start: Int,
+    end: Int,
+  ): List<MatchResult> =
    if (owner?.nameMatches(params.name.substring(start, end), params.queryExecutor) == true)
      params.queryExecutor.nameMatchQuery(path) {
        exclude(excludeModifiers)
@@ -39,10 +41,12 @@ class SingleSymbolReferencePattern(
    else
      emptyList()

-  override fun list(owner: PolySymbol?,
-                    scopeStack: Stack<PolySymbolsScope>,
-                    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                    params: ListParameters): List<ListResult> =
+  override fun list(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: ListParameters,
+  ): List<ListResult> =
    if (owner != null) {
      params.queryExecutor.nameMatchQuery(path) {
        exclude(excludeModifiers)
@@ -54,12 +58,14 @@ class SingleSymbolReferencePattern(
    }
    else emptyList()

-  override fun complete(owner: PolySymbol?,
-                        scopeStack: Stack<PolySymbolsScope>,
-                        symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                        params: CompletionParameters,
-                        start: Int,
-                        end: Int): CompletionResults =
+  override fun complete(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: CompletionParameters,
+    start: Int,
+    end: Int,
+  ): CompletionResults =
    if (owner != null
        && params.queryExecutor.nameMatchQuery(path) {
        exclude(excludeModifiers)
@@ -1,39 +1,45 @@
 // Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.patterns.impl

-import com.intellij.util.containers.Stack
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolNameSegment
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.patterns.PolySymbolsPatternSymbolsResolver
+import com.intellij.polySymbols.query.PolySymbolsScope
+import com.intellij.util.containers.Stack

 internal class StaticPattern(val content: String) : PolySymbolsPattern() {
  override fun getStaticPrefixes(): Sequence<String> = sequenceOf(content)

-  override fun match(owner: PolySymbol?,
-                     scopeStack: Stack<PolySymbolsScope>,
-                     symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                     params: MatchParameters,
-                     start: Int,
-                     end: Int): List<MatchResult> =
+  override fun match(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: MatchParameters,
+    start: Int,
+    end: Int,
+  ): List<MatchResult> =
    if (content.length <= end - start && params.name.startsWith(content, start))
      listOf(MatchResult(PolySymbolNameSegment.create(start, start + content.length)))
    else emptyList()

-  override fun list(owner: PolySymbol?,
-                    scopeStack: Stack<PolySymbolsScope>,
-                    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                    params: ListParameters): List<ListResult> =
+  override fun list(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: ListParameters,
+  ): List<ListResult> =
    listOf(ListResult(content, PolySymbolNameSegment.create(0, content.length)))

-  override fun complete(owner: PolySymbol?,
-                        scopeStack: Stack<PolySymbolsScope>,
-                        symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                        params: CompletionParameters,
-                        start: Int,
-                        end: Int): CompletionResults =
+  override fun complete(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: CompletionParameters,
+    start: Int,
+    end: Int,
+  ): CompletionResults =
    CompletionResults(PolySymbolCodeCompletionItem.create(content, start))

  override fun toString(): String =
@@ -2,19 +2,19 @@
 package com.intellij.polySymbols.patterns.impl

 import com.intellij.openapi.progress.ProgressManager
-import com.intellij.util.applyIf
-import com.intellij.util.containers.Stack
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolNameSegment
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.impl.selectBest
 import com.intellij.polySymbols.impl.withDisplayName
 import com.intellij.polySymbols.impl.withOffset
 import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.patterns.PolySymbolsPatternSymbolsResolver
 import com.intellij.polySymbols.query.PolySymbolMatch
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.utils.lastPolySymbol
 import com.intellij.polySymbols.utils.nameSegments
+import com.intellij.util.applyIf
+import com.intellij.util.containers.Stack
 import kotlin.math.max

 internal class SymbolReferencePattern(val displayName: String?) : PolySymbolsPattern() {
@@ -22,12 +22,14 @@ internal class SymbolReferencePattern(val displayName: String?) : PolySymbolsPat

  override fun isStaticAndRequired(): Boolean = false

-  override fun match(owner: PolySymbol?,
-                     scopeStack: Stack<PolySymbolsScope>,
-                     symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                     params: MatchParameters,
-                     start: Int,
-                     end: Int): List<MatchResult> {
+  override fun match(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: MatchParameters,
+    start: Int,
+    end: Int,
+  ): List<MatchResult> {
    if (start == end) {
      // TODO should be "missing required part", but needs improvements in sequence pattern code completion
      return listOf(MatchResult(listOf(PolySymbolNameSegment.create(
@@ -67,10 +69,12 @@ internal class SymbolReferencePattern(val displayName: String?) : PolySymbolsPat
    ))
  }

-  override fun list(owner: PolySymbol?,
-                    scopeStack: Stack<PolySymbolsScope>,
-                    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                    params: ListParameters): List<ListResult> =
+  override fun list(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: ListParameters,
+  ): List<ListResult> =
    symbolsResolver
      ?.listSymbols(scopeStack, params.queryExecutor, params.expandPatterns)
      ?.groupBy { it.name }
@@ -92,12 +96,14 @@ internal class SymbolReferencePattern(val displayName: String?) : PolySymbolsPat
      }
    ?: emptyList()

-  override fun complete(owner: PolySymbol?,
-                        scopeStack: Stack<PolySymbolsScope>,
-                        symbolsResolver: PolySymbolsPatternSymbolsResolver?,
-                        params: CompletionParameters,
-                        start: Int,
-                        end: Int): CompletionResults =
+  override fun complete(
+    owner: PolySymbol?,
+    scopeStack: Stack<PolySymbolsScope>,
+    symbolsResolver: PolySymbolsPatternSymbolsResolver?,
+    params: CompletionParameters,
+    start: Int,
+    end: Int,
+  ): CompletionResults =
    symbolsResolver
      ?.codeCompletion(params.name.substring(start, end), max(params.position - start, 0), scopeStack, params.queryExecutor)
      ?.let { results ->
@@ -2,12 +2,11 @@
 package com.intellij.polySymbols.query

 import com.intellij.model.Pointer
-import com.intellij.util.containers.Stack
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolQualifiedKind
 import com.intellij.polySymbols.PolySymbolQualifiedName
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
+import com.intellij.util.containers.Stack

 /**
 * A special purpose scope, which provides other scopes, possibly calling a [PolySymbolsQueryExecutor] to retrieve them.
@@ -18,8 +17,10 @@ import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 */
 abstract class PolySymbolsCompoundScope : PolySymbolsScope {

-  protected abstract fun build(queryExecutor: PolySymbolsQueryExecutor,
-                               consumer: (PolySymbolsScope) -> Unit)
+  protected abstract fun build(
+    queryExecutor: PolySymbolsQueryExecutor,
+    consumer: (PolySymbolsScope) -> Unit,
+  )

  fun getScopes(queryExecutor: PolySymbolsQueryExecutor): List<PolySymbolsScope> {
    if (requiresResolve() && !queryExecutor.allowResolve) return emptyList()
@@ -37,19 +38,25 @@ abstract class PolySymbolsCompoundScope : PolySymbolsScope {

  protected open fun requiresResolve(): Boolean = true

-  final override fun getMatchingSymbols(qualifiedName: PolySymbolQualifiedName,
-                                        params: PolySymbolsNameMatchQueryParams,
-                                        scope: Stack<PolySymbolsScope>): List<PolySymbol> =
+  final override fun getMatchingSymbols(
+    qualifiedName: PolySymbolQualifiedName,
+    params: PolySymbolsNameMatchQueryParams,
+    scope: Stack<PolySymbolsScope>,
+  ): List<PolySymbol> =
    throw UnsupportedOperationException("PolySymbolsCompoundScope must be queried through PolySymbolQueryExecutor.")

-  final override fun getSymbols(qualifiedKind: PolySymbolQualifiedKind,
-                                params: PolySymbolsListSymbolsQueryParams,
-                                scope: Stack<PolySymbolsScope>): List<PolySymbolsScope> =
+  final override fun getSymbols(
+    qualifiedKind: PolySymbolQualifiedKind,
+    params: PolySymbolsListSymbolsQueryParams,
+    scope: Stack<PolySymbolsScope>,
+  ): List<PolySymbol> =
    throw UnsupportedOperationException("PolySymbolsCompoundScope must be queried through PolySymbolQueryExecutor.")

-  final override fun getCodeCompletions(qualifiedName: PolySymbolQualifiedName,
-                                        params: PolySymbolsCodeCompletionQueryParams,
-                                        scope: Stack<PolySymbolsScope>): List<PolySymbolCodeCompletionItem> =
+  final override fun getCodeCompletions(
+    qualifiedName: PolySymbolQualifiedName,
+    params: PolySymbolsCodeCompletionQueryParams,
+    scope: Stack<PolySymbolsScope>,
+  ): List<PolySymbolCodeCompletionItem> =
    throw UnsupportedOperationException("PolySymbolsCompoundScope must be queried through PolySymbolQueryExecutor.")

  final override fun isExclusiveFor(qualifiedKind: PolySymbolQualifiedKind): Boolean =
@@ -4,10 +4,9 @@ package com.intellij.polySymbols.query
 import com.intellij.openapi.extensions.ExtensionPointName
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.psi.PsiElement
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.context.PolyContext
 import com.intellij.polySymbols.context.PolyContextRulesProvider
+import com.intellij.psi.PsiElement
 import org.jetbrains.annotations.ApiStatus.Internal
 import org.jetbrains.annotations.TestOnly

@@ -19,9 +18,11 @@ interface PolySymbolsQueryConfigurator {
  fun getContextRulesProviders(project: Project, dir: VirtualFile): List<PolyContextRulesProvider> =
    emptyList()

-  fun getNameConversionRulesProviders(project: Project,
-                                      element: PsiElement?,
-                                      context: PolyContext): List<PolySymbolNameConversionRulesProvider> =
+  fun getNameConversionRulesProviders(
+    project: Project,
+    element: PsiElement?,
+    context: PolyContext,
+  ): List<PolySymbolNameConversionRulesProvider> =
    emptyList()

  fun beforeQueryExecutorCreation(project: Project) {
@@ -5,11 +5,10 @@ import com.intellij.openapi.Disposable
 import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.psi.PsiElement
 import com.intellij.polySymbols.PolyContextKind
 import com.intellij.polySymbols.PolyContextName
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.query.impl.PolySymbolsQueryExecutorBuilderImpl
+import com.intellij.psi.PsiElement
 import org.jetbrains.annotations.TestOnly

 /**
@@ -1,15 +1,14 @@
-// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
-package com.intellij.polySymbols
+// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package com.intellij.polySymbols.query

 import com.intellij.model.Pointer
 import com.intellij.openapi.util.ModificationTracker
+import com.intellij.polySymbols.PolySymbol
+import com.intellij.polySymbols.PolySymbolQualifiedKind
+import com.intellij.polySymbols.PolySymbolQualifiedName
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
-import com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams
-import com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams
-import com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams
 import com.intellij.polySymbols.utils.getDefaultCodeCompletions
 import com.intellij.polySymbols.utils.match
-import com.intellij.polySymbols.utils.toCodeCompletionItems
 import com.intellij.util.containers.Stack

 /**
@@ -34,7 +33,7 @@ interface PolySymbolsScope : ModificationTracker {

  /**
   * Returns symbols within the scope, which matches provided namespace, kind and name.
-   * Use [PolySymbol.match] to match Poly Symbols in the scope against provided name.
+   * Use [match] to match Poly Symbols in the scope against provided name.
   *
   * If the scope contains many symbols, or results should be cached consider extending [com.intellij.polySymbols.utils.PolySymbolsScopeWithCache].
   *
@@ -50,7 +49,6 @@ interface PolySymbolsScope : ModificationTracker {
                 strictScope(params.strictScope)
                 copyFiltersFrom(params)
               }, scope)
-      .filterIsInstance<PolySymbol>()
      .flatMap { it.match(qualifiedName.name, params, scope) }

  /**
@@ -63,17 +61,17 @@ interface PolySymbolsScope : ModificationTracker {
    qualifiedKind: PolySymbolQualifiedKind,
    params: PolySymbolsListSymbolsQueryParams,
    scope: Stack<PolySymbolsScope>,
-  ): List<PolySymbolsScope> =
+  ): List<PolySymbol> =
    emptyList()

  /**
   * Returns code completions for symbols within the scope.
   *
-   * Use [PolySymbol.toCodeCompletionItems] to create code completions from `PolySymbol`s in the scope.
+   * Use [com.intellij.polySymbols.utils.toCodeCompletionItems] to create code completions from `PolySymbol`s in the scope.
   *
   * If the scope contains many symbols, or results should be cached consider extending [com.intellij.polySymbols.utils.PolySymbolsScopeWithCache].
   *
-   * Default implementation calls `getSymbols` and runs [PolySymbol.toCodeCompletionItems] on each symbol.
+   * Default implementation calls `getSymbols` and runs [com.intellij.polySymbols.utils.toCodeCompletionItems] on each symbol.
   */
  fun getCodeCompletions(
    qualifiedName: PolySymbolQualifiedName,
@@ -14,6 +14,7 @@ import com.intellij.polySymbols.documentation.PolySymbolWithDocumentation
 import com.intellij.polySymbols.documentation.impl.PolySymbolDocumentationTargetImpl
 import com.intellij.polySymbols.query.PolySymbolMatch
 import com.intellij.polySymbols.query.PolySymbolMatchBuilder
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.refactoring.PolySymbolRenameTarget
 import com.intellij.polySymbols.search.PolySymbolSearchTarget
 import com.intellij.polySymbols.search.PsiSourcedPolySymbol
@@ -4,13 +4,13 @@ package com.intellij.polySymbols.query.impl
 import com.intellij.openapi.util.ModificationTracker
 import com.intellij.polySymbols.PolyContextKind
 import com.intellij.polySymbols.PolyContextName
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.context.PolyContext.Companion.KIND_FRAMEWORK
 import com.intellij.polySymbols.context.impl.PolyContextImpl
 import com.intellij.polySymbols.query.PolySymbolNameConversionRules
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory.PolySymbolsQueryExecutorBuilder
 import com.intellij.polySymbols.query.PolySymbolsQueryResultsCustomizer
+import com.intellij.polySymbols.query.PolySymbolsScope

 class PolySymbolsQueryExecutorBuilderImpl() : PolySymbolsQueryExecutorBuilder {
  private val rootScopes = mutableListOf<PolySymbolsScope>()
@@ -10,20 +10,19 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.ModificationTracker
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.psi.PsiElement
-import com.intellij.util.asSafely
-import com.intellij.util.containers.MultiMap
 import com.intellij.polySymbols.PolyContextKind
 import com.intellij.polySymbols.PolySymbol
-import com.intellij.polySymbols.utils.PolySymbolsPrioritizedScope
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.context.PolyContext
 import com.intellij.polySymbols.context.PolyContextKindRules
 import com.intellij.polySymbols.context.PolyContextRulesProvider
 import com.intellij.polySymbols.context.impl.buildPolyContext
 import com.intellij.polySymbols.query.*
+import com.intellij.polySymbols.utils.PolySymbolsPrioritizedScope
 import com.intellij.polySymbols.utils.createModificationTracker
 import com.intellij.polySymbols.utils.findOriginalFile
+import com.intellij.psi.PsiElement
+import com.intellij.util.asSafely
+import com.intellij.util.containers.MultiMap

 class PolySymbolsQueryExecutorFactoryImpl(private val project: Project) : PolySymbolsQueryExecutorFactory, Disposable {

@@ -71,9 +70,11 @@ class PolySymbolsQueryExecutorFactoryImpl(private val project: Project) : PolySy
                                        allowResolve)
  }

-  override fun addScope(scope: PolySymbolsScope,
-                        contextDirectory: VirtualFile?,
-                        disposable: Disposable) {
+  override fun addScope(
+    scope: PolySymbolsScope,
+    contextDirectory: VirtualFile?,
+    disposable: Disposable,
+  ) {
    ApplicationManager.getApplication().assertWriteAccessAllowed()
    modificationCount++
    customScope.putValue(contextDirectory, scope)
@@ -85,8 +86,10 @@ class PolySymbolsQueryExecutorFactoryImpl(private val project: Project) : PolySy
  override fun dispose() {
  }

-  internal fun getContextRules(project: Project,
-                               dir: VirtualFile): Pair<MultiMap<PolyContextKind, PolyContextKindRules>, ModificationTracker> {
+  internal fun getContextRules(
+    project: Project,
+    dir: VirtualFile,
+  ): Pair<MultiMap<PolyContextKind, PolyContextKindRules>, ModificationTracker> {
    val result = MultiMap<PolyContextKind, PolyContextKindRules>()

    getCustomScope(dir)
@@ -6,7 +6,10 @@ import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.diagnostic.thisLogger
 import com.intellij.openapi.progress.ProgressManager
 import com.intellij.openapi.util.RecursionManager
-import com.intellij.polySymbols.*
+import com.intellij.polySymbols.PolySymbol
+import com.intellij.polySymbols.PolySymbolModifier
+import com.intellij.polySymbols.PolySymbolQualifiedKind
+import com.intellij.polySymbols.PolySymbolQualifiedName
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.context.PolyContext
 import com.intellij.polySymbols.impl.filterByQueryParams
@@ -22,7 +25,6 @@ import com.intellij.util.asSafely
 import com.intellij.util.concurrency.annotations.RequiresReadLock
 import com.intellij.util.containers.Stack
 import org.jetbrains.annotations.ApiStatus
-import java.util.*
 import kotlin.math.max
 import kotlin.math.min

@@ -462,7 +464,8 @@ class PolySymbolsQueryExecutorImpl(
    params: PolySymbolsListSymbolsQueryParams,
  ): List<PolySymbol> =
    pattern?.let { pattern ->
-      context.push(this)
+      val additionalScope = this.queryScope
+      additionalScope.forEach { context.push(it) }
      try {
        return pattern
          .list(this, context, params)
@@ -471,7 +474,7 @@ class PolySymbolsQueryExecutorImpl(
          }
      }
      finally {
-        context.pop()
+        additionalScope.forEach { _ -> context.pop() }
      }
    } ?: listOf(this)

@@ -483,12 +486,13 @@ class PolySymbolsQueryExecutorImpl(
      resultsCustomizer.apply(this, strict, qualifiedName)
    }

-  private val PolySymbolsQueryParams.recursionKey: List<Any> get() {
-    val result = SmartList<Any>()
-    result.add(requiredModifiers)
-    result.add(excludeModifiers)
-    result.add(excludeAccessModifiers)
-    requiredAccessModifier?.let { result.add(it) }
-    return result
-  }
+  private val PolySymbolsQueryParams.recursionKey: List<Any>
+    get() {
+      val result = SmartList<Any>()
+      result.add(requiredModifiers)
+      result.add(excludeModifiers)
+      result.add(excludeAccessModifiers)
+      requiredAccessModifier?.let { result.add(it) }
+      return result
+    }
 }
@@ -2,6 +2,7 @@
 package com.intellij.polySymbols.utils

 import com.intellij.find.usages.api.SearchTarget
+import com.intellij.model.Pointer
 import com.intellij.navigation.NavigatableSymbol
 import com.intellij.openapi.project.Project
 import com.intellij.platform.backend.documentation.DocumentationTarget
@@ -12,6 +13,7 @@ import com.intellij.polySymbols.patterns.PolySymbolsPattern
 import com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams
 import com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams
 import com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.refactoring.PolySymbolRenameTarget
 import com.intellij.polySymbols.refactoring.impl.PolySymbolDelegatedRenameTargetImpl
 import com.intellij.polySymbols.search.PolySymbolSearchTarget
@@ -21,7 +23,7 @@ import com.intellij.refactoring.rename.api.RenameTarget
 import com.intellij.util.containers.Stack
 import javax.swing.Icon

-interface PolySymbolDelegate<T : PolySymbol> : PolySymbol {
+interface PolySymbolDelegate<T : PolySymbol> : PolySymbol, PolySymbolsScope {

  val delegate: T

@@ -31,10 +33,6 @@ interface PolySymbolDelegate<T : PolySymbol> : PolySymbol {
    get() = delegate.origin
  override val qualifiedKind: PolySymbolQualifiedKind
    get() = delegate.qualifiedKind
-
-  override fun getModificationCount(): Long =
-    delegate.modificationCount
-
  override val queryScope: List<PolySymbolsScope>
    get() = delegate.queryScope
  override val name: String
@@ -70,25 +68,28 @@ interface PolySymbolDelegate<T : PolySymbol> : PolySymbol {
    params: PolySymbolsNameMatchQueryParams,
    scope: Stack<PolySymbolsScope>,
  ): List<PolySymbol> =
-    delegate.getMatchingSymbols(qualifiedName, params, scope)
-
+    (delegate as? PolySymbolsScope)?.getMatchingSymbols(qualifiedName, params, scope)
+    ?: emptyList()

  override fun getSymbols(
    qualifiedKind: PolySymbolQualifiedKind,
    params: PolySymbolsListSymbolsQueryParams,
    scope: Stack<PolySymbolsScope>,
-  ): List<PolySymbolsScope> =
-    delegate.getSymbols(qualifiedKind, params, scope)
+  ): List<PolySymbol> =
+    (delegate as? PolySymbolsScope)?.getSymbols(qualifiedKind, params, scope)
+    ?: emptyList()

  override fun getCodeCompletions(
    qualifiedName: PolySymbolQualifiedName,
    params: PolySymbolsCodeCompletionQueryParams,
    scope: Stack<PolySymbolsScope>,
  ): List<PolySymbolCodeCompletionItem> =
-    delegate.getCodeCompletions(qualifiedName, params, scope)
+    (delegate as? PolySymbolsScope)?.getCodeCompletions(qualifiedName, params, scope)
+    ?: emptyList()

  override fun isExclusiveFor(qualifiedKind: PolySymbolQualifiedKind): Boolean =
-    delegate.isExclusiveFor(qualifiedKind)
+    (delegate as? PolySymbolsScope)?.isExclusiveFor(qualifiedKind)
+    ?: false

  override val searchTarget: PolySymbolSearchTarget?
    get() = when (delegate) {
@@ -102,6 +103,11 @@ interface PolySymbolDelegate<T : PolySymbol> : PolySymbol {
      else -> delegate.renameTarget
    }

+  override fun createPointer(): Pointer<out PolySymbolDelegate<T>>
+
+  override fun getModificationCount(): Long =
+    (delegate as? PolySymbolsScope)?.modificationCount ?: 0
+
  companion object {

    @JvmStatic
@@ -1,6 +1,7 @@
 // Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.utils

+import com.intellij.model.Pointer
 import com.intellij.platform.backend.documentation.DocumentationTarget
 import com.intellij.polySymbols.documentation.PolySymbolDocumentation
 import com.intellij.polySymbols.documentation.PolySymbolWithDocumentation
@@ -23,4 +24,6 @@ interface PolySymbolDelegateWithDocumentation<T : PolySymbolWithDocumentation> :
  override fun getDocumentationTarget(location: PsiElement?): DocumentationTarget? =
    delegate.getDocumentationTarget(location)

+  override fun createPointer(): Pointer<out PolySymbolDelegateWithDocumentation<T>>
+
 }
@@ -86,7 +86,7 @@ fun PolySymbol.withMatchedKind(qualifiedKind: PolySymbolQualifiedKind): PolySymb
  }
  else this

-fun PolySymbol.withNavigationTarget(target: PsiElement): PolySymbol =
+fun PolySymbol.withNavigationTarget(target: PsiElement): PolySymbolDelegate<PolySymbol> =
  object : PolySymbolDelegate<PolySymbol> {
    override val delegate: PolySymbol
      get() = this@withNavigationTarget
@@ -94,7 +94,7 @@ fun PolySymbol.withNavigationTarget(target: PsiElement): PolySymbol =
    override fun getNavigationTargets(project: Project): Collection<NavigationTarget> =
      listOf(SymbolNavigationService.getInstance().psiElementNavigationTarget(target))

-    override fun createPointer(): Pointer<out PolySymbol> {
+    override fun createPointer(): Pointer<out PolySymbolDelegate<PolySymbol>> {
      val symbolPtr = delegate.createPointer()
      val targetPtr = target.createSmartPointer()
      return Pointer {
@@ -153,7 +153,8 @@ fun PolySymbol.match(
  context: Stack<PolySymbolsScope>,
 ): List<PolySymbol> {
  pattern?.let { pattern ->
-    context.push(this)
+    val additionalScope = this.queryScope
+    additionalScope.forEach { context.push(it) }
    try {
      return pattern
        .match(this, context, nameToMatch, params)
@@ -167,7 +168,7 @@ fun PolySymbol.match(
        }
    }
    finally {
-      context.pop()
+      additionalScope.forEach { _ -> context.pop() }
    }
  }

@@ -185,13 +186,14 @@ fun PolySymbol.toCodeCompletionItems(
  context: Stack<PolySymbolsScope>,
 ): List<PolySymbolCodeCompletionItem> =
  pattern?.let { pattern ->
-    context.push(this)
+    val additionalScope = this.queryScope
+    additionalScope.forEach { context.push(it) }
    try {
      pattern.complete(this, context, name, params)
        .applyIcons(this)
    }
    finally {
-      context.pop()
+      additionalScope.forEach { _ -> context.pop() }
    }
  }
  ?: params.queryExecutor.namesProvider
@@ -64,7 +64,7 @@ abstract class PolySymbolsIsolatedMappingScope<T : PsiElement>(
    return result
  }

-  override fun getSymbols(qualifiedKind: PolySymbolQualifiedKind, params: PolySymbolsListSymbolsQueryParams, scope: Stack<PolySymbolsScope>): List<PolySymbolsScope> {
+  override fun getSymbols(qualifiedKind: PolySymbolQualifiedKind, params: PolySymbolsListSymbolsQueryParams, scope: Stack<PolySymbolsScope>): List<PolySymbol> {
    if (!params.queryExecutor.allowResolve || (framework != null && params.framework != framework))
      return emptyList()
    val sourceKind = mappings[qualifiedKind] ?: return emptyList()
@@ -9,15 +9,9 @@ import com.intellij.polySymbols.FrameworkId
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolQualifiedKind
 import com.intellij.polySymbols.PolySymbolQualifiedName
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
-import com.intellij.polySymbols.query.PolySymbolNamesProvider
-import com.intellij.polySymbols.query.PolySymbolsCodeCompletionQueryParams
-import com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams
-import com.intellij.polySymbols.query.PolySymbolsNameMatchQueryParams
-import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
-import com.intellij.polySymbols.query.PolySymbolsQueryParams
 import com.intellij.polySymbols.impl.SearchMap
+import com.intellij.polySymbols.query.*
 import com.intellij.psi.util.CachedValue
 import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
@@ -28,7 +22,7 @@ import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentMap

 /**
- * Used when implementing a [com.intellij.polySymbols.PolySymbolsScope], which contains many elements.
+ * Used when implementing a [PolySymbolsScope], which contains many elements.
 *
 * Caches the list of symbols and uses efficient cache to speed up queries. When extending the class,
 * you only need to override the initialize method and provide parameters to the super constructor to specify how results should be cached.
@@ -142,7 +136,7 @@ abstract class PolySymbolsScopeWithCache<T : UserDataHolder, K>(
    qualifiedKind: PolySymbolQualifiedKind,
    params: PolySymbolsListSymbolsQueryParams,
    scope: Stack<PolySymbolsScope>,
-  ): List<PolySymbolsScope> =
+  ): List<PolySymbol> =
    if ((params.queryExecutor.allowResolve || !requiresResolve)
        && (framework == null || params.framework == framework)
        && provides(qualifiedKind)) {
@@ -2,6 +2,12 @@ package com.intellij.polySymbols.utils

 import com.intellij.model.Pointer
 import com.intellij.openapi.util.TextRange
+import com.intellij.polySymbols.PolySymbol
+import com.intellij.polySymbols.PolySymbolQualifiedKind
+import com.intellij.polySymbols.query.PolySymbolsCompoundScope
+import com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams
+import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.util.CachedValueProvider
@@ -10,12 +16,6 @@ import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.SmartList
 import com.intellij.util.containers.Stack
 import com.intellij.util.takeWhileInclusive
-import com.intellij.polySymbols.PolySymbol
-import com.intellij.polySymbols.PolySymbolQualifiedKind
-import com.intellij.polySymbols.PolySymbolsScope
-import com.intellij.polySymbols.query.PolySymbolsCompoundScope
-import com.intellij.polySymbols.query.PolySymbolsListSymbolsQueryParams
-import com.intellij.polySymbols.query.PolySymbolsQueryExecutor

 abstract class PolySymbolsStructuredScope<T : PsiElement, R : PsiElement>(protected val location: T) : PolySymbolsCompoundScope() {

@@ -200,7 +200,7 @@ abstract class PolySymbolsStructuredScope<T : PsiElement, R : PsiElement>(protec
      qualifiedKind: PolySymbolQualifiedKind,
      params: PolySymbolsListSymbolsQueryParams,
      scope: Stack<PolySymbolsScope>,
-    ): List<PolySymbolsScope> =
+    ): List<PolySymbol> =
      getAllSymbols(qualifiedKind)

    override fun getAllSymbols(qualifiedKind: PolySymbolQualifiedKind): List<PolySymbol> =
@@ -1,6 +1,7 @@
 // Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.polySymbols.utils

+import com.intellij.model.Pointer
 import com.intellij.openapi.project.Project
 import com.intellij.platform.backend.navigation.NavigationTarget
 import com.intellij.polySymbols.search.PsiSourcedPolySymbol
@@ -17,4 +18,6 @@ interface PsiSourcedPolySymbolDelegate<T : PsiSourcedPolySymbol> : PolySymbolDel
  override fun getNavigationTargets(project: Project): Collection<NavigationTarget> =
    delegate.getNavigationTargets(project)

+  override fun createPointer(): Pointer<out PsiSourcedPolySymbolDelegate<T>>
+
 }
@@ -2,16 +2,16 @@ package com.intellij.polySymbols.query.impl

 import com.intellij.openapi.Disposable
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.psi.PsiElement
 import com.intellij.polySymbols.PolyContextKind
 import com.intellij.polySymbols.PolyContextName
-import com.intellij.polySymbols.PolySymbolsScope
 import com.intellij.polySymbols.context.PolyContext
 import com.intellij.polySymbols.context.PolyContext.Companion.KIND_FRAMEWORK
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutor
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory
 import com.intellij.polySymbols.query.PolySymbolsQueryResultsCustomizerFactory
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.utils.createModificationTracker
+import com.intellij.psi.PsiElement

 class PolySymbolsMockQueryExecutorFactory : PolySymbolsQueryExecutorFactory {

@@ -22,14 +22,14 @@ class PolySymbolsMockQueryExecutorFactory : PolySymbolsQueryExecutorFactory {
  override fun create(location: PsiElement?, allowResolve: Boolean): PolySymbolsQueryExecutor =
    PolySymbolsQueryExecutorImpl(location, scopeList,
                                 PolySymbolNamesProviderImpl(
-                                  context[KIND_FRAMEWORK],
-                                  context[KIND_FRAMEWORK]?.let { framework ->
-                                    scopeList.filterIsInstance<WebTypesMockScopeImpl>().map {
-                                      it.getNameConversionRulesProvider(framework).getNameConversionRules()
-                                    }
-                                  } ?: emptyList(),
-                                  createModificationTracker(
-                                    scopeList.filterIsInstance<WebTypesMockScopeImpl>().map { it.createPointer() })),
+                                   context[KIND_FRAMEWORK],
+                                   context[KIND_FRAMEWORK]?.let { framework ->
+                                     scopeList.filterIsInstance<WebTypesMockScopeImpl>().map {
+                                       it.getNameConversionRulesProvider(framework).getNameConversionRules()
+                                     }
+                                   } ?: emptyList(),
+                                   createModificationTracker(
+                                     scopeList.filterIsInstance<WebTypesMockScopeImpl>().map { it.createPointer() })),
                                 PolySymbolsQueryResultsCustomizerFactory.getQueryResultsCustomizer(location, PolyContext.create(context)),
                                 PolyContext.create(context),
                                 allowResolve)
@@ -20,6 +20,7 @@ import com.intellij.polySymbols.utils.match
 import com.intellij.psi.PsiElement
 import com.intellij.psi.SmartPointerManager
 import com.intellij.psi.createSmartPointer
+import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.psi.util.parentOfType
 import com.intellij.psi.util.parentOfTypes
 import com.intellij.psi.xml.XmlAttribute
@@ -64,21 +65,28 @@ class PolySymbolsHtmlQueryConfigurator : PolySymbolsQueryConfigurator {
    override fun build(queryExecutor: PolySymbolsQueryExecutor, consumer: (PolySymbolsScope) -> Unit) {
      val context = location.parentOfTypes(XmlTag::class, XmlAttribute::class)
      val element = (context as? XmlTag) ?: (context as? XmlAttribute)?.parent ?: return
-      val elementScope = element.takeIf { queryExecutor.allowResolve }
-                           ?.descriptor?.asSafely<PolySymbolElementDescriptor>()?.symbol?.let { listOf(it) }
-                         ?: queryExecutor.nameMatchQuery(HTML_ELEMENTS, element.name)
-                           .exclude(PolySymbolModifier.ABSTRACT)
-                           .run()
+      val elementScope =
+        element.takeIf { queryExecutor.allowResolve }
+          ?.descriptor?.asSafely<PolySymbolElementDescriptor>()?.symbol?.queryScope
+        ?: queryExecutor.nameMatchQuery(HTML_ELEMENTS, element.name)
+          .exclude(PolySymbolModifier.ABSTRACT)
+          .run()
+          .flatMap { it.queryScope }

      elementScope.forEach(consumer)

      val attribute = context as? XmlAttribute ?: return
      attribute.takeIf { queryExecutor.allowResolve }
-        ?.descriptor?.asSafely<PolySymbolAttributeDescriptor>()?.symbol?.let(consumer)
+        ?.descriptor
+        ?.asSafely<PolySymbolAttributeDescriptor>()
+        ?.symbol
+        ?.queryScope
+        ?.forEach(consumer)
      ?: queryExecutor.nameMatchQuery(HTML_ATTRIBUTES, attribute.name)
        .additionalScope(elementScope)
        .exclude(PolySymbolModifier.ABSTRACT)
        .run()
+        .flatMap { it.queryScope }
        .forEach(consumer)
    }

@@ -134,7 +142,7 @@ class PolySymbolsHtmlQueryConfigurator : PolySymbolsQueryConfigurator {
      qualifiedKind: PolySymbolQualifiedKind,
      params: PolySymbolsListSymbolsQueryParams,
      scope: Stack<PolySymbolsScope>,
-    ): List<PolySymbolsScope> =
+    ): List<PolySymbol> =
      if (params.queryExecutor.allowResolve) {
        when (qualifiedKind) {
          HTML_ELEMENTS ->
@@ -186,7 +194,9 @@ class PolySymbolsHtmlQueryConfigurator : PolySymbolsQueryConfigurator {
    }
  }

-  abstract class StandardHtmlSymbol : MdnDocumentedSymbol(), PsiSourcedPolySymbol {
+  abstract class StandardHtmlSymbol : MdnDocumentedSymbol(), PsiSourcedPolySymbol, PolySymbolsScope {
+    abstract val project: Project?
+    override fun getModificationCount(): Long = project?.let { PsiModificationTracker.getInstance(it).modificationCount } ?: 0
    abstract override fun createPointer(): Pointer<out StandardHtmlSymbol>
  }

@@ -195,6 +205,9 @@ class PolySymbolsHtmlQueryConfigurator : PolySymbolsQueryConfigurator {
    private val tag: XmlTag?,
  ) : PolySymbol, StandardHtmlSymbol() {

+    override val project: Project?
+      get() = tag?.project ?: descriptor.declaration?.project
+
    override fun getMdnDocumentation(): MdnSymbolDocumentation? =
      getHtmlMdnTagDocumentation(getHtmlApiNamespace(descriptor.nsDescriptor?.name, tag, name),
                                 name)
@@ -249,6 +262,9 @@ class PolySymbolsHtmlQueryConfigurator : PolySymbolsQueryConfigurator {
      getHtmlMdnAttributeDocumentation(getHtmlApiNamespace(tag?.namespace, tag, tagName),
                                       tagName, name)

+    override val project: Project?
+      get() = tag?.project ?: descriptor.declaration?.project
+
    override val qualifiedKind: PolySymbolQualifiedKind
      get() = HTML_ATTRIBUTES

@@ -295,7 +311,7 @@ class PolySymbolsHtmlQueryConfigurator : PolySymbolsQueryConfigurator {
      qualifiedKind: PolySymbolQualifiedKind,
      params: PolySymbolsListSymbolsQueryParams,
      scope: Stack<PolySymbolsScope>,
-    ): List<PolySymbolsScope> =
+    ): List<PolySymbol> =
      if (qualifiedKind == HTML_ATTRIBUTE_VALUES && descriptor.isEnumerated)
        descriptor.enumeratedValues?.map { HtmlAttributeValueSymbol(it) } ?: emptyList()
      else
@@ -328,11 +344,14 @@ class PolySymbolsHtmlQueryConfigurator : PolySymbolsQueryConfigurator {

  }

-  private class HtmlEventDescriptorBasedSymbol(descriptor: XmlAttributeDescriptor) : PolySymbol, StandardHtmlSymbol() {
+  private class HtmlEventDescriptorBasedSymbol(private val descriptor: XmlAttributeDescriptor) : PolySymbol, StandardHtmlSymbol() {

    override fun getMdnDocumentation(): MdnSymbolDocumentation? =
      getDomEventDocumentation(name)

+    override val project: Project?
+      get() = descriptor.declaration?.project
+
    override val qualifiedKind: PolySymbolQualifiedKind
      get() = JS_EVENTS

@@ -7,11 +7,11 @@ import com.intellij.model.Pointer
 import com.intellij.model.Pointer.hardPointer
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.ModificationTracker
-import com.intellij.polySymbols.html.HTML_ATTRIBUTES
-import com.intellij.polySymbols.html.HTML_ELEMENTS
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolQualifiedKind
-import com.intellij.polySymbols.PolySymbolsScope
+import com.intellij.polySymbols.html.HTML_ATTRIBUTES
+import com.intellij.polySymbols.html.HTML_ELEMENTS
+import com.intellij.polySymbols.query.PolySymbolsScope
 import com.intellij.polySymbols.utils.PolySymbolsScopeWithCache
 import org.jetbrains.annotations.ApiStatus

@@ -111,7 +111,7 @@ internal data class PolySymbolHtmlAttributeInfoImpl(
            val valuesSymbols = queryExecutor.codeCompletionQuery(
              HTML_ATTRIBUTE_VALUES, "", 0)
              .exclude(PolySymbolModifier.VIRTUAL, PolySymbolModifier.ABSTRACT)
-              .additionalScope(symbol)
+              .additionalScope(symbol.queryScope)
              .run()
            typeSupport.createEnumType(symbol, valuesSymbols)
          }
@@ -141,7 +141,7 @@ internal data class PolySymbolHtmlAttributeInfoImpl(
            PolySymbolHtmlAttributeValue.Type.ENUM -> {
              queryExecutor.codeCompletionQuery(HTML_ATTRIBUTE_VALUES, "", 0)
                .exclude(PolySymbolModifier.ABSTRACT)
-                .additionalScope(symbol)
+                .additionalScope(symbol.queryScope)
                .run()
                .filter { !it.completeAfterInsert }
            }
@@ -7,13 +7,6 @@ import com.intellij.html.polySymbols.PolySymbolsFrameworkHtmlSupport
 import com.intellij.html.polySymbols.PolySymbolsHtmlQueryConfigurator.HtmlElementDescriptorBasedSymbol
 import com.intellij.html.polySymbols.PolySymbolsHtmlQueryConfigurator.StandardHtmlSymbol
 import com.intellij.html.polySymbols.hasOnlyStandardHtmlSymbolsOrExtensions
-import com.intellij.psi.PsiElement
-import com.intellij.psi.impl.source.html.dtd.HtmlNSDescriptorImpl
-import com.intellij.psi.impl.source.xml.XmlDescriptorUtil
-import com.intellij.psi.impl.source.xml.XmlDescriptorUtil.wrapInDelegating
-import com.intellij.psi.xml.XmlAttribute
-import com.intellij.psi.xml.XmlTag
-import com.intellij.util.asSafely
 import com.intellij.polySymbols.PolySymbol
 import com.intellij.polySymbols.PolySymbolModifier
 import com.intellij.polySymbols.PolySymbolQualifiedKind
@@ -21,15 +14,23 @@ import com.intellij.polySymbols.PolySymbolQualifiedName
 import com.intellij.polySymbols.completion.PolySymbolCodeCompletionItem
 import com.intellij.polySymbols.query.PolySymbolsQueryExecutorFactory
 import com.intellij.polySymbols.utils.nameSegments
+import com.intellij.psi.PsiElement
+import com.intellij.psi.impl.source.html.dtd.HtmlNSDescriptorImpl
+import com.intellij.psi.impl.source.xml.XmlDescriptorUtil
+import com.intellij.psi.impl.source.xml.XmlDescriptorUtil.wrapInDelegating
+import com.intellij.psi.xml.XmlAttribute
+import com.intellij.psi.xml.XmlTag
+import com.intellij.util.asSafely
 import com.intellij.xml.*
 import com.intellij.xml.impl.XmlElementDescriptorEx
 import com.intellij.xml.impl.schema.AnyXmlElementDescriptor
 import org.jetbrains.annotations.NonNls

-open class PolySymbolElementDescriptor private constructor(private val tag: XmlTag,
-                                                           private val name: String,
-                                                           val symbol: PolySymbol)
-  : XmlElementDescriptorEx, XmlElementDescriptorAwareAboutChildren, XmlCustomElementDescriptor {
+open class PolySymbolElementDescriptor private constructor(
+  private val tag: XmlTag,
+  private val name: String,
+  val symbol: PolySymbol,
+) : XmlElementDescriptorEx, XmlElementDescriptorAwareAboutChildren, XmlCustomElementDescriptor {

  constructor(info: PolySymbolHtmlElementInfo, tag: XmlTag) : this(tag, info.name, info.symbol)

@@ -37,41 +38,47 @@ open class PolySymbolElementDescriptor private constructor(private val tag: XmlT

  }

-  fun runNameMatchQuery(qualifiedName: PolySymbolQualifiedName,
-                        virtualSymbols: Boolean = true,
-                        abstractSymbols: Boolean = false,
-                        strictScope: Boolean = false): List<PolySymbol> =
+  fun runNameMatchQuery(
+    qualifiedName: PolySymbolQualifiedName,
+    virtualSymbols: Boolean = true,
+    abstractSymbols: Boolean = false,
+    strictScope: Boolean = false,
+  ): List<PolySymbol> =
    PolySymbolsQueryExecutorFactory.create(tag)
      .nameMatchQuery(listOf(qualifiedName)) {
        strictScope(strictScope)
        if (!virtualSymbols) exclude(PolySymbolModifier.VIRTUAL)
        if (!abstractSymbols) exclude(PolySymbolModifier.ABSTRACT)
-        additionalScope(symbol)
+        additionalScope(symbol.queryScope)
      }

-  fun runListSymbolsQuery(qualifiedKind: PolySymbolQualifiedKind,
-                          expandPatterns: Boolean,
-                          virtualSymbols: Boolean = true,
-                          abstractSymbols: Boolean = false,
-                          strictScope: Boolean = false): List<PolySymbol> =
+  fun runListSymbolsQuery(
+    qualifiedKind: PolySymbolQualifiedKind,
+    expandPatterns: Boolean,
+    virtualSymbols: Boolean = true,
+    abstractSymbols: Boolean = false,
+    strictScope: Boolean = false,
+  ): List<PolySymbol> =
    PolySymbolsQueryExecutorFactory.create(tag)
      .listSymbolsQuery(qualifiedKind, expandPatterns) {
        strictScope(strictScope)
        if (!virtualSymbols) exclude(PolySymbolModifier.VIRTUAL)
        if (!abstractSymbols) exclude(PolySymbolModifier.ABSTRACT)
-        additionalScope(symbol)
+        additionalScope(symbol.queryScope)
      }

-  fun runCodeCompletionQuery(qualifiedKind: PolySymbolQualifiedKind,
-                             name: String,
-                             /** Position to complete at in the last segment of the path **/
-                             position: Int,
-                             virtualSymbols: Boolean = true): List<PolySymbolCodeCompletionItem> =
+  fun runCodeCompletionQuery(
+    qualifiedKind: PolySymbolQualifiedKind,
+    name: String,
+    /** Position to complete at in the last segment of the path **/
+    position: Int,
+    virtualSymbols: Boolean = true,
+  ): List<PolySymbolCodeCompletionItem> =
    PolySymbolsQueryExecutorFactory.create(tag)
      .codeCompletionQuery(qualifiedKind, name, position) {
        if (!virtualSymbols) exclude(PolySymbolModifier.VIRTUAL)
        exclude(PolySymbolModifier.ABSTRACT)
-        additionalScope(symbol)
+        additionalScope(symbol.queryScope)
      }

  override fun getQualifiedName(): String {