IJPL-195201 Search Everywhere for RD: support basic semantic search contributors

Semantic search contributor checks for a special flag to allow scope auto-toggle trying first before providing any semantic results.

GitOrigin-RevId: 5785d414c01911b8fe44405bde6e69a865e6919e

platform/searchEverywhere/backend/src/providers/target/SeTargetsProviderDelegate.kt

@@ -43,16 +43,17 @@ class SeTargetsProviderDelegate(private val contributorWrapper: SeAsyncContribut
     val inputQuery = params.inputQuery
     val defaultMatchers = createDefaultMatchers(inputQuery)
 
-    val scopeToApply: String? = SeEverywhereFilter.isEverywhere(params.filter)?.let { isEverywhere ->
-      scopeProviderDelegate.searchScopesInfo.getValue()?.let { searchScopesInfo ->
+    SeEverywhereFilter.isEverywhere(params.filter)?.let { isEverywhere ->
+      val selectedScopeId = scopeProviderDelegate.searchScopesInfo.getValue()?.let { searchScopesInfo ->
         if (isEverywhere) searchScopesInfo.everywhereScopeId else searchScopesInfo.projectScopeId
-      }
+      } ?: return@let
+
+      scopeProviderDelegate.applyScope(selectedScopeId, false)
     } ?: run {
       val targetsFilter = SeTargetsFilter.from(params.filter)
       SeTypeVisibilityStateProviderDelegate.applyTypeVisibilityStates<T>(contributor, targetsFilter.hiddenTypes)
-      targetsFilter.selectedScopeId
+      scopeProviderDelegate.applyScope(targetsFilter.selectedScopeId, targetsFilter.isAutoTogglePossible)
     }
-    scopeProviderDelegate.applyScope(scopeToApply)
 
     contributorWrapper.fetchElements(inputQuery, object : AsyncProcessor<Any> {
       override suspend fun process(item: Any, weight: Int): Boolean {

platform/searchEverywhere/backend/src/providers/text/SeTextItemsProvider.kt

@@ -94,7 +94,7 @@ class SeTextItemsProvider(project: Project, private val contributorWrapper: SeAs
   }
 
   private fun applyScope(scopeId: String?) {
-    scopeProviderDelegate.applyScope(scopeId)
+    scopeProviderDelegate.applyScope(scopeId, false)
   }
 
   override suspend fun getSearchScopesInfo(): SearchScopesInfo? {

platform/searchEverywhere/frontend/src/tabs/target/SeScopeChooserActionProvider.kt

@@ -11,22 +11,22 @@ import com.intellij.util.Processor
 import org.jetbrains.annotations.ApiStatus
 
 @ApiStatus.Internal
-class SeScopeChooserActionProvider(val scopesInfo: SearchScopesInfo, private val onSelectedScopeChanged: (String?) -> Unit) {
+class SeScopeChooserActionProvider(val scopesInfo: SearchScopesInfo, private val onSelectedScopeChanged: (String?, Boolean) -> Unit) {
   private val descriptors: Map<String, ScopeDescriptor> = scopesInfo.getScopeDescriptors()
+  private var selectedScopeId: String? = scopesInfo.selectedScopeId
 
-  var selectedScopeId: String? = scopesInfo.selectedScopeId
-    private set(value) {
-      field = value
-      onSelectedScopeChanged(value)
-    }
+  private fun setSelectedScope(scopeId: String?, isAutoToggleEnabled: Boolean) {
+    selectedScopeId = scopeId
+    onSelectedScopeChanged(scopeId, isAutoToggleEnabled && !action.isEverywhere)
+  }
 
   private val action = object : ScopeChooserAction(), AutoToggleAction {
     private var isAutoToggleEnabled: Boolean = true
 
     override fun onScopeSelected(o: ScopeDescriptor) {
       scopesInfo.scopes.firstOrNull { it.name == o.displayName }?.let {
-        selectedScopeId = it.scopeId
         isAutoToggleEnabled = false
+        setSelectedScope(selectedScopeId, false)
       }
     }
 
@@ -45,12 +45,12 @@ class SeScopeChooserActionProvider(val scopesInfo: SearchScopesInfo, private val
 
     private fun updateScope(everywhere: Boolean) {
       val targetScope = if (everywhere) scopesInfo.everywhereScopeId else scopesInfo.projectScopeId
-      selectedScopeId = targetScope
+      setSelectedScope(targetScope, isAutoToggleEnabled)
     }
 
     override fun setEverywhere(everywhere: Boolean) {
-      updateScope(everywhere)
       isAutoToggleEnabled = false
+      updateScope(everywhere)
     }
 
     override fun canToggleEverywhere(): Boolean {

platform/searchEverywhere/frontend/src/tabs/target/SeTargetsFilterEditor.kt

@@ -15,7 +15,9 @@ import org.jetbrains.annotations.ApiStatus.Internal
 @Internal
 class SeTargetsFilterEditor(private val scopesInfo: SearchScopesInfo?,
                             typeVisibilityStates: List<SeTypeVisibilityStatePresentation>?) : SeFilterEditorBase<SeTargetsFilter>(
-  SeTargetsFilter(scopesInfo?.selectedScopeId, hiddenTypes(typeVisibilityStates))
+  SeTargetsFilter(scopesInfo?.selectedScopeId,
+                  scopesInfo?.selectedScopeId != scopesInfo?.everywhereScopeId,
+                  hiddenTypes(typeVisibilityStates))
 ) {
   private val updateFilterValueWithVisibilityStates = {
     filterValue = filterValue.cloneWith(hiddenTypes(visibilityStateHolder?.elements))
@@ -27,8 +29,8 @@ class SeTargetsFilterEditor(private val scopesInfo: SearchScopesInfo?,
     }
 
   private val scopeFilterAction: AnAction? = scopesInfo?.let {
-    SeScopeChooserActionProvider(scopesInfo) {
-      filterValue = filterValue.cloneWith(it)
+    SeScopeChooserActionProvider(scopesInfo) { scopeId, isAutoToggleEnabled ->
+      filterValue = filterValue.cloneWith(scopeId, isAutoToggleEnabled)
     }.getAction()
   }
 

platform/searchEverywhere/frontend/src/tabs/text/SeTextFilterEditor.kt

@@ -33,8 +33,8 @@ class SeTextFilterEditor(
 ) {
   private val findInProjectModel = FindManager.getInstance(project).findInProjectModel
   private val scopeFilterAction: AnAction? = scopesInfo?.let {
-    SeScopeChooserActionProvider(scopesInfo) {
-      filterValue = filterValue.cloneWithScope(it)
+    SeScopeChooserActionProvider(scopesInfo) { scopeId, _ ->
+      filterValue = filterValue.cloneWithScope(scopeId)
     }.getAction()
   }
   private val typesFilterAction: JComboboxAction? = project?.let {

platform/searchEverywhere/shared/src/providers/ScopeChooserActionProviderDelegate.kt

@@ -67,10 +67,13 @@ class ScopeChooserActionProviderDelegate(private val contributorWrapper: SeAsync
                             everywhereScopeId)
   }
 
-  fun applyScope(scopeId: String?) {
+  fun applyScope(scopeId: String?, isAutoTogglePossible: Boolean) {
     if (scopeId == null) return
     val scope = scopeIdToScope.load()[scopeId] ?: return
 
-    contributorWrapper.contributor.getActions { }.filterIsInstance<ScopeChooserAction>().firstOrNull()?.onScopeSelected(scope)
+    contributorWrapper.contributor.getActions { }.filterIsInstance<ScopeChooserAction>().firstOrNull()?.let {
+      it.setScopeIsDefaultAndAutoSet(isAutoTogglePossible)
+      it.onScopeSelected(scope)
+    }
   }
 }

platform/searchEverywhere/shared/src/providers/SeAdaptedItemsProvider.kt

@@ -32,7 +32,7 @@ class SeAdaptedItemsProvider(contributor: SearchEverywhereContributor<Any>) : Se
         if (isEverywhere) searchScopesInfo.everywhereScopeId else searchScopesInfo.projectScopeId
       }
     }
-    scopeProviderDelegate.applyScope(scopeToApply)
+    scopeProviderDelegate.applyScope(scopeToApply, false)
 
     contributorWrapper.fetchElements(params.inputQuery, object : AsyncProcessor<Any> {
       override suspend fun process(item: Any, weight: Int): Boolean {

platform/searchEverywhere/shared/src/providers/target/SeTargetsFilter.kt

@@ -7,13 +7,15 @@ import com.intellij.platform.searchEverywhere.SeFilterValue
 import org.jetbrains.annotations.ApiStatus
 
 @ApiStatus.Internal
-class SeTargetsFilter(val selectedScopeId: String?, val hiddenTypes: List<String>?): SeFilter {
-  fun cloneWith(selectedScopeId: String?): SeTargetsFilter = SeTargetsFilter(selectedScopeId, hiddenTypes)
-  fun cloneWith(hiddenTypes: List<String>?): SeTargetsFilter = SeTargetsFilter(selectedScopeId, hiddenTypes)
+class SeTargetsFilter(val selectedScopeId: String?, val isAutoTogglePossible: Boolean, val hiddenTypes: List<String>?): SeFilter {
+  fun cloneWith(selectedScopeId: String?, isAutoTogglePossible: Boolean): SeTargetsFilter = SeTargetsFilter(selectedScopeId, isAutoTogglePossible, hiddenTypes)
+  fun cloneWith(hiddenTypes: List<String>?): SeTargetsFilter = SeTargetsFilter(selectedScopeId, isAutoTogglePossible, hiddenTypes)
 
   override fun toState(): SeFilterState {
     val map = mutableMapOf<String, SeFilterValue>()
     selectedScopeId?.let { map[SELECTED_SCOPE_ID] = SeFilterValue.One(it) }
+    map[IS_AUTO_TOGGLE_POSSIBLE] = SeFilterValue.One(isAutoTogglePossible.toString())
+
     if (hiddenTypes?.isNotEmpty() == true) {
       map[HIDDEN_TYPES] = SeFilterValue.Many(hiddenTypes)
     }
@@ -22,6 +24,7 @@ class SeTargetsFilter(val selectedScopeId: String?, val hiddenTypes: List<String
 
   companion object {
     private const val SELECTED_SCOPE_ID = "SELECTED_SCOPE_ID"
+    private const val IS_AUTO_TOGGLE_POSSIBLE: String = "IS_AUTO_TOGGLE_POSSIBLE"
     private const val HIDDEN_TYPES = "HIDDEN_TYPES"
 
     fun from(state: SeFilterState): SeTargetsFilter {
@@ -33,13 +36,15 @@ class SeTargetsFilter(val selectedScopeId: String?, val hiddenTypes: List<String
             it as? SeFilterValue.One
           }?.value
 
+          val isAutoTogglePossible = state.map[IS_AUTO_TOGGLE_POSSIBLE]?.let { it as? SeFilterValue.One }?.value?.toBoolean() ?: false
+
           val hiddenTypes = map[HIDDEN_TYPES]?.let {
             it as? SeFilterValue.Many
           }?.values ?: emptyList()
 
-          return SeTargetsFilter(selectedScopeId, hiddenTypes)
+          return SeTargetsFilter(selectedScopeId, isAutoTogglePossible, hiddenTypes)
         }
-        SeFilterState.Empty -> return SeTargetsFilter(null, emptyList())
+        SeFilterState.Empty -> return SeTargetsFilter(null, false, emptyList())
       }
     }
   }