Add support for dynamic records (#29232)

* Add support for dynamic records

This change adds the `dyn record` primitive type to expose the new
dynamic record functionality.

One can cast any record to a `dyn record`:

```leo
record Token { owner: address, balance: u64 }

fn foo(owner: address, balance: u64) -> dyn record {
    let t = Token { owner, balance };
    let dt = t as dyn record;
    return dt;
}
```

One can take the value of a field from a `dyn record`, provided it is
cast to a type and exists at runtime:

```leo
fn foo(dt: dyn record) -> u64 {
    let balance: u64 = dt.balance;
    return balance;
}
```

* Add tests

Author: IGI-111

crates/abi-types/src/lib.rs

@@ -200,6 +200,7 @@ pub enum Plaintext {
 pub enum FunctionInput {
     Plaintext(Plaintext),
     Record(RecordRef),
+    DynamicRecord,
 }
 
 /// Valid types for function outputs. Aleo: `transition` outputs.
@@ -209,6 +210,7 @@ pub enum FunctionOutput {
     Record(RecordRef),
     /// Aleo `future` - the handle for an on-chain finalization.
     Final,
+    DynamicRecord,
 }
 
 /// Primitive types that map directly to Aleo literal types.

crates/abi/src/aleo.rs

@@ -94,6 +94,9 @@ fn convert_output(output: &ast::Output, record_names: &HashSet<Symbol>) -> abi::
 }
 
 fn convert_function_input(ty: &ast::Type, record_names: &HashSet<Symbol>) -> abi::FunctionInput {
+    if let ast::Type::DynRecord = ty {
+        return abi::FunctionInput::DynamicRecord;
+    }
     if let ast::Type::Composite(comp_ty) = ty {
         let name = comp_ty.path.identifier().name;
         if record_names.contains(&name) {
@@ -109,6 +112,7 @@ fn convert_function_input(ty: &ast::Type, record_names: &HashSet<Symbol>) -> abi
 fn convert_function_output(ty: &ast::Type, record_names: &HashSet<Symbol>) -> abi::FunctionOutput {
     match ty {
         ast::Type::Future(_) => abi::FunctionOutput::Final,
+        ast::Type::DynRecord => abi::FunctionOutput::DynamicRecord,
         ast::Type::Composite(comp_ty) => {
             let name = comp_ty.path.identifier().name;
             if record_names.contains(&name) {

crates/abi/src/lib.rs

@@ -194,6 +194,9 @@ fn convert_plaintext(ty: &ast::Type) -> abi::Plaintext {
 }
 
 fn convert_function_input(ty: &ast::Type, ctx: &Ctx) -> abi::FunctionInput {
+    if let ast::Type::DynRecord = ty {
+        return abi::FunctionInput::DynamicRecord;
+    }
     if let ast::Type::Composite(comp_ty) = ty
         && is_record(comp_ty, ctx)
     {
@@ -208,6 +211,7 @@ fn convert_function_input(ty: &ast::Type, ctx: &Ctx) -> abi::FunctionInput {
 fn convert_function_output(ty: &ast::Type, ctx: &Ctx) -> abi::FunctionOutput {
     match ty {
         ast::Type::Future(_) => abi::FunctionOutput::Final,
+        ast::Type::DynRecord => abi::FunctionOutput::DynamicRecord,
         ast::Type::Composite(comp_ty) if is_record(comp_ty, ctx) => abi::FunctionOutput::Record(abi::RecordRef {
             path: comp_ty.path.segments_iter().map(|s| s.to_string()).collect(),
             program: comp_ty.path.program().map(|s| s.to_string()),
@@ -358,6 +362,7 @@ fn collect_from_function_input(ty: &abi::FunctionInput, program_name: &str, used
                 used.insert(rec_ref.path.clone());
             }
         }
+        abi::FunctionInput::DynamicRecord => {}
     }
 }
 
@@ -370,6 +375,7 @@ fn collect_from_function_output(ty: &abi::FunctionOutput, program_name: &str, us
             }
         }
         abi::FunctionOutput::Final => {}
+        abi::FunctionOutput::DynamicRecord => {}
     }
 }
 

crates/errors/src/errors/type_checker/type_checker_error.rs

@@ -1438,4 +1438,18 @@ create_messages!(
         msg: format!("Dynamic calls can only be made from an entry point, but found one in {context}."),
         help: None,
     }
+
+    @formatted
+    dyn_record_field_requires_type {
+        args: (field: impl Display),
+        msg: format!("Accessing field `{field}` on a `dyn record` requires a type annotation."),
+        help: Some(format!("Use `let x: <type> = r.{field};` or `r.{field} as <type>`.")),
+    }
+
+    @formatted
+    cannot_cast_to_dyn_record {
+        args: (type_: impl Display),
+        msg: format!("Cannot cast `{type_}` to `dyn record`: only concrete record types can be cast to `dyn record`."),
+        help: None,
+    }
 );

crates/parser-rowan/src/lexer.rs

@@ -292,6 +292,7 @@ fn ident_to_kind(s: &str) -> SyntaxKind {
         "signature" => KW_SIGNATURE,
         "string" => KW_STRING,
         "record" => KW_RECORD,
+        "dyn" => KW_DYN,
         "identifier" => KW_IDENTIFIER,
         "i8" => KW_I8,
         "i16" => KW_I16,

crates/parser-rowan/src/parser/types.rs

@@ -54,6 +54,7 @@ impl Parser<'_, '_> {
         KW_SIGNATURE,
         KW_STRING,
         KW_IDENTIFIER,
+        KW_DYN,
         KW_I8,
         KW_I16,
         KW_I32,
@@ -129,7 +130,12 @@ impl Parser<'_, '_> {
         // isn't captured inside the TYPE_PRIMITIVE.
         self.skip_trivia();
         let m = self.start();
+        let kind = self.current();
         self.bump_raw();
+        // `dyn record` is a two-token primitive type.
+        if kind == KW_DYN {
+            self.expect(KW_RECORD);
+        }
         Some(m.complete(self, TYPE_PRIMITIVE))
     }
 

crates/parser-rowan/src/syntax_kind.rs

@@ -127,6 +127,8 @@ define_syntax_kinds! {
     KW_STRING,
     /// `record`
     KW_RECORD,
+    /// `dyn`
+    KW_DYN,
     /// `identifier`
     KW_IDENTIFIER,
     /// `Final`
@@ -596,6 +598,7 @@ impl SyntaxKind {
                 | KW_SIGNATURE
                 | KW_STRING
                 | KW_RECORD
+                | KW_DYN
                 | KW_IDENTIFIER
                 | KW_FINAL_UPPER
                 | KW_I8
@@ -651,6 +654,7 @@ impl SyntaxKind {
                 | KW_SCALAR
                 | KW_SIGNATURE
                 | KW_STRING
+                | KW_DYN
                 | KW_IDENTIFIER
                 | KW_FINAL_UPPER
                 | KW_I8
@@ -853,6 +857,7 @@ impl SyntaxKind {
             KW_SIGNATURE => "'signature'",
             KW_STRING => "'string'",
             KW_RECORD => "'record'",
+            KW_DYN => "'dyn'",
             KW_IDENTIFIER => "'identifier'",
             KW_FINAL_UPPER => "'Final'",
             KW_I8 => "'i8'",

crates/parser/src/rowan.rs

@@ -2935,6 +2935,7 @@ fn keyword_to_primitive_type(kind: SyntaxKind) -> Option<leo_ast::Type> {
         KW_SCALAR => leo_ast::Type::Scalar,
         KW_SIGNATURE => leo_ast::Type::Signature,
         KW_STRING => leo_ast::Type::String,
+        KW_DYN => leo_ast::Type::DynRecord,
         KW_IDENTIFIER => leo_ast::Type::Identifier,
         KW_U8 => leo_ast::Type::Integer(leo_ast::IntegerType::U8),
         KW_U16 => leo_ast::Type::Integer(leo_ast::IntegerType::U16),

crates/passes/src/code_generation/expression.rs

@@ -16,6 +16,8 @@
 
 use super::*;
 
+use leo_span::sym;
+
 use leo_ast::{
     ArrayAccess,
     ArrayExpression,
@@ -69,7 +71,10 @@ impl CodeGeneratingVisitor<'_> {
 
         match input {
             Expression::ArrayAccess(expr) => (Some(self.visit_array_access(expr)), vec![]),
-            Expression::MemberAccess(expr) => (Some(self.visit_member_access(expr)), vec![]),
+            Expression::MemberAccess(expr) => {
+                let (expr, stmts) = self.visit_member_access(expr);
+                (Some(expr), stmts)
+            }
             Expression::Path(expr) => (Some(self.visit_path(expr)), vec![]),
             Expression::Literal(expr) => (Some(self.visit_value(expr)), vec![]),
 
@@ -405,11 +410,28 @@ impl CodeGeneratingVisitor<'_> {
         AleoExpr::ArrayAccess(Box::new(array_operand), Box::new(index_operand))
     }
 
-    fn visit_member_access(&mut self, input: &MemberAccess) -> AleoExpr {
-        let (inner_expr, _) = self.visit_expression(&input.inner);
+    fn visit_member_access(&mut self, input: &MemberAccess) -> (AleoExpr, Vec<AleoStmt>) {
+        let (inner_expr, mut instructions) = self.visit_expression(&input.inner);
         let inner_expr = inner_expr.expect("Trying to access a member of an empty expression.");
 
-        AleoExpr::MemberAccess(Box::new(inner_expr), input.name.to_string())
+        // Check if the inner expression is a dyn record.
+        let inner_type = self.state.type_table.get(&input.inner.id());
+        if matches!(inner_type, Some(Type::DynRecord)) && input.name.name != sym::owner {
+            // Non-owner field access on dyn record: emit get.record.dynamic.
+            let result_type = self.state.type_table.get(&input.id).expect("Type should be resolved.");
+            let dest_reg = self.next_register();
+            let aleo_type = self.visit_type(&result_type);
+            instructions.push(AleoStmt::GetRecordDynamic(
+                inner_expr,
+                input.name.to_string(),
+                dest_reg.clone(),
+                aleo_type,
+            ));
+            return (AleoExpr::Reg(dest_reg), instructions);
+        }
+
+        // Regular member access (or .owner on dyn record).
+        (AleoExpr::MemberAccess(Box::new(inner_expr), input.name.to_string()), instructions)
     }
 
     fn visit_repeat(&mut self, input: &RepeatExpression) -> (AleoExpr, Vec<AleoStmt>) {

crates/passes/src/code_generation/mod.rs

@@ -421,6 +421,7 @@ pub enum AleoStmt {
         Vec<AleoReg>,
         Vec<(AleoType, Option<AleoVisibility>)>,
     ),
+    GetRecordDynamic(AleoExpr, String, AleoReg, AleoType),
     Async(String, Vec<AleoExpr>, Vec<AleoReg>),
     BranchEq(AleoExpr, AleoExpr, String),
     Position(String),
@@ -468,6 +469,9 @@ impl Display for AleoStmt {
             Self::Cast(operands, dest, type_) => {
                 writeln!(f, "    cast {operands} into {dest} as {type_};")
             }
+            Self::GetRecordDynamic(src, field, dest, type_) => {
+                writeln!(f, "    get.record.dynamic {src}.{field} into {dest} as {type_};")
+            }
             Self::Abs(op, dest) => writeln!(f, "    abs {op} into {dest};"),
             Self::AbsW(op, dest) => writeln!(f, "    abs.w {op} into {dest};"),
             Self::Double(op, dest) => writeln!(f, "    double {op} into {dest};"),