[move-compiler] Add positional struct fields (#14073)

## Description 

Adds support for positional struct fields in Move 2024.

This affects the parser, expansion, and naming (and a minor update is
needed in `to_bytecode`).

## Parser
* Updated to support positional struct declarations
* Updated dotted field accesses to support valid struct indices
* Updated binding parsing to support positional struct destructuring

## Expansion
* Added support for conversion of a `Call` to `Unpack` if it's in an
`LValue` position (similar to what we do in expansion for `Pack` to
`Unpack` in LValue position).

## Naming
* Positional fields are removed at this point 
* `Call`s are disambiguated into `Packs` or remain as `Call`s based on
the name references an in-scope struct type.
* We enforce that named packs/unpacks and positional packs/unpacks
correspond to a named/positional struct declaration.

## Test Plan 

Added a number of tests for each phase. 

---
If your changes are not user-facing and not a breaking change, you can
skip the following section. Otherwise, please indicate what changed, and
then add to the Release Notes section as highlighted during the release
process.

### Type of Change (Check all that apply)

- [ ] protocol change
- [X] user-visible impact
- [ ] breaking change for a client SDKs
- [ ] breaking change for FNs (FN binary must upgrade)
- [ ] breaking change for validators or node operators (must upgrade
binaries)
- [ ] breaking change for on-chain data layout
- [ ] necessitate either a data wipe or data migration

### Release notes

Adds positional struct declaration support to Move 2024.alpha. When
using the 2024 edition you'll be able to declare structs with positional
fields (e.g., `public struct Positional(u64, bool)`), access positional
struct fields via their index (e.g., `x.0` `,x.1`) and unpack/pack them
positionally (e.g., `let Positional(value, is_tf) = x;`, `let x =
Positional(0, true)`).

Author: tzakian

move-compiler/src/diagnostics/codes.rs

@@ -220,6 +220,7 @@ codes!(
         UnboundField: { msg: "unbound field", severity: BlockingError },
         ReservedName: { msg: "invalid use of reserved name", severity: BlockingError },
         UnboundMacro: { msg: "unbound macro", severity: BlockingError },
+        PositionalCallMismatch: { msg: "positional call mismatch", severity: NonblockingError },
     ],
     // errors for typing rules. mostly typing/translate
     TypeSafety: [

move-compiler/src/editions/mod.rs

@@ -31,6 +31,7 @@ pub enum FeatureGate {
     PostFixAbilities,
     StructTypeVisibility,
     DotCall,
+    PositionalFields,
 }
 
 #[derive(PartialEq, Eq, Clone, Copy, Debug, PartialOrd, Ord, Default)]
@@ -97,6 +98,7 @@ const E2024_ALPHA_FEATURES: &[FeatureGate] = &[
     FeatureGate::PostFixAbilities,
     FeatureGate::StructTypeVisibility,
     FeatureGate::DotCall,
+    FeatureGate::PositionalFields,
 ];
 
 impl Edition {
@@ -169,6 +171,7 @@ impl FeatureGate {
             FeatureGate::PostFixAbilities => "Postfix abilities are",
             FeatureGate::StructTypeVisibility => "Struct visibility modifiers are",
             FeatureGate::DotCall => "Method syntax is",
+            FeatureGate::PositionalFields => "Positional fields are",
         }
     }
 }

move-compiler/src/expansion/ast.rs

@@ -210,7 +210,8 @@ pub struct StructDefinition {
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum StructFields {
-    Defined(Fields<Type>),
+    Positional(Vec<Type>),
+    Named(Fields<Type>),
     Native(Loc),
 }
 
@@ -403,10 +404,16 @@ pub type Type = Spanned<Type_>;
 // Expressions
 //**************************************************************************************************
 
+#[derive(Debug, Clone, PartialEq)]
+pub enum FieldBindings {
+    Named(Fields<LValue>),
+    Positional(Vec<LValue>),
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum LValue_ {
     Var(ModuleAccess, Option<Vec<Type>>),
-    Unpack(ModuleAccess, Option<Vec<Type>>, Fields<LValue>),
+    Unpack(ModuleAccess, Option<Vec<Type>>, FieldBindings),
 }
 pub type LValue = Spanned<LValue_>;
 pub type LValueList_ = Vec<LValue>;
@@ -1188,15 +1195,23 @@ impl AstDebug for (StructName, &StructDefinition) {
         w.write(&format!("struct#{index} {name}"));
         type_parameters.ast_debug(w);
         ability_modifiers_ast_debug(w, abilities);
-        if let StructFields::Defined(fields) = fields {
-            w.block(|w| {
+        match fields {
+            StructFields::Named(fields) => w.block(|w| {
                 w.list(fields, ",", |w, (_, f, idx_st)| {
                     let (idx, st) = idx_st;
                     w.write(&format!("{}#{}: ", idx, f));
                     st.ast_debug(w);
                     true
                 });
-            })
+            }),
+            StructFields::Positional(fields) => w.block(|w| {
+                w.list(fields.iter().enumerate(), ",", |w, (idx, ty)| {
+                    w.write(&format!("{idx}#pos{idx}: "));
+                    ty.ast_debug(w);
+                    true
+                });
+            }),
+            StructFields::Native(_) => (),
         }
     }
 }
@@ -1863,20 +1878,14 @@ impl AstDebug for LValue_ {
                     w.write(">");
                 }
             }
-            L::Unpack(ma, tys_opt, fields) => {
+            L::Unpack(ma, tys_opt, field_binds) => {
                 ma.ast_debug(w);
                 if let Some(ss) = tys_opt {
                     w.write("<");
                     ss.ast_debug(w);
                     w.write(">");
                 }
-                w.write("{");
-                w.comma(fields, |w, (_, f, idx_b)| {
-                    let (idx, b) = idx_b;
-                    w.write(&format!("{}#{}: ", idx, f));
-                    b.ast_debug(w);
-                });
-                w.write("}");
+                field_binds.ast_debug(w);
             }
         }
     }
@@ -1912,3 +1921,27 @@ impl AstDebug for Vec<Vec<Exp>> {
         }
     }
 }
