Fix typo: Infered -> inferred (#17417)

tests/baselines/reference/declarationEmitInferedDefaultExportType.symbols

@@ -1,13 +0,0 @@
-=== tests/cases/compiler/declarationEmitInferedDefaultExportType.ts ===
-// test.ts
-export default {
-  foo: [],
->foo : Symbol(foo, Decl(declarationEmitInferedDefaultExportType.ts, 1, 16))
-
-  bar: undefined,
->bar : Symbol(bar, Decl(declarationEmitInferedDefaultExportType.ts, 2, 10))
->undefined : Symbol(undefined)
-
-  baz: null
->baz : Symbol(baz, Decl(declarationEmitInferedDefaultExportType.ts, 3, 17))
-}

tests/baselines/reference/declarationEmitInferedDefaultExportType2.symbols

@@ -1,13 +0,0 @@
-=== tests/cases/compiler/declarationEmitInferedDefaultExportType2.ts ===
-// test.ts
-export = {
-  foo: [],
->foo : Symbol(foo, Decl(declarationEmitInferedDefaultExportType2.ts, 1, 10))
-
-  bar: undefined,
->bar : Symbol(bar, Decl(declarationEmitInferedDefaultExportType2.ts, 2, 10))
->undefined : Symbol(undefined)
-
-  baz: null
->baz : Symbol(baz, Decl(declarationEmitInferedDefaultExportType2.ts, 3, 17))
-}

tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols

@@ -1,21 +0,0 @@
-=== tests/cases/compiler/declarationEmitInferedTypeAlias4.ts ===
-function f<A>() {
->f : Symbol(f, Decl(declarationEmitInferedTypeAlias4.ts, 0, 0))
->A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 0, 11))
-
-    type Foo<T> = T | { x: Foo<T> };
->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 0, 17))
->T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 1, 13))
->T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 1, 13))
->x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 1, 23))
->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 0, 17))
->T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 1, 13))
-
-    var x: Foo<A[]>;
->x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 2, 7))
->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 0, 17))
->A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 0, 11))
-
-    return x;
->x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 2, 7))
-}

tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols

@@ -1,19 +0,0 @@
-=== tests/cases/compiler/declarationEmitInferedTypeAlias8.ts ===
-type Foo<T> = T | { x: Foo<T> };
->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0))
->T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 0, 9))
->T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 0, 9))
->x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 0, 19))
->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0))
->T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 0, 9))
-
-var x: Foo<number[]>;
->x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 1, 3))
->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0))
-
-function returnSomeGlobalValue() {
->returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias8.ts, 1, 21))
-
-    return x;
->x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 1, 3))
-}

tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols

@@ -1,19 +0,0 @@
-=== tests/cases/compiler/declarationEmitInferedTypeAlias9.ts ===
-type Foo<T> = T | { x: Foo<T> };
->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0))
->T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 0, 9))
->T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 0, 9))
->x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 0, 19))
->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0))
->T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 0, 9))
-
-var x: Foo<number[]>;
->x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 1, 3))
->Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0))
-
-export function returnSomeGlobalValue() {
->returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias9.ts, 1, 21))
-
-    return x;
->x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 1, 3))
-}

tests/baselines/reference/declarationEmitInferredDefaultExportType.js

