[move-2024][enums] Struct matching (#17172)

## Description 

This introduces struct matching in match expressions. The major changes
include:

1. Extending path resolution to handle some cases more-generally.
1. Revising name resolution to combine a lot of the data structure name
resolution machinery
    - This now discriminates results more-locally.
- This also pulls out the previous positional versus named constructor
misuse error machinery out into a helper function we can reuse in
patterns and expressions, simplifying the expression logic and ensuring
consistent message formats.
1. Revisions to how types are tracked in unpack statements in enums to
match how they are handled in struct unpacks (that is, field types are
never reference-wrapped, even if the unpack is a borrow-flavored
unpack). This ensures consistent handling during match compilation, at
the cost of some extra computation around fringe types during final
match arm creation.
1. Finally, extending match completion to actually handle struct
unpacking.

This also make a few smaller fixes/changes:

1. Fixes a bug that occurred when unpacking empty struct borrows.
1. Revises some of the verbage around borrow error reporting for
matching.
1. Struct fields carry if they were positional or not down into match
compilation (though maybe all of that should go live in name
resolution...).
1. Marks the recursive result builder in `match_compilation` as
`#[growing_stack]`

## Test plan 

A set of new tests (though we always need more).

---

## Release notes

Check each box that your changes affect. If none of the boxes relate to
your changes, release notes aren't required.

For each box you select, include information after the relevant heading
that describes the impact of your changes that a user might notice and
any actions they must take to implement updates.

- [ ] Protocol: 
- [ ] Nodes (Validators and Full nodes): 
- [ ] Indexer: 
- [ ] JSON-RPC: 
- [ ] GraphQL: 
- [ ] CLI: 
- [ ] Rust SDK:

Author: cgswords

crates/move-analyzer/src/symbols.rs

@@ -1555,7 +1555,7 @@ fn get_mod_outer_defs(
         // process field structs first
         let mut field_defs = vec![];
         let mut field_types = vec![];
-        if let StructFields::Defined(fields) = &def.fields {
+        if let StructFields::Defined(_positional, fields) = &def.fields {
             for (fpos, fname, (_, t)) in fields {
                 let start = match get_start_loc(&fpos, files, file_id_mapping) {
                     Some(s) => s,
@@ -2244,7 +2244,7 @@ impl<'a> ParsingSymbolicator<'a> {
 
 impl<'a> TypingSymbolicator<'a> {
     /// Get symbols for the whole module
-    fn mod_symbols(&mut self, mod_def: &ModuleDefinition, mod_ident_str: &String) {
+    fn mod_symbols(&mut self, mod_def: &ModuleDefinition, mod_ident_str: &str) {
         for (pos, name, fun) in &mod_def.functions {
             // enter self-definition for function name (unwrap safe - done when inserting def)
             let name_start = get_start_loc(&pos, self.files, self.file_id_mapping).unwrap();
@@ -2355,27 +2355,17 @@ impl<'a> TypingSymbolicator<'a> {
     fn struct_symbols(
         &mut self,
         struct_def: &StructDefinition,
-        struct_name: &Symbol,
-        mod_ident_str: &String,
+        _struct_name: &Symbol,
+        _mod_ident_str: &str,
     ) {
         // create scope designated to contain type parameters (if any)
         let mut tp_scope = BTreeMap::new();
         for stp in &struct_def.type_parameters {
             self.add_type_param(&stp.param, &mut tp_scope);
         }
 
-        let positional = self
-            .mod_outer_defs
-            .get(mod_ident_str)
-            .map_or(false, |mod_defs| {
-                mod_defs
-                    .structs
-                    .get(struct_name)
-                    .map_or(false, |sdef| sdef.positional)
-            });
-
         self.type_params = tp_scope;
-        if let StructFields::Defined(fields) = &struct_def.fields {
+        if let StructFields::Defined(positional, fields) = &struct_def.fields {
             for (fpos, fname, (_, t)) in fields {
                 self.add_type_id_use_def(t);
                 if !positional {

crates/move-compiler-transactional-tests/tests/matching/fib.exp

@@ -0,0 +1 @@
+processed 3 tasks

crates/move-compiler-transactional-tests/tests/matching/fib.move

@@ -0,0 +1,33 @@
+//# init --edition development
+
+//# publish
+module 0x42::m {
+
+    public fun fib(n: u64): u64 {
+        match (n) {
+            0 => 0,
+            1 => 1,
+            n => fib(n-1) + fib(n-2)
+        }
+    }
+
+}
+
+//# run
+module 0x42::main {
+
+    fun main() {
+        use 0x42::m::fib;
+        assert!(fib(0) == 0, 0);
+        assert!(fib(1) == 1, 1);
+        assert!(fib(2) == 1, 2);
+        assert!(fib(3) == 2, 3);
+        assert!(fib(4) == 3, 4);
+        assert!(fib(5) == 5, 5);
+        assert!(fib(6) == 8, 6);
+        assert!(fib(7) == 13, 7);
+        assert!(fib(8) == 21, 8);
+        assert!(fib(9) == 34, 9);
+        assert!(fib(10) == 55, 10);
+    }
+}

crates/move-compiler-transactional-tests/tests/matching/struct_match.exp

@@ -0,0 +1 @@
+processed 3 tasks