Allow selecting partial expressions

Author: GearsDatapacks

compiler-core/src/language_server/code_action.rs

@@ -8810,6 +8810,49 @@ impl<'a> ExtractFunction<'a> {
 
         variables.push((name.clone(), type_.clone()));
     }
+
+    fn can_extract(&self, location: SrcSpan) -> bool {
+        let expression_range = self.edits.src_span_to_lsp_range(location);
+        let selected_range = self.params.range;
+
+        // If the selected range doesn't touch the expression at all, then there
+        // is no reason to extract it.
+        if !overlaps(expression_range, selected_range) {
+            return false;
+        }
+
+        // Determine whether the selected range falls completely within the
+        // expression. For example:
+        // ```gleam
+        // pub fn main() {
+        //   let something = {
+        //     let a = 1
+        //     let b = 2
+        //     let c = a + b
+        //   //^ The user has selected from here
+        //     let d = a * b
+        //     c / d
+        //     //  ^ Until here
+        //   }
+        // }
+        // ```
+        //
+        // Here, the selected range does overlap with the `let something`
+        // statement; but we don't want to extract that whole statement! The
+        // user only wanted to extract the statements inside the block. So if
+        // the selected range falls completely within the expression, we ignore
+        // it and traverse the tree further until we find exactly what the user
+        // selected.
+        //
+        let selected_within_expression = selected_range.start > expression_range.start
+            && selected_range.start < expression_range.end
+            && selected_range.end > expression_range.start
+            && selected_range.end < expression_range.end;
+
+        // If the selected range is completely within the expression, we don't
+        // want to extract it.
+        !selected_within_expression
+    }
 }
 
 impl<'ast> ast::visit::Visit<'ast> for ExtractFunction<'ast> {
@@ -8830,10 +8873,8 @@ impl<'ast> ast::visit::Visit<'ast> for ExtractFunction<'ast> {
         // extracting just a single literal in any selection, which is of course
         // not desired.
         if self.function.is_none() {
-            let range = self.edits.src_span_to_lsp_range(expression.location());
-
             // If this expression is fully selected, we mark it as being extracted.
-            if within(range, self.params.range) {
+            if self.can_extract(expression.location()) {
                 self.function = Some(ExtractedFunction::new(ExtractedValue::Expression(
                     expression,
                 )));
@@ -8843,8 +8884,7 @@ impl<'ast> ast::visit::Visit<'ast> for ExtractFunction<'ast> {
     }
 
     fn visit_typed_statement(&mut self, statement: &'ast TypedStatement) {
-        let range = self.edits.src_span_to_lsp_range(statement.location());
-        if within(range, self.params.range) {
+        if self.can_extract(statement.location()) {
             match &mut self.function {
                 None => {
                     self.function = Some(ExtractedFunction::new(ExtractedValue::Statements(

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

@@ -10245,7 +10245,7 @@ pub fn do_things(a, b) {
 ",
         find_position_of("{")
             .nth_occurrence(2)
-            .select_until(find_position_of("}\n").under_char('\n'))
+            .select_until(find_position_of("}"))
     );
 }
 
@@ -10261,7 +10261,7 @@ pub fn do_things(a, b) {
   result + 3
 }
 ",
-        find_position_of("let").select_until(find_position_of("* b\n").under_char('\n'))
+        find_position_of("let").select_until(find_position_of("* b"))
     );
 }
 
@@ -10277,7 +10277,7 @@ pub fn do_things(a, b) {
   result + 3
 }
 ",
-        find_position_of("let").select_until(find_position_of("* new_b\n").under_char('\n'))
+        find_position_of("let").select_until(find_position_of("* new_b"))
     );
 }
 
@@ -10296,7 +10296,7 @@ pub fn do_things(a, b) {
   result + 3
 }
 ",
-        find_position_of("let").select_until(find_position_of("+ a * b\n").under_char('\n'))
+        find_position_of("let").select_until(find_position_of("+ a * b"))
     );
 }
 
@@ -10311,7 +10311,7 @@ pub fn do_things(a, b) {
   wobble / wibble
 }
 ",
-        find_position_of("let").select_until(find_position_of("* b\n").under_char('\n'))
+        find_position_of("let").select_until(find_position_of("* b"))
     );
 }
 
@@ -10326,7 +10326,7 @@ pub fn do_things(a, b) {
   a
 }
 ",
-        find_position_of("let").select_until(find_position_of("echo x\n").under_char('\n'))
+        find_position_of("let").select_until(find_position_of("echo x"))
     );
 }
 
@@ -10345,7 +10345,7 @@ pub fn do_things(a, b) {
   result % 4
 }
 ",
-        find_position_of("case").select_until(find_position_of("}\n").under_char('\n'))
+        find_position_of("case").select_until(find_position_of("}"))
     );
 }
 
