Align to review comments

client/executor/common/src/runtime_blob/runtime_blob.rs

@@ -149,11 +149,11 @@ impl RuntimeBlob {
 				// just in case to cover all of our bases.
 				self.raw_module
 					.insert_section(Section::Export(Default::default()))
-					.expect("an export section can be always inserted if it doesn't exist");
+					.expect("an export section can be always inserted if it doesn't exist; qed");
 			}
 			self.raw_module
 				.export_section_mut()
-				.expect("export section always exists")
+				.expect("export section already existed or we just added it above, so it always exists; qed")
 				.entries_mut()
 				.push(ExportEntry::new(memory_name, Internal::Memory(0)));
 

client/executor/wasmtime/src/imports.rs

@@ -64,20 +64,12 @@ where
 		if allow_missing_func_imports {
 			for (name, (import_ty, func_ty)) in registry.pending_func_imports {
 				let error = format!("call to a missing function {}:{}", import_ty.module(), name);
-				if func_ty.params().len() == 0 && func_ty.results().len() == 0 {
-					linker
-						.func_wrap("env", &name, move || -> Result<(), Trap> {
-							Err(Trap::new(error.clone()))
-						})
-						.expect("adding a missing import stub doesn't fail");
-				} else {
-					log::warn!("Missing import: '{}' {:?}", name, func_ty);
-					linker
-						.func_new("env", &name, func_ty.clone(), move |_, _, _| {
-							Err(Trap::new(error.clone()))
-						})
-						.expect("adding a missing import stub doesn't fail");
-				}
+				log::debug!("Missing import: '{}' {:?}", name, func_ty);
+				linker
+					.func_new("env", &name, func_ty.clone(), move |_, _, _| {
+						Err(Trap::new(error.clone()))
+					})
+					.expect("adding a missing import stub can only fail when the item already exists, and it is missing here; qed");
 			}
 		} else {
 			let mut names = Vec::new();
@@ -117,7 +109,7 @@ impl<'a, 'b> sp_wasm_interface::HostFunctionRegistry for Registry<'a, 'b> {
 		fn_name: &str,
 		func: impl wasmtime::IntoFunc<Self::State, Params, Results>,
 	) -> Result<(), Self::Error> {
-		if let Some((_, _)) = self.pending_func_imports.remove(fn_name) {
+		if self.pending_func_imports.remove(fn_name).is_some() {
 			self.linker.func_wrap("env", fn_name, func).map_err(|error| {
 				WasmError::Other(format!(
 					"failed to register host function '{}' with the WASM linker: {}",

client/executor/wasmtime/src/runtime.rs

@@ -537,15 +537,15 @@ where
 			let mut blob = instrument(blob, &config.semantics)?;
 
 			// We don't actually need the memory to be imported so we can just convert any memory
-			// import into an export with imputiny. This simplifies our code since `wasmtime` will
+			// import into an export with impunity. This simplifies our code since `wasmtime` will
 			// now automatically take care of creating the memory for us, and it also allows us
 			// to potentially enable `wasmtime`'s instance pooling at a later date. (Imported
 			// memories are ineligible for pooling.)
 			blob.convert_memory_import_into_export(
 				config
 					.heap_pages
 					.try_into()
-					.expect("a reasonable 'heap_pages' will never exceed 2^32"),
+					.map_err(|e| WasmError::Other(format!("invalid `heap_pages`: {}", e)))?,
 			)?;
 
 			let serialized_blob = blob.clone().serialize();