maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge pull request #26558 from Microsoft/fixInfiniteConstraints

Browse source 
Fix infinite constraints
This commit is contained in:
Anders Hejlsberg 2018-08-21 17:24:42 -07:00 committed by GitHub
parent 7ec98afb8f 2f85af83a7
commit 93c76cb617
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 453 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

136
src/compiler/checker.ts
View file

@ -53,7 +53,8 @@ namespace ts {
let typeCount = 0;
let symbolCount = 0;
let enumCount = 0;
let symbolInstantiationDepth = 0;
let instantiationDepth = 0;
let constraintDepth = 0;
const emptySymbols = createSymbolTable();
const identityMapper: (type: Type) => Type = identity;
@ -5303,22 +5304,14 @@ namespace ts {
function getTypeOfInstantiatedSymbol(symbol: Symbol): Type {
const links = getSymbolLinks(symbol);
if (!links.type) {
if (symbolInstantiationDepth === 100) {
error(symbol.valueDeclaration, Diagnostics.Generic_type_instantiation_is_excessively_deep_and_possibly_infinite);
links.type = errorType;
if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
return links.type = errorType;
}
else {
if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
return links.type = errorType;
}
symbolInstantiationDepth++;
let type = instantiateType(getTypeOfSymbol(links.target!), links.mapper!);
symbolInstantiationDepth--;
if (!popTypeResolution()) {
type = reportCircularityError(symbol);
}
links.type = type;
let type = instantiateType(getTypeOfSymbol(links.target!), links.mapper!);
if (!popTypeResolution()) {
type = reportCircularityError(symbol);
}
links.type = type;
}
return links.type;
}
@ -6928,7 +6921,8 @@ namespace ts {
// over the conditional type and possibly reduced. For example, 'T extends undefined ? never : T'
// removes 'undefined' from T.
if (type.root.isDistributive) {
const constraint = getConstraintOfType(getSimplifiedType(type.checkType));
const simplified = getSimplifiedType(type.checkType);
const constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified;
if (constraint) {
const mapper = makeUnaryTypeMapper(type.root.checkType, constraint);
const instantiated = getConditionalTypeInstantiation(type, combineTypeMappers(mapper, type.mapper));
@ -7011,6 +7005,7 @@ namespace ts {
* circularly references the type variable.
*/
function getResolvedBaseConstraint(type: InstantiableType | UnionOrIntersectionType): Type {
let nonTerminating = false;
return type.resolvedBaseConstraint ||
(type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), type));
@ -7019,8 +7014,18 @@ namespace ts {
if (!pushTypeResolution(t, TypeSystemPropertyName.ImmediateBaseConstraint)) {
return circularConstraintType;
}
if (constraintDepth === 50) {
// We have reached 50 recursive invocations of getImmediateBaseConstraint and there is a
// very high likelyhood we're dealing with an infinite generic type that perpetually generates
// new type identities as we descend into it. We stop the recursion here and mark this type
// and the outer types as having circular constraints.
nonTerminating = true;
return t.immediateBaseConstraint = noConstraintType;
}
constraintDepth++;
let result = computeBaseConstraint(getSimplifiedType(t));
if (!popTypeResolution()) {
constraintDepth--;
if (!popTypeResolution() || nonTerminating) {
result = circularConstraintType;
}
t.immediateBaseConstraint = result || noConstraintType;
@ -10293,49 +10298,66 @@ namespace ts {
function instantiateType(type: Type, mapper: TypeMapper | undefined): Type;
function instantiateType(type: Type | undefined, mapper: TypeMapper | undefined): Type | undefined;
function instantiateType(type: Type | undefined, mapper: TypeMapper | undefined): Type | undefined {
if (type && mapper && mapper !== identityMapper) {
if (type.flags & TypeFlags.TypeParameter) {
return mapper(<TypeParameter>type);
if (!type || !mapper || mapper === identityMapper) {
return type;
}
if (instantiationDepth === 50) {
// We have reached 50 recursive type instantiations and there is a very high likelyhood we're dealing
// with a combination of infinite generic types that perpetually generate new type identities. We stop
// the recursion here by yielding the error type.
return errorType;
}
instantiationDepth++;
const result = instantiateTypeWorker(type, mapper);
instantiationDepth--;
return result;
}
function instantiateTypeWorker(type: Type, mapper: TypeMapper): Type {
const flags = type.flags;
if (flags & TypeFlags.TypeParameter) {
return mapper(type);
}
if (flags & TypeFlags.Object) {
const objectFlags = (<ObjectType>type).objectFlags;
if (objectFlags & ObjectFlags.Anonymous) {
// If the anonymous type originates in a declaration of a function, method, class, or
// interface, in an object type literal, or in an object literal expression, we may need
// to instantiate the type because it might reference a type parameter.
return type.symbol && type.symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) && type.symbol.declarations ?
getAnonymousTypeInstantiation(<AnonymousType>type, mapper) : type;
}
if (type.flags & TypeFlags.Object) {
if ((<ObjectType>type).objectFlags & ObjectFlags.Anonymous) {
// If the anonymous type originates in a declaration of a function, method, class, or
// interface, in an object type literal, or in an object literal expression, we may need
// to instantiate the type because it might reference a type parameter.
return type.symbol && type.symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) && type.symbol.declarations ?
getAnonymousTypeInstantiation(<AnonymousType>type, mapper) : type;
}
if ((<ObjectType>type).objectFlags & ObjectFlags.Mapped) {
return getAnonymousTypeInstantiation(<MappedType>type, mapper);
}
if ((<ObjectType>type).objectFlags & ObjectFlags.Reference) {
const typeArguments = (<TypeReference>type).typeArguments;
const newTypeArguments = instantiateTypes(typeArguments, mapper);
return newTypeArguments !== typeArguments ? createTypeReference((<TypeReference>type).target, newTypeArguments) : type;
}
if (objectFlags & ObjectFlags.Mapped) {
return getAnonymousTypeInstantiation(<AnonymousType>type, mapper);
}
if (type.flags & TypeFlags.Union && !(type.flags & TypeFlags.Primitive)) {
const types = (<UnionType>type).types;
const newTypes = instantiateTypes(types, mapper);
return newTypes !== types ? getUnionType(newTypes, UnionReduction.Literal, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)) : type;
}
if (type.flags & TypeFlags.Intersection) {
const types = (<IntersectionType>type).types;
const newTypes = instantiateTypes(types, mapper);
return newTypes !== types ? getIntersectionType(newTypes, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)) : type;
}
if (type.flags & TypeFlags.Index) {
return getIndexType(instantiateType((<IndexType>type).type, mapper));
}
if (type.flags & TypeFlags.IndexedAccess) {
return getIndexedAccessType(instantiateType((<IndexedAccessType>type).objectType, mapper), instantiateType((<IndexedAccessType>type).indexType, mapper));
}
if (type.flags & TypeFlags.Conditional) {
return getConditionalTypeInstantiation(<ConditionalType>type, combineTypeMappers((<ConditionalType>type).mapper, mapper));
}
if (type.flags & TypeFlags.Substitution) {
return instantiateType((<SubstitutionType>type).typeVariable, mapper);
if (objectFlags & ObjectFlags.Reference) {
const typeArguments = (<TypeReference>type).typeArguments;
const newTypeArguments = instantiateTypes(typeArguments, mapper);
return newTypeArguments !== typeArguments ? createTypeReference((<TypeReference>type).target, newTypeArguments) : type;
}
return type;
}
if (flags & TypeFlags.Union && !(flags & TypeFlags.Primitive)) {
const types = (<UnionType>type).types;
const newTypes = instantiateTypes(types, mapper);
return newTypes !== types ? getUnionType(newTypes, UnionReduction.Literal, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)) : type;
}
if (flags & TypeFlags.Intersection) {
const types = (<IntersectionType>type).types;
const newTypes = instantiateTypes(types, mapper);
return newTypes !== types ? getIntersectionType(newTypes, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)) : type;
}
if (flags & TypeFlags.Index) {
return getIndexType(instantiateType((<IndexType>type).type, mapper));
}
if (flags & TypeFlags.IndexedAccess) {
return getIndexedAccessType(instantiateType((<IndexedAccessType>type).objectType, mapper), instantiateType((<IndexedAccessType>type).indexType, mapper));
}
if (flags & TypeFlags.Conditional) {
return getConditionalTypeInstantiation(<ConditionalType>type, combineTypeMappers((<ConditionalType>type).mapper, mapper));
}
if (flags & TypeFlags.Substitution) {
return instantiateType((<SubstitutionType>type).typeVariable, mapper);
}
return type;
}

4
src/compiler/diagnosticMessages.json
View file

@ -1964,10 +1964,6 @@
"category": "Error",
"code": 2549
},
"Generic type instantiation is excessively deep and possibly infinite.": {
"category": "Error",
"code": 2550
},
"Property '{0}' does not exist on type '{1}'. Did you mean '{2}'?": {
"category": "Error",
"code": 2551

53
tests/baselines/reference/infiniteConstraints.errors.txt Normal file
View file

@ -0,0 +1,53 @@
tests/cases/compiler/infiniteConstraints.ts(4,37): error TS2536: Type '"val"' cannot be used to index type 'B[Exclude<keyof B, K>]'.
tests/cases/compiler/infiniteConstraints.ts(31,42): error TS2345: Argument of type '{ main: Record<"val", "dup">; alternate: Record<"val", "dup">; }' is not assignable to parameter of type '{ main: never; alternate: never; }'.
Types of property 'main' are incompatible.
Type 'Record<"val", "dup">' is not assignable to type 'never'.
tests/cases/compiler/infiniteConstraints.ts(36,71): error TS2536: Type '"foo"' cannot be used to index type 'T[keyof T]'.
==== tests/cases/compiler/infiniteConstraints.ts (3 errors) ====
// Both of the following types trigger the recursion limiter in getImmediateBaseConstraint
type T1<B extends { [K in keyof B]: Extract<B[Exclude<keyof B, K>], { val: string }>["val"] }> = B;
type T2<B extends { [K in keyof B]: B[Exclude<keyof B, K>]["val"] }> = B;
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2536: Type '"val"' cannot be used to index type 'B[Exclude<keyof B, K>]'.
// Repros from #22950
type AProp<T extends { a: string }> = T
declare function myBug<
T extends { [K in keyof T]: T[K] extends AProp<infer U> ? U : never }
>(arg: T): T
const out = myBug({obj1: {a: "test"}})
type Value<V extends string = string> = Record<"val", V>;
declare function value<V extends string>(val: V): Value<V>;
declare function ensureNoDuplicates<
T extends {
[K in keyof T]: Extract<T[K], Value>["val"] extends Extract<T[Exclude<keyof T, K>], Value>["val"]
? never
: any
}
>(vals: T): void;
const noError = ensureNoDuplicates({main: value("test"), alternate: value("test2")});
const shouldBeNoError = ensureNoDuplicates({main: value("test")});
const shouldBeError = ensureNoDuplicates({main: value("dup"), alternate: value("dup")});
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2345: Argument of type '{ main: Record<"val", "dup">; alternate: Record<"val", "dup">; }' is not assignable to parameter of type '{ main: never; alternate: never; }'.
!!! error TS2345: Types of property 'main' are incompatible.
!!! error TS2345: Type 'Record<"val", "dup">' is not assignable to type 'never'.
// Repro from #26448
type Cond<T> = T extends number ? number : never;
declare function function1<T extends {[K in keyof T]: Cond<T[K]>}>(): T[keyof T]["foo"];
~~~~~~~~~~~~~~~~~
!!! error TS2536: Type '"foo"' cannot be used to index type 'T[keyof T]'.

46
tests/baselines/reference/infiniteConstraints.js Normal file
View file

@ -0,0 +1,46 @@
//// [infiniteConstraints.ts]
// Both of the following types trigger the recursion limiter in getImmediateBaseConstraint
type T1<B extends { [K in keyof B]: Extract<B[Exclude<keyof B, K>], { val: string }>["val"] }> = B;
type T2<B extends { [K in keyof B]: B[Exclude<keyof B, K>]["val"] }> = B;
// Repros from #22950
type AProp<T extends { a: string }> = T
declare function myBug<
T extends { [K in keyof T]: T[K] extends AProp<infer U> ? U : never }
>(arg: T): T
const out = myBug({obj1: {a: "test"}})
type Value<V extends string = string> = Record<"val", V>;
declare function value<V extends string>(val: V): Value<V>;
declare function ensureNoDuplicates<
T extends {
[K in keyof T]: Extract<T[K], Value>["val"] extends Extract<T[Exclude<keyof T, K>], Value>["val"]
? never
: any
}
>(vals: T): void;
const noError = ensureNoDuplicates({main: value("test"), alternate: value("test2")});
const shouldBeNoError = ensureNoDuplicates({main: value("test")});
const shouldBeError = ensureNoDuplicates({main: value("dup"), alternate: value("dup")});
// Repro from #26448
type Cond<T> = T extends number ? number : never;
declare function function1<T extends {[K in keyof T]: Cond<T[K]>}>(): T[keyof T]["foo"];
//// [infiniteConstraints.js]
"use strict";
// Both of the following types trigger the recursion limiter in getImmediateBaseConstraint
var out = myBug({ obj1: { a: "test" } });
var noError = ensureNoDuplicates({ main: value("test"), alternate: value("test2") });
var shouldBeNoError = ensureNoDuplicates({ main: value("test") });
var shouldBeError = ensureNoDuplicates({ main: value("dup"), alternate: value("dup") });

140
tests/baselines/reference/infiniteConstraints.symbols Normal file
View file

@ -0,0 +1,140 @@
=== tests/cases/compiler/infiniteConstraints.ts ===
// Both of the following types trigger the recursion limiter in getImmediateBaseConstraint
type T1<B extends { [K in keyof B]: Extract<B[Exclude<keyof B, K>], { val: string }>["val"] }> = B;
>T1 : Symbol(T1, Decl(infiniteConstraints.ts, 0, 0))
>B : Symbol(B, Decl(infiniteConstraints.ts, 2, 8))
>K : Symbol(K, Decl(infiniteConstraints.ts, 2, 21))
>B : Symbol(B, Decl(infiniteConstraints.ts, 2, 8))
>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --))
>B : Symbol(B, Decl(infiniteConstraints.ts, 2, 8))
>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --))
>B : Symbol(B, Decl(infiniteConstraints.ts, 2, 8))
>K : Symbol(K, Decl(infiniteConstraints.ts, 2, 21))
>val : Symbol(val, Decl(infiniteConstraints.ts, 2, 69))
>B : Symbol(B, Decl(infiniteConstraints.ts, 2, 8))
type T2<B extends { [K in keyof B]: B[Exclude<keyof B, K>]["val"] }> = B;
>T2 : Symbol(T2, Decl(infiniteConstraints.ts, 2, 99))
>B : Symbol(B, Decl(infiniteConstraints.ts, 3, 8))
>K : Symbol(K, Decl(infiniteConstraints.ts, 3, 21))
>B : Symbol(B, Decl(infiniteConstraints.ts, 3, 8))
>B : Symbol(B, Decl(infiniteConstraints.ts, 3, 8))
>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --))
>B : Symbol(B, Decl(infiniteConstraints.ts, 3, 8))
>K : Symbol(K, Decl(infiniteConstraints.ts, 3, 21))
>B : Symbol(B, Decl(infiniteConstraints.ts, 3, 8))
// Repros from #22950
type AProp<T extends { a: string }> = T
>AProp : Symbol(AProp, Decl(infiniteConstraints.ts, 3, 73))
>T : Symbol(T, Decl(infiniteConstraints.ts, 7, 11))
>a : Symbol(a, Decl(infiniteConstraints.ts, 7, 22))
>T : Symbol(T, Decl(infiniteConstraints.ts, 7, 11))
declare function myBug<
>myBug : Symbol(myBug, Decl(infiniteConstraints.ts, 7, 39))
T extends { [K in keyof T]: T[K] extends AProp<infer U> ? U : never }
>T : Symbol(T, Decl(infiniteConstraints.ts, 9, 23))
>K : Symbol(K, Decl(infiniteConstraints.ts, 10, 15))
>T : Symbol(T, Decl(infiniteConstraints.ts, 9, 23))
>T : Symbol(T, Decl(infiniteConstraints.ts, 9, 23))
>K : Symbol(K, Decl(infiniteConstraints.ts, 10, 15))
>AProp : Symbol(AProp, Decl(infiniteConstraints.ts, 3, 73))
>U : Symbol(U, Decl(infiniteConstraints.ts, 10, 54))
>U : Symbol(U, Decl(infiniteConstraints.ts, 10, 54))
>(arg: T): T
>arg : Symbol(arg, Decl(infiniteConstraints.ts, 11, 2))
>T : Symbol(T, Decl(infiniteConstraints.ts, 9, 23))
>T : Symbol(T, Decl(infiniteConstraints.ts, 9, 23))
const out = myBug({obj1: {a: "test"}})
>out : Symbol(out, Decl(infiniteConstraints.ts, 13, 5))
>myBug : Symbol(myBug, Decl(infiniteConstraints.ts, 7, 39))
>obj1 : Symbol(obj1, Decl(infiniteConstraints.ts, 13, 19))
>a : Symbol(a, Decl(infiniteConstraints.ts, 13, 26))
type Value<V extends string = string> = Record<"val", V>;
>Value : Symbol(Value, Decl(infiniteConstraints.ts, 13, 38))
>V : Symbol(V, Decl(infiniteConstraints.ts, 15, 11))
>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
>V : Symbol(V, Decl(infiniteConstraints.ts, 15, 11))
declare function value<V extends string>(val: V): Value<V>;
>value : Symbol(value, Decl(infiniteConstraints.ts, 15, 57))
>V : Symbol(V, Decl(infiniteConstraints.ts, 16, 23))
>val : Symbol(val, Decl(infiniteConstraints.ts, 16, 41))
>V : Symbol(V, Decl(infiniteConstraints.ts, 16, 23))
>Value : Symbol(Value, Decl(infiniteConstraints.ts, 13, 38))
>V : Symbol(V, Decl(infiniteConstraints.ts, 16, 23))
declare function ensureNoDuplicates<
>ensureNoDuplicates : Symbol(ensureNoDuplicates, Decl(infiniteConstraints.ts, 16, 59))
T extends {
>T : Symbol(T, Decl(infiniteConstraints.ts, 18, 36))
[K in keyof T]: Extract<T[K], Value>["val"] extends Extract<T[Exclude<keyof T, K>], Value>["val"]
>K : Symbol(K, Decl(infiniteConstraints.ts, 20, 5))
>T : Symbol(T, Decl(infiniteConstraints.ts, 18, 36))
>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --))
>T : Symbol(T, Decl(infiniteConstraints.ts, 18, 36))
>K : Symbol(K, Decl(infiniteConstraints.ts, 20, 5))
>Value : Symbol(Value, Decl(infiniteConstraints.ts, 13, 38))
>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --))
>T : Symbol(T, Decl(infiniteConstraints.ts, 18, 36))
>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --))
>T : Symbol(T, Decl(infiniteConstraints.ts, 18, 36))
>K : Symbol(K, Decl(infiniteConstraints.ts, 20, 5))
>Value : Symbol(Value, Decl(infiniteConstraints.ts, 13, 38))
? never
: any
}
>(vals: T): void;
>vals : Symbol(vals, Decl(infiniteConstraints.ts, 24, 2))
>T : Symbol(T, Decl(infiniteConstraints.ts, 18, 36))
const noError = ensureNoDuplicates({main: value("test"), alternate: value("test2")});
>noError : Symbol(noError, Decl(infiniteConstraints.ts, 26, 5))
>ensureNoDuplicates : Symbol(ensureNoDuplicates, Decl(infiniteConstraints.ts, 16, 59))
>main : Symbol(main, Decl(infiniteConstraints.ts, 26, 36))
>value : Symbol(value, Decl(infiniteConstraints.ts, 15, 57))
>alternate : Symbol(alternate, Decl(infiniteConstraints.ts, 26, 56))
>value : Symbol(value, Decl(infiniteConstraints.ts, 15, 57))
const shouldBeNoError = ensureNoDuplicates({main: value("test")});
>shouldBeNoError : Symbol(shouldBeNoError, Decl(infiniteConstraints.ts, 28, 5))
>ensureNoDuplicates : Symbol(ensureNoDuplicates, Decl(infiniteConstraints.ts, 16, 59))
>main : Symbol(main, Decl(infiniteConstraints.ts, 28, 44))
>value : Symbol(value, Decl(infiniteConstraints.ts, 15, 57))
const shouldBeError = ensureNoDuplicates({main: value("dup"), alternate: value("dup")});
>shouldBeError : Symbol(shouldBeError, Decl(infiniteConstraints.ts, 30, 5))
>ensureNoDuplicates : Symbol(ensureNoDuplicates, Decl(infiniteConstraints.ts, 16, 59))
>main : Symbol(main, Decl(infiniteConstraints.ts, 30, 42))
>value : Symbol(value, Decl(infiniteConstraints.ts, 15, 57))
>alternate : Symbol(alternate, Decl(infiniteConstraints.ts, 30, 61))
>value : Symbol(value, Decl(infiniteConstraints.ts, 15, 57))
// Repro from #26448
type Cond<T> = T extends number ? number : never;
>Cond : Symbol(Cond, Decl(infiniteConstraints.ts, 30, 88))
>T : Symbol(T, Decl(infiniteConstraints.ts, 34, 10))
>T : Symbol(T, Decl(infiniteConstraints.ts, 34, 10))
declare function function1<T extends {[K in keyof T]: Cond<T[K]>}>(): T[keyof T]["foo"];
>function1 : Symbol(function1, Decl(infiniteConstraints.ts, 34, 49))
>T : Symbol(T, Decl(infiniteConstraints.ts, 35, 27))
>K : Symbol(K, Decl(infiniteConstraints.ts, 35, 39))
>T : Symbol(T, Decl(infiniteConstraints.ts, 35, 27))
>Cond : Symbol(Cond, Decl(infiniteConstraints.ts, 30, 88))
>T : Symbol(T, Decl(infiniteConstraints.ts, 35, 27))
>K : Symbol(K, Decl(infiniteConstraints.ts, 35, 39))
>T : Symbol(T, Decl(infiniteConstraints.ts, 35, 27))
>T : Symbol(T, Decl(infiniteConstraints.ts, 35, 27))

