Skip to content

Commit 0fd66de

Browse files
AndaristAndarist
committed
address PR feedback
1 parent 9a78b3d commit 0fd66de

24 files changed

Lines changed: 130 additions & 130 deletions

‎src/compiler/checker.ts‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -6959,12 +6959,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
69596959

69606960
function createMappedTypeNodeFromType(type: MappedType) {
69616961
Debug.assert(!!(type.flags & TypeFlags.Object));
6962+
const cleanup = enterNewScope(context, type.declaration, /*expandedParams*/ undefined, [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(type.declaration.typeParameter))]);
69626963
const readonlyToken = type.declaration.readonlyToken ? factory.createToken(type.declaration.readonlyToken.kind) as ReadonlyKeyword | PlusToken | MinusToken : undefined;
69636964
const questionToken = type.declaration.questionToken ? factory.createToken(type.declaration.questionToken.kind) as QuestionToken | PlusToken | MinusToken : undefined;
69646965
let appropriateConstraintTypeNode: TypeNode;
69656966
let newTypeVariable: TypeReferenceNode | undefined;
69666967
let templateType = getTemplateTypeFromMappedType(type);
6967-
let typeParameter = getTypeParameterFromMappedType(type);
6968+
const typeParameter = getTypeParameterFromMappedType(type);
69686969
// If the mapped type isn't `keyof` constraint-declared, _but_ still has modifiers preserved, and its naive instantiation won't preserve modifiers because its constraint isn't `keyof` constrained, we have work to do
69696970
const needsModifierPreservingWrapper = !isMappedTypeWithKeyofConstraintDeclaration(type)
69706971
&& !(getModifiersTypeFromMappedType(type).flags & TypeFlags.Unknown)
@@ -6975,14 +6976,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
69756976
// We do this to ensure we retain the toplevel keyof-ness of the type which may be lost due to keyof distribution during `getConstraintTypeFromMappedType`
69766977
if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams) {
69776978
const newConstraintParam = createTypeParameter(createSymbol(SymbolFlags.TypeParameter, "T" as __String));
6978-
const newTypeParam = cloneTypeParameter(typeParameter);
69796979
const name = typeParameterToName(newConstraintParam, context);
69806980
const target = type.target as MappedType;
6981-
typeParameter = newTypeParam;
69826981
newTypeVariable = factory.createTypeReferenceNode(name);
69836982
templateType = instantiateType(
69846983
getTemplateTypeFromMappedType(target),
6985-
makeArrayTypeMapper([getTypeParameterFromMappedType(target), getModifiersTypeFromMappedType(target)], [newTypeParam, newConstraintParam]),
6984+
makeArrayTypeMapper([getTypeParameterFromMappedType(target), getModifiersTypeFromMappedType(target)], [typeParameter, newConstraintParam]),
69866985
);
69876986
}
69886987
appropriateConstraintTypeNode = factory.createTypeOperatorNode(SyntaxKind.KeyOfKeyword, newTypeVariable || typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context));
@@ -7003,13 +7002,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
70037002
const templateTypeNode = typeToTypeNodeHelper(removeMissingType(templateType, !!(getMappedTypeModifiers(type) & MappedTypeModifiers.IncludeOptional)), context);
70047003
const mappedTypeNode = factory.createMappedTypeNode(readonlyToken, typeParameterNode, nameTypeNode, questionToken, templateTypeNode, /*members*/ undefined);
70057004
context.approximateLength += 10;
7006-
const result = setEmitFlags(mappedTypeNode, EmitFlags.SingleLine);
7005+
let result: TypeNode = setEmitFlags(mappedTypeNode, EmitFlags.SingleLine);
70077006
if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams) {
70087007
// homomorphic mapped type with a non-homomorphic naive inlining
70097008
// wrap it with a conditional like `SomeModifiersType extends infer U ? {..the mapped type...} : never` to ensure the resulting
70107009
// type stays homomorphic
70117010
const originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode(context, (type.declaration.typeParameter.constraint! as TypeOperatorNode).type) as TypeParameter) || unknownType, type.mapper);
7012-
return factory.createConditionalTypeNode(
7011+
result = factory.createConditionalTypeNode(
70137012
typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context),
70147013
factory.createInferTypeNode(factory.createTypeParameterDeclaration(/*modifiers*/ undefined, factory.cloneNode(newTypeVariable!.typeName) as Identifier, originalConstraint.flags & TypeFlags.Unknown ? undefined : typeToTypeNodeHelper(originalConstraint, context))),
70157014
result,
@@ -7021,13 +7020,14 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
70217020
// subtly different from the `keyof` constraint case, by including the `keyof` constraint on the `infer` type parameter, it doesn't rely on the constraint type being itself
70227021
// constrained to a `keyof` type to preserve its modifier-preserving behavior. This is all basically because we preserve modifiers for a wider set of mapped types than
70237022
// just homomorphic ones.
7024-
return factory.createConditionalTypeNode(
7023+
result = factory.createConditionalTypeNode(
70257024
typeToTypeNodeHelper(getConstraintTypeFromMappedType(type), context),
70267025
factory.createInferTypeNode(factory.createTypeParameterDeclaration(/*modifiers*/ undefined, factory.cloneNode(newTypeVariable!.typeName) as Identifier, factory.createTypeOperatorNode(SyntaxKind.KeyOfKeyword, typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context)))),
70277026
result,
70287027
factory.createKeywordTypeNode(SyntaxKind.NeverKeyword),
70297028
);
70307029
}
7030+
cleanup();
70317031
return result;
70327032
}
70337033

