Use const contexts and tuple mapped types to simplify some explicitly elucidated types (microsoft#30654)

weswigham · web-flow · commit ca98a50574f6 · 2019-04-02T13:04:51.000-07:00
* Use const contexts and tuple mapped types to simplify some explicitly elucidated types

* Fix lint

* Further cleanup - refactor mapped type into its own alias for readability

* Slightly more cleanup - PragmaPsuedoMap neednt be partial, thus removing tons of nonull assertions

* Remove GH#18217 comments
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -7749,17 +7749,17 @@ namespace ts {
 
         context.pragmas = createMap() as PragmaMap;
         for (const pragma of pragmas) {
-            if (context.pragmas.has(pragma!.name)) { // TODO: GH#18217
-                const currentValue = context.pragmas.get(pragma!.name);
+            if (context.pragmas.has(pragma.name)) {
+                const currentValue = context.pragmas.get(pragma.name);
                 if (currentValue instanceof Array) {
-                    currentValue.push(pragma!.args);
+                    currentValue.push(pragma.args);
                 }
                 else {
-                    context.pragmas.set(pragma!.name, [currentValue, pragma!.args]);
+                    context.pragmas.set(pragma.name, [currentValue, pragma.args]);
                 }
                 continue;
             }
-            context.pragmas.set(pragma!.name, pragma!.args);
+            context.pragmas.set(pragma.name, pragma.args);
         }
     }
 
@@ -7783,9 +7783,8 @@ namespace ts {
                     const typeReferenceDirectives = context.typeReferenceDirectives;
                     const libReferenceDirectives = context.libReferenceDirectives;
                     forEach(toArray(entryOrList), (arg: PragmaPseudoMap["reference"]) => {
-                        // TODO: GH#18217
-                        const { types, lib, path } = arg!.arguments;
-                        if (arg!.arguments["no-default-lib"]) {
+                        const { types, lib, path } = arg.arguments;
+                        if (arg.arguments["no-default-lib"]) {
                             context.hasNoDefaultLib = true;
                         }
                         else if (types) {
@@ -7798,41 +7797,41 @@ namespace ts {
                             referencedFiles.push({ pos: path.pos, end: path.end, fileName: path.value });
                         }
                         else {
-                            reportDiagnostic(arg!.range.pos, arg!.range.end - arg!.range.pos, Diagnostics.Invalid_reference_directive_syntax);
+                            reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, Diagnostics.Invalid_reference_directive_syntax);
                         }
                     });
                     break;
                 }
                 case "amd-dependency": {
                     context.amdDependencies = map(
                         toArray(entryOrList),
-                        (x: PragmaPseudoMap["amd-dependency"]) => ({ name: x!.arguments.name!, path: x!.arguments.path })); // TODO: GH#18217
+                        (x: PragmaPseudoMap["amd-dependency"]) => ({ name: x.arguments.name, path: x.arguments.path }));
                     break;
                 }
                 case "amd-module": {
                     if (entryOrList instanceof Array) {
                         for (const entry of entryOrList) {
                             if (context.moduleName) {
                                 // TODO: It's probably fine to issue this diagnostic on all instances of the pragma
-                                reportDiagnostic(entry!.range.pos, entry!.range.end - entry!.range.pos, Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments);
+                                reportDiagnostic(entry.range.pos, entry.range.end - entry.range.pos, Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments);
                             }
-                            context.moduleName = (entry as PragmaPseudoMap["amd-module"])!.arguments.name;
+                            context.moduleName = (entry as PragmaPseudoMap["amd-module"]).arguments.name;
                         }
                     }
                     else {
-                        context.moduleName = (entryOrList as PragmaPseudoMap["amd-module"])!.arguments.name;
+                        context.moduleName = (entryOrList as PragmaPseudoMap["amd-module"]).arguments.name;
                     }
                     break;
                 }
                 case "ts-nocheck":
                 case "ts-check": {
                     // _last_ of either nocheck or check in a file is the "winner"
                     forEach(toArray(entryOrList), entry => {
-                        if (!context.checkJsDirective || entry!.range.pos > context.checkJsDirective.pos) { // TODO: GH#18217
+                        if (!context.checkJsDirective || entry.range.pos > context.checkJsDirective.pos) {
                             context.checkJsDirective = {
                                 enabled: key === "ts-check",
-                                end: entry!.range.end,
-                                pos: entry!.range.pos
+                                end: entry.range.end,
+                                pos: entry.range.pos
                             };
                         }
                     });
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -5950,26 +5950,18 @@ namespace ts {
     /* @internal */
     export interface PragmaDefinition<T1 extends string = string, T2 extends string = string, T3 extends string = string, T4 extends string = string> {
         args?:
-            | [PragmaArgumentSpecification<T1>]
-            | [PragmaArgumentSpecification<T1>, PragmaArgumentSpecification<T2>]
-            | [PragmaArgumentSpecification<T1>, PragmaArgumentSpecification<T2>, PragmaArgumentSpecification<T3>]
-            | [PragmaArgumentSpecification<T1>, PragmaArgumentSpecification<T2>, PragmaArgumentSpecification<T3>, PragmaArgumentSpecification<T4>];
+            | readonly [PragmaArgumentSpecification<T1>]
+            | readonly [PragmaArgumentSpecification<T1>, PragmaArgumentSpecification<T2>]
+            | readonly [PragmaArgumentSpecification<T1>, PragmaArgumentSpecification<T2>, PragmaArgumentSpecification<T3>]
+            | readonly [PragmaArgumentSpecification<T1>, PragmaArgumentSpecification<T2>, PragmaArgumentSpecification<T3>, PragmaArgumentSpecification<T4>];
         // If not present, defaults to PragmaKindFlags.Default
         kind?: PragmaKindFlags;
     }
 
-    /**
-     * This function only exists to cause exact types to be inferred for all the literals within `commentPragmas`
-     */
-    /* @internal */
-    function _contextuallyTypePragmas<T extends {[name: string]: PragmaDefinition<K1, K2, K3, K4>}, K1 extends string, K2 extends string, K3 extends string, K4 extends string>(args: T): T {
-        return args;
-    }
-
     // While not strictly a type, this is here because `PragmaMap` needs to be here to be used with `SourceFile`, and we don't
     //  fancy effectively defining it twice, once in value-space and once in type-space
     /* @internal */
-    export const commentPragmas = _contextuallyTypePragmas({
+    export const commentPragmas = {
         "reference": {
             args: [
                 { name: "types", optional: true, captureSpan: true },
@@ -5997,7 +5989,7 @@ namespace ts {
             args: [{ name: "factory" }],
             kind: PragmaKindFlags.MultiLine
         },
-    });
+    } as const;
 
     /* @internal */
     type PragmaArgTypeMaybeCapture<TDesc> = TDesc extends {captureSpan: true} ? {value: string, pos: number, end: number} : string;
@@ -6008,29 +6000,29 @@ namespace ts {
             ? {[K in TName]?: PragmaArgTypeMaybeCapture<TDesc>}
             : {[K in TName]: PragmaArgTypeMaybeCapture<TDesc>};
 
+    /* @internal */
+    type UnionToIntersection<U> =
+            (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+
+    /* @internal */
+    type ArgumentDefinitionToFieldUnion<T extends readonly PragmaArgumentSpecification<any>[]> = {
+        [K in keyof T]: PragmaArgTypeOptional<T[K], T[K] extends {name: infer TName} ? TName extends string ? TName : never : never>
+    }[Extract<keyof T, number>]; // The mapped type maps over only the tuple members, but this reindex gets _all_ members - by extracting only `number` keys, we get only the tuple members
+
     /**
      * Maps a pragma definition into the desired shape for its arguments object
-     * Maybe the below is a good argument for types being iterable on struture in some way.
      */
     /* @internal */
-    type PragmaArgumentType<T extends PragmaDefinition> =
-        T extends { args: [PragmaArgumentSpecification<infer TName1>, PragmaArgumentSpecification<infer TName2>, PragmaArgumentSpecification<infer TName3>, PragmaArgumentSpecification<infer TName4>] }
-            ? PragmaArgTypeOptional<T["args"][0], TName1> & PragmaArgTypeOptional<T["args"][1], TName2> & PragmaArgTypeOptional<T["args"][2], TName3> & PragmaArgTypeOptional<T["args"][2], TName4>
-            : T extends { args: [PragmaArgumentSpecification<infer TName1>, PragmaArgumentSpecification<infer TName2>, PragmaArgumentSpecification<infer TName3>] }
-                ? PragmaArgTypeOptional<T["args"][0], TName1> & PragmaArgTypeOptional<T["args"][1], TName2> & PragmaArgTypeOptional<T["args"][2], TName3>
-                : T extends { args: [PragmaArgumentSpecification<infer TName1>, PragmaArgumentSpecification<infer TName2>] }
-                    ? PragmaArgTypeOptional<T["args"][0], TName1> & PragmaArgTypeOptional<T["args"][1], TName2>
-                    : T extends { args: [PragmaArgumentSpecification<infer TName>] }
-                        ? PragmaArgTypeOptional<T["args"][0], TName>
-                        : object;
-    // The above fallback to `object` when there's no args to allow `{}` (as intended), but not the number 2, for example
-    // TODO: Swap to `undefined` for a cleaner API once strictNullChecks is enabled
+    type PragmaArgumentType<KPrag extends keyof ConcretePragmaSpecs> =
+        ConcretePragmaSpecs[KPrag] extends { args: readonly PragmaArgumentSpecification<any>[] }
+            ? UnionToIntersection<ArgumentDefinitionToFieldUnion<ConcretePragmaSpecs[KPrag]["args"]>>
+            : never;
 
     /* @internal */
     type ConcretePragmaSpecs = typeof commentPragmas;
 
     /* @internal */
-    export type PragmaPseudoMap = {[K in keyof ConcretePragmaSpecs]?: {arguments: PragmaArgumentType<ConcretePragmaSpecs[K]>, range: CommentRange}};
+    export type PragmaPseudoMap = {[K in keyof ConcretePragmaSpecs]: {arguments: PragmaArgumentType<K>, range: CommentRange}};
 
     /* @internal */
     export type PragmaPseudoMapEntry = {[K in keyof PragmaPseudoMap]: {name: K, args: PragmaPseudoMap[K]}}[keyof PragmaPseudoMap];

Original file line number	Diff line number	Diff line change
`@@ -7749,17 +7749,17 @@ namespace ts {`
`7749`	`7749`
`7750`	`7750`	`context.pragmas = createMap() as PragmaMap;`
`7751`	`7751`	`for (const pragma of pragmas) {`
`7752`		`- if (context.pragmas.has(pragma!.name)) { // TODO: GH#18217`
`7753`		`- const currentValue = context.pragmas.get(pragma!.name);`
	`7752`	`+ if (context.pragmas.has(pragma.name)) {`
	`7753`	`+ const currentValue = context.pragmas.get(pragma.name);`
`7754`	`7754`	`if (currentValue instanceof Array) {`
`7755`		`- currentValue.push(pragma!.args);`
	`7755`	`+ currentValue.push(pragma.args);`
`7756`	`7756`	`}`
`7757`	`7757`	`else {`
`7758`		`- context.pragmas.set(pragma!.name, [currentValue, pragma!.args]);`
	`7758`	`+ context.pragmas.set(pragma.name, [currentValue, pragma.args]);`
`7759`	`7759`	`}`
`7760`	`7760`	`continue;`
`7761`	`7761`	`}`
`7762`		`- context.pragmas.set(pragma!.name, pragma!.args);`
	`7762`	`+ context.pragmas.set(pragma.name, pragma.args);`
`7763`	`7763`	`}`
`7764`	`7764`	`}`
`7765`	`7765`
`@@ -7783,9 +7783,8 @@ namespace ts {`
`7783`	`7783`	`const typeReferenceDirectives = context.typeReferenceDirectives;`
`7784`	`7784`	`const libReferenceDirectives = context.libReferenceDirectives;`
`7785`	`7785`	`forEach(toArray(entryOrList), (arg: PragmaPseudoMap["reference"]) => {`
`7786`		`- // TODO: GH#18217`
`7787`		`- const { types, lib, path } = arg!.arguments;`
`7788`		`- if (arg!.arguments["no-default-lib"]) {`
	`7786`	`+ const { types, lib, path } = arg.arguments;`
	`7787`	`+ if (arg.arguments["no-default-lib"]) {`
`7789`	`7788`	`context.hasNoDefaultLib = true;`
`7790`	`7789`	`}`
`7791`	`7790`	`else if (types) {`
`@@ -7798,41 +7797,41 @@ namespace ts {`
`7798`	`7797`	`referencedFiles.push({ pos: path.pos, end: path.end, fileName: path.value });`
`7799`	`7798`	`}`
`7800`	`7799`	`else {`
`7801`		`- reportDiagnostic(arg!.range.pos, arg!.range.end - arg!.range.pos, Diagnostics.Invalid_reference_directive_syntax);`
	`7800`	`+ reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, Diagnostics.Invalid_reference_directive_syntax);`
`7802`	`7801`	`}`
`7803`	`7802`	`});`
`7804`	`7803`	`break;`
`7805`	`7804`	`}`
`7806`	`7805`	`case "amd-dependency": {`
`7807`	`7806`	`context.amdDependencies = map(`
`7808`	`7807`	`toArray(entryOrList),`
`7809`		`- (x: PragmaPseudoMap["amd-dependency"]) => ({ name: x!.arguments.name!, path: x!.arguments.path })); // TODO: GH#18217`
	`7808`	`+ (x: PragmaPseudoMap["amd-dependency"]) => ({ name: x.arguments.name, path: x.arguments.path }));`
`7810`	`7809`	`break;`
`7811`	`7810`	`}`
`7812`	`7811`	`case "amd-module": {`
`7813`	`7812`	`if (entryOrList instanceof Array) {`
`7814`	`7813`	`for (const entry of entryOrList) {`
`7815`	`7814`	`if (context.moduleName) {`
`7816`	`7815`	`// TODO: It's probably fine to issue this diagnostic on all instances of the pragma`
`7817`		`- reportDiagnostic(entry!.range.pos, entry!.range.end - entry!.range.pos, Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments);`
	`7816`	`+ reportDiagnostic(entry.range.pos, entry.range.end - entry.range.pos, Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments);`
`7818`	`7817`	`}`
`7819`		`- context.moduleName = (entry as PragmaPseudoMap["amd-module"])!.arguments.name;`
	`7818`	`+ context.moduleName = (entry as PragmaPseudoMap["amd-module"]).arguments.name;`
`7820`	`7819`	`}`
`7821`	`7820`	`}`
`7822`	`7821`	`else {`
`7823`		`- context.moduleName = (entryOrList as PragmaPseudoMap["amd-module"])!.arguments.name;`
	`7822`	`+ context.moduleName = (entryOrList as PragmaPseudoMap["amd-module"]).arguments.name;`
`7824`	`7823`	`}`
`7825`	`7824`	`break;`
`7826`	`7825`	`}`
`7827`	`7826`	`case "ts-nocheck":`
`7828`	`7827`	`case "ts-check": {`
`7829`	`7828`	`// _last_ of either nocheck or check in a file is the "winner"`
`7830`	`7829`	`forEach(toArray(entryOrList), entry => {`
`7831`		`- if (!context.checkJsDirective \|\| entry!.range.pos > context.checkJsDirective.pos) { // TODO: GH#18217`
	`7830`	`+ if (!context.checkJsDirective \|\| entry.range.pos > context.checkJsDirective.pos) {`
`7832`	`7831`	`context.checkJsDirective = {`
`7833`	`7832`	`enabled: key === "ts-check",`
`7834`		`- end: entry!.range.end,`
`7835`		`- pos: entry!.range.pos`
	`7833`	`+ end: entry.range.end,`
	`7834`	`+ pos: entry.range.pos`
`7836`	`7835`	`};`
`7837`	`7836`	`}`
`7838`	`7837`	`});`