97
tests/baselines/reference/infiniteConstraints.types Normal file
View file

@ -0,0 +1,97 @@
=== tests/cases/compiler/infiniteConstraints.ts ===
// Both of the following types trigger the recursion limiter in getImmediateBaseConstraint
type T1<B extends { [K in keyof B]: Extract<B[Exclude<keyof B, K>], { val: string }>["val"] }> = B;
>T1 : B
>val : string
type T2<B extends { [K in keyof B]: B[Exclude<keyof B, K>]["val"] }> = B;
>T2 : B
// Repros from #22950
type AProp<T extends { a: string }> = T
>AProp : T
>a : string
declare function myBug<
>myBug : <T extends { [K in keyof T]: T[K]; }>(arg: T) => T
T extends { [K in keyof T]: T[K] extends AProp<infer U> ? U : never }
>(arg: T): T
>arg : T
const out = myBug({obj1: {a: "test"}})
>out : { obj1: { a: string; }; }
>myBug({obj1: {a: "test"}}) : { obj1: { a: string; }; }
>myBug : <T extends { [K in keyof T]: T[K]; }>(arg: T) => T
>{obj1: {a: "test"}} : { obj1: { a: string; }; }
>obj1 : { a: string; }
>{a: "test"} : { a: string; }
>a : string
>"test" : "test"
type Value<V extends string = string> = Record<"val", V>;
>Value : Record<"val", V>
declare function value<V extends string>(val: V): Value<V>;
>value : <V extends string>(val: V) => Record<"val", V>
>val : V
declare function ensureNoDuplicates<
>ensureNoDuplicates : <T extends { [K in keyof T]: Extract<T[K], Record<"val", string>>["val"] extends Extract<T[Exclude<keyof T, K>], Record<"val", string>>["val"] ? never : any; }>(vals: T) => void
T extends {
[K in keyof T]: Extract<T[K], Value>["val"] extends Extract<T[Exclude<keyof T, K>], Value>["val"]
? never
: any
}
>(vals: T): void;
>vals : T
const noError = ensureNoDuplicates({main: value("test"), alternate: value("test2")});
>noError : void
>ensureNoDuplicates({main: value("test"), alternate: value("test2")}) : void
>ensureNoDuplicates : <T extends { [K in keyof T]: Extract<T[K], Record<"val", string>>["val"] extends Extract<T[Exclude<keyof T, K>], Record<"val", string>>["val"] ? never : any; }>(vals: T) => void
>{main: value("test"), alternate: value("test2")} : { main: Record<"val", "test">; alternate: Record<"val", "test2">; }
>main : Record<"val", "test">
>value("test") : Record<"val", "test">
>value : <V extends string>(val: V) => Record<"val", V>
>"test" : "test"
>alternate : Record<"val", "test2">
>value("test2") : Record<"val", "test2">
>value : <V extends string>(val: V) => Record<"val", V>
>"test2" : "test2"
const shouldBeNoError = ensureNoDuplicates({main: value("test")});
>shouldBeNoError : void
>ensureNoDuplicates({main: value("test")}) : void
>ensureNoDuplicates : <T extends { [K in keyof T]: Extract<T[K], Record<"val", string>>["val"] extends Extract<T[Exclude<keyof T, K>], Record<"val", string>>["val"] ? never : any; }>(vals: T) => void
>{main: value("test")} : { main: Record<"val", "test">; }
>main : Record<"val", "test">
>value("test") : Record<"val", "test">
>value : <V extends string>(val: V) => Record<"val", V>
>"test" : "test"
const shouldBeError = ensureNoDuplicates({main: value("dup"), alternate: value("dup")});
>shouldBeError : any
>ensureNoDuplicates({main: value("dup"), alternate: value("dup")}) : any
>ensureNoDuplicates : <T extends { [K in keyof T]: Extract<T[K], Record<"val", string>>["val"] extends Extract<T[Exclude<keyof T, K>], Record<"val", string>>["val"] ? never : any; }>(vals: T) => void
>{main: value("dup"), alternate: value("dup")} : { main: Record<"val", "dup">; alternate: Record<"val", "dup">; }
>main : Record<"val", "dup">
>value("dup") : Record<"val", "dup">
>value : <V extends string>(val: V) => Record<"val", V>
>"dup" : "dup"
>alternate : Record<"val", "dup">
>value("dup") : Record<"val", "dup">
>value : <V extends string>(val: V) => Record<"val", V>
>"dup" : "dup"
// Repro from #26448
type Cond<T> = T extends number ? number : never;
>Cond : Cond<T>
declare function function1<T extends {[K in keyof T]: Cond<T[K]>}>(): T[keyof T]["foo"];
>function1 : <T extends { [K in keyof T]: Cond<T[K]>; }>() => T[keyof T]["foo"]

