feat: Add support for import assertions and JSON modules

cli/proc_state.rs

@@ -31,6 +31,7 @@ use deno_core::url::Url;
 use deno_core::CompiledWasmModuleStore;
 use deno_core::ModuleSource;
 use deno_core::ModuleSpecifier;
+use deno_core::ModuleType;
 use deno_core::SharedArrayBufferStore;
 use deno_graph::create_graph;
 use deno_graph::Dependency;
@@ -722,6 +723,9 @@ impl ProcState {
         code: code.clone(),
         module_url_specified: specifier.to_string(),
         module_url_found: found_specifier.to_string(),
+        // FIXME(bartlomieju): this should actually get module type from
+        // the media type of the file.
+        module_type: ModuleType::JavaScript,
       }),
       _ => Err(anyhow!(
         "Loading unprepared module: {}",

cli/standalone.rs

@@ -164,6 +164,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
 
       Ok(deno_core::ModuleSource {
         code,
+        module_type: deno_core::ModuleType::JavaScript,
         module_url_specified: module_specifier.to_string(),
         module_url_found: module_specifier.to_string(),
       })

core/bindings.rs

@@ -1,6 +1,7 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
 use crate::error::is_instance_of_error;
+use crate::modules::validate_import_assertions;
 use crate::modules::ModuleMap;
 use crate::resolve_url_or_path;
 use crate::JsRuntime;
@@ -17,6 +18,7 @@ use serde::Deserialize;
 use serde::Serialize;
 use serde_v8::to_v8;
 use std::cell::RefCell;
+use std::collections::HashMap;
 use std::option::Option;
 use url::Url;
 use v8::HandleScope;
@@ -243,7 +245,7 @@ pub extern "C" fn host_import_module_dynamically_callback(
   context: v8::Local<v8::Context>,
   referrer: v8::Local<v8::ScriptOrModule>,
   specifier: v8::Local<v8::String>,
-  _import_assertions: v8::Local<v8::FixedArray>,
+  import_assertions: v8::Local<v8::FixedArray>,
 ) -> *mut v8::Promise {
   let scope = &mut unsafe { v8::CallbackScope::new(context) };
 
@@ -267,6 +269,31 @@ pub extern "C" fn host_import_module_dynamically_callback(
   let resolver = v8::PromiseResolver::new(scope).unwrap();
   let promise = resolver.get_promise(scope);
 
+  let mut assertions: HashMap<String, String> = HashMap::default();
+  // "type" keyword, value
+  let no_of_assertions = import_assertions.length() / 2;
+  for i in 0..no_of_assertions {
+    let assert_key = import_assertions.get(scope, 2 * i).unwrap();
+    let assert_key_val = v8::Local::<v8::Value>::try_from(assert_key).unwrap();
+    let assert_value = import_assertions.get(scope, (2 * i) + 1).unwrap();
+    let assert_value_val =
+      v8::Local::<v8::Value>::try_from(assert_value).unwrap();
+    // skip parsing offset from assertion
+    assertions.insert(
+      assert_key_val.to_rust_string_lossy(scope),
+      assert_value_val.to_rust_string_lossy(scope),
+    );
+  }
+
+  {
+    let tc_scope = &mut v8::TryCatch::new(scope);
+    validate_import_assertions(tc_scope, assertions);
+    if tc_scope.has_caught() {
+      let e = tc_scope.exception().unwrap();
+      resolver.reject(tc_scope, e);
+    }
+  }
+
   let resolver_handle = v8::Global::new(scope, resolver);
   {
     let state_rc = JsRuntime::state(scope);

core/examples/fs_module_loader.rs

@@ -0,0 +1,37 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+
+use deno_core::anyhow::Error;
+use deno_core::FsModuleLoader;
+use deno_core::JsRuntime;
+use deno_core::RuntimeOptions;
+use std::rc::Rc;
+
+fn main() -> Result<(), Error> {
+  let args: Vec<String> = std::env::args().collect();
+  if args.len() < 2 {
+    println!("Usage: target/examples/debug/fs_module_loader <path_to_module>");
+    std::process::exit(1);
+  }
+  let main_url = args[1].clone();
+  println!("Run {}", main_url);
+
+  let mut js_runtime = JsRuntime::new(RuntimeOptions {
+    module_loader: Some(Rc::new(FsModuleLoader)),
+    ..Default::default()
+  });
+
+  let runtime = tokio::runtime::Builder::new_current_thread()
+    .enable_all()
+    .build()?;
+
+  let main_module = deno_core::resolve_path(&main_url)?;
+
+  let future = async move {
+    let mod_id = js_runtime.load_main_module(&main_module, None).await?;
+
+    let mut receiver = js_runtime.mod_evaluate(mod_id);
+    js_runtime.run_event_loop(false).await?;
+    Ok(())
+  };
+  runtime.block_on(future)
+}

core/lib.rs

@@ -61,6 +61,7 @@ pub use crate::modules::ModuleLoadId;
 pub use crate::modules::ModuleLoader;
 pub use crate::modules::ModuleSource;
 pub use crate::modules::ModuleSourceFuture;
+pub use crate::modules::ModuleType;
 pub use crate::modules::NoopModuleLoader;
 pub use crate::runtime::CompiledWasmModuleStore;
 pub use crate::runtime::SharedArrayBufferStore;

core/modules.rs

@@ -19,18 +19,50 @@ use std::collections::VecDeque;
 use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
-use std::sync::atomic::AtomicI32;
-use std::sync::atomic::Ordering;
 use std::task::Context;
 use std::task::Poll;
 
-lazy_static::lazy_static! {
-  pub static ref NEXT_LOAD_ID: AtomicI32 = AtomicI32::new(0);
-}
-
 pub type ModuleId = i32;
 pub type ModuleLoadId = i32;
 
+/// Throws V8 exception if assertions are invalid
+pub(crate) fn validate_import_assertions(
+  scope: &mut v8::HandleScope,
+  assertions: HashMap<String, String>,
+) {
+  for (key, value) in assertions {
+    if key == "type" {
+      // TODO(bartlomieju): store in a const list of supported values
+      if value != "json" {
+        let message = v8::String::new(
+          scope,
+          &format!("\"{}\" is not a valid module type.", value),
+        )
+        .unwrap();
+        let exception = v8::Exception::type_error(scope, message);
+        scope.throw_exception(exception);
+        return;
+      }
+    }
+  }
+}
+
+/// A type of module to be executed.
+///
+/// Currently only `JavaScript` variant is supported,
+/// but in future types like `JSON` and `WASM` will be
+/// supported.
+///
+/// For non-`JavaScript` modules, this value doesn't tell
+/// how to interpret the module; it is only used to validate
+/// the module against an import assertion (if one is present
+/// in the import statement).
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ModuleType {
+  JavaScript,
+  Json,
+}
+
 /// EsModule source code that will be loaded into V8.
 ///
 /// Users can implement `Into<ModuleInfo>` for different file types that
@@ -49,6 +81,7 @@ pub type ModuleLoadId = i32;
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ModuleSource {
   pub code: String,
+  pub module_type: ModuleType,
   pub module_url_specified: String,
   pub module_url_found: String,
 }
@@ -159,9 +192,20 @@ impl ModuleLoader for FsModuleLoader {
           module_specifier
         ))
       })?;
+      let module_type = if let Some(extension) = path.extension() {
+        if extension == "json" {
+          ModuleType::Json
+        } else {
+          ModuleType::JavaScript
+        }
+      } else {
+        ModuleType::JavaScript
+      };
+
       let code = std::fs::read_to_string(path)?;
       let module = ModuleSource {
         code,
+        module_type,
         module_url_specified: module_specifier.to_string(),
         module_url_found: module_specifier.to_string(),
       };
@@ -232,10 +276,16 @@ impl RecursiveModuleLoad {
   }
 
   fn new(init: LoadInit, module_map_rc: Rc<RefCell<ModuleMap>>) -> Self {
+    let id = {
+      let mut module_map = module_map_rc.borrow_mut();
+      let id = module_map.next_load_id;
+      module_map.next_load_id += 1;
+      id
+    };
     let op_state = module_map_rc.borrow().op_state.clone();
     let loader = module_map_rc.borrow().loader.clone();
     let mut load = Self {
-      id: NEXT_LOAD_ID.fetch_add(1, Ordering::SeqCst),
+      id,
       root_module_id: None,
       init,
       state: LoadState::Init,
@@ -419,6 +469,7 @@ impl Stream for RecursiveModuleLoad {
             // The code will be discarded, since this module is already in the
             // module map.
             code: Default::default(),
+            module_type: ModuleType::JavaScript,
           })
           .boxed()
         } else {
@@ -475,6 +526,7 @@ pub struct ModuleMap {
   info: HashMap<ModuleId, ModuleInfo>,
   by_name: HashMap<String, SymbolicModule>,
   next_module_id: ModuleId,
+  next_load_id: ModuleLoadId,
 
   // Handling of futures for loading module sources
   pub loader: Rc<dyn ModuleLoader>,
@@ -498,6 +550,7 @@ impl ModuleMap {
       info: HashMap::new(),
       by_name: HashMap::new(),
       next_module_id: 1,
+      next_load_id: 1,
       loader,
       op_state,
       dynamic_import_map: HashMap::new(),
@@ -557,6 +610,38 @@ impl ModuleMap {
       let import_specifier = module_request
         .get_specifier()
         .to_rust_string_lossy(tc_scope);
+
+      let import_assertions = module_request.get_import_assertions();
+
+      let mut assertions = HashMap::default();
+
+      // "type" keyword, value and source offset of assertion
+      let no_of_assertions = import_assertions.length() / 3;
+      for i in 0..no_of_assertions {
+        let assert_key = import_assertions.get(tc_scope, 3 * i).unwrap();
+        let assert_key_val =
+          v8::Local::<v8::Value>::try_from(assert_key).unwrap();
+        let assert_key_str = assert_key_val.to_rust_string_lossy(tc_scope);
+
+        let assert_value =
+          import_assertions.get(tc_scope, (3 * i) + 1).unwrap();
+        let assert_value_val =
+          v8::Local::<v8::Value>::try_from(assert_value).unwrap();
+        let assert_value_str = assert_value_val.to_rust_string_lossy(tc_scope);
+
+        // we're not interested in source code offset, so skipping it
+
+        assertions.insert(assert_key_str, assert_value_str);
+      }
+
+      // FIXME(bartomieju): there are no stack frames if exception
+      // is thrown here
+      validate_import_assertions(tc_scope, assertions);
+      if tc_scope.has_caught() {
+        let e = tc_scope.exception().unwrap();
+        return exception_to_err_result(tc_scope, e, false);
+      }
+
       let module_specifier =
         self.loader.resolve(&import_specifier, name, false)?;
       import_specifiers.push(module_specifier);
@@ -818,6 +903,7 @@ mod tests {
       match mock_source_code(&inner.url) {
         Some(src) => Poll::Ready(Ok(ModuleSource {
           code: src.0.to_owned(),
+          module_type: ModuleType::JavaScript,
           module_url_specified: inner.url.clone(),
           module_url_found: src.1.to_owned(),
         })),
@@ -1174,6 +1260,7 @@ mod tests {
         module_url_specified: specifier.to_string(),
         module_url_found: specifier.to_string(),
         code: "export function b() { return 'b' }".to_owned(),
+        module_type: ModuleType::JavaScript,
       };
       async move { Ok(info) }.boxed()
     }
@@ -1320,6 +1407,7 @@ mod tests {
           module_url_specified: specifier.to_string(),
           module_url_found: specifier.to_string(),
           code: code.to_owned(),
+          module_type: ModuleType::JavaScript,
         };
         async move { Ok(info) }.boxed()
       }
@@ -1648,11 +1736,13 @@ mod tests {
             module_url_specified: "file:///main_module.js".to_string(),
             module_url_found: "file:///main_module.js".to_string(),
             code: "if (!import.meta.main) throw Error();".to_owned(),
+            module_type: ModuleType::JavaScript,
           }),
           "file:///side_module.js" => Ok(ModuleSource {
             module_url_specified: "file:///side_module.js".to_string(),
             module_url_found: "file:///side_module.js".to_string(),
             code: "if (import.meta.main) throw Error();".to_owned(),
+            module_type: ModuleType::JavaScript,
           }),
           _ => unreachable!(),
         };

core/runtime.rs

@@ -1630,6 +1630,7 @@ pub mod tests {
   use crate::error::custom_error;
   use crate::modules::ModuleSource;
   use crate::modules::ModuleSourceFuture;
+  use crate::modules::ModuleType;
   use crate::op_async;
   use crate::op_sync;
   use crate::ZeroCopyBuf;
@@ -2642,6 +2643,7 @@ assertEquals(1, notify_return_value);
             code: "console.log('hello world');".to_string(),
             module_url_specified: "file:///main.js".to_string(),
             module_url_found: "file:///main.js".to_string(),
+            module_type: ModuleType::JavaScript,
           })
         }
         .boxed_local()

tools/wpt/expectation.json

@@ -6834,14 +6834,7 @@
     "semantics": {
       "scripting-1": {
         "the-script-element": {
-          "import-assertions": {
-            "dynamic-import-with-assertion-argument.any.html": [
-              "Dynamic import with an unsupported type assertion should fail"
-            ],
-            "dynamic-import-with-assertion-argument.any.worker.html": [
-              "Dynamic import with an unsupported type assertion should fail"
-            ]
-          },
+          "import-assertions": true,
           "json-module": {
             "charset-bom.any.html": [
               "UTF-8 BOM should be stripped when decoding JSON module script",