Prevent duplicate naming

compiler-core/src/language_server/code_action.rs

···
         action
     }
 
+    fn function_name(&self) -> EcoString {
+        if !self.module.ast.type_info.values.contains_key("function") {
+            return "function".into();
+        }
+
+        let mut number = 2;
+        loop {
+            let name = eco_format!("function_{number}");
+            if !self.module.ast.type_info.values.contains_key(&name) {
+                return name;
+            }
+            number += 1;
+        }
+    }
+
     fn extract_expression(
         &mut self,
         expression: &TypedExpr,
···
     ) {
         let expression_code = code_at(self.module, expression.location());
 
+        let name = self.function_name();
         let arguments = parameters.iter().map(|(name, _)| name).join(", ");
-        let call = format!("function({arguments})");
+        let call = format!("{name}({arguments})");
         self.edits.replace(expression.location(), call);
 
         let mut printer = Printer::new(&self.module.ast.names);
···
         let return_type = printer.print_type(&expression.type_());
 
         let function = format!(
-            "\n\nfn function({parameters}) -> {return_type} {{
+            "\n\nfn {name}({parameters}) -> {return_type} {{
   {expression_code}
 }}"
         );
···
             }
         };
 
+        let name = self.function_name();
         let arguments = parameters.iter().map(|(name, _)| name).join(", ");
 
         let call = if returns_anything {
-            format!("let {return_value} = function({arguments})")
+            format!("let {return_value} = {name}({arguments})")
         } else {
-            format!("function({arguments})")
+            format!("{name}({arguments})")
         };
         self.edits.replace(location, call);
 
···
         let return_type = printer.print_type(&return_type);
 
         let function = format!(
-            "\n\nfn function({parameters}) -> {return_type} {{
+            "\n\nfn {name}({parameters}) -> {return_type} {{
   {code}
   {return_value}
 }}"

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

···
             .select_until(find_position_of("TEXT"))
     );
 }
+
+#[test]
+fn extract_function_when_name_already_in_scope() {
+    assert_code_action!(
+        EXTRACT_FUNCTION,
+        r#"
+fn function() { todo }
+
+pub fn do_things(a, b) {
+  let result = {
+    let a = 10 + a
+    let b = 10 + b
+    a * b
+  }
+  result + 3
+}
+"#,
+        find_position_of("= {")
+            .select_until(find_position_of("}\n").nth_occurrence(2).under_char('\n'))
+    );
+}
+
+#[test]
+fn extract_function_when_multiple_names_already_in_scope() {
+    assert_code_action!(
+        EXTRACT_FUNCTION,
+        r#"
+fn function() { todo }
+fn function_2() { todo }
+fn function_3() { todo }
+fn function_4() { todo }
+
+pub fn do_things(a, b) {
+  let result = {
+    let a = 10 + a
+    let b = 10 + b
+    a * b
+  }
+  result + 3
+}
+"#,
+        find_position_of("= {")
+            .select_until(find_position_of("}\n").nth_occurrence(5).under_char('\n'))
+    );
+}

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

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

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

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