Rename mk_module to make_module.

Author: cthulahoops

vm/src/stdlib/ast.rs

@@ -621,7 +621,7 @@ fn ast_parse(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(ast_node)
 }
 
-pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     py_module!(ctx, "ast", {
         "parse" => ctx.new_rustfunc(ast_parse),
         "Module" => py_class!(ctx, "_ast.Module", ctx.object(), {}),

vm/src/stdlib/dis.rs

@@ -22,7 +22,7 @@ fn dis_disassemble(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.get_none())
 }
 
-pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     py_module!(ctx, "dis", {
         "dis" => ctx.new_rustfunc(dis_dis),
         "disassemble" => ctx.new_rustfunc(dis_disassemble)

vm/src/stdlib/io.rs

@@ -365,7 +365,7 @@ pub fn io_open(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     }
 }
 
-pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     //IOBase the abstract base class of the IO Module
     let io_base = py_class!(ctx, "IOBase", ctx.object(), {
         "__enter__" => ctx.new_rustfunc(io_base_cm_enter),

vm/src/stdlib/json.rs

@@ -228,7 +228,7 @@ fn json_loads(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     })
 }
 
-pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     // TODO: Make this a proper type with a constructor
     let json_decode_error = create_type(
         "JSONDecodeError",

vm/src/stdlib/keyword.rs

@@ -17,7 +17,7 @@ fn keyword_iskeyword(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(value)
 }
 
-pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     let keyword_kwlist = ctx.new_list(
         lexer::get_keywords()
             .keys()

vm/src/stdlib/math.rs

@@ -171,7 +171,7 @@ fn math_lgamma(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     }
 }
 
-pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     py_module!(ctx, "math", {
         // Number theory functions:
         "fabs" => ctx.new_rustfunc(math_fabs),

vm/src/stdlib/mod.rs

@@ -28,28 +28,28 @@ pub fn get_module_inits() -> HashMap<String, StdlibInitFunc> {
     let mut modules = HashMap::new();
     modules.insert(
         "ast".to_string(),
-        Box::new(ast::mk_module) as StdlibInitFunc,
+        Box::new(ast::make_module) as StdlibInitFunc,
     );
-    modules.insert("dis".to_string(), Box::new(dis::mk_module));
-    modules.insert("json".to_string(), Box::new(json::mk_module));
-    modules.insert("keyword".to_string(), Box::new(keyword::mk_module));
-    modules.insert("math".to_string(), Box::new(math::mk_module));
-    modules.insert("platform".to_string(), Box::new(platform::mk_module));
-    modules.insert("re".to_string(), Box::new(re::mk_module));
-    modules.insert("random".to_string(), Box::new(random::mk_module));
-    modules.insert("string".to_string(), Box::new(string::mk_module));
-    modules.insert("struct".to_string(), Box::new(pystruct::mk_module));
-    modules.insert("time".to_string(), Box::new(time_module::mk_module));
-    modules.insert("tokenize".to_string(), Box::new(tokenize::mk_module));
-    modules.insert("types".to_string(), Box::new(types::mk_module));
-    modules.insert("_weakref".to_string(), Box::new(weakref::mk_module));
+    modules.insert("dis".to_string(), Box::new(dis::make_module));
+    modules.insert("json".to_string(), Box::new(json::make_module));
+    modules.insert("keyword".to_string(), Box::new(keyword::make_module));
+    modules.insert("math".to_string(), Box::new(math::make_module));
+    modules.insert("platform".to_string(), Box::new(platform::make_module));
+    modules.insert("re".to_string(), Box::new(re::make_module));
+    modules.insert("random".to_string(), Box::new(random::make_module));
+    modules.insert("string".to_string(), Box::new(string::make_module));
+    modules.insert("struct".to_string(), Box::new(pystruct::make_module));
+    modules.insert("time".to_string(), Box::new(time_module::make_module));
+    modules.insert("tokenize".to_string(), Box::new(tokenize::make_module));
+    modules.insert("types".to_string(), Box::new(types::make_module));
+    modules.insert("_weakref".to_string(), Box::new(weakref::make_module));
 
     // disable some modules on WASM
     #[cfg(not(target_arch = "wasm32"))]
     {
-        modules.insert("io".to_string(), Box::new(io::mk_module));
-        modules.insert("os".to_string(), Box::new(os::mk_module));
-        modules.insert("socket".to_string(), Box::new(socket::mk_module));
+        modules.insert("io".to_string(), Box::new(io::make_module));
+        modules.insert("os".to_string(), Box::new(os::make_module));
+        modules.insert("socket".to_string(), Box::new(socket::make_module));
     }
 
     modules

vm/src/stdlib/os.rs

@@ -118,7 +118,7 @@ fn os_error(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Err(vm.new_os_error(msg))
 }
 
-pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     let py_mod = py_module!(ctx, "os", {
         "open" => ctx.new_rustfunc(os_open),
         "close" => ctx.new_rustfunc(os_close),

vm/src/stdlib/platform.rs

@@ -3,7 +3,7 @@ extern crate rustc_version_runtime;
 use crate::pyobject::{PyContext, PyFuncArgs, PyObjectRef, PyResult};
 use crate::VirtualMachine;
 
-pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     py_module!(ctx, "platform", {
         "python_compiler" => ctx.new_rustfunc(platform_python_compiler),
         "python_implementation" => ctx.new_rustfunc(platform_python_implementation),

vm/src/stdlib/pystruct.rs

@@ -296,7 +296,7 @@ fn struct_unpack(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.ctx.new_tuple(items))
 }
 
-pub fn mk_module(ctx: &PyContext) -> PyObjectRef {
+pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     py_module!(ctx, "struct", {
         "pack" => ctx.new_rustfunc(struct_pack),
         "unpack" => ctx.new_rustfunc(struct_unpack)