Refactor state machine to avoid repetitions (#1844)

* Refactor state-machine stuff.

* Fix tests.

* Fix core/client tests.

substrate/core/client/src/call_executor.rs

@@ -169,15 +169,14 @@ where
 	) -> error::Result<Vec<u8>> {
 		let mut changes = OverlayedChanges::default();
 		let state = self.backend.state_at(*id)?;
-		let return_data = state_machine::execute_using_consensus_failure_handler::<
-			_, _, _, _, _, NeverNativeValue, fn() -> _
-		>(
+		let return_data = state_machine::new(
 			&state,
 			self.backend.changes_trie_storage(),
 			&mut changes,
 			&self.executor,
 			method,
 			call_data,
+		).execute_using_consensus_failure_handler::<_, NeverNativeValue, fn() -> _>(
 			strategy.get_manager(),
 			false,
 			None,
@@ -209,15 +208,14 @@ where
 		let state = self.backend.state_at(*at)?;
 		if method != "Core_initialise_block" && initialised_block.map(|id| id != *at).unwrap_or(true) {
 			let header = prepare_environment_block()?;
-			state_machine::execute_using_consensus_failure_handler::<
-				_, _, _, _, _, R, fn() -> _,
-			>(
+			state_machine::new(
 				&state,
 				self.backend.changes_trie_storage(),
 				changes,
 				&self.executor,
 				"Core_initialise_block",
 				&header.encode(),
+			).execute_using_consensus_failure_handler::<_, R, fn() -> _>(
 				execution_manager.clone(),
 				false,
 				None,
@@ -225,13 +223,14 @@ where
 			*initialised_block = Some(*at);
 		}
 
-		let result = state_machine::execute_using_consensus_failure_handler(
+		let result = state_machine::new(
 			&state,
 			self.backend.changes_trie_storage(),
 			changes,
 			&self.executor,
 			method,
 			call_data,
+		).execute_using_consensus_failure_handler(
 			execution_manager,
 			false,
 			native_call,
@@ -270,13 +269,14 @@ where
 		manager: ExecutionManager<F>,
 		native_call: Option<NC>,
 	) -> error::Result<(NativeOrEncoded<R>, S::Transaction, Option<MemoryDB<Blake2Hasher>>)> {
-		state_machine::execute_using_consensus_failure_handler(
+		state_machine::new(
 			state,
 			self.backend.changes_trie_storage(),
 			changes,
 			&self.executor,
 			method,
 			call_data,
+		).execute_using_consensus_failure_handler(
 			manager,
 			true,
 			native_call,

substrate/core/client/src/genesis.rs

@@ -43,7 +43,7 @@ mod tests {
 	use parity_codec::{Encode, Decode, Joiner};
 	use keyring::Keyring;
 	use executor::{NativeExecutionDispatch, native_executor_instance};
-	use state_machine::{execute, OverlayedChanges, ExecutionStrategy, InMemoryChangesTrieStorage};
+	use state_machine::{self, OverlayedChanges, ExecutionStrategy, InMemoryChangesTrieStorage};
 	use state_machine::backend::InMemory;
 	use test_client::runtime::genesismap::{GenesisConfig, additional_storage_with_genesis};
 	use test_client::runtime::{Hash, Transfer, Block, BlockNumber, Header, Digest, Extrinsic};
@@ -86,35 +86,38 @@ mod tests {
 		let hash = header.hash();
 		let mut overlay = OverlayedChanges::default();
 
-		execute(
+		state_machine::new(
 			backend,
 			Some(&InMemoryChangesTrieStorage::new()),
 			&mut overlay,
 			&executor(),
 			"Core_initialise_block",
 			&header.encode(),
+		).execute(
 			ExecutionStrategy::NativeElseWasm,
 		).unwrap();
 
 		for tx in transactions.iter() {
-			execute(
+			state_machine::new(
 				backend,
 				Some(&InMemoryChangesTrieStorage::new()),
 				&mut overlay,
 				&executor(),
 				"BlockBuilder_apply_extrinsic",
 				&tx.encode(),
+			).execute(
 				ExecutionStrategy::NativeElseWasm,
 			).unwrap();
 		}
 
-		let (ret_data, _, _) = execute(
+		let (ret_data, _, _) = state_machine::new(
 			backend,
 			Some(&InMemoryChangesTrieStorage::new()),
 			&mut overlay,
 			&executor(),
 			"BlockBuilder_finalise_block",
 			&[],
+		).execute(
 			ExecutionStrategy::NativeElseWasm,
 		).unwrap();
 		header = Header::decode(&mut &ret_data[..]).unwrap();
@@ -152,13 +155,14 @@ mod tests {
 		let (b1data, _b1hash) = block1(genesis_hash, &backend);
 
 		let mut overlay = OverlayedChanges::default();
-		let _ = execute(
+		let _ = state_machine::new(
 			&backend,
 			Some(&InMemoryChangesTrieStorage::new()),
 			&mut overlay,
 			&executor(),
 			"Core_execute_block",
 			&b1data,
+		).execute(
 			ExecutionStrategy::NativeElseWasm,
 		).unwrap();
 	}
@@ -177,13 +181,14 @@ mod tests {
 		let (b1data, _b1hash) = block1(genesis_hash, &backend);
 
 		let mut overlay = OverlayedChanges::default();
-		let _ = execute(
+		let _ = state_machine::new(
 			&backend,
 			Some(&InMemoryChangesTrieStorage::new()),
 			&mut overlay,
 			&executor(),
 			"Core_execute_block",
 			&b1data,
+		).execute(
 			ExecutionStrategy::AlwaysWasm,
 		).unwrap();
 	}
@@ -203,13 +208,14 @@ mod tests {
 		let (b1data, _b1hash) = block1(genesis_hash, &backend);
 
 		let mut overlay = OverlayedChanges::default();
-		let _ = execute(
+		let _ = state_machine::new(
 			&backend,
 			Some(&InMemoryChangesTrieStorage::new()),
 			&mut overlay,
 			&Executor::new(None),
 			"Core_execute_block",
 			&b1data,
+		).execute(
 			ExecutionStrategy::NativeElseWasm,
 		).unwrap();
 	}