Merge pull request #26558 from Microsoft/fixInfiniteConstraints
Fix infinite constraints
This commit is contained in:
commit
93c76cb617
7 changed files with 453 additions and 61 deletions
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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
53
tests/baselines/reference/infiniteConstraints.errors.txt
Normal 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
46
tests/baselines/reference/infiniteConstraints.js
Normal 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
140
tests/baselines/reference/infiniteConstraints.symbols
Normal 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
97
tests/baselines/reference/infiniteConstraints.types
Normal 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
38
tests/cases/compiler/infiniteConstraints.ts
Normal 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"];
|
Loading…
Reference in a new issue