Add support for import defer proposal

Co-authored-by: Nicolò Ribaudo <[email protected]>

Author: 2 people

src/compiler/checker.ts

@@ -432,6 +432,7 @@ import {
     ImportDeclaration,
     ImportEqualsDeclaration,
     ImportOrExportSpecifier,
+    ImportPhase,
     ImportSpecifier,
     ImportTypeNode,
     IndexedAccessType,
@@ -9858,6 +9859,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                                             propertyName && isIdentifier(propertyName) ? factory.createIdentifier(idText(propertyName)) : undefined,
                                             factory.createIdentifier(localName),
                                         )]),
+                                        ImportPhase.Evaluation,
                                     ),
                                     factory.createStringLiteral(specifier),
                                     /*attributes*/ undefined,
@@ -9944,7 +9946,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         addResult(
                             factory.createImportDeclaration(
                                 /*modifiers*/ undefined,
-                                factory.createImportClause(isTypeOnly, factory.createIdentifier(localName), /*namedBindings*/ undefined),
+                                factory.createImportClause(isTypeOnly, factory.createIdentifier(localName), /*namedBindings*/ undefined, ImportPhase.Evaluation),
                                 specifier,
                                 attributes,
                             ),
@@ -9959,7 +9961,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         addResult(
                             factory.createImportDeclaration(
                                 /*modifiers*/ undefined,
-                                factory.createImportClause(isTypeOnly, /*name*/ undefined, factory.createNamespaceImport(factory.createIdentifier(localName))),
+                                factory.createImportClause(isTypeOnly, /*name*/ undefined, factory.createNamespaceImport(factory.createIdentifier(localName)), ImportPhase.Evaluation),
                                 specifier,
                                 (node as ImportClause).parent.attributes,
                             ),
@@ -9995,6 +9997,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                                             factory.createIdentifier(localName),
                                         ),
                                     ]),
+                                    ImportPhase.Evaluation,
                                 ),
                                 specifier,
                                 (node as ImportSpecifier).parent.parent.parent.attributes,
@@ -52860,6 +52863,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         if (node.isTypeOnly && node.namedBindings?.kind === SyntaxKind.NamedImports) {
             return checkGrammarNamedImportsOrExports(node.namedBindings);
         }
+        if (node.phase !== ImportPhase.Evaluation && moduleKind !== ModuleKind.ESNext) {
+            return grammarErrorOnNode(node, Diagnostics.Deferred_imports_are_only_supported_when_the_module_flag_is_set_to_esnext);
+        }
         return false;
     }
 

src/compiler/diagnosticMessages.json

@@ -8433,5 +8433,17 @@
     "String literal import and export names are not supported when the '--module' flag is set to 'es2015' or 'es2020'.": {
         "category": "Error",
         "code": 18057
+    },
+    "Default imports aren't allowed for deferred imports.": {
+        "category": "Error",
+        "code": 18058
+    },
+    "Named imports aren't allowed for deferred imports.": {
+        "category": "Error",
+        "code": 18059
+    },
+    "Deferred imports are only supported when the '--module' flag is set to 'esnext'.": {
+        "category": "Error",
+        "code": 18060
     }
 }

src/compiler/emitter.ts

@@ -182,6 +182,7 @@ import {
     ImportDeclaration,
     ImportEqualsDeclaration,
     ImportOrExportSpecifier,
+    ImportPhase,
     ImportSpecifier,
     ImportTypeNode,
     IndexedAccessTypeNode,
@@ -3689,6 +3690,10 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
             emitTokenWithComment(SyntaxKind.TypeKeyword, node.pos, writeKeyword, node);
             writeSpace();
         }
