refactor: disentangle bindgen extractor logic (#1025)

Co-authored-by: Daniyar Itegulov <ditegulov@gmail.com>
near · Jun 22, 2023 · 76ee2da · 76ee2da
1 parent c2352df
commit 76ee2da
Show file tree

Hide file tree

Showing 20 changed files with 538 additions and 110 deletions.
diff --git a/examples/adder/Cargo.lock b/examples/adder/Cargo.lock
diff --git a/examples/callback-results/Cargo.lock b/examples/callback-results/Cargo.lock
diff --git a/examples/cross-contract-calls/Cargo.lock b/examples/cross-contract-calls/Cargo.lock
diff --git a/examples/factory-contract/Cargo.lock b/examples/factory-contract/Cargo.lock
diff --git a/examples/fungible-token/Cargo.lock b/examples/fungible-token/Cargo.lock
diff --git a/examples/lockable-fungible-token/Cargo.lock b/examples/lockable-fungible-token/Cargo.lock
diff --git a/examples/mission-control/Cargo.lock b/examples/mission-control/Cargo.lock
diff --git a/examples/non-fungible-token/Cargo.lock b/examples/non-fungible-token/Cargo.lock
diff --git a/examples/status-message-collections/Cargo.lock b/examples/status-message-collections/Cargo.lock
diff --git a/examples/status-message/Cargo.lock b/examples/status-message/Cargo.lock
diff --git a/examples/test-contract/Cargo.lock b/examples/test-contract/Cargo.lock
diff --git a/examples/versioned/Cargo.lock b/examples/versioned/Cargo.lock
diff --git a/near-sdk-macros/Cargo.toml b/near-sdk-macros/Cargo.toml
@@ -17,6 +17,8 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 syn = { version = "1", features = ["full", "fold", "extra-traits", "visit"] }
+strum = "0.24"
+strum_macros = "0.24"
 quote = "1.0"
 Inflector = { version = "0.11.4", default-features = false, features = [] }
 

diff --git a/near-sdk-macros/src/core_impl/code_generator/item_impl_info.rs b/near-sdk-macros/src/core_impl/code_generator/item_impl_info.rs
@@ -497,12 +497,9 @@ mod tests {
             #[init]
             pub fn method(k: &mut u64) { }
         };
-        let method_info = ImplItemMethodInfo::new(&mut method, false, impl_type).unwrap().unwrap();
-        let actual = method_info.method_wrapper();
-        let expected = quote!(
-            compile_error! { "Init methods must return the contract state" }
-        );
-        assert_eq!(expected.to_string(), actual.to_string());
+        let actual = ImplItemMethodInfo::new(&mut method, false, impl_type).map(|_| ()).unwrap_err();
+        let expected = "Init function must return the contract state.";
+        assert_eq!(expected, actual.to_string());
     }
 
     #[test]
@@ -786,23 +783,6 @@ mod tests {
         assert_eq!(expected.to_string(), actual.to_string());
     }
 
-    #[test]
-    fn init_result_without_handle_result() {
-        let impl_type: Type = syn::parse_str("Hello").unwrap();
-        let mut method: ImplItemMethod = parse_quote! {
-            #[init]
-            pub fn new() -> Result<Self, &'static str> { }
-        };
-        let method_info = ImplItemMethodInfo::new(&mut method, false, impl_type).unwrap().unwrap();
-        let actual = method_info.method_wrapper();
-        let expected = quote!(
-            compile_error! {
-                "Serializing Result<T, E> has been deprecated. Consider marking your method with #[handle_result] if the second generic represents a panicable error or replacing Result with another two type sum enum otherwise. If you really want to keep the legacy behavior, mark the method with #[handle_result] and make it return Result<Result<T, E>, near_sdk::Abort>."
-            }
-        );
-        assert_eq!(expected.to_string(), actual.to_string());
-    }
-
     #[test]
     fn handle_result_init_ignore_state() {
         let impl_type: Type = syn::parse_str("Hello").unwrap();
@@ -832,33 +812,17 @@ mod tests {
     }
 
     #[test]
-    fn handle_result_incorrect_return_type() {
+    fn handle_no_self() {
         let impl_type: Type = syn::parse_str("Hello").unwrap();
-        let mut method: ImplItemMethod = parse_quote! {
-            #[handle_result]
-            pub fn method(&self) -> &'static str { }
-        };
+        let mut method: ImplItemMethod = syn::parse_str("pub fn method() { }").unwrap();
         let method_info = ImplItemMethodInfo::new(&mut method, false, impl_type).unwrap().unwrap();
         let actual = method_info.method_wrapper();
         let expected = quote!(
-            compile_error! {
-                "Method marked with #[handle_result] should return Result<T, E> (where E implements FunctionError)."
-            }
-        );
-        assert_eq!(expected.to_string(), actual.to_string());
-    }
-
-    #[test]
-    fn handle_result_without_marker() {
-        let impl_type: Type = syn::parse_str("Hello").unwrap();
-        let mut method: ImplItemMethod = parse_quote! {
-            pub fn method(&self) -> Result<u64, &'static str> { }
-        };
-        let method_info = ImplItemMethodInfo::new(&mut method, false, impl_type).unwrap().unwrap();
-        let actual = method_info.method_wrapper();
-        let expected = quote!(
-            compile_error! {
-                "Serializing Result<T, E> has been deprecated. Consider marking your method with #[handle_result] if the second generic represents a panicable error or replacing Result with another two type sum enum otherwise. If you really want to keep the legacy behavior, mark the method with #[handle_result] and make it return Result<Result<T, E>, near_sdk::Abort>."
+            #[cfg(target_arch = "wasm32")]
+            #[no_mangle]
+            pub extern "C" fn method() {
+                near_sdk::env::setup_panic_hook();
+                Hello::method();
             }
         );
         assert_eq!(expected.to_string(), actual.to_string());