added basic support for module attributes and tests updated

packages/babel-parser/src/parser/expression.js

@@ -765,12 +765,26 @@ export default class ExpressionParser extends LValParser {
     optional: boolean,
   ): N.Expression {
     if (node.callee.type === "Import") {
-      if (node.arguments.length !== 1) {
-        this.raise(node.start, Errors.ImportCallArity);
+      if (node.arguments.length === 2) {
+        this.expectPlugin("moduleAttributes");
+      }
+      if (node.arguments.length === 0 || node.arguments.length > 2) {
+        this.raise(
+          node.start,
+          Errors.ImportCallArity,
+          this.hasPlugin("moduleAttributes")
+            ? "one or two arguments"
+            : "one argument",
+        );
       } else {
-        const importArg = node.arguments[0];
-        if (importArg && importArg.type === "SpreadElement") {
-          this.raise(importArg.start, Errors.ImportCallSpreadArgument);
+        const importArgSpreadElement = node.arguments.find(
+          arg => arg.type === "SpreadElement",
+        );
+        if (importArgSpreadElement) {
+          this.raise(
+            importArgSpreadElement.start,
+            Errors.ImportCallSpreadArgument,
+          );
         }
       }
     }
@@ -799,7 +813,7 @@ export default class ExpressionParser extends LValParser {
       } else {
         this.expect(tt.comma);
         if (this.match(close)) {
-          if (dynamicImport) {
+          if (dynamicImport && !this.hasPlugin("moduleAttributes")) {
             this.raise(
               this.state.lastTokStart,
               Errors.ImportCallArgumentTrailingComma,

packages/babel-parser/src/parser/location.js

@@ -67,7 +67,7 @@ export const Errors = Object.freeze({
   IllegalReturn: "'return' outside of function",
   ImportCallArgumentTrailingComma:
     "Trailing comma is disallowed inside import(...) arguments",
-  ImportCallArity: "import() requires exactly one argument",
+  ImportCallArity: "import() requires exactly %0",
   ImportCallArityLtOne: "Dynamic imports require a parameter: import('a.js')",
   ImportCallNotNewExpression: "Cannot use new with import(...)",
   ImportCallSpreadArgument: "... is not allowed in import()",
@@ -97,6 +97,12 @@ export const Errors = Object.freeze({
   MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX",
   MixingCoalesceWithLogical:
     "Nullish coalescing operator(??) requires parens when mixing with logical operators",
+  ModuleAttributeDifferentFromType:
+    "The only accepted module attribute is `type`",
+  ModuleAttributeInvalidValue:
+    "Only string literals are allowed as module attribute values",
+  ModuleAttributesWithDuplicateKeys:
+    'Duplicate key "%0" is not allowed in module attributes',
   ModuleExportUndefined: "Export '%0' is not defined",
   MultipleDefaultsInSwitch: "Multiple default clauses",
   NewlineAfterThrow: "Illegal newline after throw",

packages/babel-parser/src/parser/statement.js

@@ -2041,13 +2041,31 @@ export default class StatementParser extends ExpressionParser {
     // import '...'
     node.specifiers = [];
     if (!this.match(tt.string)) {
+      // check if we have a default import like
+      // import React from "react";
       const hasDefault = this.maybeParseDefaultImportSpecifier(node);
+      /* we are checking if we do not have a default import, then it is obvious that we need named imports
+       * import { get } from "axios";
+       * but if we do have a default import
+       * we need to check if we have a comma after that and
+       * that is where this `|| this.eat` condition comes into play
+       */
       const parseNext = !hasDefault || this.eat(tt.comma);
+      // if we do have to parse the next set of specifiers, we first check for star imports
+      // import React, * from "react";
       const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
+      // now we check if we need to parse the next imports
+      // but only if they are not importing * (everything)
       if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);
       this.expectContextual("from");
     }
     node.source = this.parseImportSource();
+    // https://github.com/tc39/proposal-module-attributes
+    // parse module attributes if the next token is `with` or ignore and finish the ImportDeclaration node.
+    const attributes = this.maybeParseModuleAttributes();
+    if (attributes) {
+      node.attributes = attributes;
+    }
     this.semicolon();
     return this.finishNode(node, "ImportDeclaration");
   }
@@ -2078,6 +2096,59 @@ export default class StatementParser extends ExpressionParser {
     node.specifiers.push(this.finishNode(specifier, type));
   }
 
+  maybeParseModuleAttributes() {
+    if (this.match(tt._with) && !this.hasPrecedingLineBreak()) {
+      this.expectPlugin("moduleAttributes");
+      this.next();
+    } else {
+      if (this.hasPlugin("moduleAttributes")) return [];
+      return null;
+    }
+    const attrs = [];
+    const attributes = new Set();
+    do {
+      // we are trying to parse a node which has the following syntax
+      // with type: "json"
+      // [with -> keyword], [type -> Identifier], [":" -> token for colon], ["json" -> StringLiteral]
+      const node = this.startNode();
+      node.key = this.parseIdentifier(true);
+
+      // for now we are only allowing `type` as the only allowed module attribute
+      if (node.key.name !== "type") {
+        this.raise(
+          node.key.start,
+          Errors.ModuleAttributeDifferentFromType,
+          node.key.name,
+        );
+      }
+
+      // check if we already have an entry for an attribute
+      // if a duplicate entry is found, throw an error
+      // for now this logic will come into play only when someone declares `type` twice
+      if (attributes.has(node.key.name)) {
+        this.raise(
+          node.key.start,
+          Errors.ModuleAttributesWithDuplicateKeys,
+          node.key.name,
+        );
+      }
+      attributes.add(node.key.name);
+      this.expect(tt.colon);
+      // check if the value set to the module attribute is a string as we only allow string literals
+      if (!this.match(tt.string)) {
+        throw this.unexpected(
+          this.state.start,
+          Errors.ModuleAttributeInvalidValue,
+        );
+      }
+      node.value = this.parseLiteral(this.state.value, "StringLiteral");
+      this.finishNode(node, "ImportAttribute");
+      attrs.push(node);
+    } while (this.eat(tt.comma));
+
+    return attrs;
+  }
+
   maybeParseDefaultImportSpecifier(node: N.ImportDeclaration): boolean {
     if (this.shouldParseDefaultImport(node)) {
       // import defaultObj, { x, y as z } from '...'

packages/babel-parser/src/plugin-utils.js

@@ -86,6 +86,20 @@ export function validatePlugins(plugins: PluginList) {
     );
   }
 
+  if (hasPlugin(plugins, "moduleAttributes")) {
+    const moduleAttributesVerionPluginOption = getPluginOption(
+      plugins,
+      "moduleAttributes",
+      "version",
+    );
+    if (moduleAttributesVerionPluginOption !== "may-2020") {
+      throw new Error(
+        "The 'moduleAttributes' plugin requires a 'version' option," +
+          " representing the last proposal update. Currently, the" +
+          " only supported value is 'may-2020'.",
+      );
+    }
+  }
   if (
     hasPlugin(plugins, "recordAndTuple") &&
     !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(

packages/babel-parser/test/fixtures/es2020/dynamic-import/multiple-args/input.js

@@ -1 +1 @@
-import('hello', 'world');
+import('hello', 'world', '!');

packages/babel-parser/test/fixtures/es2020/dynamic-import/multiple-args/output.json

@@ -1,21 +1,21 @@
 {
   "type": "File",
-  "start":0,"end":25,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":25}},
+  "start":0,"end":30,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":30}},
   "errors": [
     "SyntaxError: import() requires exactly one argument (1:0)"
   ],
   "program": {
     "type": "Program",
-    "start":0,"end":25,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":25}},
+    "start":0,"end":30,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":30}},
     "sourceType": "script",
     "interpreter": null,
     "body": [
       {
         "type": "ExpressionStatement",
-        "start":0,"end":25,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":25}},
+        "start":0,"end":30,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":30}},
         "expression": {
           "type": "CallExpression",
-          "start":0,"end":24,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":24}},
+          "start":0,"end":29,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":29}},
           "callee": {
             "type": "Import",
             "start":0,"end":6,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":6}}
@@ -38,6 +38,15 @@
                 "raw": "'world'"
               },
               "value": "world"
+            },
+            {
+              "type": "StringLiteral",
+              "start":25,"end":28,"loc":{"start":{"line":1,"column":25},"end":{"line":1,"column":28}},
+              "extra": {
+                "rawValue": "!",
+                "raw": "'!'"
+              },
+              "value": "!"
             }
           ]
         }

packages/babel-parser/test/fixtures/experimental/_no-plugin/module-attributes-dynamic/input.js

@@ -0,0 +1 @@
+import('hello', 'world');

packages/babel-parser/test/fixtures/experimental/_no-plugin/module-attributes-dynamic/options.json

@@ -0,0 +1,5 @@
+{
+  "throws": "This experimental syntax requires enabling the parser plugin: 'moduleAttributes' (1:24)",
+  "sourceType": "module",
+  "plugins": []
+}

packages/babel-parser/test/fixtures/experimental/_no-plugin/module-attributes/input.js

@@ -0,0 +1 @@
+import foo from "foo.json" with type: "json";

packages/babel-parser/test/fixtures/experimental/_no-plugin/module-attributes/options.json

@@ -0,0 +1,5 @@
+{
+  "throws": "This experimental syntax requires enabling the parser plugin: 'moduleAttributes' (1:27)",
+  "sourceType": "module",
+  "plugins": []
+}

packages/babel-parser/test/fixtures/experimental/module-attributes/dynamic-import-with-valid-syntax/input.js

@@ -0,0 +1 @@
+import("foo.json", { with: { type: "json" } })

packages/babel-parser/test/fixtures/experimental/module-attributes/dynamic-import-with-valid-syntax/options.json

@@ -0,0 +1,11 @@
+{
+  "plugins": [
+    [
+      "moduleAttributes",
+      {
+        "version": "may-2020"
+      }
+    ]
+  ],
+  "sourceType": "module"
+}