Merge pull request #669 from CosmWasm/change-argument-order

Use generic argument order A, S, Q consistently

Author: webmaster128

Diff for: CHANGELOG.md

@@ -16,6 +16,8 @@
 - Export method `cosmwasm_vm::Cache::stats` and response type `Stats`.
 - Remove `cosmwasm_vm::testing::MockApi::new`. Use `MockApi::default` instead.
 - Convert field `Instance::api` to a method.
+- Change order of generic arguments for consistency in `Instance`, `Cache` and
+  `Backend` to always match `<A: Api, S: Storage, Q: Querier>`.
 
 ## 0.12.2 (2020-12-14)
 

Diff for: contracts/queue/tests/integration.rs

@@ -31,7 +31,7 @@ use queue::contract::{
 
 static WASM: &[u8] = include_bytes!("../target/wasm32-unknown-unknown/release/queue.wasm");
 
-fn create_contract() -> (Instance<MockStorage, MockApi, MockQuerier>, MessageInfo) {
+fn create_contract() -> (Instance<MockApi, MockStorage, MockQuerier>, MessageInfo) {
     let mut deps = mock_instance(WASM, &[]);
     let creator = HumanAddr(String::from("creator"));
     let info = mock_info(creator.as_str(), &[]);
@@ -40,13 +40,13 @@ fn create_contract() -> (Instance<MockStorage, MockApi, MockQuerier>, MessageInf
     (deps, info)
 }
 
-fn get_count(deps: &mut Instance<MockStorage, MockApi, MockQuerier>) -> u32 {
+fn get_count(deps: &mut Instance<MockApi, MockStorage, MockQuerier>) -> u32 {
     let data = query(deps, mock_env(), QueryMsg::Count {}).unwrap();
     let res: CountResponse = from_binary(&data).unwrap();
     res.count
 }
 
-fn get_sum(deps: &mut Instance<MockStorage, MockApi, MockQuerier>) -> i32 {
+fn get_sum(deps: &mut Instance<MockApi, MockStorage, MockQuerier>) -> i32 {
     let data = query(deps, mock_env(), QueryMsg::Sum {}).unwrap();
     let res: SumResponse = from_binary(&data).unwrap();
     res.sum

Diff for: contracts/reflect/tests/integration.rs

@@ -43,15 +43,15 @@ static WASM: &[u8] = include_bytes!("../target/wasm32-unknown-unknown/release/re
 /// that supports SpecialQuery.
 pub fn mock_dependencies_with_custom_querier(
     contract_balance: &[Coin],
-) -> Backend<MockStorage, MockApi, MockQuerier<SpecialQuery>> {
+) -> Backend<MockApi, MockStorage, MockQuerier<SpecialQuery>> {
     let contract_addr = HumanAddr::from(MOCK_CONTRACT_ADDR);
     let custom_querier: MockQuerier<SpecialQuery> =
         MockQuerier::new(&[(&contract_addr, contract_balance)])
             .with_custom_handler(|query| SystemResult::Ok(custom_query_execute(query)));
 
     Backend {
-        storage: MockStorage::default(),
         api: MockApi::default(),
+        storage: MockStorage::default(),
         querier: custom_querier,
     }
 }

Diff for: packages/vm/benches/main.rs

@@ -88,7 +88,7 @@ fn bench_cache(c: &mut Criterion) {
     };
 
     group.bench_function("save wasm", |b| {
-        let mut cache: Cache<MockStorage, MockApi, MockQuerier> =
+        let mut cache: Cache<MockApi, MockStorage, MockQuerier> =
             unsafe { Cache::new(options.clone()).unwrap() };
 
         b.iter(|| {
@@ -103,7 +103,7 @@ fn bench_cache(c: &mut Criterion) {
             supported_features: features_from_csv("staking"),
             memory_cache_size: Size(0),
         };
-        let mut cache: Cache<MockStorage, MockApi, MockQuerier> =
+        let mut cache: Cache<MockApi, MockStorage, MockQuerier> =
             unsafe { Cache::new(non_memcache).unwrap() };
         let checksum = cache.save_wasm(CONTRACT).unwrap();
 
@@ -119,7 +119,7 @@ fn bench_cache(c: &mut Criterion) {
 
     group.bench_function("instantiate from memory", |b| {
         let checksum = Checksum::generate(CONTRACT);
-        let mut cache: Cache<MockStorage, MockApi, MockQuerier> =
+        let mut cache: Cache<MockApi, MockStorage, MockQuerier> =
             unsafe { Cache::new(options.clone()).unwrap() };
         // Load into memory
         cache

Diff for: packages/vm/src/backend.rs

@@ -55,9 +55,9 @@ impl AddAssign for GasInfo {
 /// Designed to allow easy dependency injection at runtime.
 /// This cannot be copied or cloned since it would behave differently
 /// for mock storages and a bridge storage in the VM.
-pub struct Backend<S: Storage, A: Api, Q: Querier> {
-    pub storage: S,
+pub struct Backend<A: Api, S: Storage, Q: Querier> {
     pub api: A,
+    pub storage: S,
     pub querier: Q,
 }
 

Diff for: packages/vm/src/cache.rs

@@ -30,22 +30,22 @@ pub struct CacheOptions {
     pub memory_cache_size: Size,
 }
 
-pub struct Cache<S: Storage, A: Api, Q: Querier> {
+pub struct Cache<A: Api, S: Storage, Q: Querier> {
     wasm_path: PathBuf,
     supported_features: HashSet<String>,
     memory_cache: InMemoryCache,
     fs_cache: FileSystemCache,
     stats: Stats,
     // Those two don't store data but only fix type information
-    type_storage: PhantomData<S>,
     type_api: PhantomData<A>,
+    type_storage: PhantomData<S>,
     type_querier: PhantomData<Q>,
 }
 
-impl<S, A, Q> Cache<S, A, Q>
+impl<A, S, Q> Cache<A, S, Q>
 where
-    S: Storage + 'static, // 'static is needed by `impl<…> Instance`
     A: Api + 'static,     // 'static is needed by `impl<…> Instance`
+    S: Storage + 'static, // 'static is needed by `impl<…> Instance`
     Q: Querier + 'static, // 'static is needed by `impl<…> Instance`
 {
     /// new stores the data for cache under base_dir
@@ -113,9 +113,9 @@ where
     pub fn get_instance(
         &mut self,
         checksum: &Checksum,
-        backend: Backend<S, A, Q>,
+        backend: Backend<A, S, Q>,
         options: InstanceOptions,
-    ) -> VmResult<Instance<S, A, Q>> {
+    ) -> VmResult<Instance<A, S, Q>> {
         let store = make_store_headless(Some(options.memory_limit));
         // Get module from memory cache
         if let Some(module) = self.memory_cache.load(checksum, &store)? {
@@ -218,15 +218,15 @@ mod tests {
 
     #[test]
     fn save_wasm_works() {
-        let mut cache: Cache<MockStorage, MockApi, MockQuerier> =
+        let mut cache: Cache<MockApi, MockStorage, MockQuerier> =
             unsafe { Cache::new(make_testing_options()).unwrap() };
         cache.save_wasm(CONTRACT).unwrap();
     }
 
     #[test]
     // This property is required when the same bytecode is uploaded multiple times
     fn save_wasm_allows_saving_multiple_times() {
-        let mut cache: Cache<MockStorage, MockApi, MockQuerier> =
+        let mut cache: Cache<MockApi, MockStorage, MockQuerier> =
             unsafe { Cache::new(make_testing_options()).unwrap() };
         cache.save_wasm(CONTRACT).unwrap();
         cache.save_wasm(CONTRACT).unwrap();
@@ -246,7 +246,7 @@ mod tests {
         )
         .unwrap();
 
-        let mut cache: Cache<MockStorage, MockApi, MockQuerier> =
+        let mut cache: Cache<MockApi, MockStorage, MockQuerier> =
             unsafe { Cache::new(make_testing_options()).unwrap() };
         let save_result = cache.save_wasm(&wasm);
         match save_result.unwrap_err() {
@@ -276,7 +276,7 @@ mod tests {
 
     #[test]
     fn load_wasm_works() {
-        let mut cache: Cache<MockStorage, MockApi, MockQuerier> =
+        let mut cache: Cache<MockApi, MockStorage, MockQuerier> =
             unsafe { Cache::new(make_testing_options()).unwrap() };
         let id = cache.save_wasm(CONTRACT).unwrap();
 
@@ -295,7 +295,7 @@ mod tests {
                 supported_features: default_features(),
                 memory_cache_size: TESTING_MEMORY_CACHE_SIZE,
             };
-            let mut cache1: Cache<MockStorage, MockApi, MockQuerier> =
+            let mut cache1: Cache<MockApi, MockStorage, MockQuerier> =
                 unsafe { Cache::new(options1).unwrap() };
             id = cache1.save_wasm(CONTRACT).unwrap();
         }
@@ -306,7 +306,7 @@ mod tests {
                 supported_features: default_features(),
                 memory_cache_size: TESTING_MEMORY_CACHE_SIZE,
             };
-            let cache2: Cache<MockStorage, MockApi, MockQuerier> =
+            let cache2: Cache<MockApi, MockStorage, MockQuerier> =
                 unsafe { Cache::new(options2).unwrap() };
             let restored = cache2.load_wasm(&id).unwrap();
             assert_eq!(restored, CONTRACT);
@@ -315,7 +315,7 @@ mod tests {
 
     #[test]
     fn load_wasm_errors_for_non_existent_id() {
-        let cache: Cache<MockStorage, MockApi, MockQuerier> =
+        let cache: Cache<MockApi, MockStorage, MockQuerier> =
             unsafe { Cache::new(make_testing_options()).unwrap() };
         let checksum = Checksum::from([
             5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
@@ -339,7 +339,7 @@ mod tests {
             supported_features: default_features(),
             memory_cache_size: TESTING_MEMORY_CACHE_SIZE,
         };
-        let mut cache: Cache<MockStorage, MockApi, MockQuerier> =
+        let mut cache: Cache<MockApi, MockStorage, MockQuerier> =
             unsafe { Cache::new(options).unwrap() };
         let checksum = cache.save_wasm(CONTRACT).unwrap();
 

Diff for: packages/vm/src/calls.rs

@@ -18,15 +18,15 @@ const MAX_LENGTH_HANDLE: usize = 100_000;
 const MAX_LENGTH_MIGRATE: usize = 100_000;
 const MAX_LENGTH_QUERY: usize = 100_000;
 
-pub fn call_init<S, A, Q, U>(
-    instance: &mut Instance<S, A, Q>,
+pub fn call_init<A, S, Q, U>(
+    instance: &mut Instance<A, S, Q>,
     env: &Env,
     info: &MessageInfo,
     msg: &[u8],
 ) -> VmResult<ContractResult<InitResponse<U>>>
 where
-    S: Storage + 'static,
     A: Api + 'static,
+    S: Storage + 'static,
     Q: Querier + 'static,
     U: DeserializeOwned + Clone + fmt::Debug + JsonSchema + PartialEq,
 {
@@ -37,15 +37,15 @@ where
     Ok(result)
 }
 
-pub fn call_handle<S, A, Q, U>(
-    instance: &mut Instance<S, A, Q>,
+pub fn call_handle<A, S, Q, U>(
+    instance: &mut Instance<A, S, Q>,
     env: &Env,
     info: &MessageInfo,
     msg: &[u8],
 ) -> VmResult<ContractResult<HandleResponse<U>>>
 where
-    S: Storage + 'static,
     A: Api + 'static,
+    S: Storage + 'static,
     Q: Querier + 'static,
     U: DeserializeOwned + Clone + fmt::Debug + JsonSchema + PartialEq,
 {
@@ -56,15 +56,15 @@ where
     Ok(result)
 }
 
-pub fn call_migrate<S, A, Q, U>(
-    instance: &mut Instance<S, A, Q>,
+pub fn call_migrate<A, S, Q, U>(
+    instance: &mut Instance<A, S, Q>,
     env: &Env,
     info: &MessageInfo,
     msg: &[u8],
 ) -> VmResult<ContractResult<MigrateResponse<U>>>
 where
-    S: Storage + 'static,
     A: Api + 'static,
+    S: Storage + 'static,
     Q: Querier + 'static,
     U: DeserializeOwned + Clone + fmt::Debug + JsonSchema + PartialEq,
 {
@@ -75,11 +75,16 @@ where
     Ok(result)
 }
 
-pub fn call_query<S: Storage + 'static, A: Api + 'static, Q: Querier + 'static>(
-    instance: &mut Instance<S, A, Q>,
+pub fn call_query<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
     env: &Env,
     msg: &[u8],
-) -> VmResult<ContractResult<QueryResponse>> {
+) -> VmResult<ContractResult<QueryResponse>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
     let env = to_vec(env)?;
     let data = call_query_raw(instance, &env, msg)?;
     let result: ContractResult<QueryResponse> = from_slice(&data)?;
@@ -96,57 +101,82 @@ pub fn call_query<S: Storage + 'static, A: Api + 'static, Q: Querier + 'static>(
 
 /// Calls Wasm export "init" and returns raw data from the contract.
 /// The result is length limited to prevent abuse but otherwise unchecked.
-pub fn call_init_raw<S: Storage + 'static, A: Api + 'static, Q: Querier + 'static>(
-    instance: &mut Instance<S, A, Q>,
+pub fn call_init_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
     env: &[u8],
     info: &[u8],
     msg: &[u8],
-) -> VmResult<Vec<u8>> {
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
     instance.set_storage_readonly(false);
     call_raw(instance, "init", &[env, info, msg], MAX_LENGTH_INIT)
 }
 
 /// Calls Wasm export "handle" and returns raw data from the contract.
 /// The result is length limited to prevent abuse but otherwise unchecked.
-pub fn call_handle_raw<S: Storage + 'static, A: Api + 'static, Q: Querier + 'static>(
-    instance: &mut Instance<S, A, Q>,
+pub fn call_handle_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
     env: &[u8],
     info: &[u8],
     msg: &[u8],
-) -> VmResult<Vec<u8>> {
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
     instance.set_storage_readonly(false);
     call_raw(instance, "handle", &[env, info, msg], MAX_LENGTH_HANDLE)
 }
 
 /// Calls Wasm export "migrate" and returns raw data from the contract.
 /// The result is length limited to prevent abuse but otherwise unchecked.
-pub fn call_migrate_raw<S: Storage + 'static, A: Api + 'static, Q: Querier + 'static>(
-    instance: &mut Instance<S, A, Q>,
+pub fn call_migrate_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
     env: &[u8],
     info: &[u8],
     msg: &[u8],
-) -> VmResult<Vec<u8>> {
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
     instance.set_storage_readonly(false);
     call_raw(instance, "migrate", &[env, info, msg], MAX_LENGTH_MIGRATE)
 }
 
 /// Calls Wasm export "query" and returns raw data from the contract.
 /// The result is length limited to prevent abuse but otherwise unchecked.
-pub fn call_query_raw<S: Storage + 'static, A: Api + 'static, Q: Querier + 'static>(
-    instance: &mut Instance<S, A, Q>,
+pub fn call_query_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
     env: &[u8],
     msg: &[u8],
-) -> VmResult<Vec<u8>> {
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
     instance.set_storage_readonly(true);
     call_raw(instance, "query", &[env, msg], MAX_LENGTH_QUERY)
 }
 
-fn call_raw<S: Storage + 'static, A: Api + 'static, Q: Querier + 'static>(
-    instance: &mut Instance<S, A, Q>,
+fn call_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
     name: &str,
     args: &[&[u8]],
     result_max_length: usize,
-) -> VmResult<Vec<u8>> {
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
     let mut arg_region_ptrs = Vec::<Val>::with_capacity(args.len());
     for arg in args {
         let region_ptr = instance.allocate(arg.len())?;