+
+impl AstDebug for FieldBindings {
+    fn ast_debug(&self, w: &mut AstWriter) {
+        match self {
+            FieldBindings::Named(fields) => {
+                w.write("{");
+                w.comma(fields, |w, (_, f, idx_b)| {
+                    let (idx, b) = idx_b;
+                    w.write(&format!("{}#{}: ", idx, f));
+                    b.ast_debug(w);
+                });
+                w.write("}");
+            }
+            FieldBindings::Positional(vals) => {
+                w.write("(");
+                w.comma(vals.iter().enumerate(), |w, (idx, lval)| {
+                    w.write(&format!("{idx}: "));
+                    lval.ast_debug(w);
+                });
+                w.write(")");
+            }
+        }
+    }
+}

move-compiler/src/expansion/translate.rs

@@ -12,7 +12,8 @@ use crate::{
         byte_string, hex_string,
     },
     parser::ast::{
-        self as P, Ability, ConstantName, Field, FunctionName, ModuleName, StructName, Var,
+        self as P, Ability, ConstantName, Field, FieldBindings, FunctionName, ModuleName,
+        StructName, Var,
     },
     shared::{known_attributes::AttributePosition, unique_map::UniqueMap, *},
     FullyCompiledProgram,
@@ -1461,6 +1462,10 @@ fn struct_fields(
 ) -> E::StructFields {
     let pfields_vec = match pfields {
         P::StructFields::Native(loc) => return E::StructFields::Native(loc),
+        P::StructFields::Positional(tys) => {
+            let field_tys = tys.into_iter().map(|fty| type_(context, fty)).collect();
+            return E::StructFields::Positional(field_tys);
+        }
         P::StructFields::Defined(v) => v,
     };
     let mut field_map = UniqueMap::new();
@@ -1480,7 +1485,7 @@ fn struct_fields(
             ));
         }
     }
-    E::StructFields::Defined(field_map)
+    E::StructFields::Named(field_map)
 }
 
 //**************************************************************************************************
