add parser code for lambda types

Add LambdaCaptureKind to allow specifying move/copy/borrow treatment for free variables. Tweak simplifier to *not* remove lambda values (even though they are now ) to avoid losing some errors/warnings. add lambda-lifting specialization and _ argument handling to generate Closure expressions in the move-model.
aptos-labs · Oct 21, 2024 · 2a740e8 · 2a740e8
1 parent 7cfe2c4
commit 2a740e8
Show file tree

Hide file tree

Showing 110 changed files with 1,978 additions and 27,397 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/third_party/move/evm/move-to-yul/src/context.rs b/third_party/move/evm/move-to-yul/src/context.rs
@@ -784,7 +784,7 @@ impl<'a> Context<'a> {
             Tuple(_)
             | TypeParameter(_)
             | Reference(_, _)
-            | Fun(_, _)
+            | Fun(..)
             | TypeDomain(_)
             | ResourceDomain(_, _, _)
             | Error

diff --git a/third_party/move/evm/move-to-yul/src/solidity_ty.rs b/third_party/move/evm/move-to-yul/src/solidity_ty.rs
@@ -368,7 +368,7 @@ impl SolidityType {
             },
             TypeParameter(_)
             | Reference(_, _)
-            | Fun(_, _)
+            | Fun(..)
             | TypeDomain(_)
             | ResourceDomain(_, _, _)
             | Error

diff --git a/third_party/move/move-compiler-v2/src/bytecode_generator.rs b/third_party/move/move-compiler-v2/src/bytecode_generator.rs
@@ -480,13 +480,23 @@ impl<'env> Generator<'env> {
                 self.emit_with(*id, |attr| Bytecode::SpecBlock(attr, spec));
             },
             // TODO(LAMBDA)
-            ExpData::Lambda(id, _, _) => self.error(
+            ExpData::Lambda(id, _, _, _, _) => self.error(
                 *id,
                 "Function-typed values not yet supported except as parameters to calls to inline functions",
             ),
             // TODO(LAMBDA)
-            ExpData::Invoke(_, exp, _) => self.error(
-                exp.as_ref().node_id(),
+            ExpData::MoveFunctionExp(id, _mid, _fid) => self.error(
+                *id,
+                "Function-typed values not yet supported except as parameters to calls to inline functions",
+            ),
+            // TODO(LAMBDA)
+            ExpData::Curry(id, _mask, _fnexp, _args) => self.error(
+                *id,
+                "Function-typed values not yet supported except as parameters to calls to inline functions",
+            ),
+            // TODO(LAMBDA)
+            ExpData::Invoke(id, _exp, _) => self.error(
+                *id,
                 "Calls to function values other than inline function parameters not yet supported",
             ),
             ExpData::Quant(id, _, _, _, _, _) => {
@@ -813,12 +823,6 @@ impl<'env> Generator<'env> {
 
             Operation::NoOp => {}, // do nothing
 
-            // TODO(LAMBDA)
-            Operation::Closure(..) => self.error(
-                id,
-                "Function-typed values not yet supported except as parameters to calls to inline functions",
-            ),
-
             // Non-supported specification related operations
             Operation::Exists(Some(_))
             | Operation::SpecFunction(_, _, _)

diff --git a/third_party/move/move-compiler-v2/src/env_pipeline/ast_simplifier.rs b/third_party/move/move-compiler-v2/src/env_pipeline/ast_simplifier.rs
@@ -214,7 +214,7 @@ fn find_possibly_modified_vars(
     exp.visit_positions(&mut |pos, e| {
         use ExpData::*;
         match e {
-            Invalid(_) | Value(..) | LoopCont(..) => {
+            Invalid(_) | Value(..) | LoopCont(..) | MoveFunctionExp(..) => {
                 // Nothing happens inside these expressions, so don't bother `modifying` state.
             },
             LocalVar(id, sym) => {
@@ -359,7 +359,7 @@ fn find_possibly_modified_vars(
                     _ => {},
                 }
             },
-            Lambda(node_id, pat, _) => {
+            Lambda(node_id, pat, _, _, _) => {
                 // Define a new scope for bound vars, and turn off `modifying` within.
                 match pos {
                     VisitorPosition::Pre => {
@@ -380,6 +380,19 @@ fn find_possibly_modified_vars(
                     _ => {},
                 };
             },
+            Curry(_, _mask, _fnexp, _explist) => {
+                // Turn off `modifying` inside.
+                match pos {
+                    VisitorPosition::Pre => {
+                        modifying_stack.push(modifying);
+                        modifying = false;
+                    },
+                    VisitorPosition::Post => {
+                        modifying = modifying_stack.pop().expect("unbalanced visit 10");
+                    },
+                    _ => {},
+                }
+            },
             Block(node_id, pat, _, _) => {
                 // Define a new scope for bound vars, and turn off `modifying` within.
                 match pos {
@@ -978,7 +991,8 @@ impl<'env> ExpRewriterFunctions for SimplifierRewriter<'env> {
                     let ability_set = self
                         .env()
                         .type_abilities(&ty, self.func_env.get_type_parameters_ref());
-                    ability_set.has_ability(Ability::Drop)
+                    // Don't drop a function-valued expression so we don't lose errors.
+                    !ty.has_function() && ability_set.has_ability(Ability::Drop)
                 } else {
                     // We're missing type info, be conservative
                     false

diff --git a/third_party/move/move-compiler-v2/src/env_pipeline/flow_insensitive_checkers.rs b/third_party/move/move-compiler-v2/src/env_pipeline/flow_insensitive_checkers.rs
@@ -147,7 +147,7 @@ impl<'env, 'params> SymbolVisitor<'env, 'params> {
                 Pre | Post | BeforeBody | MidMutate | BeforeThen | BeforeElse
                 | PreSequenceValue => {},
             },
-            Lambda(_, pat, _) => {
+            Lambda(_, pat, _, _, _) => {
                 match position {
                     Pre => self.seen_uses.enter_scope(),
                     Post => {

diff --git a/third_party/move/move-compiler-v2/src/env_pipeline/function_checker.rs b/third_party/move/move-compiler-v2/src/env_pipeline/function_checker.rs
@@ -20,8 +20,8 @@ fn identify_function_types_with_functions_in_args(func_types: Vec<Type>) -> Vec<
     func_types
         .into_iter()
         .filter_map(|ty| {
-            if let Type::Fun(argt, _) = &ty {
-                if argt.deref().has_function() {
+            if let Type::Fun(args, _, _) = &ty {
+                if args.deref().has_function() {
                     Some(ty)
                 } else {
                     None
@@ -41,8 +41,8 @@ fn identify_function_typed_params_with_functions_in_rets(
     func_types
         .iter()
         .filter_map(|param| {
-            if let Type::Fun(_argt, rest) = &param.1 {
-                let rest_unboxed = rest.deref();
+            if let Type::Fun(_args, result, _) = &param.1 {
+                let rest_unboxed = result.deref();
                 if rest_unboxed.has_function() {
                     Some((*param, rest_unboxed))
                 } else {
@@ -270,7 +270,7 @@ fn check_privileged_operations_on_structs(env: &GlobalEnv, fun_env: &FunctionEnv
                 },
                 ExpData::Assign(_, pat, _)
                 | ExpData::Block(_, pat, _, _)
-                | ExpData::Lambda(_, pat, _) => {
+                | ExpData::Lambda(_, pat, _, _, _) => {
                     pat.visit_pre_post(&mut |_, pat| {
                         if let Pattern::Struct(id, str, _, _) = pat {
                             let module_id = str.module_id;
@@ -344,7 +344,7 @@ pub fn check_access_and_use(env: &mut GlobalEnv, before_inlining: bool) {
 
                 // Check that functions being called are accessible.
                 if let Some(def) = caller_func.get_def() {
-                    let callees_with_sites = def.called_funs_with_callsites();
+                    let callees_with_sites = def.used_funs_with_uses();
                     for (callee, sites) in &callees_with_sites {
                         let callee_func = env.get_function(*callee);
                         // Check visibility.

diff --git a/third_party/move/move-compiler-v2/src/env_pipeline/inliner.rs b/third_party/move/move-compiler-v2/src/env_pipeline/inliner.rs
@@ -90,7 +90,7 @@ pub fn run_inlining(env: &mut GlobalEnv, scope: RewritingScope, keep_inline_func
         let mut visited_targets = BTreeSet::new();
         while let Some(target) = todo.pop_first() {
             if visited_targets.insert(target.clone()) {
-                let callees_with_sites = target.called_funs_with_call_sites(env);
+                let callees_with_sites = target.used_funs_with_uses(env);
                 for (callee, sites) in callees_with_sites {
                     todo.insert(RewriteTarget::MoveFun(callee));
                     targets.entry(RewriteTarget::MoveFun(callee));
@@ -1161,7 +1161,7 @@ impl<'env, 'rewriter> ExpRewriterFunctions for InlinedRewriter<'env, 'rewriter>
         };
         let call_loc = self.env.get_node_loc(id);
         if let Some(lambda_target) = optional_lambda_target {
-            if let ExpData::Lambda(_, pat, body) = lambda_target.as_ref() {
+            if let ExpData::Lambda(_, pat, body, _, _) = lambda_target.as_ref() {
                 let args_vec: Vec<Exp> = args.to_vec();
                 Some(InlinedRewriter::construct_inlined_call_expression(
                     self.env,