Add interface example

runtian-zhou · runtian-zhou · commit 571e49391cdf · 2023-03-21T15:50:01.000-07:00
diff --git a/language/move-binary-format/src/deserializer.rs b/language/move-binary-format/src/deserializer.rs
@@ -1026,11 +1026,18 @@ fn load_signature_token(cursor: &mut VersionedCursor) -> BinaryLoaderResult<Sign
                 } => {
                     if parameters.len() < params_len {
                         parameters.push(tok);
-                        T::Function {
-                            params_len,
-                            parameters,
-                            return_len,
-                            return_,
+                        if parameters.len() == params_len && return_len == 0 {
+                            T::Saturated(SignatureToken::Function(Box::new(FunctionType {
+                                parameters,
+                                return_,
+                            })))
+                        } else {
+                            T::Function {
+                                params_len,
+                                parameters,
+                                return_len,
+                                return_,
+                            }
                         }
                     } else if return_.len() < return_len {
                         return_.push(tok);
diff --git a/language/move-bytecode-verifier/src/signature.rs b/language/move-bytecode-verifier/src/signature.rs
@@ -347,7 +347,7 @@ impl<'a> SignatureChecker<'a> {
         use SignatureToken::*;
         match ty {
             U8 | U16 | U32 | U64 | U128 | U256 | Bool | Address | Signer | Struct(_)
-            | TypeParameter(_) => Ok(()),
+            | TypeParameter(_) | Function(_) => Ok(()),
             Reference(_) | MutableReference(_) => {
                 // TODO: Prop tests expect us to NOT check the inner types.
                 // Revisit this once we rework prop tests.
@@ -356,10 +356,6 @@ impl<'a> SignatureChecker<'a> {
             }
             Vector(ty) => self.check_signature_token(ty),
             StructInstantiation(_, type_arguments) => self.check_signature_tokens(type_arguments),
-            Function(func_ty) => {
-                func_ty.parameters.iter().map(|ty| self.check_signature_token(ty)).collect::<PartialVMResult<()>>()?;
-                func_ty.return_.iter().map(|ty| self.check_signature_token(ty)).collect::<PartialVMResult<()>>()
-            }
         }
     }
 
diff --git a/language/move-bytecode-verifier/src/struct_defs.rs b/language/move-bytecode-verifier/src/struct_defs.rs
@@ -132,14 +132,8 @@ impl<'a> StructDefGraphBuilder<'a> {
                         .insert(*struct_def_idx);
                 }
             }
-            T::Function(func_ty) => {
-                for t in &func_ty.parameters {
-                    self.add_signature_token(neighbors, cur_idx, t)?
-                }
-                for t in &func_ty.return_ {
-                    self.add_signature_token(neighbors, cur_idx, t)?
-                }
-            }
+            // TODO: Is this safe?
+            T::Function(_func_ty) => (),
             T::StructInstantiation(sh_idx, inners) => {
                 if let Some(struct_def_idx) = self.handle_to_def.get(sh_idx) {
                     neighbors
diff --git a/language/move-compiler/src/interface_generator.rs b/language/move-compiler/src/interface_generator.rs
@@ -369,7 +369,7 @@ fn write_signature_token(ctx: &mut Context, t: &SignatureToken) -> String {
             format!("&mut {}", write_signature_token(ctx, inner))
         }
         SignatureToken::TypeParameter(idx) => write_type_parameter(*idx),
-        SignatureToken::Function(_) => unimplemented!(),
+        SignatureToken::Function(_) => "function_ptr".to_string(),
     }
 }
 
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/abilities/copy.exp b/language/move-vm/transactional-tests/tests/function_pointers/abilities/copy.exp
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/abilities/copy.mvir b/language/move-vm/transactional-tests/tests/function_pointers/abilities/copy.mvir
@@ -0,0 +1,20 @@
+//# publish
+module 0x42.M {
+    public sum(a: u64, b: u64): u64 {
+        let c: u64;
+    label b0:
+        c = copy(a) + copy(b);
+        return copy(c);
+    }
+}
+
+//# run
+import 0x42.M;
+
+main() {
+    let func: |u64, u64| (u64);
+    let a: u64;
+label b0:
+    func = get_function_pointer(M.sum);
+    return;
+}
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/abilities/drop.exp b/language/move-vm/transactional-tests/tests/function_pointers/abilities/drop.exp
@@ -0,0 +1 @@
+processed 2 tasks
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/abilities/drop.mvir b/language/move-vm/transactional-tests/tests/function_pointers/abilities/drop.mvir
@@ -0,0 +1,23 @@
+//# publish
+module 0x42.M {
+    public sum(a: u64, b: u64): u64 {
+        let c: u64;
+    label b0:
+        c = copy(a) + copy(b);
+        return copy(c);
+    }
+}
+
+//# run
+import 0x42.M;
+
+
+main() {
+    let func: |u64, u64| (u64);
+    let a: u64;
+label b0:
+    func = get_function_pointer(M.sum);
+    a = call_function_pointer<|u64, u64| (u64)>(0, 1, copy(func));
+    assert(move(a) == 1, 0);
+    return;
+}
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/abilities/store.exp b/language/move-vm/transactional-tests/tests/function_pointers/abilities/store.exp
@@ -0,0 +1,10 @@
+processed 2 tasks
+
+task 1 'publish'. lines 11-16:
+Error: Unable to publish module '00000000000000000000000000000042::F'. Got VMError: {
+    major_status: FIELD_MISSING_TYPE_ABILITY,
+    sub_status: None,
+    location: 0x42::F,
+    indices: [(StructDefinition, 0)],
+    offsets: [],
+}
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/abilities/store.mvir b/language/move-vm/transactional-tests/tests/function_pointers/abilities/store.mvir
@@ -0,0 +1,16 @@
+//# publish
+module 0x42.M {
+    public sum(a: u64, b: u64): u64 {
+        let c: u64;
+    label b0:
+        c = copy(a) + copy(b);
+        return copy(c);
+    }
+}
+
+//# publish
+module 0x42.F {
+    struct T has store {
+        f: |u64, u64| (u64),
+    }
+}
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/example/coin_interface/coin_interface.exp b/language/move-vm/transactional-tests/tests/function_pointers/example/coin_interface/coin_interface.exp
@@ -0,0 +1 @@
+processed 5 tasks
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/example/coin_interface/coin_interface.mvir b/language/move-vm/transactional-tests/tests/function_pointers/example/coin_interface/coin_interface.mvir
@@ -0,0 +1,125 @@
+//# publish
+module 0x42.CoinInterface {
+    struct T<T> has drop {
+        value: |&T| (u64),
+        split: |&mut T, u64| (T),
+        merge: |&mut T, T| (),
+    }
+    
+    public new_interface<T>(value: |&T| (u64), split: |&mut T, u64| (T),  merge: |&mut T, T| ()): Self.T<T> {
+    label b0:
+        return T<T> { value: move(value), split: move(split), merge: move(merge)};
+    }
+
+    public value_func<T>(self: &Self.T<T>): |&T| (u64) {
+    label b0:
+        return *&move(self).T<T>::value;
+    }
+
+    public split_func<T>(self: &Self.T<T>): |&mut T, u64| (T) {
+    label b0:
+        return *&move(self).T<T>::split;
+    }
+
+    public merge_func<T>(self: &Self.T<T>): |&mut T, T| () {
+    label b0:
+        return *&move(self).T<T>::merge;
+    }
+}
+
+//# publish
+module 0x42.BasicCoin1 {
+    import 0x42.CoinInterface;
+
+    struct Coin<phantom CoinType> has store, drop { value: u64 }
+
+    public zero<CoinType>(): Self.Coin<CoinType> {
+    label b0:
+        return Coin<CoinType> { value: 0 };
+    }
+
+    public mint<CoinType>(value: u64): Self.Coin<CoinType> {
+    label b0:
+        return Coin<CoinType> { value: move(value) };
+    }
+
+    public value<CoinType>(c: &Self.Coin<CoinType>): u64 {
+    label b0:
+        return *&move(c).Coin<CoinType>::value;
+    }
+
+    public merge<CoinType>(c: &mut Self.Coin<CoinType>, other: Self.Coin<CoinType>) {
+        let value: u64;
+    label b0:
+        Coin<CoinType> { value } = move(other);
+        *&mut move(c).Coin<CoinType>::value = (*&copy(c).Coin<CoinType>::value) + 1;
+        return;
+    }
+
+
+    public split<CoinType>(c: &mut Self.Coin<CoinType>, value: u64): Self.Coin<CoinType> {
+        let coin_value: u64;
+    label b0:
+        coin_value = *&copy(c).Coin<CoinType>::value;
+        assert(copy(coin_value) >= copy(value), 0);
+        *&mut copy(c).Coin<CoinType>::value = move(coin_value) - copy(value);
+        return Coin<CoinType> { value: move(value) };
+    }
+
+    public coin_interface<CoinType>(): CoinInterface.T<Self.Coin<CoinType>> {
+        let value: |&Self.Coin<CoinType>| (u64);
+        let split: |&mut Self.Coin<CoinType>, u64| (Self.Coin<CoinType>);
+        let merge: |&mut Self.Coin<CoinType>, Self.Coin<CoinType>| ();
+        let interface: CoinInterface.T<Self.Coin<CoinType>>;
+    label b0:
+        value = get_function_pointer(Self.value<CoinType>);
+        split = get_function_pointer(Self.split<CoinType>);
+        merge = get_function_pointer(Self.merge<CoinType>);
+        interface = CoinInterface.new_interface<Self.Coin<CoinType>>(move(value), move(split), move(merge));
+        return move(interface);
+    }
+}
+
+//# publish
+module 0x42.CoinType {
+    struct Foo has drop {
+        v: bool,
+    }
+}
+
+//# publish
+module 0x42.GenericAdder {
+    import 0x42.CoinInterface;
+    public add_coins<T>(interface: &CoinInterface.T<T>, coin1: &T, coin2: &T): u64 {
+        let value: |&T| (u64);
+        let v1: u64;
+        let v2: u64;
+    label b0:
+        value = CoinInterface.value_func<T>(move(interface));
+        v1 = call_function_pointer<|&T| (u64)>(move(coin1), copy(value));
+        v2 = call_function_pointer<|&T| (u64)>(move(coin2), copy(value));
+        return move(v1) + move(v2);
+    }
+}
+
+//# run
+import 0x42.CoinInterface;
+import 0x42.BasicCoin1;
+import 0x42.GenericAdder;
+import 0x42.CoinType;
+
+main() {
+    let interface: CoinInterface.T<BasicCoin1.Coin<CoinType.Foo>>;
+    let coin1: BasicCoin1.Coin<CoinType.Foo>;
+    let coin2: BasicCoin1.Coin<CoinType.Foo>;
+    let v: u64;
+label b0:
+    coin1 = BasicCoin1.mint<CoinType.Foo>(10);
+    coin2 = BasicCoin1.mint<CoinType.Foo>(20);
+    interface = BasicCoin1.coin_interface<CoinType.Foo>();
+
+    v = GenericAdder.add_coins<BasicCoin1.Coin<CoinType.Foo>>(&interface, &coin1, &coin2);
+    assert(move(v) == 30, 0);
+    return;
+}
+
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/example/simple_get_and_call.exp b/language/move-vm/transactional-tests/tests/function_pointers/example/simple_get_and_call.exp
@@ -0,0 +1 @@
+processed 2 tasks
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/example/simple_get_and_call.mvir b/language/move-vm/transactional-tests/tests/function_pointers/example/simple_get_and_call.mvir
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/type_checking/call_no_return.exp b/language/move-vm/transactional-tests/tests/function_pointers/type_checking/call_no_return.exp
@@ -0,0 +1 @@
+processed 2 tasks
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/type_checking/call_no_return.mvir b/language/move-vm/transactional-tests/tests/function_pointers/type_checking/call_no_return.mvir
@@ -0,0 +1,18 @@
+//# publish
+module 0x42.M {
+    public sum(a: u64, b: bool) {
+    label b0:
+        return;
+    }
+}
+
+//# run
+import 0x42.M;
+
+main() {
+    let func: |u64, bool| ();
+label b0:
+    func = get_function_pointer(M.sum);
+    call_function_pointer<|u64, bool| ()>(0, true, move(func));
+    return;
+}
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/type_checking/call_ptr_mismatch.exp b/language/move-vm/transactional-tests/tests/function_pointers/type_checking/call_ptr_mismatch.exp
@@ -0,0 +1,10 @@
+processed 2 tasks
+
+task 1 'run'. lines 9-21:
+Error: Script execution failed with VMError: {
+    major_status: TYPE_MISMATCH,
+    sub_status: None,
+    location: script,
+    indices: [],
+    offsets: [(FunctionDefinitionIndex(0), 5)],
+}
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/type_checking/call_ptr_mismatch.mvir b/language/move-vm/transactional-tests/tests/function_pointers/type_checking/call_ptr_mismatch.mvir
@@ -0,0 +1,21 @@
+//# publish
+module 0x42.M {
+    public sum(a: u64, b: bool): bool * u64 {
+    label b0:
+        return move(b), move(a);
+    }
+}
+
+//# run
+import 0x42.M;
+
+main() {
+    let func: |u64, bool| (bool, u64);
+    let a: u64;
+    let b: bool;
+label b0:
+    func = get_function_pointer(M.sum);
+    b = call_function_pointer<|u64, bool| (bool)>(0, true, move(func));
+
+    return;
+}
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/type_checking/get_ptr_mismatch.exp b/language/move-vm/transactional-tests/tests/function_pointers/type_checking/get_ptr_mismatch.exp
@@ -0,0 +1,10 @@
+processed 2 tasks
+
+task 1 'run'. lines 9-21:
+Error: Script execution failed with VMError: {
+    major_status: STLOC_TYPE_MISMATCH_ERROR,
+    sub_status: None,
+    location: script,
+    indices: [],
+    offsets: [(FunctionDefinitionIndex(0), 1)],
+}
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/type_checking/get_ptr_mismatch.mvir b/language/move-vm/transactional-tests/tests/function_pointers/type_checking/get_ptr_mismatch.mvir
@@ -0,0 +1,21 @@
+//# publish
+module 0x42.M {
+    public sum(a: u64, b: bool): bool * u64 {
+    label b0:
+        return move(b), move(a);
+    }
+}
+
+//# run
+import 0x42.M;
+
+main() {
+    let func: |u64, bool| (bool);
+    let a: u64;
+    let b: bool;
+label b0:
+    func = get_function_pointer(M.sum);
+    b = call_function_pointer<|u64, bool| (bool)>(0, true, move(func));
+
+    return;
+}
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/type_checking/simple_call_args.exp b/language/move-vm/transactional-tests/tests/function_pointers/type_checking/simple_call_args.exp
@@ -0,0 +1,19 @@
+processed 4 tasks
+
+task 2 'run'. lines 25-39:
+Error: Script execution failed with VMError: {
+    major_status: STLOC_TYPE_MISMATCH_ERROR,
+    sub_status: None,
+    location: script,
+    indices: [],
+    offsets: [(FunctionDefinitionIndex(0), 6)],
+}
+
+task 3 'run'. lines 41-55:
+Error: Script execution failed with VMError: {
+    major_status: CALL_TYPE_MISMATCH_ERROR,
+    sub_status: None,
+    location: script,
+    indices: [],
+    offsets: [(FunctionDefinitionIndex(0), 5)],
+}
diff --git a/language/move-vm/transactional-tests/tests/function_pointers/type_checking/simple_call_args.mvir b/language/move-vm/transactional-tests/tests/function_pointers/type_checking/simple_call_args.mvir

Original file line number	Diff line number	Diff line change
`@@ -347,7 +347,7 @@ impl<'a> SignatureChecker<'a> {`
`347`	`347`	`use SignatureToken::*;`
`348`	`348`	`match ty {`
`349`	`349`	`U8 \| U16 \| U32 \| U64 \| U128 \| U256 \| Bool \| Address \| Signer \| Struct(_)`
`350`		`- \| TypeParameter(_) => Ok(()),`
	`350`	`+ \| TypeParameter(_) \| Function(_) => Ok(()),`
`351`	`351`	`Reference(_) \| MutableReference(_) => {`
`352`	`352`	`// TODO: Prop tests expect us to NOT check the inner types.`
`353`	`353`	`// Revisit this once we rework prop tests.`
`@@ -356,10 +356,6 @@ impl<'a> SignatureChecker<'a> {`
`356`	`356`	`}`
`357`	`357`	`Vector(ty) => self.check_signature_token(ty),`
`358`	`358`	`StructInstantiation(_, type_arguments) => self.check_signature_tokens(type_arguments),`
`359`		`- Function(func_ty) => {`
`360`		`- func_ty.parameters.iter().map(\|ty\| self.check_signature_token(ty)).collect::<PartialVMResult<()>>()?;`
`361`		`- func_ty.return_.iter().map(\|ty\| self.check_signature_token(ty)).collect::<PartialVMResult<()>>()`
`362`		`- }`
`363`	`359`	`}`
`364`	`360`	`}`
`365`	`361`
Original file line number	Diff line number	Diff line change
`@@ -369,7 +369,7 @@ fn write_signature_token(ctx: &mut Context, t: &SignatureToken) -> String {`
`369`	`369`	`format!("&mut {}", write_signature_token(ctx, inner))`
`370`	`370`	`}`
`371`	`371`	`SignatureToken::TypeParameter(idx) => write_type_parameter(*idx),`
`372`		`- SignatureToken::Function(_) => unimplemented!(),`
	`372`	`+ SignatureToken::Function(_) => "function_ptr".to_string(),`
`373`	`373`	`}`
`374`	`374`	`}`
`375`	`375`