[big refactor] Remove crate aliasing. (#4395)

* Rename: Phase 1.

* Unify codec.

* Fixing: Phase 2

* Fixing: Phase 3.

* Fixing: Phase 4.

* Fixing: Phase 5.

* Fixing: Phase 6.

* Fixing: Phase 7.

* Fixing: Phase 8. Tests

* Fixing: Phase 9. Tests!!!

* Fixing: Phase 10. Moar tests!

* Finally done!

* More fixes.

* Rename primitives:: to sp_core::

* Apply renames in finality-grandpa.

* Fix benches.

* Fix benches 2.

* Revert node-template.

* Fix frame-system in our modules.

substrate/primitives/runtime-interface/Cargo.toml

@@ -5,19 +5,19 @@ authors = ["Parity Technologies <admin@parity.io>"]
 edition = "2018"
 
 [dependencies]
-wasm-interface = { package = "sp-wasm-interface", path = "../wasm-interface", optional = true }
+sp-wasm-interface = { path = "../wasm-interface", optional = true }
 sp-std = { path = "../std", default-features = false }
 sp-runtime-interface-proc-macro = { path = "proc-macro" }
-externalities = { package = "sp-externalities", path = "../externalities", optional = true }
+sp-externalities = { path = "../externalities", optional = true }
 codec = { package = "parity-scale-codec", version = "1.0.6", default-features = false }
 environmental = { version = "1.0.2", optional = true }
 static_assertions = "1.0.0"
 primitive-types = { version = "0.6.1", default-features = false }
 
 [dev-dependencies]
-test-wasm = { package = "sp-runtime-interface-test-wasm", path = "test-wasm" }
-state_machine = { package = "sp-state-machine", path = "../../primitives/state-machine"  }
-primitives = { package = "sp-core", path = "../core" }
+sp-runtime-interface-test-wasm = { path = "test-wasm" }
+sp-state-machine = { path = "../../primitives/state-machine"  }
+sp-core = { path = "../core" }
 sp-io = { path = "../io" }
 rustversion = "1.0.0"
 trybuild = "1.0.17"
@@ -25,10 +25,10 @@ trybuild = "1.0.17"
 [features]
 default = [ "std" ]
 std = [
-	"wasm-interface",
+	"sp-wasm-interface",
 	"sp-std/std",
 	"codec/std",
-	"externalities",
+	"sp-externalities",
 	"environmental",
 	"primitive-types/std",
 ]

substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/bare_function_interface.rs

@@ -106,7 +106,7 @@ fn function_std_impl(
 			if is_wasm_only {
 				Some(
 					parse_quote!(
-						mut __function_context__: &mut dyn #crate_::wasm_interface::FunctionContext
+						mut __function_context__: &mut dyn #crate_::sp_wasm_interface::FunctionContext
 					)
 				)
 			} else {
@@ -164,7 +164,7 @@ fn generate_call_to_trait(
 	} else {
 		// The name of the trait the interface trait is implemented for
 		let impl_trait_name = if is_wasm_only {
-			quote!( #crate_::wasm_interface::FunctionContext )
+			quote!( #crate_::sp_wasm_interface::FunctionContext )
 		} else {
 			quote!( #crate_::Externalities )
 		};

substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/host_function_interface.rs

@@ -174,8 +174,8 @@ fn generate_host_functions_struct(trait_def: &ItemTrait, is_wasm_only: bool) ->
 			pub struct HostFunctions;
 
 			#[cfg(feature = "std")]
-			impl #crate_::wasm_interface::HostFunctions for HostFunctions {
-				fn host_functions() -> Vec<&'static dyn #crate_::wasm_interface::Function> {
+			impl #crate_::sp_wasm_interface::HostFunctions for HostFunctions {
+				fn host_functions() -> Vec<&'static dyn #crate_::sp_wasm_interface::Function> {
 					vec![ #( #host_functions ),* ]
 				}
 			}
@@ -212,20 +212,20 @@ fn generate_host_function_implementation(
 				struct #struct_name;
 
 				#[allow(unused)]
-				impl #crate_::wasm_interface::Function for #struct_name {
+				impl #crate_::sp_wasm_interface::Function for #struct_name {
 					fn name(&self) -> &str {
 						#name
 					}
 
-					fn signature(&self) -> #crate_::wasm_interface::Signature {
+					fn signature(&self) -> #crate_::sp_wasm_interface::Signature {
 						#signature
 					}
 
 					fn execute(
 						&self,
-						__function_context__: &mut dyn #crate_::wasm_interface::FunctionContext,
-						args: &mut dyn Iterator<Item = #crate_::wasm_interface::Value>,
-					) -> std::result::Result<Option<#crate_::wasm_interface::Value>, String> {
+						__function_context__: &mut dyn #crate_::sp_wasm_interface::FunctionContext,
+						args: &mut dyn Iterator<Item = #crate_::sp_wasm_interface::Value>,
+					) -> std::result::Result<Option<#crate_::sp_wasm_interface::Value>, String> {
 						#( #wasm_to_ffi_values )*
 						#( #ffi_to_host_values )*
 						#host_function_call
@@ -234,7 +234,7 @@ fn generate_host_function_implementation(
 					}
 				}
 
-				&#struct_name as &dyn #crate_::wasm_interface::Function
+				&#struct_name as &dyn #crate_::sp_wasm_interface::Function
 			}
 		}
 	)
@@ -246,18 +246,18 @@ fn generate_wasm_interface_signature_for_host_function(sig: &Signature) -> Resul
 	let return_value = match &sig.output {
 		ReturnType::Type(_, ty) =>
 			quote! {
-				Some( <<#ty as #crate_::RIType>::FFIType as #crate_::wasm_interface::IntoValue>::VALUE_TYPE )
+				Some( <<#ty as #crate_::RIType>::FFIType as #crate_::sp_wasm_interface::IntoValue>::VALUE_TYPE )
 			},
 		ReturnType::Default => quote!( None ),
 	};
 	let arg_types = get_function_argument_types_without_ref(sig)
 		.map(|ty| quote! {
-			<<#ty as #crate_::RIType>::FFIType as #crate_::wasm_interface::IntoValue>::VALUE_TYPE
+			<<#ty as #crate_::RIType>::FFIType as #crate_::sp_wasm_interface::IntoValue>::VALUE_TYPE
 		});
 
 	Ok(
 		quote! {
-			#crate_::wasm_interface::Signature {
+			#crate_::sp_wasm_interface::Signature {
 				args: std::borrow::Cow::Borrowed(&[ #( #arg_types ),* ][..]),
 				return_value: #return_value,
 			}
@@ -292,7 +292,7 @@ fn generate_wasm_to_ffi_values<'a>(
 			Ok(quote! {
 				let val = args.next().ok_or_else(|| #error_message)?;
 				let #var_name = <
-					<#ty as #crate_::RIType>::FFIType as #crate_::wasm_interface::TryFromValue
+					<#ty as #crate_::RIType>::FFIType as #crate_::sp_wasm_interface::TryFromValue
 				>::try_from_value(val).ok_or_else(|| #try_from_error)?;
 			})
 		})
@@ -408,7 +408,7 @@ fn generate_return_value_into_wasm_value(sig: &Signature) -> TokenStream {
 				<#ty as #crate_::host::IntoFFIValue>::into_ffi_value(
 					#result_var_name,
 					__function_context__,
-				).map(#crate_::wasm_interface::IntoValue::into_value).map(Some)
+				).map(#crate_::sp_wasm_interface::IntoValue::into_value).map(Some)
 			}
 		}
 	}

substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/trait_decl_impl.rs

@@ -130,7 +130,7 @@ fn impl_trait_for_externalities(trait_def: &ItemTrait, is_wasm_only: bool) -> Re
 		});
 
 	let impl_type = if is_wasm_only {
-		quote!( &mut dyn #crate_::wasm_interface::FunctionContext )
+		quote!( &mut dyn #crate_::sp_wasm_interface::FunctionContext )
 	} else {
 		quote!( &mut dyn #crate_::Externalities )
 	};

substrate/primitives/runtime-interface/src/host.rs

@@ -18,7 +18,7 @@
 
 use crate::RIType;
 
-use wasm_interface::{FunctionContext, Result};
+use sp_wasm_interface::{FunctionContext, Result};
 
 /// Something that can be converted into a ffi value.
 pub trait IntoFFIValue: RIType {

substrate/primitives/runtime-interface/src/impls.rs

@@ -26,7 +26,7 @@ use crate::wasm::*;
 use static_assertions::assert_eq_size;
 
 #[cfg(feature = "std")]
-use wasm_interface::{FunctionContext, Result};
+use sp_wasm_interface::{FunctionContext, Result};
 
 use codec::{Encode, Decode};
 
@@ -448,7 +448,7 @@ impl IntoFFIValue for str {
 }
 
 #[cfg(feature = "std")]
-impl<T: wasm_interface::PointerType> RIType for Pointer<T> {
+impl<T: sp_wasm_interface::PointerType> RIType for Pointer<T> {
 	type FFIType = u32;
 }
 
@@ -475,7 +475,7 @@ impl<T> FromFFIValue for Pointer<T> {
 }
 
 #[cfg(feature = "std")]
-impl<T: wasm_interface::PointerType> FromFFIValue for Pointer<T> {
+impl<T: sp_wasm_interface::PointerType> FromFFIValue for Pointer<T> {
 	type SelfInstance = Self;
 
 	fn from_ffi_value(_: &mut dyn FunctionContext, arg: u32) -> Result<Self> {
@@ -484,7 +484,7 @@ impl<T: wasm_interface::PointerType> FromFFIValue for Pointer<T> {
 }
 
 #[cfg(feature = "std")]
-impl<T: wasm_interface::PointerType> IntoFFIValue for Pointer<T> {
+impl<T: sp_wasm_interface::PointerType> IntoFFIValue for Pointer<T> {
 	fn into_ffi_value(self, _: &mut dyn FunctionContext) -> Result<u32> {
 		Ok(self.into())
 	}

substrate/primitives/runtime-interface/src/lib.rs

@@ -76,7 +76,7 @@ extern crate self as sp_runtime_interface;
 
 #[doc(hidden)]
 #[cfg(feature = "std")]
-pub use wasm_interface;
+pub use sp_wasm_interface;
 
 #[doc(hidden)]
 pub use sp_std;
@@ -130,7 +130,7 @@ pub use sp_std;
 ///         fn set_or_clear(&mut self, optional: Option<Vec<u8>>);
 ///     }
 ///
-///     impl Interface for &mut dyn externalities::Externalities {
+///     impl Interface for &mut dyn sp_externalities::Externalities {
 ///         fn call_some_complex_code(data: &[u8]) -> Vec<u8> { Vec::new() }
 ///         fn set_or_clear(&mut self, optional: Option<Vec<u8>>) {
 ///             match optional {
@@ -141,11 +141,11 @@ pub use sp_std;
 ///     }
 ///
 ///     pub fn call_some_complex_code(data: &[u8]) -> Vec<u8> {
-///         <&mut dyn externalities::Externalities as Interface>::call_some_complex_code(data)
+///         <&mut dyn sp_externalities::Externalities as Interface>::call_some_complex_code(data)
 ///     }
 ///
 ///     pub fn set_or_clear(optional: Option<Vec<u8>>) {
-///         externalities::with_externalities(|mut ext| Interface::set_or_clear(&mut ext, optional))
+///         sp_externalities::with_externalities(|mut ext| Interface::set_or_clear(&mut ext, optional))
 ///             .expect("`set_or_clear` called outside of an Externalities-provided environment.")
 ///     }
 ///
@@ -227,7 +227,7 @@ pub use sp_runtime_interface_proc_macro::runtime_interface;
 
 #[doc(hidden)]
 #[cfg(feature = "std")]
-pub use externalities::{
+pub use sp_externalities::{
 	set_and_run_with_externalities, with_externalities, Externalities, ExternalitiesExt, ExtensionStore,
 };
 
@@ -249,7 +249,7 @@ pub mod pass_by;
 pub trait RIType {
 	/// The ffi type that is used to represent `Self`.
 	#[cfg(feature = "std")]
-	type FFIType: wasm_interface::IntoValue + wasm_interface::TryFromValue;
+	type FFIType: sp_wasm_interface::IntoValue + sp_wasm_interface::TryFromValue;
 	#[cfg(not(feature = "std"))]
 	type FFIType;
 }
@@ -260,4 +260,4 @@ pub type Pointer<T> = *mut T;
 
 /// A pointer that can be used in a runtime interface function signature.
 #[cfg(feature = "std")]
-pub type Pointer<T> = wasm_interface::Pointer<T>;
+pub type Pointer<T> = sp_wasm_interface::Pointer<T>;

substrate/primitives/runtime-interface/src/pass_by.rs

@@ -28,7 +28,7 @@ use crate::host::*;
 use crate::wasm::*;
 
 #[cfg(feature = "std")]
-use wasm_interface::{FunctionContext, Pointer, Result};
+use sp_wasm_interface::{FunctionContext, Pointer, Result};
 
 use sp_std::{marker::PhantomData, convert::TryFrom};
 

substrate/primitives/runtime-interface/test-wasm/Cargo.toml

@@ -6,14 +6,14 @@ edition = "2018"
 build = "build.rs"
 
 [dependencies]
-runtime-interface = { package = "sp-runtime-interface", path = "../", default-features = false }
+sp-runtime-interface = { path = "../", default-features = false }
 sp-std = { path = "../../std", default-features = false }
 sp-io = { path = "../../io", default-features = false }
-primitives = { package = "sp-core", path = "../../core", default-features = false }
+sp-core = { path = "../../core", default-features = false }
 
 [build-dependencies]
 wasm-builder-runner = { package = "substrate-wasm-builder-runner", version = "1.0.3", path = "../../../utils/wasm-builder-runner" }
 
 [features]
 default = [ "std" ]
-std = [ "runtime-interface/std", "sp-std/std", "primitives/std", "sp-io/std" ]
+std = [ "sp-runtime-interface/std", "sp-std/std", "sp-core/std", "sp-io/std" ]

substrate/primitives/runtime-interface/test-wasm/src/lib.rs

@@ -18,12 +18,12 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use runtime_interface::runtime_interface;
+use sp_runtime_interface::runtime_interface;
 
 #[cfg(not(feature = "std"))]
 use sp_std::{vec, vec::Vec, mem, convert::TryFrom};
 
-use primitives::{sr25519::Public, wasm_export_functions};
+use sp_core::{sr25519::Public, wasm_export_functions};
 
 // Inlucde the WASM binary
 #[cfg(feature = "std")]

substrate/primitives/runtime-interface/test/Cargo.toml

@@ -7,8 +7,8 @@ publish = false
 
 [dependencies]
 sp-runtime-interface = { path = "../" }
-executor = { package = "sc-executor", path = "../../../client/executor" }
-test-wasm = { package = "sp-runtime-interface-test-wasm", path = "../test-wasm" }
-state_machine = { package = "sp-state-machine", path = "../../../primitives/state-machine"  }
-primitives = { package = "sp-core", path = "../../core" }
+sc-executor = { path = "../../../client/executor" }
+sp-runtime-interface-test-wasm = { path = "../test-wasm" }
+sp-state-machine = { path = "../../../primitives/state-machine"  }
+sp-core = { path = "../../core" }
 sp-io = { path = "../../io" }

substrate/primitives/runtime-interface/test/src/lib.rs

@@ -17,26 +17,26 @@
 //! Integration tests for runtime interface primitives
 
 use sp_runtime_interface::*;
-use test_wasm::{WASM_BINARY, test_api::HostFunctions};
-use wasm_interface::HostFunctions as HostFunctionsT;
+use sp_runtime_interface_test_wasm::{WASM_BINARY, test_api::HostFunctions};
+use sp_wasm_interface::HostFunctions as HostFunctionsT;
 
-type TestExternalities = state_machine::TestExternalities<primitives::Blake2Hasher, u64>;
+type TestExternalities = sp_state_machine::TestExternalities<sp_core::Blake2Hasher, u64>;
 
 fn call_wasm_method<HF: HostFunctionsT>(method: &str) -> TestExternalities {
     let mut ext = TestExternalities::default();
     let mut ext_ext = ext.ext();
 
-    executor::call_in_wasm::<
+    sc_executor::call_in_wasm::<
         _,
         (
             HF,
             sp_io::SubstrateHostFunctions,
-            executor::deprecated_host_interface::SubstrateExternals
+            sc_executor::deprecated_host_interface::SubstrateExternals
         )
     >(
         method,
         &[],
-        executor::WasmExecutionMethod::Interpreted,
+        sc_executor::WasmExecutionMethod::Interpreted,
         &mut ext_ext,
         &WASM_BINARY[..],
         8,