Change all Rc<ModuleInstance> to ModuleRef

examples/tictactoe.rs

@@ -5,9 +5,9 @@ use std::fmt;
 use std::rc::Rc;
 use parity_wasm::elements::{FunctionType, ValueType, TableType, GlobalType, MemoryType};
 use parity_wasm::interpreter::{
-	Error as InterpreterError, ModuleInstance, UserError,
+	Error as InterpreterError, ModuleInstance, UserError, ModuleRef,
 	HostFuncIndex, Externals, RuntimeValue, GlobalInstance, TableInstance, MemoryInstance,
-	TableRef, MemoryRef, GlobalRef, FuncRef, TryInto, ImportResolver, FuncInstance
+	TableRef, MemoryRef, GlobalRef, FuncRef, TryInto, ImportResolver, FuncInstance,
 };
 use parity_wasm::elements::{Error as DeserializationError};
 use parity_wasm::ValidationError;
@@ -260,7 +260,7 @@ impl<'a> ImportResolver for RuntimeImportResolver {
 
 fn instantiate(
 	path: &str,
-) -> Result<Rc<ModuleInstance>, Error> {
+) -> Result<ModuleRef, Error> {
 	let module = parity_wasm::deserialize_file(path)?;
 	let validated_module = parity_wasm::validate_module(module)?;
 
@@ -272,8 +272,8 @@ fn instantiate(
 }
 
 fn play(
-	x_instance: Rc<ModuleInstance>,
+	x_instance: ModuleRef,
-	o_instance: Rc<ModuleInstance>,
+	o_instance: ModuleRef,
 	game: &mut tictactoe::Game,
 ) -> Result<tictactoe::GameResult, Error> {
 	let mut turn_of = tictactoe::Player::X;

src/interpreter/func.rs

@@ -3,10 +3,11 @@ use std::fmt;
 use std::collections::HashMap;
 use std::borrow::Cow;
 use elements::{FunctionType, Local, Opcodes};
-use interpreter::{Error, ModuleInstance};
+use interpreter::Error;
 use interpreter::host::{Externals, HostFuncIndex};
 use interpreter::runner::{prepare_function_args, FunctionContext, Interpreter};
 use interpreter::value::RuntimeValue;
+use interpreter::module::ModuleRef;
 use common::stack::StackWithLimit;
 use common::{DEFAULT_FRAME_STACK_LIMIT, DEFAULT_VALUE_STACK_LIMIT};
 
@@ -24,7 +25,7 @@ impl ::std::ops::Deref for FuncRef {
 pub enum FuncInstance {
 	Internal {
 		func_type: Rc<FunctionType>,
-		module: Rc<ModuleInstance>,
+		module: ModuleRef,
 		body: Rc<FuncBody>,
 	},
 	Host {
@@ -57,7 +58,7 @@ impl fmt::Debug for FuncInstance {
 
 impl FuncInstance {
 	pub(crate) fn alloc_internal(
-		module: Rc<ModuleInstance>,
+		module: ModuleRef,
 		func_type: Rc<FunctionType>,
 		body: FuncBody,
 	) -> FuncRef {

src/interpreter/mod.rs

@@ -156,6 +156,6 @@ pub use self::program::ProgramInstance;
 pub use self::value::{RuntimeValue, TryInto};
 pub use self::host::{Externals, HostFuncIndex, EmptyExternals};
 pub use self::imports::{ImportResolver, Imports};
-pub use self::module::ModuleInstance;
+pub use self::module::{ModuleInstance, ModuleRef};
 pub use self::global::{GlobalInstance, GlobalRef};
 pub use self::func::{FuncInstance, FuncRef};

src/interpreter/module.rs

@@ -15,6 +15,8 @@ use interpreter::host::Externals;
 use validation::ValidatedModule;
 use common::{DEFAULT_MEMORY_INDEX, DEFAULT_TABLE_INDEX};
 
+pub type ModuleRef = Rc<ModuleInstance>;
+
 pub enum ExternVal {
 	Func(FuncRef),
 	Table(TableRef),
@@ -159,7 +161,7 @@ impl ModuleInstance {
 	fn alloc_module_non_func_items(
 		validated_module: &ValidatedModule,
 		extern_vals: &[ExternVal],
-	) -> Result<Rc<ModuleInstance>, Error> {
+	) -> Result<ModuleRef, Error> {
 		let module = validated_module.module();
 
 		let mut module_ref = Rc::new(ModuleInstance::default());
@@ -297,7 +299,7 @@ impl ModuleInstance {
 	fn alloc_module(
 		validated_module: &ValidatedModule,
 		extern_vals: &[ExternVal]
-	) -> Result<Rc<ModuleInstance>, Error> {
+	) -> Result<ModuleRef, Error> {
 		// Step 1: Allocate all items except functions.
 		let module_ref = Self::alloc_module_non_func_items(validated_module, extern_vals)?;
 
@@ -341,7 +343,7 @@ impl ModuleInstance {
 	fn instantiate_with_externvals(
 		validated_module: &ValidatedModule,
 		extern_vals: &[ExternVal],
-	) -> Result<Rc<ModuleInstance>, Error> {
+	) -> Result<ModuleRef, Error> {
 		let module = validated_module.module();
 
 		let module_ref = ModuleInstance::alloc_module(validated_module, extern_vals)?;
@@ -385,7 +387,7 @@ impl ModuleInstance {
 	fn instantiate_with_imports(
 		validated_module: &ValidatedModule,
 		imports: &Imports,
-	) -> Result<Rc<ModuleInstance>, Error> {
+	) -> Result<ModuleRef, Error> {
 		let module = validated_module.module();
 
 		let mut extern_vals = Vec::new();
@@ -499,7 +501,7 @@ impl<'a> InstantiationBuilder<'a> {
 		self
 	}
 
-	pub fn run_start<'b, E: Externals>(mut self, state: &'b mut E) -> Result<Rc<ModuleInstance>, Error> {
+	pub fn run_start<'b, E: Externals>(mut self, state: &'b mut E) -> Result<ModuleRef, Error> {
 		let imports = self.imports.get_or_insert_with(|| Imports::default());
 		let instance = ModuleInstance::instantiate_with_imports(self.validated_module, imports)?;
 
@@ -512,7 +514,7 @@ impl<'a> InstantiationBuilder<'a> {
 		Ok(instance)
 	}
 
-	pub fn assert_no_start(mut self) -> Result<Rc<ModuleInstance>, Error> {
+	pub fn assert_no_start(mut self) -> Result<ModuleRef, Error> {
 		assert!(self.validated_module.module().start_section().is_none());
 		let imports = self.imports.get_or_insert_with(|| Imports::default());
 		let instance = ModuleInstance::instantiate_with_imports(self.validated_module, imports)?;

src/interpreter/program.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use std::borrow::Cow;
 use elements::Module;
 use interpreter::Error;
-use interpreter::module::{ModuleInstance};
+use interpreter::module::{ModuleInstance, ModuleRef};
 use interpreter::func::{FuncInstance, FuncRef};
 use interpreter::value::RuntimeValue;
 use interpreter::imports::{Imports, ImportResolver};
@@ -13,7 +13,7 @@ use validation::validate_module;
 /// Program instance. Program is a set of instantiated modules.
 #[deprecated]
 pub struct ProgramInstance {
-	modules: HashMap<String, Rc<ModuleInstance>>,
+	modules: HashMap<String, ModuleRef>,
 	resolvers: HashMap<String, Box<ImportResolver>>,
 }
 
@@ -32,7 +32,7 @@ impl ProgramInstance {
 		name: &str,
 		module: Module,
 		externals: &'a mut E,
-	) -> Result<Rc<ModuleInstance>, Error> {
+	) -> Result<ModuleRef, Error> {
 		let module_instance = {
 			let mut imports = Imports::new();
 			for (module_name, module_instance) in self.modules.iter() {
@@ -59,7 +59,7 @@ impl ProgramInstance {
 		self.resolvers.insert(name.to_owned(), import_resolver);
 	}
 
-	pub fn insert_loaded_module(&mut self, name: &str, module: Rc<ModuleInstance>) {
+	pub fn insert_loaded_module(&mut self, name: &str, module: ModuleRef) {
 		self.modules.insert(name.to_owned(), module);
 	}
 
@@ -105,7 +105,7 @@ impl ProgramInstance {
 			.or_else(|| self.resolvers.get(name).map(|x| &**x))
 	}
 
-	pub fn module(&self, name: &str) -> Option<Rc<ModuleInstance>> {
+	pub fn module(&self, name: &str) -> Option<ModuleRef> {
 		self.modules.get(name).cloned()
 	}
 }

src/interpreter/runner.rs

@@ -7,7 +7,7 @@ use std::iter::repeat;
 use std::collections::{HashMap, VecDeque};
 use elements::{Opcode, BlockType, Local, FunctionType};
 use interpreter::Error;
-use interpreter::module::ModuleInstance;
+use interpreter::module::ModuleRef;
 use interpreter::func::FuncRef;
 use interpreter::func::FuncInstance;
 use interpreter::value::{
@@ -29,7 +29,7 @@ pub struct FunctionContext {
 	pub is_initialized: bool,
 	/// Internal function reference.
 	pub function: FuncRef,
-	pub module: Rc<ModuleInstance>,
+	pub module: ModuleRef,
 	/// Function return type.
 	pub return_type: BlockType,
 	/// Local variables.
@@ -1057,7 +1057,7 @@ impl FunctionContext {
 		self.locals.extend(locals);
 	}
 
-	pub fn module(&self) -> Rc<ModuleInstance> {
+	pub fn module(&self) -> ModuleRef {
 		Rc::clone(&self.module)
 	}