+        else if (node.phase !== ImportPhase.Evaluation) {
+            emitTokenWithComment(SyntaxKind.DeferKeyword, node.pos, writeKeyword, node);
+            writeSpace();
+        }
         emit(node.name);
         if (node.name && node.namedBindings) {
             emitTokenWithComment(SyntaxKind.CommaToken, node.name.end, writePunctuation, node);

src/compiler/factory/nodeFactory.ts

@@ -135,6 +135,7 @@ import {
     ImportClause,
     ImportDeclaration,
     ImportEqualsDeclaration,
+    ImportPhase,
     ImportSpecifier,
     ImportTypeAssertionContainer,
     ImportTypeNode,
@@ -4723,11 +4724,12 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     }
 
     // @api
-    function createImportClause(isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause {
+    function createImportClause(isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, phase: ImportPhase): ImportClause {
         const node = createBaseDeclaration<ImportClause>(SyntaxKind.ImportClause);
         node.isTypeOnly = isTypeOnly;
         node.name = name;
         node.namedBindings = namedBindings;
+        node.phase = phase;
         node.transformFlags |= propagateChildFlags(node.name) |
             propagateChildFlags(node.namedBindings);
         if (isTypeOnly) {
@@ -4738,11 +4740,12 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
     }
 
     // @api
-    function updateImportClause(node: ImportClause, isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined) {
+    function updateImportClause(node: ImportClause, isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, phase: ImportPhase) {
         return node.isTypeOnly !== isTypeOnly
                 || node.name !== name
                 || node.namedBindings !== namedBindings
-            ? update(createImportClause(isTypeOnly, name, namedBindings), node)
+                || node.phase !== phase
+            ? update(createImportClause(isTypeOnly, name, namedBindings, phase), node)
             : node;
     }
 

src/compiler/factory/utilities.ts

@@ -75,6 +75,7 @@ import {
     ImportCall,
     ImportDeclaration,
     ImportEqualsDeclaration,
+    ImportPhase,
     InternalEmitFlags,
     isAssignmentExpression,
     isAssignmentOperator,
@@ -730,7 +731,7 @@ export function createExternalHelpersImportDeclarationIfNeeded(nodeFactory: Node
 
                     const externalHelpersImportDeclaration = nodeFactory.createImportDeclaration(
                         /*modifiers*/ undefined,
-                        nodeFactory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, namedBindings),
+                        nodeFactory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, namedBindings, ImportPhase.Evaluation),
                         nodeFactory.createStringLiteral(externalHelpersModuleNameText),
                         /*attributes*/ undefined,
                     );

src/compiler/parser.ts

@@ -123,6 +123,7 @@ import {
     ImportDeclaration,
     ImportEqualsDeclaration,
     ImportOrExportSpecifier,
+    ImportPhase,
     ImportSpecifier,
     ImportTypeAssertionContainer,
     ImportTypeNode,
@@ -7190,6 +7191,7 @@ namespace Parser {
                 // could be legal, it would add complexity for very little gain.
                 case SyntaxKind.InterfaceKeyword:
                 case SyntaxKind.TypeKeyword:
+                case SyntaxKind.DeferKeyword:
                     return nextTokenIsIdentifierOnSameLine();
                 case SyntaxKind.ModuleKeyword:
                 case SyntaxKind.NamespaceKeyword:
@@ -7221,7 +7223,7 @@ namespace Parser {
 
                 case SyntaxKind.ImportKeyword:
                     nextToken();
-                    return token() === SyntaxKind.StringLiteral || token() === SyntaxKind.AsteriskToken ||
+                    return token() === SyntaxKind.DeferKeyword || token() === SyntaxKind.StringLiteral || token() === SyntaxKind.AsteriskToken ||
                         token() === SyntaxKind.OpenBraceToken || tokenIsIdentifierOrKeyword(token());
                 case SyntaxKind.ExportKeyword:
                     let currentToken = nextToken();
@@ -7295,6 +7297,7 @@ namespace Parser {
             case SyntaxKind.NamespaceKeyword:
             case SyntaxKind.TypeKeyword:
             case SyntaxKind.GlobalKeyword:
+            case SyntaxKind.DeferKeyword:
                 // When these don't start a declaration, they're an identifier in an expression statement
                 return true;
 
@@ -8366,6 +8369,7 @@ namespace Parser {
         }
 
         let isTypeOnly = false;
+        let phase = ImportPhase.Evaluation;
         if (
             identifier?.escapedText === "type" &&
             (token() !== SyntaxKind.FromKeyword || isIdentifier() && lookAhead(nextTokenIsFromKeywordOrEqualsToken)) &&
@@ -8374,12 +8378,20 @@ namespace Parser {
             isTypeOnly = true;
             identifier = isIdentifier() ? parseIdentifier() : undefined;
         }
+        else if (identifier?.escapedText === "defer" && token() !== SyntaxKind.FromKeyword) {
+            phase = ImportPhase.Defer;
+            identifier = undefined;
+            if (isIdentifier()) {
+                parseErrorAtCurrentToken(Diagnostics.Default_imports_aren_t_allowed_for_deferred_imports);
+                identifier = parseIdentifier();
+            }
+        }
 
-        if (identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration()) {
+        if (identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() && phase !== ImportPhase.Defer) {
             return parseImportEqualsDeclaration(pos, hasJSDoc, modifiers, identifier, isTypeOnly);
         }
 
-        const importClause = tryParseImportClause(identifier, afterImportPos, isTypeOnly);
+        const importClause = tryParseImportClause(identifier, afterImportPos, isTypeOnly, /*skipJsDocLeadingAsterisks*/ undefined, phase);
         const moduleSpecifier = parseModuleSpecifier();
         const attributes = tryParseImportAttributes();
 
@@ -8388,7 +8400,7 @@ namespace Parser {
         return withJSDoc(finishNode(node, pos), hasJSDoc);
     }
 
-    function tryParseImportClause(identifier: Identifier | undefined, pos: number, isTypeOnly: boolean, skipJsDocLeadingAsterisks = false) {
+    function tryParseImportClause(identifier: Identifier | undefined, pos: number, isTypeOnly: boolean, skipJsDocLeadingAsterisks = false, phase: ImportPhase) {
         // ImportDeclaration:
         //  import ImportClause from ModuleSpecifier ;
         //  import ModuleSpecifier;
@@ -8398,7 +8410,7 @@ namespace Parser {
             token() === SyntaxKind.AsteriskToken || // import *
             token() === SyntaxKind.OpenBraceToken // import {
         ) {
-            importClause = parseImportClause(identifier, pos, isTypeOnly, skipJsDocLeadingAsterisks);
+            importClause = parseImportClause(identifier, pos, isTypeOnly, skipJsDocLeadingAsterisks, phase);
             parseExpected(SyntaxKind.FromKeyword);
         }
         return importClause;
@@ -8464,7 +8476,7 @@ namespace Parser {
         return finished;
     }
 
-    function parseImportClause(identifier: Identifier | undefined, pos: number, isTypeOnly: boolean, skipJsDocLeadingAsterisks: boolean) {
+    function parseImportClause(identifier: Identifier | undefined, pos: number, isTypeOnly: boolean, skipJsDocLeadingAsterisks: boolean, phase: ImportPhase) {
         // ImportClause:
         //  ImportedDefaultBinding
         //  NameSpaceImport
@@ -8480,11 +8492,19 @@ namespace Parser {
             parseOptional(SyntaxKind.CommaToken)
         ) {
             if (skipJsDocLeadingAsterisks) scanner.setSkipJsDocLeadingAsterisks(true);
-            namedBindings = token() === SyntaxKind.AsteriskToken ? parseNamespaceImport() : parseNamedImportsOrExports(SyntaxKind.NamedImports);
+            if (token() === SyntaxKind.AsteriskToken) {
+                namedBindings = parseNamespaceImport();
+            }
+            else {
+                if (phase === ImportPhase.Defer) {
+                    parseErrorAtCurrentToken(Diagnostics.Named_imports_aren_t_allowed_for_deferred_imports);
+                }
+                namedBindings = parseNamedImportsOrExports(SyntaxKind.NamedImports);
+            }
             if (skipJsDocLeadingAsterisks) scanner.setSkipJsDocLeadingAsterisks(false);
         }
 
-        return finishNode(factory.createImportClause(isTypeOnly, identifier, namedBindings), pos);
+        return finishNode(factory.createImportClause(isTypeOnly, identifier, namedBindings, phase), pos);
     }
 
     function parseModuleReference() {
@@ -9518,7 +9538,7 @@ namespace Parser {
                     identifier = parseIdentifier();
                 }
 
-                const importClause = tryParseImportClause(identifier, afterImportTagPos, /*isTypeOnly*/ true, /*skipJsDocLeadingAsterisks*/ true);
+                const importClause = tryParseImportClause(identifier, afterImportTagPos, /*isTypeOnly*/ true, /*skipJsDocLeadingAsterisks*/ true, ImportPhase.Evaluation);
                 const moduleSpecifier = parseModuleSpecifier();
                 const attributes = tryParseImportAttributes();
 

src/compiler/scanner.ts

@@ -203,6 +203,7 @@ export const textToKeywordObj: MapLike<KeywordSyntaxKind> = {
     true: SyntaxKind.TrueKeyword,
     try: SyntaxKind.TryKeyword,
     type: SyntaxKind.TypeKeyword,
+    defer: SyntaxKind.DeferKeyword,
     typeof: SyntaxKind.TypeOfKeyword,
     undefined: SyntaxKind.UndefinedKeyword,
     unique: SyntaxKind.UniqueKeyword,

src/compiler/transformers/declarations.ts

@@ -889,6 +889,7 @@ export function transformDeclarations(context: TransformationContext): Transform
                     decl.importClause.isTypeOnly,
                     visibleDefaultBinding,
                     /*namedBindings*/ undefined,
+                    decl.importClause.phase,
                 ),
                 rewriteModuleSpecifier(decl, decl.moduleSpecifier),
                 tryGetResolutionModeOverride(decl.attributes),
@@ -905,6 +906,7 @@ export function transformDeclarations(context: TransformationContext): Transform
                     decl.importClause.isTypeOnly,
                     visibleDefaultBinding,
                     namedBindings,
+                    decl.importClause.phase,
                 ),
                 rewriteModuleSpecifier(decl, decl.moduleSpecifier),
                 tryGetResolutionModeOverride(decl.attributes),
@@ -921,6 +923,7 @@ export function transformDeclarations(context: TransformationContext): Transform
                     decl.importClause.isTypeOnly,
                     visibleDefaultBinding,
                     bindingList && bindingList.length ? factory.updateNamedImports(decl.importClause.namedBindings, bindingList) : undefined,
+                    decl.importClause.phase,
                 ),
                 rewriteModuleSpecifier(decl, decl.moduleSpecifier),
                 tryGetResolutionModeOverride(decl.attributes),

src/compiler/transformers/jsx.ts

@@ -22,6 +22,7 @@ import {
     getSemanticJsxChildren,
     Identifier,
     idText,
+    ImportPhase,
     ImportSpecifier,
     insertStatementAfterCustomPrologue,
     isExpression,
@@ -172,7 +173,7 @@ export function transformJsx(context: TransformationContext): (x: SourceFile | B
             for (const [importSource, importSpecifiersMap] of arrayFrom(currentFileState.utilizedImplicitRuntimeImports.entries())) {
                 if (isExternalModule(node)) {
                     // Add `import` statement
-                    const importStatement = factory.createImportDeclaration(/*modifiers*/ undefined, factory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, factory.createNamedImports(arrayFrom(importSpecifiersMap.values()))), factory.createStringLiteral(importSource), /*attributes*/ undefined);
+                    const importStatement = factory.createImportDeclaration(/*modifiers*/ undefined, factory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, factory.createNamedImports(arrayFrom(importSpecifiersMap.values())), ImportPhase.Evaluation), factory.createStringLiteral(importSource), /*attributes*/ undefined);
                     setParentRecursive(importStatement, /*incremental*/ false);
                     statements = insertStatementAfterCustomPrologue(statements.slice(), importStatement);
                 }

src/compiler/transformers/module/esnextAnd2015.ts

@@ -28,6 +28,7 @@ import {
     idText,
     ImportDeclaration,
     ImportEqualsDeclaration,
+    ImportPhase,
     insertStatementsAfterCustomPrologue,
     isExportNamespaceAsDefaultDeclaration,
     isExternalModule,
@@ -224,6 +225,7 @@ export function transformECMAScriptModule(context: TransformationContext): (x: S
                     factory.createNamedImports([
                         factory.createImportSpecifier(/*isTypeOnly*/ false, factory.createIdentifier("createRequire"), createRequireName),
                     ]),
+                    ImportPhase.Evaluation,
                 ),
                 factory.createStringLiteral("module"),
                 /*attributes*/ undefined,
@@ -356,6 +358,7 @@ export function transformECMAScriptModule(context: TransformationContext): (x: S
                 factory.createNamespaceImport(
                     synthName,
                 ),
+                ImportPhase.Evaluation,
             ),
             updatedModuleSpecifier!,
             node.attributes,

src/compiler/transformers/ts.ts

@@ -2286,7 +2286,7 @@ export function transformTypeScript(context: TransformationContext): Transformer
         // Elide the import clause if we elide both its name and its named bindings.
         const name = shouldEmitAliasDeclaration(node) ? node.name : undefined;
         const namedBindings = visitNode(node.namedBindings, visitNamedImportBindings, isNamedImportBindings);
-        return (name || namedBindings) ? factory.updateImportClause(node, /*isTypeOnly*/ false, name, namedBindings) : undefined;
+        return (name || namedBindings) ? factory.updateImportClause(node, /*isTypeOnly*/ false, name, namedBindings, node.phase) : undefined;
     }
 
     /**