@@ -10369,7 +10369,7 @@ pub fn main() {
   }
 }
 ",
-        find_position_of("case").select_until(find_position_of("}\n").under_char('\n'))
+        find_position_of("case").select_until(find_position_of("}"))
     );
 }
 
@@ -10388,7 +10388,7 @@ pub fn main() {
   echo circumference
 }
 ",
-        find_position_of("radius *.").select_until(find_position_of("2.0\n").under_char('\n'))
+        find_position_of("radius *.").select_until(find_position_of("2.0"))
     );
 }
 
@@ -10412,7 +10412,7 @@ pub fn main() {
   echo string
 }
 "#,
-        find_position_of("case").select_until(find_position_of("}\n").under_char('\n'))
+        find_position_of("case").select_until(find_position_of("}"))
     );
 }
 
@@ -10454,8 +10454,7 @@ pub fn do_things(a, b) {
   result + 3
 }
 "#,
-        find_position_of("= {")
-            .select_until(find_position_of("}\n").nth_occurrence(2).under_char('\n'))
+        find_position_of("= {").select_until(find_position_of("}").nth_occurrence(2))
     );
 }
 
@@ -10478,7 +10477,63 @@ pub fn do_things(a, b) {
   result + 3
 }
 "#,
-        find_position_of("= {")
-            .select_until(find_position_of("}\n").nth_occurrence(5).under_char('\n'))
+        find_position_of("= {").select_until(find_position_of("}").nth_occurrence(5))
+    );
+}
+
+#[test]
+fn extract_function_partially_selected() {
+    assert_code_action!(
+        EXTRACT_FUNCTION,
+        r#"
+pub fn main() {
+  let a = 10
+  let b = 20
+  let c = a + b
+
+  echo c
+}
+"#,
+        find_position_of("a =").select_until(find_position_of("c ="))
+    );
+}
+
+#[test]
+fn selected_statements_do_not_select_outer_block() {
+    // We want to make sure only the statements within the block are extracted,
+    // and not the block itself.
+    assert_code_action!(
+        EXTRACT_FUNCTION,
+        r#"
+pub fn main() {
+  let c = {
+    let a = 10
+    let b = 20
+    a + b
+  }
+
+  echo c
+}
+"#,
+        find_position_of("let a").select_until(find_position_of("+ b"))
+    );
+}
+
+#[test]
+fn no_code_action_to_extract_when_multiple_functions_are_selected() {
+    assert_no_code_actions!(
+        EXTRACT_FUNCTION,
+        r#"
+pub fn main() {
+  let a = 10
+  a + 1
+}
+
+pub fn other() {
+  let b = 20
+  b * 2
+}
+"#,
+        find_position_of("let a").select_until(find_position_of("let b"))
     );
 }

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

@@ -14,7 +14,7 @@ pub fn do_things(a, b) {
     a * b
 ▔▔▔▔▔▔▔▔▔
   }
-▔▔▔
+▔▔↑
   result + 3
 }
 

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

@@ -10,7 +10,7 @@ pub fn do_things(a, b) {
   let b = 10 + b
 ▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
   let result = a * b
-▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔↑  
   result + 3
 }
 

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

@@ -0,0 +1,32 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "\npub fn main() {\n  let a = 10\n  let b = 20\n  let c = a + b\n\n  echo c\n}\n"
+---
+----- BEFORE ACTION
+
+pub fn main() {
+  let a = 10
+      ▔▔▔▔▔▔
+  let b = 20
+▔▔▔▔▔▔▔▔▔▔▔▔
+  let c = a + b
+▔▔▔▔▔▔↑        
+
+  echo c
+}
+
+
+----- AFTER ACTION
+
+pub fn main() {
+  let c = function()
+
+  echo c
+}
+
+fn function() -> Int {
+  let a = 10
+  let b = 20
+  let c = a + b
+  c
+}

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

@@ -19,7 +19,7 @@ pub fn do_things(a, b) {
     a * b
 ▔▔▔▔▔▔▔▔▔
   }
-▔▔▔
+▔▔↑
   result + 3
 }
 

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

@@ -16,7 +16,7 @@ pub fn do_things(a, b) {
     a * b
 ▔▔▔▔▔▔▔▔▔
   }
-▔▔▔
+▔▔↑
   result + 3
 }
 

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

@@ -10,7 +10,7 @@ pub fn do_things(a, b) {
   let new_b = 10 + b
 ▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
   let result = new_a * new_b
-▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔↑      
   result + 3
 }
 

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

@@ -16,7 +16,7 @@ pub fn do_things(a, b) {
   }
 ▔▔▔
   let result = first_part + a * b
-▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔↑      
   result + 3
 }
 

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

@@ -10,7 +10,7 @@ pub fn main() {
   let radius = 4.5
 
   let circumference = radius *. pi *. 2.0
-                      ▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+                      ▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔↑  
 
   echo circumference
 }