add support for source-phase imports (import source, import.source(...))

Implements the TC39 source-phase imports proposal (https://github.com/tc39/proposal-source-phase-imports) for both the static and dynamic forms:

  // static
  import source wasmModule from "./foo.wasm";
  import defer * as ns from "./mod.js";

  // dynamic
  const m = await import.source("./foo.wasm");
  const m = await import.defer("./mod.js");

The `source` phase tells the host to materialize the module's source
representation (e.g. a WebAssembly.Module for .wasm) instead of its
exports namespace; `defer` requests a lazily-evaluated namespace.
Dropping the phase keyword silently changes runtime semantics, which
is what terser was doing on the mozilla-AST round-trip used by tools
like Emscripten's acorn-optimizer.

Static side:
* Parser recognises the contextual `source` / `defer` phase keyword
  after `import`, with peek-based disambiguation so existing patterns
  like `import source from "x"` and `import defer, {y} from "x"`
  keep parsing as default-name imports.
* AST_Import gains a `phase` field (null for plain imports).
* mozilla-ast from_moz / to_moz carry the phase across, matching the
  shape produced by acorn-import-phases.
* Output prints the phase keyword between `import` and the specifier.
* equivalent-to includes phase in shallow_cmp.

Dynamic side:
* New AST_DynamicImport node used as the callee of an AST_Call
  representing a phased dynamic import; carries the phase. Plain
  dynamic `import(x)` continues to use the synthetic
  AST_SymbolRef("import") callee for back-compat.
* Parser dispatches `import.source` / `import.defer` via a new
  import_phase_call helper; they must be followed by a call, else
  a parse error is raised, mirroring the proposal.
* mozilla-ast: from_moz ImportExpression builds the AST_DynamicImport
  callee when M.phase is set; to_moz AST_Call emits a phased
  ImportExpression { phase } when the callee is AST_DynamicImport.
* Output prints `import.source` / `import.defer` for the callee.
* size and equivalent-to updated.

Local bindings stay AST_SymbolImport / AST_SymbolRef, so scope,
mangle and drop_unused behave exactly as for ordinary imports.

This fork is on terser 4.8.0 which lacks `import.meta` parser
support, so the import_phase_call helper handles only `source` /
`defer` (the upstream terser PR includes `meta` dispatch too).

Author: guybedford

lib/ast.js

@@ -849,12 +849,13 @@ var AST_NameMapping = DEFNODE("NameMapping", "foreign_name name", {
     },
 });
 