@@ -1,4 +1,4 @@
-//// [declarationEmitInferedDefaultExportType.ts]
+//// [declarationEmitInferredDefaultExportType.ts]
 // test.ts
 export default {
   foo: [],
@@ -6,7 +6,7 @@ export default {
   baz: null
 }
 
-//// [declarationEmitInferedDefaultExportType.js]
+//// [declarationEmitInferredDefaultExportType.js]
 "use strict";
 exports.__esModule = true;
 // test.ts
@@ -17,7 +17,7 @@ exports["default"] = {
 };
 
 
-//// [declarationEmitInferedDefaultExportType.d.ts]
+//// [declarationEmitInferredDefaultExportType.d.ts]
 declare const _default: {
     foo: any[];
     bar: any;

tests/baselines/reference/declarationEmitInferredDefaultExportType.symbols

@@ -0,0 +1,13 @@
+=== tests/cases/compiler/declarationEmitInferredDefaultExportType.ts ===
+// test.ts
+export default {
+  foo: [],
+>foo : Symbol(foo, Decl(declarationEmitInferredDefaultExportType.ts, 1, 16))
+
+  bar: undefined,
+>bar : Symbol(bar, Decl(declarationEmitInferredDefaultExportType.ts, 2, 10))
+>undefined : Symbol(undefined)
+
+  baz: null
+>baz : Symbol(baz, Decl(declarationEmitInferredDefaultExportType.ts, 3, 17))
+}

tests/baselines/reference/declarationEmitInferredDefaultExportType.types

@@ -1,4 +1,4 @@
-=== tests/cases/compiler/declarationEmitInferedDefaultExportType.ts ===
+=== tests/cases/compiler/declarationEmitInferredDefaultExportType.ts ===
 // test.ts
 export default {
 >{  foo: [],  bar: undefined,  baz: null} : { foo: undefined[]; bar: undefined; baz: null; }

tests/baselines/reference/declarationEmitInferredDefaultExportType2.js

@@ -1,4 +1,4 @@
-//// [declarationEmitInferedDefaultExportType2.ts]
+//// [declarationEmitInferredDefaultExportType2.ts]
 // test.ts
 export = {
   foo: [],
@@ -6,7 +6,7 @@ export = {
   baz: null
 }
 
-//// [declarationEmitInferedDefaultExportType2.js]
+//// [declarationEmitInferredDefaultExportType2.js]
 "use strict";
 module.exports = {
     foo: [],
@@ -15,7 +15,7 @@ module.exports = {
 };
 
 
-//// [declarationEmitInferedDefaultExportType2.d.ts]
+//// [declarationEmitInferredDefaultExportType2.d.ts]
 declare const _default: {
     foo: any[];
     bar: any;

tests/baselines/reference/declarationEmitInferredDefaultExportType2.symbols

@@ -0,0 +1,13 @@
+=== tests/cases/compiler/declarationEmitInferredDefaultExportType2.ts ===
+// test.ts
+export = {
+  foo: [],
+>foo : Symbol(foo, Decl(declarationEmitInferredDefaultExportType2.ts, 1, 10))
+
+  bar: undefined,
+>bar : Symbol(bar, Decl(declarationEmitInferredDefaultExportType2.ts, 2, 10))
+>undefined : Symbol(undefined)
+
+  baz: null
+>baz : Symbol(baz, Decl(declarationEmitInferredDefaultExportType2.ts, 3, 17))
+}

tests/baselines/reference/declarationEmitInferredDefaultExportType2.types

@@ -1,4 +1,4 @@
-=== tests/cases/compiler/declarationEmitInferedDefaultExportType2.ts ===
+=== tests/cases/compiler/declarationEmitInferredDefaultExportType2.ts ===
 // test.ts
 export = {
 >{  foo: [],  bar: undefined,  baz: null} : { foo: undefined[]; bar: undefined; baz: null; }

tests/baselines/reference/declarationEmitInferredTypeAlias1.js

@@ -1,4 +1,4 @@
-//// [tests/cases/compiler/declarationEmitInferedTypeAlias6.ts] ////
+//// [tests/cases/compiler/declarationEmitInferredTypeAlias1.ts] ////
 
 //// [0.ts]
 {

tests/baselines/reference/declarationEmitInferredTypeAlias2.js

@@ -1,4 +1,4 @@
-//// [tests/cases/compiler/declarationEmitInferedTypeAlias2.ts] ////
+//// [tests/cases/compiler/declarationEmitInferredTypeAlias2.ts] ////
 
 //// [0.ts]
 {

tests/baselines/reference/declarationEmitInferredTypeAlias3.js

@@ -1,4 +1,4 @@
-//// [tests/cases/compiler/declarationEmitInferedTypeAlias3.ts] ////
+//// [tests/cases/compiler/declarationEmitInferredTypeAlias3.ts] ////
 
 //// [0.ts]
 {

tests/baselines/reference/declarationEmitInferredTypeAlias4.js

@@ -1,18 +1,18 @@
-//// [declarationEmitInferedTypeAlias4.ts]
+//// [declarationEmitInferredTypeAlias4.ts]
 function f<A>() {
     type Foo<T> = T | { x: Foo<T> };
     var x: Foo<A[]>;
     return x;
 }
 
-//// [declarationEmitInferedTypeAlias4.js]
+//// [declarationEmitInferredTypeAlias4.js]
 function f() {
     var x;
     return x;
 }
 
 
-//// [declarationEmitInferedTypeAlias4.d.ts]
+//// [declarationEmitInferredTypeAlias4.d.ts]
 declare function f<A>(): A[] | {
     x: A[] | any;
 };

tests/baselines/reference/declarationEmitInferredTypeAlias4.symbols

@@ -0,0 +1,21 @@
+=== tests/cases/compiler/declarationEmitInferredTypeAlias4.ts ===
+function f<A>() {
+>f : Symbol(f, Decl(declarationEmitInferredTypeAlias4.ts, 0, 0))
+>A : Symbol(A, Decl(declarationEmitInferredTypeAlias4.ts, 0, 11))
+
+    type Foo<T> = T | { x: Foo<T> };
+>Foo : Symbol(Foo, Decl(declarationEmitInferredTypeAlias4.ts, 0, 17))
+>T : Symbol(T, Decl(declarationEmitInferredTypeAlias4.ts, 1, 13))
+>T : Symbol(T, Decl(declarationEmitInferredTypeAlias4.ts, 1, 13))
+>x : Symbol(x, Decl(declarationEmitInferredTypeAlias4.ts, 1, 23))
+>Foo : Symbol(Foo, Decl(declarationEmitInferredTypeAlias4.ts, 0, 17))
+>T : Symbol(T, Decl(declarationEmitInferredTypeAlias4.ts, 1, 13))
+
+    var x: Foo<A[]>;
+>x : Symbol(x, Decl(declarationEmitInferredTypeAlias4.ts, 2, 7))
+>Foo : Symbol(Foo, Decl(declarationEmitInferredTypeAlias4.ts, 0, 17))
+>A : Symbol(A, Decl(declarationEmitInferredTypeAlias4.ts, 0, 11))
+
+    return x;
+>x : Symbol(x, Decl(declarationEmitInferredTypeAlias4.ts, 2, 7))
+}

tests/baselines/reference/declarationEmitInferredTypeAlias4.types

@@ -1,4 +1,4 @@
-=== tests/cases/compiler/declarationEmitInferedTypeAlias4.ts ===
+=== tests/cases/compiler/declarationEmitInferredTypeAlias4.ts ===
 function f<A>() {
 >f : <A>() => A[] | { x: A[] | any; }
 >A : A

tests/baselines/reference/declarationEmitInferredTypeAlias5.js

@@ -1,4 +1,4 @@
-//// [tests/cases/compiler/declarationEmitInferedTypeAlias5.ts] ////
+//// [tests/cases/compiler/declarationEmitInferredTypeAlias5.ts] ////
 
 //// [0.ts]
 export type Data = string | boolean;

tests/baselines/reference/declarationEmitInferredTypeAlias6.js

@@ -1,4 +1,4 @@
-//// [tests/cases/compiler/declarationEmitInferedTypeAlias1.ts] ////
+//// [tests/cases/compiler/declarationEmitInferredTypeAlias6.ts] ////
 
 //// [0.ts]
 {

tests/baselines/reference/declarationEmitInferredTypeAlias7.js

@@ -1,4 +1,4 @@
-//// [tests/cases/compiler/declarationEmitInferedTypeAlias7.ts] ////
+//// [tests/cases/compiler/declarationEmitInferredTypeAlias7.ts] ////
 
 //// [0.ts]
 export type Data = string | boolean;

tests/baselines/reference/declarationEmitInferredTypeAlias8.js

@@ -1,4 +1,4 @@
-//// [declarationEmitInferedTypeAlias8.ts]
+//// [declarationEmitInferredTypeAlias8.ts]
 type Foo<T> = T | { x: Foo<T> };
 var x: Foo<number[]>;
 
@@ -6,14 +6,14 @@ function returnSomeGlobalValue() {
     return x;
 }
 
-//// [declarationEmitInferedTypeAlias8.js]
+//// [declarationEmitInferredTypeAlias8.js]
 var x;
 function returnSomeGlobalValue() {
     return x;
 }
 
 
-//// [declarationEmitInferedTypeAlias8.d.ts]
+//// [declarationEmitInferredTypeAlias8.d.ts]
 declare type Foo<T> = T | {
     x: Foo<T>;
 };

tests/baselines/reference/declarationEmitInferredTypeAlias8.symbols

@@ -0,0 +1,19 @@
+=== tests/cases/compiler/declarationEmitInferredTypeAlias8.ts ===
+type Foo<T> = T | { x: Foo<T> };
+>Foo : Symbol(Foo, Decl(declarationEmitInferredTypeAlias8.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitInferredTypeAlias8.ts, 0, 9))
+>T : Symbol(T, Decl(declarationEmitInferredTypeAlias8.ts, 0, 9))
+>x : Symbol(x, Decl(declarationEmitInferredTypeAlias8.ts, 0, 19))
+>Foo : Symbol(Foo, Decl(declarationEmitInferredTypeAlias8.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitInferredTypeAlias8.ts, 0, 9))
+
+var x: Foo<number[]>;
+>x : Symbol(x, Decl(declarationEmitInferredTypeAlias8.ts, 1, 3))
+>Foo : Symbol(Foo, Decl(declarationEmitInferredTypeAlias8.ts, 0, 0))
+
+function returnSomeGlobalValue() {
+>returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferredTypeAlias8.ts, 1, 21))
+
+    return x;
+>x : Symbol(x, Decl(declarationEmitInferredTypeAlias8.ts, 1, 3))
+}

tests/baselines/reference/declarationEmitInferredTypeAlias8.types

@@ -1,4 +1,4 @@
-=== tests/cases/compiler/declarationEmitInferedTypeAlias8.ts ===
+=== tests/cases/compiler/declarationEmitInferredTypeAlias8.ts ===
 type Foo<T> = T | { x: Foo<T> };
 >Foo : Foo<T>
 >T : T

tests/baselines/reference/declarationEmitInferredTypeAlias9.js

@@ -1,4 +1,4 @@
-//// [declarationEmitInferedTypeAlias9.ts]
+//// [declarationEmitInferredTypeAlias9.ts]
 type Foo<T> = T | { x: Foo<T> };
 var x: Foo<number[]>;
 
@@ -6,7 +6,7 @@ export function returnSomeGlobalValue() {
     return x;
 }
 
-//// [declarationEmitInferedTypeAlias9.js]
+//// [declarationEmitInferredTypeAlias9.js]
 "use strict";
 exports.__esModule = true;
 var x;
@@ -16,7 +16,7 @@ function returnSomeGlobalValue() {
 exports.returnSomeGlobalValue = returnSomeGlobalValue;
 
 
-//// [declarationEmitInferedTypeAlias9.d.ts]
+//// [declarationEmitInferredTypeAlias9.d.ts]
 export declare function returnSomeGlobalValue(): number[] | {
     x: number[] | any;
 };

tests/baselines/reference/declarationEmitInferredTypeAlias9.symbols

@@ -0,0 +1,19 @@
+=== tests/cases/compiler/declarationEmitInferredTypeAlias9.ts ===
+type Foo<T> = T | { x: Foo<T> };
+>Foo : Symbol(Foo, Decl(declarationEmitInferredTypeAlias9.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitInferredTypeAlias9.ts, 0, 9))
+>T : Symbol(T, Decl(declarationEmitInferredTypeAlias9.ts, 0, 9))
+>x : Symbol(x, Decl(declarationEmitInferredTypeAlias9.ts, 0, 19))
+>Foo : Symbol(Foo, Decl(declarationEmitInferredTypeAlias9.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitInferredTypeAlias9.ts, 0, 9))
+
+var x: Foo<number[]>;
+>x : Symbol(x, Decl(declarationEmitInferredTypeAlias9.ts, 1, 3))
+>Foo : Symbol(Foo, Decl(declarationEmitInferredTypeAlias9.ts, 0, 0))
+
+export function returnSomeGlobalValue() {
+>returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferredTypeAlias9.ts, 1, 21))
+
+    return x;
+>x : Symbol(x, Decl(declarationEmitInferredTypeAlias9.ts, 1, 3))
+}

tests/baselines/reference/declarationEmitInferredTypeAlias9.types

@@ -1,4 +1,4 @@
-=== tests/cases/compiler/declarationEmitInferedTypeAlias9.ts ===
+=== tests/cases/compiler/declarationEmitInferredTypeAlias9.ts ===
 type Foo<T> = T | { x: Foo<T> };
 >Foo : T | { x: T | any; }
 >T : T