Add named functions as document symbols

Author: lionel-

.github/copilot-instructions.md

@@ -19,3 +19,6 @@ _below_ the calling function. A general goal is to be able to read linearly from
 top to bottom with the relevant context and main logic first. The code should be
 organised like a call stack. Of course that's not always possible, use best
 judgement to produce the clearest code organization.
+
+ Keep the main logic as unnested as possible. Favour Rust's `let ... else`
+ syntax to return early or continue a loop in the `else` clause, over `if let`.

crates/ark/src/lsp/snapshots/ark__lsp__symbols__tests__symbol_call_methods.snap

@@ -0,0 +1,101 @@
+---
+source: crates/ark/src/lsp/symbols.rs
+expression: "test_symbol(\"\n# section ----\nlist(\n    foo = function() {\n        1\n    }, # matched\n    function() {\n        2\n    }, # not matched\n    bar = function() {\n        3\n    }, # matched\n    baz = (function() {\n        4\n    }) # not matched\n)\n\")"
+---
+[
+    DocumentSymbol {
+        name: "section",
+        detail: None,
+        kind: String,
+        tags: None,
+        deprecated: None,
+        range: Range {
+            start: Position {
+                line: 1,
+                character: 0,
+            },
+            end: Position {
+                line: 15,
+                character: 1,
+            },
+        },
+        selection_range: Range {
+            start: Position {
+                line: 1,
+                character: 0,
+            },
+            end: Position {
+                line: 15,
+                character: 1,
+            },
+        },
+        children: Some(
+            [
+                DocumentSymbol {
+                    name: "foo",
+                    detail: Some(
+                        "function()",
+                    ),
+                    kind: Method,
+                    tags: None,
+                    deprecated: None,
+                    range: Range {
+                        start: Position {
+                            line: 3,
+                            character: 10,
+                        },
+                        end: Position {
+                            line: 5,
+                            character: 5,
+                        },
+                    },
+                    selection_range: Range {
+                        start: Position {
+                            line: 3,
+                            character: 10,
+                        },
+                        end: Position {
+                            line: 5,
+                            character: 5,
+                        },
+                    },
+                    children: Some(
+                        [],
+                    ),
+                },
+                DocumentSymbol {
+                    name: "bar",
+                    detail: Some(
+                        "function()",
+                    ),
+                    kind: Method,
+                    tags: None,
+                    deprecated: None,
+                    range: Range {
+                        start: Position {
+                            line: 9,
+                            character: 10,
+                        },
+                        end: Position {
+                            line: 11,
+                            character: 5,
+                        },
+                    },
+                    selection_range: Range {
+                        start: Position {
+                            line: 9,
+                            character: 10,
+                        },
+                        end: Position {
+                            line: 11,
+                            character: 5,
+                        },
+                    },
+                    children: Some(
+                        [],
+                    ),
+                },
+            ],
+        ),
+    },
+]

crates/ark/src/lsp/symbols.rs

@@ -273,7 +273,66 @@ fn collect_call(
 
     match fun_symbol.as_str() {
         "test_that" => collect_call_test_that(node, contents, symbols)?,
-        _ => {},
+        _ => collect_call_methods(node, contents, symbols)?,
+    }
+
+    Ok(())
+}
+
+fn collect_call_methods(
+    node: &Node,
+    contents: &Rope,
+    symbols: &mut Vec<DocumentSymbol>,
+) -> anyhow::Result<()> {
+    dbg!(node);
+    let Some(arguments) = node.child_by_field_name("arguments") else {
+        return Ok(());
+    };
+
+    let mut cursor = node.walk();
+    for arg in arguments.children(&mut cursor) {
+        if arg.kind() != "argument" {
+            continue;
+        }
+
+        let Some(arg_value) = arg.child_by_field_name("value") else {
+            continue;
+        };
+        if arg_value.kind() != "function_definition" {
+            continue;
+        }
+
+        // Process the function body to extract child symbols.
+        // We do this even if it's not a "method", i.e. if it's not named.
+        let body = arg_value.child_by_field_name("body").into_result()?;
+        let mut children = Vec::new();
+        collect_symbols(&body, contents, 0, &mut children)?;
+
+        // There must be a name node, we're only collecting named functions as methods
+        let Some(arg_name) = arg.child_by_field_name("name") else {
+            continue;
+        };
+        if !arg_name.is_identifier_or_string() {
+            continue;
+        }
+        let arg_name_str = contents.node_slice(&arg_name)?.to_string();
+
+        let start = convert_point_to_position(contents, arg_value.start_position());
+        let end = convert_point_to_position(contents, arg_value.end_position());
+
+        let mut symbol = new_symbol_node(
+            arg_name_str,
+            SymbolKind::METHOD,
+            Range { start, end },
+            vec![],
+        );
+
+        // Don't include whole function as detail as the body often doesn't
+        // provide useful information and only make the outline more busy (with
+        // curly braces, newline characters, etc).
+        symbol.detail = Some(String::from("function()"));
+
+        symbols.push(symbol);
     }
 
     Ok(())
@@ -681,7 +740,37 @@ test_that('foo', {
 test_that('bar', {
   1
 })
+"
+        ));
+    }
+
+    #[test]
+    fn test_symbol_call_methods() {
+        insta::assert_debug_snapshot!(test_symbol(
+            "
+# section ----
+list(
+    foo = function() {
+        1
+    }, # matched
+    function() {
+        2
+    }, # not matched
+    bar = function() {
+        3
+    }, # matched
+    baz = (function() {
+        4
+    }) # not matched
+)
 "
         ));
     }
 }
+
+// chat <- r6::r6class(
+//   "chat",
+//   public = list(
+//     initialize = function() "initialize",
+//  )
+//     )