Implement renaming for Functions, Constants and Type Variants

CHANGELOG.md

@@ -8,6 +8,40 @@
 
 ### Language server
 
+- The language server now allows renaming of functions and constants across modules.
+  For example:
+
+  ```gleam
+  // wibble.gleam
+  pub fn wibble() {
+    wibble()
+  //^ Trigger rename
+  }
+  // wobble.gleam
+  import wibble
+
+  pub fn main() {
+    wibble.wibble()
+  }
+  ```
+
+  Becomes:
+
+  ```gleam
+  // wibble.gleam
+  pub fn wobble() {
+    wobble()
+  }
+  // wobble.gleam
+  import wibble
+
+  pub fn main() {
+    wibble.wobble()
+  }
+  ```
+
+  ([Surya Rose](https://github.com/GearsDatapacks))
+
 ### Formatter
 
 ### Bug fixes

compiler-core/schema.capnp

@@ -33,6 +33,18 @@ struct Module {
   typeAliases @10 :List(Property(TypeAliasConstructor));
   documentation @11 :List(Text);
   containsEcho @12 :Bool;
+  references @13 :References;
+}
+
+struct References {
+  importedModules @0 :List(Text);
+  valueReferences @1 :List(ValueReference);
+}
+
+struct ValueReference {
+  module @0 :Text;
+  name @1 :Text;
+  references @2 :List(SrcSpan);
 }
 
 struct TypeAliasConstructor {
@@ -161,6 +173,7 @@ struct ValueConstructorVariant {
       literal @0 :Constant;
       location @1 :SrcSpan;
       module @2 :Text;
+      name @22 :Text;
       documentation @14 :Text;
       implementations @19 :Implementations;
     }

compiler-core/src/analyse.rs

@@ -22,8 +22,8 @@ use crate::{
     parse::SpannedString,
     type_::{
         self, AccessorsMap, Deprecation, ModuleInterface, Opaque, PatternConstructor,
-        RecordAccessor, Type, TypeAliasConstructor, TypeConstructor, TypeValueConstructor,
-        TypeValueConstructorField, TypeVariantConstructors, ValueConstructor,
+        RecordAccessor, References, Type, TypeAliasConstructor, TypeConstructor,
+        TypeValueConstructor, TypeValueConstructorField, TypeVariantConstructors, ValueConstructor,
         ValueConstructorVariant, Warning,
         environment::*,
         error::{Error, FeatureKind, MissingAnnotation, Named, Problems, convert_unify_error},
@@ -340,6 +340,10 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
                 type_aliases,
                 documentation,
                 contains_echo: echo_found,
+                references: References {
+                    imported_modules: env.imported_modules.into_keys().collect(),
+                    value_references: env.references.into_locations(),
+                },
             },
             names: type_names,
         };
@@ -407,6 +411,7 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
                 location,
                 literal: typed_expr.clone(),
                 module: self.module_name.clone(),
+                name: name.clone(),
                 implementations,
             },
             type_: type_.clone(),
@@ -421,6 +426,12 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
         );
         environment.insert_module_value(name.clone(), variant);
 
+        environment.references.register_reference(
+            environment.current_module.clone(),
+            name.clone(),
+            name_location,
+        );
+
         if publicity.is_private() {
             environment.init_usage(
                 name.clone(),
@@ -516,6 +527,10 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
             .map(|(a, t)| a.set_type(t.clone()))
             .collect_vec();
 
+        environment
+            .references
+            .enter_function(environment.current_module.clone(), name.clone());
+
         // Infer the type using the preregistered args + return types as a starting point
         let result = environment.in_new_scope(&mut self.problems, |environment, problems| {
             let mut expr_typer = ExprTyper::new(environment, definition, problems);
@@ -634,6 +649,12 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
             deprecation.clone(),
         );
 
+        environment.references.register_reference(
+            environment.current_module.clone(),
+            name.clone(),
+            name_location,
+        );
+
         Definition::Function(Function {
             documentation: doc,
             location,
@@ -1079,6 +1100,12 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
                 },
             );
 
+            environment.references.register_reference(
+                environment.current_module.clone(),
+                constructor.name.clone(),
+                constructor.name_location,
+            );
+
             if value_constructor_publicity.is_private() {
                 environment.init_usage(
                     constructor.name.clone(),
@@ -1624,6 +1651,7 @@ fn generalise_module_constant(
         literal: *value.clone(),
         module: module_name.clone(),
         implementations,
+        name: name.clone(),
     };
     environment.insert_variable(
         name.clone(),

compiler-core/src/analyse/imports.rs

@@ -171,6 +171,25 @@ impl<'context, 'problems> Importer<'context, 'problems> {
                     name.clone(),
                     used_name.clone(),
                 );
+                self.environment.references.register_reference(
+                    module.clone(),
+                    import_name.clone(),
+                    import.imported_name_location,
+                );
+            }
+            ValueConstructorVariant::ModuleConstant { module, .. }
+            | ValueConstructorVariant::ModuleFn { module, .. } => {
+                self.environment.init_usage(
+                    used_name.clone(),
+                    EntityKind::ImportedValue,
+                    location,
+                    self.problems,
+                );
+                self.environment.references.register_reference(
+                    module.clone(),
+                    import_name.clone(),
+                    import.imported_name_location,
+                );
             }
             _ => self.environment.init_usage(
                 used_name.clone(),

compiler-core/src/ast.rs

@@ -892,20 +892,21 @@ impl TypedDefinition {
 
             Definition::CustomType(custom) => {
                 // Check if location is within the type of one of the arguments of a constructor.
-                if let Some(annotation) = custom
+                if let Some(constructor) = custom
                     .constructors
                     .iter()
                     .find(|constructor| constructor.location.contains(byte_index))
-                    .and_then(|constructor| {
-                        constructor
-                            .arguments
-                            .iter()
-                            .find(|arg| arg.location.contains(byte_index))
-                    })
-                    .filter(|arg| arg.location.contains(byte_index))
-                    .and_then(|arg| arg.ast.find_node(byte_index, arg.type_.clone()))
                 {
-                    return Some(annotation);
+                    if let Some(annotation) = constructor
+                        .arguments
+                        .iter()
+                        .find(|arg| arg.location.contains(byte_index))
+                        .and_then(|arg| arg.ast.find_node(byte_index, arg.type_.clone()))
+                    {
+                        return Some(annotation);
+                    }
+
+                    return Some(Located::VariantConstructorDefinition(constructor));
                 }
 
                 // Note that the custom type `.location` covers the function
@@ -1077,6 +1078,8 @@ impl<A, B, C, E> Definition<A, B, C, E> {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct UnqualifiedImport {
     pub location: SrcSpan,
+    /// The location excluding the potential `as ...` clause, or the `type` keyword
+    pub imported_name_location: SrcSpan,
     pub name: EcoString,
     pub as_name: Option<EcoString>,
 }
@@ -1819,6 +1822,7 @@ pub enum Pattern<Type> {
     /// The constructor for a custom type. Starts with an uppercase letter.
     Constructor {
         location: SrcSpan,
+        name_location: SrcSpan,
         name: EcoString,
         arguments: Vec<CallArg<Self>>,
         module: Option<(EcoString, SrcSpan)>,

compiler-core/src/ast/visit.rs

@@ -469,6 +469,7 @@ pub trait Visit<'ast> {
     fn visit_typed_pattern_constructor(
         &mut self,
         location: &'ast SrcSpan,
+        name_location: &'ast SrcSpan,
         name: &'ast EcoString,
         arguments: &'ast Vec<CallArg<TypedPattern>>,
         module: &'ast Option<(EcoString, SrcSpan)>,
@@ -479,6 +480,7 @@ pub trait Visit<'ast> {
         visit_typed_pattern_constructor(
             self,
             location,
+            name_location,
             name,
             arguments,
             module,
@@ -1473,6 +1475,7 @@ where
         } => v.visit_typed_pattern_list(location, elements, tail, type_),
         Pattern::Constructor {
             location,
+            name_location,
             name,
             arguments,
             module,
@@ -1481,6 +1484,7 @@ where
             type_,
         } => v.visit_typed_pattern_constructor(
             location,
+            name_location,
             name,
             arguments,
             module,
@@ -1593,6 +1597,7 @@ pub fn visit_typed_pattern_list<'a, V>(
 pub fn visit_typed_pattern_constructor<'a, V>(
     v: &mut V,
     _location: &'a SrcSpan,
+    _name_location: &'a SrcSpan,
     _name: &'a EcoString,
     arguments: &'a Vec<CallArg<TypedPattern>>,
     _module: &'a Option<(EcoString, SrcSpan)>,

compiler-core/src/ast_folder.rs

@@ -1173,13 +1173,21 @@ pub trait PatternFolder {
 
             Pattern::Constructor {
                 location,
+                name_location,
                 name,
                 arguments,
                 module,
                 spread,
                 constructor: _,
                 type_: (),
-            } => self.fold_pattern_constructor(location, name, arguments, module, spread),
+            } => self.fold_pattern_constructor(
+                location,
+                name_location,
+                name,
+                arguments,
+                module,
+                spread,
+            ),
 
             Pattern::Tuple { location, elems } => self.fold_pattern_tuple(location, elems),
 
@@ -1289,13 +1297,15 @@ pub trait PatternFolder {
     fn fold_pattern_constructor(
         &mut self,
         location: SrcSpan,
+        name_location: SrcSpan,
         name: EcoString,
         arguments: Vec<CallArg<UntypedPattern>>,
         module: Option<(EcoString, SrcSpan)>,
         spread: Option<SrcSpan>,
     ) -> UntypedPattern {
         Pattern::Constructor {
             location,
+            name_location,
             name,
             arguments,
             module,
@@ -1390,6 +1400,7 @@ pub trait PatternFolder {
 
             Pattern::Constructor {
                 location,
+                name_location,
                 name,
                 arguments,
                 module,
@@ -1406,6 +1417,7 @@ pub trait PatternFolder {
                     .collect();
                 Pattern::Constructor {
                     location,
+                    name_location,
                     name,
                     arguments,
                     module,

compiler-core/src/build.rs

@@ -17,8 +17,8 @@ pub use self::project_compiler::{Built, Options, ProjectCompiler};
 pub use self::telemetry::{NullTelemetry, Telemetry};
 
 use crate::ast::{
-    self, CallArg, CustomType, DefinitionLocation, Pattern, TypeAst, TypedArg, TypedDefinition,
-    TypedExpr, TypedFunction, TypedPattern, TypedStatement,
+    self, CallArg, CustomType, DefinitionLocation, TypedArg, TypedDefinition, TypedExpr,
+    TypedFunction, TypedPattern, TypedRecordConstructor, TypedStatement,
 };
 use crate::type_::Type;
 use crate::{
@@ -339,6 +339,7 @@ pub enum Located<'a> {
     Statement(&'a TypedStatement),
     Expression(&'a TypedExpr),
     ModuleStatement(&'a TypedDefinition),
+    VariantConstructorDefinition(&'a TypedRecordConstructor),
     FunctionBody(&'a TypedFunction),
     Arg(&'a TypedArg),
     Annotation(SrcSpan, std::sync::Arc<Type>),
@@ -382,6 +383,10 @@ impl<'a> Located<'a> {
                 module: None,
                 span: statement.location(),
             }),
+            Self::VariantConstructorDefinition(record) => Some(DefinitionLocation {
+                module: None,
+                span: record.location,
+            }),
             Self::UnqualifiedImport(UnqualifiedImport {
                 module,
                 name,
@@ -420,6 +425,7 @@ impl<'a> Located<'a> {
 
             Located::PatternSpread { .. } => None,
             Located::ModuleStatement(definition) => None,
+            Located::VariantConstructorDefinition(_) => None,
             Located::FunctionBody(function) => None,
             Located::UnqualifiedImport(unqualified_import) => None,
             Located::ModuleName { .. } => None,

compiler-core/src/build/package_loader/tests.rs

@@ -64,6 +64,7 @@ fn write_cache(
         type_aliases: Default::default(),
         documentation: Default::default(),
         contains_echo: false,
+        references: Default::default(),
     };
     let path = Utf8Path::new("/artefact").join(format!("{name}.cache"));
     fs.write_bytes(