Request global symbol locations from LSP context

Summary: For symbols that are not available in any scope for a file, pass that information back to the server. The server can then lookup the URI, which can either be a file:// uri in the case of a prelude, or starlark: in the case of a native file.

Reviewed By: stepancheg

Differential Revision: D38452379

fbshipit-source-id: 59c924dce50b5bae0b864da25fa59591b246ad3a

Author: Natalie Jameson

starlark/src/analysis/definition.rs

@@ -60,6 +60,9 @@ pub enum DefinitionLocation {
         source: ResolvedSpan,
         literal: String,
     },
+    /// A named symbol was found, but it was not found in any of the current scopes. It
+    /// should be considered a global symbol, and attempted to be resolved externally.
+    Unresolved { source: ResolvedSpan, name: String },
     /// Either the provided location was not an access of a variable, or no definition
     /// could be found.
     NotFound,
@@ -178,6 +181,7 @@ impl LspModule {
         let line_span = self.ast.codemap.line_span(line as usize);
         let current_pos = std::cmp::min(line_span.begin() + col, line_span.end());
 
+        // Finalize the results after recursing down from and back up to the the top level scope.
         match find_definition_in_scope(&scope, current_pos) {
             Definition::Location {
                 source,
@@ -187,7 +191,10 @@ impl LspModule {
                 destination: self.ast.codemap.resolve_span(destination),
             },
             Definition::Name { source, name } => match scope.bound.get(name) {
-                None => DefinitionLocation::NotFound,
+                None => DefinitionLocation::Unresolved {
+                    source: self.ast.codemap.resolve_span(source),
+                    name: name.to_owned(),
+                },
                 Some((Assigner::Load { path, name }, span)) => DefinitionLocation::LoadedLocation {
                     source: self.ast.codemap.resolve_span(source),
                     destination: self.ast.codemap.resolve_span(*span),
@@ -728,7 +735,10 @@ mod test {
             module.find_definition(parsed.begin_line("y_var2"), parsed.begin_column("y_var2"))
         );
         assert_eq!(
-            DefinitionLocation::NotFound,
+            DefinitionLocation::Unresolved {
+                source: parsed.span("z_var"),
+                name: "z".to_owned()
+            },
             module.find_definition(parsed.begin_line("z_var"), parsed.begin_column("z_var"))
         );
         Ok(())

starlark/src/lsp/server.rs

@@ -527,6 +527,30 @@ impl<T: LspContext> Backend<T> {
                         _ => None,
                     }
                 }
+                DefinitionLocation::Unresolved { source, name } => {
+                    match self.context.get_url_for_global_symbol(&uri, &name)? {
+                        Some(uri) => {
+                            let loaded_location = self
+                                .get_ast_or_load_from_disk(&uri)?
+                                .and_then(|ast| ast.find_exported_symbol(&name));
+                            match loaded_location {
+                                None => Some(LocationLink {
+                                    origin_selection_range: Some(source.into()),
+                                    target_uri: uri.try_into()?,
+                                    target_range: Range::default(),
+                                    target_selection_range: Range::default(),
+                                }),
+                                Some(loaded_location) => Some(LocationLink {
+                                    origin_selection_range: Some(source.into()),
+                                    target_uri: uri.try_into()?,
+                                    target_range: loaded_location.into(),
+                                    target_selection_range: loaded_location.into(),
+                                }),
+                            }
+                        }
+                        None => None,
+                    }
+                }
             },
             None => None,
         };
@@ -1565,4 +1589,91 @@ mod test {
 
         Ok(())
     }
+
+    #[test]
+    fn goto_works_for_native_symbols() -> anyhow::Result<()> {
+        let foo_uri = temp_file_uri("foo.star");
+        let native_uri = Url::parse("starlark:/native/builtin.bzl")?;
+
+        let mut server = TestServer::new()?;
+
+        let foo_contents = dedent(
+            r#"
+            <click_n1>na<n1>t</n1>ive_function1</click_n1>()
+            def f(<n2_loc>native_function1</n2_loc>):
+                print(<click_n2>nat<n2>i</n2>ve_function1</click_n2>)
+            mi<n3>s</n3>sing_global()
+            "#,
+        )
+        .trim()
+        .to_owned();
+        let native_contents = dedent(
+            r#"
+            def <n1_loc>native_function1</n1_loc>():
+                pass
+
+            def native_function2():
+                pass
+            "#,
+        )
+        .trim()
+        .to_owned();
+
+        let foo = FixtureWithRanges::from_fixture(foo_uri.path(), &foo_contents)?;
+        let native = FixtureWithRanges::from_fixture(native_uri.path(), &native_contents)?;
+
+        server.open_file(foo_uri.clone(), foo.program())?;
+
+        let expected_n1_location = expected_location_link_from_spans(
+            native_uri,
+            foo.span("click_n1"),
+            native.span("n1_loc"),
+        );
+
+        let goto_definition = goto_definition_request(
+            &mut server,
+            foo_uri.clone(),
+            foo.begin_line("n1"),
+            foo.begin_column("n1"),
+        );
+        let request_id = server.send_request(goto_definition)?;
+        let n1_location = goto_definition_response_location(&mut server, request_id)?;
+
+        assert_eq!(expected_n1_location, n1_location);
+
+        let expected_n2_location = expected_location_link_from_spans(
+            foo_uri.clone(),
+            foo.span("click_n2"),
+            foo.span("n2_loc"),
+        );
+
+        let goto_definition = goto_definition_request(
+            &mut server,
+            foo_uri.clone(),
+            foo.begin_line("n2"),
+            foo.begin_column("n2"),
+        );
+        let request_id = server.send_request(goto_definition)?;
+        let n2_location = goto_definition_response_location(&mut server, request_id)?;
+
+        assert_eq!(expected_n2_location, n2_location);
+
+        let goto_definition = goto_definition_request(
+            &mut server,
+            foo_uri,
+            foo.begin_line("n3"),
+            foo.begin_column("n3"),
+        );
+        let request_id = server.send_request(goto_definition)?;
+        let n3_response = server.get_response::<GotoDefinitionResponse>(request_id)?;
+        match n3_response {
+            GotoDefinitionResponse::Array(definitions) if definitions.is_empty() => Ok(()),
+            response => Err(anyhow::anyhow!(
+                "Expected empty definitions, got `{:?}`",
+                response
+            )),
+        }?;
+
+        Ok(())
+    }
 }