Implement extract function for statements also

compiler-core/src/language_server/code_action.rs

···
     }
 
     fn extract_statements(&mut self, statements: Vec<&TypedStatement>, function_end: u32) {
-        todo!("Implement for statements")
+        let Some(first) = statements.first() else {
+            return;
+        };
+        let Some(last) = statements.last() else {
+            return;
+        };
+
+        let location = SrcSpan::new(first.location().start, last.location().end);
+
+        let referenced_variables = referenced_variables_for_statements(&statements);
+
+        let code = code_at(self.module, location);
+
+        let arguments = referenced_variables.iter().map(|(name, _)| name).join(", ");
+        let call = format!("function({arguments})");
+        self.edits.replace(location, call);
+
+        let mut printer = Printer::new(&self.module.ast.names);
+
+        let parameters = referenced_variables
+            .iter()
+            .map(|(name, type_)| eco_format!("{name}: {}", printer.print_type(type_)))
+            .join(", ");
+        let return_type = printer.print_type(&last.type_());
+
+        let function = format!(
+            "\n\nfn function({parameters}) -> {return_type} {{
+  {code}
+}}"
+        );
+
+        self.edits.insert(function_end, function);
     }
 }
 
···
 }
 
 fn referenced_variables(expression: &TypedExpr) -> Vec<(EcoString, Arc<Type>)> {
-    let mut references = ReferencedVariables {
-        variables: Vec::new(),
-        defined_variables: HashSet::new(),
-    };
+    let mut references = ReferencedVariables::new();
     references.visit_typed_expr(expression);
     references.variables
 }
 
+fn referenced_variables_for_statements(
+    statements: &[&TypedStatement],
+) -> Vec<(EcoString, Arc<Type>)> {
+    let mut references = ReferencedVariables::new();
+    for statement in statements {
+        references.visit_typed_statement(*statement);
+    }
+    references.variables
+}
+
 struct ReferencedVariables {
     variables: Vec<(EcoString, Arc<Type>)>,
     defined_variables: HashSet<EcoString>,
 }
 
 impl ReferencedVariables {
+    fn new() -> Self {
+        Self {
+            variables: Vec::new(),
+            defined_variables: HashSet::new(),
+        }
+    }
+
     fn register(&mut self, name: &EcoString, type_: &Arc<Type>) {
         if self.defined_variables.contains(name) {
             return;

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

···
             .select_until(find_position_of("}\n").under_char('\n'))
     );
 }
+
+#[test]
+fn extract_function_from_statements() {
+    assert_code_action!(
+        EXTRACT_FUNCTION,
+        "
+pub fn do_things(a, b) {
+  let a = 10 + a
+  let b = 10 + b
+  let result = a * b
+  result + 3
+}
+",
+        find_position_of("let").select_until(find_position_of("* b\n").under_char('\n'))
+    );
+}

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

···
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "\npub fn do_things(a, b) {\n  let a = 10 + a\n  let b = 10 + b\n  let result = a * b\n  result + 3\n}\n"
+---
+----- BEFORE ACTION
+
+pub fn do_things(a, b) {
+  let a = 10 + a
+  ▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+  let b = 10 + b
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+  let result = a * b
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+  result + 3
+}
+
+
+----- AFTER ACTION
+
+pub fn do_things(a, b) {
+  function(a, b)
+  result + 3
+}
+
+fn function(a: Int, b: Int) -> Int {
+  let a = 10 + a
+  let b = 10 + b
+  let result = a * b
+}