Merge branch 'main' of https://github.com/microsoft/TypeScript into feat/51086

Author: a-tarasyuk

package-lock.json

@@ -11353,7 +11353,18 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
 
     // The outer type parameters are those defined by enclosing generic classes, methods, or functions.
     function getOuterTypeParametersOfClassOrInterface(symbol: Symbol): TypeParameter[] | undefined {
-        const declaration = symbol.flags & SymbolFlags.Class ? symbol.valueDeclaration : getDeclarationOfKind(symbol, SyntaxKind.InterfaceDeclaration)!;
+        const declaration = (symbol.flags & SymbolFlags.Class || symbol.flags & SymbolFlags.Function)
+            ? symbol.valueDeclaration
+            : symbol.declarations?.find(decl => {
+                if (decl.kind === SyntaxKind.InterfaceDeclaration) {
+                    return true;
+                }
+                if (decl.kind !== SyntaxKind.VariableDeclaration) {
+                    return false;
+                }
+                const initializer = (decl as VariableDeclaration).initializer;
+                return !!initializer && (initializer.kind === SyntaxKind.FunctionExpression || initializer.kind === SyntaxKind.ArrowFunction);
+            })!;
         Debug.assert(!!declaration, "Class was missing valueDeclaration -OR- non-class had no interface declarations");
         return getOuterTypeParameters(declaration);
     }
@@ -24592,8 +24603,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     // parameter and has inferences that would conflict. Otherwise, we use the contra-variant inference.
                     const useCovariantType = inferredCovariantType && !(inferredCovariantType.flags & TypeFlags.Never) &&
                         some(inference.contraCandidates, t => isTypeSubtypeOf(inferredCovariantType, t)) &&
-                        every(context.inferences, other => other === inference ||
-                            getConstraintOfTypeParameter(other.typeParameter) !== inference.typeParameter ||
+                        every(context.inferences, other =>
+                            other !== inference && getConstraintOfTypeParameter(other.typeParameter) !== inference.typeParameter ||
                             every(other.candidates, t => isTypeSubtypeOf(t, inferredCovariantType)));
                     inferredType = useCovariantType ? inferredCovariantType : getContravariantInference(inference);
                 }

src/compiler/checker.ts

@@ -3864,6 +3864,10 @@
         "category": "Error",
         "code": 4084
     },
+    "Extends clause for inferred type '{0}' has or is using private name '{1}'.": {
+        "category": "Error",
+        "code": 4085
+    },
     "Conflicting definitions for '{0}' found at '{1}' and '{2}'. Consider installing a specific version of this library to resolve the conflict.": {
         "category": "Error",
         "code": 4090

src/compiler/diagnosticMessages.json

@@ -259,6 +259,7 @@ export interface ModuleResolutionState {
     requestContainingDirectory: string | undefined;
     reportDiagnostic: DiagnosticReporter;
     isConfigLookup: boolean;
+    candidateIsFromPackageJsonField: boolean;
 }
 
 /** Just the fields that we use for module resolution.
@@ -526,6 +527,7 @@ export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string
         requestContainingDirectory: containingDirectory,
         reportDiagnostic: diag => void diagnostics.push(diag),
         isConfigLookup: false,
+        candidateIsFromPackageJsonField: false,
     };
     let resolved = primaryLookup();
     let primary = true;
@@ -1652,6 +1654,7 @@ function nodeModuleNameResolverWorker(features: NodeResolutionFeatures, moduleNa
         requestContainingDirectory: containingDirectory,
         reportDiagnostic: diag => void diagnostics.push(diag),
         isConfigLookup,
+        candidateIsFromPackageJsonField: false,
     };
 
     if (traceEnabled && getEmitModuleResolutionKind(compilerOptions) >= ModuleResolutionKind.Node16 && getEmitModuleResolutionKind(compilerOptions) <= ModuleResolutionKind.NodeNext) {
@@ -1948,7 +1951,7 @@ function tryAddingExtensions(candidate: string, extensions: Extensions, original
 
     function tryExtension(ext: string, resolvedUsingTsExtension?: boolean): PathAndExtension | undefined {
         const path = tryFile(candidate + ext, onlyRecordFailures, state);
-        return path === undefined ? undefined : { path, ext, resolvedUsingTsExtension };
+        return path === undefined ? undefined : { path, ext, resolvedUsingTsExtension: !state.candidateIsFromPackageJsonField && resolvedUsingTsExtension };
     }
 }
 
@@ -2111,6 +2114,7 @@ export function getTemporaryModuleResolutionState(packageJsonInfoCache: PackageJ
         requestContainingDirectory: undefined,
         reportDiagnostic: noop,
         isConfigLookup: false,
+        candidateIsFromPackageJsonField: false,
     };
 }
 
@@ -2232,11 +2236,14 @@ function loadNodeModuleFromDirectoryWorker(extensions: Extensions, candidate: st
         // (technically it only emits a deprecation warning in esm packages right now, but that's probably
         // enough to mean we don't need to support it)
         const features = state.features;
+        const candidateIsFromPackageJsonField = state.candidateIsFromPackageJsonField;
+        state.candidateIsFromPackageJsonField = true;
         if (jsonContent?.type !== "module") {
             state.features &= ~NodeResolutionFeatures.EsmMode;
         }
         const result = nodeLoadModuleByRelativeName(expandedExtensions, candidate, onlyRecordFailures, state, /*considerPackageJson*/ false);
         state.features = features;
