tmp

Author: alexcrichton

crates/backend/src/ast.rs

@@ -587,6 +587,26 @@ impl Variant {
 
 impl Import {
     fn shared(&self) -> shared::Import {
+        match (&self.module, &self.version) {
+            (&Some(ref m), None) if m.starts_with("./") => {}
+            (&Some(ref m), &Some(_)) if m.starts_with("./") => {
+                panic!("when a module path starts with `./` that indicates \
+                        that a local file is being imported so the `version` \
+                        key cannot also be specified");
+            }
+            (&Some(_), &Some(_)) => {}
+            (&Some(_), &None) => {
+                panic!("when the `module` directive doesn't start with `./` \
+                        then it's interpreted as an NPM package which requires \
+                        a `version` to be specified as well, try using \
+                        #[wasm_bindgen(module = \"...\", version = \"...\")]")
+            }
+            (&None, &Some(_)) => {
+                panic!("the #[wasm_bindgen(version = \"...\")] attribute can only \
+                        be used when `module = \"...\"` is also specified");
+            }
+            (&None, &None) => {}
+        }
         shared::Import {
             module: self.module.clone(),
             version: self.version.clone(),

crates/cli-support/src/js/mod.rs

@@ -1429,12 +1429,7 @@ impl<'a, 'b> SubContext<'a, 'b> {
     }
 
     fn generate_import(&mut self, import: &shared::Import) -> Result<(), Error> {
-        match (&import.module, &import.version) {
-            (&Some(ref m), &Some(ref v)) => {
-                self.cx.module_versions.push((m.clone(), v.clone()));
-            }
-            _ => {}
-        }
+        self.validate_import_module(import)?;
         match import.kind {
             shared::ImportKind::Function(ref f) => {
                 self.generate_import_function(import, f)
@@ -1455,6 +1450,40 @@ impl<'a, 'b> SubContext<'a, 'b> {
         Ok(())
     }
 
+    fn validate_import_module(&mut self, import: &shared::Import)
+        -> Result<(), Error>
+    {
+        let version = match import.version {
+            Some(ref s) => s,
+            None => return Ok(()),
+        };
+        let module = match import.module {
+            Some(ref s) => s,
+            None => return Ok(()),
+        };
+        if module.starts_with("./") {
+            return Ok(())
+        }
+        let pkg = if module.starts_with("@") {
+            // Translate `@foo/bar/baz` to `@foo/bar` and `@foo/bar` to itself
+            let first_slash = match module.find('/') {
+                Some(i) => i,
+                None => {
+                    bail!("packages starting with `@` must be of the form \
+                           `@foo/bar`, but found: `{}`", module)
+                }
+            };
+            match module[first_slash + 1..].find('/') {
+                Some(i) => &module[..i],
+                None => module,
+            }
+        } else {
+            module.split('/').next().unwrap()
+        };
+        self.cx.module_versions.push((pkg.to_string(), version.clone()));
+        Ok(())
+    }
+
     fn generate_import_static(
         &mut self,
         info: &shared::Import,