Merge branch 'main' into module-resolution/ts-extensions

Author: andrewbranch

package-lock.json

@@ -35025,7 +35025,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function hasEmptyObjectIntersection(type: Type): boolean {
-        return someType(type, t => t === unknownEmptyObjectType || !!(t.flags & TypeFlags.Intersection) && some((t as IntersectionType).types, isEmptyAnonymousObjectType));
+        return someType(type, t => t === unknownEmptyObjectType || !!(t.flags & TypeFlags.Intersection) && isEmptyAnonymousObjectType(getBaseConstraintOrType(t)));
     }
 
     function checkInExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type {

src/compiler/checker.ts

@@ -958,32 +958,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);
@@ -994,14 +1019,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) {

src/compiler/transformers/module/module.ts

@@ -26,6 +26,7 @@ import {
     removeFileExtension,
     removeMinAndVersionNumbers,
     some,
+    toFileNameLowerCase,
     TypeAcquisition,
     Version,
     versionMajorMinor,
@@ -313,8 +314,8 @@ export function discoverTypings(
                     // packages. So that needs this dance here.
                     const pathComponents = getPathComponents(normalizePath(manifestPath));
                     const isScoped = pathComponents[pathComponents.length - 3][0] === "@";
-                    return isScoped && pathComponents[pathComponents.length - 4].toLowerCase() === modulesDirName || // `node_modules/@foo/bar`
-                        !isScoped && pathComponents[pathComponents.length - 3].toLowerCase() === modulesDirName; // `node_modules/foo`
+                    return isScoped && toFileNameLowerCase(pathComponents[pathComponents.length - 4]) === modulesDirName || // `node_modules/@foo/bar`
+                        !isScoped && toFileNameLowerCase(pathComponents[pathComponents.length - 3]) === modulesDirName; // `node_modules/foo`
                 });
 
         if (log) log(`Searching for typing names in ${packagesFolderPath}; all files: ${JSON.stringify(dependencyManifestNames)}`);
@@ -361,7 +362,7 @@ export function discoverTypings(
         const fromFileNames = mapDefined(fileNames, j => {
             if (!hasJSFileExtension(j)) return undefined;
 
-            const inferredTypingName = removeFileExtension(getBaseFileName(j.toLowerCase()));
+            const inferredTypingName = removeFileExtension(toFileNameLowerCase(getBaseFileName(j)));
             const cleanedTypingName = removeMinAndVersionNumbers(inferredTypingName);
             return safeList.get(cleanedTypingName);
         });

src/jsTyping/jsTyping.ts

@@ -459,7 +459,7 @@ export class LanguageServiceShimHostAdapter implements LanguageServiceHost {
         if ("getTypeReferenceDirectiveResolutionsForFile" in this.shimHost) {
             this.resolveTypeReferenceDirectives = (typeDirectiveNames, containingFile) => {
                 const typeDirectivesForFile = JSON.parse(this.shimHost.getTypeReferenceDirectiveResolutionsForFile!(containingFile)) as MapLike<ResolvedTypeReferenceDirective>; // TODO: GH#18217
-                return map(typeDirectiveNames as (string | FileReference)[], name => getProperty(typeDirectivesForFile, isString(name) ? name : name.fileName.toLowerCase()));
+                return map(typeDirectiveNames as (string | FileReference)[], name => getProperty(typeDirectivesForFile, isString(name) ? name : toFileNameLowerCase(name.fileName)));
             };
         }
     }

src/services/shims.ts

@@ -25,6 +25,7 @@ export interface ProgramWithSourceTexts extends ts.Program {
 
 export interface TestCompilerHost extends ts.CompilerHost {
     getTrace(): string[];
+    clearTrace(): void;
 }
 
 export class SourceText implements ts.IScriptSnapshot {
@@ -124,6 +125,7 @@ export function createTestCompilerHost(texts: readonly NamedSourceText[], target
     const result: TestCompilerHost = {
         trace: s => trace.push(s),
         getTrace: () => trace,
+        clearTrace: () => trace.length = 0,
         getSourceFile: fileName => files.get(fileName),
         getDefaultLibFileName: () => "lib.d.ts",
         writeFile: ts.notImplemented,