Avoid emitting temp variable in downleveled import()

Author: Josh-Cena

src/compiler/transformers/module/module.ts

@@ -850,32 +850,57 @@ export function transformModule(context: TransformationContext): (x: SourceFile
     function createImportCallExpressionCommonJS(arg: Expression | undefined, isInlineable?: boolean): Expression {
         // import(x)
         // emit as
-        // var _a;
-        // (_a = x, Promise.resolve().then(() => require(_a)) /*CommonJs Require*/
+        // Promise.resolve(`${x}`).then((s) => require(s)) /*CommonJs Require*/
         // We have to wrap require in then callback so that require is done in asynchronously
         // if we simply do require in resolve callback in Promise constructor. We will execute the loading immediately
-        // If the arg is not inlineable, we have to evaluate it in the current scope with a temp var
-        const temp = arg && !isSimpleInlineableExpression(arg) && !isInlineable ? factory.createTempVariable(hoistVariableDeclaration) : undefined;
+        // If the arg is not inlineable, we have to evaluate and ToString() it in the current scope
+        // Otherwise, we inline it in require() so that it's statically analyzable
+        const needSyncEval = arg && !isSimpleInlineableExpression(arg) && !isInlineable;
+
         const promiseResolveCall = factory.createCallExpression(
             factory.createPropertyAccessExpression(factory.createIdentifier("Promise"), "resolve"),
             /*typeArguments*/ undefined,
-            /*argumentsArray*/ [],
+            /*argumentsArray*/ needSyncEval
+                ? languageVersion >= ScriptTarget.ES2015
+                    ? [
+                          factory.createTemplateExpression(factory.createTemplateHead(""), [
+                              factory.createTemplateSpan(arg, factory.createTemplateTail("")),
+                          ]),
+                      ]
+                    : [
+                          factory.createCallExpression(
+                              factory.createPropertyAccessExpression(factory.createStringLiteral(""), "concat"),
+                              /*typeArguments*/ undefined,
+                              [arg]
+                          ),
+                      ]
+                : []
         );
+
         let requireCall: Expression = factory.createCallExpression(
             factory.createIdentifier("require"),
             /*typeArguments*/ undefined,
-            temp ? [temp] : arg ? [arg] : [],
+            needSyncEval ? [factory.createIdentifier("s")] : arg ? [arg] : [],
         );
         if (getESModuleInterop(compilerOptions)) {
             requireCall = emitHelpers().createImportStarHelper(requireCall);
         }
 
+        const parameters = needSyncEval
+            ? [
+                factory.createParameterDeclaration(
+                    /*modifiers*/ undefined,
+                    /*dotDotDotToken*/ undefined,
+                    /*name*/ "s"),
+            ]
+            : [];
+
         let func: FunctionExpression | ArrowFunction;
         if (languageVersion >= ScriptTarget.ES2015) {
             func = factory.createArrowFunction(
                 /*modifiers*/ undefined,
                 /*typeParameters*/ undefined,
-                /*parameters*/ [],
+                /*parameters*/ parameters,
                 /*type*/ undefined,
                 /*equalsGreaterThanToken*/ undefined,
                 requireCall);
@@ -886,14 +911,14 @@ export function transformModule(context: TransformationContext): (x: SourceFile
                 /*asteriskToken*/ undefined,
                 /*name*/ undefined,
                 /*typeParameters*/ undefined,
-                /*parameters*/ [],
+                /*parameters*/ parameters,
                 /*type*/ undefined,
                 factory.createBlock([factory.createReturnStatement(requireCall)]));
         }
 
         const downleveledImport = factory.createCallExpression(factory.createPropertyAccessExpression(promiseResolveCall, "then"), /*typeArguments*/ undefined, [func]);
 
-        return temp === undefined ? downleveledImport : factory.createCommaListExpression([factory.createAssignment(temp, arg!), downleveledImport]);
+        return downleveledImport;
     }
 
     function getHelperExpressionForExport(node: ExportDeclaration, innerExpr: Expression) {

tests/baselines/reference/asyncImportNestedYield.js

@@ -46,13 +46,12 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
 function foo() {
     return __asyncGenerator(this, arguments, function foo_1() {
         return __generator(this, function (_a) {
-            var _b, _c;
             switch (_a.label) {
                 case 0: return [4 /*yield*/, __await("foo")];
                 case 1: return [4 /*yield*/, _a.sent()];
-                case 2: return [4 /*yield*/, __await.apply(void 0, [(_b = _a.sent(), Promise.resolve().then(function () { return require(_b); }))])];
+                case 2: return [4 /*yield*/, __await.apply(void 0, [Promise.resolve("".concat(_a.sent())).then(function (s) { return require(s); })])];
                 case 3:
-                    _c = (_a.sent())["default"], Promise.resolve().then(function () { return require(_c); });
+                    Promise.resolve("".concat((_a.sent())["default"])).then(function (s) { return require(s); });
                     return [2 /*return*/];
             }
         });

tests/baselines/reference/dynamicImportEvaluateSpecifier.js

@@ -16,16 +16,14 @@ const someFunction = async () => {
 
 
 //// [dynamicImportEvaluateSpecifier.js]
-var _a, _b;
 // https://github.com/microsoft/TypeScript/issues/48285
 let i = 0;
-_a = String(i++), Promise.resolve().then(() => require(_a));
-_b = String(i++), Promise.resolve().then(() => require(_b));
+Promise.resolve(`${String(i++)}`).then(s => require(s));
+Promise.resolve(`${String(i++)}`).then(s => require(s));
 const getPath = async () => {
     /* in reality this would do some async FS operation, or a web request */
     return "/root/my/cool/path";
 };
 const someFunction = async () => {
-    var _a;
-    const result = await (_a = await getPath(), Promise.resolve().then(() => require(_a)));
+    const result = await Promise.resolve(`${await getPath()}`).then(s => require(s));
 };

tests/baselines/reference/dynamicImportTrailingComma.js

@@ -3,6 +3,5 @@ const path = './foo';
 import(path,);
 
 //// [dynamicImportTrailingComma.js]
-var _a;
 var path = './foo';
-_a = path, Promise.resolve().then(function () { return require(_a); });
+Promise.resolve("".concat(path)).then(function (s) { return require(s); });

tests/baselines/reference/jsdocInTypeScript.js

@@ -58,7 +58,6 @@ var v = import(String());
 
 
 //// [jsdocInTypeScript.js]
-var _a;
 var T = /** @class */ (function () {
     function T() {
     }
@@ -93,4 +92,4 @@ var E = {};
 E[""];
 // make sure import types in JSDoc are not resolved
 /** @type {import("should-not-be-resolved").Type} */
-var v = (_a = String(), Promise.resolve().then(function () { return require(_a); }));
+var v = Promise.resolve("".concat(String())).then(function (s) { return require(s); });