diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 48bc0da113816..538bc2fccdafc 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1512,6 +1512,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { var currentNode: Node | undefined; var varianceTypeParameter: TypeParameter | undefined; var isInferencePartiallyBlocked = false; + var propagateAnyFunctionType = true; var emptySymbols = createSymbolTable(); var arrayVariances = [VarianceFlags.Covariant]; @@ -2145,7 +2146,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { var anyFunctionType = createAnonymousType(/*symbol*/ undefined, emptySymbols, emptyArray, emptyArray, emptyArray); // The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated // in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes. - anyFunctionType.objectFlags |= ObjectFlags.NonInferrableType; + anyFunctionType.objectFlags |= ObjectFlags.NonInferrableType | ObjectFlags.ContainsAnyFunctionType; var noConstraintType = createAnonymousType(/*symbol*/ undefined, emptySymbols, emptyArray, emptyArray, emptyArray); var circularConstraintType = createAnonymousType(/*symbol*/ undefined, emptySymbols, emptyArray, emptyArray, emptyArray); @@ -26195,7 +26196,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // Before we commit to a particular inference (and thus lock out any further inferences), // we infer from any intra-expression inference sites we have collected. inferFromIntraExpressionSites(context); - clearCachedInferences(context.inferences); + clearCachedInferences(context.inferences, true); inference.isFixed = true; } return getInferredType(context, i); @@ -26212,8 +26213,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { ); } - function clearCachedInferences(inferences: InferenceInfo[]) { + function clearCachedInferences(inferences: InferenceInfo[], clearSeenAnyFunctionType?: boolean) { for (const inference of inferences) { + if (clearSeenAnyFunctionType && inference.seenAnyFunctionType) { + inference.seenAnyFunctionType = false; + inference.inferredType = undefined; + } if (!inference.isFixed) { inference.inferredType = undefined; } @@ -26694,7 +26699,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (!couldContainTypeVariables(target) || isNoInferType(target)) { return; } - if (source === wildcardType || source === blockedStringType) { + if (source === wildcardType || source === blockedStringType || propagateAnyFunctionType && source === anyFunctionType) { // We are inferring from an 'any' type. We want to infer this type for every type parameter // referenced in the target type, so we record it as the propagation type and infer from the // target to itself. Then, as we find candidates we substitute the propagation type. @@ -26793,7 +26798,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // // As a special case, also ignore nonInferrableAnyType, which is a special form of the any type // used as a stand-in for binding elements when they are being inferred. - if (getObjectFlags(source) & ObjectFlags.NonInferrableType || source === nonInferrableAnyType) { + const objectFlags = getObjectFlags(source); + if ((objectFlags & (ObjectFlags.NonInferrableType | (propagateAnyFunctionType ? ObjectFlags.ContainsAnyFunctionType : 0))) === ObjectFlags.NonInferrableType || source === nonInferrableAnyType) { return; } if (!inference.isFixed) { @@ -26801,11 +26807,19 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (candidate === blockedStringType) { return; } + if (propagateAnyFunctionType && getObjectFlags(candidate) & ObjectFlags.ContainsAnyFunctionType) { + // basically it means that + if (!hasInferenceCandidates(inference)) { + inference.seenAnyFunctionType = true; + } + return; + } if (inference.priority === undefined || priority < inference.priority) { inference.candidates = undefined; inference.contraCandidates = undefined; inference.topLevel = true; inference.priority = priority; + inference.seenAnyFunctionType = false; } if (priority === inference.priority) { // We make contravariant inferences only if we are in a pure contravariant position, @@ -27542,6 +27556,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // We use silentNeverType as the wildcard that signals no inferences. inferredType = silentNeverType; } + else if (inference.seenAnyFunctionType) { + inferredType = wildcardType; + } else { // Infer either the default or the empty object type when no inferences were // made. It is important to remember that in this case, inference still @@ -36745,6 +36762,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // round of type inference and applicability checking for this particular candidate. argCheckMode = CheckMode.Normal; if (inferenceContext) { + if (some(inferenceContext.inferences, i => !!i.seenAnyFunctionType)) { + clearCachedInferences(inferenceContext.inferences, true); + } const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext); checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters); // If the original signature has a generic rest type, instantiation may produce a @@ -36873,7 +36893,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function inferSignatureInstantiationForOverloadFailure(node: CallLikeExpression, typeParameters: readonly TypeParameter[], candidate: Signature, args: readonly Expression[], checkMode: CheckMode): Signature { const inferenceContext = createInferenceContext(typeParameters, candidate, /*flags*/ isInJSFile(node) ? InferenceFlags.AnyDefault : InferenceFlags.None); + const savePropagateAnyFunctionType = propagateAnyFunctionType; + propagateAnyFunctionType = false; const typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | CheckMode.SkipContextSensitive | CheckMode.SkipGenericFunctions, inferenceContext); + propagateAnyFunctionType = savePropagateAnyFunctionType; return createSignatureInstantiation(candidate, typeArgumentTypes); } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 4835b4bdf2efa..3754e508a4b09 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -6531,11 +6531,13 @@ export const enum ObjectFlags { /** @internal */ CouldContainTypeVariables = 1 << 20, // Type could contain a type variable SingleSignatureType = 1 << 27, // A single signature type extracted from a potentially broader type + /** @internal */ + ContainsAnyFunctionType = 1 << 28, // pick a better value maybe ClassOrInterface = Class | Interface, /** @internal */ RequiresWidening = ContainsWideningType | ContainsObjectOrArrayLiteral, /** @internal */ - PropagatingFlags = ContainsWideningType | ContainsObjectOrArrayLiteral | NonInferrableType, + PropagatingFlags = ContainsWideningType | ContainsObjectOrArrayLiteral | NonInferrableType | ContainsAnyFunctionType, /** @internal */ InstantiatedMapped = Mapped | Instantiated, // Object flags that uniquely identify the kind of ObjectType @@ -7111,6 +7113,7 @@ export interface InferenceInfo { topLevel: boolean; // True if all inferences are to top level occurrences isFixed: boolean; // True if inferences are fixed impliedArity?: number; + seenAnyFunctionType?: boolean } // dprint-ignore diff --git a/tests/baselines/reference/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.symbols b/tests/baselines/reference/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.symbols new file mode 100644 index 0000000000000..0fcddcf3bbbad --- /dev/null +++ b/tests/baselines/reference/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.symbols @@ -0,0 +1,199 @@ +//// [tests/cases/compiler/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts] //// + +=== contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts === +// based on https://github.com/microsoft/TypeScript/issues/51831 + +type NoMatchAll = Exclude +>NoMatchAll : Symbol(NoMatchAll, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 0, 0)) +>K : Symbol(K, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 2, 16)) +>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --)) +>K : Symbol(K, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 2, 16)) + +type Union = { +>Union : Symbol(Union, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 2, 36)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 3, 11)) + + [P in keyof T]: ({ [Q in "kind"]: P } & T[P]) extends infer U ? { [Q in keyof U]: U[Q] } : never +>P : Symbol(P, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 4, 3)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 3, 11)) +>Q : Symbol(Q, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 4, 22)) +>P : Symbol(P, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 4, 3)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 3, 11)) +>P : Symbol(P, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 4, 3)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 4, 61)) +>Q : Symbol(Q, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 4, 69)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 4, 61)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 4, 61)) +>Q : Symbol(Q, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 4, 69)) + +}[keyof T] +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 3, 11)) + +type UnionMap = { [K in U["kind"]]: U extends { kind: K } ? U : never } +>UnionMap : Symbol(UnionMap, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 5, 10)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 6, 14)) +>kind : Symbol(kind, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 6, 25)) +>K : Symbol(K, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 6, 47)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 6, 14)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 6, 14)) +>kind : Symbol(kind, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 6, 75)) +>K : Symbol(K, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 6, 47)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 6, 14)) + +type ExhaustivePattern = { [K in T["kind"] as NoMatchAll]: (union: UnionMap[K]) => R }; +>ExhaustivePattern : Symbol(ExhaustivePattern, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 6, 99)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 23)) +>kind : Symbol(kind, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 34)) +>R : Symbol(R, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 50)) +>K : Symbol(K, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 59)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 23)) +>NoMatchAll : Symbol(NoMatchAll, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 0, 0)) +>K : Symbol(K, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 59)) +>union : Symbol(union, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 94)) +>UnionMap : Symbol(UnionMap, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 5, 10)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 23)) +>K : Symbol(K, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 59)) +>R : Symbol(R, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 50)) + +type NonExhaustivePattern = { [K in T["kind"] as NoMatchAll]?: (union: UnionMap[K]) => R } & {_: (union: T) => R}; +>NonExhaustivePattern : Symbol(NonExhaustivePattern, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 124)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 26)) +>kind : Symbol(kind, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 37)) +>R : Symbol(R, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 53)) +>K : Symbol(K, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 62)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 26)) +>NoMatchAll : Symbol(NoMatchAll, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 0, 0)) +>K : Symbol(K, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 62)) +>union : Symbol(union, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 98)) +>UnionMap : Symbol(UnionMap, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 5, 10)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 26)) +>K : Symbol(K, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 62)) +>R : Symbol(R, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 53)) +>_ : Symbol(_, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 131)) +>union : Symbol(union, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 135)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 26)) +>R : Symbol(R, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 53)) + +type Pattern = ExhaustivePattern | NonExhaustivePattern; +>Pattern : Symbol(Pattern, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 151)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 9, 13)) +>kind : Symbol(kind, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 9, 24)) +>R : Symbol(R, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 9, 40)) +>ExhaustivePattern : Symbol(ExhaustivePattern, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 6, 99)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 9, 13)) +>R : Symbol(R, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 9, 40)) +>NonExhaustivePattern : Symbol(NonExhaustivePattern, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 7, 124)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 9, 13)) +>R : Symbol(R, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 9, 40)) + +function match(union: U, pattern: Pattern): T { +>match : Symbol(match, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 9, 99)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 15)) +>kind : Symbol(kind, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 26)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 42)) +>union : Symbol(union, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 46)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 15)) +>pattern : Symbol(pattern, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 55)) +>Pattern : Symbol(Pattern, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 8, 151)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 15)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 42)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 42)) + + if((pattern as any)[union.kind]) { +>pattern : Symbol(pattern, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 55)) +>union.kind : Symbol(kind, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 26)) +>union : Symbol(union, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 46)) +>kind : Symbol(kind, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 26)) + + return (pattern as any)[union.kind](union as U) as T +>pattern : Symbol(pattern, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 55)) +>union.kind : Symbol(kind, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 26)) +>union : Symbol(union, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 46)) +>kind : Symbol(kind, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 26)) +>union : Symbol(union, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 46)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 15)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 42)) + } + return (pattern as any)["_"](union as U) as T +>pattern : Symbol(pattern, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 55)) +>union : Symbol(union, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 46)) +>U : Symbol(U, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 15)) +>T : Symbol(T, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 11, 42)) +} + +type ValueType = Union<{ +>ValueType : Symbol(ValueType, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 16, 1)) +>Union : Symbol(Union, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 2, 36)) + + String: {value: string}, +>String : Symbol(String, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 18, 24)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 19, 11)) + + Number: {value: number}, +>Number : Symbol(Number, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 19, 26)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 20, 11)) + + Boolean: {value: boolean}, +>Boolean : Symbol(Boolean, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 20, 26)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 21, 12)) + + Date: {value: Date} +>Date : Symbol(Date, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 21, 28)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 22, 9)) +>Date : Symbol(Date, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.scripthost.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +}> + +function main(value: ValueType) { +>main : Symbol(main, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 23, 2)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 25, 14)) +>ValueType : Symbol(ValueType, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 16, 1)) + + let test1 = match(value, { +>test1 : Symbol(test1, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 26, 5)) +>match : Symbol(match, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 9, 99)) +>ValueType : Symbol(ValueType, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 16, 1)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 25, 14)) + + String: ({value}) => value, +>String : Symbol(String, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 26, 47)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 27, 14)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 27, 14)) + + Number: ({value}) => value.toString(), +>Number : Symbol(Number, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 27, 31)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 28, 14)) +>value.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 28, 14)) +>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) + + _: (token) => "Unknown" +>_ : Symbol(_, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 28, 42)) +>token : Symbol(token, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 29, 8)) + + }); + + let test2 = match(value, { +>test2 : Symbol(test2, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 32, 5)) +>match : Symbol(match, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 9, 99)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 25, 14)) + + String: ({value}) => value, +>String : Symbol(String, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 32, 28)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 33, 14)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 33, 14)) + + Number: ({value}) => value.toString(), +>Number : Symbol(Number, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 33, 31)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 34, 14)) +>value.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) +>value : Symbol(value, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 34, 14)) +>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) + + _: (token) => "Unknown" +>_ : Symbol(_, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 34, 42)) +>token : Symbol(token, Decl(contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts, 35, 8)) + + }); +} + diff --git a/tests/baselines/reference/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.types b/tests/baselines/reference/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.types new file mode 100644 index 0000000000000..c56b7284ba319 --- /dev/null +++ b/tests/baselines/reference/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.types @@ -0,0 +1,246 @@ +//// [tests/cases/compiler/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts] //// + +=== contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts === +// based on https://github.com/microsoft/TypeScript/issues/51831 + +type NoMatchAll = Exclude +>NoMatchAll : NoMatchAll +> : ^^^^^^^^^^^^^ + +type Union = { +>Union : Union +> : ^^^^^^^^ + + [P in keyof T]: ({ [Q in "kind"]: P } & T[P]) extends infer U ? { [Q in keyof U]: U[Q] } : never +}[keyof T] +type UnionMap = { [K in U["kind"]]: U extends { kind: K } ? U : never } +>UnionMap : UnionMap +> : ^^^^^^^^^^^ +>kind : string +> : ^^^^^^ +>kind : K +> : ^ + +type ExhaustivePattern = { [K in T["kind"] as NoMatchAll]: (union: UnionMap[K]) => R }; +>ExhaustivePattern : ExhaustivePattern +> : ^^^^^^^^^^^^^^^^^^^^^^^ +>kind : string +> : ^^^^^^ +>union : UnionMap[K] +> : ^^^^^^^^^^^^^^ + +type NonExhaustivePattern = { [K in T["kind"] as NoMatchAll]?: (union: UnionMap[K]) => R } & {_: (union: T) => R}; +>NonExhaustivePattern : NonExhaustivePattern +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ +>kind : string +> : ^^^^^^ +>union : UnionMap[K] +> : ^^^^^^^^^^^^^^ +>_ : (union: T) => R +> : ^ ^^ ^^^^^ +>union : T +> : ^ + +type Pattern = ExhaustivePattern | NonExhaustivePattern; +>Pattern : Pattern +> : ^^^^^^^^^^^^^ +>kind : string +> : ^^^^^^ + +function match(union: U, pattern: Pattern): T { +>match : (union: U, pattern: Pattern) => T +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ +>kind : string +> : ^^^^^^ +>union : U +> : ^ +>pattern : Pattern +> : ^^^^^^^^^^^^^ + + if((pattern as any)[union.kind]) { +>(pattern as any)[union.kind] : any +>(pattern as any) : any +>pattern as any : any +>pattern : Pattern +> : ^^^^^^^^^^^^^ +>union.kind : string +> : ^^^^^^ +>union : U +> : ^ +>kind : string +> : ^^^^^^ + + return (pattern as any)[union.kind](union as U) as T +>(pattern as any)[union.kind](union as U) as T : T +> : ^ +>(pattern as any)[union.kind](union as U) : any +>(pattern as any)[union.kind] : any +>(pattern as any) : any +>pattern as any : any +>pattern : Pattern +> : ^^^^^^^^^^^^^ +>union.kind : string +> : ^^^^^^ +>union : U +> : ^ +>kind : string +> : ^^^^^^ +>union as U : U +> : ^ +>union : U +> : ^ + } + return (pattern as any)["_"](union as U) as T +>(pattern as any)["_"](union as U) as T : T +> : ^ +>(pattern as any)["_"](union as U) : any +>(pattern as any)["_"] : any +>(pattern as any) : any +>pattern as any : any +>pattern : Pattern +> : ^^^^^^^^^^^^^ +>"_" : "_" +> : ^^^ +>union as U : U +> : ^ +>union : U +> : ^ +} + +type ValueType = Union<{ +>ValueType : ValueType +> : ^^^^^^^^^ + + String: {value: string}, +>String : { value: string; } +> : ^^^^^^^^^ ^^^ +>value : string +> : ^^^^^^ + + Number: {value: number}, +>Number : { value: number; } +> : ^^^^^^^^^ ^^^ +>value : number +> : ^^^^^^ + + Boolean: {value: boolean}, +>Boolean : { value: boolean; } +> : ^^^^^^^^^ ^^^ +>value : boolean +> : ^^^^^^^ + + Date: {value: Date} +>Date : { value: Date; } +> : ^^^^^^^^^ ^^^ +>value : Date +> : ^^^^ + +}> + +function main(value: ValueType) { +>main : (value: ValueType) => void +> : ^ ^^ ^^^^^^^^^ +>value : ValueType +> : ^^^^^^^^^ + + let test1 = match(value, { +>test1 : string +> : ^^^^^^ +>match(value, { String: ({value}) => value, Number: ({value}) => value.toString(), _: (token) => "Unknown" }) : string +> : ^^^^^^ +>match : (union: U, pattern: Pattern) => T +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ +>value : ValueType +> : ^^^^^^^^^ +>{ String: ({value}) => value, Number: ({value}) => value.toString(), _: (token) => "Unknown" } : { String: ({ value }: { kind: "String"; value: string; }) => string; Number: ({ value }: { kind: "Number"; value: number; }) => string; _: (token: ValueType) => string; } +> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ + + String: ({value}) => value, +>String : ({ value }: { kind: "String"; value: string; }) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ +>({value}) => value : ({ value }: { kind: "String"; value: string; }) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ +>value : string +> : ^^^^^^ +>value : string +> : ^^^^^^ + + Number: ({value}) => value.toString(), +>Number : ({ value }: { kind: "Number"; value: number; }) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ +>({value}) => value.toString() : ({ value }: { kind: "Number"; value: number; }) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ +>value : number +> : ^^^^^^ +>value.toString() : string +> : ^^^^^^ +>value.toString : (radix?: number) => string +> : ^ ^^^ ^^^^^ +>value : number +> : ^^^^^^ +>toString : (radix?: number) => string +> : ^ ^^^ ^^^^^ + + _: (token) => "Unknown" +>_ : (token: ValueType) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^ +>(token) => "Unknown" : (token: ValueType) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^ +>token : ValueType +> : ^^^^^^^^^ +>"Unknown" : "Unknown" +> : ^^^^^^^^^ + + }); + + let test2 = match(value, { +>test2 : string +> : ^^^^^^ +>match(value, { String: ({value}) => value, Number: ({value}) => value.toString(), _: (token) => "Unknown" }) : string +> : ^^^^^^ +>match : (union: U, pattern: Pattern) => T +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^ +>value : ValueType +> : ^^^^^^^^^ +>{ String: ({value}) => value, Number: ({value}) => value.toString(), _: (token) => "Unknown" } : { String: ({ value }: { kind: "String"; value: string; }) => string; Number: ({ value }: { kind: "Number"; value: number; }) => string; _: (token: ValueType) => string; } +> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ + + String: ({value}) => value, +>String : ({ value }: { kind: "String"; value: string; }) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ +>({value}) => value : ({ value }: { kind: "String"; value: string; }) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ +>value : string +> : ^^^^^^ +>value : string +> : ^^^^^^ + + Number: ({value}) => value.toString(), +>Number : ({ value }: { kind: "Number"; value: number; }) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ +>({value}) => value.toString() : ({ value }: { kind: "Number"; value: number; }) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ +>value : number +> : ^^^^^^ +>value.toString() : string +> : ^^^^^^ +>value.toString : (radix?: number) => string +> : ^ ^^^ ^^^^^ +>value : number +> : ^^^^^^ +>toString : (radix?: number) => string +> : ^ ^^^ ^^^^^ + + _: (token) => "Unknown" +>_ : (token: ValueType) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^ +>(token) => "Unknown" : (token: ValueType) => string +> : ^ ^^^^^^^^^^^^^^^^^^^^^^ +>token : ValueType +> : ^^^^^^^^^ +>"Unknown" : "Unknown" +> : ^^^^^^^^^ + + }); +} + diff --git a/tests/baselines/reference/inferenceContextSensitiveDependentParameters1.errors.txt b/tests/baselines/reference/inferenceContextSensitiveDependentParameters1.errors.txt new file mode 100644 index 0000000000000..5777986e6ddae --- /dev/null +++ b/tests/baselines/reference/inferenceContextSensitiveDependentParameters1.errors.txt @@ -0,0 +1,195 @@ +inferenceContextSensitiveDependentParameters1.ts(108,13): error TS2345: Argument of type '"value"' is not assignable to parameter of type 'never'. + + +==== inferenceContextSensitiveDependentParameters1.ts (1 errors) ==== + // https://github.com/microsoft/TypeScript/issues/62204 + + declare function TestConfig< + const TConfig extends { a?: any; b?: any; c?: any }, + >( + config: TConfig, + test: keyof Omit extends never ? true : false, + ): void; + + TestConfig( + { + a: "hello", + b: function () { + return "123"; + }, + }, + true, + ); + + declare function TestConfig_2< + const TConfig extends { a?: any; b?: (arg: number) => unknown; c?: any }, + >( + config: TConfig, + test: keyof Omit extends never ? true : false, + ): void; + + TestConfig_2( + { + a: "hello", + b: (arg) => { + return "123"; + }, + }, + true, + ); + + // https://github.com/microsoft/TypeScript/issues/47599#issuecomment-2919401231 + type KeysMatchingType = { + [K in keyof T]: T[K] extends V ? K : never; + }[keyof T]; + type ExtractItems = R[IK] extends readonly (infer T)[] + ? T + : never; + type StreamPaginatedDataProps = { + callback: (limit: number, offset: number) => Promise; + responseKeys: { items: IK; total: TK }; + limit?: number; + }; + + declare function streamPaginatedData< + R, + const IK extends KeysMatchingType, + const TK extends KeysMatchingType, + >({ + callback, + responseKeys, + limit, + }: StreamPaginatedDataProps): AsyncGenerator< + ExtractItems, + void, + unknown + >; + + const sampleData = [ + { location: { name: "New York" } }, + { location: { name: "Tokyo" } }, + ] as const; + + streamPaginatedData({ + callback: async (a, b) => ({ + someCount: sampleData.length, + abra: sampleData, + }), + responseKeys: { total: "someCount", items: "abra" }, + }) + + // https://github.com/microsoft/TypeScript/issues/47599#issuecomment-2132658606 + interface Base { + x: string; + } + interface Foo extends Base { + y: number; + } + + type Fn = (t: T) => void; + declare const FooFn: Fn; + + type Baz = >(arg: { + x: (bar: Foo) => R; + y?: F[]; + }) => R; + + declare const baz: Baz; + const R1 = baz({ x: (ctx) => ctx }); + const R2 = baz({ x: (ctx) => ctx, y: [FooFn] }); + + // https://github.com/microsoft/TypeScript/issues/55489 + type NonStringIterable = T extends string + ? never + : T extends Iterable + ? T + : never; + + declare function doSomething(value: NonStringIterable): T; + + const o = { foo() {} }; + + doSomething("value"); // error + ~~~~~~~ +!!! error TS2345: Argument of type '"value"' is not assignable to parameter of type 'never'. + doSomething(["v"]); + doSomething([o]); + doSomething([{ foo() {} }]); + + // https://github.com/microsoft/TypeScript/issues/55124 + type Values = T[keyof T]; + type ExtractFields = Values<{ + [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never; + }>; + type SetType = { + [key: string]: any; + target?: ExtractFields; + }; + + declare function test55124>( + options: OptionsData, + ): void; + + test55124({ + target: "$test4", + data1: { + $test1: 111, + $test2: null, + }, + data2: { + $test3: {}, + $test4: () => {}, + $test5() {}, + }, + }); + + type SetType_2 = { + [key: `data${number}`]: Record void>; + target?: ExtractFields; + }; + + declare function test55124_2>( + options: OptionsData, + ): void; + + test55124_2({ + target: "$test4", + data1: { + $test1: () => {}, + $test2: () => {}, + }, + data2: { + $test3: () => {}, + $test4: () => {}, + $test5: (arg) => {}, + }, + }); + + // https://github.com/microsoft/TypeScript/issues/54438 + interface Entity { + id: number; + name: string; + } + + type Fn54438 = (params: Record) => T[]; + + declare function test54438(fn: Fn54438, key: K): T; + + test54438(() => [] as Entity[], "id"); + test54438((params: Record) => [] as Entity[], "name"); + test54438((params: unknown) => [] as Entity[], "id"); + test54438((params) => [] as Entity[], "id"); + + export declare const serve: (props: { + bindings: Extract, string>; + fetch: (event: unknown) => Generator; + }) => unknown; + + declare const bar: () => Generator<"SendMessage">; + + serve({ + bindings: "SendMessage" as const, + fetch: function* (a) { + yield* bar(); + }, + }); \ No newline at end of file diff --git a/tests/baselines/reference/inferenceContextSensitiveDependentParameters1.symbols b/tests/baselines/reference/inferenceContextSensitiveDependentParameters1.symbols new file mode 100644 index 0000000000000..685e21609b189 --- /dev/null +++ b/tests/baselines/reference/inferenceContextSensitiveDependentParameters1.symbols @@ -0,0 +1,553 @@ +//// [tests/cases/compiler/inferenceContextSensitiveDependentParameters1.ts] //// + +=== inferenceContextSensitiveDependentParameters1.ts === +// https://github.com/microsoft/TypeScript/issues/62204 + +declare function TestConfig< +>TestConfig : Symbol(TestConfig, Decl(inferenceContextSensitiveDependentParameters1.ts, 0, 0)) + + const TConfig extends { a?: any; b?: any; c?: any }, +>TConfig : Symbol(TConfig, Decl(inferenceContextSensitiveDependentParameters1.ts, 2, 28)) +>a : Symbol(a, Decl(inferenceContextSensitiveDependentParameters1.ts, 3, 25)) +>b : Symbol(b, Decl(inferenceContextSensitiveDependentParameters1.ts, 3, 34)) +>c : Symbol(c, Decl(inferenceContextSensitiveDependentParameters1.ts, 3, 43)) + +>( + config: TConfig, +>config : Symbol(config, Decl(inferenceContextSensitiveDependentParameters1.ts, 4, 2)) +>TConfig : Symbol(TConfig, Decl(inferenceContextSensitiveDependentParameters1.ts, 2, 28)) + + test: keyof Omit extends never ? true : false, +>test : Symbol(test, Decl(inferenceContextSensitiveDependentParameters1.ts, 5, 18)) +>Omit : Symbol(Omit, Decl(lib.es5.d.ts, --, --)) +>TConfig : Symbol(TConfig, Decl(inferenceContextSensitiveDependentParameters1.ts, 2, 28)) + +): void; + +TestConfig( +>TestConfig : Symbol(TestConfig, Decl(inferenceContextSensitiveDependentParameters1.ts, 0, 0)) + { + a: "hello", +>a : Symbol(a, Decl(inferenceContextSensitiveDependentParameters1.ts, 10, 3)) + + b: function () { +>b : Symbol(b, Decl(inferenceContextSensitiveDependentParameters1.ts, 11, 15)) + + return "123"; + }, + }, + true, +); + +declare function TestConfig_2< +>TestConfig_2 : Symbol(TestConfig_2, Decl(inferenceContextSensitiveDependentParameters1.ts, 17, 2)) + + const TConfig extends { a?: any; b?: (arg: number) => unknown; c?: any }, +>TConfig : Symbol(TConfig, Decl(inferenceContextSensitiveDependentParameters1.ts, 19, 30)) +>a : Symbol(a, Decl(inferenceContextSensitiveDependentParameters1.ts, 20, 25)) +>b : Symbol(b, Decl(inferenceContextSensitiveDependentParameters1.ts, 20, 34)) +>arg : Symbol(arg, Decl(inferenceContextSensitiveDependentParameters1.ts, 20, 40)) +>c : Symbol(c, Decl(inferenceContextSensitiveDependentParameters1.ts, 20, 64)) + +>( + config: TConfig, +>config : Symbol(config, Decl(inferenceContextSensitiveDependentParameters1.ts, 21, 2)) +>TConfig : Symbol(TConfig, Decl(inferenceContextSensitiveDependentParameters1.ts, 19, 30)) + + test: keyof Omit extends never ? true : false, +>test : Symbol(test, Decl(inferenceContextSensitiveDependentParameters1.ts, 22, 18)) +>Omit : Symbol(Omit, Decl(lib.es5.d.ts, --, --)) +>TConfig : Symbol(TConfig, Decl(inferenceContextSensitiveDependentParameters1.ts, 19, 30)) + +): void; + +TestConfig_2( +>TestConfig_2 : Symbol(TestConfig_2, Decl(inferenceContextSensitiveDependentParameters1.ts, 17, 2)) + { + a: "hello", +>a : Symbol(a, Decl(inferenceContextSensitiveDependentParameters1.ts, 27, 3)) + + b: (arg) => { +>b : Symbol(b, Decl(inferenceContextSensitiveDependentParameters1.ts, 28, 15)) +>arg : Symbol(arg, Decl(inferenceContextSensitiveDependentParameters1.ts, 29, 8)) + + return "123"; + }, + }, + true, +); + +// https://github.com/microsoft/TypeScript/issues/47599#issuecomment-2919401231 +type KeysMatchingType = { +>KeysMatchingType : Symbol(KeysMatchingType, Decl(inferenceContextSensitiveDependentParameters1.ts, 34, 2)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 37, 22)) +>V : Symbol(V, Decl(inferenceContextSensitiveDependentParameters1.ts, 37, 24)) + + [K in keyof T]: T[K] extends V ? K : never; +>K : Symbol(K, Decl(inferenceContextSensitiveDependentParameters1.ts, 38, 3)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 37, 22)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 37, 22)) +>K : Symbol(K, Decl(inferenceContextSensitiveDependentParameters1.ts, 38, 3)) +>V : Symbol(V, Decl(inferenceContextSensitiveDependentParameters1.ts, 37, 24)) +>K : Symbol(K, Decl(inferenceContextSensitiveDependentParameters1.ts, 38, 3)) + +}[keyof T]; +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 37, 22)) + +type ExtractItems = R[IK] extends readonly (infer T)[] +>ExtractItems : Symbol(ExtractItems, Decl(inferenceContextSensitiveDependentParameters1.ts, 39, 11)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 40, 18)) +>IK : Symbol(IK, Decl(inferenceContextSensitiveDependentParameters1.ts, 40, 20)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 40, 18)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 40, 18)) +>IK : Symbol(IK, Decl(inferenceContextSensitiveDependentParameters1.ts, 40, 20)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 40, 72)) + + ? T +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 40, 72)) + + : never; +type StreamPaginatedDataProps = { +>StreamPaginatedDataProps : Symbol(StreamPaginatedDataProps, Decl(inferenceContextSensitiveDependentParameters1.ts, 42, 10)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 43, 30)) +>IK : Symbol(IK, Decl(inferenceContextSensitiveDependentParameters1.ts, 43, 32)) +>TK : Symbol(TK, Decl(inferenceContextSensitiveDependentParameters1.ts, 43, 36)) + + callback: (limit: number, offset: number) => Promise; +>callback : Symbol(callback, Decl(inferenceContextSensitiveDependentParameters1.ts, 43, 44)) +>limit : Symbol(limit, Decl(inferenceContextSensitiveDependentParameters1.ts, 44, 13)) +>offset : Symbol(offset, Decl(inferenceContextSensitiveDependentParameters1.ts, 44, 27)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 43, 30)) + + responseKeys: { items: IK; total: TK }; +>responseKeys : Symbol(responseKeys, Decl(inferenceContextSensitiveDependentParameters1.ts, 44, 58)) +>items : Symbol(items, Decl(inferenceContextSensitiveDependentParameters1.ts, 45, 17)) +>IK : Symbol(IK, Decl(inferenceContextSensitiveDependentParameters1.ts, 43, 32)) +>total : Symbol(total, Decl(inferenceContextSensitiveDependentParameters1.ts, 45, 28)) +>TK : Symbol(TK, Decl(inferenceContextSensitiveDependentParameters1.ts, 43, 36)) + + limit?: number; +>limit : Symbol(limit, Decl(inferenceContextSensitiveDependentParameters1.ts, 45, 41)) + +}; + +declare function streamPaginatedData< +>streamPaginatedData : Symbol(streamPaginatedData, Decl(inferenceContextSensitiveDependentParameters1.ts, 47, 2)) + + R, +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 49, 37)) + + const IK extends KeysMatchingType, +>IK : Symbol(IK, Decl(inferenceContextSensitiveDependentParameters1.ts, 50, 4)) +>KeysMatchingType : Symbol(KeysMatchingType, Decl(inferenceContextSensitiveDependentParameters1.ts, 34, 2)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 49, 37)) + + const TK extends KeysMatchingType, +>TK : Symbol(TK, Decl(inferenceContextSensitiveDependentParameters1.ts, 51, 59)) +>KeysMatchingType : Symbol(KeysMatchingType, Decl(inferenceContextSensitiveDependentParameters1.ts, 34, 2)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 49, 37)) + +>({ + callback, +>callback : Symbol(callback, Decl(inferenceContextSensitiveDependentParameters1.ts, 53, 3)) + + responseKeys, +>responseKeys : Symbol(responseKeys, Decl(inferenceContextSensitiveDependentParameters1.ts, 54, 11)) + + limit, +>limit : Symbol(limit, Decl(inferenceContextSensitiveDependentParameters1.ts, 55, 15)) + +}: StreamPaginatedDataProps): AsyncGenerator< +>StreamPaginatedDataProps : Symbol(StreamPaginatedDataProps, Decl(inferenceContextSensitiveDependentParameters1.ts, 42, 10)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 49, 37)) +>IK : Symbol(IK, Decl(inferenceContextSensitiveDependentParameters1.ts, 50, 4)) +>TK : Symbol(TK, Decl(inferenceContextSensitiveDependentParameters1.ts, 51, 59)) +>AsyncGenerator : Symbol(AsyncGenerator, Decl(lib.es2018.asyncgenerator.d.ts, --, --)) + + ExtractItems, +>ExtractItems : Symbol(ExtractItems, Decl(inferenceContextSensitiveDependentParameters1.ts, 39, 11)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 49, 37)) +>IK : Symbol(IK, Decl(inferenceContextSensitiveDependentParameters1.ts, 50, 4)) + + void, + unknown +>; + +const sampleData = [ +>sampleData : Symbol(sampleData, Decl(inferenceContextSensitiveDependentParameters1.ts, 63, 5)) + + { location: { name: "New York" } }, +>location : Symbol(location, Decl(inferenceContextSensitiveDependentParameters1.ts, 64, 3)) +>name : Symbol(name, Decl(inferenceContextSensitiveDependentParameters1.ts, 64, 15)) + + { location: { name: "Tokyo" } }, +>location : Symbol(location, Decl(inferenceContextSensitiveDependentParameters1.ts, 65, 3)) +>name : Symbol(name, Decl(inferenceContextSensitiveDependentParameters1.ts, 65, 15)) + +] as const; +>const : Symbol(const) + +streamPaginatedData({ +>streamPaginatedData : Symbol(streamPaginatedData, Decl(inferenceContextSensitiveDependentParameters1.ts, 47, 2)) + + callback: async (a, b) => ({ +>callback : Symbol(callback, Decl(inferenceContextSensitiveDependentParameters1.ts, 68, 21)) +>a : Symbol(a, Decl(inferenceContextSensitiveDependentParameters1.ts, 69, 19)) +>b : Symbol(b, Decl(inferenceContextSensitiveDependentParameters1.ts, 69, 21)) + + someCount: sampleData.length, +>someCount : Symbol(someCount, Decl(inferenceContextSensitiveDependentParameters1.ts, 69, 30)) +>sampleData.length : Symbol(length) +>sampleData : Symbol(sampleData, Decl(inferenceContextSensitiveDependentParameters1.ts, 63, 5)) +>length : Symbol(length) + + abra: sampleData, +>abra : Symbol(abra, Decl(inferenceContextSensitiveDependentParameters1.ts, 70, 33)) +>sampleData : Symbol(sampleData, Decl(inferenceContextSensitiveDependentParameters1.ts, 63, 5)) + + }), + responseKeys: { total: "someCount", items: "abra" }, +>responseKeys : Symbol(responseKeys, Decl(inferenceContextSensitiveDependentParameters1.ts, 72, 5)) +>total : Symbol(total, Decl(inferenceContextSensitiveDependentParameters1.ts, 73, 17)) +>items : Symbol(items, Decl(inferenceContextSensitiveDependentParameters1.ts, 73, 37)) + +}) + +// https://github.com/microsoft/TypeScript/issues/47599#issuecomment-2132658606 +interface Base { +>Base : Symbol(Base, Decl(inferenceContextSensitiveDependentParameters1.ts, 74, 2)) + + x: string; +>x : Symbol(Base.x, Decl(inferenceContextSensitiveDependentParameters1.ts, 77, 16)) +} +interface Foo extends Base { +>Foo : Symbol(Foo, Decl(inferenceContextSensitiveDependentParameters1.ts, 79, 1)) +>Base : Symbol(Base, Decl(inferenceContextSensitiveDependentParameters1.ts, 74, 2)) + + y: number; +>y : Symbol(Foo.y, Decl(inferenceContextSensitiveDependentParameters1.ts, 80, 28)) +} + +type Fn = (t: T) => void; +>Fn : Symbol(Fn, Decl(inferenceContextSensitiveDependentParameters1.ts, 82, 1)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 84, 8)) +>t : Symbol(t, Decl(inferenceContextSensitiveDependentParameters1.ts, 84, 14)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 84, 8)) + +declare const FooFn: Fn; +>FooFn : Symbol(FooFn, Decl(inferenceContextSensitiveDependentParameters1.ts, 85, 13)) +>Fn : Symbol(Fn, Decl(inferenceContextSensitiveDependentParameters1.ts, 82, 1)) +>Foo : Symbol(Foo, Decl(inferenceContextSensitiveDependentParameters1.ts, 79, 1)) + +type Baz = >(arg: { +>Baz : Symbol(Baz, Decl(inferenceContextSensitiveDependentParameters1.ts, 85, 29)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 87, 12)) +>Base : Symbol(Base, Decl(inferenceContextSensitiveDependentParameters1.ts, 74, 2)) +>F : Symbol(F, Decl(inferenceContextSensitiveDependentParameters1.ts, 87, 27)) +>Fn : Symbol(Fn, Decl(inferenceContextSensitiveDependentParameters1.ts, 82, 1)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 87, 12)) +>arg : Symbol(arg, Decl(inferenceContextSensitiveDependentParameters1.ts, 87, 45)) + + x: (bar: Foo) => R; +>x : Symbol(x, Decl(inferenceContextSensitiveDependentParameters1.ts, 87, 51)) +>bar : Symbol(bar, Decl(inferenceContextSensitiveDependentParameters1.ts, 88, 6)) +>Foo : Symbol(Foo, Decl(inferenceContextSensitiveDependentParameters1.ts, 79, 1)) +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 87, 12)) + + y?: F[]; +>y : Symbol(y, Decl(inferenceContextSensitiveDependentParameters1.ts, 88, 21)) +>F : Symbol(F, Decl(inferenceContextSensitiveDependentParameters1.ts, 87, 27)) + +}) => R; +>R : Symbol(R, Decl(inferenceContextSensitiveDependentParameters1.ts, 87, 12)) + +declare const baz: Baz; +>baz : Symbol(baz, Decl(inferenceContextSensitiveDependentParameters1.ts, 92, 13)) +>Baz : Symbol(Baz, Decl(inferenceContextSensitiveDependentParameters1.ts, 85, 29)) + +const R1 = baz({ x: (ctx) => ctx }); +>R1 : Symbol(R1, Decl(inferenceContextSensitiveDependentParameters1.ts, 93, 5)) +>baz : Symbol(baz, Decl(inferenceContextSensitiveDependentParameters1.ts, 92, 13)) +>x : Symbol(x, Decl(inferenceContextSensitiveDependentParameters1.ts, 93, 16)) +>ctx : Symbol(ctx, Decl(inferenceContextSensitiveDependentParameters1.ts, 93, 21)) +>ctx : Symbol(ctx, Decl(inferenceContextSensitiveDependentParameters1.ts, 93, 21)) + +const R2 = baz({ x: (ctx) => ctx, y: [FooFn] }); +>R2 : Symbol(R2, Decl(inferenceContextSensitiveDependentParameters1.ts, 94, 5)) +>baz : Symbol(baz, Decl(inferenceContextSensitiveDependentParameters1.ts, 92, 13)) +>x : Symbol(x, Decl(inferenceContextSensitiveDependentParameters1.ts, 94, 16)) +>ctx : Symbol(ctx, Decl(inferenceContextSensitiveDependentParameters1.ts, 94, 21)) +>ctx : Symbol(ctx, Decl(inferenceContextSensitiveDependentParameters1.ts, 94, 21)) +>y : Symbol(y, Decl(inferenceContextSensitiveDependentParameters1.ts, 94, 33)) +>FooFn : Symbol(FooFn, Decl(inferenceContextSensitiveDependentParameters1.ts, 85, 13)) + +// https://github.com/microsoft/TypeScript/issues/55489 +type NonStringIterable = T extends string +>NonStringIterable : Symbol(NonStringIterable, Decl(inferenceContextSensitiveDependentParameters1.ts, 94, 48)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 97, 23)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 97, 23)) + + ? never + : T extends Iterable +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 97, 23)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + ? T +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 97, 23)) + + : never; + +declare function doSomething(value: NonStringIterable): T; +>doSomething : Symbol(doSomething, Decl(inferenceContextSensitiveDependentParameters1.ts, 101, 10)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 103, 29)) +>value : Symbol(value, Decl(inferenceContextSensitiveDependentParameters1.ts, 103, 32)) +>NonStringIterable : Symbol(NonStringIterable, Decl(inferenceContextSensitiveDependentParameters1.ts, 94, 48)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 103, 29)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 103, 29)) + +const o = { foo() {} }; +>o : Symbol(o, Decl(inferenceContextSensitiveDependentParameters1.ts, 105, 5)) +>foo : Symbol(foo, Decl(inferenceContextSensitiveDependentParameters1.ts, 105, 11)) + +doSomething("value"); // error +>doSomething : Symbol(doSomething, Decl(inferenceContextSensitiveDependentParameters1.ts, 101, 10)) + +doSomething(["v"]); +>doSomething : Symbol(doSomething, Decl(inferenceContextSensitiveDependentParameters1.ts, 101, 10)) + +doSomething([o]); +>doSomething : Symbol(doSomething, Decl(inferenceContextSensitiveDependentParameters1.ts, 101, 10)) +>o : Symbol(o, Decl(inferenceContextSensitiveDependentParameters1.ts, 105, 5)) + +doSomething([{ foo() {} }]); +>doSomething : Symbol(doSomething, Decl(inferenceContextSensitiveDependentParameters1.ts, 101, 10)) +>foo : Symbol(foo, Decl(inferenceContextSensitiveDependentParameters1.ts, 110, 14)) + +// https://github.com/microsoft/TypeScript/issues/55124 +type Values = T[keyof T]; +>Values : Symbol(Values, Decl(inferenceContextSensitiveDependentParameters1.ts, 110, 28)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 113, 12)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 113, 12)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 113, 12)) + +type ExtractFields = Values<{ +>ExtractFields : Symbol(ExtractFields, Decl(inferenceContextSensitiveDependentParameters1.ts, 113, 28)) +>Options : Symbol(Options, Decl(inferenceContextSensitiveDependentParameters1.ts, 114, 19)) +>Values : Symbol(Values, Decl(inferenceContextSensitiveDependentParameters1.ts, 110, 28)) + + [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never; +>K : Symbol(K, Decl(inferenceContextSensitiveDependentParameters1.ts, 115, 3)) +>Options : Symbol(Options, Decl(inferenceContextSensitiveDependentParameters1.ts, 114, 19)) +>Options : Symbol(Options, Decl(inferenceContextSensitiveDependentParameters1.ts, 114, 19)) +>K : Symbol(K, Decl(inferenceContextSensitiveDependentParameters1.ts, 115, 3)) +>Options : Symbol(Options, Decl(inferenceContextSensitiveDependentParameters1.ts, 114, 19)) +>K : Symbol(K, Decl(inferenceContextSensitiveDependentParameters1.ts, 115, 3)) + +}>; +type SetType = { +>SetType : Symbol(SetType, Decl(inferenceContextSensitiveDependentParameters1.ts, 116, 3)) +>Options : Symbol(Options, Decl(inferenceContextSensitiveDependentParameters1.ts, 117, 13)) + + [key: string]: any; +>key : Symbol(key, Decl(inferenceContextSensitiveDependentParameters1.ts, 118, 3)) + + target?: ExtractFields; +>target : Symbol(target, Decl(inferenceContextSensitiveDependentParameters1.ts, 118, 21)) +>ExtractFields : Symbol(ExtractFields, Decl(inferenceContextSensitiveDependentParameters1.ts, 113, 28)) +>Options : Symbol(Options, Decl(inferenceContextSensitiveDependentParameters1.ts, 117, 13)) + +}; + +declare function test55124>( +>test55124 : Symbol(test55124, Decl(inferenceContextSensitiveDependentParameters1.ts, 120, 2)) +>OptionsData : Symbol(OptionsData, Decl(inferenceContextSensitiveDependentParameters1.ts, 122, 27)) +>SetType : Symbol(SetType, Decl(inferenceContextSensitiveDependentParameters1.ts, 116, 3)) +>OptionsData : Symbol(OptionsData, Decl(inferenceContextSensitiveDependentParameters1.ts, 122, 27)) + + options: OptionsData, +>options : Symbol(options, Decl(inferenceContextSensitiveDependentParameters1.ts, 122, 69)) +>OptionsData : Symbol(OptionsData, Decl(inferenceContextSensitiveDependentParameters1.ts, 122, 27)) + +): void; + +test55124({ +>test55124 : Symbol(test55124, Decl(inferenceContextSensitiveDependentParameters1.ts, 120, 2)) + + target: "$test4", +>target : Symbol(target, Decl(inferenceContextSensitiveDependentParameters1.ts, 126, 11)) + + data1: { +>data1 : Symbol(data1, Decl(inferenceContextSensitiveDependentParameters1.ts, 127, 19)) + + $test1: 111, +>$test1 : Symbol($test1, Decl(inferenceContextSensitiveDependentParameters1.ts, 128, 10)) + + $test2: null, +>$test2 : Symbol($test2, Decl(inferenceContextSensitiveDependentParameters1.ts, 129, 16)) + + }, + data2: { +>data2 : Symbol(data2, Decl(inferenceContextSensitiveDependentParameters1.ts, 131, 4)) + + $test3: {}, +>$test3 : Symbol($test3, Decl(inferenceContextSensitiveDependentParameters1.ts, 132, 10)) + + $test4: () => {}, +>$test4 : Symbol($test4, Decl(inferenceContextSensitiveDependentParameters1.ts, 133, 15)) + + $test5() {}, +>$test5 : Symbol($test5, Decl(inferenceContextSensitiveDependentParameters1.ts, 134, 21)) + + }, +}); + +type SetType_2 = { +>SetType_2 : Symbol(SetType_2, Decl(inferenceContextSensitiveDependentParameters1.ts, 137, 3)) +>Options : Symbol(Options, Decl(inferenceContextSensitiveDependentParameters1.ts, 139, 15)) + + [key: `data${number}`]: Record void>; +>key : Symbol(key, Decl(inferenceContextSensitiveDependentParameters1.ts, 140, 3)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>arg : Symbol(arg, Decl(inferenceContextSensitiveDependentParameters1.ts, 140, 42)) + + target?: ExtractFields; +>target : Symbol(target, Decl(inferenceContextSensitiveDependentParameters1.ts, 140, 64)) +>ExtractFields : Symbol(ExtractFields, Decl(inferenceContextSensitiveDependentParameters1.ts, 113, 28)) +>Options : Symbol(Options, Decl(inferenceContextSensitiveDependentParameters1.ts, 139, 15)) + +}; + +declare function test55124_2>( +>test55124_2 : Symbol(test55124_2, Decl(inferenceContextSensitiveDependentParameters1.ts, 142, 2)) +>OptionsData : Symbol(OptionsData, Decl(inferenceContextSensitiveDependentParameters1.ts, 144, 29)) +>SetType_2 : Symbol(SetType_2, Decl(inferenceContextSensitiveDependentParameters1.ts, 137, 3)) +>OptionsData : Symbol(OptionsData, Decl(inferenceContextSensitiveDependentParameters1.ts, 144, 29)) + + options: OptionsData, +>options : Symbol(options, Decl(inferenceContextSensitiveDependentParameters1.ts, 144, 73)) +>OptionsData : Symbol(OptionsData, Decl(inferenceContextSensitiveDependentParameters1.ts, 144, 29)) + +): void; + +test55124_2({ +>test55124_2 : Symbol(test55124_2, Decl(inferenceContextSensitiveDependentParameters1.ts, 142, 2)) + + target: "$test4", +>target : Symbol(target, Decl(inferenceContextSensitiveDependentParameters1.ts, 148, 13)) + + data1: { +>data1 : Symbol(data1, Decl(inferenceContextSensitiveDependentParameters1.ts, 149, 19)) + + $test1: () => {}, +>$test1 : Symbol($test1, Decl(inferenceContextSensitiveDependentParameters1.ts, 150, 10)) + + $test2: () => {}, +>$test2 : Symbol($test2, Decl(inferenceContextSensitiveDependentParameters1.ts, 151, 21)) + + }, + data2: { +>data2 : Symbol(data2, Decl(inferenceContextSensitiveDependentParameters1.ts, 153, 4)) + + $test3: () => {}, +>$test3 : Symbol($test3, Decl(inferenceContextSensitiveDependentParameters1.ts, 154, 10)) + + $test4: () => {}, +>$test4 : Symbol($test4, Decl(inferenceContextSensitiveDependentParameters1.ts, 155, 21)) + + $test5: (arg) => {}, +>$test5 : Symbol($test5, Decl(inferenceContextSensitiveDependentParameters1.ts, 156, 21)) +>arg : Symbol(arg, Decl(inferenceContextSensitiveDependentParameters1.ts, 157, 13)) + + }, +}); + +// https://github.com/microsoft/TypeScript/issues/54438 +interface Entity { +>Entity : Symbol(Entity, Decl(inferenceContextSensitiveDependentParameters1.ts, 159, 3)) + + id: number; +>id : Symbol(Entity.id, Decl(inferenceContextSensitiveDependentParameters1.ts, 162, 18)) + + name: string; +>name : Symbol(Entity.name, Decl(inferenceContextSensitiveDependentParameters1.ts, 163, 13)) +} + +type Fn54438 = (params: Record) => T[]; +>Fn54438 : Symbol(Fn54438, Decl(inferenceContextSensitiveDependentParameters1.ts, 165, 1)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 167, 13)) +>params : Symbol(params, Decl(inferenceContextSensitiveDependentParameters1.ts, 167, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 167, 13)) + +declare function test54438(fn: Fn54438, key: K): T; +>test54438 : Symbol(test54438, Decl(inferenceContextSensitiveDependentParameters1.ts, 167, 59)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 169, 27)) +>K : Symbol(K, Decl(inferenceContextSensitiveDependentParameters1.ts, 169, 29)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 169, 27)) +>fn : Symbol(fn, Decl(inferenceContextSensitiveDependentParameters1.ts, 169, 49)) +>Fn54438 : Symbol(Fn54438, Decl(inferenceContextSensitiveDependentParameters1.ts, 165, 1)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 169, 27)) +>key : Symbol(key, Decl(inferenceContextSensitiveDependentParameters1.ts, 169, 64)) +>K : Symbol(K, Decl(inferenceContextSensitiveDependentParameters1.ts, 169, 29)) +>T : Symbol(T, Decl(inferenceContextSensitiveDependentParameters1.ts, 169, 27)) + +test54438(() => [] as Entity[], "id"); +>test54438 : Symbol(test54438, Decl(inferenceContextSensitiveDependentParameters1.ts, 167, 59)) +>Entity : Symbol(Entity, Decl(inferenceContextSensitiveDependentParameters1.ts, 159, 3)) + +test54438((params: Record) => [] as Entity[], "name"); +>test54438 : Symbol(test54438, Decl(inferenceContextSensitiveDependentParameters1.ts, 167, 59)) +>params : Symbol(params, Decl(inferenceContextSensitiveDependentParameters1.ts, 172, 11)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Entity : Symbol(Entity, Decl(inferenceContextSensitiveDependentParameters1.ts, 159, 3)) + +test54438((params: unknown) => [] as Entity[], "id"); +>test54438 : Symbol(test54438, Decl(inferenceContextSensitiveDependentParameters1.ts, 167, 59)) +>params : Symbol(params, Decl(inferenceContextSensitiveDependentParameters1.ts, 173, 11)) +>Entity : Symbol(Entity, Decl(inferenceContextSensitiveDependentParameters1.ts, 159, 3)) + +test54438((params) => [] as Entity[], "id"); +>test54438 : Symbol(test54438, Decl(inferenceContextSensitiveDependentParameters1.ts, 167, 59)) +>params : Symbol(params, Decl(inferenceContextSensitiveDependentParameters1.ts, 174, 11)) +>Entity : Symbol(Entity, Decl(inferenceContextSensitiveDependentParameters1.ts, 159, 3)) + +export declare const serve: (props: { +>serve : Symbol(serve, Decl(inferenceContextSensitiveDependentParameters1.ts, 176, 20)) +>Req : Symbol(Req, Decl(inferenceContextSensitiveDependentParameters1.ts, 176, 29)) +>props : Symbol(props, Decl(inferenceContextSensitiveDependentParameters1.ts, 176, 34)) + + bindings: Extract, string>; +>bindings : Symbol(bindings, Decl(inferenceContextSensitiveDependentParameters1.ts, 176, 42)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>NoInfer : Symbol(NoInfer, Decl(lib.es5.d.ts, --, --)) +>Req : Symbol(Req, Decl(inferenceContextSensitiveDependentParameters1.ts, 176, 29)) + + fetch: (event: unknown) => Generator; +>fetch : Symbol(fetch, Decl(inferenceContextSensitiveDependentParameters1.ts, 177, 42)) +>event : Symbol(event, Decl(inferenceContextSensitiveDependentParameters1.ts, 178, 10)) +>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --)) +>Req : Symbol(Req, Decl(inferenceContextSensitiveDependentParameters1.ts, 176, 29)) + +}) => unknown; + +declare const bar: () => Generator<"SendMessage">; +>bar : Symbol(bar, Decl(inferenceContextSensitiveDependentParameters1.ts, 181, 13)) +>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --)) + +serve({ +>serve : Symbol(serve, Decl(inferenceContextSensitiveDependentParameters1.ts, 176, 20)) + + bindings: "SendMessage" as const, +>bindings : Symbol(bindings, Decl(inferenceContextSensitiveDependentParameters1.ts, 183, 7)) +>const : Symbol(const) + + fetch: function* (a) { +>fetch : Symbol(fetch, Decl(inferenceContextSensitiveDependentParameters1.ts, 184, 35)) +>a : Symbol(a, Decl(inferenceContextSensitiveDependentParameters1.ts, 185, 20)) + + yield* bar(); +>bar : Symbol(bar, Decl(inferenceContextSensitiveDependentParameters1.ts, 181, 13)) + + }, +}); diff --git a/tests/baselines/reference/inferenceContextSensitiveDependentParameters1.types b/tests/baselines/reference/inferenceContextSensitiveDependentParameters1.types new file mode 100644 index 0000000000000..155029bceb6b3 --- /dev/null +++ b/tests/baselines/reference/inferenceContextSensitiveDependentParameters1.types @@ -0,0 +1,759 @@ +//// [tests/cases/compiler/inferenceContextSensitiveDependentParameters1.ts] //// + +=== Performance Stats === +Type Count: 2,500 +Instantiation count: 2,500 + +=== inferenceContextSensitiveDependentParameters1.ts === +// https://github.com/microsoft/TypeScript/issues/62204 + +declare function TestConfig< +>TestConfig : (config: TConfig, test: keyof Omit extends never ? true : false) => void +> : ^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ + + const TConfig extends { a?: any; b?: any; c?: any }, +>a : any +> : ^^^ +>b : any +> : ^^^ +>c : any +> : ^^^ + +>( + config: TConfig, +>config : TConfig +> : ^^^^^^^ + + test: keyof Omit extends never ? true : false, +>test : Exclude extends never ? true : false +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>true : true +> : ^^^^ +>false : false +> : ^^^^^ + +): void; + +TestConfig( +>TestConfig( { a: "hello", b: function () { return "123"; }, }, true,) : void +> : ^^^^ +>TestConfig : (config: TConfig, test: keyof Omit extends never ? true : false) => void +> : ^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ + { +>{ a: "hello", b: function () { return "123"; }, } : { a: "hello"; b: () => "123"; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + a: "hello", +>a : "hello" +> : ^^^^^^^ +>"hello" : "hello" +> : ^^^^^^^ + + b: function () { +>b : () => "123" +> : ^^^^^^^^^^^ +>function () { return "123"; } : () => "123" +> : ^^^^^^^^^^^ + + return "123"; +>"123" : "123" +> : ^^^^^ + + }, + }, + true, +>true : true +> : ^^^^ + +); + +declare function TestConfig_2< +>TestConfig_2 : unknown; c?: any; }>(config: TConfig, test: keyof Omit extends never ? true : false) => void +> : ^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ + + const TConfig extends { a?: any; b?: (arg: number) => unknown; c?: any }, +>a : any +> : ^^^ +>b : ((arg: number) => unknown) | undefined +> : ^^ ^^ ^^^^^ ^^^^^^^^^^^^^ +>arg : number +> : ^^^^^^ +>c : any +> : ^^^ + +>( + config: TConfig, +>config : TConfig +> : ^^^^^^^ + + test: keyof Omit extends never ? true : false, +>test : Exclude extends never ? true : false +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>true : true +> : ^^^^ +>false : false +> : ^^^^^ + +): void; + +TestConfig_2( +>TestConfig_2( { a: "hello", b: (arg) => { return "123"; }, }, true,) : void +> : ^^^^ +>TestConfig_2 : unknown; c?: any; }>(config: TConfig, test: keyof Omit extends never ? true : false) => void +> : ^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ + { +>{ a: "hello", b: (arg) => { return "123"; }, } : { a: "hello"; b: (arg: number) => string; } +> : ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ + + a: "hello", +>a : "hello" +> : ^^^^^^^ +>"hello" : "hello" +> : ^^^^^^^ + + b: (arg) => { +>b : (arg: number) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>(arg) => { return "123"; } : (arg: number) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>arg : number +> : ^^^^^^ + + return "123"; +>"123" : "123" +> : ^^^^^ + + }, + }, + true, +>true : true +> : ^^^^ + +); + +// https://github.com/microsoft/TypeScript/issues/47599#issuecomment-2919401231 +type KeysMatchingType = { +>KeysMatchingType : KeysMatchingType +> : ^^^^^^^^^^^^^^^^^^^^^^ + + [K in keyof T]: T[K] extends V ? K : never; +}[keyof T]; +type ExtractItems = R[IK] extends readonly (infer T)[] +>ExtractItems : ExtractItems +> : ^^^^^^^^^^^^^^^^^^^ + + ? T + : never; +type StreamPaginatedDataProps = { +>StreamPaginatedDataProps : StreamPaginatedDataProps +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + callback: (limit: number, offset: number) => Promise; +>callback : (limit: number, offset: number) => Promise +> : ^ ^^ ^^ ^^ ^^^^^ +>limit : number +> : ^^^^^^ +>offset : number +> : ^^^^^^ + + responseKeys: { items: IK; total: TK }; +>responseKeys : { items: IK; total: TK; } +> : ^^^^^^^^^ ^^^^^^^^^ ^^^ +>items : IK +> : ^^ +>total : TK +> : ^^ + + limit?: number; +>limit : number | undefined +> : ^^^^^^^^^^^^^^^^^^ + +}; + +declare function streamPaginatedData< +>streamPaginatedData : , const TK extends KeysMatchingType>({ callback, responseKeys, limit, }: StreamPaginatedDataProps) => AsyncGenerator, void, unknown> +> : ^ ^^^^^^^^ ^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^^^^ + + R, + const IK extends KeysMatchingType, + const TK extends KeysMatchingType, +>({ + callback, +>callback : (limit: number, offset: number) => Promise +> : ^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^ + + responseKeys, +>responseKeys : { items: IK; total: TK; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + limit, +>limit : number | undefined +> : ^^^^^^^^^^^^^^^^^^ + +}: StreamPaginatedDataProps): AsyncGenerator< + ExtractItems, + void, + unknown +>; + +const sampleData = [ +>sampleData : readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[ { location: { name: "New York" } }, { location: { name: "Tokyo" } },] as const : readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[ { location: { name: "New York" } }, { location: { name: "Tokyo" } },] : readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + { location: { name: "New York" } }, +>{ location: { name: "New York" } } : { readonly location: { readonly name: "New York"; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>location : { readonly name: "New York"; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ name: "New York" } : { readonly name: "New York"; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>name : "New York" +> : ^^^^^^^^^^ +>"New York" : "New York" +> : ^^^^^^^^^^ + + { location: { name: "Tokyo" } }, +>{ location: { name: "Tokyo" } } : { readonly location: { readonly name: "Tokyo"; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>location : { readonly name: "Tokyo"; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ name: "Tokyo" } : { readonly name: "Tokyo"; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>name : "Tokyo" +> : ^^^^^^^ +>"Tokyo" : "Tokyo" +> : ^^^^^^^ + +] as const; + +streamPaginatedData({ +>streamPaginatedData({ callback: async (a, b) => ({ someCount: sampleData.length, abra: sampleData, }), responseKeys: { total: "someCount", items: "abra" },}) : AsyncGenerator<{ readonly location: { readonly name: "New York"; }; } | { readonly location: { readonly name: "Tokyo"; }; }, void, unknown> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>streamPaginatedData : , const TK extends KeysMatchingType>({ callback, responseKeys, limit, }: StreamPaginatedDataProps) => AsyncGenerator, void, unknown> +> : ^ ^^^^^^^^ ^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>{ callback: async (a, b) => ({ someCount: sampleData.length, abra: sampleData, }), responseKeys: { total: "someCount", items: "abra" },} : { callback: (a: number, b: number) => Promise<{ someCount: 2; abra: readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }]; }>; responseKeys: { total: "someCount"; items: "abra"; }; } +> : ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + callback: async (a, b) => ({ +>callback : (a: number, b: number) => Promise<{ someCount: 2; abra: readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }]; }> +> : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>async (a, b) => ({ someCount: sampleData.length, abra: sampleData, }) : (a: number, b: number) => Promise<{ someCount: 2; abra: readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }]; }> +> : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>a : number +> : ^^^^^^ +>b : number +> : ^^^^^^ +>({ someCount: sampleData.length, abra: sampleData, }) : { someCount: 2; abra: readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }]; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ someCount: sampleData.length, abra: sampleData, } : { someCount: 2; abra: readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }]; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + someCount: sampleData.length, +>someCount : 2 +> : ^ +>sampleData.length : 2 +> : ^ +>sampleData : readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>length : 2 +> : ^ + + abra: sampleData, +>abra : readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>sampleData : readonly [{ readonly location: { readonly name: "New York"; }; }, { readonly location: { readonly name: "Tokyo"; }; }] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + }), + responseKeys: { total: "someCount", items: "abra" }, +>responseKeys : { total: "someCount"; items: "abra"; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ total: "someCount", items: "abra" } : { total: "someCount"; items: "abra"; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>total : "someCount" +> : ^^^^^^^^^^^ +>"someCount" : "someCount" +> : ^^^^^^^^^^^ +>items : "abra" +> : ^^^^^^ +>"abra" : "abra" +> : ^^^^^^ + +}) + +// https://github.com/microsoft/TypeScript/issues/47599#issuecomment-2132658606 +interface Base { + x: string; +>x : string +> : ^^^^^^ +} +interface Foo extends Base { + y: number; +>y : number +> : ^^^^^^ +} + +type Fn = (t: T) => void; +>Fn : Fn +> : ^^^^^ +>t : T +> : ^ + +declare const FooFn: Fn; +>FooFn : Fn +> : ^^^^^^^ + +type Baz = >(arg: { +>Baz : Baz +> : ^^^ +>arg : { x: (bar: Foo) => R; y?: F[]; } +> : ^^^^^ ^^^^^^ ^^^ + + x: (bar: Foo) => R; +>x : (bar: Foo) => R +> : ^ ^^ ^^^^^ +>bar : Foo +> : ^^^ + + y?: F[]; +>y : F[] | undefined +> : ^^^^^^^^^^^^^^^ + +}) => R; + +declare const baz: Baz; +>baz : Baz +> : ^^^ + +const R1 = baz({ x: (ctx) => ctx }); +>R1 : Foo +> : ^^^ +>baz({ x: (ctx) => ctx }) : Foo +> : ^^^ +>baz : Baz +> : ^^^ +>{ x: (ctx) => ctx } : { x: (ctx: Foo) => Foo; } +> : ^^^^^^ ^^^^^^^^^^^^^^^^ +>x : (ctx: Foo) => Foo +> : ^ ^^^^^^^^^^^^^ +>(ctx) => ctx : (ctx: Foo) => Foo +> : ^ ^^^^^^^^^^^^^ +>ctx : Foo +> : ^^^ +>ctx : Foo +> : ^^^ + +const R2 = baz({ x: (ctx) => ctx, y: [FooFn] }); +>R2 : Foo +> : ^^^ +>baz({ x: (ctx) => ctx, y: [FooFn] }) : Foo +> : ^^^ +>baz : Baz +> : ^^^ +>{ x: (ctx) => ctx, y: [FooFn] } : { x: (ctx: Foo) => Foo; y: Fn[]; } +> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>x : (ctx: Foo) => Foo +> : ^ ^^^^^^^^^^^^^ +>(ctx) => ctx : (ctx: Foo) => Foo +> : ^ ^^^^^^^^^^^^^ +>ctx : Foo +> : ^^^ +>ctx : Foo +> : ^^^ +>y : Fn[] +> : ^^^^^^^^^ +>[FooFn] : Fn[] +> : ^^^^^^^^^ +>FooFn : Fn +> : ^^^^^^^ + +// https://github.com/microsoft/TypeScript/issues/55489 +type NonStringIterable = T extends string +>NonStringIterable : NonStringIterable +> : ^^^^^^^^^^^^^^^^^^^^ + + ? never + : T extends Iterable + ? T + : never; + +declare function doSomething(value: NonStringIterable): T; +>doSomething : (value: NonStringIterable) => T +> : ^ ^^ ^^ ^^^^^ +>value : NonStringIterable +> : ^^^^^^^^^^^^^^^^^^^^ + +const o = { foo() {} }; +>o : { foo(): void; } +> : ^^^^^^^^^^^^^^^^ +>{ foo() {} } : { foo(): void; } +> : ^^^^^^^^^^^^^^^^ +>foo : () => void +> : ^^^^^^^^^^ + +doSomething("value"); // error +>doSomething("value") : "value" +> : ^^^^^^^ +>doSomething : (value: NonStringIterable) => T +> : ^ ^^ ^^ ^^^^^ +>"value" : "value" +> : ^^^^^^^ + +doSomething(["v"]); +>doSomething(["v"]) : string[] +> : ^^^^^^^^ +>doSomething : (value: NonStringIterable) => T +> : ^ ^^ ^^ ^^^^^ +>["v"] : string[] +> : ^^^^^^^^ +>"v" : "v" +> : ^^^ + +doSomething([o]); +>doSomething([o]) : { foo(): void; }[] +> : ^^^^^^^^^^^^^^^^^^ +>doSomething : (value: NonStringIterable) => T +> : ^ ^^ ^^ ^^^^^ +>[o] : { foo(): void; }[] +> : ^^^^^^^^^^^^^^^^^^ +>o : { foo(): void; } +> : ^^^^^^^^^^^^^^^^ + +doSomething([{ foo() {} }]); +>doSomething([{ foo() {} }]) : { foo(): void; }[] +> : ^^^^^^^^^^^^^^^^^^ +>doSomething : (value: NonStringIterable) => T +> : ^ ^^ ^^ ^^^^^ +>[{ foo() {} }] : { foo(): void; }[] +> : ^^^^^^^^^^^^^^^^^^ +>{ foo() {} } : { foo(): void; } +> : ^^^^^^^^^^^^^^^^ +>foo : () => void +> : ^^^^^^^^^^ + +// https://github.com/microsoft/TypeScript/issues/55124 +type Values = T[keyof T]; +>Values : Values +> : ^^^^^^^^^ + +type ExtractFields = Values<{ +>ExtractFields : ExtractFields +> : ^^^^^^^^^^^^^^^^^^^^^^ + + [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never; +}>; +type SetType = { +>SetType : SetType +> : ^^^^^^^^^^^^^^^^ + + [key: string]: any; +>key : string +> : ^^^^^^ + + target?: ExtractFields; +>target : ExtractFields | undefined +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +}; + +declare function test55124>( +>test55124 : >(options: OptionsData) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ + + options: OptionsData, +>options : OptionsData +> : ^^^^^^^^^^^ + +): void; + +test55124({ +>test55124({ target: "$test4", data1: { $test1: 111, $test2: null, }, data2: { $test3: {}, $test4: () => {}, $test5() {}, },}) : void +> : ^^^^ +>test55124 : >(options: OptionsData) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>{ target: "$test4", data1: { $test1: 111, $test2: null, }, data2: { $test3: {}, $test4: () => {}, $test5() {}, },} : { target: "$test4"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + target: "$test4", +>target : "$test4" +> : ^^^^^^^^ +>"$test4" : "$test4" +> : ^^^^^^^^ + + data1: { +>data1 : { $test1: number; $test2: null; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ $test1: 111, $test2: null, } : { $test1: number; $test2: null; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + $test1: 111, +>$test1 : number +> : ^^^^^^ +>111 : 111 +> : ^^^ + + $test2: null, +>$test2 : null +> : ^^^^ + + }, + data2: { +>data2 : { $test3: {}; $test4: () => void; $test5(): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ $test3: {}, $test4: () => {}, $test5() {}, } : { $test3: {}; $test4: () => void; $test5(): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + $test3: {}, +>$test3 : {} +> : ^^ +>{} : {} +> : ^^ + + $test4: () => {}, +>$test4 : () => void +> : ^^^^^^^^^^ +>() => {} : () => void +> : ^^^^^^^^^^ + + $test5() {}, +>$test5 : () => void +> : ^^^^^^^^^^ + + }, +}); + +type SetType_2 = { +>SetType_2 : SetType_2 +> : ^^^^^^^^^^^^^^^^^^ + + [key: `data${number}`]: Record void>; +>key : `data${number}` +> : ^^^^^^^^^^^^^^^ +>arg : number +> : ^^^^^^ + + target?: ExtractFields; +>target : ExtractFields | undefined +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +}; + +declare function test55124_2>( +>test55124_2 : >(options: OptionsData) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ + + options: OptionsData, +>options : OptionsData +> : ^^^^^^^^^^^ + +): void; + +test55124_2({ +>test55124_2({ target: "$test4", data1: { $test1: () => {}, $test2: () => {}, }, data2: { $test3: () => {}, $test4: () => {}, $test5: (arg) => {}, },}) : void +> : ^^^^ +>test55124_2 : >(options: OptionsData) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>{ target: "$test4", data1: { $test1: () => {}, $test2: () => {}, }, data2: { $test3: () => {}, $test4: () => {}, $test5: (arg) => {}, },} : { target: "$test4"; data1: { $test1: () => void; $test2: () => void; }; data2: { $test3: () => void; $test4: () => void; $test5: (arg: number) => void; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ + + target: "$test4", +>target : "$test4" +> : ^^^^^^^^ +>"$test4" : "$test4" +> : ^^^^^^^^ + + data1: { +>data1 : { $test1: () => void; $test2: () => void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ $test1: () => {}, $test2: () => {}, } : { $test1: () => void; $test2: () => void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + $test1: () => {}, +>$test1 : () => void +> : ^^^^^^^^^^ +>() => {} : () => void +> : ^^^^^^^^^^ + + $test2: () => {}, +>$test2 : () => void +> : ^^^^^^^^^^ +>() => {} : () => void +> : ^^^^^^^^^^ + + }, + data2: { +>data2 : { $test3: () => void; $test4: () => void; $test5: (arg: number) => void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ +>{ $test3: () => {}, $test4: () => {}, $test5: (arg) => {}, } : { $test3: () => void; $test4: () => void; $test5: (arg: number) => void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ + + $test3: () => {}, +>$test3 : () => void +> : ^^^^^^^^^^ +>() => {} : () => void +> : ^^^^^^^^^^ + + $test4: () => {}, +>$test4 : () => void +> : ^^^^^^^^^^ +>() => {} : () => void +> : ^^^^^^^^^^ + + $test5: (arg) => {}, +>$test5 : (arg: number) => void +> : ^ ^^^^^^^^^^^^^^^^^ +>(arg) => {} : (arg: number) => void +> : ^ ^^^^^^^^^^^^^^^^^ +>arg : number +> : ^^^^^^ + + }, +}); + +// https://github.com/microsoft/TypeScript/issues/54438 +interface Entity { + id: number; +>id : number +> : ^^^^^^ + + name: string; +>name : string +> : ^^^^^^ +} + +type Fn54438 = (params: Record) => T[]; +>Fn54438 : Fn54438 +> : ^^^^^^^^^^ +>params : Record +> : ^^^^^^^^^^^^^^^^^^^^^^^ + +declare function test54438(fn: Fn54438, key: K): T; +>test54438 : (fn: Fn54438, key: K) => T +> : ^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>fn : Fn54438 +> : ^^^^^^^^^^ +>key : K +> : ^ + +test54438(() => [] as Entity[], "id"); +>test54438(() => [] as Entity[], "id") : Entity +> : ^^^^^^ +>test54438 : (fn: Fn54438, key: K) => T +> : ^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>() => [] as Entity[] : () => Entity[] +> : ^^^^^^ +>[] as Entity[] : Entity[] +> : ^^^^^^^^ +>[] : never[] +> : ^^^^^^^ +>"id" : "id" +> : ^^^^ + +test54438((params: Record) => [] as Entity[], "name"); +>test54438((params: Record) => [] as Entity[], "name") : Entity +> : ^^^^^^ +>test54438 : (fn: Fn54438, key: K) => T +> : ^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>(params: Record) => [] as Entity[] : (params: Record) => Entity[] +> : ^ ^^ ^^^^^ +>params : Record +> : ^^^^^^^^^^^^^^^^^^^^^^^ +>[] as Entity[] : Entity[] +> : ^^^^^^^^ +>[] : never[] +> : ^^^^^^^ +>"name" : "name" +> : ^^^^^^ + +test54438((params: unknown) => [] as Entity[], "id"); +>test54438((params: unknown) => [] as Entity[], "id") : Entity +> : ^^^^^^ +>test54438 : (fn: Fn54438, key: K) => T +> : ^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>(params: unknown) => [] as Entity[] : (params: unknown) => Entity[] +> : ^ ^^ ^^^^^ +>params : unknown +> : ^^^^^^^ +>[] as Entity[] : Entity[] +> : ^^^^^^^^ +>[] : never[] +> : ^^^^^^^ +>"id" : "id" +> : ^^^^ + +test54438((params) => [] as Entity[], "id"); +>test54438((params) => [] as Entity[], "id") : Entity +> : ^^^^^^ +>test54438 : (fn: Fn54438, key: K) => T +> : ^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>(params) => [] as Entity[] : (params: Record) => Entity[] +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>params : Record +> : ^^^^^^^^^^^^^^^^^^^^^^^ +>[] as Entity[] : Entity[] +> : ^^^^^^^^ +>[] : never[] +> : ^^^^^^^ +>"id" : "id" +> : ^^^^ + +export declare const serve: (props: { +>serve : (props: { bindings: Extract, string>; fetch: (event: unknown) => Generator; }) => unknown +> : ^ ^^ ^^ ^^^^^ +>props : { bindings: Extract, string>; fetch: (event: unknown) => Generator; } +> : ^^^^^^^^^^^^ ^^^^^^^^^ ^^^ + + bindings: Extract, string>; +>bindings : Extract, string> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + fetch: (event: unknown) => Generator; +>fetch : (event: unknown) => Generator +> : ^ ^^ ^^^^^ +>event : unknown +> : ^^^^^^^ + +}) => unknown; + +declare const bar: () => Generator<"SendMessage">; +>bar : () => Generator<"SendMessage"> +> : ^^^^^^ + +serve({ +>serve({ bindings: "SendMessage" as const, fetch: function* (a) { yield* bar(); },}) : unknown +> : ^^^^^^^ +>serve : (props: { bindings: Extract, string>; fetch: (event: unknown) => Generator; }) => unknown +> : ^ ^^ ^^ ^^^^^ +>{ bindings: "SendMessage" as const, fetch: function* (a) { yield* bar(); },} : { bindings: "SendMessage"; fetch: (a: unknown) => Generator<"SendMessage", void, any>; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + bindings: "SendMessage" as const, +>bindings : "SendMessage" +> : ^^^^^^^^^^^^^ +>"SendMessage" as const : "SendMessage" +> : ^^^^^^^^^^^^^ +>"SendMessage" : "SendMessage" +> : ^^^^^^^^^^^^^ + + fetch: function* (a) { +>fetch : (a: unknown) => Generator<"SendMessage", void, any> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function* (a) { yield* bar(); } : (a: unknown) => Generator<"SendMessage", void, any> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>a : unknown +> : ^^^^^^^ + + yield* bar(); +>yield* bar() : any +> : ^^^ +>bar() : Generator<"SendMessage", any, any> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>bar : () => Generator<"SendMessage"> +> : ^^^^^^ + + }, +}); diff --git a/tests/cases/compiler/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts b/tests/cases/compiler/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts new file mode 100644 index 0000000000000..61cf2c37c233a --- /dev/null +++ b/tests/cases/compiler/contextualTypesNegatedTypeLikeConstraintInGenericMappedType4.ts @@ -0,0 +1,41 @@ +// @strict: true +// @noEmit: true + +// based on https://github.com/microsoft/TypeScript/issues/51831 + +type NoMatchAll = Exclude +type Union = { + [P in keyof T]: ({ [Q in "kind"]: P } & T[P]) extends infer U ? { [Q in keyof U]: U[Q] } : never +}[keyof T] +type UnionMap = { [K in U["kind"]]: U extends { kind: K } ? U : never } +type ExhaustivePattern = { [K in T["kind"] as NoMatchAll]: (union: UnionMap[K]) => R }; +type NonExhaustivePattern = { [K in T["kind"] as NoMatchAll]?: (union: UnionMap[K]) => R } & {_: (union: T) => R}; +type Pattern = ExhaustivePattern | NonExhaustivePattern; + +function match(union: U, pattern: Pattern): T { + if((pattern as any)[union.kind]) { + return (pattern as any)[union.kind](union as U) as T + } + return (pattern as any)["_"](union as U) as T +} + +type ValueType = Union<{ + String: {value: string}, + Number: {value: number}, + Boolean: {value: boolean}, + Date: {value: Date} +}> + +function main(value: ValueType) { + let test1 = match(value, { + String: ({value}) => value, + Number: ({value}) => value.toString(), + _: (token) => "Unknown" + }); + + let test2 = match(value, { + String: ({value}) => value, + Number: ({value}) => value.toString(), + _: (token) => "Unknown" + }); +} diff --git a/tests/cases/compiler/inferenceContextSensitiveDependentParameters1.ts b/tests/cases/compiler/inferenceContextSensitiveDependentParameters1.ts new file mode 100644 index 0000000000000..a9fef05920a2b --- /dev/null +++ b/tests/cases/compiler/inferenceContextSensitiveDependentParameters1.ts @@ -0,0 +1,193 @@ +// @strict: true +// @target: esnext +// @noEmit: true + +// https://github.com/microsoft/TypeScript/issues/62204 + +declare function TestConfig< + const TConfig extends { a?: any; b?: any; c?: any }, +>( + config: TConfig, + test: keyof Omit extends never ? true : false, +): void; + +TestConfig( + { + a: "hello", + b: function () { + return "123"; + }, + }, + true, +); + +declare function TestConfig_2< + const TConfig extends { a?: any; b?: (arg: number) => unknown; c?: any }, +>( + config: TConfig, + test: keyof Omit extends never ? true : false, +): void; + +TestConfig_2( + { + a: "hello", + b: (arg) => { + return "123"; + }, + }, + true, +); + +// https://github.com/microsoft/TypeScript/issues/47599#issuecomment-2919401231 +type KeysMatchingType = { + [K in keyof T]: T[K] extends V ? K : never; +}[keyof T]; +type ExtractItems = R[IK] extends readonly (infer T)[] + ? T + : never; +type StreamPaginatedDataProps = { + callback: (limit: number, offset: number) => Promise; + responseKeys: { items: IK; total: TK }; + limit?: number; +}; + +declare function streamPaginatedData< + R, + const IK extends KeysMatchingType, + const TK extends KeysMatchingType, +>({ + callback, + responseKeys, + limit, +}: StreamPaginatedDataProps): AsyncGenerator< + ExtractItems, + void, + unknown +>; + +const sampleData = [ + { location: { name: "New York" } }, + { location: { name: "Tokyo" } }, +] as const; + +streamPaginatedData({ + callback: async (a, b) => ({ + someCount: sampleData.length, + abra: sampleData, + }), + responseKeys: { total: "someCount", items: "abra" }, +}) + +// https://github.com/microsoft/TypeScript/issues/47599#issuecomment-2132658606 +interface Base { + x: string; +} +interface Foo extends Base { + y: number; +} + +type Fn = (t: T) => void; +declare const FooFn: Fn; + +type Baz = >(arg: { + x: (bar: Foo) => R; + y?: F[]; +}) => R; + +declare const baz: Baz; +const R1 = baz({ x: (ctx) => ctx }); +const R2 = baz({ x: (ctx) => ctx, y: [FooFn] }); + +// https://github.com/microsoft/TypeScript/issues/55489 +type NonStringIterable = T extends string + ? never + : T extends Iterable + ? T + : never; + +declare function doSomething(value: NonStringIterable): T; + +const o = { foo() {} }; + +doSomething("value"); // error +doSomething(["v"]); +doSomething([o]); +doSomething([{ foo() {} }]); + +// https://github.com/microsoft/TypeScript/issues/55124 +type Values = T[keyof T]; +type ExtractFields = Values<{ + [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never; +}>; +type SetType = { + [key: string]: any; + target?: ExtractFields; +}; + +declare function test55124>( + options: OptionsData, +): void; + +test55124({ + target: "$test4", + data1: { + $test1: 111, + $test2: null, + }, + data2: { + $test3: {}, + $test4: () => {}, + $test5() {}, + }, +}); + +type SetType_2 = { + [key: `data${number}`]: Record void>; + target?: ExtractFields; +}; + +declare function test55124_2>( + options: OptionsData, +): void; + +test55124_2({ + target: "$test4", + data1: { + $test1: () => {}, + $test2: () => {}, + }, + data2: { + $test3: () => {}, + $test4: () => {}, + $test5: (arg) => {}, + }, +}); + +// https://github.com/microsoft/TypeScript/issues/54438 +interface Entity { + id: number; + name: string; +} + +type Fn54438 = (params: Record) => T[]; + +declare function test54438(fn: Fn54438, key: K): T; + +test54438(() => [] as Entity[], "id"); +test54438((params: Record) => [] as Entity[], "name"); +test54438((params: unknown) => [] as Entity[], "id"); +test54438((params) => [] as Entity[], "id"); + +export declare const serve: (props: { + bindings: Extract, string>; + fetch: (event: unknown) => Generator; +}) => unknown; + +declare const bar: () => Generator<"SendMessage">; + +serve({ + bindings: "SendMessage" as const, + fetch: function* (a) { + yield* bar(); + }, +}); \ No newline at end of file