38
tests/cases/compiler/infiniteConstraints.ts Normal file
View file

@ -0,0 +1,38 @@
// @strict: true
// Both of the following types trigger the recursion limiter in getImmediateBaseConstraint
type T1<B extends { [K in keyof B]: Extract<B[Exclude<keyof B, K>], { val: string }>["val"] }> = B;
type T2<B extends { [K in keyof B]: B[Exclude<keyof B, K>]["val"] }> = B;
// Repros from #22950
type AProp<T extends { a: string }> = T
declare function myBug<
T extends { [K in keyof T]: T[K] extends AProp<infer U> ? U : never }
>(arg: T): T
const out = myBug({obj1: {a: "test"}})
type Value<V extends string = string> = Record<"val", V>;
declare function value<V extends string>(val: V): Value<V>;
declare function ensureNoDuplicates<
T extends {
[K in keyof T]: Extract<T[K], Value>["val"] extends Extract<T[Exclude<keyof T, K>], Value>["val"]
? never
: any
}
>(vals: T): void;
const noError = ensureNoDuplicates({main: value("test"), alternate: value("test2")});
const shouldBeNoError = ensureNoDuplicates({main: value("test")});
const shouldBeError = ensureNoDuplicates({main: value("dup"), alternate: value("dup")});
// Repro from #26448
type Cond<T> = T extends number ? number : never;
declare function function1<T extends {[K in keyof T]: Cond<T[K]>}>(): T[keyof T]["foo"];