@@ -2278,7 +2283,7 @@ fn exp_(context: &mut Context, sp!(loc, pe_): P::Exp) -> E::Exp {
                 .into_iter()
                 .map(|(f, pe)| (f, exp_(context, pe)))
                 .collect();
-            let efields = fields(context, loc, "construction", "argument", efields_vec);
+            let efields = named_fields(context, loc, "construction", "argument", efields_vec);
             match en_opt {
                 Some(en) => EE::Pack(en, tys_opt, efields),
                 None => {
@@ -2562,7 +2567,7 @@ fn num_too_big_error(loc: Loc, type_description: &'static str) -> Diagnostic {
 // Fields
 //**************************************************************************************************
 
-fn fields<T>(
+fn named_fields<T>(
     context: &mut Context,
     loc: Loc,
     case: &str,
@@ -2621,11 +2626,24 @@ fn bind(context: &mut Context, sp!(loc, pb_): P::Bind) -> Option<E::LValue> {
         PB::Unpack(ptn, ptys_opt, pfields) => {
             let tn = name_access_chain(context, Access::ApplyNamed, *ptn)?;
             let tys_opt = optional_types(context, ptys_opt);
-            let vfields: Option<Vec<(Field, E::LValue)>> = pfields
-                .into_iter()
-                .map(|(f, pb)| Some((f, bind(context, pb)?)))
-                .collect();
-            let fields = fields(context, loc, "deconstruction binding", "binding", vfields?);
+            let fields = match pfields {
+                FieldBindings::Named(named_bindings) => {
+                    let vfields: Option<Vec<(Field, E::LValue)>> = named_bindings
+                        .into_iter()
+                        .map(|(f, pb)| Some((f, bind(context, pb)?)))
+                        .collect();
+                    let fields =
+                        named_fields(context, loc, "deconstruction binding", "binding", vfields?);
+                    E::FieldBindings::Named(fields)
+                }
+                FieldBindings::Positional(positional_bindings) => {
+                    let fields: Option<Vec<E::LValue>> = positional_bindings
+                        .into_iter()
+                        .map(|b| bind(context, b))
+                        .collect();
+                    E::FieldBindings::Positional(fields?)
+                }
+            };
             EL::Unpack(tn, tys_opt, fields)
         }
     };
@@ -2723,7 +2741,16 @@ fn assign(context: &mut Context, sp!(loc, e_): P::Exp) -> Option<E::LValue> {
             let en = name_access_chain(context, Access::ApplyNamed, pn)?;
             let tys_opt = optional_types(context, ptys_opt);
             let efields = assign_unpack_fields(context, loc, pfields)?;
-            EL::Unpack(en, tys_opt, efields)
+            EL::Unpack(en, tys_opt, E::FieldBindings::Named(efields))
+        }
+        PE::Call(pn, false, ptys_opt, sp!(_, exprs)) => {
+            context
+                .env
+                .check_feature(FeatureGate::PositionalFields, context.current_package, loc);
+            let en = name_access_chain(context, Access::ApplyNamed, pn)?;
+            let tys_opt = optional_types(context, ptys_opt);
+            let pfields: Option<_> = exprs.into_iter().map(|e| assign(context, e)).collect();
+            EL::Unpack(en, tys_opt, E::FieldBindings::Positional(pfields?))
         }
         _ => {
             context.env.add_diag(diag!(
@@ -2749,7 +2776,7 @@ fn assign_unpack_fields(
         .into_iter()
         .map(|(f, e)| Some((f, assign(context, e)?)))
         .collect::<Option<_>>()?;
-    Some(fields(
+    Some(named_fields(
         context,
         loc,
         "deconstructing assignment",
@@ -2924,9 +2951,14 @@ fn unbound_names_bind(unbound: &mut BTreeSet<Name>, sp!(_, l_): &E::LValue) {
         EL::Var(sp!(_, E::ModuleAccess_::ModuleAccess(..)), _) => {
             // Qualified vars are not considered in unbound set.
         }
-        EL::Unpack(_, _, efields) => efields
-            .iter()
-            .for_each(|(_, _, (_, l))| unbound_names_bind(unbound, l)),
+        EL::Unpack(_, _, efields) => match efields {
+            E::FieldBindings::Named(efields) => efields
+                .iter()
+                .for_each(|(_, _, (_, l))| unbound_names_bind(unbound, l)),
+            E::FieldBindings::Positional(lvals) => {
+                lvals.iter().for_each(|l| unbound_names_bind(unbound, l))
+            }
+        },
     }
 }
 
@@ -2945,9 +2977,14 @@ fn unbound_names_assign(unbound: &mut BTreeSet<Name>, sp!(_, l_): &E::LValue) {
         EL::Var(sp!(_, E::ModuleAccess_::ModuleAccess(..)), _) => {
             // Qualified vars are not considered in unbound set.
         }
-        EL::Unpack(_, _, efields) => efields
-            .iter()
-            .for_each(|(_, _, (_, l))| unbound_names_assign(unbound, l)),
+        EL::Unpack(_, _, efields) => match efields {
+            E::FieldBindings::Named(efields) => efields
+                .iter()
+                .for_each(|(_, _, (_, l))| unbound_names_assign(unbound, l)),
+            E::FieldBindings::Positional(lvals) => {
+                lvals.iter().for_each(|l| unbound_names_assign(unbound, l))
+            }
+        },
     }
 }