Fix renaming module selects in guards

Author: GearsDatapacks

CHANGELOG.md

@@ -165,3 +165,7 @@
   a dev dependency, while previously it would incorrectly let these
   dependencies to be imported.
   ([Surya Rose](https://github.com/GearsDatapacks))
+
+- Fixed a bug where renaming a constant which is referenced in another module
+  inside a guard would generate invalid code.
+  ([Surya Rose](https://github.com/GearsDatapacks))

compiler-core/src/ast.rs

@@ -2047,7 +2047,7 @@ pub enum ClauseGuard<Type, RecordTag> {
     },
 
     FieldAccess {
-        location: SrcSpan,
+        label_location: SrcSpan,
         index: Option<u64>,
         label: EcoString,
         type_: Type,
@@ -2093,9 +2093,13 @@ impl<A, B> ClauseGuard<A, B> {
             | ClauseGuard::DivInt { location, .. }
             | ClauseGuard::DivFloat { location, .. }
             | ClauseGuard::RemainderInt { location, .. }
-            | ClauseGuard::FieldAccess { location, .. }
             | ClauseGuard::LtEqFloat { location, .. }
             | ClauseGuard::ModuleSelect { location, .. } => *location,
+            ClauseGuard::FieldAccess {
+                label_location,
+                container,
+                ..
+            } => container.location().merge(label_location),
         }
     }
 

compiler-core/src/ast/visit.rs

@@ -382,13 +382,13 @@ pub trait Visit<'ast> {
 
     fn visit_typed_clause_guard_field_access(
         &mut self,
-        location: &'ast SrcSpan,
+        label_location: &'ast SrcSpan,
         index: &'ast Option<u64>,
         label: &'ast EcoString,
         type_: &'ast Arc<Type>,
         container: &'ast TypedClauseGuard,
     ) {
-        visit_typed_clause_guard_field_access(self, location, index, label, type_, container)
+        visit_typed_clause_guard_field_access(self, label_location, index, label, type_, container)
     }
 
     fn visit_typed_clause_guard_module_select(
@@ -1384,12 +1384,14 @@ where
             tuple,
         } => v.visit_typed_clause_guard_tuple_index(location, index, type_, tuple),
         super::ClauseGuard::FieldAccess {
-            location,
+            label_location,
             index,
             label,
             type_,
             container,
-        } => v.visit_typed_clause_guard_field_access(location, index, label, type_, container),
+        } => {
+            v.visit_typed_clause_guard_field_access(label_location, index, label, type_, container)
+        }
         super::ClauseGuard::ModuleSelect {
             location,
             type_,
@@ -1434,7 +1436,7 @@ pub fn visit_typed_clause_guard_tuple_index<'a, V>(
 
 pub fn visit_typed_clause_guard_field_access<'a, V>(
     v: &mut V,
-    _location: &'a SrcSpan,
+    _label_location: &'a SrcSpan,
     _index: &'a Option<u64>,
     _label: &'a EcoString,
     _type_: &'a Arc<Type>,

compiler-core/src/language_server/tests/rename.rs

@@ -1526,3 +1526,27 @@ pub fn main() {
         find_position_of("Ok")
     );
 }
+
+#[test]
+fn rename_module_access_in_clause_guard() {
+    assert_rename!(
+        (
+            "wibble",
+            "
+import app
+
+pub fn main() {
+  case app.something {
+    thing if thing == app.something -> True
+    _ -> False
+  }
+}
+"
+        ),
+        "
+pub const something = 10
+",
+        "new_name",
+        find_position_of("something")
+    );
+}

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__rename__rename_module_access_in_clause_guard.snap

@@ -0,0 +1,39 @@
+---
+source: compiler-core/src/language_server/tests/rename.rs
+expression: "\npub const something = 10\n"
+---
+----- BEFORE RENAME
+-- wibble.gleam
+
+import app
+
+pub fn main() {
+  case app.something {
+    thing if thing == app.something -> True
+    _ -> False
+  }
+}
+
+
+-- app.gleam
+
+pub const something = 10
+          ↑▔▔▔▔▔▔▔▔     
+
+
+----- AFTER RENAME
+-- wibble.gleam
+
+import app
+
+pub fn main() {
+  case app.new_name {
+    thing if thing == app.new_name -> True
+    _ -> False
+  }
+}
+
+
+-- app.gleam
+
+pub const new_name = 10

compiler-core/src/parse.rs

@@ -1782,13 +1782,13 @@ where
                             }
                         }
 
-                        Some((_, Token::Name { name: label }, int_e)) => {
+                        Some((name_start, Token::Name { name: label }, name_end)) => {
                             self.parse_function_call_in_clause_guard(start)?;
 
                             unit = ClauseGuard::FieldAccess {
-                                location: SrcSpan {
-                                    start: dot_s,
-                                    end: int_e,
+                                label_location: SrcSpan {
+                                    start: name_start,
+                                    end: name_end,
                                 },
                                 index: None,
                                 label,

compiler-core/src/type_/expression.rs

@@ -2370,20 +2370,22 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
             }
 
             ClauseGuard::FieldAccess {
-                location,
+                label_location,
                 label,
                 container,
                 index: _,
                 type_: (),
             } => match self.infer_clause_guard(*container.clone()) {
-                Ok(container) => self.infer_guard_record_access(container, label, location),
+                Ok(container) => self.infer_guard_record_access(container, label, label_location),
 
                 Err(err) => match *container {
                     ClauseGuard::Var { name, location, .. } => {
-                        self.infer_guard_module_access(name, label, location, err)
+                        self.infer_guard_module_access(name, label, location, label_location, err)
                     }
 
-                    _ => Err(Error::RecordAccessUnknownType { location }),
+                    _ => Err(Error::RecordAccessUnknownType {
+                        location: label_location,
+                    }),
                 },
             },
 
@@ -2820,7 +2822,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
             container,
             label,
             index: Some(index),
-            location,
+            label_location: location,
             type_,
         })
     }
@@ -2829,11 +2831,12 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
         &mut self,
         name: EcoString,
         label: EcoString,
-        location: SrcSpan,
+        module_location: SrcSpan,
+        label_location: SrcSpan,
         record_access_error: Error,
     ) -> Result<TypedClauseGuard, Error> {
         let module_access = self
-            .infer_module_access(&name, label, &location, location)
+            .infer_module_access(&name, label, &module_location, label_location)
             .and_then(|ma| match ma {
                 TypedExpr::ModuleSelect {
                     location,
@@ -2849,7 +2852,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                             module_name.clone(),
                             label.clone(),
                             &label,
-                            location,
+                            label_location,
                             ReferenceKind::Qualified,
                         );
 
@@ -2866,7 +2869,9 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                     _ => Err(Error::RecordAccessUnknownType { location }),
                 },
 
-                _ => Err(Error::RecordAccessUnknownType { location }),
+                _ => Err(Error::RecordAccessUnknownType {
+                    location: module_location,
+                }),
             });
 
         // If the name is in the environment, use the original error from

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__guards__string_variable_access.snap

@@ -14,10 +14,10 @@ pub fn a(a: String) {
 
 ----- ERROR
 error: Unknown record field
-  ┌─ /src/one/two.gleam:4:11
+  ┌─ /src/one/two.gleam:4:12
   │
 4 │     _ if a.b -> 1
-  │           ^^ This field does not exist
+  │            ^ This field does not exist
 
 The value being accessed has this type: