Fix typo in PseudoPragma* types (#27437)

sandersn · web-flow · commit 21148b3b0aea · 2018-09-28T10:39:30.000-07:00
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -7725,7 +7725,7 @@ namespace ts {
     /*@internal*/
     export function processCommentPragmas(context: PragmaContext, sourceText: string): void {
         const triviaScanner = createScanner(context.languageVersion, /*skipTrivia*/ false, LanguageVariant.Standard, sourceText);
-        const pragmas: PragmaPsuedoMapEntry[] = [];
+        const pragmas: PragmaPseudoMapEntry[] = [];
 
         // Keep scanning all the leading trivia in the file until we get to something that
         // isn't trivia.  Any single line comment will be analyzed to see if it is a
@@ -7780,7 +7780,7 @@ namespace ts {
                     const referencedFiles = context.referencedFiles;
                     const typeReferenceDirectives = context.typeReferenceDirectives;
                     const libReferenceDirectives = context.libReferenceDirectives;
-                    forEach(toArray(entryOrList), (arg: PragmaPsuedoMap["reference"]) => {
+                    forEach(toArray(entryOrList), (arg: PragmaPseudoMap["reference"]) => {
                         // TODO: GH#18217
                         if (arg!.arguments["no-default-lib"]) {
                             context.hasNoDefaultLib = true;
@@ -7803,7 +7803,7 @@ namespace ts {
                 case "amd-dependency": {
                     context.amdDependencies = map(
                         toArray(entryOrList),
-                        (x: PragmaPsuedoMap["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 })); // TODO: GH#18217
                     break;
                 }
                 case "amd-module": {
@@ -7813,11 +7813,11 @@ namespace ts {
                                 // 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);
                             }
-                            context.moduleName = (entry as PragmaPsuedoMap["amd-module"])!.arguments.name;
+                            context.moduleName = (entry as PragmaPseudoMap["amd-module"])!.arguments.name;
                         }
                     }
                     else {
-                        context.moduleName = (entryOrList as PragmaPsuedoMap["amd-module"])!.arguments.name;
+                        context.moduleName = (entryOrList as PragmaPseudoMap["amd-module"])!.arguments.name;
                     }
                     break;
                 }
@@ -7853,10 +7853,10 @@ namespace ts {
 
     const tripleSlashXMLCommentStartRegEx = /^\/\/\/\s*<(\S+)\s.*?\/>/im;
     const singleLinePragmaRegEx = /^\/\/\/?\s*@(\S+)\s*(.*)\s*$/im;
-    function extractPragmas(pragmas: PragmaPsuedoMapEntry[], range: CommentRange, text: string) {
+    function extractPragmas(pragmas: PragmaPseudoMapEntry[], range: CommentRange, text: string) {
         const tripleSlash = range.kind === SyntaxKind.SingleLineCommentTrivia && tripleSlashXMLCommentStartRegEx.exec(text);
         if (tripleSlash) {
-            const name = tripleSlash[1].toLowerCase() as keyof PragmaPsuedoMap; // Technically unsafe cast, but we do it so the below check to make it safe typechecks
+            const name = tripleSlash[1].toLowerCase() as keyof PragmaPseudoMap; // Technically unsafe cast, but we do it so the below check to make it safe typechecks
             const pragma = commentPragmas[name] as PragmaDefinition;
             if (!pragma || !(pragma.kind! & PragmaKindFlags.TripleSlashXML)) {
                 return;
@@ -7883,10 +7883,10 @@ namespace ts {
                         }
                     }
                 }
-                pragmas.push({ name, args: { arguments: argument, range } } as PragmaPsuedoMapEntry);
+                pragmas.push({ name, args: { arguments: argument, range } } as PragmaPseudoMapEntry);
             }
             else {
-                pragmas.push({ name, args: { arguments: {}, range } } as PragmaPsuedoMapEntry);
+                pragmas.push({ name, args: { arguments: {}, range } } as PragmaPseudoMapEntry);
             }
             return;
         }
@@ -7905,17 +7905,17 @@ namespace ts {
         }
     }
 
-    function addPragmaForMatch(pragmas: PragmaPsuedoMapEntry[], range: CommentRange, kind: PragmaKindFlags, match: RegExpExecArray) {
+    function addPragmaForMatch(pragmas: PragmaPseudoMapEntry[], range: CommentRange, kind: PragmaKindFlags, match: RegExpExecArray) {
         if (!match) return;
-        const name = match[1].toLowerCase() as keyof PragmaPsuedoMap; // Technically unsafe cast, but we do it so they below check to make it safe typechecks
+        const name = match[1].toLowerCase() as keyof PragmaPseudoMap; // Technically unsafe cast, but we do it so they below check to make it safe typechecks
         const pragma = commentPragmas[name] as PragmaDefinition;
         if (!pragma || !(pragma.kind! & kind)) {
             return;
         }
         const args = match[2]; // Split on spaces and match up positionally with definition
         const argument = getNamedPragmaArguments(pragma, args);
         if (argument === "fail") return; // Missing required argument, fail to parse it
-        pragmas.push({ name, args: { arguments: argument, range } } as PragmaPsuedoMapEntry);
+        pragmas.push({ name, args: { arguments: argument, range } } as PragmaPseudoMapEntry);
         return;
     }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -5616,15 +5616,15 @@ namespace ts {
     type ConcretePragmaSpecs = typeof commentPragmas;
 
     /* @internal */
-    export type PragmaPsuedoMap = {[K in keyof ConcretePragmaSpecs]?: {arguments: PragmaArgumentType<ConcretePragmaSpecs[K]>, range: CommentRange}};
+    export type PragmaPseudoMap = {[K in keyof ConcretePragmaSpecs]?: {arguments: PragmaArgumentType<ConcretePragmaSpecs[K]>, range: CommentRange}};
 
     /* @internal */
-    export type PragmaPsuedoMapEntry = {[K in keyof PragmaPsuedoMap]: {name: K, args: PragmaPsuedoMap[K]}}[keyof PragmaPsuedoMap];
+    export type PragmaPseudoMapEntry = {[K in keyof PragmaPseudoMap]: {name: K, args: PragmaPseudoMap[K]}}[keyof PragmaPseudoMap];
 
     /* @internal */
-    export interface ReadonlyPragmaMap extends ReadonlyMap<PragmaPsuedoMap[keyof PragmaPsuedoMap] | PragmaPsuedoMap[keyof PragmaPsuedoMap][]> {
-        get<TKey extends keyof PragmaPsuedoMap>(key: TKey): PragmaPsuedoMap[TKey] | PragmaPsuedoMap[TKey][];
-        forEach(action: <TKey extends keyof PragmaPsuedoMap>(value: PragmaPsuedoMap[TKey] | PragmaPsuedoMap[TKey][], key: TKey) => void): void;
+    export interface ReadonlyPragmaMap extends ReadonlyMap<PragmaPseudoMap[keyof PragmaPseudoMap] | PragmaPseudoMap[keyof PragmaPseudoMap][]> {
+        get<TKey extends keyof PragmaPseudoMap>(key: TKey): PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][];
+        forEach(action: <TKey extends keyof PragmaPseudoMap>(value: PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][], key: TKey) => void): void;
     }
 
     /**
@@ -5633,10 +5633,10 @@ namespace ts {
      * in multiple places
      */
     /* @internal */
-    export interface PragmaMap extends Map<PragmaPsuedoMap[keyof PragmaPsuedoMap] | PragmaPsuedoMap[keyof PragmaPsuedoMap][]>, ReadonlyPragmaMap {
-        set<TKey extends keyof PragmaPsuedoMap>(key: TKey, value: PragmaPsuedoMap[TKey] | PragmaPsuedoMap[TKey][]): this;
-        get<TKey extends keyof PragmaPsuedoMap>(key: TKey): PragmaPsuedoMap[TKey] | PragmaPsuedoMap[TKey][];
-        forEach(action: <TKey extends keyof PragmaPsuedoMap>(value: PragmaPsuedoMap[TKey] | PragmaPsuedoMap[TKey][], key: TKey) => void): void;
+    export interface PragmaMap extends Map<PragmaPseudoMap[keyof PragmaPseudoMap] | PragmaPseudoMap[keyof PragmaPseudoMap][]>, ReadonlyPragmaMap {
+        set<TKey extends keyof PragmaPseudoMap>(key: TKey, value: PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][]): this;
+        get<TKey extends keyof PragmaPseudoMap>(key: TKey): PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][];
+        forEach(action: <TKey extends keyof PragmaPseudoMap>(value: PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][], key: TKey) => void): void;
     }
 
     export interface UserPreferences {

Original file line number	Diff line number	Diff line change
`@@ -7725,7 +7725,7 @@ namespace ts {`
`7725`	`7725`	`/@internal/`
`7726`	`7726`	`export function processCommentPragmas(context: PragmaContext, sourceText: string): void {`
`7727`	`7727`	`const triviaScanner = createScanner(context.languageVersion, /skipTrivia/ false, LanguageVariant.Standard, sourceText);`
`7728`		`- const pragmas: PragmaPsuedoMapEntry[] = [];`
	`7728`	`+ const pragmas: PragmaPseudoMapEntry[] = [];`
`7729`	`7729`
`7730`	`7730`	`// Keep scanning all the leading trivia in the file until we get to something that`
`7731`	`7731`	`// isn't trivia. Any single line comment will be analyzed to see if it is a`
`@@ -7780,7 +7780,7 @@ namespace ts {`
`7780`	`7780`	`const referencedFiles = context.referencedFiles;`
`7781`	`7781`	`const typeReferenceDirectives = context.typeReferenceDirectives;`
`7782`	`7782`	`const libReferenceDirectives = context.libReferenceDirectives;`
`7783`		`- forEach(toArray(entryOrList), (arg: PragmaPsuedoMap["reference"]) => {`
	`7783`	`+ forEach(toArray(entryOrList), (arg: PragmaPseudoMap["reference"]) => {`
`7784`	`7784`	`// TODO: GH#18217`
`7785`	`7785`	`if (arg!.arguments["no-default-lib"]) {`
`7786`	`7786`	`context.hasNoDefaultLib = true;`
`@@ -7803,7 +7803,7 @@ namespace ts {`
`7803`	`7803`	`case "amd-dependency": {`
`7804`	`7804`	`context.amdDependencies = map(`
`7805`	`7805`	`toArray(entryOrList),`
`7806`		`- (x: PragmaPsuedoMap["amd-dependency"]) => ({ name: x!.arguments.name!, path: x!.arguments.path })); // TODO: GH#18217`
	`7806`	`+ (x: PragmaPseudoMap["amd-dependency"]) => ({ name: x!.arguments.name!, path: x!.arguments.path })); // TODO: GH#18217`
`7807`	`7807`	`break;`
`7808`	`7808`	`}`
`7809`	`7809`	`case "amd-module": {`
`@@ -7813,11 +7813,11 @@ namespace ts {`
`7813`	`7813`	`// TODO: It's probably fine to issue this diagnostic on all instances of the pragma`
`7814`	`7814`	`reportDiagnostic(entry!.range.pos, entry!.range.end - entry!.range.pos, Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments);`
`7815`	`7815`	`}`
`7816`		`- context.moduleName = (entry as PragmaPsuedoMap["amd-module"])!.arguments.name;`
	`7816`	`+ context.moduleName = (entry as PragmaPseudoMap["amd-module"])!.arguments.name;`
`7817`	`7817`	`}`
`7818`	`7818`	`}`
`7819`	`7819`	`else {`
`7820`		`- context.moduleName = (entryOrList as PragmaPsuedoMap["amd-module"])!.arguments.name;`
	`7820`	`+ context.moduleName = (entryOrList as PragmaPseudoMap["amd-module"])!.arguments.name;`
`7821`	`7821`	`}`
`7822`	`7822`	`break;`
`7823`	`7823`	`}`
`@@ -7853,10 +7853,10 @@ namespace ts {`
`7853`	`7853`
`7854`	`7854`	`const tripleSlashXMLCommentStartRegEx = /^\/\/\/\s<(\S+)\s.?\/>/im;`
`7855`	`7855`	`const singleLinePragmaRegEx = /^\/\/\/?\s@(\S+)\s(.)\s$/im;`
`7856`		`- function extractPragmas(pragmas: PragmaPsuedoMapEntry[], range: CommentRange, text: string) {`
	`7856`	`+ function extractPragmas(pragmas: PragmaPseudoMapEntry[], range: CommentRange, text: string) {`
`7857`	`7857`	`const tripleSlash = range.kind === SyntaxKind.SingleLineCommentTrivia && tripleSlashXMLCommentStartRegEx.exec(text);`
`7858`	`7858`	`if (tripleSlash) {`
`7859`		`- const name = tripleSlash[1].toLowerCase() as keyof PragmaPsuedoMap; // Technically unsafe cast, but we do it so the below check to make it safe typechecks`
	`7859`	`+ const name = tripleSlash[1].toLowerCase() as keyof PragmaPseudoMap; // Technically unsafe cast, but we do it so the below check to make it safe typechecks`
`7860`	`7860`	`const pragma = commentPragmas[name] as PragmaDefinition;`
`7861`	`7861`	`if (!pragma \|\| !(pragma.kind! & PragmaKindFlags.TripleSlashXML)) {`
`7862`	`7862`	`return;`
`@@ -7883,10 +7883,10 @@ namespace ts {`
`7883`	`7883`	`}`
`7884`	`7884`	`}`
`7885`	`7885`	`}`
`7886`		`- pragmas.push({ name, args: { arguments: argument, range } } as PragmaPsuedoMapEntry);`
	`7886`	`+ pragmas.push({ name, args: { arguments: argument, range } } as PragmaPseudoMapEntry);`
`7887`	`7887`	`}`
`7888`	`7888`	`else {`
`7889`		`- pragmas.push({ name, args: { arguments: {}, range } } as PragmaPsuedoMapEntry);`
	`7889`	`+ pragmas.push({ name, args: { arguments: {}, range } } as PragmaPseudoMapEntry);`
`7890`	`7890`	`}`
`7891`	`7891`	`return;`
`7892`	`7892`	`}`
`@@ -7905,17 +7905,17 @@ namespace ts {`
`7905`	`7905`	`}`
`7906`	`7906`	`}`
`7907`	`7907`
`7908`		`- function addPragmaForMatch(pragmas: PragmaPsuedoMapEntry[], range: CommentRange, kind: PragmaKindFlags, match: RegExpExecArray) {`
	`7908`	`+ function addPragmaForMatch(pragmas: PragmaPseudoMapEntry[], range: CommentRange, kind: PragmaKindFlags, match: RegExpExecArray) {`
`7909`	`7909`	`if (!match) return;`
`7910`		`- const name = match[1].toLowerCase() as keyof PragmaPsuedoMap; // Technically unsafe cast, but we do it so they below check to make it safe typechecks`
	`7910`	`+ const name = match[1].toLowerCase() as keyof PragmaPseudoMap; // Technically unsafe cast, but we do it so they below check to make it safe typechecks`
`7911`	`7911`	`const pragma = commentPragmas[name] as PragmaDefinition;`
`7912`	`7912`	`if (!pragma \|\| !(pragma.kind! & kind)) {`
`7913`	`7913`	`return;`
`7914`	`7914`	`}`
`7915`	`7915`	`const args = match[2]; // Split on spaces and match up positionally with definition`
`7916`	`7916`	`const argument = getNamedPragmaArguments(pragma, args);`
`7917`	`7917`	`if (argument === "fail") return; // Missing required argument, fail to parse it`
`7918`		`- pragmas.push({ name, args: { arguments: argument, range } } as PragmaPsuedoMapEntry);`
	`7918`	`+ pragmas.push({ name, args: { arguments: argument, range } } as PragmaPseudoMapEntry);`
`7919`	`7919`	`return;`
`7920`	`7920`	`}`
`7921`	`7921`