Apply refactor in other tests

Author: asterite

tooling/lsp/src/notifications/mod.rs

@@ -666,29 +666,18 @@ mod notification_tests {
     use super::*;
     use async_lsp::lsp_types::{
         InlayHintLabel, InlayHintParams, Position, Range, TextDocumentContentChangeEvent,
-        TextDocumentIdentifier, TextDocumentItem, VersionedTextDocumentIdentifier,
-        WorkDoneProgressParams,
+        TextDocumentIdentifier, VersionedTextDocumentIdentifier, WorkDoneProgressParams,
     };
     use tokio::test;
 
     #[test]
     async fn test_caches_open_files() {
-        let (mut state, noir_text_document) = test_utils::init_lsp_server("inlay_hints").await;
+        // Open the document with empty text.
+        let (mut state, noir_text_document) =
+            test_utils::init_lsp_server_with_inline_source("inlay_hints", "src/main.nr", "").await;
 
-        // Open the document, fake the text to be empty
-        let _ = on_did_open_text_document(
-            &mut state,
-            DidOpenTextDocumentParams {
-                text_document: TextDocumentItem {
-                    uri: noir_text_document.clone(),
-                    language_id: "noir".to_string(),
-                    version: 0,
-                    text: "".to_string(),
-                },
-            },
-        );
-
-        // Fake the text to change to "global a = 1;"
+        // Then change the in-memory text to "global a = true;" and verify subsequent requests
+        // see the new content, not what's on disk.
         let _ = on_did_change_text_document(
             &mut state,
             DidChangeTextDocumentParams {

tooling/lsp/src/requests/document_symbol.rs

@@ -548,23 +548,36 @@ mod document_symbol_tests {
 
     #[test]
     async fn test_document_symbol() {
-        let (mut state, noir_text_document) = test_utils::init_lsp_server("document_symbol").await;
+        let src = r#"fn foo(_x: i32) {
+    let _ = 1;
+}
 
-        let response = on_document_symbol_request(
-            &mut state,
-            DocumentSymbolParams {
-                text_document: TextDocumentIdentifier { uri: noir_text_document },
-                work_done_progress_params: WorkDoneProgressParams { work_done_token: None },
-                partial_result_params: PartialResultParams { partial_result_token: None },
-            },
-        )
-        .await
-        .expect("Could not execute on_document_symbol_request")
-        .unwrap();
+struct SomeStruct {
+    field: i32,
+}
 
-        let DocumentSymbolResponse::Nested(symbols) = response else {
-            panic!("Expected response to be nested");
-        };
+impl SomeStruct {
+    fn new() -> SomeStruct {
+        SomeStruct { field: 0 }
+    }
+}
+
+trait SomeTrait<U> {
+    fn some_method(x: U);
+}
+
+impl SomeTrait<i32> for SomeStruct {
+    fn some_method(_x: i32) {
+    }
+}
+
+mod submodule {
+    global SOME_GLOBAL = 1;
+}
+
+impl i32 {}
+"#;
+        let symbols = get_document_symbols(src).await;
 
         assert_eq!(
             symbols,

tooling/lsp/src/requests/goto_definition.rs

@@ -82,21 +82,24 @@ fn on_goto_definition_inner(
 mod goto_definition_tests {
     use std::panic;
 
-    use crate::test_utils::{self, search_in_file};
+    use crate::test_utils::{self, search_in_text};
     use async_lsp::lsp_types::{Position, Range};
     use tokio::test;
 
     use super::*;
 
-    async fn expect_goto_for_all_references(directory: &str, name: &str, definition_index: usize) {
-        let (mut state, noir_text_document) = test_utils::init_lsp_server(directory).await;
-
-        let ranges = search_in_file(noir_text_document.path(), name);
+    /// Run goto-definition from every occurrence of `name` in `src` and assert each lands at
+    /// the `definition_index`-th occurrence. The definition position itself is skipped because
+    /// goto on a definition does not currently return itself.
+    async fn expect_goto_for_all_references(src: &str, name: &str, definition_index: usize) {
+        let ranges = search_in_text(src, name);
         let expected_range = ranges[definition_index];
 
+        let (mut state, noir_text_document) =
+            test_utils::init_lsp_server_with_inline_source("document_symbol", "src/main.nr", src)
+                .await;
+
         for (index, range) in ranges.iter().enumerate() {
-            // Ideally "go to" at the definition should return the same location, but this isn't currently
-            // working. But it's also not that important, so we'll keep it for later.
             if index == definition_index {
                 continue;
             }
@@ -127,6 +130,41 @@ mod goto_definition_tests {
         }
     }
 
+    /// Run goto-definition at the `>|<` cursor in `src` and assert the response points within
+    /// the same file at `expected_range`.
+    async fn expect_goto_inline(src: &str, expected_range: Range) {
+        let (mut state, noir_text_document, position, _src) =
+            test_utils::init_lsp_server_with_inline_source_and_cursor(
+                "document_symbol",
+                "src/main.nr",
+                src,
+            )
+            .await;
+
+        let params = GotoDefinitionParams {
+            text_document_position_params: lsp_types::TextDocumentPositionParams {
+                text_document: lsp_types::TextDocumentIdentifier {
+                    uri: noir_text_document.clone(),
+                },
+                position,
+            },
+            work_done_progress_params: Default::default(),
+            partial_result_params: Default::default(),
+        };
+
+        let response = on_goto_definition_request(&mut state, params)
+            .await
+            .expect("Could execute on_goto_definition_request")
+            .unwrap_or_else(|| panic!("Didn't get a goto definition response"));
+
+        if let GotoDefinitionResponse::Scalar(location) = response {
+            assert_eq!(location.uri, noir_text_document);
+            assert_eq!(location.range, expected_range);
+        } else {
+            panic!("Expected a scalar response");
+        }
+    }
+
     async fn expect_goto(
         directory: &str,
         position: Position,
@@ -161,15 +199,36 @@ mod goto_definition_tests {
 
     #[test]
     async fn goto_from_function_location_to_declaration() {
-        expect_goto_for_all_references("go_to_definition", "another_function", 0).await;
+        expect_goto_for_all_references(
+            r#"fn another_function() -> Field {
+    1
+}
+
+fn main() {
+    another_function();
+    another_function();
+}
+"#,
+            "another_function",
+            0,
+        )
+        .await;
     }
 
     #[test]
     async fn goto_from_use_as() {
-        expect_goto(
-            "go_to_definition",
-            Position { line: 7, character: 29 }, // The word after `as`,
-            "src/main.nr",
+        expect_goto_inline(
+            r#"mod foo {
+    pub fn another_function() -> Field { 1 }
+}
+
+use foo::another_function as >|<aliased_function;
+
+fn main() {
+    let _ = aliased_function();
+}
+"#,
+            // `another_function` in `pub fn another_function`
             Range {
                 start: Position { line: 1, character: 11 },
                 end: Position { line: 1, character: 27 },
@@ -208,10 +267,14 @@ mod goto_definition_tests {
 
     #[test]
     async fn goto_module_from_use_path() {
-        expect_goto(
-            "go_to_definition",
-            Position { line: 6, character: 4 }, // "foo" in "use foo::another_function;"
-            "src/main.nr",
+        expect_goto_inline(
+            r#"mod foo {
+    pub fn another_function() -> Field { 1 }
+}
+
+use >|<foo::another_function;
+"#,
+            // `foo` in `mod foo {`
             Range {
                 start: Position { line: 0, character: 4 },
                 end: Position { line: 0, character: 7 },
@@ -236,32 +299,37 @@ mod goto_definition_tests {
 
     #[test]
     async fn goto_for_local_variable() {
-        expect_goto_for_all_references("local_variable", "some_var", 0).await;
+        expect_goto_for_all_references(
+            r#"fn main() {
+    let some_var = 1;
+    let _ = some_var + some_var;
+}
+"#,
+            "some_var",
+            0,
+        )
+        .await;
     }
 
     #[test]
     async fn goto_at_struct_definition_finds_same_struct() {
-        expect_goto(
-            "go_to_definition",
-            Position { line: 21, character: 7 }, // "Foo" in "struct Foo"
-            "src/main.nr",
+        expect_goto_inline(
+            "struct >|<Foo {}\n",
             Range {
-                start: Position { line: 21, character: 7 },
-                end: Position { line: 21, character: 10 },
+                start: Position { line: 0, character: 7 },
+                end: Position { line: 0, character: 10 },
             },
         )
         .await;
     }
 
     #[test]
     async fn goto_at_trait_definition_finds_same_trait() {
-        expect_goto(
-            "go_to_definition",
-            Position { line: 25, character: 6 }, // "Trait" in "trait Trait"
-            "src/main.nr",
+        expect_goto_inline(
+            "trait >|<Trait {}\n",
             Range {
-                start: Position { line: 25, character: 6 },
-                end: Position { line: 25, character: 11 },
+                start: Position { line: 0, character: 6 },
+                end: Position { line: 0, character: 11 },
             },
         )
         .await;
@@ -283,22 +351,37 @@ mod goto_definition_tests {
 
     #[test]
     async fn goto_attribute_function() {
-        expect_goto(
-            "go_to_definition",
-            Position { line: 31, character: 3 }, // "attr"
-            "src/main.nr",
+        expect_goto_inline(
+            r#"#[>|<attr]
+pub fn foo() {}
+
+comptime fn attr(_: FunctionDefinition) -> Quoted {
+    quote { pub fn hello() {} }
+}
+"#,
+            // `attr` in `comptime fn attr(...)`
             Range {
-                start: Position { line: 34, character: 12 },
-                end: Position { line: 34, character: 16 },
+                start: Position { line: 3, character: 12 },
+                end: Position { line: 3, character: 16 },
             },
         )
         .await;
     }
 
     #[test]
     async fn goto_reference_in_doc_comment() {
-        let (mut state, noir_text_document) = test_utils::init_lsp_server("go_to_definition").await;
-        let position = Position { line: 38, character: 10 };
+        let src = r#"struct Foo {}
+
+/// See [F>|<oo].
+fn test_doc_comment() {}
+"#;
+        let (mut state, noir_text_document, position, _src) =
+            test_utils::init_lsp_server_with_inline_source_and_cursor(
+                "document_symbol",
+                "src/main.nr",
+                src,
+            )
+            .await;
 
         let params = GotoDefinitionParams {
             text_document_position_params: lsp_types::TextDocumentPositionParams {
@@ -320,30 +403,23 @@ mod goto_definition_tests {
         };
         assert_eq!(links.len(), 1);
         let link = &links[0];
-        assert!(link.target_uri.to_string().ends_with("src/main.nr"));
+        assert_eq!(link.target_uri, noir_text_document);
 
         // This range is `[Foo]` in the doc comment
         assert_eq!(
             link.origin_selection_range,
             Some(Range {
-                start: Position { line: 38, character: 8 },
-                end: Position { line: 38, character: 13 },
+                start: Position { line: 2, character: 8 },
+                end: Position { line: 2, character: 13 },
             },)
         );
 
-        assert_eq!(
-            link.target_range,
-            Range {
-                start: Position { line: 21, character: 7 },
-                end: Position { line: 21, character: 10 },
-            }
-        );
-        assert_eq!(
-            link.target_selection_range,
-            Range {
-                start: Position { line: 21, character: 7 },
-                end: Position { line: 21, character: 10 },
-            }
-        );
+        // `Foo` in `struct Foo {}` — line 0, chars 7-10
+        let foo_def_range = Range {
+            start: Position { line: 0, character: 7 },
+            end: Position { line: 0, character: 10 },
+        };
+        assert_eq!(link.target_range, foo_def_range);
+        assert_eq!(link.target_selection_range, foo_def_range);
     }
 }