Code actions to add and remove anonymous functions

CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## Unreleased
 
+- The language server now offers code actions to wrap a function reference in an
+  anonymous function, or to remove a trivial anonymous function, leaving its
+  contents. For example:
+
+  ```gleam
+  pub fn main() {
+    [-1, -2, -3] |> list.map(fn(a) { int.absolute_value(a) })
+                          // ^^ Activating the "Remove anonymous function"
+                          // code action here
+  }
+  ```
+
+  would result in:
+
+  ```gleam
+  pub fn main() {
+    [-1, -2, -3] |> list.map(int.absolute_value)
+  }
+  ```
+
+  while the other action would reverse the change. ([Eli Treuherz](http.github.com/treuherz))
+
 ### Compiler
 
 - The compiler now performs function inlining optimisations for a specific set

compiler-core/src/ast/typed.rs

@@ -76,6 +76,7 @@ pub enum TypedExpr {
         type_: Arc<Type>,
         fun: Box<Self>,
         arguments: Vec<CallArg<Self>>,
+        arguments_start: Option<u32>,
     },
 
     BinOp {

compiler-core/src/ast/untyped.rs

@@ -53,6 +53,7 @@ pub enum UntypedExpr {
         location: SrcSpan,
         fun: Box<Self>,
         arguments: Vec<CallArg<Self>>,
+        arguments_start: u32,
     },
 
     BinOp {
@@ -293,11 +294,18 @@ impl HasLocation for UntypedExpr {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum FunctionLiteralKind {
     Capture { hole: SrcSpan },
-    Anonymous { head: SrcSpan },
+    Anonymous { head: SrcSpan, body: SrcSpan },
     Use { location: SrcSpan },
 }
 
 impl FunctionLiteralKind {
+    pub fn is_anonymous(&self) -> bool {
+        match self {
+            FunctionLiteralKind::Anonymous { .. } => true,
+            FunctionLiteralKind::Capture { .. } | FunctionLiteralKind::Use { .. } => false,
+        }
+    }
+
     pub fn is_capture(&self) -> bool {
         match self {
             FunctionLiteralKind::Capture { .. } => true,

compiler-core/src/ast/visit.rs

@@ -196,8 +196,9 @@ pub trait Visit<'ast> {
         type_: &'ast Arc<Type>,
         fun: &'ast TypedExpr,
         arguments: &'ast [TypedCallArg],
+        arguments_start: &'ast Option<u32>,
     ) {
-        visit_typed_expr_call(self, location, type_, fun, arguments);
+        visit_typed_expr_call(self, location, type_, fun, arguments, arguments_start);
     }
 
     fn visit_typed_expr_bin_op(
@@ -814,7 +815,8 @@ where
             type_,
             fun,
             arguments,
-        } => v.visit_typed_expr_call(location, type_, fun, arguments),
+            arguments_start,
+        } => v.visit_typed_expr_call(location, type_, fun, arguments, arguments_start),
         TypedExpr::BinOp {
             location,
             type_,
@@ -1049,6 +1051,7 @@ pub fn visit_typed_expr_call<'a, V>(
     _type_: &'a Arc<Type>,
     fun: &'a TypedExpr,
     arguments: &'a [TypedCallArg],
+    _arguments_start: &'a Option<u32>,
 ) where
     V: Visit<'a> + ?Sized,
 {

compiler-core/src/ast_folder.rs

@@ -289,7 +289,8 @@ pub trait UntypedExprFolder: TypeAstFolder + UntypedConstantFolder + PatternFold
                 location,
                 fun,
                 arguments,
-            } => self.fold_call(location, fun, arguments),
+                arguments_start,
+            } => self.fold_call(location, fun, arguments, arguments_start),
 
             UntypedExpr::BinOp {
                 location,
@@ -445,6 +446,7 @@ pub trait UntypedExprFolder: TypeAstFolder + UntypedConstantFolder + PatternFold
                 location,
                 fun,
                 arguments,
+                arguments_start,
             } => {
                 let fun = Box::new(self.fold_expr(*fun));
                 let arguments = arguments
@@ -458,6 +460,7 @@ pub trait UntypedExprFolder: TypeAstFolder + UntypedConstantFolder + PatternFold
                     location,
                     fun,
                     arguments,
+                    arguments_start,
                 }
             }
 
@@ -770,11 +773,13 @@ pub trait UntypedExprFolder: TypeAstFolder + UntypedConstantFolder + PatternFold
         location: SrcSpan,
         fun: Box<UntypedExpr>,
         arguments: Vec<CallArg<UntypedExpr>>,
+        arguments_start: u32,
     ) -> UntypedExpr {
         UntypedExpr::Call {
             location,
             fun,
             arguments,
+            arguments_start,
         }
     }
 

compiler-core/src/format.rs

@@ -1592,6 +1592,7 @@ impl<'comments> Formatter<'comments> {
             fun,
             arguments,
             location,
+            ..
         })) = call.first()
         else {
             // The body of a capture being not a fn shouldn't be possible...

compiler-core/src/inline.rs

@@ -363,7 +363,8 @@ impl Inliner<'_> {
                 type_,
                 fun,
                 arguments,
-            } => self.call(location, type_, fun, arguments),
+                arguments_start,
+            } => self.call(location, type_, fun, arguments, arguments_start),
 
             TypedExpr::BinOp {
                 location,
@@ -581,6 +582,7 @@ impl Inliner<'_> {
         type_: Arc<Type>,
         function: Box<TypedExpr>,
         arguments: Vec<TypedCallArg>,
+        arguments_start: Option<u32>,
     ) -> TypedExpr {
         let arguments = self.arguments(arguments);
 
@@ -699,6 +701,7 @@ impl Inliner<'_> {
             type_,
             fun: Box::new(function),
             arguments,
+            arguments_start,
         }
     }
 
@@ -1534,6 +1537,7 @@ impl InlinableExpression {
                     .iter()
                     .map(|argument| argument.to_call_arg(Self::to_expression))
                     .collect(),
+                arguments_start: None,
             },
         }
     }