add warning (#17647)

Author: rahxephon89

third_party/move/move-compiler-v2/src/env_pipeline/closure_checker.rs

@@ -17,6 +17,7 @@ use move_core_types::ability::Ability;
 use move_model::{
     ast::{ExpData, Operation},
     model::GlobalEnv,
+    ty::Type,
     well_known,
 };
 
@@ -90,6 +91,12 @@ pub fn check_closures(env: &GlobalEnv) {
                         };
                         for captured in args {
                             let captured_ty = env.get_node_type(captured.node_id());
+                            // when capturing a value that contains option, we need to generate a warning
+                            // After refactoring option type to use enum, we can lift this limitation
+                            // TODO: remove it after option type is refactored to use enum
+                            if contains_option_type(env, &captured_ty) {
+                                env.warning(&env.get_node_loc(captured.node_id()), "capturing option values is currently not supported");
+                            }
                             if captured_ty.is_reference() {
                                 env.error(
                                     &env.get_node_loc(captured.node_id()),
@@ -135,3 +142,49 @@ pub fn check_closures(env: &GlobalEnv) {
         }
     }
 }
+
+/// Check if the type contains an option type
+/// Note that this function does not find contained options within reference types/function types
+/// because it is used for checking captured values only
+fn contains_option_type(env: &GlobalEnv, ty: &Type) -> bool {
+    match ty {
+        Type::Vector(ty) => contains_option_type(env, ty),
+        Type::Struct(mid, sid, tys) => {
+            let struct_env = env.get_module(*mid).into_struct(*sid);
+            if struct_env.is_option_type() {
+                return true;
+            }
+            if struct_env.has_variants() {
+                for variant in struct_env.get_variants() {
+                    for field in struct_env.get_fields_of_variant(variant) {
+                        if contains_option_type(env, &field.get_type()) {
+                            return true;
+                        }
+                    }
+                }
+            } else {
+                for field in struct_env.get_fields() {
+                    if contains_option_type(env, &field.get_type()) {
+                        return true;
+                    }
+                }
+            }
+            tys.iter()
+                .zip(struct_env.get_type_parameters().iter())
+                .filter(|(_, param)| !param.1.is_phantom)
+                .any(|(t, _)| contains_option_type(env, t))
+        },
+        // since fun params and result does not appear in layout, we can safely return false,
+        Type::Fun(..) => false,
+        Type::Primitive(..) => false,
+        // compiler error will be generated separately
+        // we are looking at option values that are captured, and because references cannot be captured,
+        // we do not have to recurse here.
+        Type::Reference(..) => false,
+        Type::TypeParameter(..) => false,
+        _ => unreachable!(
+            "ICE: argument with type `{}` should not appear in this context",
+            ty.display(&env.get_type_display_ctx())
+        ),
+    }
+}

third_party/move/move-compiler-v2/tests/checking-lang-v2.2/lambda/capturing_option_1.exp

@@ -0,0 +1,63 @@
+
+Diagnostics:
+warning: capturing option values is currently not supported
+   ┌─ tests/checking-lang-v2.2/lambda/capturing_option_1.move:11:66
+   │
+11 │         let f: ||option::Option<u64> has copy+drop+store = || id(v);
+   │                                                                  ^
+
+warning: capturing option values is currently not supported
+   ┌─ tests/checking-lang-v2.2/lambda/capturing_option_1.move:16:67
+   │
+16 │         let _f: ||option::Option<u64> has copy+drop+store = || id(v);
+   │                                                                   ^
+
+// -- Model dump before first bytecode pipeline
+module 0x99::m {
+    use std::option;
+    struct FunctionStore {
+        f: ||0x1::option::Option<u64> has copy + drop + store,
+    }
+    private entry fun entry_func() {
+        {
+          let v: 0x1::option::Option<u64> = option::none<u64>();
+          {
+            let _f: ||0x1::option::Option<u64> has copy + drop + store = closure#1m::id(v);
+            Tuple()
+          }
+        }
+    }
+    public fun id(x: 0x1::option::Option<u64>): 0x1::option::Option<u64> {
+        x
+    }
+    private fun init_module(account: &signer) {
+        {
+          let v: 0x1::option::Option<u64> = option::none<u64>();
+          {
+            let f: ||0x1::option::Option<u64> has copy + drop + store = closure#1m::id(v);
+            MoveTo<FunctionStore>(account, pack m::FunctionStore(f));
+            Tuple()
+          }
+        }
+    }
+} // end 0x99::m
+
+// -- Sourcified model before first bytecode pipeline
+module 0x99::m {
+    use std::option;
+    struct FunctionStore has key {
+        f: ||0x1::option::Option<u64> has copy + drop + store,
+    }
+    entry fun entry_func() {
+        let v = 0x1::option::none<u64>();
+        let _f: ||0x1::option::Option<u64> has copy + drop + store = || id(v);
+    }
+    public fun id(x: 0x1::option::Option<u64>): 0x1::option::Option<u64> {
+        x
+    }
+    fun init_module(account: &signer) {
+        let v = 0x1::option::none<u64>();
+        let f: ||0x1::option::Option<u64> has copy + drop + store = || id(v);
+        move_to<FunctionStore>(FunctionStore{f: f}, account);
+    }
+}

third_party/move/move-compiler-v2/tests/checking-lang-v2.2/lambda/capturing_option_1.move

@@ -0,0 +1,18 @@
+module 0x99::m {
+    use std::option;
+    struct FunctionStore has key {
+        f: ||option::Option<u64> has copy+drop+store,
+    }
+    public fun id(x: option::Option<u64>): option::Option<u64> {
+        x
+    }
+    fun init_module(account: &signer) {
+        let v = option::none();
+        let f: ||option::Option<u64> has copy+drop+store = || id(v);
+        move_to(account, FunctionStore { f });
+    }
+    entry fun entry_func() {
+        let v = option::none();
+        let _f: ||option::Option<u64> has copy+drop+store = || id(v);
+    }
+}

third_party/move/move-compiler-v2/tests/checking-lang-v2.2/lambda/capturing_option_2.exp

@@ -0,0 +1,48 @@
+
+Diagnostics:
+warning: capturing option values is currently not supported
+   ┌─ tests/checking-lang-v2.2/lambda/capturing_option_2.move:14:67
+   │
+14 │         let _f: ||option::Option<u64> has copy+drop+store = || id(v);
+   │                                                                   ^
+
+// -- Model dump before first bytecode pipeline
+module 0x99::m {
+    use std::option;
+    struct FunctionStore {
+        f: ||0x1::option::Option<u64> has copy + drop + store,
+    }
+    struct OptionStore {
+        o: 0x1::option::Option<u64>,
+    }
+    private entry fun entry_func() {
+        {
+          let v: OptionStore = pack m::OptionStore(option::none<u64>());
+          {
+            let _f: ||0x1::option::Option<u64> has copy + drop + store = closure#1m::id(v);
+            Tuple()
+          }
+        }
+    }
+    public fun id(x: OptionStore): 0x1::option::Option<u64> {
+        select m::OptionStore.o<OptionStore>(x)
+    }
+} // end 0x99::m
+
+// -- Sourcified model before first bytecode pipeline
+module 0x99::m {
+    use std::option;
+    struct FunctionStore has key {
+        f: ||0x1::option::Option<u64> has copy + drop + store,
+    }
+    struct OptionStore has copy, drop, store {
+        o: 0x1::option::Option<u64>,
+    }
+    entry fun entry_func() {
+        let v = OptionStore{o: 0x1::option::none<u64>()};
+        let _f: ||0x1::option::Option<u64> has copy + drop + store = || id(v);
+    }
+    public fun id(x: OptionStore): 0x1::option::Option<u64> {
+        x.o
+    }
+}

third_party/move/move-compiler-v2/tests/checking-lang-v2.2/lambda/capturing_option_2.move

@@ -0,0 +1,16 @@
+module 0x99::m {
+    use std::option;
+    struct OptionStore has copy,drop,store {
+        o: option::Option<u64>,
+    }
+    struct FunctionStore has key {
+        f: ||option::Option<u64> has copy+drop+store,
+    }
+    public fun id(x: OptionStore): option::Option<u64> {
+        x.o
+    }
+    entry fun entry_func() {
+        let v = OptionStore { o: option::none() };
+        let _f: ||option::Option<u64> has copy+drop+store = || id(v);
+    }
+}

third_party/move/move-compiler-v2/tests/checking-lang-v2.2/lambda/capturing_option_3.exp

@@ -0,0 +1,44 @@
+
+Diagnostics:
+warning: capturing option values is currently not supported
+   ┌─ tests/checking-lang-v2.2/lambda/capturing_option_3.move:12:67
+   │
+12 │         let _f: ||option::Option<u64> has copy+drop+store = || id(v);
+   │                                                                   ^
+
+// -- Model dump before first bytecode pipeline
+module 0x99::m {
+    use std::option;
+    use std::vector;
+    struct FunctionStore {
+        f: ||0x1::option::Option<u64> has copy + drop + store,
+    }
+    private entry fun entry_func() {
+        {
+          let v: vector<0x1::option::Option<u64>> = vector::empty<0x1::option::Option<u64>>();
+          {
+            let _f: ||0x1::option::Option<u64> has copy + drop + store = closure#1m::id(v);
+            Tuple()
+          }
+        }
+    }
+    public fun id(_x: vector<0x1::option::Option<u64>>): 0x1::option::Option<u64> {
+        option::none<u64>()
+    }
+} // end 0x99::m
+
+// -- Sourcified model before first bytecode pipeline
+module 0x99::m {
+    use std::option;
+    use std::vector;
+    struct FunctionStore has key {
+        f: ||0x1::option::Option<u64> has copy + drop + store,
+    }
+    entry fun entry_func() {
+        let v = 0x1::vector::empty<0x1::option::Option<u64>>();
+        let _f: ||0x1::option::Option<u64> has copy + drop + store = || id(v);
+    }
+    public fun id(_x: vector<0x1::option::Option<u64>>): 0x1::option::Option<u64> {
+        0x1::option::none<u64>()
+    }
+}

third_party/move/move-compiler-v2/tests/checking-lang-v2.2/lambda/capturing_option_3.move

@@ -0,0 +1,14 @@
+module 0x99::m {
+    use std::option;
+    use std::vector;
+    struct FunctionStore has key {
+        f: ||option::Option<u64> has copy+drop+store,
+    }
+    public fun id(_x: vector<option::Option<u64>>): option::Option<u64> {
+        option::none()
+    }
+    entry fun entry_func() {
+        let v = vector::empty();
+        let _f: ||option::Option<u64> has copy+drop+store = || id(v);
+    }
+}

third_party/move/move-compiler-v2/tests/checking-lang-v2.2/lambda/capturing_option_4.exp

@@ -0,0 +1,69 @@
+
+Diagnostics:
+warning: capturing option values is currently not supported
+   ┌─ tests/checking-lang-v2.2/lambda/capturing_option_4.move:14:66
+   │
+14 │         let f: ||option::Option<u64> has copy+drop+store = || id(v);
+   │                                                                  ^
+
+warning: capturing option values is currently not supported
+   ┌─ tests/checking-lang-v2.2/lambda/capturing_option_4.move:19:67
+   │
+19 │         let _f: ||option::Option<u64> has copy+drop+store = || id(v);
+   │                                                                   ^
+
+// -- Model dump before first bytecode pipeline
+module 0x99::m {
+    use std::option;
+    struct FunctionStore {
+        f: ||0x1::option::Option<u64> has copy + drop + store,
+    }
+    struct Store<T> {
+        o: T,
+    }
+    private entry fun entry_func() {
+        {
+          let v: Store<0x1::option::Option<u64>> = pack m::Store<0x1::option::Option<u64>>(option::none<u64>());
+          {
+            let _f: ||0x1::option::Option<u64> has copy + drop + store = closure#1m::id<0x1::option::Option<u64>>(v);
+            Tuple()
+          }
+        }
+    }
+    public fun id<T>(x: Store<T>): T {
+        select m::Store.o<Store<T>>(x)
+    }
+    private fun init_module(account: &signer) {
+        {
+          let v: Store<0x1::option::Option<u64>> = pack m::Store<0x1::option::Option<u64>>(option::none<u64>());
+          {
+            let f: ||0x1::option::Option<u64> has copy + drop + store = closure#1m::id<0x1::option::Option<u64>>(v);
+            MoveTo<FunctionStore>(account, pack m::FunctionStore(f));
+            Tuple()
+          }
+        }
+    }
+} // end 0x99::m
+
+// -- Sourcified model before first bytecode pipeline
+module 0x99::m {
+    use std::option;
+    struct FunctionStore has key {
+        f: ||0x1::option::Option<u64> has copy + drop + store,
+    }
+    struct Store<T: copy + drop + store> has copy, drop, store {
+        o: T,
+    }
+    entry fun entry_func() {
+        let v = Store<0x1::option::Option<u64>>{o: 0x1::option::none<u64>()};
+        let _f: ||0x1::option::Option<u64> has copy + drop + store = || id<0x1::option::Option<u64>>(v);
+    }
+    public fun id<T: copy + drop + store>(x: Store<T>): T {
+        x.o
+    }
+    fun init_module(account: &signer) {
+        let v = Store<0x1::option::Option<u64>>{o: 0x1::option::none<u64>()};
+        let f: ||0x1::option::Option<u64> has copy + drop + store = || id<0x1::option::Option<u64>>(v);
+        move_to<FunctionStore>(FunctionStore{f: f}, account);
+    }
+}

third_party/move/move-compiler-v2/tests/checking-lang-v2.2/lambda/capturing_option_4.move

@@ -0,0 +1,21 @@
+module 0x99::m {
+    use std::option;
+    struct Store<T: store+drop+copy> has copy,drop,store {
+        o: T,
+    }
+    struct FunctionStore has key {
+        f: ||option::Option<u64> has copy+drop+store,
+    }
+    public fun id<T: store+drop+copy>(x: Store<T>): T {
+        x.o
+    }
+    fun init_module(account: &signer) {
+        let v = Store { o: option::none() };
+        let f: ||option::Option<u64> has copy+drop+store = || id(v);
+        move_to(account, FunctionStore { f });
+    }
+    entry fun entry_func() {
+        let v = Store { o: option::none() };
+        let _f: ||option::Option<u64> has copy+drop+store = || id(v);
+    }
+ }