-var AST_Import = DEFNODE("Import", "imported_name imported_names module_name", {
+var AST_Import = DEFNODE("Import", "imported_name imported_names module_name phase", {
     $documentation: "An `import` statement",
     $propdoc: {
         imported_name: "[AST_SymbolImport] The name of the variable holding the module's default export.",
         imported_names: "[AST_NameMapping*] The names of non-default imported variables",
         module_name: "[AST_String] String literal describing where this module came from",
+        phase: "[string?] Phase keyword for source-phase imports ('source' or 'defer'), or null."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function() {
@@ -879,6 +880,13 @@ var AST_Import = DEFNODE("Import", "imported_name imported_names module_name", {
     },
 });
 
+var AST_DynamicImport = DEFNODE("DynamicImport", "phase", {
+    $documentation: "The callee of a dynamic `import(...)` / `import.source(...)` / `import.defer(...)` expression. Always appears as the `expression` of an AST_Call.",
+    $propdoc: {
+        phase: "[string?] Phase keyword ('source' or 'defer'), or null for a plain dynamic import."
+    },
+});
+
 var AST_Export = DEFNODE("Export", "exported_definition exported_value is_default exported_names module_name", {
     $documentation: "An `export` statement",
     $propdoc: {
@@ -1656,6 +1664,7 @@ export {
     AST_Function,
     AST_Hole,
     AST_If,
+    AST_DynamicImport,
     AST_Import,
     AST_Infinity,
     AST_IterationStatement,

lib/equivalent-to.js

@@ -25,6 +25,7 @@ import {
     AST_ForIn,
     AST_ForOf,
     AST_If,
+    AST_DynamicImport,
     AST_Import,
     AST_Jump,
     AST_LabeledStatement,
@@ -206,7 +207,12 @@ AST_NameMapping.prototype.shallow_cmp = pass_through;
 
 AST_Import.prototype.shallow_cmp = mkshallow({
     imported_name: "exist",
-    imported_names: "exist"
+    imported_names: "exist",
+    phase: "eq",
+});
+
+AST_DynamicImport.prototype.shallow_cmp = mkshallow({
+    phase: "eq",
 });
 
 AST_Export.prototype.shallow_cmp = mkshallow({

lib/mozilla-ast.js

@@ -88,6 +88,7 @@ import {
     AST_Function,
     AST_Hole,
     AST_If,
+    AST_DynamicImport,
     AST_Import,
     AST_Label,
     AST_LabeledStatement,
@@ -485,9 +486,11 @@ import {
                 end         : my_end_token(M),
                 imported_name: imported_name,
                 imported_names : imported_names,
-                module_name : from_moz(M.source)
+                module_name : from_moz(M.source),
+                phase: M.phase || null
             });
         },
+
         ExportAllDeclaration: function(M) {
             return new AST_Export({
                 start: my_start_token(M),
@@ -603,14 +606,23 @@ import {
         },
         ImportExpression: function(M) {
           let import_token = my_start_token(M);
+          // Source-phase imports proposal: `import.source(x)` / `import.defer(x)`
+          // arrive as ImportExpression nodes with a `phase` field (per
+          // acorn-import-phases). Plain dynamic imports continue to use a
+          // synthetic `import` SymbolRef callee for back-compat.
+          var expression = M.phase ? new AST_DynamicImport({
+              start: import_token,
+              end: my_end_token(M),
+              phase: M.phase,
+          }) : new AST_SymbolRef({
+              start: import_token,
+              end: import_token,
+              name: "import",
+          });
           return new AST_Call({
             start      : import_token,
             end        : my_end_token(M),
-            expression : new AST_SymbolRef({
-              start    : import_token,
-              end      : import_token,
-              name     : "import"
-            }),
+            expression : expression,
             args       : [from_moz(M.source)]
           });
         }
@@ -669,6 +681,28 @@ import {
     map("NewExpression", AST_New, "callee>expression, arguments@args");
     map("CallExpression", AST_Call, "callee>expression, arguments@args");
 
+    // AST_Call normally maps to CallExpression (registered above), but a
+    // phased dynamic import — `import.source(x)` / `import.defer(x)` — round-
+    // trips through Mozilla AST as an ImportExpression with `phase`, matching
+    // acorn-import-phases' shape.
+    def_to_moz(AST_Call, function To_Moz_CallOrImportExpression(M) {
+        if (M.expression instanceof AST_DynamicImport) {
+            var args = M.args.map(to_moz);
+            var out = {
+                type: "ImportExpression",
+                source: args[0],
+                options: args[1] || null,
+            };
+            if (M.expression.phase) out.phase = M.expression.phase;
+            return out;
+        }
+        return {
+            type: "CallExpression",
+            callee: to_moz(M.expression),
+            arguments: M.args.map(to_moz),
+        };
+    });
+
     def_to_moz(AST_Toplevel, function To_Moz_Program(M) {
         return to_moz_scope("Program", M);
     });
@@ -867,11 +901,13 @@ import {
                 });
             });
         }
-        return {
+        var moz = {
             type: "ImportDeclaration",
             specifiers: specifiers,
             source: to_moz(M.module_name)
         };
+        if (M.phase) moz.phase = M.phase;
+        return moz;
     });
 
     def_to_moz(AST_Sequence, function To_Moz_SequenceExpression(M) {

lib/output.js

@@ -93,6 +93,7 @@ import {
     AST_Function,
     AST_Hole,
     AST_If,
+    AST_DynamicImport,
     AST_Import,
     AST_Jump,
     AST_LabeledStatement,
@@ -1596,6 +1597,10 @@ function OutputStream(options) {
     DEFPRINT(AST_Import, function(self, output) {
         output.print("import");
         output.space();
+        if (self.phase) {
+            output.print(self.phase);
+            output.space();
+        }
         if (self.imported_name) {
             self.imported_name.print(output);
         }
@@ -1627,7 +1632,13 @@ function OutputStream(options) {
         self.module_name.print(output);
         output.semicolon();
     });
-
+    DEFPRINT(AST_DynamicImport, function(self, output) {
+        if (self.phase) {
+            output.print("import." + self.phase);
+        } else {
+            output.print("import");
+        }
+    });
     DEFPRINT(AST_NameMapping, function(self, output) {
         var is_import = output.parent() instanceof AST_Import;
         var definition = self.name.definition();

lib/parse.js

@@ -90,6 +90,7 @@ import {
     AST_Function,
     AST_Hole,
     AST_If,
+    AST_DynamicImport,
     AST_Import,
     AST_IterationStatement,
     AST_Label,
@@ -1169,7 +1170,7 @@ function parse($TEXT, options) {
                 }
                 return function_(AST_Defun, false, true, is_export_default);
             }
-            if (S.token.value == "import" && !is_token(peek(), "punc", "(")) {
+            if (S.token.value == "import" && !is_token(peek(), "punc", "(") && !is_token(peek(), "punc", ".")) {
                 next();
                 var node = import_();
                 semicolon();
@@ -2217,6 +2218,9 @@ function parse($TEXT, options) {
         if (is("operator", "new")) {
             return new_(allow_calls);
         }
+        if (is("name", "import") && is_token(peek(), "punc", ".")) {
+            return import_phase_call(allow_calls);
+        }
         var start = S.token;
         var peeked;
         var async = is("name", "async")
@@ -2594,6 +2598,21 @@ function parse($TEXT, options) {
 
     function import_() {
         var start = prev();
+
+        // Source-phase imports proposal: `import source NAME from "..."` and
+        // `import defer * as NS from "..."`. The phase keyword is a contextual
+        // identifier; disambiguate from a legitimate default-import named
+        // `source`/`defer` by peeking past it: if the next token is `from` or
+        // `,`, the identifier IS the default-imported binding, not a phase.
+        var phase = null;
+        if (is("name", "source") || is("name", "defer")) {
+            var peeked = peek();
+            if (!is_token(peeked, "name", "from") && !is_token(peeked, "punc", ",")) {
+                phase = S.token.value;
+                next();
+            }
+        }
+
         var imported_name;
         var imported_names;
         if (is("name")) {
@@ -2624,10 +2643,33 @@ function parse($TEXT, options) {
                 quote: mod_str.quote,
                 end: mod_str,
             }),
+            phase,
             end: S.token,
         });
     }
 
+    // Phased dynamic imports: `import.source(...)` / `import.defer(...)`. The
+    // proposal restricts these to the callee position of a call expression;
+    // `import.meta` is unsupported in this fork.
+    function import_phase_call(allow_calls) {
+        var start = S.token;
+        expect_token("name", "import");
+        expect_token("punc", ".");
+        if (!is("name", "source") && !is("name", "defer")) {
+            unexpected();
+        }
+        var phase = S.token.value;
+        next();
+        if (!is("punc", "(")) {
+            croak("'import." + phase + "' can only be used in a dynamic import");
+        }
+        return subscripts(new AST_DynamicImport({
+            start: start,
+            phase: phase,
+            end: prev(),
+        }), allow_calls);
+    }
+
     function map_name(is_import) {
         function make_symbol(type) {
             return new type({

lib/size.js

@@ -31,6 +31,7 @@ import {
     AST_Function,
     AST_Hole,
     AST_If,
+    AST_DynamicImport,
     AST_Import,
     AST_Infinity,
     AST_LabeledStatement,
@@ -257,6 +258,11 @@ AST_Import.prototype._size = function () {
     return size;
 };
 
+AST_DynamicImport.prototype._size = function () {
+    // `import` (6) or `import.source` (13) or `import.defer` (12)
+    return this.phase ? 7 + this.phase.length : 6;
+};
+
 AST_Export.prototype._size = function () {
     let size = 7 + (this.is_default ? 8 : 0);