Prepare for variable refactorings

compiler/crates/common/src/diagnostic.rs

@@ -12,6 +12,7 @@ use std::fmt::Write;
 
 use lsp_types::DiagnosticSeverity;
 use lsp_types::DiagnosticTag;
+use lsp_types::NumberOrString;
 use serde::ser::SerializeMap;
 use serde_json::Value;
 
@@ -64,6 +65,7 @@ impl Diagnostic {
         tags: Vec<DiagnosticTag>,
     ) -> Self {
         Self(Box::new(DiagnosticData {
+            code: None,
             message: Box::new(message),
             location,
             related_information: Vec::new(),
@@ -88,6 +90,27 @@ impl Diagnostic {
     ) -> Self {
         let data = message.get_data();
         Self(Box::new(DiagnosticData {
+            code: None,
+            message: Box::new(message),
+            location,
+            tags: Vec::new(),
+            severity: DiagnosticSeverity::ERROR,
+            related_information: Vec::new(),
+            data,
+            machine_readable: BTreeMap::new(),
+        }))
+    }
+
+    /// Creates a new error Diagnostic with additional data and code
+    /// that can be used in IDE code actions
+    pub fn error_with_data_and_code<T: 'static + DiagnosticDisplay + WithDiagnosticData>(
+        code: i32,
+        message: T,
+        location: Location,
+    ) -> Self {
+        let data = message.get_data();
+        Self(Box::new(DiagnosticData {
+            code: Some(NumberOrString::Number(code)),
             message: Box::new(message),
             location,
             tags: Vec::new(),
@@ -167,6 +190,10 @@ impl Diagnostic {
         self
     }
 
+    pub fn code(&self) -> Option<NumberOrString> {
+        self.0.code.to_owned()
+    }
+
     pub fn message(&self) -> &impl DiagnosticDisplay {
         &self.0.message
     }
@@ -276,6 +303,9 @@ where
 
 #[derive(fmt::Debug)]
 struct DiagnosticData {
+    /// The diagnostic's code. Can be omitted.
+    code: Option<NumberOrString>,
+
     /// Human readable error message.
     message: Box<dyn DiagnosticDisplay>,
 

compiler/crates/relay-lsp/src/code_action.rs

@@ -64,10 +64,10 @@ pub(crate) fn on_code_action(
         text_document: params.text_document,
         position: params.range.start,
     };
-    let (document, position_span) =
+    let (document, location) =
         state.extract_executable_document_from_text(&text_document_position_params, 1)?;
 
-    let path = document.resolve((), position_span);
+    let path = document.resolve((), location.span());
 
     let used_definition_names = get_definition_names(&definitions);
     let result = get_code_actions(path, used_definition_names, uri, params.range)

compiler/crates/relay-lsp/src/completion.rs

@@ -1312,13 +1312,13 @@ pub fn on_completion(
     params: <Completion as Request>::Params,
 ) -> LSPRuntimeResult<<Completion as Request>::Result> {
     match state.extract_executable_document_from_text(&params.text_document_position, 0) {
-        Ok((document, position_span)) => {
+        Ok((document, location)) => {
             let project_name = state
                 .extract_project_name_from_url(&params.text_document_position.text_document.uri)?;
             let schema = &state.get_schema(&project_name)?;
             let items = resolve_completion_items(
                 document,
-                position_span,
+                location.span(),
                 project_name,
                 schema,
                 state.get_schema_documentation(project_name.lookup()),

compiler/crates/relay-lsp/src/diagnostic_reporter.rs

@@ -210,7 +210,7 @@ impl DiagnosticReporter {
             .collect::<Vec<_>>();
 
         Diagnostic {
-            code: None,
+            code: diagnostic.code(),
             data: get_diagnostics_data(diagnostic),
             message: diagnostic.message().to_string(),
             range: text_source.to_span_range(diagnostic.location().span()),

compiler/crates/relay-lsp/src/find_field_usages.rs

@@ -31,7 +31,6 @@ use schema::Type;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::location::transform_relay_location_to_lsp_location;
 use crate::server::GlobalState;
 use crate::LSPRuntimeError;
 use crate::LSPRuntimeResult;
@@ -80,13 +79,12 @@ pub fn on_find_field_usages(
 
     let schema = state.get_schema(&schema_name)?;
     let program = state.get_program(&schema_name)?;
-    let root_dir = &state.root_dir();
 
     let ir_locations = get_usages(&program, &schema, type_name, field_name)?;
     let lsp_locations = ir_locations
         .into_iter()
         .map(|(label, ir_location)| {
-            let lsp_location = transform_relay_location_to_lsp_location(root_dir, ir_location)?;
+            let lsp_location = state.get_lsp_location(ir_location)?;
             Ok(FindFieldUsageResultItem {
                 location_uri: lsp_location.uri.to_string(),
                 location_range: lsp_location.range,

compiler/crates/relay-lsp/src/goto_definition.rs

@@ -31,7 +31,6 @@ use serde::Serialize;
 
 use self::goto_docblock_definition::get_docblock_definition_description;
 use self::goto_graphql_definition::get_graphql_definition_description;
-use crate::location::transform_relay_location_to_lsp_location;
 use crate::lsp_runtime_error::LSPRuntimeError;
 use crate::lsp_runtime_error::LSPRuntimeResult;
 use crate::server::GlobalState;
@@ -70,7 +69,7 @@ pub fn on_goto_definition(
     state: &impl GlobalState,
     params: <GotoDefinition as Request>::Params,
 ) -> LSPRuntimeResult<<GotoDefinition as Request>::Result> {
-    let (feature, position_span) =
+    let (feature, location) =
         state.extract_feature_from_text(&params.text_document_position_params, 1)?;
 
     let project_name = state
@@ -80,15 +79,14 @@ pub fn on_goto_definition(
 
     let definition_description = match feature {
         crate::Feature::GraphQLDocument(document) => {
-            get_graphql_definition_description(document, position_span, &schema)?
+            get_graphql_definition_description(document, location.span(), &schema)?
         }
         crate::Feature::DocblockIr(docblock_ir) => {
-            get_docblock_definition_description(&docblock_ir, position_span)?
+            get_docblock_definition_description(&docblock_ir, location.span())?
         }
     };
 
     let extra_data_provider = state.get_extra_data_provider();
-    let root_dir = state.root_dir();
 
     let goto_definition_response: GotoDefinitionResponse = match definition_description {
         DefinitionDescription::FieldArgument {
@@ -100,14 +98,12 @@ pub fn on_goto_definition(
             parent_type,
             field_name,
             argument_name,
-            &root_dir,
+            state,
         )?,
         DefinitionDescription::DirectiveArgument {
             directive_name,
             argument_name,
-        } => {
-            locate_directive_argument_definition(&schema, directive_name, argument_name, &root_dir)?
-        }
+        } => locate_directive_argument_definition(&schema, directive_name, argument_name, state)?,
         DefinitionDescription::Field {
             parent_type,
             field_name,
@@ -117,20 +113,16 @@ pub fn on_goto_definition(
             field_name,
             extra_data_provider,
             project_name,
-            &root_dir,
+            state,
         )?,
         DefinitionDescription::Fragment { fragment_name } => {
-            locate_fragment_definition(program, fragment_name, &root_dir)?
+            locate_fragment_definition(program, fragment_name, state)?
+        }
+        DefinitionDescription::Type { type_name } => {
+            locate_type_definition(extra_data_provider, project_name, type_name, &schema, state)?
         }
-        DefinitionDescription::Type { type_name } => locate_type_definition(
-            extra_data_provider,
-            project_name,
-            type_name,
-            &schema,
-            &root_dir,
-        )?,
         DefinitionDescription::Directive { directive_name } => {
-            locate_directive_definition(directive_name, &schema, &root_dir)?
+            locate_directive_definition(directive_name, &schema, state)?
         }
     };
 
@@ -148,30 +140,32 @@ pub fn on_goto_definition(
 fn locate_fragment_definition(
     program: graphql_ir::Program,
     fragment_name: FragmentDefinitionName,
-    root_dir: &std::path::Path,
+    state: &impl GlobalState,
 ) -> Result<GotoDefinitionResponse, LSPRuntimeError> {
     let fragment = program.fragment(fragment_name).ok_or_else(|| {
         LSPRuntimeError::UnexpectedError(format!(
             "Could not find fragment with name {}",
             fragment_name
         ))
     })?;
-    Ok(GotoDefinitionResponse::Scalar(
-        transform_relay_location_to_lsp_location(root_dir, fragment.name.location)?,
-    ))
+
+    state
+        .get_lsp_location(fragment.name.location)
+        .map(GotoDefinitionResponse::Scalar)
 }
 
 fn locate_directive_definition(
     directive_name: DirectiveName,
     schema: &Arc<SDLSchema>,
-    root_dir: &std::path::Path,
+    state: &impl GlobalState,
 ) -> Result<GotoDefinitionResponse, LSPRuntimeError> {
     let directive = schema.get_directive(directive_name);
 
     directive
         .map(|directive| directive.name.location)
         .map(|schema_location| {
-            transform_relay_location_to_lsp_location(root_dir, schema_location)
+            state
+                .get_lsp_location(schema_location)
                 .map(GotoDefinitionResponse::Scalar)
         })
         .ok_or(LSPRuntimeError::ExpectedError)?
@@ -182,7 +176,7 @@ fn locate_type_definition(
     project_name: StringKey,
     type_name: StringKey,
     schema: &Arc<SDLSchema>,
-    root_dir: &std::path::Path,
+    state: &impl GlobalState,
 ) -> Result<GotoDefinitionResponse, LSPRuntimeError> {
     let provider_response = extra_data_provider.resolve_field_definition(
         project_name.to_string(),
@@ -222,7 +216,8 @@ fn locate_type_definition(
                     Type::Object(object_id) => schema.object(object_id).name.location,
                 })
                 .map(|schema_location| {
-                    transform_relay_location_to_lsp_location(root_dir, schema_location)
+                    state
+                        .get_lsp_location(schema_location)
                         .map(GotoDefinitionResponse::Scalar)
                 })
                 .ok_or(LSPRuntimeError::ExpectedError)?
@@ -235,7 +230,7 @@ fn locate_field_argument_definition(
     parent_type: Type,
     field_name: StringKey,
     argument_name: ArgumentName,
-    root_dir: &std::path::Path,
+    state: &impl GlobalState,
 ) -> Result<GotoDefinitionResponse, LSPRuntimeError> {
     let field = schema.field(schema.named_field(parent_type, field_name).ok_or_else(|| {
         LSPRuntimeError::UnexpectedError(format!("Could not find field with name {}", field_name))
@@ -252,15 +247,16 @@ fn locate_field_argument_definition(
             ))
         })?;
 
-    transform_relay_location_to_lsp_location(root_dir, argument.name.location)
-        .map(|location| Ok(GotoDefinitionResponse::Scalar(location)))?
+    state
+        .get_lsp_location(argument.name.location)
+        .map(GotoDefinitionResponse::Scalar)
 }
 
 fn locate_directive_argument_definition(
     schema: &SDLSchema,
     directive_name: DirectiveName,
     argument_name: ArgumentName,
-    root_dir: &std::path::Path,
+    state: &impl GlobalState,
 ) -> LSPRuntimeResult<GotoDefinitionResponse> {
     let directive =
         schema
@@ -281,8 +277,9 @@ fn locate_directive_argument_definition(
             ))
         })?;
 
-    transform_relay_location_to_lsp_location(root_dir, argument.name.location)
-        .map(|location| Ok(GotoDefinitionResponse::Scalar(location)))?
+    state
+        .get_lsp_location(argument.name.location)
+        .map(GotoDefinitionResponse::Scalar)
 }
 
 fn locate_field_definition(
@@ -291,7 +288,7 @@ fn locate_field_definition(
     field_name: StringKey,
     extra_data_provider: &dyn LSPExtraDataProvider,
     project_name: StringKey,
-    root_dir: &std::path::Path,
+    state: &impl GlobalState,
 ) -> Result<GotoDefinitionResponse, LSPRuntimeError> {
     let field = schema.field(schema.named_field(parent_type, field_name).ok_or_else(|| {
         LSPRuntimeError::UnexpectedError(format!("Could not find field with name {}", field_name,))
@@ -334,10 +331,9 @@ fn locate_field_definition(
         }
     }
 
-    transform_relay_location_to_lsp_location(root_dir, field.name.location)
+    state
+        .get_lsp_location(field.name.location)
         .map(GotoDefinitionResponse::Scalar)
-        // If the field does not exist in the schema, that's fine
-        .map_err(|_| LSPRuntimeError::ExpectedError)
 }
 
 fn get_location(path: &str, line: u64) -> Result<lsp_types::Location, LSPRuntimeError> {

compiler/crates/relay-lsp/src/hover.rs

@@ -67,10 +67,10 @@ pub fn on_hover(
     state: &impl GlobalState,
     params: <HoverRequest as Request>::Params,
 ) -> LSPRuntimeResult<<HoverRequest as Request>::Result> {
-    let (document, position_span) =
+    let (document, location) =
         state.extract_executable_document_from_text(&params.text_document_position_params, 1)?;
 
-    let resolution_path = document.resolve((), position_span);
+    let resolution_path = document.resolve((), location.span());
 
     let project_name = state
         .extract_project_name_from_url(&params.text_document_position_params.text_document.uri)?;

compiler/crates/relay-lsp/src/location.rs

@@ -11,6 +11,8 @@ use std::path::PathBuf;
 use common::Location;
 use common::SourceLocationKey;
 use common::TextSource;
+use dashmap::DashMap;
+use extract_graphql::JavaScriptSourceFeature;
 use intern::Lookup;
 use lsp_types::Url;
 
@@ -22,6 +24,7 @@ use crate::lsp_runtime_error::LSPRuntimeResult;
 pub fn transform_relay_location_to_lsp_location(
     root_dir: &Path,
     location: Location,
+    synced_javascript_features: &DashMap<Url, Vec<JavaScriptSourceFeature>>,
 ) -> LSPRuntimeResult<lsp_types::Location> {
     match location.source_location() {
         SourceLocationKey::Standalone { path } => {
@@ -36,19 +39,28 @@ pub fn transform_relay_location_to_lsp_location(
             Ok(lsp_types::Location { uri, range })
         }
         SourceLocationKey::Embedded { path, index } => {
-            let path_to_fragment = root_dir.join(PathBuf::from(path.lookup()));
-            let uri = get_uri(&path_to_fragment)?;
+            let file_path = root_dir.join(PathBuf::from(path.lookup()));
+            let uri = get_uri(&file_path)?;
 
-            let file_contents = get_file_contents(&path_to_fragment)?;
+            let features = match synced_javascript_features.get(&uri) {
+                Some(features) => Ok(features.clone()),
+                None => {
+                    let file_contents = get_file_contents(&file_path)?;
 
-            let response = extract_graphql::extract(&file_contents);
-            let response_length = response.len();
-            let embedded_source = response.into_iter().nth(index.into()).ok_or_else(|| {
-                LSPRuntimeError::UnexpectedError(format!(
-                    "File {:?} does not contain enough graphql literals: {} needed; {} found",
-                    path_to_fragment, index, response_length
-                ))
-            })?;
+                    Ok(extract_graphql::extract(&file_contents))
+                }
+            }?;
+
+            let features_length = features.len();
+            let embedded_source = features
+                .into_iter()
+                .nth(index.try_into().unwrap())
+                .ok_or_else(|| {
+                    LSPRuntimeError::UnexpectedError(format!(
+                        "File {:?} does not contain enough graphql literals: {} needed; {} found",
+                        file_path, index, features_length
+                    ))
+                })?;
 
             let text_source = embedded_source.text_source();
             let range = text_source.to_span_range(location.span());