Exclude comment sections from workspace symbols by default

crates/ark/src/lsp/config.rs

@@ -62,13 +62,22 @@ pub static SETTINGS: &[Setting] = &[
                 .unwrap_or_else(|| SymbolsConfig::default().include_assignments_in_blocks)
         },
     },
+    Setting {
+        key: "positron.r.workspaceSymbols.includeCommentSections",
+        set: |cfg, v| {
+            cfg.workspace_symbols.include_comment_sections = v
+                .as_bool()
+                .unwrap_or_else(|| WorkspaceSymbolsConfig::default().include_comment_sections)
+        },
+    },
 ];
 
 /// Configuration of the LSP
 #[derive(Clone, Default, Debug)]
 pub(crate) struct LspConfig {
     pub(crate) diagnostics: DiagnosticsConfig,
     pub(crate) symbols: SymbolsConfig,
+    pub(crate) workspace_symbols: WorkspaceSymbolsConfig,
     pub(crate) document: DocumentConfig,
 }
 
@@ -78,6 +87,12 @@ pub struct SymbolsConfig {
     pub include_assignments_in_blocks: bool,
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct WorkspaceSymbolsConfig {
+    /// Whether to include sections like `# My section ---` in workspace symbols.
+    pub include_comment_sections: bool,
+}
+
 /// Configuration of a document.
 ///
 /// The naming follows <https://editorconfig.org/> where possible.
@@ -141,6 +156,14 @@ impl Default for SymbolsConfig {
     }
 }
 
+impl Default for WorkspaceSymbolsConfig {
+    fn default() -> Self {
+        Self {
+            include_comment_sections: false,
+        }
+    }
+}
+
 impl Default for IndentationConfig {
     fn default() -> Self {
         Self {

crates/ark/src/lsp/handlers.rs

@@ -124,8 +124,9 @@ pub(crate) async fn handle_initialized(
 #[tracing::instrument(level = "info", skip_all)]
 pub(crate) fn handle_symbol(
     params: WorkspaceSymbolParams,
+    state: &WorldState,
 ) -> anyhow::Result<Option<Vec<SymbolInformation>>> {
-    symbols::symbols(&params)
+    symbols::symbols(&params, state)
         .map(|res| Some(res))
         .or_else(|err| {
             // Missing doc: Why are we not propagating errors to the frontend?

crates/ark/src/lsp/indexer.rs

@@ -121,10 +121,17 @@ fn insert(path: &Path, entry: IndexEntry) -> anyhow::Result<()> {
 
     let index = index.entry(path.to_string()).or_default();
 
-    // Retain the first occurrence in the index. In the future we'll track every occurrences and
-    // their scopes but for now we only track the first definition of an object (in a way, its
+    // We generally retain only the first occurrence in the index. In the
+    // future we'll track every occurrences and their scopes but for now we
+    // only track the first definition of an object (in a way, its
     // declaration).
-    if !index.contains_key(&entry.key) {
+    if let Some(existing_entry) = index.get(&entry.key) {
+        // Give priority to non-section entries.
+        if matches!(existing_entry.data, IndexEntryData::Section { .. }) {
+            index.insert(entry.key.clone(), entry);
+        }
+        // Else, ignore.
+    } else {
         index.insert(entry.key.clone(), entry);
     }
 

crates/ark/src/lsp/main_loop.rs

@@ -281,7 +281,7 @@ impl GlobalState {
                             respond(tx, || state_handlers::initialize(params, &mut self.lsp_state, &mut self.world), LspResponse::Initialize)?;
                         },
                         LspRequest::WorkspaceSymbol(params) => {
-                            respond(tx, || handlers::handle_symbol(params), LspResponse::WorkspaceSymbol)?;
+                            respond(tx, || handlers::handle_symbol(params, &self.world), LspResponse::WorkspaceSymbol)?;
                         },
                         LspRequest::DocumentSymbol(params) => {
                             respond(tx, || handlers::handle_document_symbol(params, &self.world), LspResponse::DocumentSymbol)?;

crates/ark/src/lsp/symbols.rs

@@ -56,7 +56,10 @@ fn new_symbol_node(
     symbol
 }
 
-pub fn symbols(params: &WorkspaceSymbolParams) -> anyhow::Result<Vec<SymbolInformation>> {
+pub(crate) fn symbols(
+    params: &WorkspaceSymbolParams,
+    state: &WorldState,
+) -> anyhow::Result<Vec<SymbolInformation>> {
     let query = &params.query;
     let mut info: Vec<SymbolInformation> = Vec::new();
 
@@ -81,18 +84,21 @@ pub fn symbols(params: &WorkspaceSymbolParams) -> anyhow::Result<Vec<SymbolInfor
             },
 
             IndexEntryData::Section { level: _, title } => {
-                info.push(SymbolInformation {
-                    name: title.to_string(),
-                    kind: SymbolKind::STRING,
-                    location: Location {
-                        uri: Url::from_file_path(path).unwrap(),
-                        range: entry.range,
-                    },
-                    tags: None,
-                    deprecated: None,
-                    container_name: None,
-                });
+                if state.config.workspace_symbols.include_comment_sections {
+                    info.push(SymbolInformation {
+                        name: title.to_string(),
+                        kind: SymbolKind::STRING,
+                        location: Location {
+                            uri: Url::from_file_path(path).unwrap(),
+                            range: entry.range,
+                        },
+                        tags: None,
+                        deprecated: None,
+                        container_name: None,
+                    });
+                }
             },
+
             IndexEntryData::Variable { name } => {
                 info.push(SymbolInformation {
                     name: name.clone(),