‎tests/baselines/reference/circularReferenceInReturnType2.types‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -108,8 +108,8 @@ const A = object<Something>()({
108108
> : ^^^
109109
>object<Something>()({ name: "A", fields: () => ({ a: field({ type: A, resolve() { return { foo: 100, }; }, }), }),}) : ObjectType<Something>
110110
> : ^^^^^^^^^^^^^^^^^^^^^
111-
>object<Something>() : <Fields extends { [Key in keyof Fields]: Field<Something, Key & string>; }>(config: { name: string; fields: Fields | (() => Fields); }) => ObjectType<Something>
112-
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
111+
>object<Something>() : <Fields extends { [Key_1 in keyof Fields]: Field<Something, Key_1 & string>; }>(config: { name: string; fields: Fields | (() => Fields); }) => ObjectType<Something>
112+
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
113113
>object : <Source>() => <Fields extends { [Key in keyof Fields]: Field<Source, Key & string>; }>(config: { name: string; fields: Fields | (() => Fields); }) => ObjectType<Source>
114114
> : ^ ^^^^^^^
115115
>{ name: "A", fields: () => ({ a: field({ type: A, resolve() { return { foo: 100, }; }, }), }),} : { name: string; fields: () => any; }

‎tests/baselines/reference/coAndContraVariantInferences3.types‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -32,8 +32,8 @@ type OverloadDefinitions = { readonly [P in number]: (...args: any[]) => any; };
3232
type OverloadBinder<T extends OverloadDefinitions> = (args: OverloadParameters<T>) => OverloadKeys<T> | undefined;
3333
>OverloadBinder : OverloadBinder<T>
3434
> : ^^^^^^^^^^^^^^^^^
35-
>args : Parameters<{ [P in Extract<keyof T, number>]: T[P]; }[Extract<keyof T, number>]>
36-
> : ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
35+
>args : Parameters<{ [P_1 in Extract<keyof T, number>]: T[P_1]; }[Extract<keyof T, number>]>
36+
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3737

3838
type OverloadKeys<T extends OverloadDefinitions> = Extract<keyof T, number>;
3939
>OverloadKeys : OverloadKeys<T>
@@ -50,7 +50,7 @@ type OverloadFunction<T extends OverloadDefinitions> = UnionToIntersection<T[key
5050
type OverloadBinders<T extends OverloadDefinitions> = { [P in OverloadKeys<T>]: (args: OverloadParameters<T>) => boolean | undefined; };
5151
>OverloadBinders : OverloadBinders<T>
5252
> : ^^^^^^^^^^^^^^^^^^
53-
>args : Parameters<{ [P_1 in Extract<keyof T, number>]: T[P_1]; }[Extract<keyof T, number>]>
53+
>args : Parameters<{ [P_2 in Extract<keyof T, number>]: T[P_2]; }[Extract<keyof T, number>]>
5454
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
5555

5656
type OverloadDeprecations<T extends OverloadDefinitions> = { [P in OverloadKeys<T>]?: DeprecationOptions; };

‎tests/baselines/reference/conditionalTypeContextualTypeSimplificationsSuceeds.types‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,8 +15,8 @@ function bad<P extends Props>(
1515
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^
1616

1717
attrs: string extends keyof P ? { [K in keyof P]: P[K] } : { [K in keyof P]: P[K] }) { }
18-
>attrs : string extends keyof P ? { [K in keyof P]: P[K]; } : { [K_1 in keyof P]: P[K_1]; }
19-
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
18+
>attrs : string extends keyof P ? { [K in keyof P]: P[K]; } : { [K in keyof P]: P[K]; }
19+
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
2020

2121
function good1<P extends Props>(
2222
>good1 : <P extends Props>(attrs: string extends keyof P ? P : { [K in keyof P]: P[K]; }) => void

‎tests/baselines/reference/contextualTypesNegatedTypeLikeConstraintInGenericMappedType2.types‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -39,18 +39,18 @@ type Value = { _tag: "A"; a: number } | { _tag: "B"; b: number };
3939
> : ^^^^^^
4040

4141
const matcher = typeTags<Value>();
42-
>matcher : <P extends { readonly A: (_: { _tag: "A"; a: number; }) => any; readonly B: (_: { _tag: "B"; b: number; }) => any; } & { readonly [Tag in Exclude<keyof P, "A" | "B">]: never; }>(fields: P) => unknown
43-
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^
44-
>typeTags<Value>() : <P extends { readonly A: (_: { _tag: "A"; a: number; }) => any; readonly B: (_: { _tag: "B"; b: number; }) => any; } & { readonly [Tag in Exclude<keyof P, "A" | "B">]: never; }>(fields: P) => unknown
45-
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^
42+
>matcher : <P extends { readonly A: (_: { _tag: "A"; a: number; }) => any; readonly B: (_: { _tag: "B"; b: number; }) => any; } & { readonly [Tag_1 in Exclude<keyof P, "A" | "B">]: never; }>(fields: P) => unknown
43+
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^
44+
>typeTags<Value>() : <P extends { readonly A: (_: { _tag: "A"; a: number; }) => any; readonly B: (_: { _tag: "B"; b: number; }) => any; } & { readonly [Tag_1 in Exclude<keyof P, "A" | "B">]: never; }>(fields: P) => unknown
45+
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^
4646
>typeTags : <I>() => <P extends { readonly [Tag in Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag; }>) => any; } & { readonly [Tag in Exclude<keyof P, Tags<"_tag", I>>]: never; }>(fields: P) => unknown
4747
> : ^ ^^^^^^^
4848

4949
matcher({
5050
>matcher({ A: (_) => _.a, B: (_) => "fail",}) : unknown
5151
> : ^^^^^^^
52-
>matcher : <P extends { readonly A: (_: { _tag: "A"; a: number; }) => any; readonly B: (_: { _tag: "B"; b: number; }) => any; } & { readonly [Tag in Exclude<keyof P, "A" | "B">]: never; }>(fields: P) => unknown
53-
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^
52+
>matcher : <P extends { readonly A: (_: { _tag: "A"; a: number; }) => any; readonly B: (_: { _tag: "B"; b: number; }) => any; } & { readonly [Tag_1 in Exclude<keyof P, "A" | "B">]: never; }>(fields: P) => unknown
53+
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^
5454
>{ A: (_) => _.a, B: (_) => "fail",} : { A: (_: { _tag: "A"; a: number; }) => number; B: (_: { _tag: "B"; b: number; }) => string; }
5555
> : ^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^
5656

@@ -83,8 +83,8 @@ matcher({
8383
matcher({
8484
>matcher({ A: (_) => _.a, B: (_) => "fail", C: (_) => "fail",}) : unknown
8585
> : ^^^^^^^
86-
>matcher : <P extends { readonly A: (_: { _tag: "A"; a: number; }) => any; readonly B: (_: { _tag: "B"; b: number; }) => any; } & { readonly [Tag in Exclude<keyof P, "A" | "B">]: never; }>(fields: P) => unknown
87-
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^
86+
>matcher : <P extends { readonly A: (_: { _tag: "A"; a: number; }) => any; readonly B: (_: { _tag: "B"; b: number; }) => any; } & { readonly [Tag_1 in Exclude<keyof P, "A" | "B">]: never; }>(fields: P) => unknown
87+
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^
8888
>{ A: (_) => _.a, B: (_) => "fail", C: (_) => "fail",} : { A: (_: { _tag: "A"; a: number; }) => number; B: (_: { _tag: "B"; b: number; }) => string; C: (_: any) => string; }
8989
> : ^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
9090

‎tests/baselines/reference/declarationEmitInlinedDistributiveConditional.js‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ export type PublicKeys1<T> = T extends `_${string}` ? never : T;
5151
type PublicKeys2<T> = T extends `_${string}` ? never : T;
5252
export {};
5353
//// [api.d.ts]
54-
export declare const dropPrivateProps1: <Obj>(obj: Obj) => { [K in import("./internal").PublicKeys1<keyof Obj>]: Obj[K]; };
55-
export declare const dropPrivateProps2: <Obj>(obj: Obj) => { [K in keyof Obj extends infer T ? T extends keyof Obj ? T extends `_${string}` ? never : T : never : never]: Obj[K]; };
54+
export declare const dropPrivateProps1: <Obj>(obj: Obj) => { [K_1 in import("./internal").PublicKeys1<keyof Obj>]: Obj[K_1]; };
55+
export declare const dropPrivateProps2: <Obj>(obj: Obj) => { [K_1 in keyof Obj extends infer T ? T extends keyof Obj ? T extends `_${string}` ? never : T : never : never]: Obj[K_1]; };
5656
//// [test.d.ts]
5757
export {};

0 commit comments

Comments
 (0)