Track all possible references to variables

compiler-core/src/language_server/code_action.rs

···
         constructor: &'ast ValueConstructor,
         name: &'ast EcoString,
     ) {
-        match &constructor.variant {
-            type_::ValueConstructorVariant::LocalVariable {
-                location: definition_location,
-                ..
-            } => {
-                self.register_referenced_variable(
-                    name,
-                    &constructor.type_,
-                    *location,
-                    *definition_location,
-                );
-            }
-            type_::ValueConstructorVariant::ModuleConstant { .. }
-            | type_::ValueConstructorVariant::LocalConstant { .. }
-            | type_::ValueConstructorVariant::ModuleFn { .. }
-            | type_::ValueConstructorVariant::Record { .. } => {}
+        if let type_::ValueConstructorVariant::LocalVariable {
+            location: definition_location,
+            ..
+        } = &constructor.variant
+        {
+            self.register_referenced_variable(
+                name,
+                &constructor.type_,
+                *location,
+                *definition_location,
+            );
+        }
+    }
+
+    fn visit_typed_clause_guard_var(
+        &mut self,
+        location: &'ast SrcSpan,
+        name: &'ast EcoString,
+        type_: &'ast Arc<Type>,
+        definition_location: &'ast SrcSpan,
+    ) {
+        self.register_referenced_variable(name, type_, *location, *definition_location);
+    }
+
+    fn visit_typed_bit_array_size_variable(
+        &mut self,
+        location: &'ast SrcSpan,
+        name: &'ast EcoString,
+        constructor: &'ast Option<Box<ValueConstructor>>,
+        type_: &'ast Arc<Type>,
+    ) {
+        let variant = match constructor {
+            Some(constructor) => &constructor.variant,
+            None => return,
+        };
+        if let type_::ValueConstructorVariant::LocalVariable {
+            location: definition_location,
+            ..
+        } = variant
+        {
+            self.register_referenced_variable(name, type_, *location, *definition_location);
         }
     }
 }

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

···
         find_position_of("let").select_until(find_position_of("echo x\n").under_char('\n'))
     );
 }
+
+#[test]
+fn extract_function_which_uses_variable_in_guard() {
+    assert_code_action!(
+        EXTRACT_FUNCTION,
+        "
+pub fn do_things(a, b) {
+  let result = case Nil {
+    _ if a > b -> 17
+    _ if a < b -> 12
+    _ -> panic
+  }
+
+  result % 4
+}
+",
+        find_position_of("case").select_until(find_position_of("}\n").under_char('\n'))
+    );
+}
+
+#[test]
+fn extract_function_which_uses_variable_in_bit_array_pattern() {
+    assert_code_action!(
+        EXTRACT_FUNCTION,
+        "
+pub fn main() {
+  let bits = todo
+  let size = todo
+
+  let segment = case bits {
+    <<x:size(size), _:bits>> -> Ok(x)
+    _ -> Error(Nil)
+  }
+
+  case segment {
+    Ok(value) -> echo value
+    Error(_) -> panic
+  }
+}
+",
+        find_position_of("case").select_until(find_position_of("}\n").under_char('\n'))
+    );
+}

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

···
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "\npub fn main() {\n  let bits = todo\n  let size = todo\n\n  let segment = case bits {\n    <<x:size(size), _:bits>> -> Ok(x)\n    _ -> Error(Nil)\n  }\n\n  case segment {\n    Ok(value) -> echo value\n    Error(_) -> panic\n  }\n}\n"
+---
+----- BEFORE ACTION
+
+pub fn main() {
+  let bits = todo
+  let size = todo
+
+  let segment = case bits {
+                ▔▔▔▔▔▔▔▔▔▔▔
+    <<x:size(size), _:bits>> -> Ok(x)
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+    _ -> Error(Nil)
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+  }
+▔▔▔
+
+  case segment {
+    Ok(value) -> echo value
+    Error(_) -> panic
+  }
+}
+
+
+----- AFTER ACTION
+
+pub fn main() {
+  let bits = todo
+  let size = todo
+
+  let segment = function(bits, size)
+
+  case segment {
+    Ok(value) -> echo value
+    Error(_) -> panic
+  }
+}
+
+fn function(bits: BitArray, size: Int) -> Result(Int, Nil) {
+  case bits {
+    <<x:size(size), _:bits>> -> Ok(x)
+    _ -> Error(Nil)
+  }
+}

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

···
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "\npub fn do_things(a, b) {\n  let result = case Nil {\n    _ if a > b -> 17\n    _ if a < b -> 12\n    _ -> panic\n  }\n\n  result % 4\n}\n"
+---
+----- BEFORE ACTION
+
+pub fn do_things(a, b) {
+  let result = case Nil {
+               ▔▔▔▔▔▔▔▔▔▔
+    _ if a > b -> 17
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+    _ if a < b -> 12
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+    _ -> panic
+▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+  }
+▔▔▔
+
+  result % 4
+}
+
+
+----- AFTER ACTION
+
+pub fn do_things(a, b) {
+  let result = function(a, b)
+
+  result % 4
+}
+
+fn function(a: Int, b: Int) -> Int {
+  case Nil {
+    _ if a > b -> 17
+    _ if a < b -> 12
+    _ -> panic
+  }
+}