+        state.candidateIsFromPackageJsonField = candidateIsFromPackageJsonField;
         return result;
     };
 
@@ -2313,7 +2320,18 @@ function loadModuleFromSelfNameReference(extensions: Extensions, moduleName: str
         return undefined;
     }
     const trailingParts = parts.slice(nameParts.length);
-    return loadModuleFromExports(scope, extensions, !length(trailingParts) ? "." : `.${directorySeparator}${trailingParts.join(directorySeparator)}`, state, cache, redirectedReference);
+    const subpath = !length(trailingParts) ? "." : `.${directorySeparator}${trailingParts.join(directorySeparator)}`;
+    // Maybe TODO: splitting extensions into two priorities should be unnecessary, except
+    // https://github.com/microsoft/TypeScript/issues/50762 makes the behavior different.
+    // As long as that bug exists, we need to do two passes here in self-name loading
+    // in order to be consistent with (non-self) library-name loading in
+    // `loadModuleFromNearestNodeModulesDirectoryWorker`, which uses two passes in order
+    // to prioritize `@types` packages higher up the directory tree over untyped
+    // implementation packages.
+    const priorityExtensions = extensions & (Extensions.TypeScript | Extensions.Declaration);
+    const secondaryExtensions = extensions & ~(Extensions.TypeScript | Extensions.Declaration);
+    return loadModuleFromExports(scope, priorityExtensions, subpath, state, cache, redirectedReference)
+        || loadModuleFromExports(scope, secondaryExtensions, subpath, state, cache, redirectedReference);
 }
 
 function loadModuleFromExports(scope: PackageJsonInfo, extensions: Extensions, subpath: string, state: ModuleResolutionState, cache: ModuleResolutionCache | undefined, redirectedReference: ResolvedProjectReference | undefined): SearchResult<Resolved> {
@@ -2753,27 +2771,31 @@ function loadModuleFromImmediateNodeModulesDirectory(extensions: Extensions, mod
 
 function loadModuleFromSpecificNodeModulesDirectory(extensions: Extensions, moduleName: string, nodeModulesDirectory: string, nodeModulesDirectoryExists: boolean, state: ModuleResolutionState, cache: ModuleResolutionCache | undefined, redirectedReference: ResolvedProjectReference | undefined): Resolved | undefined {
     const candidate = normalizePath(combinePaths(nodeModulesDirectory, moduleName));
+    const { packageName, rest } = parsePackageName(moduleName);
+    const packageDirectory = combinePaths(nodeModulesDirectory, packageName);
 
+    let rootPackageInfo: PackageJsonInfo | undefined;
     // First look for a nested package.json, as in `node_modules/foo/bar/package.json`.
     let packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state);
     // But only if we're not respecting export maps (if we are, we might redirect around this location)
-    if (!(state.features & NodeResolutionFeatures.Exports)) {
-        if (packageInfo) {
-            const fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state);
-            if (fromFile) {
-                return noPackageId(fromFile);
-            }
-
-            const fromDirectory = loadNodeModuleFromDirectoryWorker(
-                extensions,
-                candidate,
-                !nodeModulesDirectoryExists,
-                state,
-                packageInfo.contents.packageJsonContent,
-                getVersionPathsOfPackageJsonInfo(packageInfo, state),
-            );
-            return withPackageId(packageInfo, fromDirectory);
+    if (rest !== "" && packageInfo && (
+        !(state.features & NodeResolutionFeatures.Exports) ||
+        !hasProperty((rootPackageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state))?.contents.packageJsonContent ?? emptyArray, "exports")
+    )) {
+        const fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state);
+        if (fromFile) {
+            return noPackageId(fromFile);
         }
+
+        const fromDirectory = loadNodeModuleFromDirectoryWorker(
+            extensions,
+            candidate,
+            !nodeModulesDirectoryExists,
+            state,
+            packageInfo.contents.packageJsonContent,
+            getVersionPathsOfPackageJsonInfo(packageInfo, state),
+        );
+        return withPackageId(packageInfo, fromDirectory);
     }
 
     const loader: ResolutionKindSpecificLoader = (extensions, candidate, onlyRecordFailures, state) => {
@@ -2800,11 +2822,9 @@ function loadModuleFromSpecificNodeModulesDirectory(extensions: Extensions, modu
         return withPackageId(packageInfo, pathAndExtension);
     };
 
-    const { packageName, rest } = parsePackageName(moduleName);
-    const packageDirectory = combinePaths(nodeModulesDirectory, packageName);
     if (rest !== "") {
         // Previous `packageInfo` may have been from a nested package.json; ensure we have the one from the package root now.
-        packageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state);
+        packageInfo = rootPackageInfo ?? getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state);
     }
     // package exports are higher priority than file/directory/typesVersions lookups and (and, if there's exports present, blocks them)
     if (packageInfo && packageInfo.contents.packageJsonContent.exports && state.features & NodeResolutionFeatures.Exports) {
@@ -2935,6 +2955,7 @@ export function classicNameResolver(moduleName: string, containingFile: string,
         requestContainingDirectory: containingDirectory,
         reportDiagnostic: diag => void diagnostics.push(diag),
         isConfigLookup: false,
+        candidateIsFromPackageJsonField: false,
     };
 
     const resolved =
@@ -3015,6 +3036,7 @@ export function loadModuleFromGlobalCache(moduleName: string, projectName: strin
         requestContainingDirectory: undefined,
         reportDiagnostic: diag => void diagnostics.push(diag),
         isConfigLookup: false,
+        candidateIsFromPackageJsonField: false,
     };
     const resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.Declaration, moduleName, globalCache, state, /*typesScopeOnly*/ false, /*cache*/ undefined, /*redirectedReference*/ undefined);
     return createResolvedModuleWithFailedLookupLocations(

src/compiler/moduleNameResolver.ts

@@ -500,6 +500,10 @@ export function createGetSymbolAccessibilityDiagnosticForNode(node: DeclarationD
                 diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1;
                 break;
 
+            case SyntaxKind.InferType:
+                diagnosticMessage = Diagnostics.Extends_clause_for_inferred_type_0_has_or_is_using_private_name_1;
+                break;
+
             case SyntaxKind.TypeAliasDeclaration:
                 diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1;
                 break;

src/compiler/transformers/declarations/diagnostics.ts

@@ -1,8 +1,10 @@
 tests/cases/compiler/circularBaseTypes.ts(4,11): error TS2310: Type 'M2' recursively references itself as a base type.
 tests/cases/compiler/circularBaseTypes.ts(5,6): error TS2456: Type alias 'M3' circularly references itself.
+tests/cases/compiler/circularBaseTypes.ts(13,21): error TS2313: Type parameter 'K' has a circular constraint.
+tests/cases/compiler/circularBaseTypes.ts(14,11): error TS2310: Type 'Y' recursively references itself as a base type.
 
 
-==== tests/cases/compiler/circularBaseTypes.ts (2 errors) ====
+==== tests/cases/compiler/circularBaseTypes.ts (4 errors) ====
     // Repro from #38098
 
     type M<T> = { value: T };
@@ -16,4 +18,16 @@ tests/cases/compiler/circularBaseTypes.ts(5,6): error TS2456: Type alias 'M3' ci
     function f(m: M3) {
       return m.value;
     }
+    
+    // Repro from #32581
+    
+    type X<T> = { [K in keyof T]: string } & { b: string };
+                        ~~~~~~~
+!!! error TS2313: Type parameter 'K' has a circular constraint.
+!!! related TS2751 tests/cases/compiler/circularBaseTypes.ts:14:11: Circularity originates in type at this location.
+    interface Y extends X<Y> {
+              ~
+!!! error TS2310: Type 'Y' recursively references itself as a base type.
+      a: "";
+    }
 

tests/baselines/reference/circularBaseTypes.errors.txt

@@ -8,6 +8,13 @@ type M3 = M2[keyof M2];  // Error
 function f(m: M3) {
   return m.value;
 }
+
+// Repro from #32581
+
+type X<T> = { [K in keyof T]: string } & { b: string };
+interface Y extends X<Y> {
+  a: "";
+}
 
 
 //// [circularBaseTypes.js]
@@ -27,3 +34,11 @@ interface M2 extends M<M3> {
 }
 type M3 = M2[keyof M2];
 declare function f(m: M3): any;
+type X<T> = {
+    [K in keyof T]: string;
+} & {
+    b: string;
+};
+interface Y extends X<Y> {
+    a: "";
+}

tests/baselines/reference/circularBaseTypes.js

@@ -26,3 +26,21 @@ function f(m: M3) {
 >m : Symbol(m, Decl(circularBaseTypes.ts, 6, 11))
 }
 
+// Repro from #32581
+
+type X<T> = { [K in keyof T]: string } & { b: string };
+>X : Symbol(X, Decl(circularBaseTypes.ts, 8, 1))
+>T : Symbol(T, Decl(circularBaseTypes.ts, 12, 7))
+>K : Symbol(K, Decl(circularBaseTypes.ts, 12, 15))
+>T : Symbol(T, Decl(circularBaseTypes.ts, 12, 7))
+>b : Symbol(b, Decl(circularBaseTypes.ts, 12, 42))
+
+interface Y extends X<Y> {
+>Y : Symbol(Y, Decl(circularBaseTypes.ts, 12, 55))
+>X : Symbol(X, Decl(circularBaseTypes.ts, 8, 1))
+>Y : Symbol(Y, Decl(circularBaseTypes.ts, 12, 55))
+
+  a: "";
+>a : Symbol(Y.a, Decl(circularBaseTypes.ts, 13, 26))
+}
+

tests/baselines/reference/circularBaseTypes.symbols

@@ -19,3 +19,14 @@ function f(m: M3) {
 >value : any
 }
 
+// Repro from #32581
+
+type X<T> = { [K in keyof T]: string } & { b: string };
+>X : X<T>
+>b : string
+
+interface Y extends X<Y> {
+  a: "";
+>a : ""
+}
+