From 0c9a35ccc0a29581ef254c586897cb340e967d1b Mon Sep 17 00:00:00 2001 From: Ruwan Pradeep Geeganage Date: Tue, 30 Apr 2019 20:19:21 +0200 Subject: [PATCH] Use 'Omit' instead of 'Pick>' for object rest (#31134) * add Omit instead of Pick,..> * remove the fallback * run the baseline-accept * removed unused variables * fix tests\baselines\reference --- src/compiler/checker.ts | 20 +++++++------------ .../reference/genericIsNeverEmptyObject.types | 12 +++++------ .../reference/genericObjectRest.types | 16 +++++++-------- .../reference/literalTypeWidening.types | 6 +++--- .../reference/mappedTypeConstraints.symbols | 4 ++-- .../reference/mappedTypeConstraints.types | 4 ++-- .../reference/objectRestNegative.types | 6 +++--- 7 files changed, 31 insertions(+), 37 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index cb43388b2dd00..2675f06824744 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -535,8 +535,7 @@ namespace ts { let deferredGlobalTemplateStringsArrayType: ObjectType; let deferredGlobalImportMetaType: ObjectType; let deferredGlobalExtractSymbol: Symbol; - let deferredGlobalExcludeSymbol: Symbol; - let deferredGlobalPickSymbol: Symbol; + let deferredGlobalOmitSymbol: Symbol; let deferredGlobalBigIntType: ObjectType; const allPotentiallyUnusedIdentifiers = createMap(); // key is file name @@ -4969,13 +4968,12 @@ namespace ts { if (omitKeyType.flags & TypeFlags.Never) { return source; } - const pickTypeAlias = getGlobalPickSymbol(); - const excludeTypeAlias = getGlobalExcludeSymbol(); - if (!pickTypeAlias || !excludeTypeAlias) { + + const omitTypeAlias = getGlobalOmitSymbol(); + if (!omitTypeAlias) { return errorType; } - const pickKeys = getTypeAliasInstantiation(excludeTypeAlias, [getIndexType(source), omitKeyType]); - return getTypeAliasInstantiation(pickTypeAlias, [source, pickKeys]); + return getTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]); } const members = createSymbolTable(); for (const prop of getPropertiesOfType(source)) { @@ -9305,12 +9303,8 @@ namespace ts { return deferredGlobalExtractSymbol || (deferredGlobalExtractSymbol = getGlobalSymbol("Extract" as __String, SymbolFlags.TypeAlias, Diagnostics.Cannot_find_global_type_0)!); // TODO: GH#18217 } - function getGlobalExcludeSymbol(): Symbol { - return deferredGlobalExcludeSymbol || (deferredGlobalExcludeSymbol = getGlobalSymbol("Exclude" as __String, SymbolFlags.TypeAlias, Diagnostics.Cannot_find_global_type_0)!); // TODO: GH#18217 - } - - function getGlobalPickSymbol(): Symbol { - return deferredGlobalPickSymbol || (deferredGlobalPickSymbol = getGlobalSymbol("Pick" as __String, SymbolFlags.TypeAlias, Diagnostics.Cannot_find_global_type_0)!); // TODO: GH#18217 + function getGlobalOmitSymbol(): Symbol { + return deferredGlobalOmitSymbol || (deferredGlobalOmitSymbol = getGlobalSymbol("Omit" as __String, SymbolFlags.TypeAlias, Diagnostics.Cannot_find_global_type_0)!); // TODO: GH#18217 } function getGlobalBigIntType(reportErrors: boolean) { diff --git a/tests/baselines/reference/genericIsNeverEmptyObject.types b/tests/baselines/reference/genericIsNeverEmptyObject.types index 5d2b4d9d57f53..3a49e723e7600 100644 --- a/tests/baselines/reference/genericIsNeverEmptyObject.types +++ b/tests/baselines/reference/genericIsNeverEmptyObject.types @@ -2,18 +2,18 @@ // Repro from #29067 function test(obj: T) { ->test : (obj: T) => Pick> & { b: string; } +>test : (obj: T) => Omit & { b: string; } >a : string >obj : T let { a, ...rest } = obj; >a : string ->rest : Pick> +>rest : Omit >obj : T return { ...rest, b: a }; ->{ ...rest, b: a } : Pick> & { b: string; } ->rest : Pick> +>{ ...rest, b: a } : Omit & { b: string; } +>rest : Omit >b : string >a : string } @@ -30,7 +30,7 @@ let o2: { b: string, x: number } = test(o1); >o2 : { b: string; x: number; } >b : string >x : number ->test(o1) : Pick<{ a: string; x: number; }, "x"> & { b: string; } ->test : (obj: T) => Pick> & { b: string; } +>test(o1) : Omit<{ a: string; x: number; }, "a"> & { b: string; } +>test : (obj: T) => Omit & { b: string; } >o1 : { a: string; x: number; } diff --git a/tests/baselines/reference/genericObjectRest.types b/tests/baselines/reference/genericObjectRest.types index c2fcaad7cb87c..ba5145dccba19 100644 --- a/tests/baselines/reference/genericObjectRest.types +++ b/tests/baselines/reference/genericObjectRest.types @@ -16,7 +16,7 @@ function f1(obj: T) { let { a: a1, ...r1 } = obj; >a : any >a1 : string ->r1 : Pick> +>r1 : Omit >obj : T let { a: a2, b: b2, ...r2 } = obj; @@ -24,24 +24,24 @@ function f1(obj: T) { >a2 : string >b : any >b2 : number ->r2 : Pick> +>r2 : Omit >obj : T let { 'a': a3, ...r3 } = obj; >a3 : string ->r3 : Pick> +>r3 : Omit >obj : T let { ['a']: a4, ...r4 } = obj; >'a' : "a" >a4 : string ->r4 : Pick> +>r4 : Omit >obj : T let { [a]: a5, ...r5 } = obj; >a : "a" >a5 : string ->r5 : Pick> +>r5 : Omit >obj : T } @@ -68,7 +68,7 @@ function f2(obj: T) { >a1 : string >sb : unique symbol >b1 : number ->r1 : Pick> +>r1 : Omit >obj : T } @@ -83,7 +83,7 @@ function f3(obj: T, k1: K1, k2: K2) { >a1 : T[K1] >k2 : K2 >a2 : T[K2] ->r1 : Pick> +>r1 : Omit >obj : T } @@ -104,7 +104,7 @@ function f4(obj: Item, k1: K1, k2: >a1 : Item[K1] >k2 : K2 >a2 : Item[K2] ->r1 : Pick | Exclude<"b", K1 | K2> | Exclude<"c", K1 | K2>> +>r1 : Omit >obj : Item } diff --git a/tests/baselines/reference/literalTypeWidening.types b/tests/baselines/reference/literalTypeWidening.types index 95bde9a08ac3d..81db0bfc36f68 100644 --- a/tests/baselines/reference/literalTypeWidening.types +++ b/tests/baselines/reference/literalTypeWidening.types @@ -443,14 +443,14 @@ function test(obj: T): T { let { a, ...rest } = obj; >a : string ->rest : Pick> +>rest : Omit >obj : T return { a: 'hello', ...rest } as T; >{ a: 'hello', ...rest } as T : T ->{ a: 'hello', ...rest } : { a: string; } & Pick> +>{ a: 'hello', ...rest } : { a: string; } & Omit >a : string >'hello' : "hello" ->rest : Pick> +>rest : Omit } diff --git a/tests/baselines/reference/mappedTypeConstraints.symbols b/tests/baselines/reference/mappedTypeConstraints.symbols index 3601ffc3de848..4a793fd0dc388 100644 --- a/tests/baselines/reference/mappedTypeConstraints.symbols +++ b/tests/baselines/reference/mappedTypeConstraints.symbols @@ -132,9 +132,9 @@ const modifier = (targetProps: T) => { >targetProps : Symbol(targetProps, Decl(mappedTypeConstraints.ts, 30, 41)) rest.foo; ->rest.foo : Symbol(foo, Decl(mappedTypeConstraints.ts, 25, 20)) +>rest.foo : Symbol(foo) >rest : Symbol(rest, Decl(mappedTypeConstraints.ts, 31, 13)) ->foo : Symbol(foo, Decl(mappedTypeConstraints.ts, 25, 20)) +>foo : Symbol(foo) }; diff --git a/tests/baselines/reference/mappedTypeConstraints.types b/tests/baselines/reference/mappedTypeConstraints.types index 3e42e2a2e9800..98ae325e6be91 100644 --- a/tests/baselines/reference/mappedTypeConstraints.types +++ b/tests/baselines/reference/mappedTypeConstraints.types @@ -98,12 +98,12 @@ const modifier = (targetProps: T) => { let {bar, ...rest} = targetProps; >bar : string ->rest : Pick> +>rest : Omit >targetProps : T rest.foo; >rest.foo : T["foo"] ->rest : Pick> +>rest : Omit >foo : T["foo"] }; diff --git a/tests/baselines/reference/objectRestNegative.types b/tests/baselines/reference/objectRestNegative.types index 58ed1902f6dd4..7cc174299e484 100644 --- a/tests/baselines/reference/objectRestNegative.types +++ b/tests/baselines/reference/objectRestNegative.types @@ -36,18 +36,18 @@ function stillMustBeLast({ ...mustBeLast, a }: { a: number, b: string }): void { >b : string } function generic(t: T) { ->generic : (t: T) => Pick> +>generic : (t: T) => Omit >x : any >y : any >t : T let { x, ...rest } = t; >x : any ->rest : Pick> +>rest : Omit >t : T return rest; ->rest : Pick> +>rest : Omit } let rest: { b: string }