Rename TrampolineState to EnvState.

Author: jimpo

core/executor/src/wasmtime/runtime.rs

@@ -20,7 +20,7 @@ use crate::error::{Error, Result, WasmError};
 use crate::host_interface::SubstrateExternals;
 use crate::wasm_runtime::WasmRuntime;
 use crate::wasmtime::function_executor::FunctionExecutorState;
-use crate::wasmtime::trampoline::{TrampolineState, make_trampoline};
+use crate::wasmtime::trampoline::{EnvState, make_trampoline};
 use crate::wasmtime::util::{cranelift_ir_signature, read_memory_into, write_memory_from};
 use crate::{Externalities, RuntimeVersion};
 
@@ -182,7 +182,7 @@ fn call_method(
 		unsafe { mem::transmute::<_, &'static mut Compiler>(context.compiler_mut()) },
 		get_heap_base(&instance)?,
 	);
-	reset_host_state(context, Some(executor_state))?;
+	reset_env_state(context, Some(executor_state))?;
 
 	// Write the input data into guest memory.
 	let (data_ptr, data_len) = inject_input_data(context, &mut instance, data)?;
@@ -194,7 +194,7 @@ fn call_method(
 			.invoke(&mut instance, method, &args[..])
 			.map_err(Error::Wasmtime)
 	})?;
-	let trap_error = reset_host_state(context, None)?;
+	let trap_error = reset_env_state(context, None)?;
 	let (output_ptr, output_len) = match outcome {
 		ActionOutcome::Returned { values } => {
 			if values.len()	!= 1 {
@@ -260,7 +260,7 @@ fn instantiate_env_module(global_exports: Rc<RefCell<HashMap<String, Option<Expo
 	let imports = Imports::none();
 	let data_initializers = Vec::new();
 	let signatures = PrimaryMap::new();
-	let host_state = TrampolineState::new::<SubstrateExternals>(code_memory);
+	let env_state = EnvState::new::<SubstrateExternals>(code_memory);
 
 	let result = InstanceHandle::new(
 		Rc::new(module),
@@ -270,7 +270,7 @@ fn instantiate_env_module(global_exports: Rc<RefCell<HashMap<String, Option<Expo
 		&data_initializers,
 		signatures.into_boxed_slice(),
 		None,
-		Box::new(host_state),
+		Box::new(env_state),
 	);
 	result.map_err(|e| WasmError::WasmtimeSetup(SetupError::Instantiate(e)))
 }
@@ -305,30 +305,30 @@ fn grow_memory(instance: &mut InstanceHandle, pages: u32) -> Result<()> {
 		.ok_or_else(|| "requested heap_pages would exceed maximum memory size".into())
 }
 
-fn get_host_state(context: &mut Context) -> Result<&mut TrampolineState> {
+fn get_env_state(context: &mut Context) -> Result<&mut EnvState> {
 	let env_instance = context.get_instance("env")
 		.map_err(|err| format!("cannot find \"env\" module: {}", err))?;
 	env_instance
 		.host_state()
-		.downcast_mut::<TrampolineState>()
+		.downcast_mut::<EnvState>()
 		.ok_or_else(|| "cannot get \"env\" module host state".into())
 }
 
-fn reset_host_state(context: &mut Context, executor_state: Option<FunctionExecutorState>)
+fn reset_env_state(context: &mut Context, executor_state: Option<FunctionExecutorState>)
 	-> Result<Option<Error>>
 {
-	let trampoline_state = get_host_state(context)?;
-	trampoline_state.executor_state = executor_state;
-	Ok(trampoline_state.reset_trap())
+	let env_state = get_env_state(context)?;
+	env_state.executor_state = executor_state;
+	Ok(env_state.take_trap())
 }
 
 fn inject_input_data(
 	context: &mut Context,
 	instance: &mut InstanceHandle,
 	data: &[u8],
 ) -> Result<(Pointer<u8>, WordSize)> {
-	let trampoline_state = get_host_state(context)?;
-	let executor_state = trampoline_state.executor_state
+	let env_state = get_env_state(context)?;
+	let executor_state = env_state.executor_state
 		.as_mut()
 		.ok_or_else(|| "cannot get \"env\" module executor state")?;
 

core/executor/src/wasmtime/trampoline.rs

@@ -32,7 +32,7 @@ use crate::wasmtime::function_executor::{FunctionExecutorState, FunctionExecutor
 
 /// The top-level host state of the "env" module. This state is used by the trampoline function to
 /// construct a `FunctionExecutor` which can execute the host call.
-pub struct TrampolineState {
+pub struct EnvState {
 	externals: &'static [&'static dyn Function],
 	trap: Option<Error>,
 	/// The executor state stored across host calls during a single Wasm runtime call.
@@ -43,10 +43,10 @@ pub struct TrampolineState {
 	code_memory: CodeMemory,
 }
 
-impl TrampolineState {
-	/// Construct a new `TrampolineState` which owns the given code memory.
+impl EnvState {
+	/// Construct a new `EnvState` which owns the given code memory.
 	pub fn new<HF: HostFunctions>(code_memory: CodeMemory) -> Self {
-		TrampolineState {
+		EnvState {
 			externals: HF::functions(),
 			trap: None,
 			executor_state: None,
@@ -55,15 +55,15 @@ impl TrampolineState {
 	}
 
 	/// Resets the trap error to None and returns the current value.
-	pub fn reset_trap(&mut self) -> Option<Error> {
-		mem::replace(&mut self.trap, None)
+	pub fn take_trap(&mut self) -> Option<Error> {
+		self.trap.take()
 	}
 }
 
 /// This is called by the dynamically generated trampoline taking the function index and reference
 /// to the call arguments on the stack as arguments. Returns 0 on success and 1 on an error.
 unsafe extern "C" fn stub_fn(vmctx: *mut VMContext, func_index: u32, values_vec: *mut i64) -> u32 {
-	if let Some(state) = (*vmctx).host_state().downcast_mut::<TrampolineState>() {
+	if let Some(state) = (*vmctx).host_state().downcast_mut::<EnvState>() {
 		match stub_fn_inner(
 			vmctx,
 			state.externals,