Rename .span to resolve_span

Summary: Returns a ResolvedSpan, so more consistent. Plus in future we may want to return a real Span from the span function.

Reviewed By: bobyangyf

Differential Revision: D47194444

fbshipit-source-id: 1e178cfecde5307ed221f7034ee867aa407d1099

Author: ndmitchell

starlark/src/lsp/definition.rs

@@ -692,7 +692,7 @@ pub(crate) mod helpers {
                 .begin_column as u32
         }
 
-        pub(crate) fn span(&self, identifier: &str) -> ResolvedSpan {
+        pub(crate) fn resolved_span(&self, identifier: &str) -> ResolvedSpan {
             *self
                 .ranges
                 .get(identifier)
@@ -802,8 +802,8 @@ mod test {
         let module = parsed.module()?;
 
         let expected: Definition = IdentifierDefinition::LoadedLocation {
-            source: parsed.span("print_click"),
-            destination: parsed.span("print"),
+            source: parsed.resolved_span("print_click"),
+            destination: parsed.resolved_span("print"),
             path: "bar.star".to_owned(),
             name: "other_print".to_owned(),
         }
@@ -849,12 +849,12 @@ mod test {
         let module = parsed.module()?;
 
         let expected_add = Definition::from(IdentifierDefinition::Location {
-            source: parsed.span("add_click"),
-            destination: parsed.span("add"),
+            source: parsed.resolved_span("add_click"),
+            destination: parsed.resolved_span("add"),
         });
         let expected_invalid = Definition::from(IdentifierDefinition::Location {
-            source: parsed.span("invalid_symbol_click"),
-            destination: parsed.span("invalid_symbol"),
+            source: parsed.resolved_span("invalid_symbol_click"),
+            destination: parsed.resolved_span("invalid_symbol"),
         });
 
         assert_eq!(
@@ -912,8 +912,8 @@ mod test {
 
         assert_eq!(
             Definition::from(IdentifierDefinition::Location {
-                source: parsed.span("x_param"),
-                destination: parsed.span("x")
+                source: parsed.resolved_span("x_param"),
+                destination: parsed.resolved_span("x")
             }),
             module.find_definition_at_location(
                 parsed.begin_line("x_param"),
@@ -950,8 +950,8 @@ mod test {
 
         assert_eq!(
             Definition::from(IdentifierDefinition::Location {
-                source: parsed.span("x_var"),
-                destination: parsed.span("x")
+                source: parsed.resolved_span("x_var"),
+                destination: parsed.resolved_span("x")
             }),
             module.find_definition_at_location(
                 parsed.begin_line("x_var"),
@@ -960,8 +960,8 @@ mod test {
         );
         assert_eq!(
             Definition::from(IdentifierDefinition::Location {
-                source: parsed.span("y_var1"),
-                destination: parsed.span("y2")
+                source: parsed.resolved_span("y_var1"),
+                destination: parsed.resolved_span("y2")
             }),
             module.find_definition_at_location(
                 parsed.begin_line("y_var1"),
@@ -971,8 +971,8 @@ mod test {
 
         assert_eq!(
             Definition::from(IdentifierDefinition::Location {
-                source: parsed.span("y_var2"),
-                destination: parsed.span("y1")
+                source: parsed.resolved_span("y_var2"),
+                destination: parsed.resolved_span("y1")
             }),
             module.find_definition_at_location(
                 parsed.begin_line("y_var2"),
@@ -981,7 +981,7 @@ mod test {
         );
         assert_eq!(
             Definition::from(IdentifierDefinition::Unresolved {
-                source: parsed.span("z_var"),
+                source: parsed.resolved_span("z_var"),
                 name: "z".to_owned()
             }),
             module.find_definition_at_location(
@@ -1078,7 +1078,7 @@ mod test {
 
         fn test(parsed: &FixtureWithRanges, module: &LspModule, name: &str) {
             let expected = Definition::from(IdentifierDefinition::StringLiteral {
-                source: parsed.span(&format!("{}_click", name)),
+                source: parsed.resolved_span(&format!("{}_click", name)),
                 literal: name.to_owned(),
             });
             let actual = module
@@ -1129,12 +1129,12 @@ mod test {
 
         let expected = |span_id: &str, segments: &[&str]| -> Definition {
             let root_definition_location = IdentifierDefinition::Unresolved {
-                source: parsed.span(&format!("{}_root", span_id)),
+                source: parsed.resolved_span(&format!("{}_root", span_id)),
                 name: "foo".to_owned(),
             };
             if segments.len() > 1 {
                 DottedDefinition {
-                    source: parsed.span(span_id),
+                    source: parsed.resolved_span(span_id),
                     root_definition_location,
                     segments: segments.iter().map(|s| (*s).to_owned()).collect(),
                 }
@@ -1184,14 +1184,14 @@ mod test {
 
         let expected = |span_id: &str, segments: &[&str]| -> Definition {
             let root_definition_location = IdentifierDefinition::LoadedLocation {
-                source: parsed.span(&format!("{}_root", span_id)),
-                destination: parsed.span("root"),
+                source: parsed.resolved_span(&format!("{}_root", span_id)),
+                destination: parsed.resolved_span("root"),
                 path: "defs.bzl".to_owned(),
                 name: "foo".to_owned(),
             };
             if segments.len() > 1 {
                 DottedDefinition {
-                    source: parsed.span(span_id),
+                    source: parsed.resolved_span(span_id),
                     root_definition_location,
                     segments: segments.iter().map(|s| (*s).to_owned()).collect(),
                 }
@@ -1240,12 +1240,12 @@ mod test {
 
         let expected = |span_id: &str, segments: &[&str]| -> Definition {
             let root_definition_location = IdentifierDefinition::Location {
-                source: parsed.span(&format!("{}_root", span_id)),
-                destination: parsed.span("root"),
+                source: parsed.resolved_span(&format!("{}_root", span_id)),
+                destination: parsed.resolved_span("root"),
             };
             if segments.len() > 1 {
                 DottedDefinition {
-                    source: parsed.span(span_id),
+                    source: parsed.resolved_span(span_id),
                     root_definition_location,
                     segments: segments.iter().map(|s| (*s).to_owned()).collect(),
                 }

starlark/src/lsp/server.rs

@@ -991,8 +991,8 @@ mod test {
 
         let expected_location = expected_location_link_from_spans(
             bar_uri.clone(),
-            foo.span("baz_click"),
-            bar.span("baz"),
+            foo.resolved_span("baz_click"),
+            bar.resolved_span("baz"),
         );
 
         let mut server = TestServer::new()?;
@@ -1040,8 +1040,8 @@ mod test {
 
         let expected_location = expected_location_link_from_spans(
             bar_uri.clone(),
-            foo.span("baz_click"),
-            bar.span("baz"),
+            foo.resolved_span("baz_click"),
+            bar.resolved_span("baz"),
         );
 
         let mut server = TestServer::new()?;
@@ -1085,8 +1085,8 @@ mod test {
 
         let expected_location = expected_location_link_from_spans(
             bar_uri.clone(),
-            foo.span("baz_click"),
-            bar.span("baz"),
+            foo.resolved_span("baz_click"),
+            bar.resolved_span("baz"),
         );
 
         let mut server = TestServer::new()?;
@@ -1127,8 +1127,8 @@ mod test {
         let foo = FixtureWithRanges::from_fixture(foo_uri.path(), &foo_contents)?;
         let expected_location = expected_location_link_from_spans(
             foo_uri.clone(),
-            foo.span("baz_click"),
-            foo.span("baz_loc"),
+            foo.resolved_span("baz_click"),
+            foo.resolved_span("baz_loc"),
         );
 
         let mut server = TestServer::new()?;
@@ -1171,8 +1171,8 @@ mod test {
 
         let expected_location = expected_location_link_from_spans(
             foo_uri.clone(),
-            foo.span("not_baz"),
-            foo.span("not_baz_loc"),
+            foo.resolved_span("not_baz"),
+            foo.resolved_span("not_baz_loc"),
         );
 
         let mut server = TestServer::new()?;
@@ -1217,8 +1217,8 @@ mod test {
 
         let expected_location = expected_location_link_from_spans(
             bar_uri.clone(),
-            foo.span("baz_click"),
-            bar.span("baz"),
+            foo.resolved_span("baz_click"),
+            bar.resolved_span("baz"),
         );
 
         let mut server = TestServer::new()?;
@@ -1262,8 +1262,8 @@ mod test {
 
         let expected_location = expected_location_link_from_spans(
             foo_uri.clone(),
-            foo.span("not_baz_loc"),
-            foo.span("not_baz_loc"),
+            foo.resolved_span("not_baz_loc"),
+            foo.resolved_span("not_baz_loc"),
         );
 
         let mut server = TestServer::new()?;
@@ -1311,7 +1311,7 @@ mod test {
         let foo = FixtureWithRanges::from_fixture(foo_uri.path(), &foo_contents)?;
 
         let expected_location = LocationLink {
-            origin_selection_range: Some(foo.span("bar_click").into()),
+            origin_selection_range: Some(foo.resolved_span("bar_click").into()),
             target_uri: bar_uri,
             target_range: Default::default(),
             target_selection_range: Default::default(),
@@ -1358,7 +1358,7 @@ mod test {
 
         let bar_contents = r#""Just <bar>a string</bar>""#;
         let bar = FixtureWithRanges::from_fixture(bar_uri.path(), bar_contents)?;
-        let bar_range = bar.span("bar");
+        let bar_range = bar.resolved_span("bar");
         let bar_range_str = format!(
             "{}:{}:{}:{}",
             bar_range.begin_line, bar_range.begin_column, bar_range.end_line, bar_range.end_column
@@ -1457,7 +1457,7 @@ mod test {
             };
             let expected_location = expected_location_link_from_spans(
                 bar_uri.clone(),
-                foo.span(&format!("{}_click", name)),
+                foo.resolved_span(&format!("{}_click", name)),
                 range,
             );
 
@@ -1564,7 +1564,7 @@ mod test {
         let response = goto_definition_response_location(&mut server, req_id)?;
 
         let expected = LocationLink {
-            origin_selection_range: Some(foo.span("bar").into()),
+            origin_selection_range: Some(foo.resolved_span("bar").into()),
             target_uri: bar_uri,
             target_range: Default::default(),
             target_selection_range: Default::default(),
@@ -1582,7 +1582,7 @@ mod test {
         let response = goto_definition_response_location(&mut server, req_id)?;
 
         let expected = LocationLink {
-            origin_selection_range: Some(foo.span("baz").into()),
+            origin_selection_range: Some(foo.resolved_span("baz").into()),
             target_uri: baz_uri,
             target_range: Default::default(),
             target_selection_range: Default::default(),
@@ -1600,7 +1600,7 @@ mod test {
         let response = goto_definition_response_location(&mut server, req_id)?;
 
         let expected = LocationLink {
-            origin_selection_range: Some(foo.span("dir1").into()),
+            origin_selection_range: Some(foo.resolved_span("dir1").into()),
             target_uri: dir1_uri,
             target_range: Default::default(),
             target_selection_range: Default::default(),
@@ -1619,7 +1619,7 @@ mod test {
         let response = goto_definition_response_location(&mut server, req_id)?;
 
         let expected = LocationLink {
-            origin_selection_range: Some(foo.span("dir2").into()),
+            origin_selection_range: Some(foo.resolved_span("dir2").into()),
             target_uri: dir2_uri,
             target_range: Default::default(),
             target_selection_range: Default::default(),
@@ -1731,8 +1731,8 @@ mod test {
 
         let expected_n1_location = expected_location_link_from_spans(
             native_uri,
-            foo.span("click_n1"),
-            native.span("n1_loc"),
+            foo.resolved_span("click_n1"),
+            native.resolved_span("n1_loc"),
         );
 
         let goto_definition = goto_definition_request(
@@ -1748,8 +1748,8 @@ mod test {
 
         let expected_n2_location = expected_location_link_from_spans(
             foo_uri.clone(),
-            foo.span("click_n2"),
-            foo.span("n2_loc"),
+            foo.resolved_span("click_n2"),
+            foo.resolved_span("n2_loc"),
         );
 
         let goto_definition = goto_definition_request(
@@ -1856,8 +1856,8 @@ mod test {
             .map(|(fixture, uri, id)| {
                 expected_location_link_from_spans(
                     (*uri).clone(),
-                    foo.span(id),
-                    fixture.span(&format!("dest_{}", id)),
+                    foo.resolved_span(id),
+                    fixture.resolved_span(&format!("dest_{}", id)),
                 )
             })
             .collect::<Vec<_>>();