default options for v8::script_compiler::compile_module (#125)

And other clean ups

src/lib.rs

@@ -55,8 +55,7 @@ pub use isolate::Isolate;
 pub use isolate::OwnedIsolate;
 pub use local::Local;
 pub use locker::Locker;
-pub use module::Module;
+pub use module::*;
-pub use module::ModuleStatus;
 pub use number::{Integer, Number};
 pub use object::Object;
 pub use primitive_array::PrimitiveArray;

src/module.rs

@@ -11,11 +11,13 @@ use std::mem::MaybeUninit;
 type v8__Module__ResolveCallback =
   extern "C" fn(Local<Context>, Local<String>, Local<Module>) -> *mut Module;
 
-type ResolveCallback = fn(
+/// Called during Module::instantiate_module. Provided with arguments:
-  Local<Context>,
+/// (context, specifier, referrer)
-  Local<String>,
+/// Return null on error.
-  Local<Module>,
+/// Hint: to tranform Local<Module> to *mut Module do this:
-) -> Option<Local<'static, Module>>;
+///   &mut *module
+pub type ResolveCallback =
+  fn(Local<Context>, Local<String>, Local<Module>) -> *mut Module;
 
 extern "C" {
   fn v8__Module__GetStatus(this: *const Module) -> ModuleStatus;
@@ -144,10 +146,7 @@ impl Module {
     ) -> *mut Module {
       let guard = RESOLVE_CALLBACK.lock().unwrap();
       let cb = guard.unwrap();
-      match cb(context, specifier, referrer) {
+      cb(context, specifier, referrer)
-        None => std::ptr::null_mut(),
-        Some(mut p) => &mut *p,
-      }
     }
     let r =
       unsafe { v8__Module__InstantiateModule(self, context, c_cb) }.into();

src/script_compiler.rs

@@ -79,6 +79,19 @@ pub enum NoCacheReason {
 pub fn compile_module(
   isolate: &Isolate,
   source: Source,
+) -> Option<Local<Module>> {
+  compile_module2(
+    isolate,
+    source,
+    CompileOptions::NoCompileOptions,
+    NoCacheReason::NoReason,
+  )
+}
+
+/// Same as compile_module with more options.
+pub fn compile_module2(
+  isolate: &Isolate,
+  source: Source,
   options: CompileOptions,
   no_cache_reason: NoCacheReason,
 ) -> Option<Local<Module>> {

tests/test_api.rs

@@ -779,12 +779,7 @@ fn script_compiler_source() {
     let source =
       v8::script_compiler::Source::new(v8_str(scope, source), &script_origin);
 
-    let result = v8::script_compiler::compile_module(
+    let result = v8::script_compiler::compile_module(&isolate, source);
-      &isolate,
-      source,
-      v8::script_compiler::CompileOptions::NoCompileOptions,
-      v8::script_compiler::NoCacheReason::NoReason,
-    );
     assert!(result.is_some());
 
     context.exit();
@@ -814,13 +809,8 @@ fn module_instantiation_failures1() {
     let origin = mock_script_origin(scope, "foo.js");
     let source = v8::script_compiler::Source::new(source_text, &origin);
 
-    let mut module = v8::script_compiler::compile_module(
+    let mut module =
-      &isolate,
+      v8::script_compiler::compile_module(&isolate, source).unwrap();
-      source,
-      v8::script_compiler::CompileOptions::NoCompileOptions,
-      v8::script_compiler::NoCacheReason::NoReason,
-    )
-    .unwrap();
     assert_eq!(v8::ModuleStatus::Uninstantiated, module.get_status());
     assert_eq!(2, module.get_module_requests_length());
 
@@ -848,11 +838,11 @@ fn module_instantiation_failures1() {
         mut context: v8::Local<v8::Context>,
         _specifier: v8::Local<v8::String>,
         _referrer: v8::Local<v8::Module>,
-      ) -> Option<v8::Local<'static, v8::Module>> {
+      ) -> *mut v8::Module {
         let isolate: &mut v8::Isolate = context.as_mut();
         let e = v8_str(isolate, "boom");
         isolate.throw_exception(e.into());
-        None
+        std::ptr::null_mut()
       }
       let result = module.instantiate_module(context, resolve_callback);
       assert!(result.is_none());
@@ -871,6 +861,18 @@ fn module_instantiation_failures1() {
   drop(g);
 }
 
+fn compile_specifier_as_module_resolve_callback(
+  mut context: v8::Local<v8::Context>,
+  specifier: v8::Local<v8::String>,
+  _referrer: v8::Local<v8::Module>,
+) -> *mut v8::Module {
+  let isolate: &mut v8::Isolate = context.as_mut();
+  let origin = mock_script_origin(isolate, "module.js");
+  let source = v8::script_compiler::Source::new(specifier, &origin);
+  let module = v8::script_compiler::compile_module(isolate, source).unwrap();
+  &mut *cast(module)
+}
+
 #[test]
 fn module_evaluation() {
   let g = setup();
@@ -891,37 +893,14 @@ fn module_evaluation() {
     let origin = mock_script_origin(scope, "foo.js");
     let source = v8::script_compiler::Source::new(source_text, &origin);
 
-    let mut module = v8::script_compiler::compile_module(
+    let mut module =
-      &isolate,
+      v8::script_compiler::compile_module(&isolate, source).unwrap();
-      source,
-      v8::script_compiler::CompileOptions::NoCompileOptions,
-      v8::script_compiler::NoCacheReason::NoReason,
-    )
-    .unwrap();
     assert_eq!(v8::ModuleStatus::Uninstantiated, module.get_status());
 
-    fn resolve_callback(
+    let result = module.instantiate_module(
-      mut context: v8::Local<v8::Context>,
+      context,
-      specifier: v8::Local<v8::String>,
+      compile_specifier_as_module_resolve_callback,
-      _referrer: v8::Local<v8::Module>,
+    );
-    ) -> Option<v8::Local<'static, v8::Module>> {
-      let isolate_: &mut v8::Isolate = context.as_mut();
-      let module_ = {
-        let mut escapable_scope = v8::EscapableHandleScope::new(isolate_);
-        let origin = mock_script_origin(isolate_, "module.js");
-        let source = v8::script_compiler::Source::new(specifier, &origin);
-        let module = v8::script_compiler::compile_module(
-          isolate_,
-          source,
-          v8::script_compiler::CompileOptions::NoCompileOptions,
-          v8::script_compiler::NoCacheReason::NoReason,
-        )
-        .unwrap();
-        escapable_scope.escape(cast(module))
-      };
-      Some(cast(module_))
-    }
-    let result = module.instantiate_module(context, resolve_callback);
     assert!(result.unwrap());
     assert_eq!(v8::ModuleStatus::Instantiated, module.get_status());