From 293eba6203e16e7f26c3d1457f32f4447925ff15 Mon Sep 17 00:00:00 2001 From: Alan Pierce Date: Sat, 10 Nov 2018 14:45:26 -0800 Subject: [PATCH 01/20] Change isolatedModules to allow const enum declaration and disallow access Fixes #20703 with solution suggested in https://github.com/Microsoft/TypeScript/issues/20703#issuecomment-361434795 Previously, `--isolatedModules` gave an error for any ambient const enum, which meant that some third-party libraries would always give errors even if the ambient const enums they declare were never used. Now, we only give an error when an ambient const enum is referenced, which allows such libraries to still be used as long as the const enums are never accessed. Some nuances: * As before, the error is only surfaced for *ambient* const enums. With non-ambient const enums, we know that an `isolatedModules` build will emit the enum and produce a plain reference rather than inlining the constant, so everything will still work. * I originally planned to do this check in the code path that inlines the constant, but that code is only exercised at emit time, so, for example, the TS language service wasn't giving an error in my editor. Instead, I do the check at typecheck time next to another const-enum-related check. * This can be a breaking change when using `skipLibCheck` because the error is typically moved from a .d.ts file to a .ts file. Testing done: I ran this TS build on a large project of mine that previously had disabled `isolatedModules` so I could use the `chalk` library. With `isolatedModules` enabled, there was no longer an error in the chalk typedefs, and a reference to the `Level` const enum produced an error in my editor. --- src/compiler/checker.ts | 44 +++++++++++-------- src/compiler/diagnosticMessages.json | 8 ++-- ...isolatedModulesAmbientConstEnum.errors.txt | 9 ++-- .../isolatedModulesAmbientConstEnum.js | 5 ++- .../isolatedModulesAmbientConstEnum.symbols | 5 ++- .../isolatedModulesAmbientConstEnum.types | 7 ++- .../isolatedModulesAmbientConstEnum.ts | 2 +- 7 files changed, 48 insertions(+), 32 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e24c707d2d7..1e54b5d7848 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -22567,23 +22567,35 @@ namespace ts { } if (isConstEnumObjectType(type)) { - // enum object type for const enums are only permitted in: - // - 'left' in property access - // - 'object' in indexed access - // - target in rhs of import statement - const ok = - (node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).expression === node) || - (node.parent.kind === SyntaxKind.ElementAccessExpression && (node.parent).expression === node) || - ((node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) && isInRightSideOfImportOrExportAssignment(node) || - (node.parent.kind === SyntaxKind.TypeQuery && (node.parent).exprName === node)); - - if (!ok) { - error(node, Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query); - } + checkConstEnumAccess(node, type); } return type; } + function checkConstEnumAccess(node: Expression | QualifiedName, type: Type) { + // enum object type for const enums are only permitted in: + // - 'left' in property access + // - 'object' in indexed access + // - target in rhs of import statement + const ok = + (node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).expression === node) || + (node.parent.kind === SyntaxKind.ElementAccessExpression && (node.parent).expression === node) || + ((node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) && isInRightSideOfImportOrExportAssignment(node) || + (node.parent.kind === SyntaxKind.TypeQuery && (node.parent).exprName === node)); + + if (!ok) { + error(node, Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query); + } + + if (compilerOptions.isolatedModules) { + Debug.assert(!!(type.symbol.flags & SymbolFlags.ConstEnum)); + const constEnumDeclaration = type.symbol.valueDeclaration as EnumDeclaration; + if (constEnumDeclaration.flags & NodeFlags.Ambient) { + error(node, Diagnostics.Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided); + } + } + } + function checkParenthesizedExpression(node: ParenthesizedExpression, checkMode?: CheckMode): Type { const tag = isInJSFile(node) ? getJSDocTypeTag(node) : undefined; if (tag) { @@ -26721,11 +26733,6 @@ namespace ts { computeEnumMemberValues(node); - const enumIsConst = isEnumConst(node); - if (compilerOptions.isolatedModules && enumIsConst && node.flags & NodeFlags.Ambient) { - error(node.name, Diagnostics.Ambient_const_enums_are_not_allowed_when_the_isolatedModules_flag_is_provided); - } - // Spec 2014 - Section 9.3: // It isn't possible for one enum declaration to continue the automatic numbering sequence of another, // and when an enum type has multiple declarations, only one declaration is permitted to omit a value @@ -26736,6 +26743,7 @@ namespace ts { const firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind); if (node === firstDeclaration) { if (enumSymbol.declarations.length > 1) { + const enumIsConst = isEnumConst(node); // check that const is placed\omitted on all enum declarations forEach(enumSymbol.declarations, decl => { if (isEnumDeclaration(decl) && isEnumConst(decl) !== enumIsConst) { diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 3ba74f03073..f593a49398d 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -659,10 +659,6 @@ "category": "Error", "code": 1208 }, - "Ambient const enums are not allowed when the '--isolatedModules' flag is provided.": { - "category": "Error", - "code": 1209 - }, "Invalid use of '{0}'. Class definitions are automatically in strict mode.": { "category": "Error", "code": 1210 @@ -2513,6 +2509,10 @@ "category": "Message", "code": 2738 }, + "Cannot access ambient const enums when the '--isolatedModules' flag is provided.": { + "category": "Error", + "code": 2739 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt b/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt index 642e38cc6e0..c4569f2ac3e 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt @@ -1,8 +1,9 @@ -tests/cases/compiler/file1.ts(1,20): error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided. +tests/cases/compiler/file1.ts(2,16): error TS2739: Cannot access ambient const enums when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/file1.ts (1 errors) ==== declare const enum E { X = 1} - ~ -!!! error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided. - export var y; \ No newline at end of file + export var y = E.X; + ~ +!!! error TS2739: Cannot access ambient const enums when the '--isolatedModules' flag is provided. + \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.js b/tests/baselines/reference/isolatedModulesAmbientConstEnum.js index 44b6e1c1d76..2977c8ab827 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.js +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.js @@ -1,6 +1,7 @@ //// [file1.ts] declare const enum E { X = 1} -export var y; +export var y = E.X; + //// [file1.js] -export var y; +export var y = E.X; diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.symbols b/tests/baselines/reference/isolatedModulesAmbientConstEnum.symbols index 2da04dbdf02..828f79379b1 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.symbols +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.symbols @@ -3,6 +3,9 @@ declare const enum E { X = 1} >E : Symbol(E, Decl(file1.ts, 0, 0)) >X : Symbol(E.X, Decl(file1.ts, 0, 22)) -export var y; +export var y = E.X; >y : Symbol(y, Decl(file1.ts, 1, 10)) +>E.X : Symbol(E.X, Decl(file1.ts, 0, 22)) +>E : Symbol(E, Decl(file1.ts, 0, 0)) +>X : Symbol(E.X, Decl(file1.ts, 0, 22)) diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.types b/tests/baselines/reference/isolatedModulesAmbientConstEnum.types index 8b714d98f6e..bb4212895f9 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.types +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.types @@ -4,6 +4,9 @@ declare const enum E { X = 1} >X : E.X >1 : 1 -export var y; ->y : any +export var y = E.X; +>y : E +>E.X : E +>E : typeof E +>X : E diff --git a/tests/cases/compiler/isolatedModulesAmbientConstEnum.ts b/tests/cases/compiler/isolatedModulesAmbientConstEnum.ts index 59fcdcd1fe4..993235c2c0c 100644 --- a/tests/cases/compiler/isolatedModulesAmbientConstEnum.ts +++ b/tests/cases/compiler/isolatedModulesAmbientConstEnum.ts @@ -4,4 +4,4 @@ // @filename: file1.ts declare const enum E { X = 1} -export var y; \ No newline at end of file +export var y = E.X; From beae9d7be94337482bf4539b9547bfd512f53364 Mon Sep 17 00:00:00 2001 From: Alan Pierce Date: Fri, 25 Jan 2019 09:31:36 -0800 Subject: [PATCH 02/20] Accept whitespace change in baseline after merge --- .../reference/isolatedModulesAmbientConstEnum.errors.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt b/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt index 417436486de..6deae7b10e1 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt @@ -6,3 +6,4 @@ tests/cases/compiler/file1.ts(2,16): error TS2748: Cannot access ambient const e export var y = E.X; ~ !!! error TS2748: Cannot access ambient const enums when the '--isolatedModules' flag is provided. + \ No newline at end of file From 3d0c7f3156c14152d021d1452fd742c8f6802926 Mon Sep 17 00:00:00 2001 From: Jack Williams Date: Sun, 3 Feb 2019 16:07:21 +0000 Subject: [PATCH 03/20] Narrow unknown in switch --- src/compiler/checker.ts | 26 +- .../reference/unknownType2.errors.txt | 231 ++++++++++ tests/baselines/reference/unknownType2.js | 205 ++++++++- .../baselines/reference/unknownType2.symbols | 417 +++++++++++++++--- tests/baselines/reference/unknownType2.types | 306 ++++++++++++- .../conformance/types/unknown/unknownType2.ts | 112 ++++- 6 files changed, 1226 insertions(+), 71 deletions(-) create mode 100644 tests/baselines/reference/unknownType2.errors.txt diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 2e6259b668a..a4c4761fb55 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -16152,13 +16152,37 @@ namespace ts { } function narrowTypeBySwitchOnDiscriminant(type: Type, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number) { - // We only narrow if all case expressions specify values with unit types + // We only narrow if all case expressions specify + // values with unit types, except for the case where + // `type` is unknown. In this instance we map object + // types to the nonPrimitive type and narrow with that. const switchTypes = getSwitchClauseTypes(switchStatement); if (!switchTypes.length) { return type; } const clauseTypes = switchTypes.slice(clauseStart, clauseEnd); const hasDefaultClause = clauseStart === clauseEnd || contains(clauseTypes, neverType); + if ((type.flags & TypeFlags.Unknown) && !hasDefaultClause) { + let groundClauseTypes: Type[] | undefined = undefined; + for (let i = 0; i < clauseTypes.length; i += 1) { + const t = clauseTypes[i]; + if (t.flags & (TypeFlags.Primitive | TypeFlags.NonPrimitive)) { + if (groundClauseTypes !== undefined) { + groundClauseTypes.push(t) + } + } + else if (t.flags & TypeFlags.Object) { + if (groundClauseTypes === undefined) { + groundClauseTypes = clauseTypes.slice(0, i); + } + groundClauseTypes.push(nonPrimitiveType); + } + else { + return type; + } + } + return getUnionType(groundClauseTypes === undefined ? clauseTypes : groundClauseTypes); + } const discriminantType = getUnionType(clauseTypes); const caseType = discriminantType.flags & TypeFlags.Never ? neverType : diff --git a/tests/baselines/reference/unknownType2.errors.txt b/tests/baselines/reference/unknownType2.errors.txt new file mode 100644 index 00000000000..5f08804b9e0 --- /dev/null +++ b/tests/baselines/reference/unknownType2.errors.txt @@ -0,0 +1,231 @@ +tests/cases/conformance/types/unknown/unknownType2.ts(216,13): error TS2322: Type '"yes" | "no" | "maybe"' is not assignable to type 'SomeResponse'. + Type '"maybe"' is not assignable to type 'SomeResponse'. + + +==== tests/cases/conformance/types/unknown/unknownType2.ts (1 errors) ==== + type isUnknown = unknown extends T ? true : false; + type isTrue = T; + + type SomeResponse = 'yes' | 'no' | 'idk'; + let validate: (x: unknown) => SomeResponse = x => (x === 'yes' || x === 'no') ? x : 'idk'; // No error + + const u: unknown = undefined; + + declare const symb: unique symbol; + declare const symbNonUnique: symbol; + + if (u === 5) { + const y = u.toString(10); + } + + if (u === true || u === false) { + const someBool: boolean = u; + } + + if (u === undefined) { + const undef: undefined = u; + } + + if (u === null) { + const someNull: null = u; + } + + if (u === symb) { + const symbolAlias: typeof symb = u; + } + + if (!(u === 42)) { + type A = isTrue> + } + + if (u !== 42) { + type B = isTrue> + } + + if (u == 42) { + type C = isTrue> + } + + if (u == true) { + type D = isTrue> + } + + if (u == Object) { + type E = isTrue> + } + + declare const aString: string; + declare const aBoolean: boolean; + declare const aNumber: number; + declare const anObject: object; + declare const anObjectLiteral: { x: number }; + declare const aUnion: { x: number } | { y: string }; + declare const anIntersection: { x: number } & { y: string }; + declare const aFunction: () => number; + + if (u === aString) { + let uString: string = u; + } + + if (u === aBoolean) { + let uString: boolean = u; + } + + if (u === aNumber) { + let uNumber: number = u; + } + + if (u === anObject) { + let uObject: object = u; + } + + if (u === anObjectLiteral) { + let uObjectLiteral: object = u; + } + + if (u === aUnion) { + type unionDoesNotNarrow = isTrue> + } + + if (u === anIntersection) { + type intersectionDoesNotNarrow = isTrue> + } + + if (u === aFunction) { + let uFunction: object = u; + } + + enum NumberEnum { + A, + B, + C + } + + enum StringEnum { + A = "A", + B = "B", + C = "C" + } + + if (u === NumberEnum || u === StringEnum) { + let enumObj: object = u; + } + + if (u === NumberEnum.A) { + let a: NumberEnum.A = u + } + + if (u === StringEnum.B) { + let b: StringEnum.B = u + } + + function switchTestEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + break; + case StringEnum.B: + const b: StringEnum.B = x; + break; + case StringEnum.C: + const c: StringEnum.C = x; + break; + } + type End = isTrue> + } + + function switchTestCollectEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + case StringEnum.B: + const b: StringEnum.A | StringEnum.B = x; + case StringEnum.C: + const c: StringEnum.A | StringEnum.B | StringEnum.C = x; + const all: StringEnum = x; + return; + } + type End = isTrue> + } + + function switchTestLiterals(x: unknown) { + switch (x) { + case 1: + const one: 1 = x; + break; + case 2: + const two: 2 = x; + break; + case 3: + const three: 3 = x; + break; + case true: + const t: true = x; + break; + case false: + const f: false = x; + break; + case "A": + const a: "A" = x; + break; + case undefined: + const undef: undefined = x; + break; + case null: + const llun: null = x; + break; + case symb: + const anotherSymbol: typeof symb = x; + break; + case symbNonUnique: + const nonUniqueSymbol: symbol = x; + break; + } + type End = isTrue> + } + + function switchTestObjects(x: unknown, y: () => void, z: { prop: number }) { + switch (x) { + case true: + case false: + const bool: boolean = x; + break; + case y: + const obj1: object = x; + break; + case z: + const obj2: object = x; + break; + } + type End = isTrue> + } + + function switchResponse(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'idk': + return x; + default: + throw new Error('unknown response'); + } + // Arguably this should be never. + type End = isTrue> + } + + function switchResponseWrong(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'maybe': + return x; // error + ~~~~~~~~~ +!!! error TS2322: Type '"yes" | "no" | "maybe"' is not assignable to type 'SomeResponse'. +!!! error TS2322: Type '"maybe"' is not assignable to type 'SomeResponse'. + default: + throw new Error('Can you repeat the question?'); + } + // Arguably this should be never. + type End = isTrue> + } + \ No newline at end of file diff --git a/tests/baselines/reference/unknownType2.js b/tests/baselines/reference/unknownType2.js index 66b763efb58..2ec5b3ed205 100644 --- a/tests/baselines/reference/unknownType2.js +++ b/tests/baselines/reference/unknownType2.js @@ -8,6 +8,7 @@ let validate: (x: unknown) => SomeResponse = x => (x === 'yes' || x === 'no') ? const u: unknown = undefined; declare const symb: unique symbol; +declare const symbNonUnique: symbol; if (u === 5) { const y = u.toString(10); @@ -106,13 +107,120 @@ if (u === NumberEnum || u === StringEnum) { let enumObj: object = u; } -if(u === NumberEnum.A) { +if (u === NumberEnum.A) { let a: NumberEnum.A = u } -if(u === StringEnum.B) { +if (u === StringEnum.B) { let b: StringEnum.B = u } + +function switchTestEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + break; + case StringEnum.B: + const b: StringEnum.B = x; + break; + case StringEnum.C: + const c: StringEnum.C = x; + break; + } + type End = isTrue> +} + +function switchTestCollectEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + case StringEnum.B: + const b: StringEnum.A | StringEnum.B = x; + case StringEnum.C: + const c: StringEnum.A | StringEnum.B | StringEnum.C = x; + const all: StringEnum = x; + return; + } + type End = isTrue> +} + +function switchTestLiterals(x: unknown) { + switch (x) { + case 1: + const one: 1 = x; + break; + case 2: + const two: 2 = x; + break; + case 3: + const three: 3 = x; + break; + case true: + const t: true = x; + break; + case false: + const f: false = x; + break; + case "A": + const a: "A" = x; + break; + case undefined: + const undef: undefined = x; + break; + case null: + const llun: null = x; + break; + case symb: + const anotherSymbol: typeof symb = x; + break; + case symbNonUnique: + const nonUniqueSymbol: symbol = x; + break; + } + type End = isTrue> +} + +function switchTestObjects(x: unknown, y: () => void, z: { prop: number }) { + switch (x) { + case true: + case false: + const bool: boolean = x; + break; + case y: + const obj1: object = x; + break; + case z: + const obj2: object = x; + break; + } + type End = isTrue> +} + +function switchResponse(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'idk': + return x; + default: + throw new Error('unknown response'); + } + // Arguably this should be never. + type End = isTrue> +} + +function switchResponseWrong(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'maybe': + return x; // error + default: + throw new Error('Can you repeat the question?'); + } + // Arguably this should be never. + type End = isTrue> +} //// [unknownType2.js] @@ -187,3 +295,96 @@ if (u === NumberEnum.A) { if (u === StringEnum.B) { var b = u; } +function switchTestEnum(x) { + switch (x) { + case StringEnum.A: + var a = x; + break; + case StringEnum.B: + var b = x; + break; + case StringEnum.C: + var c = x; + break; + } +} +function switchTestCollectEnum(x) { + switch (x) { + case StringEnum.A: + var a = x; + case StringEnum.B: + var b = x; + case StringEnum.C: + var c = x; + var all = x; + return; + } +} +function switchTestLiterals(x) { + switch (x) { + case 1: + var one = x; + break; + case 2: + var two = x; + break; + case 3: + var three = x; + break; + case true: + var t = x; + break; + case false: + var f = x; + break; + case "A": + var a = x; + break; + case undefined: + var undef = x; + break; + case null: + var llun = x; + break; + case symb: + var anotherSymbol = x; + break; + case symbNonUnique: + var nonUniqueSymbol = x; + break; + } +} +function switchTestObjects(x, y, z) { + switch (x) { + case true: + case false: + var bool = x; + break; + case y: + var obj1 = x; + break; + case z: + var obj2 = x; + break; + } +} +function switchResponse(x) { + switch (x) { + case 'yes': + case 'no': + case 'idk': + return x; + default: + throw new Error('unknown response'); + } +} +function switchResponseWrong(x) { + switch (x) { + case 'yes': + case 'no': + case 'maybe': + return x; // error + default: + throw new Error('Can you repeat the question?'); + } +} diff --git a/tests/baselines/reference/unknownType2.symbols b/tests/baselines/reference/unknownType2.symbols index 577b1186def..6e871bd4de4 100644 --- a/tests/baselines/reference/unknownType2.symbols +++ b/tests/baselines/reference/unknownType2.symbols @@ -28,11 +28,14 @@ const u: unknown = undefined; declare const symb: unique symbol; >symb : Symbol(symb, Decl(unknownType2.ts, 8, 13)) +declare const symbNonUnique: symbol; +>symbNonUnique : Symbol(symbNonUnique, Decl(unknownType2.ts, 9, 13)) + if (u === 5) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) const y = u.toString(10); ->y : Symbol(y, Decl(unknownType2.ts, 11, 9)) +>y : Symbol(y, Decl(unknownType2.ts, 12, 9)) >u.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) >toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) @@ -43,7 +46,7 @@ if (u === true || u === false) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) const someBool: boolean = u; ->someBool : Symbol(someBool, Decl(unknownType2.ts, 15, 9)) +>someBool : Symbol(someBool, Decl(unknownType2.ts, 16, 9)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } @@ -52,7 +55,7 @@ if (u === undefined) { >undefined : Symbol(undefined) const undef: undefined = u; ->undef : Symbol(undef, Decl(unknownType2.ts, 19, 9)) +>undef : Symbol(undef, Decl(unknownType2.ts, 20, 9)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } @@ -60,7 +63,7 @@ if (u === null) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) const someNull: null = u; ->someNull : Symbol(someNull, Decl(unknownType2.ts, 23, 9)) +>someNull : Symbol(someNull, Decl(unknownType2.ts, 24, 9)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } @@ -69,7 +72,7 @@ if (u === symb) { >symb : Symbol(symb, Decl(unknownType2.ts, 8, 13)) const symbolAlias: typeof symb = u; ->symbolAlias : Symbol(symbolAlias, Decl(unknownType2.ts, 27, 9)) +>symbolAlias : Symbol(symbolAlias, Decl(unknownType2.ts, 28, 9)) >symb : Symbol(symb, Decl(unknownType2.ts, 8, 13)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } @@ -78,7 +81,7 @@ if (!(u === 42)) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) type A = isTrue> ->A : Symbol(A, Decl(unknownType2.ts, 30, 18)) +>A : Symbol(A, Decl(unknownType2.ts, 31, 18)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -88,7 +91,7 @@ if (u !== 42) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) type B = isTrue> ->B : Symbol(B, Decl(unknownType2.ts, 34, 15)) +>B : Symbol(B, Decl(unknownType2.ts, 35, 15)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -98,7 +101,7 @@ if (u == 42) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) type C = isTrue> ->C : Symbol(C, Decl(unknownType2.ts, 38, 14)) +>C : Symbol(C, Decl(unknownType2.ts, 39, 14)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -108,7 +111,7 @@ if (u == true) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) type D = isTrue> ->D : Symbol(D, Decl(unknownType2.ts, 42, 16)) +>D : Symbol(D, Decl(unknownType2.ts, 43, 16)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -119,92 +122,92 @@ if (u == Object) { >Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) type E = isTrue> ->E : Symbol(E, Decl(unknownType2.ts, 46, 18)) +>E : Symbol(E, Decl(unknownType2.ts, 47, 18)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } declare const aString: string; ->aString : Symbol(aString, Decl(unknownType2.ts, 50, 13)) +>aString : Symbol(aString, Decl(unknownType2.ts, 51, 13)) declare const aBoolean: boolean; ->aBoolean : Symbol(aBoolean, Decl(unknownType2.ts, 51, 13)) +>aBoolean : Symbol(aBoolean, Decl(unknownType2.ts, 52, 13)) declare const aNumber: number; ->aNumber : Symbol(aNumber, Decl(unknownType2.ts, 52, 13)) +>aNumber : Symbol(aNumber, Decl(unknownType2.ts, 53, 13)) declare const anObject: object; ->anObject : Symbol(anObject, Decl(unknownType2.ts, 53, 13)) +>anObject : Symbol(anObject, Decl(unknownType2.ts, 54, 13)) declare const anObjectLiteral: { x: number }; ->anObjectLiteral : Symbol(anObjectLiteral, Decl(unknownType2.ts, 54, 13)) ->x : Symbol(x, Decl(unknownType2.ts, 54, 32)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(unknownType2.ts, 55, 13)) +>x : Symbol(x, Decl(unknownType2.ts, 55, 32)) declare const aUnion: { x: number } | { y: string }; ->aUnion : Symbol(aUnion, Decl(unknownType2.ts, 55, 13)) ->x : Symbol(x, Decl(unknownType2.ts, 55, 23)) ->y : Symbol(y, Decl(unknownType2.ts, 55, 39)) +>aUnion : Symbol(aUnion, Decl(unknownType2.ts, 56, 13)) +>x : Symbol(x, Decl(unknownType2.ts, 56, 23)) +>y : Symbol(y, Decl(unknownType2.ts, 56, 39)) declare const anIntersection: { x: number } & { y: string }; ->anIntersection : Symbol(anIntersection, Decl(unknownType2.ts, 56, 13)) ->x : Symbol(x, Decl(unknownType2.ts, 56, 31)) ->y : Symbol(y, Decl(unknownType2.ts, 56, 47)) +>anIntersection : Symbol(anIntersection, Decl(unknownType2.ts, 57, 13)) +>x : Symbol(x, Decl(unknownType2.ts, 57, 31)) +>y : Symbol(y, Decl(unknownType2.ts, 57, 47)) declare const aFunction: () => number; ->aFunction : Symbol(aFunction, Decl(unknownType2.ts, 57, 13)) +>aFunction : Symbol(aFunction, Decl(unknownType2.ts, 58, 13)) if (u === aString) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->aString : Symbol(aString, Decl(unknownType2.ts, 50, 13)) +>aString : Symbol(aString, Decl(unknownType2.ts, 51, 13)) let uString: string = u; ->uString : Symbol(uString, Decl(unknownType2.ts, 60, 7)) +>uString : Symbol(uString, Decl(unknownType2.ts, 61, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } if (u === aBoolean) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->aBoolean : Symbol(aBoolean, Decl(unknownType2.ts, 51, 13)) +>aBoolean : Symbol(aBoolean, Decl(unknownType2.ts, 52, 13)) let uString: boolean = u; ->uString : Symbol(uString, Decl(unknownType2.ts, 64, 7)) +>uString : Symbol(uString, Decl(unknownType2.ts, 65, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } if (u === aNumber) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->aNumber : Symbol(aNumber, Decl(unknownType2.ts, 52, 13)) +>aNumber : Symbol(aNumber, Decl(unknownType2.ts, 53, 13)) let uNumber: number = u; ->uNumber : Symbol(uNumber, Decl(unknownType2.ts, 68, 7)) +>uNumber : Symbol(uNumber, Decl(unknownType2.ts, 69, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } if (u === anObject) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->anObject : Symbol(anObject, Decl(unknownType2.ts, 53, 13)) +>anObject : Symbol(anObject, Decl(unknownType2.ts, 54, 13)) let uObject: object = u; ->uObject : Symbol(uObject, Decl(unknownType2.ts, 72, 7)) +>uObject : Symbol(uObject, Decl(unknownType2.ts, 73, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } if (u === anObjectLiteral) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->anObjectLiteral : Symbol(anObjectLiteral, Decl(unknownType2.ts, 54, 13)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(unknownType2.ts, 55, 13)) let uObjectLiteral: object = u; ->uObjectLiteral : Symbol(uObjectLiteral, Decl(unknownType2.ts, 76, 7)) +>uObjectLiteral : Symbol(uObjectLiteral, Decl(unknownType2.ts, 77, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } if (u === aUnion) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->aUnion : Symbol(aUnion, Decl(unknownType2.ts, 55, 13)) +>aUnion : Symbol(aUnion, Decl(unknownType2.ts, 56, 13)) type unionDoesNotNarrow = isTrue> ->unionDoesNotNarrow : Symbol(unionDoesNotNarrow, Decl(unknownType2.ts, 79, 19)) +>unionDoesNotNarrow : Symbol(unionDoesNotNarrow, Decl(unknownType2.ts, 80, 19)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -212,10 +215,10 @@ if (u === aUnion) { if (u === anIntersection) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->anIntersection : Symbol(anIntersection, Decl(unknownType2.ts, 56, 13)) +>anIntersection : Symbol(anIntersection, Decl(unknownType2.ts, 57, 13)) type intersectionDoesNotNarrow = isTrue> ->intersectionDoesNotNarrow : Symbol(intersectionDoesNotNarrow, Decl(unknownType2.ts, 83, 27)) +>intersectionDoesNotNarrow : Symbol(intersectionDoesNotNarrow, Decl(unknownType2.ts, 84, 27)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -223,73 +226,359 @@ if (u === anIntersection) { if (u === aFunction) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->aFunction : Symbol(aFunction, Decl(unknownType2.ts, 57, 13)) +>aFunction : Symbol(aFunction, Decl(unknownType2.ts, 58, 13)) let uFunction: object = u; ->uFunction : Symbol(uFunction, Decl(unknownType2.ts, 88, 7)) +>uFunction : Symbol(uFunction, Decl(unknownType2.ts, 89, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } enum NumberEnum { ->NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 89, 1)) +>NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 90, 1)) A, ->A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 91, 17)) +>A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 92, 17)) B, ->B : Symbol(NumberEnum.B, Decl(unknownType2.ts, 92, 6)) +>B : Symbol(NumberEnum.B, Decl(unknownType2.ts, 93, 6)) C ->C : Symbol(NumberEnum.C, Decl(unknownType2.ts, 93, 6)) +>C : Symbol(NumberEnum.C, Decl(unknownType2.ts, 94, 6)) } enum StringEnum { ->StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 95, 1)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) A = "A", ->A : Symbol(StringEnum.A, Decl(unknownType2.ts, 97, 17)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) B = "B", ->B : Symbol(StringEnum.B, Decl(unknownType2.ts, 98, 12)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) C = "C" ->C : Symbol(StringEnum.C, Decl(unknownType2.ts, 99, 12)) +>C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) } if (u === NumberEnum || u === StringEnum) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 89, 1)) +>NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 90, 1)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 95, 1)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) let enumObj: object = u; ->enumObj : Symbol(enumObj, Decl(unknownType2.ts, 104, 7)) +>enumObj : Symbol(enumObj, Decl(unknownType2.ts, 105, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } -if(u === NumberEnum.A) { +if (u === NumberEnum.A) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->NumberEnum.A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 91, 17)) ->NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 89, 1)) ->A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 91, 17)) +>NumberEnum.A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 92, 17)) +>NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 90, 1)) +>A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 92, 17)) let a: NumberEnum.A = u ->a : Symbol(a, Decl(unknownType2.ts, 108, 7)) ->NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 89, 1)) ->A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 91, 17)) +>a : Symbol(a, Decl(unknownType2.ts, 109, 7)) +>NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 90, 1)) +>A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 92, 17)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } -if(u === StringEnum.B) { +if (u === StringEnum.B) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->StringEnum.B : Symbol(StringEnum.B, Decl(unknownType2.ts, 98, 12)) ->StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 95, 1)) ->B : Symbol(StringEnum.B, Decl(unknownType2.ts, 98, 12)) +>StringEnum.B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) let b: StringEnum.B = u ->b : Symbol(b, Decl(unknownType2.ts, 112, 7)) ->StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 95, 1)) ->B : Symbol(StringEnum.B, Decl(unknownType2.ts, 98, 12)) +>b : Symbol(b, Decl(unknownType2.ts, 113, 7)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } +function switchTestEnum(x: unknown) { +>switchTestEnum : Symbol(switchTestEnum, Decl(unknownType2.ts, 114, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) + + case StringEnum.A: +>StringEnum.A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) + + const a: StringEnum.A = x; +>a : Symbol(a, Decl(unknownType2.ts, 119, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) + + break; + case StringEnum.B: +>StringEnum.B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) + + const b: StringEnum.B = x; +>b : Symbol(b, Decl(unknownType2.ts, 122, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) + + break; + case StringEnum.C: +>StringEnum.C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) + + const c: StringEnum.C = x; +>c : Symbol(c, Decl(unknownType2.ts, 125, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) + + break; + } + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 127, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) +} + +function switchTestCollectEnum(x: unknown) { +>switchTestCollectEnum : Symbol(switchTestCollectEnum, Decl(unknownType2.ts, 129, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + case StringEnum.A: +>StringEnum.A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) + + const a: StringEnum.A = x; +>a : Symbol(a, Decl(unknownType2.ts, 134, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + case StringEnum.B: +>StringEnum.B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) + + const b: StringEnum.A | StringEnum.B = x; +>b : Symbol(b, Decl(unknownType2.ts, 136, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + case StringEnum.C: +>StringEnum.C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) + + const c: StringEnum.A | StringEnum.B | StringEnum.C = x; +>c : Symbol(c, Decl(unknownType2.ts, 138, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + const all: StringEnum = x; +>all : Symbol(all, Decl(unknownType2.ts, 139, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + return; + } + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 141, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) +} + +function switchTestLiterals(x: unknown) { +>switchTestLiterals : Symbol(switchTestLiterals, Decl(unknownType2.ts, 143, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + case 1: + const one: 1 = x; +>one : Symbol(one, Decl(unknownType2.ts, 148, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case 2: + const two: 2 = x; +>two : Symbol(two, Decl(unknownType2.ts, 151, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case 3: + const three: 3 = x; +>three : Symbol(three, Decl(unknownType2.ts, 154, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case true: + const t: true = x; +>t : Symbol(t, Decl(unknownType2.ts, 157, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case false: + const f: false = x; +>f : Symbol(f, Decl(unknownType2.ts, 160, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case "A": + const a: "A" = x; +>a : Symbol(a, Decl(unknownType2.ts, 163, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case undefined: +>undefined : Symbol(undefined) + + const undef: undefined = x; +>undef : Symbol(undef, Decl(unknownType2.ts, 166, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case null: + const llun: null = x; +>llun : Symbol(llun, Decl(unknownType2.ts, 169, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case symb: +>symb : Symbol(symb, Decl(unknownType2.ts, 8, 13)) + + const anotherSymbol: typeof symb = x; +>anotherSymbol : Symbol(anotherSymbol, Decl(unknownType2.ts, 172, 17)) +>symb : Symbol(symb, Decl(unknownType2.ts, 8, 13)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case symbNonUnique: +>symbNonUnique : Symbol(symbNonUnique, Decl(unknownType2.ts, 9, 13)) + + const nonUniqueSymbol: symbol = x; +>nonUniqueSymbol : Symbol(nonUniqueSymbol, Decl(unknownType2.ts, 175, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + } + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 177, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) +} + +function switchTestObjects(x: unknown, y: () => void, z: { prop: number }) { +>switchTestObjects : Symbol(switchTestObjects, Decl(unknownType2.ts, 179, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) +>y : Symbol(y, Decl(unknownType2.ts, 181, 38)) +>z : Symbol(z, Decl(unknownType2.ts, 181, 53)) +>prop : Symbol(prop, Decl(unknownType2.ts, 181, 58)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) + + case true: + case false: + const bool: boolean = x; +>bool : Symbol(bool, Decl(unknownType2.ts, 185, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) + + break; + case y: +>y : Symbol(y, Decl(unknownType2.ts, 181, 38)) + + const obj1: object = x; +>obj1 : Symbol(obj1, Decl(unknownType2.ts, 188, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) + + break; + case z: +>z : Symbol(z, Decl(unknownType2.ts, 181, 53)) + + const obj2: object = x; +>obj2 : Symbol(obj2, Decl(unknownType2.ts, 191, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) + + break; + } + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 193, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) +} + +function switchResponse(x: unknown): SomeResponse { +>switchResponse : Symbol(switchResponse, Decl(unknownType2.ts, 195, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 197, 24)) +>SomeResponse : Symbol(SomeResponse, Decl(unknownType2.ts, 1, 32)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 197, 24)) + + case 'yes': + case 'no': + case 'idk': + return x; +>x : Symbol(x, Decl(unknownType2.ts, 197, 24)) + + default: + throw new Error('unknown response'); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } + // Arguably this should be never. + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 205, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 197, 24)) +} + +function switchResponseWrong(x: unknown): SomeResponse { +>switchResponseWrong : Symbol(switchResponseWrong, Decl(unknownType2.ts, 208, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 210, 29)) +>SomeResponse : Symbol(SomeResponse, Decl(unknownType2.ts, 1, 32)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 210, 29)) + + case 'yes': + case 'no': + case 'maybe': + return x; // error +>x : Symbol(x, Decl(unknownType2.ts, 210, 29)) + + default: + throw new Error('Can you repeat the question?'); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } + // Arguably this should be never. + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 218, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 210, 29)) +} + diff --git a/tests/baselines/reference/unknownType2.types b/tests/baselines/reference/unknownType2.types index f90d85525cc..7fc3c3d1038 100644 --- a/tests/baselines/reference/unknownType2.types +++ b/tests/baselines/reference/unknownType2.types @@ -35,6 +35,9 @@ const u: unknown = undefined; declare const symb: unique symbol; >symb : unique symbol +declare const symbNonUnique: symbol; +>symbNonUnique : symbol + if (u === 5) { >u === 5 : boolean >u : unknown @@ -299,7 +302,7 @@ if (u === NumberEnum || u === StringEnum) { >u : object } -if(u === NumberEnum.A) { +if (u === NumberEnum.A) { >u === NumberEnum.A : boolean >u : unknown >NumberEnum.A : NumberEnum.A @@ -312,7 +315,7 @@ if(u === NumberEnum.A) { >u : NumberEnum.A } -if(u === StringEnum.B) { +if (u === StringEnum.B) { >u === StringEnum.B : boolean >u : unknown >StringEnum.B : StringEnum.B @@ -325,3 +328,302 @@ if(u === StringEnum.B) { >u : StringEnum.B } +function switchTestEnum(x: unknown) { +>switchTestEnum : (x: unknown) => void +>x : unknown + + switch (x) { +>x : unknown + + case StringEnum.A: +>StringEnum.A : StringEnum.A +>StringEnum : typeof StringEnum +>A : StringEnum.A + + const a: StringEnum.A = x; +>a : StringEnum.A +>StringEnum : any +>x : StringEnum.A + + break; + case StringEnum.B: +>StringEnum.B : StringEnum.B +>StringEnum : typeof StringEnum +>B : StringEnum.B + + const b: StringEnum.B = x; +>b : StringEnum.B +>StringEnum : any +>x : StringEnum.B + + break; + case StringEnum.C: +>StringEnum.C : StringEnum.C +>StringEnum : typeof StringEnum +>C : StringEnum.C + + const c: StringEnum.C = x; +>c : StringEnum.C +>StringEnum : any +>x : StringEnum.C + + break; + } + type End = isTrue> +>End : true +>x : unknown +} + +function switchTestCollectEnum(x: unknown) { +>switchTestCollectEnum : (x: unknown) => void +>x : unknown + + switch (x) { +>x : unknown + + case StringEnum.A: +>StringEnum.A : StringEnum.A +>StringEnum : typeof StringEnum +>A : StringEnum.A + + const a: StringEnum.A = x; +>a : StringEnum.A +>StringEnum : any +>x : StringEnum.A + + case StringEnum.B: +>StringEnum.B : StringEnum.B +>StringEnum : typeof StringEnum +>B : StringEnum.B + + const b: StringEnum.A | StringEnum.B = x; +>b : StringEnum.A | StringEnum.B +>StringEnum : any +>StringEnum : any +>x : StringEnum.A | StringEnum.B + + case StringEnum.C: +>StringEnum.C : StringEnum.C +>StringEnum : typeof StringEnum +>C : StringEnum.C + + const c: StringEnum.A | StringEnum.B | StringEnum.C = x; +>c : StringEnum +>StringEnum : any +>StringEnum : any +>StringEnum : any +>x : StringEnum + + const all: StringEnum = x; +>all : StringEnum +>x : StringEnum + + return; + } + type End = isTrue> +>End : true +>x : unknown +} + +function switchTestLiterals(x: unknown) { +>switchTestLiterals : (x: unknown) => void +>x : unknown + + switch (x) { +>x : unknown + + case 1: +>1 : 1 + + const one: 1 = x; +>one : 1 +>x : 1 + + break; + case 2: +>2 : 2 + + const two: 2 = x; +>two : 2 +>x : 2 + + break; + case 3: +>3 : 3 + + const three: 3 = x; +>three : 3 +>x : 3 + + break; + case true: +>true : true + + const t: true = x; +>t : true +>true : true +>x : true + + break; + case false: +>false : false + + const f: false = x; +>f : false +>false : false +>x : false + + break; + case "A": +>"A" : "A" + + const a: "A" = x; +>a : "A" +>x : "A" + + break; + case undefined: +>undefined : undefined + + const undef: undefined = x; +>undef : undefined +>x : undefined + + break; + case null: +>null : null + + const llun: null = x; +>llun : null +>null : null +>x : null + + break; + case symb: +>symb : unique symbol + + const anotherSymbol: typeof symb = x; +>anotherSymbol : unique symbol +>symb : unique symbol +>x : unique symbol + + break; + case symbNonUnique: +>symbNonUnique : symbol + + const nonUniqueSymbol: symbol = x; +>nonUniqueSymbol : symbol +>x : symbol + + break; + } + type End = isTrue> +>End : true +>x : unknown +} + +function switchTestObjects(x: unknown, y: () => void, z: { prop: number }) { +>switchTestObjects : (x: unknown, y: () => void, z: { prop: number; }) => void +>x : unknown +>y : () => void +>z : { prop: number; } +>prop : number + + switch (x) { +>x : unknown + + case true: +>true : true + + case false: +>false : false + + const bool: boolean = x; +>bool : boolean +>x : boolean + + break; + case y: +>y : () => void + + const obj1: object = x; +>obj1 : object +>x : object + + break; + case z: +>z : { prop: number; } + + const obj2: object = x; +>obj2 : object +>x : object + + break; + } + type End = isTrue> +>End : true +>x : unknown +} + +function switchResponse(x: unknown): SomeResponse { +>switchResponse : (x: unknown) => SomeResponse +>x : unknown + + switch (x) { +>x : unknown + + case 'yes': +>'yes' : "yes" + + case 'no': +>'no' : "no" + + case 'idk': +>'idk' : "idk" + + return x; +>x : SomeResponse + + default: + throw new Error('unknown response'); +>new Error('unknown response') : Error +>Error : ErrorConstructor +>'unknown response' : "unknown response" + } + // Arguably this should be never. + type End = isTrue> +>End : true +>x : unknown +} + +function switchResponseWrong(x: unknown): SomeResponse { +>switchResponseWrong : (x: unknown) => SomeResponse +>x : unknown + + switch (x) { +>x : unknown + + case 'yes': +>'yes' : "yes" + + case 'no': +>'no' : "no" + + case 'maybe': +>'maybe' : "maybe" + + return x; // error +>x : "yes" | "no" | "maybe" + + default: + throw new Error('Can you repeat the question?'); +>new Error('Can you repeat the question?') : Error +>Error : ErrorConstructor +>'Can you repeat the question?' : "Can you repeat the question?" + } + // Arguably this should be never. + type End = isTrue> +>End : true +>x : unknown +} + diff --git a/tests/cases/conformance/types/unknown/unknownType2.ts b/tests/cases/conformance/types/unknown/unknownType2.ts index f8700958d6b..b3d16654b80 100644 --- a/tests/cases/conformance/types/unknown/unknownType2.ts +++ b/tests/cases/conformance/types/unknown/unknownType2.ts @@ -9,6 +9,7 @@ let validate: (x: unknown) => SomeResponse = x => (x === 'yes' || x === 'no') ? const u: unknown = undefined; declare const symb: unique symbol; +declare const symbNonUnique: symbol; if (u === 5) { const y = u.toString(10); @@ -107,10 +108,117 @@ if (u === NumberEnum || u === StringEnum) { let enumObj: object = u; } -if(u === NumberEnum.A) { +if (u === NumberEnum.A) { let a: NumberEnum.A = u } -if(u === StringEnum.B) { +if (u === StringEnum.B) { let b: StringEnum.B = u } + +function switchTestEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + break; + case StringEnum.B: + const b: StringEnum.B = x; + break; + case StringEnum.C: + const c: StringEnum.C = x; + break; + } + type End = isTrue> +} + +function switchTestCollectEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + case StringEnum.B: + const b: StringEnum.A | StringEnum.B = x; + case StringEnum.C: + const c: StringEnum.A | StringEnum.B | StringEnum.C = x; + const all: StringEnum = x; + return; + } + type End = isTrue> +} + +function switchTestLiterals(x: unknown) { + switch (x) { + case 1: + const one: 1 = x; + break; + case 2: + const two: 2 = x; + break; + case 3: + const three: 3 = x; + break; + case true: + const t: true = x; + break; + case false: + const f: false = x; + break; + case "A": + const a: "A" = x; + break; + case undefined: + const undef: undefined = x; + break; + case null: + const llun: null = x; + break; + case symb: + const anotherSymbol: typeof symb = x; + break; + case symbNonUnique: + const nonUniqueSymbol: symbol = x; + break; + } + type End = isTrue> +} + +function switchTestObjects(x: unknown, y: () => void, z: { prop: number }) { + switch (x) { + case true: + case false: + const bool: boolean = x; + break; + case y: + const obj1: object = x; + break; + case z: + const obj2: object = x; + break; + } + type End = isTrue> +} + +function switchResponse(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'idk': + return x; + default: + throw new Error('unknown response'); + } + // Arguably this should be never. + type End = isTrue> +} + +function switchResponseWrong(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'maybe': + return x; // error + default: + throw new Error('Can you repeat the question?'); + } + // Arguably this should be never. + type End = isTrue> +} From 25f9a1fec281807143c994167042f142ee49fc36 Mon Sep 17 00:00:00 2001 From: Jack Williams Date: Sun, 3 Feb 2019 22:44:15 +0000 Subject: [PATCH 04/20] Fix lint errors --- src/compiler/checker.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index a4c4761fb55..4e9985129e0 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -16163,12 +16163,12 @@ namespace ts { const clauseTypes = switchTypes.slice(clauseStart, clauseEnd); const hasDefaultClause = clauseStart === clauseEnd || contains(clauseTypes, neverType); if ((type.flags & TypeFlags.Unknown) && !hasDefaultClause) { - let groundClauseTypes: Type[] | undefined = undefined; + let groundClauseTypes: Type[] | undefined; for (let i = 0; i < clauseTypes.length; i += 1) { const t = clauseTypes[i]; if (t.flags & (TypeFlags.Primitive | TypeFlags.NonPrimitive)) { if (groundClauseTypes !== undefined) { - groundClauseTypes.push(t) + groundClauseTypes.push(t); } } else if (t.flags & TypeFlags.Object) { From ee10c247b73f168206c2172a9382c4215788af6a Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 4 Feb 2019 17:36:09 -0800 Subject: [PATCH 05/20] Less aggressive logic for detecting circular mapped arrays and tuples --- src/compiler/checker.ts | 28 ++++++++++++---------------- src/compiler/types.ts | 1 - 2 files changed, 12 insertions(+), 17 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 2e6259b668a..94e053e7b1d 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10841,7 +10841,7 @@ namespace ts { function getHomomorphicTypeVariable(type: MappedType) { const constraintType = getConstraintTypeFromMappedType(type); if (constraintType.flags & TypeFlags.Index) { - const typeVariable = (constraintType).type; + const typeVariable = getActualTypeVariable((constraintType).type); if (typeVariable.flags & TypeFlags.TypeParameter) { return typeVariable; } @@ -10864,26 +10864,15 @@ namespace ts { if (typeVariable) { const mappedTypeVariable = instantiateType(typeVariable, mapper); if (typeVariable !== mappedTypeVariable) { - // If we are already in the process of creating an instantiation of this mapped type, - // return the error type. This situation only arises if we are instantiating the mapped - // type for an array or tuple type, as we then need to eagerly resolve the (possibly - // circular) element type(s). - if (type.instantiating) { - return errorType; - } - type.instantiating = true; - const modifiers = getMappedTypeModifiers(type); - const result = mapType(mappedTypeVariable, t => { - if (t.flags & (TypeFlags.AnyOrUnknown | TypeFlags.InstantiableNonPrimitive | TypeFlags.Object | TypeFlags.Intersection) && t !== wildcardType) { + return mapType(mappedTypeVariable, t => { + if (t.flags & (TypeFlags.AnyOrUnknown | TypeFlags.InstantiableNonPrimitive | TypeFlags.Object | TypeFlags.Intersection) && t !== wildcardType && t !== errorType) { const replacementMapper = createReplacementMapper(typeVariable, t, mapper); - return isArrayType(t) ? createArrayType(instantiateMappedTypeTemplate(type, numberType, /*isOptional*/ true, replacementMapper), getModifiedReadonlyState(isReadonlyArrayType(t), modifiers)) : + return isArrayType(t) ? instantiateMappedArrayType(t, type, replacementMapper) : isTupleType(t) ? instantiateMappedTupleType(t, type, replacementMapper) : instantiateAnonymousType(type, replacementMapper); } return t; }); - type.instantiating = false; - return result; } } return instantiateAnonymousType(type, mapper); @@ -10893,6 +10882,12 @@ namespace ts { return modifiers & MappedTypeModifiers.IncludeReadonly ? true : modifiers & MappedTypeModifiers.ExcludeReadonly ? false : state; } + function instantiateMappedArrayType(arrayType: Type, mappedType: MappedType, mapper: TypeMapper) { + const elementType = instantiateMappedTypeTemplate(mappedType, numberType, /*isOptional*/ true, mapper); + return elementType === errorType ? errorType : + createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType))); + } + function instantiateMappedTupleType(tupleType: TupleTypeReference, mappedType: MappedType, mapper: TypeMapper) { const minLength = tupleType.target.minLength; const elementTypes = map(tupleType.typeArguments || emptyArray, (_, i) => @@ -10902,7 +10897,8 @@ namespace ts { modifiers & MappedTypeModifiers.ExcludeOptional ? getTypeReferenceArity(tupleType) - (tupleType.target.hasRestElement ? 1 : 0) : minLength; const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers); - return createTupleType(elementTypes, newMinLength, tupleType.target.hasRestElement, newReadonly, tupleType.target.associatedNames); + return contains(elementTypes, errorType) ? errorType : + createTupleType(elementTypes, newMinLength, tupleType.target.hasRestElement, newReadonly, tupleType.target.associatedNames); } function instantiateMappedTypeTemplate(type: MappedType, key: Type, isOptional: boolean, mapper: TypeMapper) { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index ff5ce74d31d..60444cc4f3e 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -4114,7 +4114,6 @@ namespace ts { templateType?: Type; modifiersType?: Type; resolvedApparentType?: Type; - instantiating?: boolean; } export interface EvolvingArrayType extends ObjectType { From 9639434d725a0acc997569911ec0f7f4e5166b5e Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 4 Feb 2019 17:37:11 -0800 Subject: [PATCH 06/20] Accept new baselines --- tests/baselines/reference/recursiveMappedTypes.errors.txt | 5 ++++- tests/baselines/reference/recursiveMappedTypes.types | 6 +++--- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/tests/baselines/reference/recursiveMappedTypes.errors.txt b/tests/baselines/reference/recursiveMappedTypes.errors.txt index b702cf7e316..1ae78204336 100644 --- a/tests/baselines/reference/recursiveMappedTypes.errors.txt +++ b/tests/baselines/reference/recursiveMappedTypes.errors.txt @@ -4,9 +4,10 @@ tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(7,6): error TS2456: tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(8,11): error TS2313: Type parameter 'K' has a circular constraint. tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(11,6): error TS2456: Type alias 'Recurse2' circularly references itself. tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(12,11): error TS2313: Type parameter 'K' has a circular constraint. +tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(20,19): error TS2589: Type instantiation is excessively deep and possibly infinite. -==== tests/cases/conformance/types/mapped/recursiveMappedTypes.ts (6 errors) ==== +==== tests/cases/conformance/types/mapped/recursiveMappedTypes.ts (7 errors) ==== // Recursive mapped types simply appear empty type Recurse = { @@ -39,6 +40,8 @@ tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(12,11): error TS231 type tup = [number, number, number, number]; function foo(arg: Circular): tup { + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. return arg; } \ No newline at end of file diff --git a/tests/baselines/reference/recursiveMappedTypes.types b/tests/baselines/reference/recursiveMappedTypes.types index 5741f711e9d..7a3251a8240 100644 --- a/tests/baselines/reference/recursiveMappedTypes.types +++ b/tests/baselines/reference/recursiveMappedTypes.types @@ -28,10 +28,10 @@ type tup = [number, number, number, number]; >tup : [number, number, number, number] function foo(arg: Circular): tup { ->foo : (arg: [any, any, any, any]) => [number, number, number, number] ->arg : [any, any, any, any] +>foo : (arg: any) => [number, number, number, number] +>arg : any return arg; ->arg : [any, any, any, any] +>arg : any } From bee9f1a5e767fa0aee79b4099980a3f61a089da4 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 4 Feb 2019 17:48:53 -0800 Subject: [PATCH 07/20] Add regression tests --- .../types/mapped/recursiveMappedTypes.ts | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/tests/cases/conformance/types/mapped/recursiveMappedTypes.ts b/tests/cases/conformance/types/mapped/recursiveMappedTypes.ts index 188efa2f51a..69a0c1ca597 100644 --- a/tests/cases/conformance/types/mapped/recursiveMappedTypes.ts +++ b/tests/cases/conformance/types/mapped/recursiveMappedTypes.ts @@ -22,3 +22,42 @@ type tup = [number, number, number, number]; function foo(arg: Circular): tup { return arg; } + +// Repro from #29442 + +type DeepMap = { + [K in keyof T]: T[K] extends unknown[] ? DeepMap : R; +}; + +type tpl = [string, [string, [string]]]; +type arr = string[][]; + +type t1 = DeepMap; // [number, [number, [number]]] +type t2 = DeepMap; // number[][] + +// Repro from #29577 + +type Transform = { [K in keyof T]: Transform }; + +interface User { + avatar: string; +} + +interface Guest { + displayName: string; +} + +interface Product { + users: (User | Guest)[]; +} + +declare var product: Transform; +product.users; // (Transform | Transform)[] + +// Repro from #29702 + +type Remap1 = { [P in keyof T]: Remap1; }; +type Remap2 = T extends object ? { [P in keyof T]: Remap2; } : T; + +type a = Remap1; // string[] +type b = Remap2; // string[] From f8eb67195c5b62de0d999b9df91cd71cca22424d Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 4 Feb 2019 17:49:00 -0800 Subject: [PATCH 08/20] Accept new baselines --- .../reference/recursiveMappedTypes.errors.txt | 39 +++++++ .../reference/recursiveMappedTypes.js | 40 +++++++ .../reference/recursiveMappedTypes.symbols | 110 ++++++++++++++++++ .../reference/recursiveMappedTypes.types | 62 ++++++++++ 4 files changed, 251 insertions(+) diff --git a/tests/baselines/reference/recursiveMappedTypes.errors.txt b/tests/baselines/reference/recursiveMappedTypes.errors.txt index 1ae78204336..f2f59052a90 100644 --- a/tests/baselines/reference/recursiveMappedTypes.errors.txt +++ b/tests/baselines/reference/recursiveMappedTypes.errors.txt @@ -44,4 +44,43 @@ tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(20,19): error TS258 !!! error TS2589: Type instantiation is excessively deep and possibly infinite. return arg; } + + // Repro from #29442 + + type DeepMap = { + [K in keyof T]: T[K] extends unknown[] ? DeepMap : R; + }; + + type tpl = [string, [string, [string]]]; + type arr = string[][]; + + type t1 = DeepMap; // [number, [number, [number]]] + type t2 = DeepMap; // number[][] + + // Repro from #29577 + + type Transform = { [K in keyof T]: Transform }; + + interface User { + avatar: string; + } + + interface Guest { + displayName: string; + } + + interface Product { + users: (User | Guest)[]; + } + + declare var product: Transform; + product.users; // (Transform | Transform)[] + + // Repro from #29702 + + type Remap1 = { [P in keyof T]: Remap1; }; + type Remap2 = T extends object ? { [P in keyof T]: Remap2; } : T; + + type a = Remap1; // string[] + type b = Remap2; // string[] \ No newline at end of file diff --git a/tests/baselines/reference/recursiveMappedTypes.js b/tests/baselines/reference/recursiveMappedTypes.js index 612c9d3fca4..e9e44a1df41 100644 --- a/tests/baselines/reference/recursiveMappedTypes.js +++ b/tests/baselines/reference/recursiveMappedTypes.js @@ -21,6 +21,45 @@ type tup = [number, number, number, number]; function foo(arg: Circular): tup { return arg; } + +// Repro from #29442 + +type DeepMap = { + [K in keyof T]: T[K] extends unknown[] ? DeepMap : R; +}; + +type tpl = [string, [string, [string]]]; +type arr = string[][]; + +type t1 = DeepMap; // [number, [number, [number]]] +type t2 = DeepMap; // number[][] + +// Repro from #29577 + +type Transform = { [K in keyof T]: Transform }; + +interface User { + avatar: string; +} + +interface Guest { + displayName: string; +} + +interface Product { + users: (User | Guest)[]; +} + +declare var product: Transform; +product.users; // (Transform | Transform)[] + +// Repro from #29702 + +type Remap1 = { [P in keyof T]: Remap1; }; +type Remap2 = T extends object ? { [P in keyof T]: Remap2; } : T; + +type a = Remap1; // string[] +type b = Remap2; // string[] //// [recursiveMappedTypes.js] @@ -30,6 +69,7 @@ exports.__esModule = true; function foo(arg) { return arg; } +product.users; // (Transform | Transform)[] //// [recursiveMappedTypes.d.ts] diff --git a/tests/baselines/reference/recursiveMappedTypes.symbols b/tests/baselines/reference/recursiveMappedTypes.symbols index 7c0e2ffaa23..1638dc03f56 100644 --- a/tests/baselines/reference/recursiveMappedTypes.symbols +++ b/tests/baselines/reference/recursiveMappedTypes.symbols @@ -55,3 +55,113 @@ function foo(arg: Circular): tup { >arg : Symbol(arg, Decl(recursiveMappedTypes.ts, 19, 13)) } +// Repro from #29442 + +type DeepMap = { +>DeepMap : Symbol(DeepMap, Decl(recursiveMappedTypes.ts, 21, 1)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 25, 13)) +>R : Symbol(R, Decl(recursiveMappedTypes.ts, 25, 33)) + + [K in keyof T]: T[K] extends unknown[] ? DeepMap : R; +>K : Symbol(K, Decl(recursiveMappedTypes.ts, 26, 3)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 25, 13)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 25, 13)) +>K : Symbol(K, Decl(recursiveMappedTypes.ts, 26, 3)) +>DeepMap : Symbol(DeepMap, Decl(recursiveMappedTypes.ts, 21, 1)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 25, 13)) +>K : Symbol(K, Decl(recursiveMappedTypes.ts, 26, 3)) +>R : Symbol(R, Decl(recursiveMappedTypes.ts, 25, 33)) +>R : Symbol(R, Decl(recursiveMappedTypes.ts, 25, 33)) + +}; + +type tpl = [string, [string, [string]]]; +>tpl : Symbol(tpl, Decl(recursiveMappedTypes.ts, 27, 2)) + +type arr = string[][]; +>arr : Symbol(arr, Decl(recursiveMappedTypes.ts, 29, 40)) + +type t1 = DeepMap; // [number, [number, [number]]] +>t1 : Symbol(t1, Decl(recursiveMappedTypes.ts, 30, 22)) +>DeepMap : Symbol(DeepMap, Decl(recursiveMappedTypes.ts, 21, 1)) +>tpl : Symbol(tpl, Decl(recursiveMappedTypes.ts, 27, 2)) + +type t2 = DeepMap; // number[][] +>t2 : Symbol(t2, Decl(recursiveMappedTypes.ts, 32, 31)) +>DeepMap : Symbol(DeepMap, Decl(recursiveMappedTypes.ts, 21, 1)) +>arr : Symbol(arr, Decl(recursiveMappedTypes.ts, 29, 40)) + +// Repro from #29577 + +type Transform = { [K in keyof T]: Transform }; +>Transform : Symbol(Transform, Decl(recursiveMappedTypes.ts, 33, 31)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 37, 15)) +>K : Symbol(K, Decl(recursiveMappedTypes.ts, 37, 23)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 37, 15)) +>Transform : Symbol(Transform, Decl(recursiveMappedTypes.ts, 33, 31)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 37, 15)) +>K : Symbol(K, Decl(recursiveMappedTypes.ts, 37, 23)) + +interface User { +>User : Symbol(User, Decl(recursiveMappedTypes.ts, 37, 56)) + + avatar: string; +>avatar : Symbol(User.avatar, Decl(recursiveMappedTypes.ts, 39, 16)) +} + +interface Guest { +>Guest : Symbol(Guest, Decl(recursiveMappedTypes.ts, 41, 1)) + + displayName: string; +>displayName : Symbol(Guest.displayName, Decl(recursiveMappedTypes.ts, 43, 17)) +} + +interface Product { +>Product : Symbol(Product, Decl(recursiveMappedTypes.ts, 45, 1)) + + users: (User | Guest)[]; +>users : Symbol(Product.users, Decl(recursiveMappedTypes.ts, 47, 19)) +>User : Symbol(User, Decl(recursiveMappedTypes.ts, 37, 56)) +>Guest : Symbol(Guest, Decl(recursiveMappedTypes.ts, 41, 1)) +} + +declare var product: Transform; +>product : Symbol(product, Decl(recursiveMappedTypes.ts, 51, 11)) +>Transform : Symbol(Transform, Decl(recursiveMappedTypes.ts, 33, 31)) +>Product : Symbol(Product, Decl(recursiveMappedTypes.ts, 45, 1)) + +product.users; // (Transform | Transform)[] +>product.users : Symbol(users, Decl(recursiveMappedTypes.ts, 47, 19)) +>product : Symbol(product, Decl(recursiveMappedTypes.ts, 51, 11)) +>users : Symbol(users, Decl(recursiveMappedTypes.ts, 47, 19)) + +// Repro from #29702 + +type Remap1 = { [P in keyof T]: Remap1; }; +>Remap1 : Symbol(Remap1, Decl(recursiveMappedTypes.ts, 52, 14)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 56, 12)) +>P : Symbol(P, Decl(recursiveMappedTypes.ts, 56, 20)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 56, 12)) +>Remap1 : Symbol(Remap1, Decl(recursiveMappedTypes.ts, 52, 14)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 56, 12)) +>P : Symbol(P, Decl(recursiveMappedTypes.ts, 56, 20)) + +type Remap2 = T extends object ? { [P in keyof T]: Remap2; } : T; +>Remap2 : Symbol(Remap2, Decl(recursiveMappedTypes.ts, 56, 51)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 57, 12)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 57, 12)) +>P : Symbol(P, Decl(recursiveMappedTypes.ts, 57, 39)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 57, 12)) +>Remap2 : Symbol(Remap2, Decl(recursiveMappedTypes.ts, 56, 51)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 57, 12)) +>P : Symbol(P, Decl(recursiveMappedTypes.ts, 57, 39)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 57, 12)) + +type a = Remap1; // string[] +>a : Symbol(a, Decl(recursiveMappedTypes.ts, 57, 74)) +>Remap1 : Symbol(Remap1, Decl(recursiveMappedTypes.ts, 52, 14)) + +type b = Remap2; // string[] +>b : Symbol(b, Decl(recursiveMappedTypes.ts, 59, 26)) +>Remap2 : Symbol(Remap2, Decl(recursiveMappedTypes.ts, 56, 51)) + diff --git a/tests/baselines/reference/recursiveMappedTypes.types b/tests/baselines/reference/recursiveMappedTypes.types index 7a3251a8240..126d1e1d740 100644 --- a/tests/baselines/reference/recursiveMappedTypes.types +++ b/tests/baselines/reference/recursiveMappedTypes.types @@ -35,3 +35,65 @@ function foo(arg: Circular): tup { >arg : any } +// Repro from #29442 + +type DeepMap = { +>DeepMap : DeepMap + + [K in keyof T]: T[K] extends unknown[] ? DeepMap : R; +}; + +type tpl = [string, [string, [string]]]; +>tpl : [string, [string, [string]]] + +type arr = string[][]; +>arr : string[][] + +type t1 = DeepMap; // [number, [number, [number]]] +>t1 : [number, [number, [number]]] + +type t2 = DeepMap; // number[][] +>t2 : number[][] + +// Repro from #29577 + +type Transform = { [K in keyof T]: Transform }; +>Transform : Transform + +interface User { + avatar: string; +>avatar : string +} + +interface Guest { + displayName: string; +>displayName : string +} + +interface Product { + users: (User | Guest)[]; +>users : (User | Guest)[] +} + +declare var product: Transform; +>product : Transform + +product.users; // (Transform | Transform)[] +>product.users : (Transform | Transform)[] +>product : Transform +>users : (Transform | Transform)[] + +// Repro from #29702 + +type Remap1 = { [P in keyof T]: Remap1; }; +>Remap1 : Remap1 + +type Remap2 = T extends object ? { [P in keyof T]: Remap2; } : T; +>Remap2 : Remap2 + +type a = Remap1; // string[] +>a : string[] + +type b = Remap2; // string[] +>b : string[] + From 2256d761a20616434d3e20d2f7e0caa46ea7e1c3 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 5 Feb 2019 12:40:25 -0800 Subject: [PATCH 09/20] Revert change to strict property initialization checks --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index ce06e84b2fd..7d9d36b77b6 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -27225,7 +27225,7 @@ namespace ts { reference.expression.parent = reference; reference.parent = constructor; reference.flowNode = constructor.returnFlowNode; - const flowType = getFlowTypeOfReference(reference, getOptionalType(propType)); + const flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType)); return !(getFalsyFlags(flowType) & TypeFlags.Undefined); } From 2d44a402025d5f98db7ac83d7ad274015f5d8094 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 5 Feb 2019 13:08:18 -0800 Subject: [PATCH 10/20] Add regression test --- .../strictPropertyInitialization.ts | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/strictPropertyInitialization.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/strictPropertyInitialization.ts index 01177200429..fc03101922a 100644 --- a/tests/cases/conformance/classes/propertyMemberDeclarations/strictPropertyInitialization.ts +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/strictPropertyInitialization.ts @@ -99,3 +99,14 @@ class C10 { let y = this.c; } } + +// Property is considered initialized by type any even though value could be undefined + +declare function someValue(): any; + +class C11 { + a: number; + constructor() { + this.a = someValue(); + } +} From 16cf5d11cc78101991f09e2e16c48e1d509ad1b9 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 5 Feb 2019 13:08:25 -0800 Subject: [PATCH 11/20] Accept new baselines --- .../strictPropertyInitialization.errors.txt | 11 ++++++++++ .../reference/strictPropertyInitialization.js | 22 +++++++++++++++++++ .../strictPropertyInitialization.symbols | 20 +++++++++++++++++ .../strictPropertyInitialization.types | 22 +++++++++++++++++++ 4 files changed, 75 insertions(+) diff --git a/tests/baselines/reference/strictPropertyInitialization.errors.txt b/tests/baselines/reference/strictPropertyInitialization.errors.txt index 4a3fe0eb3e5..17283f61162 100644 --- a/tests/baselines/reference/strictPropertyInitialization.errors.txt +++ b/tests/baselines/reference/strictPropertyInitialization.errors.txt @@ -117,4 +117,15 @@ tests/cases/conformance/classes/propertyMemberDeclarations/strictPropertyInitial let y = this.c; } } + + // Property is considered initialized by type any even though value could be undefined + + declare function someValue(): any; + + class C11 { + a: number; + constructor() { + this.a = someValue(); + } + } \ No newline at end of file diff --git a/tests/baselines/reference/strictPropertyInitialization.js b/tests/baselines/reference/strictPropertyInitialization.js index 6de5084e40c..3593fdb37f8 100644 --- a/tests/baselines/reference/strictPropertyInitialization.js +++ b/tests/baselines/reference/strictPropertyInitialization.js @@ -97,6 +97,17 @@ class C10 { let y = this.c; } } + +// Property is considered initialized by type any even though value could be undefined + +declare function someValue(): any; + +class C11 { + a: number; + constructor() { + this.a = someValue(); + } +} //// [strictPropertyInitialization.js] @@ -172,6 +183,12 @@ var C10 = /** @class */ (function () { } return C10; }()); +var C11 = /** @class */ (function () { + function C11() { + this.a = someValue(); + } + return C11; +}()); //// [strictPropertyInitialization.d.ts] @@ -227,3 +244,8 @@ declare class C10 { c?: number; constructor(); } +declare function someValue(): any; +declare class C11 { + a: number; + constructor(); +} diff --git a/tests/baselines/reference/strictPropertyInitialization.symbols b/tests/baselines/reference/strictPropertyInitialization.symbols index c271094a527..6421d0b6920 100644 --- a/tests/baselines/reference/strictPropertyInitialization.symbols +++ b/tests/baselines/reference/strictPropertyInitialization.symbols @@ -210,3 +210,23 @@ class C10 { } } +// Property is considered initialized by type any even though value could be undefined + +declare function someValue(): any; +>someValue : Symbol(someValue, Decl(strictPropertyInitialization.ts, 97, 1)) + +class C11 { +>C11 : Symbol(C11, Decl(strictPropertyInitialization.ts, 101, 34)) + + a: number; +>a : Symbol(C11.a, Decl(strictPropertyInitialization.ts, 103, 11)) + + constructor() { + this.a = someValue(); +>this.a : Symbol(C11.a, Decl(strictPropertyInitialization.ts, 103, 11)) +>this : Symbol(C11, Decl(strictPropertyInitialization.ts, 101, 34)) +>a : Symbol(C11.a, Decl(strictPropertyInitialization.ts, 103, 11)) +>someValue : Symbol(someValue, Decl(strictPropertyInitialization.ts, 97, 1)) + } +} + diff --git a/tests/baselines/reference/strictPropertyInitialization.types b/tests/baselines/reference/strictPropertyInitialization.types index 4c0ab3e8527..f1fe49e94e8 100644 --- a/tests/baselines/reference/strictPropertyInitialization.types +++ b/tests/baselines/reference/strictPropertyInitialization.types @@ -227,3 +227,25 @@ class C10 { } } +// Property is considered initialized by type any even though value could be undefined + +declare function someValue(): any; +>someValue : () => any + +class C11 { +>C11 : C11 + + a: number; +>a : number + + constructor() { + this.a = someValue(); +>this.a = someValue() : any +>this.a : number +>this : this +>a : number +>someValue() : any +>someValue : () => any + } +} + From 12edac0925e3ffd7ad1ec0f9782cef6f88d0fed8 Mon Sep 17 00:00:00 2001 From: Klaus Meinhardt Date: Wed, 6 Feb 2019 00:51:55 +0100 Subject: [PATCH 12/20] getEffectiveBaseTypeNode: only use JSDoc augments if there is extends (#29349) --- src/compiler/utilities.ts | 5 +++-- .../reference/jsdocAugments_noExtends.errors.txt | 15 +++++++++++++++ .../reference/jsdocAugments_noExtends.symbols | 2 -- .../reference/jsdocAugments_noExtends.types | 6 +++--- 4 files changed, 21 insertions(+), 7 deletions(-) create mode 100644 tests/baselines/reference/jsdocAugments_noExtends.errors.txt diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index bcaa4d54285..65e050d085b 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2514,14 +2514,15 @@ namespace ts { } export function getEffectiveBaseTypeNode(node: ClassLikeDeclaration | InterfaceDeclaration) { - if (isInJSFile(node)) { + const baseType = getClassExtendsHeritageElement(node); + if (baseType && isInJSFile(node)) { // Prefer an @augments tag because it may have type parameters. const tag = getJSDocAugmentsTag(node); if (tag) { return tag.class; } } - return getClassExtendsHeritageElement(node); + return baseType; } export function getClassExtendsHeritageElement(node: ClassLikeDeclaration | InterfaceDeclaration) { diff --git a/tests/baselines/reference/jsdocAugments_noExtends.errors.txt b/tests/baselines/reference/jsdocAugments_noExtends.errors.txt new file mode 100644 index 00000000000..036f30301f9 --- /dev/null +++ b/tests/baselines/reference/jsdocAugments_noExtends.errors.txt @@ -0,0 +1,15 @@ +/b.js(6,21): error TS2339: Property 'x' does not exist on type 'B'. + + +==== /b.js (1 errors) ==== + class A { constructor() { this.x = 0; } } + + /** @augments A */ + class B { + m() { + return this.x; + ~ +!!! error TS2339: Property 'x' does not exist on type 'B'. + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/jsdocAugments_noExtends.symbols b/tests/baselines/reference/jsdocAugments_noExtends.symbols index cd3d8575f26..2303e600979 100644 --- a/tests/baselines/reference/jsdocAugments_noExtends.symbols +++ b/tests/baselines/reference/jsdocAugments_noExtends.symbols @@ -13,9 +13,7 @@ class B { >m : Symbol(B.m, Decl(b.js, 3, 9)) return this.x; ->this.x : Symbol(A.x, Decl(b.js, 0, 25)) >this : Symbol(B, Decl(b.js, 0, 41)) ->x : Symbol(A.x, Decl(b.js, 0, 25)) } } diff --git a/tests/baselines/reference/jsdocAugments_noExtends.types b/tests/baselines/reference/jsdocAugments_noExtends.types index 5a2c5632ab7..fab9c7b7c84 100644 --- a/tests/baselines/reference/jsdocAugments_noExtends.types +++ b/tests/baselines/reference/jsdocAugments_noExtends.types @@ -12,12 +12,12 @@ class B { >B : B m() { ->m : () => number +>m : () => any return this.x; ->this.x : number +>this.x : any >this : this ->x : number +>x : any } } From 341f9cf1d6cdc9a9311740fff75fcade7e9092af Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 5 Feb 2019 17:53:33 -0800 Subject: [PATCH 13/20] Added test. --- .../compiler/forwardDeclaredCommonTypes01.ts | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 tests/cases/compiler/forwardDeclaredCommonTypes01.ts diff --git a/tests/cases/compiler/forwardDeclaredCommonTypes01.ts b/tests/cases/compiler/forwardDeclaredCommonTypes01.ts new file mode 100644 index 00000000000..f4eea80ab03 --- /dev/null +++ b/tests/cases/compiler/forwardDeclaredCommonTypes01.ts @@ -0,0 +1,18 @@ +// @lib: es5 +// @target: es5 + +interface Promise {} +interface Symbol {} +interface Map {} +interface WeakMap {} +interface Set {} +interface WeakSet {} + +(function() { + new Promise; + new Symbol; Symbol(); + new Map; + new WeakMap; + new Set; + new WeakSet; +}); From 3382a2ea54483d5f4df15ebd4f4b536aa83f2b2c Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 5 Feb 2019 17:54:05 -0800 Subject: [PATCH 14/20] Give good error messages on more types. --- src/compiler/checker.ts | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 23459491518..c8eea8ef70c 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1716,7 +1716,7 @@ namespace ts { } const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.Type & ~SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined, /*isUse*/ false)); if (symbol && !(symbol.flags & SymbolFlags.NamespaceModule)) { - const message = (name === "Promise" || name === "Symbol") + const message = isES2015OrLaterConstructorName(name) ? Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later : Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here; error(errorLocation, message, unescapeLeadingUnderscores(name)); @@ -1726,6 +1726,19 @@ namespace ts { return false; } + function isES2015OrLaterConstructorName(n: __String) { + switch (n) { + case "Promise": + case "Symbol": + case "Map": + case "WeakMap": + case "Set": + case "WeakSet": + return true; + } + return false; + } + function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation: Node, name: __String, meaning: SymbolFlags): boolean { if (meaning & (SymbolFlags.Value & ~SymbolFlags.NamespaceModule & ~SymbolFlags.Type)) { const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.NamespaceModule & ~SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined, /*isUse*/ false)); From e35ab96c0b0b6eede086231a00ca303303661ae2 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 5 Feb 2019 18:00:48 -0800 Subject: [PATCH 15/20] Accepted baselines. --- .../forwardDeclaredCommonTypes01.errors.txt | 40 +++++++++++++++++++ .../reference/forwardDeclaredCommonTypes01.js | 28 +++++++++++++ .../forwardDeclaredCommonTypes01.symbols | 35 ++++++++++++++++ .../forwardDeclaredCommonTypes01.types | 40 +++++++++++++++++++ 4 files changed, 143 insertions(+) create mode 100644 tests/baselines/reference/forwardDeclaredCommonTypes01.errors.txt create mode 100644 tests/baselines/reference/forwardDeclaredCommonTypes01.js create mode 100644 tests/baselines/reference/forwardDeclaredCommonTypes01.symbols create mode 100644 tests/baselines/reference/forwardDeclaredCommonTypes01.types diff --git a/tests/baselines/reference/forwardDeclaredCommonTypes01.errors.txt b/tests/baselines/reference/forwardDeclaredCommonTypes01.errors.txt new file mode 100644 index 00000000000..59a3a7313aa --- /dev/null +++ b/tests/baselines/reference/forwardDeclaredCommonTypes01.errors.txt @@ -0,0 +1,40 @@ +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(9,9): error TS2585: 'Promise' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(10,9): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(10,17): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(11,9): error TS2585: 'Map' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(12,9): error TS2585: 'WeakMap' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(13,9): error TS2585: 'Set' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(14,9): error TS2585: 'WeakSet' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + + +==== tests/cases/compiler/forwardDeclaredCommonTypes01.ts (7 errors) ==== + interface Promise {} + interface Symbol {} + interface Map {} + interface WeakMap {} + interface Set {} + interface WeakSet {} + + (function() { + new Promise; + ~~~~~~~ +!!! error TS2585: 'Promise' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + new Symbol; Symbol(); + ~~~~~~ +!!! error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + ~~~~~~ +!!! error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + new Map; + ~~~ +!!! error TS2585: 'Map' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + new WeakMap; + ~~~~~~~ +!!! error TS2585: 'WeakMap' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + new Set; + ~~~ +!!! error TS2585: 'Set' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + new WeakSet; + ~~~~~~~ +!!! error TS2585: 'WeakSet' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + }); + \ No newline at end of file diff --git a/tests/baselines/reference/forwardDeclaredCommonTypes01.js b/tests/baselines/reference/forwardDeclaredCommonTypes01.js new file mode 100644 index 00000000000..51778524430 --- /dev/null +++ b/tests/baselines/reference/forwardDeclaredCommonTypes01.js @@ -0,0 +1,28 @@ +//// [forwardDeclaredCommonTypes01.ts] +interface Promise {} +interface Symbol {} +interface Map {} +interface WeakMap {} +interface Set {} +interface WeakSet {} + +(function() { + new Promise; + new Symbol; Symbol(); + new Map; + new WeakMap; + new Set; + new WeakSet; +}); + + +//// [forwardDeclaredCommonTypes01.js] +(function () { + new Promise; + new Symbol; + Symbol(); + new Map; + new WeakMap; + new Set; + new WeakSet; +}); diff --git a/tests/baselines/reference/forwardDeclaredCommonTypes01.symbols b/tests/baselines/reference/forwardDeclaredCommonTypes01.symbols new file mode 100644 index 00000000000..427bf4c39fb --- /dev/null +++ b/tests/baselines/reference/forwardDeclaredCommonTypes01.symbols @@ -0,0 +1,35 @@ +=== tests/cases/compiler/forwardDeclaredCommonTypes01.ts === +interface Promise {} +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(forwardDeclaredCommonTypes01.ts, 0, 0)) +>T : Symbol(T, Decl(lib.es5.d.ts, --, --), Decl(forwardDeclaredCommonTypes01.ts, 0, 18)) + +interface Symbol {} +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(forwardDeclaredCommonTypes01.ts, 0, 23)) + +interface Map {} +>Map : Symbol(Map, Decl(forwardDeclaredCommonTypes01.ts, 1, 19)) +>K : Symbol(K, Decl(forwardDeclaredCommonTypes01.ts, 2, 14)) +>V : Symbol(V, Decl(forwardDeclaredCommonTypes01.ts, 2, 16)) + +interface WeakMap {} +>WeakMap : Symbol(WeakMap, Decl(forwardDeclaredCommonTypes01.ts, 2, 22)) +>K : Symbol(K, Decl(forwardDeclaredCommonTypes01.ts, 3, 18)) +>V : Symbol(V, Decl(forwardDeclaredCommonTypes01.ts, 3, 35)) + +interface Set {} +>Set : Symbol(Set, Decl(forwardDeclaredCommonTypes01.ts, 3, 41)) +>T : Symbol(T, Decl(forwardDeclaredCommonTypes01.ts, 4, 14)) + +interface WeakSet {} +>WeakSet : Symbol(WeakSet, Decl(forwardDeclaredCommonTypes01.ts, 4, 19)) +>T : Symbol(T, Decl(forwardDeclaredCommonTypes01.ts, 5, 18)) + +(function() { + new Promise; + new Symbol; Symbol(); + new Map; + new WeakMap; + new Set; + new WeakSet; +}); + diff --git a/tests/baselines/reference/forwardDeclaredCommonTypes01.types b/tests/baselines/reference/forwardDeclaredCommonTypes01.types new file mode 100644 index 00000000000..279b772d7d5 --- /dev/null +++ b/tests/baselines/reference/forwardDeclaredCommonTypes01.types @@ -0,0 +1,40 @@ +=== tests/cases/compiler/forwardDeclaredCommonTypes01.ts === +interface Promise {} +interface Symbol {} +interface Map {} +interface WeakMap {} +interface Set {} +interface WeakSet {} + +(function() { +>(function() { new Promise; new Symbol; Symbol(); new Map; new WeakMap; new Set; new WeakSet;}) : () => void +>function() { new Promise; new Symbol; Symbol(); new Map; new WeakMap; new Set; new WeakSet;} : () => void + + new Promise; +>new Promise : any +>Promise : any + + new Symbol; Symbol(); +>new Symbol : any +>Symbol : any +>Symbol() : any +>Symbol : any + + new Map; +>new Map : any +>Map : any + + new WeakMap; +>new WeakMap : any +>WeakMap : any + + new Set; +>new Set : any +>Set : any + + new WeakSet; +>new WeakSet : any +>WeakSet : any + +}); + From 33af4ea250ec372186f2b857b2400b3bbce97a09 Mon Sep 17 00:00:00 2001 From: Nathan Shively-Sanders <293473+sandersn@users.noreply.github.com> Date: Wed, 6 Feb 2019 08:57:24 -0800 Subject: [PATCH 16/20] assertNever no longer crashes on string input (#29764) --- src/compiler/core.ts | 2 +- src/testRunner/unittests/asserts.ts | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/compiler/core.ts b/src/compiler/core.ts index a2f2b245502..eb24dd1edd5 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -1652,7 +1652,7 @@ namespace ts { } export function assertNever(member: never, message = "Illegal value:", stackCrawlMark?: AnyFunction): never { - const detail = "kind" in member && "pos" in member ? "SyntaxKind: " + showSyntaxKind(member as Node) : JSON.stringify(member); + const detail = typeof member === "object" && "kind" in member && "pos" in member ? "SyntaxKind: " + showSyntaxKind(member as Node) : JSON.stringify(member); return fail(`${message} ${detail}`, stackCrawlMark || assertNever); } diff --git a/src/testRunner/unittests/asserts.ts b/src/testRunner/unittests/asserts.ts index c54173e2f90..116a74cf179 100644 --- a/src/testRunner/unittests/asserts.ts +++ b/src/testRunner/unittests/asserts.ts @@ -5,5 +5,8 @@ namespace ts { assert.throws(() => assert.deepEqual(createNodeArray([], /*hasTrailingComma*/ true), createNodeArray([], /*hasTrailingComma*/ false))); assert.deepEqual(createNodeArray([createIdentifier("A")], /*hasTrailingComma*/ true), createNodeArray([createIdentifier("A")], /*hasTrailingComma*/ true)); }); + it("assertNever on string has correct error", () => { + assert.throws(() => Debug.assertNever("hi" as never), "Debug Failure. Illegal value: \"hi\""); + }); }); } From f0a6154e9b43561112f37285eaeccaf9582f6543 Mon Sep 17 00:00:00 2001 From: Jesse Trinity Date: Wed, 6 Feb 2019 10:04:13 -0800 Subject: [PATCH 17/20] Added auto setting to quotePreference --- src/compiler/types.ts | 2 +- src/server/protocol.ts | 2 +- src/services/codefixes/helpers.ts | 1 + src/services/utilities.ts | 14 ++++++++------ 4 files changed, 11 insertions(+), 8 deletions(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 60444cc4f3e..277b5a4ebe9 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -5862,7 +5862,7 @@ namespace ts { export interface UserPreferences { readonly disableSuggestions?: boolean; - readonly quotePreference?: "double" | "single"; + readonly quotePreference?: "auto" | "double" | "single"; readonly includeCompletionsForModuleExports?: boolean; readonly includeCompletionsWithInsertText?: boolean; readonly importModuleSpecifierPreference?: "relative" | "non-relative"; diff --git a/src/server/protocol.ts b/src/server/protocol.ts index 11930de4d8c..1fd8d98b570 100644 --- a/src/server/protocol.ts +++ b/src/server/protocol.ts @@ -2891,7 +2891,7 @@ namespace ts.server.protocol { export interface UserPreferences { readonly disableSuggestions?: boolean; - readonly quotePreference?: "double" | "single"; + readonly quotePreference?: "auto" | "double" | "single"; /** * If enabled, TypeScript will search through all external modules' exports and add them to the completions list. * This affects lone identifier completions but not completions on the right hand side of `obj.`. diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts index 4309e6ec35d..ec86415b9fa 100644 --- a/src/services/codefixes/helpers.ts +++ b/src/services/codefixes/helpers.ts @@ -264,6 +264,7 @@ namespace ts.codefix { createNew( createIdentifier("Error"), /*typeArguments*/ undefined, + // TODO Handle auto quote preference. [createLiteral("Method not implemented.", /*isSingleQuote*/ preferences.quotePreference === "single")]))], /*multiline*/ true); } diff --git a/src/services/utilities.ts b/src/services/utilities.ts index 2f78ef2324b..8d48c32782a 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -1315,10 +1315,9 @@ namespace ts { } export function getQuotePreference(sourceFile: SourceFile, preferences: UserPreferences): QuotePreference { - if (preferences.quotePreference) { + if (preferences.quotePreference && preferences.quotePreference !== "auto") { return preferences.quotePreference === "single" ? QuotePreference.Single : QuotePreference.Double; - } - else { + } else { const firstModuleSpecifier = sourceFile.imports && find(sourceFile.imports, isStringLiteral); return firstModuleSpecifier ? quotePreferenceFromString(firstModuleSpecifier, sourceFile) : QuotePreference.Double; } @@ -1868,15 +1867,18 @@ namespace ts { if (/^\d+$/.test(text)) { return text; } + // Editors can pass in undefined or empty string - we want to infer the preference in those cases. + const quotePreference = preferences.quotePreference || "auto"; const quoted = JSON.stringify(text); - switch (preferences.quotePreference) { - case undefined: + switch (quotePreference) { + // TODO use getQuotePreference to infer the actual quote style. + case "auto": case "double": return quoted; case "single": return `'${stripQuotes(quoted).replace("'", "\\'").replace('\\"', '"')}'`; default: - return Debug.assertNever(preferences.quotePreference); + return Debug.assertNever(quotePreference); } } From 7fd1e62a63caec46cf2f52f99bdcbf453a1debab Mon Sep 17 00:00:00 2001 From: Jesse Trinity Date: Wed, 6 Feb 2019 14:36:17 -0800 Subject: [PATCH 18/20] accepted new baselines --- src/services/utilities.ts | 3 ++- tests/baselines/reference/api/tsserverlibrary.d.ts | 4 ++-- tests/baselines/reference/api/typescript.d.ts | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/services/utilities.ts b/src/services/utilities.ts index 8d48c32782a..285ca0cc6a9 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -1317,7 +1317,8 @@ namespace ts { export function getQuotePreference(sourceFile: SourceFile, preferences: UserPreferences): QuotePreference { if (preferences.quotePreference && preferences.quotePreference !== "auto") { return preferences.quotePreference === "single" ? QuotePreference.Single : QuotePreference.Double; - } else { + } + else { const firstModuleSpecifier = sourceFile.imports && find(sourceFile.imports, isStringLiteral); return firstModuleSpecifier ? quotePreferenceFromString(firstModuleSpecifier, sourceFile) : QuotePreference.Double; } diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index ee13a377f5e..53c40047e5d 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -3010,7 +3010,7 @@ declare namespace ts { } interface UserPreferences { readonly disableSuggestions?: boolean; - readonly quotePreference?: "double" | "single"; + readonly quotePreference?: "auto" | "double" | "single"; readonly includeCompletionsForModuleExports?: boolean; readonly includeCompletionsWithInsertText?: boolean; readonly importModuleSpecifierPreference?: "relative" | "non-relative"; @@ -7927,7 +7927,7 @@ declare namespace ts.server.protocol { } interface UserPreferences { readonly disableSuggestions?: boolean; - readonly quotePreference?: "double" | "single"; + readonly quotePreference?: "auto" | "double" | "single"; /** * If enabled, TypeScript will search through all external modules' exports and add them to the completions list. * This affects lone identifier completions but not completions on the right hand side of `obj.`. diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 49238bd3d6d..7e451446b54 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -3010,7 +3010,7 @@ declare namespace ts { } interface UserPreferences { readonly disableSuggestions?: boolean; - readonly quotePreference?: "double" | "single"; + readonly quotePreference?: "auto" | "double" | "single"; readonly includeCompletionsForModuleExports?: boolean; readonly includeCompletionsWithInsertText?: boolean; readonly importModuleSpecifierPreference?: "relative" | "non-relative"; From 6249b4c70409d540cb13d3e65aa43dd1cf6c493f Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Thu, 7 Feb 2019 08:35:52 +0900 Subject: [PATCH 19/20] Remove ES2018 transforms for ES2018 target (#26315) * rename esnext.ts as es2018.ts * remove ES2018 transforms for ES2018 target * change target from esnext to es2018 * rename tests --- src/compiler/binder.ts | 70 +- src/compiler/transformer.ts | 4 + src/compiler/transformers/es2018.ts | 1046 +++++++++++++++++ src/compiler/transformers/esnext.ts | 1024 +--------------- src/compiler/tsconfig.json | 1 + src/compiler/types.ts | 2 + ...er.asyncGenerators.classMethods.es2018.js} | 2 +- ...yncGenerators.classMethods.es2018.symbols} | 18 +- ...asyncGenerators.classMethods.es2018.types} | 18 +- ...Generators.functionDeclarations.es2018.js} | 2 +- ...ators.functionDeclarations.es2018.symbols} | 14 +- ...erators.functionDeclarations.es2018.types} | 14 +- ...cGenerators.functionExpressions.es2018.js} | 2 +- ...rators.functionExpressions.es2018.symbols} | 14 +- ...nerators.functionExpressions.es2018.types} | 14 +- ...Generators.objectLiteralMethods.es2018.js} | 2 +- ...ators.objectLiteralMethods.es2018.symbols} | 14 +- ...erators.objectLiteralMethods.es2018.types} | 14 +- ...t.esnext.js => emitter.forAwait.es2018.js} | 5 +- ...ymbols => emitter.forAwait.es2018.symbols} | 13 +- ...xt.types => emitter.forAwait.es2018.types} | 13 +- tests/baselines/reference/forAwaitForUnion.js | 3 +- .../reference/forAwaitForUnion.symbols | 1 + .../reference/forAwaitForUnion.types | 1 + ...Generators.classMethods.es2018.errors.txt} | 111 +- ...yncGenerators.classMethods.es2018.symbols} | 51 +- ...asyncGenerators.classMethods.es2018.types} | 51 +- ...rs.functionDeclarations.es2018.errors.txt} | 79 +- ...ators.functionDeclarations.es2018.symbols} | 43 +- ...erators.functionDeclarations.es2018.types} | 43 +- ...ors.functionExpressions.es2018.errors.txt} | 106 +- ...rators.functionExpressions.es2018.symbols} | 42 +- ...nerators.functionExpressions.es2018.types} | 42 +- ...rs.objectLiteralMethods.es2018.errors.txt} | 105 +- ...ators.objectLiteralMethods.es2018.symbols} | 49 +- ...erators.objectLiteralMethods.es2018.types} | 49 +- ....txt => parser.forAwait.es2018.errors.txt} | 55 +- ...symbols => parser.forAwait.es2018.symbols} | 25 +- ...ext.types => parser.forAwait.es2018.types} | 25 +- ...=> types.asyncGenerators.es2018.1.symbols} | 89 +- ...s => types.asyncGenerators.es2018.1.types} | 3 +- ...types.asyncGenerators.es2018.2.errors.txt} | 53 +- ...=> types.asyncGenerators.es2018.2.symbols} | 55 +- ...s => types.asyncGenerators.es2018.2.types} | 3 +- .../reference/types.forAwait.es2018.1.symbols | 77 ++ ....1.types => types.forAwait.es2018.1.types} | 3 +- ...txt => types.forAwait.es2018.2.errors.txt} | 17 +- .../reference/types.forAwait.es2018.2.symbols | 42 + ....2.types => types.forAwait.es2018.2.types} | 3 +- ...txt => types.forAwait.es2018.3.errors.txt} | 13 +- .../reference/types.forAwait.es2018.3.symbols | 28 + ....3.types => types.forAwait.es2018.3.types} | 3 +- .../reference/types.forAwait.esnext.1.symbols | 76 -- .../reference/types.forAwait.esnext.2.symbols | 41 - .../reference/types.forAwait.esnext.3.symbols | 27 - tests/cases/compiler/forAwaitForUnion.ts | 4 +- ...er.asyncGenerators.classMethods.es2018.ts} | 2 +- ...Generators.functionDeclarations.es2018.ts} | 2 +- ...cGenerators.functionExpressions.es2018.ts} | 2 +- ...Generators.objectLiteralMethods.es2018.ts} | 2 +- .../forAwait/emitter.forAwait.es2018.ts} | 4 +- ...er.asyncGenerators.classMethods.es2018.ts} | 4 +- ...Generators.functionDeclarations.es2018.ts} | 4 +- ...cGenerators.functionExpressions.es2018.ts} | 2 +- ...Generators.objectLiteralMethods.es2018.ts} | 4 +- .../forAwait/parser.forAwait.es2018.ts} | 4 +- ...1.ts => types.asyncGenerators.es2018.1.ts} | 4 +- ...2.ts => types.asyncGenerators.es2018.2.ts} | 4 +- ...esnext.1.ts => types.forAwait.es2018.1.ts} | 4 +- ...esnext.2.ts => types.forAwait.es2018.2.ts} | 4 +- ...esnext.3.ts => types.forAwait.es2018.3.ts} | 4 +- 71 files changed, 1918 insertions(+), 1856 deletions(-) create mode 100644 src/compiler/transformers/es2018.ts rename tests/baselines/reference/{emitter.asyncGenerators.classMethods.esnext.js => emitter.asyncGenerators.classMethods.es2018.js} (88%) rename tests/baselines/reference/{emitter.asyncGenerators.classMethods.esnext.symbols => emitter.asyncGenerators.classMethods.es2018.symbols} (73%) rename tests/baselines/reference/{emitter.asyncGenerators.classMethods.esnext.types => emitter.asyncGenerators.classMethods.es2018.types} (70%) rename tests/baselines/reference/{emitter.asyncGenerators.functionDeclarations.esnext.js => emitter.asyncGenerators.functionDeclarations.es2018.js} (83%) rename tests/baselines/reference/{emitter.asyncGenerators.functionDeclarations.esnext.symbols => emitter.asyncGenerators.functionDeclarations.es2018.symbols} (62%) rename tests/baselines/reference/{emitter.asyncGenerators.functionDeclarations.esnext.types => emitter.asyncGenerators.functionDeclarations.es2018.types} (68%) rename tests/baselines/reference/{emitter.asyncGenerators.functionExpressions.esnext.js => emitter.asyncGenerators.functionExpressions.es2018.js} (85%) rename tests/baselines/reference/{emitter.asyncGenerators.functionExpressions.esnext.symbols => emitter.asyncGenerators.functionExpressions.es2018.symbols} (63%) rename tests/baselines/reference/{emitter.asyncGenerators.functionExpressions.esnext.types => emitter.asyncGenerators.functionExpressions.es2018.types} (77%) rename tests/baselines/reference/{emitter.asyncGenerators.objectLiteralMethods.esnext.js => emitter.asyncGenerators.objectLiteralMethods.es2018.js} (86%) rename tests/baselines/reference/{emitter.asyncGenerators.objectLiteralMethods.esnext.symbols => emitter.asyncGenerators.objectLiteralMethods.es2018.symbols} (69%) rename tests/baselines/reference/{emitter.asyncGenerators.objectLiteralMethods.esnext.types => emitter.asyncGenerators.objectLiteralMethods.es2018.types} (80%) rename tests/baselines/reference/{emitter.forAwait.esnext.js => emitter.forAwait.es2018.js} (90%) rename tests/baselines/reference/{emitter.forAwait.esnext.symbols => emitter.forAwait.es2018.symbols} (77%) rename tests/baselines/reference/{emitter.forAwait.esnext.types => emitter.forAwait.es2018.types} (69%) rename tests/baselines/reference/{parser.asyncGenerators.classMethods.esnext.errors.txt => parser.asyncGenerators.classMethods.es2018.errors.txt} (68%) rename tests/baselines/reference/{parser.asyncGenerators.classMethods.esnext.symbols => parser.asyncGenerators.classMethods.es2018.symbols} (78%) rename tests/baselines/reference/{parser.asyncGenerators.classMethods.esnext.types => parser.asyncGenerators.classMethods.es2018.types} (69%) rename tests/baselines/reference/{parser.asyncGenerators.functionDeclarations.esnext.errors.txt => parser.asyncGenerators.functionDeclarations.es2018.errors.txt} (65%) rename tests/baselines/reference/{parser.asyncGenerators.functionDeclarations.esnext.symbols => parser.asyncGenerators.functionDeclarations.es2018.symbols} (74%) rename tests/baselines/reference/{parser.asyncGenerators.functionDeclarations.esnext.types => parser.asyncGenerators.functionDeclarations.es2018.types} (68%) rename tests/baselines/reference/{parser.asyncGenerators.functionExpressions.esnext.errors.txt => parser.asyncGenerators.functionExpressions.es2018.errors.txt} (66%) rename tests/baselines/reference/{parser.asyncGenerators.functionExpressions.esnext.symbols => parser.asyncGenerators.functionExpressions.es2018.symbols} (75%) rename tests/baselines/reference/{parser.asyncGenerators.functionExpressions.esnext.types => parser.asyncGenerators.functionExpressions.es2018.types} (76%) rename tests/baselines/reference/{parser.asyncGenerators.objectLiteralMethods.esnext.errors.txt => parser.asyncGenerators.objectLiteralMethods.es2018.errors.txt} (67%) rename tests/baselines/reference/{parser.asyncGenerators.objectLiteralMethods.esnext.symbols => parser.asyncGenerators.objectLiteralMethods.es2018.symbols} (78%) rename tests/baselines/reference/{parser.asyncGenerators.objectLiteralMethods.esnext.types => parser.asyncGenerators.objectLiteralMethods.es2018.types} (79%) rename tests/baselines/reference/{parser.forAwait.esnext.errors.txt => parser.forAwait.es2018.errors.txt} (68%) rename tests/baselines/reference/{parser.forAwait.esnext.symbols => parser.forAwait.es2018.symbols} (80%) rename tests/baselines/reference/{parser.forAwait.esnext.types => parser.forAwait.es2018.types} (64%) rename tests/baselines/reference/{types.asyncGenerators.esnext.1.symbols => types.asyncGenerators.es2018.1.symbols} (90%) rename tests/baselines/reference/{types.asyncGenerators.esnext.1.types => types.asyncGenerators.es2018.1.types} (96%) rename tests/baselines/reference/{types.asyncGenerators.esnext.2.errors.txt => types.asyncGenerators.es2018.2.errors.txt} (88%) rename tests/baselines/reference/{types.asyncGenerators.esnext.2.symbols => types.asyncGenerators.es2018.2.symbols} (86%) rename tests/baselines/reference/{types.asyncGenerators.esnext.2.types => types.asyncGenerators.es2018.2.types} (96%) create mode 100644 tests/baselines/reference/types.forAwait.es2018.1.symbols rename tests/baselines/reference/{types.forAwait.esnext.1.types => types.forAwait.es2018.1.types} (92%) rename tests/baselines/reference/{types.forAwait.esnext.2.errors.txt => types.forAwait.es2018.2.errors.txt} (77%) create mode 100644 tests/baselines/reference/types.forAwait.es2018.2.symbols rename tests/baselines/reference/{types.forAwait.esnext.2.types => types.forAwait.es2018.2.types} (87%) rename tests/baselines/reference/{types.forAwait.esnext.3.errors.txt => types.forAwait.es2018.3.errors.txt} (78%) create mode 100644 tests/baselines/reference/types.forAwait.es2018.3.symbols rename tests/baselines/reference/{types.forAwait.esnext.3.types => types.forAwait.es2018.3.types} (79%) delete mode 100644 tests/baselines/reference/types.forAwait.esnext.1.symbols delete mode 100644 tests/baselines/reference/types.forAwait.esnext.2.symbols delete mode 100644 tests/baselines/reference/types.forAwait.esnext.3.symbols rename tests/cases/conformance/emitter/{esnext/asyncGenerators/emitter.asyncGenerators.classMethods.esnext.ts => es2018/asyncGenerators/emitter.asyncGenerators.classMethods.es2018.ts} (91%) rename tests/cases/conformance/emitter/{esnext/asyncGenerators/emitter.asyncGenerators.functionDeclarations.esnext.ts => es2018/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es2018.ts} (91%) rename tests/cases/conformance/emitter/{esnext/asyncGenerators/emitter.asyncGenerators.functionExpressions.esnext.ts => es2018/asyncGenerators/emitter.asyncGenerators.functionExpressions.es2018.ts} (92%) rename tests/cases/conformance/emitter/{esnext/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.esnext.ts => es2018/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es2018.ts} (90%) rename tests/cases/conformance/emitter/{esnext/forAwait/emitter.forAwait.esnext.ts => es2018/forAwait/emitter.forAwait.es2018.ts} (92%) rename tests/cases/conformance/parser/{ecmascriptnext/asyncGenerators/parser.asyncGenerators.classMethods.esnext.ts => ecmascript2018/asyncGenerators/parser.asyncGenerators.classMethods.es2018.ts} (93%) rename tests/cases/conformance/parser/{ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionDeclarations.esnext.ts => ecmascript2018/asyncGenerators/parser.asyncGenerators.functionDeclarations.es2018.ts} (94%) rename tests/cases/conformance/parser/{ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionExpressions.esnext.ts => ecmascript2018/asyncGenerators/parser.asyncGenerators.functionExpressions.es2018.ts} (95%) rename tests/cases/conformance/parser/{ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts => ecmascript2018/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.es2018.ts} (93%) rename tests/cases/conformance/parser/{ecmascriptnext/forAwait/parser.forAwait.esnext.ts => ecmascript2018/forAwait/parser.forAwait.es2018.ts} (93%) rename tests/cases/conformance/types/asyncGenerators/{types.asyncGenerators.esnext.1.ts => types.asyncGenerators.es2018.1.ts} (96%) rename tests/cases/conformance/types/asyncGenerators/{types.asyncGenerators.esnext.2.ts => types.asyncGenerators.es2018.2.ts} (96%) rename tests/cases/conformance/types/forAwait/{types.forAwait.esnext.1.ts => types.forAwait.es2018.1.ts} (93%) rename tests/cases/conformance/types/forAwait/{types.forAwait.esnext.2.ts => types.forAwait.es2018.2.ts} (90%) rename tests/cases/conformance/types/forAwait/{types.forAwait.esnext.3.ts => types.forAwait.es2018.3.ts} (87%) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 6781f6f1701..9124bdf2939 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -3137,8 +3137,8 @@ namespace ts { if (operatorTokenKind === SyntaxKind.EqualsToken && leftKind === SyntaxKind.ObjectLiteralExpression) { // Destructuring object assignments with are ES2015 syntax - // and possibly ESNext if they contain rest - transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.AssertDestructuringAssignment; + // and possibly ES2018 if they contain rest + transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2015 | TransformFlags.AssertDestructuringAssignment; } else if (operatorTokenKind === SyntaxKind.EqualsToken && leftKind === SyntaxKind.ArrayLiteralExpression) { // Destructuring assignments are ES2015 syntax. @@ -3174,9 +3174,9 @@ namespace ts { transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.ContainsTypeScriptClassSyntax; } - // parameters with object rest destructuring are ES Next syntax + // parameters with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } // If a parameter has an initializer, a binding pattern or a dotDotDot token, then @@ -3326,9 +3326,9 @@ namespace ts { transformFlags |= TransformFlags.AssertTypeScript; } - // function declarations with object rest destructuring are ES Next syntax + // function declarations with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } node.transformFlags = transformFlags | TransformFlags.HasComputedFlags; @@ -3350,14 +3350,14 @@ namespace ts { transformFlags |= TransformFlags.AssertTypeScript; } - // function declarations with object rest destructuring are ES Next syntax + // function declarations with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } // An async method declaration is ES2017 syntax. if (hasModifier(node, ModifierFlags.Async)) { - transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017; + transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017; } if (node.asteriskToken) { @@ -3381,9 +3381,9 @@ namespace ts { transformFlags |= TransformFlags.AssertTypeScript; } - // function declarations with object rest destructuring are ES Next syntax + // function declarations with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } node.transformFlags = transformFlags | TransformFlags.HasComputedFlags; @@ -3427,12 +3427,12 @@ namespace ts { // An async function declaration is ES2017 syntax. if (modifierFlags & ModifierFlags.Async) { - transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017; + transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017; } - // function declarations with object rest destructuring are ES Next syntax + // function declarations with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } // If a FunctionDeclaration's subtree has marked the container as needing to capture the @@ -3469,12 +3469,12 @@ namespace ts { // An async function expression is ES2017 syntax. if (hasModifier(node, ModifierFlags.Async)) { - transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017; + transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017; } - // function expressions with object rest destructuring are ES Next syntax + // function expressions with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } @@ -3513,9 +3513,9 @@ namespace ts { transformFlags |= TransformFlags.AssertES2017; } - // arrow functions with object rest destructuring are ES Next syntax + // arrow functions with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } // If an ArrowFunction contains a lexical this, its container must capture the lexical this. @@ -3535,8 +3535,8 @@ namespace ts { if (transformFlags & TransformFlags.Super) { transformFlags ^= TransformFlags.Super; // super inside of an async function requires hoisting the super access (ES2017). - // same for super inside of an async generator, which is ESNext. - transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsESNext; + // same for super inside of an async generator, which is ES2018. + transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsES2018; } node.transformFlags = transformFlags | TransformFlags.HasComputedFlags; @@ -3553,8 +3553,8 @@ namespace ts { if (expressionFlags & TransformFlags.Super) { transformFlags &= ~TransformFlags.Super; // super inside of an async function requires hoisting the super access (ES2017). - // same for super inside of an async generator, which is ESNext. - transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsESNext; + // same for super inside of an async generator, which is ES2018. + transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsES2018; } node.transformFlags = transformFlags | TransformFlags.HasComputedFlags; @@ -3565,9 +3565,9 @@ namespace ts { let transformFlags = subtreeFlags; transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern; - // A VariableDeclaration containing ObjectRest is ESNext syntax + // A VariableDeclaration containing ObjectRest is ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } // Type annotations are TypeScript syntax. @@ -3674,8 +3674,8 @@ namespace ts { switch (kind) { case SyntaxKind.AsyncKeyword: case SyntaxKind.AwaitExpression: - // async/await is ES2017 syntax, but may be ESNext syntax (for async generators) - transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2017; + // async/await is ES2017 syntax, but may be ES2018 syntax (for async generators) + transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2017; break; case SyntaxKind.TypeAssertionExpression: @@ -3747,7 +3747,7 @@ namespace ts { case SyntaxKind.ForOfStatement: // This node is either ES2015 syntax or ES2017 syntax (if it is a for-await-of). if ((node).awaitModifier) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } transformFlags |= TransformFlags.AssertES2015; break; @@ -3755,7 +3755,7 @@ namespace ts { case SyntaxKind.YieldExpression: // This node is either ES2015 syntax (in a generator) or ES2017 syntax (in an async // generator). - transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.ContainsYield; + transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2015 | TransformFlags.ContainsYield; break; case SyntaxKind.AnyKeyword: @@ -3824,7 +3824,7 @@ namespace ts { break; case SyntaxKind.SpreadAssignment: - transformFlags |= TransformFlags.AssertESNext | TransformFlags.ContainsObjectRestOrSpread; + transformFlags |= TransformFlags.AssertES2018 | TransformFlags.ContainsObjectRestOrSpread; break; case SyntaxKind.SuperKeyword: @@ -3841,7 +3841,7 @@ namespace ts { case SyntaxKind.ObjectBindingPattern: transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern; if (subtreeFlags & TransformFlags.ContainsRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext | TransformFlags.ContainsObjectRestOrSpread; + transformFlags |= TransformFlags.AssertES2018 | TransformFlags.ContainsObjectRestOrSpread; } excludeFlags = TransformFlags.BindingPatternExcludes; break; @@ -3879,8 +3879,8 @@ namespace ts { if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { // If an ObjectLiteralExpression contains a spread element, then it - // is an ES next node. - transformFlags |= TransformFlags.AssertESNext; + // is an ES2018 node. + transformFlags |= TransformFlags.AssertES2018; } break; @@ -3915,8 +3915,8 @@ namespace ts { break; case SyntaxKind.ReturnStatement: - // Return statements may require an `await` in ESNext. - transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion | TransformFlags.AssertESNext; + // Return statements may require an `await` in ES2018. + transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion | TransformFlags.AssertES2018; break; case SyntaxKind.ContinueStatement: diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts index fdcaadb4040..aabc6be57a0 100644 --- a/src/compiler/transformer.ts +++ b/src/compiler/transformer.ts @@ -42,6 +42,10 @@ namespace ts { transformers.push(transformESNext); } + if (languageVersion < ScriptTarget.ES2018) { + transformers.push(transformES2018); + } + if (languageVersion < ScriptTarget.ES2017) { transformers.push(transformES2017); } diff --git a/src/compiler/transformers/es2018.ts b/src/compiler/transformers/es2018.ts new file mode 100644 index 00000000000..3087249373a --- /dev/null +++ b/src/compiler/transformers/es2018.ts @@ -0,0 +1,1046 @@ +/*@internal*/ +namespace ts { + const enum ESNextSubstitutionFlags { + /** Enables substitutions for async methods with `super` calls. */ + AsyncMethodsWithSuper = 1 << 0 + } + + export function transformES2018(context: TransformationContext) { + const { + resumeLexicalEnvironment, + endLexicalEnvironment, + hoistVariableDeclaration + } = context; + + const resolver = context.getEmitResolver(); + const compilerOptions = context.getCompilerOptions(); + const languageVersion = getEmitScriptTarget(compilerOptions); + + const previousOnEmitNode = context.onEmitNode; + context.onEmitNode = onEmitNode; + + const previousOnSubstituteNode = context.onSubstituteNode; + context.onSubstituteNode = onSubstituteNode; + + let enabledSubstitutions: ESNextSubstitutionFlags; + let enclosingFunctionFlags: FunctionFlags; + let enclosingSuperContainerFlags: NodeCheckFlags = 0; + + /** Keeps track of property names accessed on super (`super.x`) within async functions. */ + let capturedSuperProperties: UnderscoreEscapedMap; + /** Whether the async function contains an element access on super (`super[x]`). */ + let hasSuperElementAccess: boolean; + /** A set of node IDs for generated super accessors. */ + const substitutedSuperAccessors: boolean[] = []; + + return chainBundle(transformSourceFile); + + function transformSourceFile(node: SourceFile) { + if (node.isDeclarationFile) { + return node; + } + + const visited = visitEachChild(node, visitor, context); + addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + + function visitor(node: Node): VisitResult { + return visitorWorker(node, /*noDestructuringValue*/ false); + } + + function visitorNoDestructuringValue(node: Node): VisitResult { + return visitorWorker(node, /*noDestructuringValue*/ true); + } + + function visitorNoAsyncModifier(node: Node): VisitResult { + if (node.kind === SyntaxKind.AsyncKeyword) { + return undefined; + } + return node; + } + + function visitorWorker(node: Node, noDestructuringValue: boolean): VisitResult { + if ((node.transformFlags & TransformFlags.ContainsES2018) === 0) { + return node; + } + switch (node.kind) { + case SyntaxKind.AwaitExpression: + return visitAwaitExpression(node as AwaitExpression); + case SyntaxKind.YieldExpression: + return visitYieldExpression(node as YieldExpression); + case SyntaxKind.ReturnStatement: + return visitReturnStatement(node as ReturnStatement); + case SyntaxKind.LabeledStatement: + return visitLabeledStatement(node as LabeledStatement); + case SyntaxKind.ObjectLiteralExpression: + return visitObjectLiteralExpression(node as ObjectLiteralExpression); + case SyntaxKind.BinaryExpression: + return visitBinaryExpression(node as BinaryExpression, noDestructuringValue); + case SyntaxKind.VariableDeclaration: + return visitVariableDeclaration(node as VariableDeclaration); + case SyntaxKind.ForOfStatement: + return visitForOfStatement(node as ForOfStatement, /*outermostLabeledStatement*/ undefined); + case SyntaxKind.ForStatement: + return visitForStatement(node as ForStatement); + case SyntaxKind.VoidExpression: + return visitVoidExpression(node as VoidExpression); + case SyntaxKind.Constructor: + return visitConstructorDeclaration(node as ConstructorDeclaration); + case SyntaxKind.MethodDeclaration: + return visitMethodDeclaration(node as MethodDeclaration); + case SyntaxKind.GetAccessor: + return visitGetAccessorDeclaration(node as GetAccessorDeclaration); + case SyntaxKind.SetAccessor: + return visitSetAccessorDeclaration(node as SetAccessorDeclaration); + case SyntaxKind.FunctionDeclaration: + return visitFunctionDeclaration(node as FunctionDeclaration); + case SyntaxKind.FunctionExpression: + return visitFunctionExpression(node as FunctionExpression); + case SyntaxKind.ArrowFunction: + return visitArrowFunction(node as ArrowFunction); + case SyntaxKind.Parameter: + return visitParameter(node as ParameterDeclaration); + case SyntaxKind.ExpressionStatement: + return visitExpressionStatement(node as ExpressionStatement); + case SyntaxKind.ParenthesizedExpression: + return visitParenthesizedExpression(node as ParenthesizedExpression, noDestructuringValue); + case SyntaxKind.PropertyAccessExpression: + if (capturedSuperProperties && isPropertyAccessExpression(node) && node.expression.kind === SyntaxKind.SuperKeyword) { + capturedSuperProperties.set(node.name.escapedText, true); + } + return visitEachChild(node, visitor, context); + case SyntaxKind.ElementAccessExpression: + if (capturedSuperProperties && (node).expression.kind === SyntaxKind.SuperKeyword) { + hasSuperElementAccess = true; + } + return visitEachChild(node, visitor, context); + default: + return visitEachChild(node, visitor, context); + } + } + + function visitAwaitExpression(node: AwaitExpression): Expression { + if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { + return setOriginalNode( + setTextRange( + createYield(createAwaitHelper(context, visitNode(node.expression, visitor, isExpression))), + /*location*/ node + ), + node + ); + } + return visitEachChild(node, visitor, context); + } + + function visitYieldExpression(node: YieldExpression) { + if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { + if (node.asteriskToken) { + const expression = visitNode(node.expression, visitor, isExpression); + + return setOriginalNode( + setTextRange( + createYield( + createAwaitHelper(context, + updateYield( + node, + node.asteriskToken, + createAsyncDelegatorHelper( + context, + createAsyncValuesHelper(context, expression, expression), + expression + ) + ) + ) + ), + node + ), + node + ); + } + + return setOriginalNode( + setTextRange( + createYield( + createDownlevelAwait( + node.expression + ? visitNode(node.expression, visitor, isExpression) + : createVoidZero() + ) + ), + node + ), + node + ); + } + + return visitEachChild(node, visitor, context); + } + + function visitReturnStatement(node: ReturnStatement) { + if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { + return updateReturn(node, createDownlevelAwait( + node.expression ? visitNode(node.expression, visitor, isExpression) : createVoidZero() + )); + } + + return visitEachChild(node, visitor, context); + } + + function visitLabeledStatement(node: LabeledStatement) { + if (enclosingFunctionFlags & FunctionFlags.Async) { + const statement = unwrapInnermostStatementOfLabel(node); + if (statement.kind === SyntaxKind.ForOfStatement && (statement).awaitModifier) { + return visitForOfStatement(statement, node); + } + return restoreEnclosingLabel(visitEachChild(statement, visitor, context), node); + } + return visitEachChild(node, visitor, context); + } + + function chunkObjectLiteralElements(elements: ReadonlyArray): Expression[] { + let chunkObject: ObjectLiteralElementLike[] | undefined; + const objects: Expression[] = []; + for (const e of elements) { + if (e.kind === SyntaxKind.SpreadAssignment) { + if (chunkObject) { + objects.push(createObjectLiteral(chunkObject)); + chunkObject = undefined; + } + const target = e.expression; + objects.push(visitNode(target, visitor, isExpression)); + } + else { + chunkObject = append(chunkObject, e.kind === SyntaxKind.PropertyAssignment + ? createPropertyAssignment(e.name, visitNode(e.initializer, visitor, isExpression)) + : visitNode(e, visitor, isObjectLiteralElementLike)); + } + } + if (chunkObject) { + objects.push(createObjectLiteral(chunkObject)); + } + + return objects; + } + + function visitObjectLiteralExpression(node: ObjectLiteralExpression): Expression { + if (node.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + // spread elements emit like so: + // non-spread elements are chunked together into object literals, and then all are passed to __assign: + // { a, ...o, b } => __assign({a}, o, {b}); + // If the first element is a spread element, then the first argument to __assign is {}: + // { ...o, a, b, ...o2 } => __assign({}, o, {a, b}, o2) + const objects = chunkObjectLiteralElements(node.properties); + if (objects.length && objects[0].kind !== SyntaxKind.ObjectLiteralExpression) { + objects.unshift(createObjectLiteral()); + } + return createAssignHelper(context, objects); + } + return visitEachChild(node, visitor, context); + } + + function visitExpressionStatement(node: ExpressionStatement): ExpressionStatement { + return visitEachChild(node, visitorNoDestructuringValue, context); + } + + function visitParenthesizedExpression(node: ParenthesizedExpression, noDestructuringValue: boolean): ParenthesizedExpression { + return visitEachChild(node, noDestructuringValue ? visitorNoDestructuringValue : visitor, context); + } + + /** + * Visits a BinaryExpression that contains a destructuring assignment. + * + * @param node A BinaryExpression node. + */ + function visitBinaryExpression(node: BinaryExpression, noDestructuringValue: boolean): Expression { + if (isDestructuringAssignment(node) && node.left.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + return flattenDestructuringAssignment( + node, + visitor, + context, + FlattenLevel.ObjectRest, + !noDestructuringValue + ); + } + else if (node.operatorToken.kind === SyntaxKind.CommaToken) { + return updateBinary( + node, + visitNode(node.left, visitorNoDestructuringValue, isExpression), + visitNode(node.right, noDestructuringValue ? visitorNoDestructuringValue : visitor, isExpression) + ); + } + return visitEachChild(node, visitor, context); + } + + /** + * Visits a VariableDeclaration node with a binding pattern. + * + * @param node A VariableDeclaration node. + */ + function visitVariableDeclaration(node: VariableDeclaration): VisitResult { + // If we are here it is because the name contains a binding pattern with a rest somewhere in it. + if (isBindingPattern(node.name) && node.name.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + return flattenDestructuringBinding( + node, + visitor, + context, + FlattenLevel.ObjectRest + ); + } + return visitEachChild(node, visitor, context); + } + + function visitForStatement(node: ForStatement): VisitResult { + return updateFor( + node, + visitNode(node.initializer, visitorNoDestructuringValue, isForInitializer), + visitNode(node.condition, visitor, isExpression), + visitNode(node.incrementor, visitor, isExpression), + visitNode(node.statement, visitor, isStatement) + ); + } + + function visitVoidExpression(node: VoidExpression) { + return visitEachChild(node, visitorNoDestructuringValue, context); + } + + /** + * Visits a ForOfStatement and converts it into a ES2015-compatible ForOfStatement. + * + * @param node A ForOfStatement. + */ + function visitForOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement | undefined): VisitResult { + if (node.initializer.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + node = transformForOfStatementWithObjectRest(node); + } + if (node.awaitModifier) { + return transformForAwaitOfStatement(node, outermostLabeledStatement); + } + else { + return restoreEnclosingLabel(visitEachChild(node, visitor, context), outermostLabeledStatement); + } + } + + function transformForOfStatementWithObjectRest(node: ForOfStatement) { + const initializerWithoutParens = skipParentheses(node.initializer) as ForInitializer; + if (isVariableDeclarationList(initializerWithoutParens) || isAssignmentPattern(initializerWithoutParens)) { + let bodyLocation: TextRange | undefined; + let statementsLocation: TextRange | undefined; + const temp = createTempVariable(/*recordTempVariable*/ undefined); + const statements: Statement[] = [createForOfBindingStatement(initializerWithoutParens, temp)]; + if (isBlock(node.statement)) { + addRange(statements, node.statement.statements); + bodyLocation = node.statement; + statementsLocation = node.statement.statements; + } + else if (node.statement) { + append(statements, node.statement); + bodyLocation = node.statement; + statementsLocation = node.statement; + } + return updateForOf( + node, + node.awaitModifier, + setTextRange( + createVariableDeclarationList( + [ + setTextRange(createVariableDeclaration(temp), node.initializer) + ], + NodeFlags.Let + ), + node.initializer + ), + node.expression, + setTextRange( + createBlock( + setTextRange(createNodeArray(statements), statementsLocation), + /*multiLine*/ true + ), + bodyLocation + ) + ); + } + return node; + } + + function convertForOfStatementHead(node: ForOfStatement, boundValue: Expression) { + const binding = createForOfBindingStatement(node.initializer, boundValue); + + let bodyLocation: TextRange | undefined; + let statementsLocation: TextRange | undefined; + const statements: Statement[] = [visitNode(binding, visitor, isStatement)]; + const statement = visitNode(node.statement, visitor, isStatement); + if (isBlock(statement)) { + addRange(statements, statement.statements); + bodyLocation = statement; + statementsLocation = statement.statements; + } + else { + statements.push(statement); + } + + return setEmitFlags( + setTextRange( + createBlock( + setTextRange(createNodeArray(statements), statementsLocation), + /*multiLine*/ true + ), + bodyLocation + ), + EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps + ); + } + + function createDownlevelAwait(expression: Expression) { + return enclosingFunctionFlags & FunctionFlags.Generator + ? createYield(/*asteriskToken*/ undefined, createAwaitHelper(context, expression)) + : createAwait(expression); + } + + function transformForAwaitOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement | undefined) { + const expression = visitNode(node.expression, visitor, isExpression); + const iterator = isIdentifier(expression) ? getGeneratedNameForNode(expression) : createTempVariable(/*recordTempVariable*/ undefined); + const result = isIdentifier(expression) ? getGeneratedNameForNode(iterator) : createTempVariable(/*recordTempVariable*/ undefined); + const errorRecord = createUniqueName("e"); + const catchVariable = getGeneratedNameForNode(errorRecord); + const returnMethod = createTempVariable(/*recordTempVariable*/ undefined); + const callValues = createAsyncValuesHelper(context, expression, /*location*/ node.expression); + const callNext = createCall(createPropertyAccess(iterator, "next"), /*typeArguments*/ undefined, []); + const getDone = createPropertyAccess(result, "done"); + const getValue = createPropertyAccess(result, "value"); + const callReturn = createFunctionCall(returnMethod, iterator, []); + + hoistVariableDeclaration(errorRecord); + hoistVariableDeclaration(returnMethod); + + const forStatement = setEmitFlags( + setTextRange( + createFor( + /*initializer*/ setEmitFlags( + setTextRange( + createVariableDeclarationList([ + setTextRange(createVariableDeclaration(iterator, /*type*/ undefined, callValues), node.expression), + createVariableDeclaration(result) + ]), + node.expression + ), + EmitFlags.NoHoisting + ), + /*condition*/ createComma( + createAssignment(result, createDownlevelAwait(callNext)), + createLogicalNot(getDone) + ), + /*incrementor*/ undefined, + /*statement*/ convertForOfStatementHead(node, getValue) + ), + /*location*/ node + ), + EmitFlags.NoTokenTrailingSourceMaps + ); + + return createTry( + createBlock([ + restoreEnclosingLabel( + forStatement, + outermostLabeledStatement + ) + ]), + createCatchClause( + createVariableDeclaration(catchVariable), + setEmitFlags( + createBlock([ + createExpressionStatement( + createAssignment( + errorRecord, + createObjectLiteral([ + createPropertyAssignment("error", catchVariable) + ]) + ) + ) + ]), + EmitFlags.SingleLine + ) + ), + createBlock([ + createTry( + /*tryBlock*/ createBlock([ + setEmitFlags( + createIf( + createLogicalAnd( + createLogicalAnd( + result, + createLogicalNot(getDone) + ), + createAssignment( + returnMethod, + createPropertyAccess(iterator, "return") + ) + ), + createExpressionStatement(createDownlevelAwait(callReturn)) + ), + EmitFlags.SingleLine + ) + ]), + /*catchClause*/ undefined, + /*finallyBlock*/ setEmitFlags( + createBlock([ + setEmitFlags( + createIf( + errorRecord, + createThrow( + createPropertyAccess(errorRecord, "error") + ) + ), + EmitFlags.SingleLine + ) + ]), + EmitFlags.SingleLine + ) + ) + ]) + ); + } + + function visitParameter(node: ParameterDeclaration): ParameterDeclaration { + if (node.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + // Binding patterns are converted into a generated name and are + // evaluated inside the function body. + return updateParameter( + node, + /*decorators*/ undefined, + /*modifiers*/ undefined, + node.dotDotDotToken, + getGeneratedNameForNode(node), + /*questionToken*/ undefined, + /*type*/ undefined, + visitNode(node.initializer, visitor, isExpression) + ); + } + return visitEachChild(node, visitor, context); + } + + function visitConstructorDeclaration(node: ConstructorDeclaration) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = FunctionFlags.Normal; + const updated = updateConstructor( + node, + /*decorators*/ undefined, + node.modifiers, + visitParameterList(node.parameters, visitor, context), + transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitGetAccessorDeclaration(node: GetAccessorDeclaration) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = FunctionFlags.Normal; + const updated = updateGetAccessor( + node, + /*decorators*/ undefined, + node.modifiers, + visitNode(node.name, visitor, isPropertyName), + visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, + transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitSetAccessorDeclaration(node: SetAccessorDeclaration) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = FunctionFlags.Normal; + const updated = updateSetAccessor( + node, + /*decorators*/ undefined, + node.modifiers, + visitNode(node.name, visitor, isPropertyName), + visitParameterList(node.parameters, visitor, context), + transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitMethodDeclaration(node: MethodDeclaration) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateMethod( + node, + /*decorators*/ undefined, + enclosingFunctionFlags & FunctionFlags.Generator + ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) + : node.modifiers, + enclosingFunctionFlags & FunctionFlags.Async + ? undefined + : node.asteriskToken, + visitNode(node.name, visitor, isPropertyName), + visitNode>(/*questionToken*/ undefined, visitor, isToken), + /*typeParameters*/ undefined, + visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, + enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitFunctionDeclaration(node: FunctionDeclaration) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateFunctionDeclaration( + node, + /*decorators*/ undefined, + enclosingFunctionFlags & FunctionFlags.Generator + ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) + : node.modifiers, + enclosingFunctionFlags & FunctionFlags.Async + ? undefined + : node.asteriskToken, + node.name, + /*typeParameters*/ undefined, + visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, + enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitArrowFunction(node: ArrowFunction) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateArrowFunction( + node, + node.modifiers, + /*typeParameters*/ undefined, + visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, + node.equalsGreaterThanToken, + transformFunctionBody(node), + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitFunctionExpression(node: FunctionExpression) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateFunctionExpression( + node, + enclosingFunctionFlags & FunctionFlags.Generator + ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) + : node.modifiers, + enclosingFunctionFlags & FunctionFlags.Async + ? undefined + : node.asteriskToken, + node.name, + /*typeParameters*/ undefined, + visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, + enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function transformAsyncGeneratorFunctionBody(node: MethodDeclaration | AccessorDeclaration | FunctionDeclaration | FunctionExpression): FunctionBody { + resumeLexicalEnvironment(); + const statements: Statement[] = []; + const statementOffset = addPrologue(statements, node.body!.statements, /*ensureUseStrict*/ false, visitor); + appendObjectRestAssignmentsIfNeeded(statements, node); + + const savedCapturedSuperProperties = capturedSuperProperties; + const savedHasSuperElementAccess = hasSuperElementAccess; + capturedSuperProperties = createUnderscoreEscapedMap(); + hasSuperElementAccess = false; + + const returnStatement = createReturn( + createAsyncGeneratorHelper( + context, + createFunctionExpression( + /*modifiers*/ undefined, + createToken(SyntaxKind.AsteriskToken), + node.name && getGeneratedNameForNode(node.name), + /*typeParameters*/ undefined, + /*parameters*/ [], + /*type*/ undefined, + updateBlock( + node.body!, + visitLexicalEnvironment(node.body!.statements, visitor, context, statementOffset) + ) + ) + ) + ); + + // Minor optimization, emit `_super` helper to capture `super` access in an arrow. + // This step isn't needed if we eventually transform this to ES5. + const emitSuperHelpers = languageVersion >= ScriptTarget.ES2015 && resolver.getNodeCheckFlags(node) & (NodeCheckFlags.AsyncMethodWithSuperBinding | NodeCheckFlags.AsyncMethodWithSuper); + + if (emitSuperHelpers) { + enableSubstitutionForAsyncMethodsWithSuper(); + const variableStatement = createSuperAccessVariableStatement(resolver, node, capturedSuperProperties); + substitutedSuperAccessors[getNodeId(variableStatement)] = true; + addStatementsAfterPrologue(statements, [variableStatement]); + } + + statements.push(returnStatement); + + addStatementsAfterPrologue(statements, endLexicalEnvironment()); + const block = updateBlock(node.body!, statements); + + if (emitSuperHelpers && hasSuperElementAccess) { + if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuperBinding) { + addEmitHelper(block, advancedAsyncSuperHelper); + } + else if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuper) { + addEmitHelper(block, asyncSuperHelper); + } + } + + capturedSuperProperties = savedCapturedSuperProperties; + hasSuperElementAccess = savedHasSuperElementAccess; + + return block; + } + + function transformFunctionBody(node: FunctionDeclaration | FunctionExpression | ConstructorDeclaration | MethodDeclaration | AccessorDeclaration): FunctionBody; + function transformFunctionBody(node: ArrowFunction): ConciseBody; + function transformFunctionBody(node: FunctionLikeDeclaration): ConciseBody { + resumeLexicalEnvironment(); + let statementOffset = 0; + const statements: Statement[] = []; + const body = visitNode(node.body, visitor, isConciseBody); + if (isBlock(body)) { + statementOffset = addPrologue(statements, body.statements, /*ensureUseStrict*/ false, visitor); + } + addRange(statements, appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node)); + const leadingStatements = endLexicalEnvironment(); + if (statementOffset > 0 || some(statements) || some(leadingStatements)) { + const block = convertToFunctionBody(body, /*multiLine*/ true); + addStatementsAfterPrologue(statements, leadingStatements); + addRange(statements, block.statements.slice(statementOffset)); + return updateBlock(block, setTextRange(createNodeArray(statements), block.statements)); + } + return body; + } + + function appendObjectRestAssignmentsIfNeeded(statements: Statement[] | undefined, node: FunctionLikeDeclaration): Statement[] | undefined { + for (const parameter of node.parameters) { + if (parameter.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + const temp = getGeneratedNameForNode(parameter); + const declarations = flattenDestructuringBinding( + parameter, + visitor, + context, + FlattenLevel.ObjectRest, + temp, + /*doNotRecordTempVariablesInLine*/ false, + /*skipInitializer*/ true, + ); + if (some(declarations)) { + const statement = createVariableStatement( + /*modifiers*/ undefined, + createVariableDeclarationList( + declarations + ) + ); + setEmitFlags(statement, EmitFlags.CustomPrologue); + statements = append(statements, statement); + } + } + } + return statements; + } + + function enableSubstitutionForAsyncMethodsWithSuper() { + if ((enabledSubstitutions & ESNextSubstitutionFlags.AsyncMethodsWithSuper) === 0) { + enabledSubstitutions |= ESNextSubstitutionFlags.AsyncMethodsWithSuper; + + // We need to enable substitutions for call, property access, and element access + // if we need to rewrite super calls. + context.enableSubstitution(SyntaxKind.CallExpression); + context.enableSubstitution(SyntaxKind.PropertyAccessExpression); + context.enableSubstitution(SyntaxKind.ElementAccessExpression); + + // We need to be notified when entering and exiting declarations that bind super. + context.enableEmitNotification(SyntaxKind.ClassDeclaration); + context.enableEmitNotification(SyntaxKind.MethodDeclaration); + context.enableEmitNotification(SyntaxKind.GetAccessor); + context.enableEmitNotification(SyntaxKind.SetAccessor); + context.enableEmitNotification(SyntaxKind.Constructor); + // We need to be notified when entering the generated accessor arrow functions. + context.enableEmitNotification(SyntaxKind.VariableStatement); + } + } + + /** + * Called by the printer just before a node is printed. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to be printed. + * @param emitCallback The callback used to emit the node. + */ + function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) { + // If we need to support substitutions for `super` in an async method, + // we should track it here. + if (enabledSubstitutions & ESNextSubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) { + const superContainerFlags = resolver.getNodeCheckFlags(node) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding); + if (superContainerFlags !== enclosingSuperContainerFlags) { + const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = superContainerFlags; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + } + // Disable substitution in the generated super accessor itself. + else if (enabledSubstitutions && substitutedSuperAccessors[getNodeId(node)]) { + const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = 0 as NodeCheckFlags; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + + previousOnEmitNode(hint, node, emitCallback); + } + + /** + * Hooks node substitutions. + * + * @param hint The context for the emitter. + * @param node The node to substitute. + */ + function onSubstituteNode(hint: EmitHint, node: Node) { + node = previousOnSubstituteNode(hint, node); + if (hint === EmitHint.Expression && enclosingSuperContainerFlags) { + return substituteExpression(node); + } + return node; + } + + function substituteExpression(node: Expression) { + switch (node.kind) { + case SyntaxKind.PropertyAccessExpression: + return substitutePropertyAccessExpression(node); + case SyntaxKind.ElementAccessExpression: + return substituteElementAccessExpression(node); + case SyntaxKind.CallExpression: + return substituteCallExpression(node); + } + return node; + } + + function substitutePropertyAccessExpression(node: PropertyAccessExpression) { + if (node.expression.kind === SyntaxKind.SuperKeyword) { + return setTextRange( + createPropertyAccess( + createFileLevelUniqueName("_super"), + node.name), + node + ); + } + return node; + } + + function substituteElementAccessExpression(node: ElementAccessExpression) { + if (node.expression.kind === SyntaxKind.SuperKeyword) { + return createSuperElementAccessInAsyncMethod( + node.argumentExpression, + node + ); + } + return node; + } + + function substituteCallExpression(node: CallExpression): Expression { + const expression = node.expression; + if (isSuperProperty(expression)) { + const argumentExpression = isPropertyAccessExpression(expression) + ? substitutePropertyAccessExpression(expression) + : substituteElementAccessExpression(expression); + return createCall( + createPropertyAccess(argumentExpression, "call"), + /*typeArguments*/ undefined, + [ + createThis(), + ...node.arguments + ] + ); + } + return node; + } + + function isSuperContainer(node: Node) { + const kind = node.kind; + return kind === SyntaxKind.ClassDeclaration + || kind === SyntaxKind.Constructor + || kind === SyntaxKind.MethodDeclaration + || kind === SyntaxKind.GetAccessor + || kind === SyntaxKind.SetAccessor; + } + + function createSuperElementAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression { + if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) { + return setTextRange( + createPropertyAccess( + createCall( + createIdentifier("_superIndex"), + /*typeArguments*/ undefined, + [argumentExpression] + ), + "value" + ), + location + ); + } + else { + return setTextRange( + createCall( + createIdentifier("_superIndex"), + /*typeArguments*/ undefined, + [argumentExpression] + ), + location + ); + } + } + } + + const assignHelper: EmitHelper = { + name: "typescript:assign", + scoped: false, + priority: 1, + text: ` + var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); + };` + }; + + export function createAssignHelper(context: TransformationContext, attributesSegments: Expression[]) { + if (context.getCompilerOptions().target! >= ScriptTarget.ES2015) { + return createCall(createPropertyAccess(createIdentifier("Object"), "assign"), + /*typeArguments*/ undefined, + attributesSegments); + } + context.requestEmitHelper(assignHelper); + return createCall( + getHelperName("__assign"), + /*typeArguments*/ undefined, + attributesSegments + ); + } + + const awaitHelper: EmitHelper = { + name: "typescript:await", + scoped: false, + text: ` + var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }` + }; + + function createAwaitHelper(context: TransformationContext, expression: Expression) { + context.requestEmitHelper(awaitHelper); + return createCall(getHelperName("__await"), /*typeArguments*/ undefined, [expression]); + } + + const asyncGeneratorHelper: EmitHelper = { + name: "typescript:asyncGenerator", + scoped: false, + text: ` + var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } + };` + }; + + function createAsyncGeneratorHelper(context: TransformationContext, generatorFunc: FunctionExpression) { + context.requestEmitHelper(awaitHelper); + context.requestEmitHelper(asyncGeneratorHelper); + + // Mark this node as originally an async function + (generatorFunc.emitNode || (generatorFunc.emitNode = {} as EmitNode)).flags |= EmitFlags.AsyncFunctionBody; + + return createCall( + getHelperName("__asyncGenerator"), + /*typeArguments*/ undefined, + [ + createThis(), + createIdentifier("arguments"), + generatorFunc + ] + ); + } + + const asyncDelegator: EmitHelper = { + name: "typescript:asyncDelegator", + scoped: false, + text: ` + var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i, p; + return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; } + };` + }; + + function createAsyncDelegatorHelper(context: TransformationContext, expression: Expression, location?: TextRange) { + context.requestEmitHelper(awaitHelper); + context.requestEmitHelper(asyncDelegator); + return setTextRange( + createCall( + getHelperName("__asyncDelegator"), + /*typeArguments*/ undefined, + [expression] + ), + location + ); + } + + const asyncValues: EmitHelper = { + name: "typescript:asyncValues", + scoped: false, + text: ` + var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } + };` + }; + + function createAsyncValuesHelper(context: TransformationContext, expression: Expression, location?: TextRange) { + context.requestEmitHelper(asyncValues); + return setTextRange( + createCall( + getHelperName("__asyncValues"), + /*typeArguments*/ undefined, + [expression] + ), + location + ); + } +} diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index cd62cca2c9d..7c20d39cdea 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -1,38 +1,6 @@ /*@internal*/ namespace ts { - const enum ESNextSubstitutionFlags { - /** Enables substitutions for async methods with `super` calls. */ - AsyncMethodsWithSuper = 1 << 0 - } - export function transformESNext(context: TransformationContext) { - const { - resumeLexicalEnvironment, - endLexicalEnvironment, - hoistVariableDeclaration - } = context; - - const resolver = context.getEmitResolver(); - const compilerOptions = context.getCompilerOptions(); - const languageVersion = getEmitScriptTarget(compilerOptions); - - const previousOnEmitNode = context.onEmitNode; - context.onEmitNode = onEmitNode; - - const previousOnSubstituteNode = context.onSubstituteNode; - context.onSubstituteNode = onSubstituteNode; - - let enabledSubstitutions: ESNextSubstitutionFlags; - let enclosingFunctionFlags: FunctionFlags; - let enclosingSuperContainerFlags: NodeCheckFlags = 0; - - /** Keeps track of property names accessed on super (`super.x`) within async functions. */ - let capturedSuperProperties: UnderscoreEscapedMap; - /** Whether the async function contains an element access on super (`super[x]`). */ - let hasSuperElementAccess: boolean; - /** A set of node IDs for generated super accessors. */ - const substitutedSuperAccessors: boolean[] = []; - return chainBundle(transformSourceFile); function transformSourceFile(node: SourceFile) { @@ -40,215 +8,21 @@ namespace ts { return node; } - const visited = visitEachChild(node, visitor, context); - addEmitHelpers(visited, context.readEmitHelpers()); - return visited; + return visitEachChild(node, visitor, context); } function visitor(node: Node): VisitResult { - return visitorWorker(node, /*noDestructuringValue*/ false); - } - - function visitorNoDestructuringValue(node: Node): VisitResult { - return visitorWorker(node, /*noDestructuringValue*/ true); - } - - function visitorNoAsyncModifier(node: Node): VisitResult { - if (node.kind === SyntaxKind.AsyncKeyword) { - return undefined; - } - return node; - } - - function visitorWorker(node: Node, noDestructuringValue: boolean): VisitResult { if ((node.transformFlags & TransformFlags.ContainsESNext) === 0) { return node; } switch (node.kind) { - case SyntaxKind.AwaitExpression: - return visitAwaitExpression(node as AwaitExpression); - case SyntaxKind.YieldExpression: - return visitYieldExpression(node as YieldExpression); - case SyntaxKind.ReturnStatement: - return visitReturnStatement(node as ReturnStatement); - case SyntaxKind.LabeledStatement: - return visitLabeledStatement(node as LabeledStatement); - case SyntaxKind.ObjectLiteralExpression: - return visitObjectLiteralExpression(node as ObjectLiteralExpression); - case SyntaxKind.BinaryExpression: - return visitBinaryExpression(node as BinaryExpression, noDestructuringValue); - case SyntaxKind.VariableDeclaration: - return visitVariableDeclaration(node as VariableDeclaration); - case SyntaxKind.ForOfStatement: - return visitForOfStatement(node as ForOfStatement, /*outermostLabeledStatement*/ undefined); - case SyntaxKind.ForStatement: - return visitForStatement(node as ForStatement); - case SyntaxKind.VoidExpression: - return visitVoidExpression(node as VoidExpression); - case SyntaxKind.Constructor: - return visitConstructorDeclaration(node as ConstructorDeclaration); - case SyntaxKind.MethodDeclaration: - return visitMethodDeclaration(node as MethodDeclaration); - case SyntaxKind.GetAccessor: - return visitGetAccessorDeclaration(node as GetAccessorDeclaration); - case SyntaxKind.SetAccessor: - return visitSetAccessorDeclaration(node as SetAccessorDeclaration); - case SyntaxKind.FunctionDeclaration: - return visitFunctionDeclaration(node as FunctionDeclaration); - case SyntaxKind.FunctionExpression: - return visitFunctionExpression(node as FunctionExpression); - case SyntaxKind.ArrowFunction: - return visitArrowFunction(node as ArrowFunction); - case SyntaxKind.Parameter: - return visitParameter(node as ParameterDeclaration); - case SyntaxKind.ExpressionStatement: - return visitExpressionStatement(node as ExpressionStatement); - case SyntaxKind.ParenthesizedExpression: - return visitParenthesizedExpression(node as ParenthesizedExpression, noDestructuringValue); case SyntaxKind.CatchClause: return visitCatchClause(node as CatchClause); - case SyntaxKind.PropertyAccessExpression: - if (capturedSuperProperties && isPropertyAccessExpression(node) && node.expression.kind === SyntaxKind.SuperKeyword) { - capturedSuperProperties.set(node.name.escapedText, true); - } - return visitEachChild(node, visitor, context); - case SyntaxKind.ElementAccessExpression: - if (capturedSuperProperties && (node).expression.kind === SyntaxKind.SuperKeyword) { - hasSuperElementAccess = true; - } - return visitEachChild(node, visitor, context); default: return visitEachChild(node, visitor, context); } } - function visitAwaitExpression(node: AwaitExpression): Expression { - if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { - return setOriginalNode( - setTextRange( - createYield(createAwaitHelper(context, visitNode(node.expression, visitor, isExpression))), - /*location*/ node - ), - node - ); - } - return visitEachChild(node, visitor, context); - } - - function visitYieldExpression(node: YieldExpression) { - if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { - if (node.asteriskToken) { - const expression = visitNode(node.expression, visitor, isExpression); - - return setOriginalNode( - setTextRange( - createYield( - createAwaitHelper(context, - updateYield( - node, - node.asteriskToken, - createAsyncDelegatorHelper( - context, - createAsyncValuesHelper(context, expression, expression), - expression - ) - ) - ) - ), - node - ), - node - ); - } - - return setOriginalNode( - setTextRange( - createYield( - createDownlevelAwait( - node.expression - ? visitNode(node.expression, visitor, isExpression) - : createVoidZero() - ) - ), - node - ), - node - ); - } - - return visitEachChild(node, visitor, context); - } - - function visitReturnStatement(node: ReturnStatement) { - if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { - return updateReturn(node, createDownlevelAwait( - node.expression ? visitNode(node.expression, visitor, isExpression) : createVoidZero() - )); - } - - return visitEachChild(node, visitor, context); - } - - function visitLabeledStatement(node: LabeledStatement) { - if (enclosingFunctionFlags & FunctionFlags.Async) { - const statement = unwrapInnermostStatementOfLabel(node); - if (statement.kind === SyntaxKind.ForOfStatement && (statement).awaitModifier) { - return visitForOfStatement(statement, node); - } - return restoreEnclosingLabel(visitEachChild(statement, visitor, context), node); - } - return visitEachChild(node, visitor, context); - } - - function chunkObjectLiteralElements(elements: ReadonlyArray): Expression[] { - let chunkObject: ObjectLiteralElementLike[] | undefined; - const objects: Expression[] = []; - for (const e of elements) { - if (e.kind === SyntaxKind.SpreadAssignment) { - if (chunkObject) { - objects.push(createObjectLiteral(chunkObject)); - chunkObject = undefined; - } - const target = e.expression; - objects.push(visitNode(target, visitor, isExpression)); - } - else { - chunkObject = append(chunkObject, e.kind === SyntaxKind.PropertyAssignment - ? createPropertyAssignment(e.name, visitNode(e.initializer, visitor, isExpression)) - : visitNode(e, visitor, isObjectLiteralElementLike)); - } - } - if (chunkObject) { - objects.push(createObjectLiteral(chunkObject)); - } - - return objects; - } - - function visitObjectLiteralExpression(node: ObjectLiteralExpression): Expression { - if (node.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - // spread elements emit like so: - // non-spread elements are chunked together into object literals, and then all are passed to __assign: - // { a, ...o, b } => __assign({a}, o, {b}); - // If the first element is a spread element, then the first argument to __assign is {}: - // { ...o, a, b, ...o2 } => __assign({}, o, {a, b}, o2) - const objects = chunkObjectLiteralElements(node.properties); - if (objects.length && objects[0].kind !== SyntaxKind.ObjectLiteralExpression) { - objects.unshift(createObjectLiteral()); - } - return createAssignHelper(context, objects); - } - return visitEachChild(node, visitor, context); - } - - function visitExpressionStatement(node: ExpressionStatement): ExpressionStatement { - return visitEachChild(node, visitorNoDestructuringValue, context); - } - - function visitParenthesizedExpression(node: ParenthesizedExpression, noDestructuringValue: boolean): ParenthesizedExpression { - return visitEachChild(node, noDestructuringValue ? visitorNoDestructuringValue : visitor, context); - } - function visitCatchClause(node: CatchClause): CatchClause { if (!node.variableDeclaration) { return updateCatchClause( @@ -259,801 +33,5 @@ namespace ts { } return visitEachChild(node, visitor, context); } - - /** - * Visits a BinaryExpression that contains a destructuring assignment. - * - * @param node A BinaryExpression node. - */ - function visitBinaryExpression(node: BinaryExpression, noDestructuringValue: boolean): Expression { - if (isDestructuringAssignment(node) && node.left.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - return flattenDestructuringAssignment( - node, - visitor, - context, - FlattenLevel.ObjectRest, - !noDestructuringValue - ); - } - else if (node.operatorToken.kind === SyntaxKind.CommaToken) { - return updateBinary( - node, - visitNode(node.left, visitorNoDestructuringValue, isExpression), - visitNode(node.right, noDestructuringValue ? visitorNoDestructuringValue : visitor, isExpression) - ); - } - return visitEachChild(node, visitor, context); - } - - /** - * Visits a VariableDeclaration node with a binding pattern. - * - * @param node A VariableDeclaration node. - */ - function visitVariableDeclaration(node: VariableDeclaration): VisitResult { - // If we are here it is because the name contains a binding pattern with a rest somewhere in it. - if (isBindingPattern(node.name) && node.name.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - return flattenDestructuringBinding( - node, - visitor, - context, - FlattenLevel.ObjectRest - ); - } - return visitEachChild(node, visitor, context); - } - - function visitForStatement(node: ForStatement): VisitResult { - return updateFor( - node, - visitNode(node.initializer, visitorNoDestructuringValue, isForInitializer), - visitNode(node.condition, visitor, isExpression), - visitNode(node.incrementor, visitor, isExpression), - visitNode(node.statement, visitor, isStatement) - ); - } - - function visitVoidExpression(node: VoidExpression) { - return visitEachChild(node, visitorNoDestructuringValue, context); - } - - /** - * Visits a ForOfStatement and converts it into a ES2015-compatible ForOfStatement. - * - * @param node A ForOfStatement. - */ - function visitForOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement | undefined): VisitResult { - if (node.initializer.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - node = transformForOfStatementWithObjectRest(node); - } - if (node.awaitModifier) { - return transformForAwaitOfStatement(node, outermostLabeledStatement); - } - else { - return restoreEnclosingLabel(visitEachChild(node, visitor, context), outermostLabeledStatement); - } - } - - function transformForOfStatementWithObjectRest(node: ForOfStatement) { - const initializerWithoutParens = skipParentheses(node.initializer) as ForInitializer; - if (isVariableDeclarationList(initializerWithoutParens) || isAssignmentPattern(initializerWithoutParens)) { - let bodyLocation: TextRange | undefined; - let statementsLocation: TextRange | undefined; - const temp = createTempVariable(/*recordTempVariable*/ undefined); - const statements: Statement[] = [createForOfBindingStatement(initializerWithoutParens, temp)]; - if (isBlock(node.statement)) { - addRange(statements, node.statement.statements); - bodyLocation = node.statement; - statementsLocation = node.statement.statements; - } - else if (node.statement) { - append(statements, node.statement); - bodyLocation = node.statement; - statementsLocation = node.statement; - } - return updateForOf( - node, - node.awaitModifier, - setTextRange( - createVariableDeclarationList( - [ - setTextRange(createVariableDeclaration(temp), node.initializer) - ], - NodeFlags.Let - ), - node.initializer - ), - node.expression, - setTextRange( - createBlock( - setTextRange(createNodeArray(statements), statementsLocation), - /*multiLine*/ true - ), - bodyLocation - ) - ); - } - return node; - } - - function convertForOfStatementHead(node: ForOfStatement, boundValue: Expression) { - const binding = createForOfBindingStatement(node.initializer, boundValue); - - let bodyLocation: TextRange | undefined; - let statementsLocation: TextRange | undefined; - const statements: Statement[] = [visitNode(binding, visitor, isStatement)]; - const statement = visitNode(node.statement, visitor, isStatement); - if (isBlock(statement)) { - addRange(statements, statement.statements); - bodyLocation = statement; - statementsLocation = statement.statements; - } - else { - statements.push(statement); - } - - return setEmitFlags( - setTextRange( - createBlock( - setTextRange(createNodeArray(statements), statementsLocation), - /*multiLine*/ true - ), - bodyLocation - ), - EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps - ); - } - - function createDownlevelAwait(expression: Expression) { - return enclosingFunctionFlags & FunctionFlags.Generator - ? createYield(/*asteriskToken*/ undefined, createAwaitHelper(context, expression)) - : createAwait(expression); - } - - function transformForAwaitOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement | undefined) { - const expression = visitNode(node.expression, visitor, isExpression); - const iterator = isIdentifier(expression) ? getGeneratedNameForNode(expression) : createTempVariable(/*recordTempVariable*/ undefined); - const result = isIdentifier(expression) ? getGeneratedNameForNode(iterator) : createTempVariable(/*recordTempVariable*/ undefined); - const errorRecord = createUniqueName("e"); - const catchVariable = getGeneratedNameForNode(errorRecord); - const returnMethod = createTempVariable(/*recordTempVariable*/ undefined); - const callValues = createAsyncValuesHelper(context, expression, /*location*/ node.expression); - const callNext = createCall(createPropertyAccess(iterator, "next"), /*typeArguments*/ undefined, []); - const getDone = createPropertyAccess(result, "done"); - const getValue = createPropertyAccess(result, "value"); - const callReturn = createFunctionCall(returnMethod, iterator, []); - - hoistVariableDeclaration(errorRecord); - hoistVariableDeclaration(returnMethod); - - const forStatement = setEmitFlags( - setTextRange( - createFor( - /*initializer*/ setEmitFlags( - setTextRange( - createVariableDeclarationList([ - setTextRange(createVariableDeclaration(iterator, /*type*/ undefined, callValues), node.expression), - createVariableDeclaration(result) - ]), - node.expression - ), - EmitFlags.NoHoisting - ), - /*condition*/ createComma( - createAssignment(result, createDownlevelAwait(callNext)), - createLogicalNot(getDone) - ), - /*incrementor*/ undefined, - /*statement*/ convertForOfStatementHead(node, getValue) - ), - /*location*/ node - ), - EmitFlags.NoTokenTrailingSourceMaps - ); - - return createTry( - createBlock([ - restoreEnclosingLabel( - forStatement, - outermostLabeledStatement - ) - ]), - createCatchClause( - createVariableDeclaration(catchVariable), - setEmitFlags( - createBlock([ - createExpressionStatement( - createAssignment( - errorRecord, - createObjectLiteral([ - createPropertyAssignment("error", catchVariable) - ]) - ) - ) - ]), - EmitFlags.SingleLine - ) - ), - createBlock([ - createTry( - /*tryBlock*/ createBlock([ - setEmitFlags( - createIf( - createLogicalAnd( - createLogicalAnd( - result, - createLogicalNot(getDone) - ), - createAssignment( - returnMethod, - createPropertyAccess(iterator, "return") - ) - ), - createExpressionStatement(createDownlevelAwait(callReturn)) - ), - EmitFlags.SingleLine - ) - ]), - /*catchClause*/ undefined, - /*finallyBlock*/ setEmitFlags( - createBlock([ - setEmitFlags( - createIf( - errorRecord, - createThrow( - createPropertyAccess(errorRecord, "error") - ) - ), - EmitFlags.SingleLine - ) - ]), - EmitFlags.SingleLine - ) - ) - ]) - ); - } - - function visitParameter(node: ParameterDeclaration): ParameterDeclaration { - if (node.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - // Binding patterns are converted into a generated name and are - // evaluated inside the function body. - return updateParameter( - node, - /*decorators*/ undefined, - /*modifiers*/ undefined, - node.dotDotDotToken, - getGeneratedNameForNode(node), - /*questionToken*/ undefined, - /*type*/ undefined, - visitNode(node.initializer, visitor, isExpression) - ); - } - return visitEachChild(node, visitor, context); - } - - function visitConstructorDeclaration(node: ConstructorDeclaration) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = FunctionFlags.Normal; - const updated = updateConstructor( - node, - /*decorators*/ undefined, - node.modifiers, - visitParameterList(node.parameters, visitor, context), - transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitGetAccessorDeclaration(node: GetAccessorDeclaration) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = FunctionFlags.Normal; - const updated = updateGetAccessor( - node, - /*decorators*/ undefined, - node.modifiers, - visitNode(node.name, visitor, isPropertyName), - visitParameterList(node.parameters, visitor, context), - /*type*/ undefined, - transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitSetAccessorDeclaration(node: SetAccessorDeclaration) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = FunctionFlags.Normal; - const updated = updateSetAccessor( - node, - /*decorators*/ undefined, - node.modifiers, - visitNode(node.name, visitor, isPropertyName), - visitParameterList(node.parameters, visitor, context), - transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitMethodDeclaration(node: MethodDeclaration) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = getFunctionFlags(node); - const updated = updateMethod( - node, - /*decorators*/ undefined, - enclosingFunctionFlags & FunctionFlags.Generator - ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) - : node.modifiers, - enclosingFunctionFlags & FunctionFlags.Async - ? undefined - : node.asteriskToken, - visitNode(node.name, visitor, isPropertyName), - visitNode>(/*questionToken*/ undefined, visitor, isToken), - /*typeParameters*/ undefined, - visitParameterList(node.parameters, visitor, context), - /*type*/ undefined, - enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator - ? transformAsyncGeneratorFunctionBody(node) - : transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitFunctionDeclaration(node: FunctionDeclaration) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = getFunctionFlags(node); - const updated = updateFunctionDeclaration( - node, - /*decorators*/ undefined, - enclosingFunctionFlags & FunctionFlags.Generator - ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) - : node.modifiers, - enclosingFunctionFlags & FunctionFlags.Async - ? undefined - : node.asteriskToken, - node.name, - /*typeParameters*/ undefined, - visitParameterList(node.parameters, visitor, context), - /*type*/ undefined, - enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator - ? transformAsyncGeneratorFunctionBody(node) - : transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitArrowFunction(node: ArrowFunction) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = getFunctionFlags(node); - const updated = updateArrowFunction( - node, - node.modifiers, - /*typeParameters*/ undefined, - visitParameterList(node.parameters, visitor, context), - /*type*/ undefined, - node.equalsGreaterThanToken, - transformFunctionBody(node), - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitFunctionExpression(node: FunctionExpression) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = getFunctionFlags(node); - const updated = updateFunctionExpression( - node, - enclosingFunctionFlags & FunctionFlags.Generator - ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) - : node.modifiers, - enclosingFunctionFlags & FunctionFlags.Async - ? undefined - : node.asteriskToken, - node.name, - /*typeParameters*/ undefined, - visitParameterList(node.parameters, visitor, context), - /*type*/ undefined, - enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator - ? transformAsyncGeneratorFunctionBody(node) - : transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function transformAsyncGeneratorFunctionBody(node: MethodDeclaration | AccessorDeclaration | FunctionDeclaration | FunctionExpression): FunctionBody { - resumeLexicalEnvironment(); - const statements: Statement[] = []; - const statementOffset = addPrologue(statements, node.body!.statements, /*ensureUseStrict*/ false, visitor); - appendObjectRestAssignmentsIfNeeded(statements, node); - - const savedCapturedSuperProperties = capturedSuperProperties; - const savedHasSuperElementAccess = hasSuperElementAccess; - capturedSuperProperties = createUnderscoreEscapedMap(); - hasSuperElementAccess = false; - - const returnStatement = createReturn( - createAsyncGeneratorHelper( - context, - createFunctionExpression( - /*modifiers*/ undefined, - createToken(SyntaxKind.AsteriskToken), - node.name && getGeneratedNameForNode(node.name), - /*typeParameters*/ undefined, - /*parameters*/ [], - /*type*/ undefined, - updateBlock( - node.body!, - visitLexicalEnvironment(node.body!.statements, visitor, context, statementOffset) - ) - ) - ) - ); - - // Minor optimization, emit `_super` helper to capture `super` access in an arrow. - // This step isn't needed if we eventually transform this to ES5. - const emitSuperHelpers = languageVersion >= ScriptTarget.ES2015 && resolver.getNodeCheckFlags(node) & (NodeCheckFlags.AsyncMethodWithSuperBinding | NodeCheckFlags.AsyncMethodWithSuper); - - if (emitSuperHelpers) { - enableSubstitutionForAsyncMethodsWithSuper(); - const variableStatement = createSuperAccessVariableStatement(resolver, node, capturedSuperProperties); - substitutedSuperAccessors[getNodeId(variableStatement)] = true; - addStatementsAfterPrologue(statements, [variableStatement]); - } - - statements.push(returnStatement); - - addStatementsAfterPrologue(statements, endLexicalEnvironment()); - const block = updateBlock(node.body!, statements); - - if (emitSuperHelpers && hasSuperElementAccess) { - if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuperBinding) { - addEmitHelper(block, advancedAsyncSuperHelper); - } - else if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuper) { - addEmitHelper(block, asyncSuperHelper); - } - } - - capturedSuperProperties = savedCapturedSuperProperties; - hasSuperElementAccess = savedHasSuperElementAccess; - - return block; - } - - function transformFunctionBody(node: FunctionDeclaration | FunctionExpression | ConstructorDeclaration | MethodDeclaration | AccessorDeclaration): FunctionBody; - function transformFunctionBody(node: ArrowFunction): ConciseBody; - function transformFunctionBody(node: FunctionLikeDeclaration): ConciseBody { - resumeLexicalEnvironment(); - let statementOffset = 0; - const statements: Statement[] = []; - const body = visitNode(node.body, visitor, isConciseBody); - if (isBlock(body)) { - statementOffset = addPrologue(statements, body.statements, /*ensureUseStrict*/ false, visitor); - } - addRange(statements, appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node)); - const leadingStatements = endLexicalEnvironment(); - if (statementOffset > 0 || some(statements) || some(leadingStatements)) { - const block = convertToFunctionBody(body, /*multiLine*/ true); - addStatementsAfterPrologue(statements, leadingStatements); - addRange(statements, block.statements.slice(statementOffset)); - return updateBlock(block, setTextRange(createNodeArray(statements), block.statements)); - } - return body; - } - - function appendObjectRestAssignmentsIfNeeded(statements: Statement[] | undefined, node: FunctionLikeDeclaration): Statement[] | undefined { - for (const parameter of node.parameters) { - if (parameter.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - const temp = getGeneratedNameForNode(parameter); - const declarations = flattenDestructuringBinding( - parameter, - visitor, - context, - FlattenLevel.ObjectRest, - temp, - /*doNotRecordTempVariablesInLine*/ false, - /*skipInitializer*/ true, - ); - if (some(declarations)) { - const statement = createVariableStatement( - /*modifiers*/ undefined, - createVariableDeclarationList( - declarations - ) - ); - setEmitFlags(statement, EmitFlags.CustomPrologue); - statements = append(statements, statement); - } - } - } - return statements; - } - - function enableSubstitutionForAsyncMethodsWithSuper() { - if ((enabledSubstitutions & ESNextSubstitutionFlags.AsyncMethodsWithSuper) === 0) { - enabledSubstitutions |= ESNextSubstitutionFlags.AsyncMethodsWithSuper; - - // We need to enable substitutions for call, property access, and element access - // if we need to rewrite super calls. - context.enableSubstitution(SyntaxKind.CallExpression); - context.enableSubstitution(SyntaxKind.PropertyAccessExpression); - context.enableSubstitution(SyntaxKind.ElementAccessExpression); - - // We need to be notified when entering and exiting declarations that bind super. - context.enableEmitNotification(SyntaxKind.ClassDeclaration); - context.enableEmitNotification(SyntaxKind.MethodDeclaration); - context.enableEmitNotification(SyntaxKind.GetAccessor); - context.enableEmitNotification(SyntaxKind.SetAccessor); - context.enableEmitNotification(SyntaxKind.Constructor); - // We need to be notified when entering the generated accessor arrow functions. - context.enableEmitNotification(SyntaxKind.VariableStatement); - } - } - - /** - * Called by the printer just before a node is printed. - * - * @param hint A hint as to the intended usage of the node. - * @param node The node to be printed. - * @param emitCallback The callback used to emit the node. - */ - function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) { - // If we need to support substitutions for `super` in an async method, - // we should track it here. - if (enabledSubstitutions & ESNextSubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) { - const superContainerFlags = resolver.getNodeCheckFlags(node) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding); - if (superContainerFlags !== enclosingSuperContainerFlags) { - const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; - enclosingSuperContainerFlags = superContainerFlags; - previousOnEmitNode(hint, node, emitCallback); - enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; - return; - } - } - // Disable substitution in the generated super accessor itself. - else if (enabledSubstitutions && substitutedSuperAccessors[getNodeId(node)]) { - const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; - enclosingSuperContainerFlags = 0 as NodeCheckFlags; - previousOnEmitNode(hint, node, emitCallback); - enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; - return; - } - - previousOnEmitNode(hint, node, emitCallback); - } - - /** - * Hooks node substitutions. - * - * @param hint The context for the emitter. - * @param node The node to substitute. - */ - function onSubstituteNode(hint: EmitHint, node: Node) { - node = previousOnSubstituteNode(hint, node); - if (hint === EmitHint.Expression && enclosingSuperContainerFlags) { - return substituteExpression(node); - } - return node; - } - - function substituteExpression(node: Expression) { - switch (node.kind) { - case SyntaxKind.PropertyAccessExpression: - return substitutePropertyAccessExpression(node); - case SyntaxKind.ElementAccessExpression: - return substituteElementAccessExpression(node); - case SyntaxKind.CallExpression: - return substituteCallExpression(node); - } - return node; - } - - function substitutePropertyAccessExpression(node: PropertyAccessExpression) { - if (node.expression.kind === SyntaxKind.SuperKeyword) { - return setTextRange( - createPropertyAccess( - createFileLevelUniqueName("_super"), - node.name), - node - ); - } - return node; - } - - function substituteElementAccessExpression(node: ElementAccessExpression) { - if (node.expression.kind === SyntaxKind.SuperKeyword) { - return createSuperElementAccessInAsyncMethod( - node.argumentExpression, - node - ); - } - return node; - } - - function substituteCallExpression(node: CallExpression): Expression { - const expression = node.expression; - if (isSuperProperty(expression)) { - const argumentExpression = isPropertyAccessExpression(expression) - ? substitutePropertyAccessExpression(expression) - : substituteElementAccessExpression(expression); - return createCall( - createPropertyAccess(argumentExpression, "call"), - /*typeArguments*/ undefined, - [ - createThis(), - ...node.arguments - ] - ); - } - return node; - } - - function isSuperContainer(node: Node) { - const kind = node.kind; - return kind === SyntaxKind.ClassDeclaration - || kind === SyntaxKind.Constructor - || kind === SyntaxKind.MethodDeclaration - || kind === SyntaxKind.GetAccessor - || kind === SyntaxKind.SetAccessor; - } - - function createSuperElementAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression { - if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) { - return setTextRange( - createPropertyAccess( - createCall( - createIdentifier("_superIndex"), - /*typeArguments*/ undefined, - [argumentExpression] - ), - "value" - ), - location - ); - } - else { - return setTextRange( - createCall( - createIdentifier("_superIndex"), - /*typeArguments*/ undefined, - [argumentExpression] - ), - location - ); - } - } - } - - const assignHelper: EmitHelper = { - name: "typescript:assign", - scoped: false, - priority: 1, - text: ` - var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); - };` - }; - - export function createAssignHelper(context: TransformationContext, attributesSegments: Expression[]) { - if (context.getCompilerOptions().target! >= ScriptTarget.ES2015) { - return createCall(createPropertyAccess(createIdentifier("Object"), "assign"), - /*typeArguments*/ undefined, - attributesSegments); - } - context.requestEmitHelper(assignHelper); - return createCall( - getHelperName("__assign"), - /*typeArguments*/ undefined, - attributesSegments - ); - } - - const awaitHelper: EmitHelper = { - name: "typescript:await", - scoped: false, - text: ` - var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }` - }; - - function createAwaitHelper(context: TransformationContext, expression: Expression) { - context.requestEmitHelper(awaitHelper); - return createCall(getHelperName("__await"), /*typeArguments*/ undefined, [expression]); - } - - const asyncGeneratorHelper: EmitHelper = { - name: "typescript:asyncGenerator", - scoped: false, - text: ` - var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { - if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); - var g = generator.apply(thisArg, _arguments || []), i, q = []; - return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; - function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } - function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } - function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } - function fulfill(value) { resume("next", value); } - function reject(value) { resume("throw", value); } - function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } - };` - }; - - function createAsyncGeneratorHelper(context: TransformationContext, generatorFunc: FunctionExpression) { - context.requestEmitHelper(awaitHelper); - context.requestEmitHelper(asyncGeneratorHelper); - - // Mark this node as originally an async function - (generatorFunc.emitNode || (generatorFunc.emitNode = {} as EmitNode)).flags |= EmitFlags.AsyncFunctionBody; - - return createCall( - getHelperName("__asyncGenerator"), - /*typeArguments*/ undefined, - [ - createThis(), - createIdentifier("arguments"), - generatorFunc - ] - ); - } - - const asyncDelegator: EmitHelper = { - name: "typescript:asyncDelegator", - scoped: false, - text: ` - var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { - var i, p; - return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; } - };` - }; - - function createAsyncDelegatorHelper(context: TransformationContext, expression: Expression, location?: TextRange) { - context.requestEmitHelper(awaitHelper); - context.requestEmitHelper(asyncDelegator); - return setTextRange( - createCall( - getHelperName("__asyncDelegator"), - /*typeArguments*/ undefined, - [expression] - ), - location - ); - } - - const asyncValues: EmitHelper = { - name: "typescript:asyncValues", - scoped: false, - text: ` - var __asyncValues = (this && this.__asyncValues) || function (o) { - if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); - var m = o[Symbol.asyncIterator], i; - return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); - function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } - function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } - };` - }; - - function createAsyncValuesHelper(context: TransformationContext, expression: Expression, location?: TextRange) { - context.requestEmitHelper(asyncValues); - return setTextRange( - createCall( - getHelperName("__asyncValues"), - /*typeArguments*/ undefined, - [expression] - ), - location - ); } } diff --git a/src/compiler/tsconfig.json b/src/compiler/tsconfig.json index c41f47f3c4a..14b7ce377e5 100644 --- a/src/compiler/tsconfig.json +++ b/src/compiler/tsconfig.json @@ -30,6 +30,7 @@ "transformers/destructuring.ts", "transformers/ts.ts", "transformers/es2017.ts", + "transformers/es2018.ts", "transformers/esnext.ts", "transformers/jsx.ts", "transformers/es2016.ts", diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 60444cc4f3e..84c365a3968 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -5071,6 +5071,7 @@ namespace ts { ContainsDynamicImport = 1 << 24, Super = 1 << 25, ContainsSuper = 1 << 26, + ContainsES2018 = 1 << 27, // Please leave this as 1 << 29. // It is the maximum bit we can set before we outgrow the size of a v8 small integer (SMI) on an x86 system. @@ -5082,6 +5083,7 @@ namespace ts { AssertTypeScript = TypeScript | ContainsTypeScript, AssertJsx = ContainsJsx, AssertESNext = ContainsESNext, + AssertES2018 = ContainsES2018, AssertES2017 = ContainsES2017, AssertES2016 = ContainsES2016, AssertES2015 = ES2015 | ContainsES2015, diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.js similarity index 88% rename from tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.js rename to tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.js index 84c8aaf009b..6fcebafdd45 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.js +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.js @@ -1,4 +1,4 @@ -//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.classMethods.esnext.ts] //// +//// [tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.classMethods.es2018.ts] //// //// [C1.ts] class C1 { diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.symbols similarity index 73% rename from tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.symbols rename to tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.symbols index 99450781f82..bf5bff3bf3b 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.symbols +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.symbols @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C1.ts === class C1 { >C1 : Symbol(C1, Decl(C1.ts, 0, 0)) @@ -6,7 +6,7 @@ class C1 { >f : Symbol(C1.f, Decl(C1.ts, 0, 10)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C2.ts === class C2 { >C2 : Symbol(C2, Decl(C2.ts, 0, 0)) @@ -17,7 +17,7 @@ class C2 { >x : Symbol(x, Decl(C2.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C3.ts === class C3 { >C3 : Symbol(C3, Decl(C3.ts, 0, 0)) @@ -28,7 +28,7 @@ class C3 { >x : Symbol(x, Decl(C3.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C4.ts === class C4 { >C4 : Symbol(C4, Decl(C4.ts, 0, 0)) @@ -39,7 +39,7 @@ class C4 { >x : Symbol(x, Decl(C4.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C5.ts === class C5 { >C5 : Symbol(C5, Decl(C5.ts, 0, 0)) @@ -50,7 +50,7 @@ class C5 { >x : Symbol(x, Decl(C5.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C6.ts === class C6 { >C6 : Symbol(C6, Decl(C6.ts, 0, 0)) @@ -61,7 +61,7 @@ class C6 { >x : Symbol(x, Decl(C6.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C7.ts === class C7 { >C7 : Symbol(C7, Decl(C7.ts, 0, 0)) @@ -71,7 +71,7 @@ class C7 { return 1; } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C8.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C8.ts === class C8 { >C8 : Symbol(C8, Decl(C8.ts, 0, 0)) @@ -87,7 +87,7 @@ class C8 { >g : Symbol(C8.g, Decl(C8.ts, 0, 10)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C9.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C9.ts === class B9 { >B9 : Symbol(B9, Decl(C9.ts, 0, 0)) diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types similarity index 70% rename from tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.types rename to tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types index f2f5f4d7503..17fefc54e81 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.types +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C1.ts === class C1 { >C1 : C1 @@ -6,7 +6,7 @@ class C1 { >f : () => AsyncIterableIterator } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C2.ts === class C2 { >C2 : C2 @@ -18,7 +18,7 @@ class C2 { >yield : any } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C3.ts === class C3 { >C3 : C3 @@ -31,7 +31,7 @@ class C3 { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C4.ts === class C4 { >C4 : C4 @@ -45,7 +45,7 @@ class C4 { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C5.ts === class C5 { >C5 : C5 @@ -62,7 +62,7 @@ class C5 { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C6.ts === class C6 { >C6 : C6 @@ -75,7 +75,7 @@ class C6 { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C7.ts === class C7 { >C7 : C7 @@ -86,7 +86,7 @@ class C7 { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C8.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C8.ts === class C8 { >C8 : C8 @@ -103,7 +103,7 @@ class C8 { >g : () => void } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C9.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C9.ts === class B9 { >B9 : B9 diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.js similarity index 83% rename from tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.js rename to tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.js index 57708e027a3..6937d84f276 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.js @@ -1,4 +1,4 @@ -//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionDeclarations.esnext.ts] //// +//// [tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es2018.ts] //// //// [F1.ts] async function * f1() { diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.symbols similarity index 62% rename from tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.symbols rename to tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.symbols index 018b7d7e07a..a93cc2ccbb0 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.symbols +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.symbols @@ -1,43 +1,43 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F1.ts === async function * f1() { >f1 : Symbol(f1, Decl(F1.ts, 0, 0)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F2.ts === async function * f2() { >f2 : Symbol(f2, Decl(F2.ts, 0, 0)) const x = yield; >x : Symbol(x, Decl(F2.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F3.ts === async function * f3() { >f3 : Symbol(f3, Decl(F3.ts, 0, 0)) const x = yield 1; >x : Symbol(x, Decl(F3.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F4.ts === async function * f4() { >f4 : Symbol(f4, Decl(F4.ts, 0, 0)) const x = yield* [1]; >x : Symbol(x, Decl(F4.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F5.ts === async function * f5() { >f5 : Symbol(f5, Decl(F5.ts, 0, 0)) const x = yield* (async function*() { yield 1; })(); >x : Symbol(x, Decl(F5.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F6.ts === async function * f6() { >f6 : Symbol(f6, Decl(F6.ts, 0, 0)) const x = await 1; >x : Symbol(x, Decl(F6.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F7.ts === async function * f7() { >f7 : Symbol(f7, Decl(F7.ts, 0, 0)) diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types similarity index 68% rename from tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.types rename to tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types index c0d80117746..8ffd5534e40 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.types +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types @@ -1,8 +1,8 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F1.ts === async function * f1() { >f1 : () => AsyncIterableIterator } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F2.ts === async function * f2() { >f2 : () => AsyncIterableIterator @@ -10,7 +10,7 @@ async function * f2() { >x : any >yield : any } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F3.ts === async function * f3() { >f3 : () => AsyncIterableIterator @@ -19,7 +19,7 @@ async function * f3() { >yield 1 : any >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F4.ts === async function * f4() { >f4 : () => AsyncIterableIterator @@ -29,7 +29,7 @@ async function * f4() { >[1] : number[] >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F5.ts === async function * f5() { >f5 : () => AsyncIterableIterator @@ -42,7 +42,7 @@ async function * f5() { >yield 1 : any >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F6.ts === async function * f6() { >f6 : () => AsyncIterableIterator @@ -51,7 +51,7 @@ async function * f6() { >await 1 : 1 >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F7.ts === async function * f7() { >f7 : () => AsyncIterableIterator diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.js similarity index 85% rename from tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.js rename to tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.js index 349fea53b7a..f9be141c5b2 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.js @@ -1,4 +1,4 @@ -//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionExpressions.esnext.ts] //// +//// [tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionExpressions.es2018.ts] //// //// [F1.ts] const f1 = async function * () { diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.symbols similarity index 63% rename from tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.symbols rename to tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.symbols index e59d8429fb7..06c2d7a580e 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.symbols +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.symbols @@ -1,43 +1,43 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F1.ts === const f1 = async function * () { >f1 : Symbol(f1, Decl(F1.ts, 0, 5)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F2.ts === const f2 = async function * () { >f2 : Symbol(f2, Decl(F2.ts, 0, 5)) const x = yield; >x : Symbol(x, Decl(F2.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F3.ts === const f3 = async function * () { >f3 : Symbol(f3, Decl(F3.ts, 0, 5)) const x = yield 1; >x : Symbol(x, Decl(F3.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F4.ts === const f4 = async function * () { >f4 : Symbol(f4, Decl(F4.ts, 0, 5)) const x = yield* [1]; >x : Symbol(x, Decl(F4.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F5.ts === const f5 = async function * () { >f5 : Symbol(f5, Decl(F5.ts, 0, 5)) const x = yield* (async function*() { yield 1; })(); >x : Symbol(x, Decl(F5.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F6.ts === const f6 = async function * () { >f6 : Symbol(f6, Decl(F6.ts, 0, 5)) const x = await 1; >x : Symbol(x, Decl(F6.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F7.ts === const f7 = async function * () { >f7 : Symbol(f7, Decl(F7.ts, 0, 5)) diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types similarity index 77% rename from tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.types rename to tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types index 5802bc10a2d..07ee0579bed 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.types +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types @@ -1,9 +1,9 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F1.ts === const f1 = async function * () { >f1 : () => AsyncIterableIterator >async function * () {} : () => AsyncIterableIterator } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F2.ts === const f2 = async function * () { >f2 : () => AsyncIterableIterator >async function * () { const x = yield;} : () => AsyncIterableIterator @@ -12,7 +12,7 @@ const f2 = async function * () { >x : any >yield : any } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F3.ts === const f3 = async function * () { >f3 : () => AsyncIterableIterator >async function * () { const x = yield 1;} : () => AsyncIterableIterator @@ -22,7 +22,7 @@ const f3 = async function * () { >yield 1 : any >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F4.ts === const f4 = async function * () { >f4 : () => AsyncIterableIterator >async function * () { const x = yield* [1];} : () => AsyncIterableIterator @@ -33,7 +33,7 @@ const f4 = async function * () { >[1] : number[] >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F5.ts === const f5 = async function * () { >f5 : () => AsyncIterableIterator >async function * () { const x = yield* (async function*() { yield 1; })();} : () => AsyncIterableIterator @@ -47,7 +47,7 @@ const f5 = async function * () { >yield 1 : any >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F6.ts === const f6 = async function * () { >f6 : () => AsyncIterableIterator >async function * () { const x = await 1;} : () => AsyncIterableIterator @@ -57,7 +57,7 @@ const f6 = async function * () { >await 1 : 1 >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F7.ts === const f7 = async function * () { >f7 : () => AsyncIterableIterator >async function * () { return 1;} : () => AsyncIterableIterator diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.js similarity index 86% rename from tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.js rename to tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.js index a1877b38184..765e6a2fdfa 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.js +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.js @@ -1,4 +1,4 @@ -//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.esnext.ts] //// +//// [tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es2018.ts] //// //// [O1.ts] const o1 = { diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.symbols similarity index 69% rename from tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.symbols rename to tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.symbols index c1c7847c592..a0e4794068b 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.symbols +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.symbols @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O1.ts === const o1 = { >o1 : Symbol(o1, Decl(O1.ts, 0, 5)) @@ -6,7 +6,7 @@ const o1 = { >f : Symbol(f, Decl(O1.ts, 0, 12)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O2.ts === const o2 = { >o2 : Symbol(o2, Decl(O2.ts, 0, 5)) @@ -17,7 +17,7 @@ const o2 = { >x : Symbol(x, Decl(O2.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O3.ts === const o3 = { >o3 : Symbol(o3, Decl(O3.ts, 0, 5)) @@ -28,7 +28,7 @@ const o3 = { >x : Symbol(x, Decl(O3.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O4.ts === const o4 = { >o4 : Symbol(o4, Decl(O4.ts, 0, 5)) @@ -39,7 +39,7 @@ const o4 = { >x : Symbol(x, Decl(O4.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O5.ts === const o5 = { >o5 : Symbol(o5, Decl(O5.ts, 0, 5)) @@ -50,7 +50,7 @@ const o5 = { >x : Symbol(x, Decl(O5.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O6.ts === const o6 = { >o6 : Symbol(o6, Decl(O6.ts, 0, 5)) @@ -61,7 +61,7 @@ const o6 = { >x : Symbol(x, Decl(O6.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O7.ts === const o7 = { >o7 : Symbol(o7, Decl(O7.ts, 0, 5)) diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types similarity index 80% rename from tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.types rename to tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types index a05b5326b2c..4b33425a7a4 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.types +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O1.ts === const o1 = { >o1 : { f(): AsyncIterableIterator; } >{ async * f() { }} : { f(): AsyncIterableIterator; } @@ -7,7 +7,7 @@ const o1 = { >f : () => AsyncIterableIterator } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O2.ts === const o2 = { >o2 : { f(): AsyncIterableIterator; } >{ async * f() { const x = yield; }} : { f(): AsyncIterableIterator; } @@ -20,7 +20,7 @@ const o2 = { >yield : any } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O3.ts === const o3 = { >o3 : { f(): AsyncIterableIterator; } >{ async * f() { const x = yield 1; }} : { f(): AsyncIterableIterator; } @@ -34,7 +34,7 @@ const o3 = { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O4.ts === const o4 = { >o4 : { f(): AsyncIterableIterator; } >{ async * f() { const x = yield* [1]; }} : { f(): AsyncIterableIterator; } @@ -49,7 +49,7 @@ const o4 = { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O5.ts === const o5 = { >o5 : { f(): AsyncIterableIterator; } >{ async * f() { const x = yield* (async function*() { yield 1; })(); }} : { f(): AsyncIterableIterator; } @@ -67,7 +67,7 @@ const o5 = { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O6.ts === const o6 = { >o6 : { f(): AsyncIterableIterator; } >{ async * f() { const x = await 1; }} : { f(): AsyncIterableIterator; } @@ -81,7 +81,7 @@ const o6 = { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O7.ts === const o7 = { >o7 : { f(): AsyncIterableIterator; } >{ async * f() { return 1; }} : { f(): AsyncIterableIterator; } diff --git a/tests/baselines/reference/emitter.forAwait.esnext.js b/tests/baselines/reference/emitter.forAwait.es2018.js similarity index 90% rename from tests/baselines/reference/emitter.forAwait.esnext.js rename to tests/baselines/reference/emitter.forAwait.es2018.js index 0042ae38fbd..f9ae2b1bd95 100644 --- a/tests/baselines/reference/emitter.forAwait.esnext.js +++ b/tests/baselines/reference/emitter.forAwait.es2018.js @@ -1,4 +1,4 @@ -//// [tests/cases/conformance/emitter/esnext/forAwait/emitter.forAwait.esnext.ts] //// +//// [tests/cases/conformance/emitter/es2018/forAwait/emitter.forAwait.es2018.ts] //// //// [file1.ts] async function f1() { @@ -39,7 +39,8 @@ async function* f6() { outer: for await (const x of y) { continue outer; } -} +} + //// [file1.js] async function f1() { diff --git a/tests/baselines/reference/emitter.forAwait.esnext.symbols b/tests/baselines/reference/emitter.forAwait.es2018.symbols similarity index 77% rename from tests/baselines/reference/emitter.forAwait.esnext.symbols rename to tests/baselines/reference/emitter.forAwait.es2018.symbols index 2910738102b..c1beab7fb78 100644 --- a/tests/baselines/reference/emitter.forAwait.esnext.symbols +++ b/tests/baselines/reference/emitter.forAwait.es2018.symbols @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/forAwait/file1.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file1.ts === async function f1() { >f1 : Symbol(f1, Decl(file1.ts, 0, 0)) @@ -10,7 +10,7 @@ async function f1() { >y : Symbol(y, Decl(file1.ts, 1, 7)) } } -=== tests/cases/conformance/emitter/esnext/forAwait/file2.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file2.ts === async function f2() { >f2 : Symbol(f2, Decl(file2.ts, 0, 0)) @@ -23,7 +23,7 @@ async function f2() { >y : Symbol(y, Decl(file2.ts, 1, 15)) } } -=== tests/cases/conformance/emitter/esnext/forAwait/file3.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file3.ts === async function* f3() { >f3 : Symbol(f3, Decl(file3.ts, 0, 0)) @@ -35,7 +35,7 @@ async function* f3() { >y : Symbol(y, Decl(file3.ts, 1, 7)) } } -=== tests/cases/conformance/emitter/esnext/forAwait/file4.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file4.ts === async function* f4() { >f4 : Symbol(f4, Decl(file4.ts, 0, 0)) @@ -48,7 +48,7 @@ async function* f4() { >y : Symbol(y, Decl(file4.ts, 1, 15)) } } -=== tests/cases/conformance/emitter/esnext/forAwait/file5.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file5.ts === // https://github.com/Microsoft/TypeScript/issues/21363 async function f5() { >f5 : Symbol(f5, Decl(file5.ts, 0, 0)) @@ -63,7 +63,7 @@ async function f5() { continue outer; } } -=== tests/cases/conformance/emitter/esnext/forAwait/file6.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file6.ts === // https://github.com/Microsoft/TypeScript/issues/21363 async function* f6() { >f6 : Symbol(f6, Decl(file6.ts, 0, 0)) @@ -78,3 +78,4 @@ async function* f6() { continue outer; } } + diff --git a/tests/baselines/reference/emitter.forAwait.esnext.types b/tests/baselines/reference/emitter.forAwait.es2018.types similarity index 69% rename from tests/baselines/reference/emitter.forAwait.esnext.types rename to tests/baselines/reference/emitter.forAwait.es2018.types index 6339aeebeff..c9954de364d 100644 --- a/tests/baselines/reference/emitter.forAwait.esnext.types +++ b/tests/baselines/reference/emitter.forAwait.es2018.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/forAwait/file1.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file1.ts === async function f1() { >f1 : () => Promise @@ -10,7 +10,7 @@ async function f1() { >y : any } } -=== tests/cases/conformance/emitter/esnext/forAwait/file2.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file2.ts === async function f2() { >f2 : () => Promise @@ -23,7 +23,7 @@ async function f2() { >y : any } } -=== tests/cases/conformance/emitter/esnext/forAwait/file3.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file3.ts === async function* f3() { >f3 : () => AsyncIterableIterator @@ -35,7 +35,7 @@ async function* f3() { >y : any } } -=== tests/cases/conformance/emitter/esnext/forAwait/file4.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file4.ts === async function* f4() { >f4 : () => AsyncIterableIterator @@ -48,7 +48,7 @@ async function* f4() { >y : any } } -=== tests/cases/conformance/emitter/esnext/forAwait/file5.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file5.ts === // https://github.com/Microsoft/TypeScript/issues/21363 async function f5() { >f5 : () => Promise @@ -65,7 +65,7 @@ async function f5() { >outer : any } } -=== tests/cases/conformance/emitter/esnext/forAwait/file6.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file6.ts === // https://github.com/Microsoft/TypeScript/issues/21363 async function* f6() { >f6 : () => AsyncIterableIterator @@ -82,3 +82,4 @@ async function* f6() { >outer : any } } + diff --git a/tests/baselines/reference/forAwaitForUnion.js b/tests/baselines/reference/forAwaitForUnion.js index e0a4b9ebf82..072d45967d8 100644 --- a/tests/baselines/reference/forAwaitForUnion.js +++ b/tests/baselines/reference/forAwaitForUnion.js @@ -2,7 +2,8 @@ async function f(source: Iterable | AsyncIterable) { for await (const x of source) { } -} +} + //// [forAwaitForUnion.js] async function f(source) { diff --git a/tests/baselines/reference/forAwaitForUnion.symbols b/tests/baselines/reference/forAwaitForUnion.symbols index 8b31ea48684..386cc725a12 100644 --- a/tests/baselines/reference/forAwaitForUnion.symbols +++ b/tests/baselines/reference/forAwaitForUnion.symbols @@ -13,3 +13,4 @@ async function f(source: Iterable | AsyncIterable) { >source : Symbol(source, Decl(forAwaitForUnion.ts, 0, 20)) } } + diff --git a/tests/baselines/reference/forAwaitForUnion.types b/tests/baselines/reference/forAwaitForUnion.types index 9013ce41191..180197b26ea 100644 --- a/tests/baselines/reference/forAwaitForUnion.types +++ b/tests/baselines/reference/forAwaitForUnion.types @@ -8,3 +8,4 @@ async function f(source: Iterable | AsyncIterable) { >source : Iterable | AsyncIterable } } + diff --git a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.errors.txt similarity index 68% rename from tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.errors.txt rename to tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.errors.txt index febd6d1160e..0a114efc26c 100644 --- a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.errors.txt +++ b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.errors.txt @@ -1,50 +1,50 @@ -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts(2,17): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts(2,15): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts(2,17): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts(2,19): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts(3,14): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,15): error TS2693: 'await' only refers to a type, but is being used as a value here. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,20): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,18): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,24): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,26): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,18): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,26): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,28): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,34): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,36): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,28): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,36): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsStrictError.ts(4,16): error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInClassComputedPropertyIsError.ts(2,14): error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInClassComputedPropertyIsError.ts(2,14): error TS2693: 'yield' only refers to a type, but is being used as a value here. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS1163: A 'yield' expression is only allowed in a generator body. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS2523: 'yield' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,15): error TS2693: 'yield' only refers to a type, but is being used as a value here. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,20): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts(3,16): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts(2,17): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts(2,15): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts(2,17): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts(2,19): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts(3,14): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,15): error TS2693: 'await' only refers to a type, but is being used as a value here. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,20): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,18): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,24): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,26): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,18): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,26): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,28): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,34): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,36): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,28): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,36): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsStrictError.ts(4,16): error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInClassComputedPropertyIsError.ts(2,14): error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInClassComputedPropertyIsError.ts(2,14): error TS2693: 'yield' only refers to a type, but is being used as a value here. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS1163: A 'yield' expression is only allowed in a generator body. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS2523: 'yield' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,15): error TS2693: 'yield' only refers to a type, but is being used as a value here. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,20): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts(3,16): error TS1109: Expression expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts (0 errors) ==== class C1 { async * f() { } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts (0 errors) ==== class C2 { async * await() { } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts (0 errors) ==== class C3 { async * yield() { } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (4 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts (4 errors) ==== class C4 { async * f(await) { ~~~~~ @@ -57,7 +57,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } ~ !!! error TS1128: Declaration or statement expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (4 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts (4 errors) ==== class C5 { async * f(yield) { ~~~~~ @@ -70,14 +70,14 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } ~ !!! error TS1128: Declaration or statement expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== class C6 { async * f(a = await 1) { ~~~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts (2 errors) ==== class C7 { async * f(a = yield) { ~~~~~ @@ -86,14 +86,14 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== class C8 { async * f() { async function * g() { } } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== class C9 { async * f() { function yield() { @@ -104,7 +104,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== class C10 { async * f() { const x = function yield() { @@ -115,7 +115,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== class C11 { async * f() { function await() { @@ -128,7 +128,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== class C12 { async * f() { const x = function await() { @@ -141,19 +141,19 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts (0 errors) ==== class C13 { async * f() { yield; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== class C14 { async * f() { yield 1; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== class C15 { async * f() { yield *; @@ -161,19 +161,19 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1109: Expression expected. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== class C16 { async * f() { yield * []; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== class C17 { async * f() { await 1; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== class C18 { async * f() { await; @@ -181,14 +181,14 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1109: Expression expected. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== interface await {} class C19 { async * f() { let x: await; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsStrictError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsStrictError.ts (1 errors) ==== interface yield {} class C20 { async * f() { @@ -197,7 +197,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInClassComputedPropertyIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInClassComputedPropertyIsError.ts (2 errors) ==== class C21 { async * [yield]() { ~~~~~ @@ -206,13 +206,13 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS2693: 'yield' only refers to a type, but is being used as a value here. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== class C22 { async * f() { const x = { [yield]: 1 }; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts (1 errors) ==== class C23 { async * get x() { ~ @@ -220,16 +220,17 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa return 1; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts (1 errors) ==== class C24 { async * set x(value: number) { ~ !!! error TS1005: '(' expected. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts (1 errors) ==== class C25 { async * x = 1; ~ !!! error TS1005: '(' expected. - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.symbols b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.symbols similarity index 78% rename from tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.symbols rename to tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.symbols index 30e2ed3df59..b3494dd0079 100644 --- a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.symbols +++ b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.symbols @@ -1,4 +1,4 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts === class C1 { >C1 : Symbol(C1, Decl(methodIsOk.ts, 0, 0)) @@ -6,7 +6,7 @@ class C1 { >f : Symbol(C1.f, Decl(methodIsOk.ts, 0, 10)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts === class C2 { >C2 : Symbol(C2, Decl(awaitMethodNameIsOk.ts, 0, 0)) @@ -14,7 +14,7 @@ class C2 { >await : Symbol(C2.await, Decl(awaitMethodNameIsOk.ts, 0, 10)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts === class C3 { >C3 : Symbol(C3, Decl(yieldMethodNameIsOk.ts, 0, 0)) @@ -22,7 +22,7 @@ class C3 { >yield : Symbol(C3.yield, Decl(yieldMethodNameIsOk.ts, 0, 10)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === class C4 { >C4 : Symbol(C4, Decl(awaitParameterIsError.ts, 0, 0)) @@ -30,7 +30,7 @@ class C4 { >f : Symbol(C4.f, Decl(awaitParameterIsError.ts, 0, 10)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === class C5 { >C5 : Symbol(C5, Decl(yieldParameterIsError.ts, 0, 0)) @@ -38,7 +38,7 @@ class C5 { >f : Symbol(C5.f, Decl(yieldParameterIsError.ts, 0, 10)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === class C6 { >C6 : Symbol(C6, Decl(awaitInParameterInitializerIsError.ts, 0, 0)) @@ -47,7 +47,7 @@ class C6 { >a : Symbol(a, Decl(awaitInParameterInitializerIsError.ts, 1, 14)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === class C7 { >C7 : Symbol(C7, Decl(yieldInParameterInitializerIsError.ts, 0, 0)) @@ -56,7 +56,7 @@ class C7 { >a : Symbol(a, Decl(yieldInParameterInitializerIsError.ts, 1, 14)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === class C8 { >C8 : Symbol(C8, Decl(nestedAsyncGeneratorIsOk.ts, 0, 0)) @@ -68,7 +68,7 @@ class C8 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === class C9 { >C9 : Symbol(C9, Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 0)) @@ -80,7 +80,7 @@ class C9 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === class C10 { >C10 : Symbol(C10, Decl(nestedFunctionExpressionNamedYieldIsError.ts, 0, 0)) @@ -93,7 +93,7 @@ class C10 { }; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === class C11 { >C11 : Symbol(C11, Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 0)) @@ -105,7 +105,7 @@ class C11 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === class C12 { >C12 : Symbol(C12, Decl(nestedFunctionExpressionNamedAwaitIsError.ts, 0, 0)) @@ -118,7 +118,7 @@ class C12 { }; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === class C13 { >C13 : Symbol(C13, Decl(yieldIsOk.ts, 0, 0)) @@ -128,7 +128,7 @@ class C13 { yield; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === class C14 { >C14 : Symbol(C14, Decl(yieldWithValueIsOk.ts, 0, 0)) @@ -138,7 +138,7 @@ class C14 { yield 1; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === class C15 { >C15 : Symbol(C15, Decl(yieldStarMissingValueIsError.ts, 0, 0)) @@ -148,7 +148,7 @@ class C15 { yield *; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === class C16 { >C16 : Symbol(C16, Decl(yieldStarWithValueIsOk.ts, 0, 0)) @@ -158,7 +158,7 @@ class C16 { yield * []; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === class C17 { >C17 : Symbol(C17, Decl(awaitWithValueIsOk.ts, 0, 0)) @@ -168,7 +168,7 @@ class C17 { await 1; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === class C18 { >C18 : Symbol(C18, Decl(awaitMissingValueIsError.ts, 0, 0)) @@ -178,7 +178,7 @@ class C18 { await; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} >await : Symbol(await, Decl(awaitAsTypeIsOk.ts, 0, 0)) @@ -193,7 +193,7 @@ class C19 { >await : Symbol(await, Decl(awaitAsTypeIsOk.ts, 0, 0)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsStrictError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsStrictError.ts === interface yield {} >yield : Symbol(yield, Decl(yieldAsTypeIsStrictError.ts, 0, 0)) @@ -208,7 +208,7 @@ class C20 { >yield : Symbol(yield, Decl(yieldAsTypeIsStrictError.ts, 0, 0)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInClassComputedPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInClassComputedPropertyIsError.ts === class C21 { >C21 : Symbol(C21, Decl(yieldInClassComputedPropertyIsError.ts, 0, 0)) @@ -216,7 +216,7 @@ class C21 { >[yield] : Symbol(C21[yield], Decl(yieldInClassComputedPropertyIsError.ts, 0, 11)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === class C22 { >C22 : Symbol(C22, Decl(yieldInNestedComputedPropertyIsOk.ts, 0, 0)) @@ -228,7 +228,7 @@ class C22 { >[yield] : Symbol([yield], Decl(yieldInNestedComputedPropertyIsOk.ts, 2, 19)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === class C23 { >C23 : Symbol(C23, Decl(asyncGeneratorGetAccessorIsError.ts, 0, 0)) @@ -239,7 +239,7 @@ class C23 { return 1; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === class C24 { >C24 : Symbol(C24, Decl(asyncGeneratorSetAccessorIsError.ts, 0, 0)) @@ -249,7 +249,7 @@ class C24 { >value : Symbol(value, Decl(asyncGeneratorSetAccessorIsError.ts, 1, 18)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts === class C25 { >C25 : Symbol(C25, Decl(asyncGeneratorPropertyIsError.ts, 0, 0)) @@ -257,3 +257,4 @@ class C25 { >x : Symbol(C25.x, Decl(asyncGeneratorPropertyIsError.ts, 0, 11)) >1 : Symbol(C25[1], Decl(asyncGeneratorPropertyIsError.ts, 1, 15)) } + diff --git a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.types b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types similarity index 69% rename from tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.types rename to tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types index a6662a10d43..9252c2a22c1 100644 --- a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.types +++ b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts === class C1 { >C1 : C1 @@ -6,7 +6,7 @@ class C1 { >f : () => AsyncIterableIterator } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts === class C2 { >C2 : C2 @@ -14,7 +14,7 @@ class C2 { >await : () => AsyncIterableIterator } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts === class C3 { >C3 : C3 @@ -22,7 +22,7 @@ class C3 { >yield : () => AsyncIterableIterator } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === class C4 { >C4 : C4 @@ -31,7 +31,7 @@ class C4 { >await : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === class C5 { >C5 : C5 @@ -40,7 +40,7 @@ class C5 { >yield : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === class C6 { >C6 : C6 @@ -51,7 +51,7 @@ class C6 { >1 : 1 } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === class C7 { >C7 : C7 @@ -61,7 +61,7 @@ class C7 { >yield : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === class C8 { >C8 : C8 @@ -73,7 +73,7 @@ class C8 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === class C9 { >C9 : C9 @@ -87,7 +87,7 @@ class C9 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === class C10 { >C10 : C10 @@ -103,7 +103,7 @@ class C10 { }; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === class C11 { >C11 : C11 @@ -118,7 +118,7 @@ class C11 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === class C12 { >C12 : C12 @@ -135,7 +135,7 @@ class C12 { }; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === class C13 { >C13 : C13 @@ -146,7 +146,7 @@ class C13 { >yield : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === class C14 { >C14 : C14 @@ -158,7 +158,7 @@ class C14 { >1 : 1 } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === class C15 { >C15 : C15 @@ -170,7 +170,7 @@ class C15 { > : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === class C16 { >C16 : C16 @@ -182,7 +182,7 @@ class C16 { >[] : undefined[] } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === class C17 { >C17 : C17 @@ -194,7 +194,7 @@ class C17 { >1 : 1 } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === class C18 { >C18 : C18 @@ -206,7 +206,7 @@ class C18 { > : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} class C19 { >C19 : C19 @@ -218,7 +218,7 @@ class C19 { >x : await } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsStrictError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsStrictError.ts === interface yield {} class C20 { >C20 : C20 @@ -230,7 +230,7 @@ class C20 { >x : yield } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInClassComputedPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInClassComputedPropertyIsError.ts === class C21 { >C21 : C21 @@ -239,7 +239,7 @@ class C21 { >yield : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === class C22 { >C22 : C22 @@ -254,7 +254,7 @@ class C22 { >1 : 1 } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === class C23 { >C23 : C23 @@ -266,7 +266,7 @@ class C23 { >1 : 1 } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === class C24 { >C24 : C24 @@ -276,7 +276,7 @@ class C24 { >value : number } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts === class C25 { >C25 : C25 @@ -284,3 +284,4 @@ class C25 { >x : () => any >1 : any } + diff --git a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.errors.txt similarity index 65% rename from tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.errors.txt rename to tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.errors.txt index a80c67badd5..bc020c474df 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.errors.txt +++ b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.errors.txt @@ -1,61 +1,61 @@ -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts(1,25): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts(2,10): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(1,21): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(1,26): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,14): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,20): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,22): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,14): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,22): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,24): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,32): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,24): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,32): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts(1,25): error TS2523: 'yield' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(1,21): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(1,26): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts(2,12): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts(1,25): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts(2,10): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(1,21): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(1,26): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,14): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,20): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,22): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,14): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,22): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,24): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,32): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,24): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,32): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts(1,25): error TS2523: 'yield' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(1,21): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(1,26): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts(2,12): error TS1109: Expression expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionDeclarationIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionDeclarationIsOk.ts (0 errors) ==== async function * f1() { } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsOk.ts (0 errors) ==== async function * await() { } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsOk.ts (0 errors) ==== async function * yield() { } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts (2 errors) ==== async function * f4(await) { ~~~~~ !!! error TS1138: Parameter declaration expected. ~ !!! error TS1005: ';' expected. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts (2 errors) ==== async function * f5(yield) { ~~~~~ !!! error TS1138: Parameter declaration expected. ~ !!! error TS1005: ';' expected. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== async function * f6(a = await 1) { ~~~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== async function * f7(a = yield) { ~~~~~ !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== async function * f8() { async function * g() { } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== async function * f9() { function yield() { ~~~~~ @@ -64,7 +64,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: '=>' expected. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== async function * f10() { const x = function yield() { ~~~~~ @@ -73,7 +73,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: '=>' expected. }; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== async function * f11() { function await() { ~~~~~ @@ -84,7 +84,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: ';' expected. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (2 errors) ==== async function * f12() { const x = function yield() { ~~~~~ @@ -93,45 +93,46 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: '=>' expected. }; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts (0 errors) ==== async function * f13() { yield; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== async function * f14() { yield 1; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== async function * f15() { yield *; ~ !!! error TS1109: Expression expected. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== async function * f16() { yield * []; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== async function * f17() { await 1; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== async function * f18() { await; ~ !!! error TS1109: Expression expected. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== interface await {} async function * f19() { let x: await; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== interface yield {} async function * f20() { let x: yield; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== async function * f21() { const x = { [yield]: 1 }; - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.symbols b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.symbols similarity index 74% rename from tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.symbols rename to tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.symbols index f8359754d6f..cfc9034846c 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.symbols +++ b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.symbols @@ -1,36 +1,36 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionDeclarationIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionDeclarationIsOk.ts === async function * f1() { >f1 : Symbol(f1, Decl(functionDeclarationIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsOk.ts === async function * await() { >await : Symbol(await, Decl(awaitNameIsOk.ts, 0, 0), Decl(awaitAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsOk.ts === async function * yield() { >yield : Symbol(yield, Decl(yieldNameIsOk.ts, 0, 0), Decl(yieldAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === async function * f4(await) { >f4 : Symbol(f4, Decl(awaitParameterIsError.ts, 0, 0)) >await : Symbol(await, Decl(awaitNameIsOk.ts, 0, 0), Decl(awaitAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === async function * f5(yield) { >f5 : Symbol(f5, Decl(yieldParameterIsError.ts, 0, 0)) >yield : Symbol(yield, Decl(yieldNameIsOk.ts, 0, 0), Decl(yieldAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === async function * f6(a = await 1) { >f6 : Symbol(f6, Decl(awaitInParameterInitializerIsError.ts, 0, 0)) >a : Symbol(a, Decl(awaitInParameterInitializerIsError.ts, 0, 20)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === async function * f7(a = yield) { >f7 : Symbol(f7, Decl(yieldInParameterInitializerIsError.ts, 0, 0)) >a : Symbol(a, Decl(yieldInParameterInitializerIsError.ts, 0, 20)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === async function * f8() { >f8 : Symbol(f8, Decl(nestedAsyncGeneratorIsOk.ts, 0, 0)) @@ -38,7 +38,7 @@ async function * f8() { >g : Symbol(g, Decl(nestedAsyncGeneratorIsOk.ts, 0, 23)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === async function * f9() { >f9 : Symbol(f9, Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 0)) @@ -46,7 +46,7 @@ async function * f9() { > : Symbol((Missing), Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 23)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === async function * f10() { >f10 : Symbol(f10, Decl(nestedFunctionExpressionNamedYieldIsError.ts, 0, 0)) @@ -55,7 +55,7 @@ async function * f10() { }; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === async function * f11() { >f11 : Symbol(f11, Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 0)) @@ -63,7 +63,7 @@ async function * f11() { > : Symbol((Missing), Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 24)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === async function * f12() { >f12 : Symbol(f12, Decl(nestedFunctionExpressionNamedAwaitIsError.ts, 0, 0)) @@ -72,43 +72,43 @@ async function * f12() { }; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === async function * f13() { >f13 : Symbol(f13, Decl(yieldIsOk.ts, 0, 0)) yield; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === async function * f14() { >f14 : Symbol(f14, Decl(yieldWithValueIsOk.ts, 0, 0)) yield 1; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === async function * f15() { >f15 : Symbol(f15, Decl(yieldStarMissingValueIsError.ts, 0, 0)) yield *; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === async function * f16() { >f16 : Symbol(f16, Decl(yieldStarWithValueIsOk.ts, 0, 0)) yield * []; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === async function * f17() { >f17 : Symbol(f17, Decl(awaitWithValueIsOk.ts, 0, 0)) await 1; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === async function * f18() { >f18 : Symbol(f18, Decl(awaitMissingValueIsError.ts, 0, 0)) await; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} >await : Symbol(await, Decl(awaitNameIsOk.ts, 0, 0), Decl(awaitAsTypeIsOk.ts, 0, 0)) @@ -119,7 +119,7 @@ async function * f19() { >x : Symbol(x, Decl(awaitAsTypeIsOk.ts, 2, 7)) >await : Symbol(await, Decl(awaitNameIsOk.ts, 0, 0), Decl(awaitAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} >yield : Symbol(yield, Decl(yieldNameIsOk.ts, 0, 0), Decl(yieldAsTypeIsOk.ts, 0, 0)) @@ -130,7 +130,7 @@ async function * f20() { >x : Symbol(x, Decl(yieldAsTypeIsOk.ts, 2, 7)) >yield : Symbol(yield, Decl(yieldNameIsOk.ts, 0, 0), Decl(yieldAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === async function * f21() { >f21 : Symbol(f21, Decl(yieldInNestedComputedPropertyIsOk.ts, 0, 0)) @@ -138,3 +138,4 @@ async function * f21() { >x : Symbol(x, Decl(yieldInNestedComputedPropertyIsOk.ts, 1, 9)) >[yield] : Symbol([yield], Decl(yieldInNestedComputedPropertyIsOk.ts, 1, 15)) } + diff --git a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.types b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types similarity index 68% rename from tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.types rename to tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types index 5d3c28b9f9e..8804529efd2 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.types +++ b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types @@ -1,39 +1,39 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionDeclarationIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionDeclarationIsOk.ts === async function * f1() { >f1 : () => AsyncIterableIterator } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsOk.ts === async function * await() { >await : () => AsyncIterableIterator } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsOk.ts === async function * yield() { >yield : () => AsyncIterableIterator } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === async function * f4(await) { >f4 : () => any >await : () => AsyncIterableIterator } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === async function * f5(yield) { >f5 : () => any >yield : () => AsyncIterableIterator } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === async function * f6(a = await 1) { >f6 : (a?: number) => AsyncIterableIterator >a : number >await 1 : 1 >1 : 1 } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === async function * f7(a = yield) { >f7 : (a?: any) => AsyncIterableIterator >a : any >yield : any } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === async function * f8() { >f8 : () => AsyncIterableIterator @@ -41,7 +41,7 @@ async function * f8() { >g : () => AsyncIterableIterator } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === async function * f9() { >f9 : () => AsyncIterableIterator<() => void> @@ -51,7 +51,7 @@ async function * f9() { >() { } : () => void } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === async function * f10() { >f10 : () => AsyncIterableIterator<() => void> @@ -63,7 +63,7 @@ async function * f10() { }; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === async function * f11() { >f11 : () => AsyncIterableIterator @@ -74,7 +74,7 @@ async function * f11() { > : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === async function * f12() { >f12 : () => AsyncIterableIterator<() => void> @@ -86,14 +86,14 @@ async function * f12() { }; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === async function * f13() { >f13 : () => AsyncIterableIterator yield; >yield : any } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === async function * f14() { >f14 : () => AsyncIterableIterator @@ -101,7 +101,7 @@ async function * f14() { >yield 1 : any >1 : 1 } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === async function * f15() { >f15 : () => AsyncIterableIterator @@ -109,7 +109,7 @@ async function * f15() { >yield * : any > : any } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === async function * f16() { >f16 : () => AsyncIterableIterator @@ -117,7 +117,7 @@ async function * f16() { >yield * [] : any >[] : undefined[] } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === async function * f17() { >f17 : () => AsyncIterableIterator @@ -125,7 +125,7 @@ async function * f17() { >await 1 : 1 >1 : 1 } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === async function * f18() { >f18 : () => AsyncIterableIterator @@ -133,7 +133,7 @@ async function * f18() { >await : any > : any } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} async function * f19() { >f19 : () => AsyncIterableIterator @@ -141,7 +141,7 @@ async function * f19() { let x: await; >x : await } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} async function * f20() { >f20 : () => AsyncIterableIterator @@ -149,7 +149,7 @@ async function * f20() { let x: yield; >x : yield } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === async function * f21() { >f21 : () => AsyncIterableIterator @@ -160,3 +160,4 @@ async function * f21() { >yield : any >1 : 1 } + diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.errors.txt similarity index 66% rename from tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.errors.txt rename to tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.errors.txt index f9f564f1cc2..43d2eb414b2 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.errors.txt +++ b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.errors.txt @@ -1,96 +1,96 @@ -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts(1,34): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts(2,10): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts(1,29): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts(1,29): error TS2451: Cannot redeclare block-scoped variable 'await'. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts(1,34): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts(1,37): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(1,30): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(1,30): error TS2451: Cannot redeclare block-scoped variable 'await'. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(1,35): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,14): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,20): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,22): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,14): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,22): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,24): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,30): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,32): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,24): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,32): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts(1,34): error TS2523: 'yield' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts(1,29): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts(1,29): error TS2451: Cannot redeclare block-scoped variable 'yield'. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts(1,34): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts(1,37): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(1,30): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(1,30): error TS2451: Cannot redeclare block-scoped variable 'yield'. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(1,35): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts(2,12): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts(1,34): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts(2,10): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts(1,29): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts(1,29): error TS2451: Cannot redeclare block-scoped variable 'await'. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts(1,34): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts(1,37): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(1,30): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(1,30): error TS2451: Cannot redeclare block-scoped variable 'await'. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(1,35): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,14): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,20): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,22): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,14): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,22): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,24): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,30): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,32): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,24): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,32): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts(1,34): error TS2523: 'yield' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts(1,29): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts(1,29): error TS2451: Cannot redeclare block-scoped variable 'yield'. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts(1,34): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts(1,37): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(1,30): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(1,30): error TS2451: Cannot redeclare block-scoped variable 'yield'. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(1,35): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts(2,12): error TS1109: Expression expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionExpressionIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionExpressionIsOk.ts (0 errors) ==== const f1 = async function * f() { }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts (4 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts (4 errors) ==== const f2 = async function * await() { ~~~~~ !!! error TS1005: '(' expected. ~~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'await'. -!!! related TS6203 tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts:1:30: 'await' was also declared here. +!!! related TS6203 tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts:1:30: 'await' was also declared here. ~ !!! error TS1005: ',' expected. ~ !!! error TS1005: '=>' expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts (4 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts (4 errors) ==== const f3 = async function * yield() { ~~~~~ !!! error TS1005: '(' expected. ~~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'yield'. -!!! related TS6203 tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts:1:30: 'yield' was also declared here. +!!! related TS6203 tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts:1:30: 'yield' was also declared here. ~ !!! error TS1005: ',' expected. ~ !!! error TS1005: '=>' expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts (3 errors) ==== const f4 = async function * (await) { ~~~~~ !!! error TS1138: Parameter declaration expected. ~~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'await'. -!!! related TS6203 tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts:1:29: 'await' was also declared here. +!!! related TS6203 tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts:1:29: 'await' was also declared here. ~ !!! error TS1005: ',' expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts (3 errors) ==== const f5 = async function * (yield) { ~~~~~ !!! error TS1138: Parameter declaration expected. ~~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'yield'. -!!! related TS6203 tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts:1:29: 'yield' was also declared here. +!!! related TS6203 tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts:1:29: 'yield' was also declared here. ~ !!! error TS1005: ',' expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== const f6 = async function * (a = await 1) { ~~~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== const f7 = async function * (a = yield) { ~~~~~ !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== const f8 = async function * () { async function * g() { } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== const f9 = async function * () { function yield() { ~~~~~ @@ -99,7 +99,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: '=>' expected. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== const f10 = async function * () { const x = function yield() { ~~~~~ @@ -108,7 +108,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: '=>' expected. }; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== const f11 = async function * () { function await() { ~~~~~ @@ -119,7 +119,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: ';' expected. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== const f12 = async function * () { const x = function await() { ~~~~~ @@ -130,45 +130,45 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: ';' expected. }; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts (0 errors) ==== const f13 = async function * () { yield; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== const f14 = async function * () { yield 1; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== const f15 = async function * () { yield *; ~ !!! error TS1109: Expression expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== const f16 = async function * () { yield * []; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== const f17 = async function * () { await 1; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== const f18 = async function * () { await; ~ !!! error TS1109: Expression expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== interface await {} const f19 = async function * () { let x: await; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== interface yield {} const f20 = async function * () { let x: yield; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== const f21 = async function *() { const x = { [yield]: 1 }; }; diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.symbols b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.symbols similarity index 75% rename from tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.symbols rename to tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.symbols index a22915b1533..b914ecf1eaf 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.symbols +++ b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.symbols @@ -1,46 +1,46 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionExpressionIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionExpressionIsOk.ts === const f1 = async function * f() { >f1 : Symbol(f1, Decl(functionExpressionIsOk.ts, 0, 5)) >f : Symbol(f, Decl(functionExpressionIsOk.ts, 0, 10)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts === const f2 = async function * await() { >f2 : Symbol(f2, Decl(awaitNameIsError.ts, 0, 5)) >await : Symbol(await, Decl(awaitNameIsError.ts, 0, 27), Decl(awaitAsTypeIsOk.ts, 0, 0)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts === const f3 = async function * yield() { >f3 : Symbol(f3, Decl(yieldNameIsError.ts, 0, 5)) >yield : Symbol(yield, Decl(yieldNameIsError.ts, 0, 27), Decl(yieldAsTypeIsOk.ts, 0, 0)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === const f4 = async function * (await) { >f4 : Symbol(f4, Decl(awaitParameterIsError.ts, 0, 5)) >await : Symbol(await, Decl(awaitParameterIsError.ts, 0, 29)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === const f5 = async function * (yield) { >f5 : Symbol(f5, Decl(yieldParameterIsError.ts, 0, 5)) >yield : Symbol(yield, Decl(yieldParameterIsError.ts, 0, 29)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === const f6 = async function * (a = await 1) { >f6 : Symbol(f6, Decl(awaitInParameterInitializerIsError.ts, 0, 5)) >a : Symbol(a, Decl(awaitInParameterInitializerIsError.ts, 0, 29)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === const f7 = async function * (a = yield) { >f7 : Symbol(f7, Decl(yieldInParameterInitializerIsError.ts, 0, 5)) >a : Symbol(a, Decl(yieldInParameterInitializerIsError.ts, 0, 29)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === const f8 = async function * () { >f8 : Symbol(f8, Decl(nestedAsyncGeneratorIsOk.ts, 0, 5)) @@ -48,7 +48,7 @@ const f8 = async function * () { >g : Symbol(g, Decl(nestedAsyncGeneratorIsOk.ts, 0, 32)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === const f9 = async function * () { >f9 : Symbol(f9, Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 5)) @@ -56,7 +56,7 @@ const f9 = async function * () { > : Symbol((Missing), Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 32)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === const f10 = async function * () { >f10 : Symbol(f10, Decl(nestedFunctionExpressionNamedYieldIsError.ts, 0, 5)) @@ -65,7 +65,7 @@ const f10 = async function * () { }; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === const f11 = async function * () { >f11 : Symbol(f11, Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 5)) @@ -73,7 +73,7 @@ const f11 = async function * () { > : Symbol((Missing), Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 33)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === const f12 = async function * () { >f12 : Symbol(f12, Decl(nestedFunctionExpressionNamedAwaitIsError.ts, 0, 5)) @@ -82,43 +82,43 @@ const f12 = async function * () { }; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === const f13 = async function * () { >f13 : Symbol(f13, Decl(yieldIsOk.ts, 0, 5)) yield; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === const f14 = async function * () { >f14 : Symbol(f14, Decl(yieldWithValueIsOk.ts, 0, 5)) yield 1; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === const f15 = async function * () { >f15 : Symbol(f15, Decl(yieldStarMissingValueIsError.ts, 0, 5)) yield *; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === const f16 = async function * () { >f16 : Symbol(f16, Decl(yieldStarWithValueIsOk.ts, 0, 5)) yield * []; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === const f17 = async function * () { >f17 : Symbol(f17, Decl(awaitWithValueIsOk.ts, 0, 5)) await 1; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === const f18 = async function * () { >f18 : Symbol(f18, Decl(awaitMissingValueIsError.ts, 0, 5)) await; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} >await : Symbol(await, Decl(awaitNameIsError.ts, 0, 27), Decl(awaitAsTypeIsOk.ts, 0, 0)) @@ -130,7 +130,7 @@ const f19 = async function * () { >await : Symbol(await, Decl(awaitNameIsError.ts, 0, 27), Decl(awaitAsTypeIsOk.ts, 0, 0)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} >yield : Symbol(yield, Decl(yieldNameIsError.ts, 0, 27), Decl(yieldAsTypeIsOk.ts, 0, 0)) @@ -142,7 +142,7 @@ const f20 = async function * () { >yield : Symbol(yield, Decl(yieldNameIsError.ts, 0, 27), Decl(yieldAsTypeIsOk.ts, 0, 0)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === const f21 = async function *() { >f21 : Symbol(f21, Decl(yieldInNestedComputedPropertyIsOk.ts, 0, 5)) diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.types b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types similarity index 76% rename from tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.types rename to tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types index f97176336c6..277b79a3a39 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.types +++ b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types @@ -1,11 +1,11 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionExpressionIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionExpressionIsOk.ts === const f1 = async function * f() { >f1 : () => AsyncIterableIterator >async function * f() {} : () => AsyncIterableIterator >f : () => AsyncIterableIterator }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts === const f2 = async function * await() { >f2 : () => any >async function * : () => any @@ -13,7 +13,7 @@ const f2 = async function * await() { >() {} : () => void }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts === const f3 = async function * yield() { >f3 : () => any >async function * : () => any @@ -21,21 +21,21 @@ const f3 = async function * yield() { >() {} : () => void }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === const f4 = async function * (await) { >f4 : () => any >async function * ( : () => any >await : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === const f5 = async function * (yield) { >f5 : () => any >async function * ( : () => any >yield : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === const f6 = async function * (a = await 1) { >f6 : (a?: number) => AsyncIterableIterator >async function * (a = await 1) {} : (a?: number) => AsyncIterableIterator @@ -44,7 +44,7 @@ const f6 = async function * (a = await 1) { >1 : 1 }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === const f7 = async function * (a = yield) { >f7 : (a?: any) => AsyncIterableIterator >async function * (a = yield) {} : (a?: any) => AsyncIterableIterator @@ -52,7 +52,7 @@ const f7 = async function * (a = yield) { >yield : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === const f8 = async function * () { >f8 : () => AsyncIterableIterator >async function * () { async function * g() { }} : () => AsyncIterableIterator @@ -61,7 +61,7 @@ const f8 = async function * () { >g : () => AsyncIterableIterator } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === const f9 = async function * () { >f9 : () => AsyncIterableIterator<() => void> >async function * () { function yield() { }} : () => AsyncIterableIterator<() => void> @@ -72,7 +72,7 @@ const f9 = async function * () { >() { } : () => void } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === const f10 = async function * () { >f10 : () => AsyncIterableIterator<() => void> >async function * () { const x = function yield() { };} : () => AsyncIterableIterator<() => void> @@ -85,7 +85,7 @@ const f10 = async function * () { }; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === const f11 = async function * () { >f11 : () => AsyncIterableIterator >async function * () { function await() { }} : () => AsyncIterableIterator @@ -97,7 +97,7 @@ const f11 = async function * () { > : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === const f12 = async function * () { >f12 : () => AsyncIterableIterator >async function * () { const x = function await() { };} : () => AsyncIterableIterator @@ -111,7 +111,7 @@ const f12 = async function * () { }; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === const f13 = async function * () { >f13 : () => AsyncIterableIterator >async function * () { yield;} : () => AsyncIterableIterator @@ -120,7 +120,7 @@ const f13 = async function * () { >yield : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === const f14 = async function * () { >f14 : () => AsyncIterableIterator >async function * () { yield 1;} : () => AsyncIterableIterator @@ -130,7 +130,7 @@ const f14 = async function * () { >1 : 1 }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === const f15 = async function * () { >f15 : () => AsyncIterableIterator >async function * () { yield *;} : () => AsyncIterableIterator @@ -140,7 +140,7 @@ const f15 = async function * () { > : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === const f16 = async function * () { >f16 : () => AsyncIterableIterator >async function * () { yield * [];} : () => AsyncIterableIterator @@ -150,7 +150,7 @@ const f16 = async function * () { >[] : undefined[] }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === const f17 = async function * () { >f17 : () => AsyncIterableIterator >async function * () { await 1;} : () => AsyncIterableIterator @@ -160,7 +160,7 @@ const f17 = async function * () { >1 : 1 }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === const f18 = async function * () { >f18 : () => AsyncIterableIterator >async function * () { await;} : () => AsyncIterableIterator @@ -170,7 +170,7 @@ const f18 = async function * () { > : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} const f19 = async function * () { >f19 : () => AsyncIterableIterator @@ -180,7 +180,7 @@ const f19 = async function * () { >x : await }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} const f20 = async function * () { >f20 : () => AsyncIterableIterator @@ -190,7 +190,7 @@ const f20 = async function * () { >x : yield }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === const f21 = async function *() { >f21 : () => AsyncIterableIterator >async function *() { const x = { [yield]: 1 };} : () => AsyncIterableIterator diff --git a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.errors.txt similarity index 67% rename from tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.errors.txt rename to tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.errors.txt index 4fe18485a2d..e0f8adbab15 100644 --- a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.errors.txt +++ b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.errors.txt @@ -1,48 +1,48 @@ -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts(2,17): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts(2,14): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts(2,17): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts(2,19): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts(3,14): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,15): error TS2693: 'await' only refers to a type, but is being used as a value here. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,20): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,22): error TS1136: Property assignment expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,18): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,24): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,26): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,18): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,26): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,28): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,34): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,36): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,28): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,36): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS2523: 'yield' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,15): error TS2693: 'yield' only refers to a type, but is being used as a value here. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,20): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,22): error TS1136: Property assignment expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts(3,16): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts(2,17): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts(2,14): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts(2,17): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts(2,19): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts(3,14): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,15): error TS2693: 'await' only refers to a type, but is being used as a value here. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,20): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,22): error TS1136: Property assignment expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,18): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,24): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,26): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,18): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,26): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,28): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,34): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,36): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,28): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,36): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS2523: 'yield' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,15): error TS2693: 'yield' only refers to a type, but is being used as a value here. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,20): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,22): error TS1136: Property assignment expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts(3,16): error TS1109: Expression expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts (0 errors) ==== const o1 = { async * f() { } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts (0 errors) ==== const o2 = { async * await() { } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts (0 errors) ==== const o3 = { async * yield() { } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (5 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts (5 errors) ==== const o4 = { async * f(await) { ~~~~~ @@ -57,7 +57,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; ~ !!! error TS1128: Declaration or statement expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (5 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts (5 errors) ==== const o5 = { async * f(yield) { ~~~~~ @@ -72,28 +72,28 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; ~ !!! error TS1128: Declaration or statement expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== const o6 = { async * f(a = await 1) { ~~~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== const o7 = { async * f(a = yield) { ~~~~~ !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== const o8 = { async * f() { async function * g() { } } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== const o9 = { async * f() { function yield() { @@ -104,7 +104,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== const o10 = { async * f() { const x = function yield() { @@ -115,7 +115,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== const o11 = { async * f() { function await() { @@ -128,7 +128,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== const o12 = { async * f() { const x = function await() { @@ -141,19 +141,19 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts (0 errors) ==== const o13 = { async * f() { yield; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== const o14 = { async * f() { yield 1; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== const o15 = { async * f() { yield *; @@ -161,19 +161,19 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1109: Expression expected. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== const o16 = { async * f() { yield * []; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== const o17 = { async * f() { await 1; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== const o18 = { async * f() { await; @@ -181,27 +181,27 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1109: Expression expected. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== interface await {} const o19 = { async * f() { let x: await; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== interface yield {} const o20 = { async * f() { let x: yield; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== const o21 = { async * f() { const x = { [yield]: 1 }; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts (1 errors) ==== const o22 = { async * get x() { ~ @@ -209,16 +209,17 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa return 1; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts (1 errors) ==== const o23 = { async * set x(value: number) { ~ !!! error TS1005: '(' expected. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts (1 errors) ==== const o24 = { async * x: 1; ~ !!! error TS1005: '(' expected. - }; \ No newline at end of file + }; + \ No newline at end of file diff --git a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.symbols b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.symbols similarity index 78% rename from tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.symbols rename to tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.symbols index df64b125c65..acc79db8e8e 100644 --- a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.symbols +++ b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.symbols @@ -1,4 +1,4 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts === const o1 = { >o1 : Symbol(o1, Decl(methodIsOk.ts, 0, 5)) @@ -6,7 +6,7 @@ const o1 = { >f : Symbol(f, Decl(methodIsOk.ts, 0, 12)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts === const o2 = { >o2 : Symbol(o2, Decl(awaitMethodNameIsOk.ts, 0, 5)) @@ -14,7 +14,7 @@ const o2 = { >await : Symbol(await, Decl(awaitMethodNameIsOk.ts, 0, 12)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts === const o3 = { >o3 : Symbol(o3, Decl(yieldMethodNameIsOk.ts, 0, 5)) @@ -22,7 +22,7 @@ const o3 = { >yield : Symbol(yield, Decl(yieldMethodNameIsOk.ts, 0, 12)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === const o4 = { >o4 : Symbol(o4, Decl(awaitParameterIsError.ts, 0, 5)) @@ -31,7 +31,7 @@ const o4 = { >await : Symbol(await, Decl(awaitParameterIsError.ts, 1, 14)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === const o5 = { >o5 : Symbol(o5, Decl(yieldParameterIsError.ts, 0, 5)) @@ -40,7 +40,7 @@ const o5 = { >yield : Symbol(yield, Decl(yieldParameterIsError.ts, 1, 14)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === const o6 = { >o6 : Symbol(o6, Decl(awaitInParameterInitializerIsError.ts, 0, 5)) @@ -49,7 +49,7 @@ const o6 = { >a : Symbol(a, Decl(awaitInParameterInitializerIsError.ts, 1, 14)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === const o7 = { >o7 : Symbol(o7, Decl(yieldInParameterInitializerIsError.ts, 0, 5)) @@ -58,7 +58,7 @@ const o7 = { >a : Symbol(a, Decl(yieldInParameterInitializerIsError.ts, 1, 14)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === const o8 = { >o8 : Symbol(o8, Decl(nestedAsyncGeneratorIsOk.ts, 0, 5)) @@ -70,7 +70,7 @@ const o8 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === const o9 = { >o9 : Symbol(o9, Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 5)) @@ -82,7 +82,7 @@ const o9 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === const o10 = { >o10 : Symbol(o10, Decl(nestedFunctionExpressionNamedYieldIsError.ts, 0, 5)) @@ -95,7 +95,7 @@ const o10 = { }; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === const o11 = { >o11 : Symbol(o11, Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 5)) @@ -107,7 +107,7 @@ const o11 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === const o12 = { >o12 : Symbol(o12, Decl(nestedFunctionExpressionNamedAwaitIsError.ts, 0, 5)) @@ -120,7 +120,7 @@ const o12 = { }; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === const o13 = { >o13 : Symbol(o13, Decl(yieldIsOk.ts, 0, 5)) @@ -130,7 +130,7 @@ const o13 = { yield; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === const o14 = { >o14 : Symbol(o14, Decl(yieldWithValueIsOk.ts, 0, 5)) @@ -140,7 +140,7 @@ const o14 = { yield 1; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === const o15 = { >o15 : Symbol(o15, Decl(yieldStarMissingValueIsError.ts, 0, 5)) @@ -150,7 +150,7 @@ const o15 = { yield *; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === const o16 = { >o16 : Symbol(o16, Decl(yieldStarWithValueIsOk.ts, 0, 5)) @@ -160,7 +160,7 @@ const o16 = { yield * []; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === const o17 = { >o17 : Symbol(o17, Decl(awaitWithValueIsOk.ts, 0, 5)) @@ -170,7 +170,7 @@ const o17 = { await 1; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === const o18 = { >o18 : Symbol(o18, Decl(awaitMissingValueIsError.ts, 0, 5)) @@ -180,7 +180,7 @@ const o18 = { await; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} >await : Symbol(await, Decl(awaitAsTypeIsOk.ts, 0, 0)) @@ -195,7 +195,7 @@ const o19 = { >await : Symbol(await, Decl(awaitAsTypeIsOk.ts, 0, 0)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} >yield : Symbol(yield, Decl(yieldAsTypeIsOk.ts, 0, 0)) @@ -210,7 +210,7 @@ const o20 = { >yield : Symbol(yield, Decl(yieldAsTypeIsOk.ts, 0, 0)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === const o21 = { >o21 : Symbol(o21, Decl(yieldInNestedComputedPropertyIsOk.ts, 0, 5)) @@ -222,7 +222,7 @@ const o21 = { >[yield] : Symbol([yield], Decl(yieldInNestedComputedPropertyIsOk.ts, 2, 19)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === const o22 = { >o22 : Symbol(o22, Decl(asyncGeneratorGetAccessorIsError.ts, 0, 5)) @@ -233,7 +233,7 @@ const o22 = { return 1; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === const o23 = { >o23 : Symbol(o23, Decl(asyncGeneratorSetAccessorIsError.ts, 0, 5)) @@ -243,7 +243,7 @@ const o23 = { >value : Symbol(value, Decl(asyncGeneratorSetAccessorIsError.ts, 1, 18)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts === const o24 = { >o24 : Symbol(o24, Decl(asyncGeneratorPropertyIsError.ts, 0, 5)) @@ -251,3 +251,4 @@ const o24 = { >x : Symbol(x, Decl(asyncGeneratorPropertyIsError.ts, 0, 13)) }; + diff --git a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.types b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types similarity index 79% rename from tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.types rename to tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types index 4cdaa6c1813..655ecb3e6a0 100644 --- a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.types +++ b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts === const o1 = { >o1 : { f(): AsyncIterableIterator; } >{ async * f() { }} : { f(): AsyncIterableIterator; } @@ -7,7 +7,7 @@ const o1 = { >f : () => AsyncIterableIterator } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts === const o2 = { >o2 : { await(): AsyncIterableIterator; } >{ async * await() { }} : { await(): AsyncIterableIterator; } @@ -16,7 +16,7 @@ const o2 = { >await : () => AsyncIterableIterator } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts === const o3 = { >o3 : { yield(): AsyncIterableIterator; } >{ async * yield() { }} : { yield(): AsyncIterableIterator; } @@ -25,7 +25,7 @@ const o3 = { >yield : () => AsyncIterableIterator } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === const o4 = { >o4 : { f(): any; await: any; } >{ async * f(await) : { f(): any; await: any; } @@ -35,7 +35,7 @@ const o4 = { >await : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === const o5 = { >o5 : { f(): any; yield: any; } >{ async * f(yield) : { f(): any; yield: any; } @@ -45,7 +45,7 @@ const o5 = { >yield : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === const o6 = { >o6 : { f(a?: number): AsyncIterableIterator; } >{ async * f(a = await 1) { }} : { f(a?: number): AsyncIterableIterator; } @@ -57,7 +57,7 @@ const o6 = { >1 : 1 } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === const o7 = { >o7 : { f(a?: any): AsyncIterableIterator; } >{ async * f(a = yield) { }} : { f(a?: any): AsyncIterableIterator; } @@ -68,7 +68,7 @@ const o7 = { >yield : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === const o8 = { >o8 : { f(): AsyncIterableIterator; } >{ async * f() { async function * g() { } }} : { f(): AsyncIterableIterator; } @@ -81,7 +81,7 @@ const o8 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === const o9 = { >o9 : { f(): AsyncIterableIterator<() => void>; } >{ async * f() { function yield() { } }} : { f(): AsyncIterableIterator<() => void>; } @@ -96,7 +96,7 @@ const o9 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === const o10 = { >o10 : { f(): AsyncIterableIterator<() => void>; } >{ async * f() { const x = function yield() { }; }} : { f(): AsyncIterableIterator<() => void>; } @@ -113,7 +113,7 @@ const o10 = { }; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === const o11 = { >o11 : { f(): AsyncIterableIterator; } >{ async * f() { function await() { } }} : { f(): AsyncIterableIterator; } @@ -129,7 +129,7 @@ const o11 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === const o12 = { >o12 : { f(): AsyncIterableIterator; } >{ async * f() { const x = function await() { }; }} : { f(): AsyncIterableIterator; } @@ -147,7 +147,7 @@ const o12 = { }; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === const o13 = { >o13 : { f(): AsyncIterableIterator; } >{ async * f() { yield; }} : { f(): AsyncIterableIterator; } @@ -159,7 +159,7 @@ const o13 = { >yield : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === const o14 = { >o14 : { f(): AsyncIterableIterator; } >{ async * f() { yield 1; }} : { f(): AsyncIterableIterator; } @@ -172,7 +172,7 @@ const o14 = { >1 : 1 } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === const o15 = { >o15 : { f(): AsyncIterableIterator; } >{ async * f() { yield *; }} : { f(): AsyncIterableIterator; } @@ -185,7 +185,7 @@ const o15 = { > : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === const o16 = { >o16 : { f(): AsyncIterableIterator; } >{ async * f() { yield * []; }} : { f(): AsyncIterableIterator; } @@ -198,7 +198,7 @@ const o16 = { >[] : undefined[] } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === const o17 = { >o17 : { f(): AsyncIterableIterator; } >{ async * f() { await 1; }} : { f(): AsyncIterableIterator; } @@ -211,7 +211,7 @@ const o17 = { >1 : 1 } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === const o18 = { >o18 : { f(): AsyncIterableIterator; } >{ async * f() { await; }} : { f(): AsyncIterableIterator; } @@ -224,7 +224,7 @@ const o18 = { > : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} const o19 = { >o19 : { f(): AsyncIterableIterator; } @@ -237,7 +237,7 @@ const o19 = { >x : await } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} const o20 = { >o20 : { f(): AsyncIterableIterator; } @@ -250,7 +250,7 @@ const o20 = { >x : yield } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === const o21 = { >o21 : { f(): AsyncIterableIterator; } >{ async * f() { const x = { [yield]: 1 }; }} : { f(): AsyncIterableIterator; } @@ -266,7 +266,7 @@ const o21 = { >1 : 1 } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === const o22 = { >o22 : { get(): any; x(): number; } >{ async * get x() { return 1; }} : { get(): any; x(): number; } @@ -279,7 +279,7 @@ const o22 = { >1 : 1 } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === const o23 = { >o23 : { set(): any; x(value: number): void; } >{ async * set x(value: number) { }} : { set(): any; x(value: number): void; } @@ -290,7 +290,7 @@ const o23 = { >value : number } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts === const o24 = { >o24 : { x(): 1; } >{ async * x: 1;} : { x(): 1; } @@ -299,3 +299,4 @@ const o24 = { >x : () => 1 }; + diff --git a/tests/baselines/reference/parser.forAwait.esnext.errors.txt b/tests/baselines/reference/parser.forAwait.es2018.errors.txt similarity index 68% rename from tests/baselines/reference/parser.forAwait.esnext.errors.txt rename to tests/baselines/reference/parser.forAwait.es2018.errors.txt index 44dfd947b56..e0e848db769 100644 --- a/tests/baselines/reference/parser.forAwait.esnext.errors.txt +++ b/tests/baselines/reference/parser.forAwait.es2018.errors.txt @@ -1,27 +1,27 @@ -tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithDeclIsError.ts(1,20): error TS1005: 'of' expected. -tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithDeclIsError.ts(1,23): error TS2304: Cannot find name 'y'. -tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts(1,12): error TS2304: Cannot find name 'x'. -tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts(1,14): error TS1005: 'of' expected. -tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts(1,17): error TS2304: Cannot find name 'y'. -tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithDeclIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithExprIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithDeclIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithExprIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithDeclIsError.ts(1,5): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithDeclIsError.ts(1,23): error TS2304: Cannot find name 'y'. -tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts(1,5): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts(1,12): error TS2304: Cannot find name 'x'. -tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts(1,17): error TS2304: Cannot find name 'y'. +tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithDeclIsError.ts(1,20): error TS1005: 'of' expected. +tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithDeclIsError.ts(1,23): error TS2304: Cannot find name 'y'. +tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts(1,12): error TS2304: Cannot find name 'x'. +tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts(1,14): error TS1005: 'of' expected. +tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts(1,17): error TS2304: Cannot find name 'y'. +tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithDeclIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithExprIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithDeclIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithExprIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithDeclIsError.ts(1,5): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithDeclIsError.ts(1,23): error TS2304: Cannot find name 'y'. +tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts(1,5): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts(1,12): error TS2304: Cannot find name 'x'. +tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts(1,17): error TS2304: Cannot find name 'y'. -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithDeclIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithDeclIsError.ts (2 errors) ==== for await (const x of y) { ~~~~~ !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. ~ !!! error TS2304: Cannot find name 'y'. } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts (3 errors) ==== for await (x of y) { ~~~~~ !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. @@ -30,14 +30,14 @@ tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.t ~ !!! error TS2304: Cannot find name 'y'. } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithDeclIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithDeclIsError.ts (2 errors) ==== for await (const x in y) { ~~ !!! error TS1005: 'of' expected. ~ !!! error TS2304: Cannot find name 'y'. } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts (3 errors) ==== for await (x in y) { ~ !!! error TS2304: Cannot find name 'x'. @@ -46,7 +46,7 @@ tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.t ~ !!! error TS2304: Cannot find name 'y'. } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithDeclIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithDeclIsError.ts (1 errors) ==== function f5() { let y: any; for await (const x of y) { @@ -54,7 +54,7 @@ tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.t !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithExprIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithExprIsError.ts (1 errors) ==== function f6() { let x: any, y: any; for await (x of y) { @@ -62,31 +62,31 @@ tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.t !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithDeclIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithDeclIsOk.ts (0 errors) ==== async function f7() { let y: any; for await (const x of y) { } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithExprIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithExprIsOk.ts (0 errors) ==== async function f8() { let x: any, y: any; for await (x of y) { } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithDeclIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithDeclIsOk.ts (0 errors) ==== async function* f9() { let y: any; for await (const x of y) { } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithExpressionIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithExpressionIsOk.ts (0 errors) ==== async function* f10() { let x: any, y: any; for await (x of y) { } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithDeclIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithDeclIsError.ts (1 errors) ==== function* f11() { let y: any; for await (const x of y) { @@ -94,11 +94,12 @@ tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.t !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithExprIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithExprIsError.ts (1 errors) ==== function* f12() { let x: any, y: any; for await (x of y) { ~~~~~ !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. } - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/parser.forAwait.esnext.symbols b/tests/baselines/reference/parser.forAwait.es2018.symbols similarity index 80% rename from tests/baselines/reference/parser.forAwait.esnext.symbols rename to tests/baselines/reference/parser.forAwait.es2018.symbols index 226445cb79a..c859ebda943 100644 --- a/tests/baselines/reference/parser.forAwait.esnext.symbols +++ b/tests/baselines/reference/parser.forAwait.es2018.symbols @@ -1,18 +1,18 @@ -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithDeclIsError.ts === for await (const x of y) { >x : Symbol(x, Decl(topLevelWithDeclIsError.ts, 0, 16)) } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts === for await (x of y) { No type information for this code.} -No type information for this code.=== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithDeclIsError.ts === +No type information for this code.=== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithDeclIsError.ts === for await (const x in y) { >x : Symbol(x, Decl(forAwaitInWithDeclIsError.ts, 0, 16)) } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts === for await (x in y) { No type information for this code.} -No type information for this code.=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithDeclIsError.ts === +No type information for this code.=== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithDeclIsError.ts === function f5() { >f5 : Symbol(f5, Decl(inFunctionDeclWithDeclIsError.ts, 0, 0)) @@ -24,7 +24,7 @@ function f5() { >y : Symbol(y, Decl(inFunctionDeclWithDeclIsError.ts, 1, 7)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithExprIsError.ts === function f6() { >f6 : Symbol(f6, Decl(inFunctionDeclWithExprIsError.ts, 0, 0)) @@ -37,7 +37,7 @@ function f6() { >y : Symbol(y, Decl(inFunctionDeclWithExprIsError.ts, 1, 15)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithDeclIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithDeclIsOk.ts === async function f7() { >f7 : Symbol(f7, Decl(inAsyncFunctionWithDeclIsOk.ts, 0, 0)) @@ -49,7 +49,7 @@ async function f7() { >y : Symbol(y, Decl(inAsyncFunctionWithDeclIsOk.ts, 1, 7)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithExprIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithExprIsOk.ts === async function f8() { >f8 : Symbol(f8, Decl(inAsyncFunctionWithExprIsOk.ts, 0, 0)) @@ -62,7 +62,7 @@ async function f8() { >y : Symbol(y, Decl(inAsyncFunctionWithExprIsOk.ts, 1, 15)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithDeclIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithDeclIsOk.ts === async function* f9() { >f9 : Symbol(f9, Decl(inAsyncGeneratorWithDeclIsOk.ts, 0, 0)) @@ -74,7 +74,7 @@ async function* f9() { >y : Symbol(y, Decl(inAsyncGeneratorWithDeclIsOk.ts, 1, 7)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithExpressionIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithExpressionIsOk.ts === async function* f10() { >f10 : Symbol(f10, Decl(inAsyncGeneratorWithExpressionIsOk.ts, 0, 0)) @@ -87,7 +87,7 @@ async function* f10() { >y : Symbol(y, Decl(inAsyncGeneratorWithExpressionIsOk.ts, 1, 15)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithDeclIsError.ts === function* f11() { >f11 : Symbol(f11, Decl(inGeneratorWithDeclIsError.ts, 0, 0)) @@ -99,7 +99,7 @@ function* f11() { >y : Symbol(y, Decl(inGeneratorWithDeclIsError.ts, 1, 7)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithExprIsError.ts === function* f12() { >f12 : Symbol(f12, Decl(inGeneratorWithExprIsError.ts, 0, 0)) @@ -112,3 +112,4 @@ function* f12() { >y : Symbol(y, Decl(inGeneratorWithExprIsError.ts, 1, 15)) } } + diff --git a/tests/baselines/reference/parser.forAwait.esnext.types b/tests/baselines/reference/parser.forAwait.es2018.types similarity index 64% rename from tests/baselines/reference/parser.forAwait.esnext.types rename to tests/baselines/reference/parser.forAwait.es2018.types index 28408aa3c14..672d063883d 100644 --- a/tests/baselines/reference/parser.forAwait.esnext.types +++ b/tests/baselines/reference/parser.forAwait.es2018.types @@ -1,24 +1,24 @@ -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithDeclIsError.ts === for await (const x of y) { >x : any >y : any } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts === for await (x of y) { >x : any >y : any } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithDeclIsError.ts === for await (const x in y) { >x : string >y : any } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts === for await (x in y) { >x : any >y : any } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithDeclIsError.ts === function f5() { >f5 : () => void @@ -30,7 +30,7 @@ function f5() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithExprIsError.ts === function f6() { >f6 : () => void @@ -43,7 +43,7 @@ function f6() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithDeclIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithDeclIsOk.ts === async function f7() { >f7 : () => Promise @@ -55,7 +55,7 @@ async function f7() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithExprIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithExprIsOk.ts === async function f8() { >f8 : () => Promise @@ -68,7 +68,7 @@ async function f8() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithDeclIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithDeclIsOk.ts === async function* f9() { >f9 : () => AsyncIterableIterator @@ -80,7 +80,7 @@ async function* f9() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithExpressionIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithExpressionIsOk.ts === async function* f10() { >f10 : () => AsyncIterableIterator @@ -93,7 +93,7 @@ async function* f10() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithDeclIsError.ts === function* f11() { >f11 : () => IterableIterator @@ -105,7 +105,7 @@ function* f11() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithExprIsError.ts === function* f12() { >f12 : () => IterableIterator @@ -118,3 +118,4 @@ function* f12() { >y : any } } + diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.1.symbols b/tests/baselines/reference/types.asyncGenerators.es2018.1.symbols similarity index 90% rename from tests/baselines/reference/types.asyncGenerators.esnext.1.symbols rename to tests/baselines/reference/types.asyncGenerators.es2018.1.symbols index 2b98a589b0e..27b21d4810f 100644 --- a/tests/baselines/reference/types.asyncGenerators.esnext.1.symbols +++ b/tests/baselines/reference/types.asyncGenerators.es2018.1.symbols @@ -1,19 +1,19 @@ -=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts === +=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts === async function * inferReturnType1() { ->inferReturnType1 : Symbol(inferReturnType1, Decl(types.asyncGenerators.esnext.1.ts, 0, 0)) +>inferReturnType1 : Symbol(inferReturnType1, Decl(types.asyncGenerators.es2018.1.ts, 0, 0)) } async function * inferReturnType2() { ->inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.esnext.1.ts, 1, 1)) +>inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.es2018.1.ts, 1, 1)) yield; } async function * inferReturnType3() { ->inferReturnType3 : Symbol(inferReturnType3, Decl(types.asyncGenerators.esnext.1.ts, 4, 1)) +>inferReturnType3 : Symbol(inferReturnType3, Decl(types.asyncGenerators.es2018.1.ts, 4, 1)) yield 1; } async function * inferReturnType4() { ->inferReturnType4 : Symbol(inferReturnType4, Decl(types.asyncGenerators.esnext.1.ts, 7, 1)) +>inferReturnType4 : Symbol(inferReturnType4, Decl(types.asyncGenerators.es2018.1.ts, 7, 1)) yield Promise.resolve(1); >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) @@ -21,7 +21,7 @@ async function * inferReturnType4() { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * inferReturnType5() { ->inferReturnType5 : Symbol(inferReturnType5, Decl(types.asyncGenerators.esnext.1.ts, 10, 1)) +>inferReturnType5 : Symbol(inferReturnType5, Decl(types.asyncGenerators.es2018.1.ts, 10, 1)) yield 1; yield Promise.resolve(2); @@ -30,12 +30,12 @@ async function * inferReturnType5() { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * inferReturnType6() { ->inferReturnType6 : Symbol(inferReturnType6, Decl(types.asyncGenerators.esnext.1.ts, 14, 1)) +>inferReturnType6 : Symbol(inferReturnType6, Decl(types.asyncGenerators.es2018.1.ts, 14, 1)) yield* [1, 2]; } async function * inferReturnType7() { ->inferReturnType7 : Symbol(inferReturnType7, Decl(types.asyncGenerators.esnext.1.ts, 17, 1)) +>inferReturnType7 : Symbol(inferReturnType7, Decl(types.asyncGenerators.es2018.1.ts, 17, 1)) yield* [Promise.resolve(1)]; >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) @@ -43,18 +43,18 @@ async function * inferReturnType7() { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * inferReturnType8() { ->inferReturnType8 : Symbol(inferReturnType8, Decl(types.asyncGenerators.esnext.1.ts, 20, 1)) +>inferReturnType8 : Symbol(inferReturnType8, Decl(types.asyncGenerators.es2018.1.ts, 20, 1)) yield* (async function * () { yield 1; })(); } const assignability1: () => AsyncIterableIterator = async function * () { ->assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.esnext.1.ts, 24, 5)) +>assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.es2018.1.ts, 24, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; }; const assignability2: () => AsyncIterableIterator = async function * () { ->assignability2 : Symbol(assignability2, Decl(types.asyncGenerators.esnext.1.ts, 27, 5)) +>assignability2 : Symbol(assignability2, Decl(types.asyncGenerators.es2018.1.ts, 27, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -64,13 +64,13 @@ const assignability2: () => AsyncIterableIterator = async function * () }; const assignability3: () => AsyncIterableIterator = async function * () { ->assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.esnext.1.ts, 30, 5)) +>assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.es2018.1.ts, 30, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; }; const assignability4: () => AsyncIterableIterator = async function * () { ->assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.esnext.1.ts, 33, 5)) +>assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.es2018.1.ts, 33, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -80,19 +80,19 @@ const assignability4: () => AsyncIterableIterator = async function * () }; const assignability5: () => AsyncIterableIterator = async function * () { ->assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.esnext.1.ts, 36, 5)) +>assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.es2018.1.ts, 36, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); }; const assignability6: () => AsyncIterable = async function * () { ->assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.esnext.1.ts, 39, 5)) +>assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.es2018.1.ts, 39, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; }; const assignability7: () => AsyncIterable = async function * () { ->assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.esnext.1.ts, 42, 5)) +>assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.es2018.1.ts, 42, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -102,13 +102,13 @@ const assignability7: () => AsyncIterable = async function * () { }; const assignability8: () => AsyncIterable = async function * () { ->assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.esnext.1.ts, 45, 5)) +>assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.es2018.1.ts, 45, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; }; const assignability9: () => AsyncIterable = async function * () { ->assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.esnext.1.ts, 48, 5)) +>assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.es2018.1.ts, 48, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -118,19 +118,19 @@ const assignability9: () => AsyncIterable = async function * () { }; const assignability10: () => AsyncIterable = async function * () { ->assignability10 : Symbol(assignability10, Decl(types.asyncGenerators.esnext.1.ts, 51, 5)) +>assignability10 : Symbol(assignability10, Decl(types.asyncGenerators.es2018.1.ts, 51, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); }; const assignability11: () => AsyncIterator = async function * () { ->assignability11 : Symbol(assignability11, Decl(types.asyncGenerators.esnext.1.ts, 54, 5)) +>assignability11 : Symbol(assignability11, Decl(types.asyncGenerators.es2018.1.ts, 54, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; }; const assignability12: () => AsyncIterator = async function * () { ->assignability12 : Symbol(assignability12, Decl(types.asyncGenerators.esnext.1.ts, 57, 5)) +>assignability12 : Symbol(assignability12, Decl(types.asyncGenerators.es2018.1.ts, 57, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -140,13 +140,13 @@ const assignability12: () => AsyncIterator = async function * () { }; const assignability13: () => AsyncIterator = async function * () { ->assignability13 : Symbol(assignability13, Decl(types.asyncGenerators.esnext.1.ts, 60, 5)) +>assignability13 : Symbol(assignability13, Decl(types.asyncGenerators.es2018.1.ts, 60, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; }; const assignability14: () => AsyncIterator = async function * () { ->assignability14 : Symbol(assignability14, Decl(types.asyncGenerators.esnext.1.ts, 63, 5)) +>assignability14 : Symbol(assignability14, Decl(types.asyncGenerators.es2018.1.ts, 63, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -156,19 +156,19 @@ const assignability14: () => AsyncIterator = async function * () { }; const assignability15: () => AsyncIterator = async function * () { ->assignability15 : Symbol(assignability15, Decl(types.asyncGenerators.esnext.1.ts, 66, 5)) +>assignability15 : Symbol(assignability15, Decl(types.asyncGenerators.es2018.1.ts, 66, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); }; async function * explicitReturnType1(): AsyncIterableIterator { ->explicitReturnType1 : Symbol(explicitReturnType1, Decl(types.asyncGenerators.esnext.1.ts, 68, 2)) +>explicitReturnType1 : Symbol(explicitReturnType1, Decl(types.asyncGenerators.es2018.1.ts, 68, 2)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; } async function * explicitReturnType2(): AsyncIterableIterator { ->explicitReturnType2 : Symbol(explicitReturnType2, Decl(types.asyncGenerators.esnext.1.ts, 71, 1)) +>explicitReturnType2 : Symbol(explicitReturnType2, Decl(types.asyncGenerators.es2018.1.ts, 71, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -177,13 +177,13 @@ async function * explicitReturnType2(): AsyncIterableIterator { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType3(): AsyncIterableIterator { ->explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.esnext.1.ts, 74, 1)) +>explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.es2018.1.ts, 74, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; } async function * explicitReturnType4(): AsyncIterableIterator { ->explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.esnext.1.ts, 77, 1)) +>explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.es2018.1.ts, 77, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -192,19 +192,19 @@ async function * explicitReturnType4(): AsyncIterableIterator { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType5(): AsyncIterableIterator { ->explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.esnext.1.ts, 80, 1)) +>explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.es2018.1.ts, 80, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); } async function * explicitReturnType6(): AsyncIterable { ->explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.esnext.1.ts, 83, 1)) +>explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.es2018.1.ts, 83, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; } async function * explicitReturnType7(): AsyncIterable { ->explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.esnext.1.ts, 86, 1)) +>explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.es2018.1.ts, 86, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -213,13 +213,13 @@ async function * explicitReturnType7(): AsyncIterable { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType8(): AsyncIterable { ->explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.esnext.1.ts, 89, 1)) +>explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.es2018.1.ts, 89, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; } async function * explicitReturnType9(): AsyncIterable { ->explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.esnext.1.ts, 92, 1)) +>explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.es2018.1.ts, 92, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -228,19 +228,19 @@ async function * explicitReturnType9(): AsyncIterable { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType10(): AsyncIterable { ->explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.esnext.1.ts, 95, 1)) +>explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.es2018.1.ts, 95, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); } async function * explicitReturnType11(): AsyncIterator { ->explicitReturnType11 : Symbol(explicitReturnType11, Decl(types.asyncGenerators.esnext.1.ts, 98, 1)) +>explicitReturnType11 : Symbol(explicitReturnType11, Decl(types.asyncGenerators.es2018.1.ts, 98, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; } async function * explicitReturnType12(): AsyncIterator { ->explicitReturnType12 : Symbol(explicitReturnType12, Decl(types.asyncGenerators.esnext.1.ts, 101, 1)) +>explicitReturnType12 : Symbol(explicitReturnType12, Decl(types.asyncGenerators.es2018.1.ts, 101, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -249,13 +249,13 @@ async function * explicitReturnType12(): AsyncIterator { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType13(): AsyncIterator { ->explicitReturnType13 : Symbol(explicitReturnType13, Decl(types.asyncGenerators.esnext.1.ts, 104, 1)) +>explicitReturnType13 : Symbol(explicitReturnType13, Decl(types.asyncGenerators.es2018.1.ts, 104, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; } async function * explicitReturnType14(): AsyncIterator { ->explicitReturnType14 : Symbol(explicitReturnType14, Decl(types.asyncGenerators.esnext.1.ts, 107, 1)) +>explicitReturnType14 : Symbol(explicitReturnType14, Decl(types.asyncGenerators.es2018.1.ts, 107, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -264,28 +264,29 @@ async function * explicitReturnType14(): AsyncIterator { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType15(): AsyncIterator { ->explicitReturnType15 : Symbol(explicitReturnType15, Decl(types.asyncGenerators.esnext.1.ts, 110, 1)) +>explicitReturnType15 : Symbol(explicitReturnType15, Decl(types.asyncGenerators.es2018.1.ts, 110, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); } async function * explicitReturnType16(): {} { ->explicitReturnType16 : Symbol(explicitReturnType16, Decl(types.asyncGenerators.esnext.1.ts, 113, 1)) +>explicitReturnType16 : Symbol(explicitReturnType16, Decl(types.asyncGenerators.es2018.1.ts, 113, 1)) yield 1; } async function * awaitedType1() { ->awaitedType1 : Symbol(awaitedType1, Decl(types.asyncGenerators.esnext.1.ts, 116, 1)) +>awaitedType1 : Symbol(awaitedType1, Decl(types.asyncGenerators.es2018.1.ts, 116, 1)) const x = await 1; ->x : Symbol(x, Decl(types.asyncGenerators.esnext.1.ts, 118, 9)) +>x : Symbol(x, Decl(types.asyncGenerators.es2018.1.ts, 118, 9)) } async function * awaitedType2() { ->awaitedType2 : Symbol(awaitedType2, Decl(types.asyncGenerators.esnext.1.ts, 119, 1)) +>awaitedType2 : Symbol(awaitedType2, Decl(types.asyncGenerators.es2018.1.ts, 119, 1)) const x = await Promise.resolve(1); ->x : Symbol(x, Decl(types.asyncGenerators.esnext.1.ts, 121, 9)) +>x : Symbol(x, Decl(types.asyncGenerators.es2018.1.ts, 121, 9)) >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } + diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.1.types b/tests/baselines/reference/types.asyncGenerators.es2018.1.types similarity index 96% rename from tests/baselines/reference/types.asyncGenerators.esnext.1.types rename to tests/baselines/reference/types.asyncGenerators.es2018.1.types index c509e12b2fe..0f3b7753313 100644 --- a/tests/baselines/reference/types.asyncGenerators.esnext.1.types +++ b/tests/baselines/reference/types.asyncGenerators.es2018.1.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts === +=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts === async function * inferReturnType1() { >inferReturnType1 : () => AsyncIterableIterator } @@ -430,3 +430,4 @@ async function * awaitedType2() { >resolve : { (value: T | PromiseLike): Promise; (): Promise; } >1 : 1 } + diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.2.errors.txt b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt similarity index 88% rename from tests/baselines/reference/types.asyncGenerators.esnext.2.errors.txt rename to tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt index 5e9124d9433..471cf39bed2 100644 --- a/tests/baselines/reference/types.asyncGenerators.esnext.2.errors.txt +++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt @@ -1,13 +1,13 @@ -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(2,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(8,12): error TS2504: Type 'Promise' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(10,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(2,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(8,12): error TS2504: Type 'Promise' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(10,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterableIterator'. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(13,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(13,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterableIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(16,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(16,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterableIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(19,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(19,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterable'. Types of property '[Symbol.asyncIterator]' are incompatible. Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. @@ -17,35 +17,35 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts( Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(22,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(22,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterable'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(25,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(25,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterable'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(28,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(28,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(31,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(31,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(34,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(34,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(38,11): error TS2322: Type '"a"' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(41,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(44,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(47,11): error TS2322: Type '"a"' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(50,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(53,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(56,11): error TS2322: Type '"a"' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(59,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(62,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(64,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator' but required in type 'IterableIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(67,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator' but required in type 'Iterable'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(70,42): error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'Iterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(38,11): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(41,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(44,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(47,11): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(50,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(53,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(56,11): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(59,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(62,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(64,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator' but required in type 'IterableIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(67,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator' but required in type 'Iterable'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(70,42): error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'Iterator'. Types of property 'next' are incompatible. Type '(value?: any) => Promise>' is not assignable to type '(value?: any) => IteratorResult'. Type 'Promise>' is missing the following properties from type 'IteratorResult': done, value -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(74,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -==== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts (24 errors) ==== +==== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts (24 errors) ==== async function * inferReturnType1() { yield* {}; ~~ @@ -191,4 +191,5 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts( yield* {}; ~~ !!! error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.2.symbols b/tests/baselines/reference/types.asyncGenerators.es2018.2.symbols similarity index 86% rename from tests/baselines/reference/types.asyncGenerators.esnext.2.symbols rename to tests/baselines/reference/types.asyncGenerators.es2018.2.symbols index 2305609b9de..704aefcb42c 100644 --- a/tests/baselines/reference/types.asyncGenerators.esnext.2.symbols +++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.symbols @@ -1,17 +1,17 @@ -=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts === +=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts === async function * inferReturnType1() { ->inferReturnType1 : Symbol(inferReturnType1, Decl(types.asyncGenerators.esnext.2.ts, 0, 0)) +>inferReturnType1 : Symbol(inferReturnType1, Decl(types.asyncGenerators.es2018.2.ts, 0, 0)) yield* {}; } async function * inferReturnType2() { ->inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.esnext.2.ts, 2, 1)) +>inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.es2018.2.ts, 2, 1)) yield* inferReturnType2(); ->inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.esnext.2.ts, 2, 1)) +>inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.es2018.2.ts, 2, 1)) } async function * inferReturnType3() { ->inferReturnType3 : Symbol(inferReturnType3, Decl(types.asyncGenerators.esnext.2.ts, 5, 1)) +>inferReturnType3 : Symbol(inferReturnType3, Decl(types.asyncGenerators.es2018.2.ts, 5, 1)) yield* Promise.resolve([1, 2]); >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) @@ -19,133 +19,134 @@ async function * inferReturnType3() { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } const assignability1: () => AsyncIterableIterator = async function * () { ->assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.esnext.2.ts, 9, 5)) +>assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.es2018.2.ts, 9, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; }; const assignability2: () => AsyncIterableIterator = async function * () { ->assignability2 : Symbol(assignability2, Decl(types.asyncGenerators.esnext.2.ts, 12, 5)) +>assignability2 : Symbol(assignability2, Decl(types.asyncGenerators.es2018.2.ts, 12, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; }; const assignability3: () => AsyncIterableIterator = async function * () { ->assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.esnext.2.ts, 15, 5)) +>assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.es2018.2.ts, 15, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); }; const assignability4: () => AsyncIterable = async function * () { ->assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.esnext.2.ts, 18, 5)) +>assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.es2018.2.ts, 18, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; }; const assignability5: () => AsyncIterable = async function * () { ->assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.esnext.2.ts, 21, 5)) +>assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.es2018.2.ts, 21, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; }; const assignability6: () => AsyncIterable = async function * () { ->assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.esnext.2.ts, 24, 5)) +>assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.es2018.2.ts, 24, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); }; const assignability7: () => AsyncIterator = async function * () { ->assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.esnext.2.ts, 27, 5)) +>assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.es2018.2.ts, 27, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; }; const assignability8: () => AsyncIterator = async function * () { ->assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.esnext.2.ts, 30, 5)) +>assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.es2018.2.ts, 30, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; }; const assignability9: () => AsyncIterator = async function * () { ->assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.esnext.2.ts, 33, 5)) +>assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.es2018.2.ts, 33, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); }; async function * explicitReturnType1(): AsyncIterableIterator { ->explicitReturnType1 : Symbol(explicitReturnType1, Decl(types.asyncGenerators.esnext.2.ts, 35, 2)) +>explicitReturnType1 : Symbol(explicitReturnType1, Decl(types.asyncGenerators.es2018.2.ts, 35, 2)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; } async function * explicitReturnType2(): AsyncIterableIterator { ->explicitReturnType2 : Symbol(explicitReturnType2, Decl(types.asyncGenerators.esnext.2.ts, 38, 1)) +>explicitReturnType2 : Symbol(explicitReturnType2, Decl(types.asyncGenerators.es2018.2.ts, 38, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; } async function * explicitReturnType3(): AsyncIterableIterator { ->explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.esnext.2.ts, 41, 1)) +>explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.es2018.2.ts, 41, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); } async function * explicitReturnType4(): AsyncIterable { ->explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.esnext.2.ts, 44, 1)) +>explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.es2018.2.ts, 44, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; } async function * explicitReturnType5(): AsyncIterable { ->explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.esnext.2.ts, 47, 1)) +>explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.es2018.2.ts, 47, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; } async function * explicitReturnType6(): AsyncIterable { ->explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.esnext.2.ts, 50, 1)) +>explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.es2018.2.ts, 50, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); } async function * explicitReturnType7(): AsyncIterator { ->explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.esnext.2.ts, 53, 1)) +>explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.es2018.2.ts, 53, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; } async function * explicitReturnType8(): AsyncIterator { ->explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.esnext.2.ts, 56, 1)) +>explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.es2018.2.ts, 56, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; } async function * explicitReturnType9(): AsyncIterator { ->explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.esnext.2.ts, 59, 1)) +>explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.es2018.2.ts, 59, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); } async function * explicitReturnType10(): IterableIterator { ->explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.esnext.2.ts, 62, 1)) +>explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.es2018.2.ts, 62, 1)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) yield 1; } async function * explicitReturnType11(): Iterable { ->explicitReturnType11 : Symbol(explicitReturnType11, Decl(types.asyncGenerators.esnext.2.ts, 65, 1)) +>explicitReturnType11 : Symbol(explicitReturnType11, Decl(types.asyncGenerators.es2018.2.ts, 65, 1)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) yield 1; } async function * explicitReturnType12(): Iterator { ->explicitReturnType12 : Symbol(explicitReturnType12, Decl(types.asyncGenerators.esnext.2.ts, 68, 1)) +>explicitReturnType12 : Symbol(explicitReturnType12, Decl(types.asyncGenerators.es2018.2.ts, 68, 1)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --)) yield 1; } async function * yieldStar() { ->yieldStar : Symbol(yieldStar, Decl(types.asyncGenerators.esnext.2.ts, 71, 1)) +>yieldStar : Symbol(yieldStar, Decl(types.asyncGenerators.es2018.2.ts, 71, 1)) yield* {}; } + diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.2.types b/tests/baselines/reference/types.asyncGenerators.es2018.2.types similarity index 96% rename from tests/baselines/reference/types.asyncGenerators.esnext.2.types rename to tests/baselines/reference/types.asyncGenerators.es2018.2.types index 35474631c0a..6bcc95297a9 100644 --- a/tests/baselines/reference/types.asyncGenerators.esnext.2.types +++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts === +=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts === async function * inferReturnType1() { >inferReturnType1 : () => AsyncIterableIterator @@ -235,3 +235,4 @@ async function * yieldStar() { >yield* {} : any >{} : {} } + diff --git a/tests/baselines/reference/types.forAwait.es2018.1.symbols b/tests/baselines/reference/types.forAwait.es2018.1.symbols new file mode 100644 index 00000000000..a84297ae62a --- /dev/null +++ b/tests/baselines/reference/types.forAwait.es2018.1.symbols @@ -0,0 +1,77 @@ +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts === +declare const asyncIterable: AsyncIterable; +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13)) +>AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) + +declare const iterable: Iterable; +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const iterableOfPromise: Iterable>; +>iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.es2018.1.ts, 2, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) + +async function f1() { +>f1 : Symbol(f1, Decl(types.forAwait.es2018.1.ts, 2, 59)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 4, 7)) + + for await (const x of asyncIterable) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 5, 20)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13)) + } + for await (const x of iterable) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 7, 20)) +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13)) + } + for await (const x of iterableOfPromise) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 9, 20)) +>iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.es2018.1.ts, 2, 13)) + } + for await (y of asyncIterable) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 4, 7)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13)) + } + for await (y of iterable) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 4, 7)) +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13)) + } + for await (y of iterableOfPromise) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 4, 7)) +>iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.es2018.1.ts, 2, 13)) + } +} +async function * f2() { +>f2 : Symbol(f2, Decl(types.forAwait.es2018.1.ts, 17, 1)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 19, 7)) + + for await (const x of asyncIterable) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 20, 20)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13)) + } + for await (const x of iterable) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 22, 20)) +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13)) + } + for await (const x of iterableOfPromise) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 24, 20)) +>iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.es2018.1.ts, 2, 13)) + } + for await (y of asyncIterable) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 19, 7)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13)) + } + for await (y of iterable) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 19, 7)) +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13)) + } + for await (y of iterableOfPromise) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 19, 7)) +>iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.es2018.1.ts, 2, 13)) + } +} + diff --git a/tests/baselines/reference/types.forAwait.esnext.1.types b/tests/baselines/reference/types.forAwait.es2018.1.types similarity index 92% rename from tests/baselines/reference/types.forAwait.esnext.1.types rename to tests/baselines/reference/types.forAwait.es2018.1.types index 69403b40593..aa1035b87cb 100644 --- a/tests/baselines/reference/types.forAwait.esnext.1.types +++ b/tests/baselines/reference/types.forAwait.es2018.1.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts === +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts === declare const asyncIterable: AsyncIterable; >asyncIterable : AsyncIterable @@ -70,3 +70,4 @@ async function * f2() { >iterableOfPromise : Iterable> } } + diff --git a/tests/baselines/reference/types.forAwait.esnext.2.errors.txt b/tests/baselines/reference/types.forAwait.es2018.2.errors.txt similarity index 77% rename from tests/baselines/reference/types.forAwait.esnext.2.errors.txt rename to tests/baselines/reference/types.forAwait.es2018.2.errors.txt index 530743d9825..cc24920d85d 100644 --- a/tests/baselines/reference/types.forAwait.esnext.2.errors.txt +++ b/tests/baselines/reference/types.forAwait.es2018.2.errors.txt @@ -1,12 +1,12 @@ -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(6,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(8,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(10,16): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(12,16): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(14,21): error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(16,15): error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(6,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(8,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(10,16): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(12,16): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(14,21): error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(16,15): error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. -==== tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts (6 errors) ==== +==== tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts (6 errors) ==== declare const asyncIterable: AsyncIterable; declare const iterable: Iterable; async function f() { @@ -36,4 +36,5 @@ tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(16,15): error ~~~~~~~~~~~~~ !!! error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. } - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/types.forAwait.es2018.2.symbols b/tests/baselines/reference/types.forAwait.es2018.2.symbols new file mode 100644 index 00000000000..2fb30f55ca8 --- /dev/null +++ b/tests/baselines/reference/types.forAwait.es2018.2.symbols @@ -0,0 +1,42 @@ +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts === +declare const asyncIterable: AsyncIterable; +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.2.ts, 0, 13)) +>AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) + +declare const iterable: Iterable; +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.2.ts, 1, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +async function f() { +>f : Symbol(f, Decl(types.forAwait.es2018.2.ts, 1, 41)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.es2018.2.ts, 3, 7)) + + let z: string; +>z : Symbol(z, Decl(types.forAwait.es2018.2.ts, 4, 7)) + + for await (const x of {}) { +>x : Symbol(x, Decl(types.forAwait.es2018.2.ts, 5, 20)) + } + for await (y of {}) { +>y : Symbol(y, Decl(types.forAwait.es2018.2.ts, 3, 7)) + } + for await (z of asyncIterable) { +>z : Symbol(z, Decl(types.forAwait.es2018.2.ts, 4, 7)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.2.ts, 0, 13)) + } + for await (z of iterable) { +>z : Symbol(z, Decl(types.forAwait.es2018.2.ts, 4, 7)) +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.2.ts, 1, 13)) + } + for (const x of asyncIterable) { +>x : Symbol(x, Decl(types.forAwait.es2018.2.ts, 13, 14)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.2.ts, 0, 13)) + } + for (y of asyncIterable) { +>y : Symbol(y, Decl(types.forAwait.es2018.2.ts, 3, 7)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.2.ts, 0, 13)) + } +} + diff --git a/tests/baselines/reference/types.forAwait.esnext.2.types b/tests/baselines/reference/types.forAwait.es2018.2.types similarity index 87% rename from tests/baselines/reference/types.forAwait.esnext.2.types rename to tests/baselines/reference/types.forAwait.es2018.2.types index 0c2dc0cd695..e4db7426bc0 100644 --- a/tests/baselines/reference/types.forAwait.esnext.2.types +++ b/tests/baselines/reference/types.forAwait.es2018.2.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts === +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts === declare const asyncIterable: AsyncIterable; >asyncIterable : AsyncIterable @@ -39,3 +39,4 @@ async function f() { >asyncIterable : AsyncIterable } } + diff --git a/tests/baselines/reference/types.forAwait.esnext.3.errors.txt b/tests/baselines/reference/types.forAwait.es2018.3.errors.txt similarity index 78% rename from tests/baselines/reference/types.forAwait.esnext.3.errors.txt rename to tests/baselines/reference/types.forAwait.es2018.3.errors.txt index baf8c76b24a..296ac0d066b 100644 --- a/tests/baselines/reference/types.forAwait.esnext.3.errors.txt +++ b/tests/baselines/reference/types.forAwait.es2018.3.errors.txt @@ -1,12 +1,12 @@ error TS2318: Cannot find global type 'AsyncIterableIterator'. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts(3,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts(5,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts(10,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts(12,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(3,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(5,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(10,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(12,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. !!! error TS2318: Cannot find global type 'AsyncIterableIterator'. -==== tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts (4 errors) ==== +==== tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts (4 errors) ==== async function f1() { let y: number; for await (const x of {}) { @@ -28,4 +28,5 @@ tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts(12,21): error ~~ !!! error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. } - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/types.forAwait.es2018.3.symbols b/tests/baselines/reference/types.forAwait.es2018.3.symbols new file mode 100644 index 00000000000..b40783f9b78 --- /dev/null +++ b/tests/baselines/reference/types.forAwait.es2018.3.symbols @@ -0,0 +1,28 @@ +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts === +async function f1() { +>f1 : Symbol(f1, Decl(types.forAwait.es2018.3.ts, 0, 0)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.es2018.3.ts, 1, 7)) + + for await (const x of {}) { +>x : Symbol(x, Decl(types.forAwait.es2018.3.ts, 2, 20)) + } + for await (y of {}) { +>y : Symbol(y, Decl(types.forAwait.es2018.3.ts, 1, 7)) + } +} +async function* f2() { +>f2 : Symbol(f2, Decl(types.forAwait.es2018.3.ts, 6, 1)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.es2018.3.ts, 8, 7)) + + for await (const x of {}) { +>x : Symbol(x, Decl(types.forAwait.es2018.3.ts, 9, 20)) + } + for await (y of {}) { +>y : Symbol(y, Decl(types.forAwait.es2018.3.ts, 8, 7)) + } +} + diff --git a/tests/baselines/reference/types.forAwait.esnext.3.types b/tests/baselines/reference/types.forAwait.es2018.3.types similarity index 79% rename from tests/baselines/reference/types.forAwait.esnext.3.types rename to tests/baselines/reference/types.forAwait.es2018.3.types index 6b9ebdc4ac9..604ecadc54d 100644 --- a/tests/baselines/reference/types.forAwait.esnext.3.types +++ b/tests/baselines/reference/types.forAwait.es2018.3.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts === +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts === async function f1() { >f1 : () => Promise @@ -29,3 +29,4 @@ async function* f2() { >{} : {} } } + diff --git a/tests/baselines/reference/types.forAwait.esnext.1.symbols b/tests/baselines/reference/types.forAwait.esnext.1.symbols deleted file mode 100644 index c3c10c42109..00000000000 --- a/tests/baselines/reference/types.forAwait.esnext.1.symbols +++ /dev/null @@ -1,76 +0,0 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts === -declare const asyncIterable: AsyncIterable; ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.1.ts, 0, 13)) ->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) - -declare const iterable: Iterable; ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -declare const iterableOfPromise: Iterable>; ->iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.esnext.1.ts, 2, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) - -async function f1() { ->f1 : Symbol(f1, Decl(types.forAwait.esnext.1.ts, 2, 59)) - - let y: number; ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 4, 7)) - - for await (const x of asyncIterable) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 5, 20)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.1.ts, 0, 13)) - } - for await (const x of iterable) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 7, 20)) ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) - } - for await (const x of iterableOfPromise) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 9, 20)) ->iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.esnext.1.ts, 2, 13)) - } - for await (y of asyncIterable) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 4, 7)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.1.ts, 0, 13)) - } - for await (y of iterable) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 4, 7)) ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) - } - for await (y of iterableOfPromise) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 4, 7)) ->iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.esnext.1.ts, 2, 13)) - } -} -async function * f2() { ->f2 : Symbol(f2, Decl(types.forAwait.esnext.1.ts, 17, 1)) - - let y: number; ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 19, 7)) - - for await (const x of asyncIterable) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 20, 20)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.1.ts, 0, 13)) - } - for await (const x of iterable) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 22, 20)) ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) - } - for await (const x of iterableOfPromise) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 24, 20)) ->iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.esnext.1.ts, 2, 13)) - } - for await (y of asyncIterable) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 19, 7)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.1.ts, 0, 13)) - } - for await (y of iterable) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 19, 7)) ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) - } - for await (y of iterableOfPromise) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 19, 7)) ->iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.esnext.1.ts, 2, 13)) - } -} diff --git a/tests/baselines/reference/types.forAwait.esnext.2.symbols b/tests/baselines/reference/types.forAwait.esnext.2.symbols deleted file mode 100644 index 5013f1c964d..00000000000 --- a/tests/baselines/reference/types.forAwait.esnext.2.symbols +++ /dev/null @@ -1,41 +0,0 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts === -declare const asyncIterable: AsyncIterable; ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.2.ts, 0, 13)) ->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) - -declare const iterable: Iterable; ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.2.ts, 1, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -async function f() { ->f : Symbol(f, Decl(types.forAwait.esnext.2.ts, 1, 41)) - - let y: number; ->y : Symbol(y, Decl(types.forAwait.esnext.2.ts, 3, 7)) - - let z: string; ->z : Symbol(z, Decl(types.forAwait.esnext.2.ts, 4, 7)) - - for await (const x of {}) { ->x : Symbol(x, Decl(types.forAwait.esnext.2.ts, 5, 20)) - } - for await (y of {}) { ->y : Symbol(y, Decl(types.forAwait.esnext.2.ts, 3, 7)) - } - for await (z of asyncIterable) { ->z : Symbol(z, Decl(types.forAwait.esnext.2.ts, 4, 7)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.2.ts, 0, 13)) - } - for await (z of iterable) { ->z : Symbol(z, Decl(types.forAwait.esnext.2.ts, 4, 7)) ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.2.ts, 1, 13)) - } - for (const x of asyncIterable) { ->x : Symbol(x, Decl(types.forAwait.esnext.2.ts, 13, 14)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.2.ts, 0, 13)) - } - for (y of asyncIterable) { ->y : Symbol(y, Decl(types.forAwait.esnext.2.ts, 3, 7)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.2.ts, 0, 13)) - } -} diff --git a/tests/baselines/reference/types.forAwait.esnext.3.symbols b/tests/baselines/reference/types.forAwait.esnext.3.symbols deleted file mode 100644 index c7df2f71ede..00000000000 --- a/tests/baselines/reference/types.forAwait.esnext.3.symbols +++ /dev/null @@ -1,27 +0,0 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts === -async function f1() { ->f1 : Symbol(f1, Decl(types.forAwait.esnext.3.ts, 0, 0)) - - let y: number; ->y : Symbol(y, Decl(types.forAwait.esnext.3.ts, 1, 7)) - - for await (const x of {}) { ->x : Symbol(x, Decl(types.forAwait.esnext.3.ts, 2, 20)) - } - for await (y of {}) { ->y : Symbol(y, Decl(types.forAwait.esnext.3.ts, 1, 7)) - } -} -async function* f2() { ->f2 : Symbol(f2, Decl(types.forAwait.esnext.3.ts, 6, 1)) - - let y: number; ->y : Symbol(y, Decl(types.forAwait.esnext.3.ts, 8, 7)) - - for await (const x of {}) { ->x : Symbol(x, Decl(types.forAwait.esnext.3.ts, 9, 20)) - } - for await (y of {}) { ->y : Symbol(y, Decl(types.forAwait.esnext.3.ts, 8, 7)) - } -} diff --git a/tests/cases/compiler/forAwaitForUnion.ts b/tests/cases/compiler/forAwaitForUnion.ts index 65e08ab77a9..f9434e02897 100644 --- a/tests/cases/compiler/forAwaitForUnion.ts +++ b/tests/cases/compiler/forAwaitForUnion.ts @@ -1,6 +1,6 @@ -// @target: esnext +// @target: es2018 // @lib: esnext async function f(source: Iterable | AsyncIterable) { for await (const x of source) { } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.classMethods.esnext.ts b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.classMethods.es2018.ts similarity index 91% rename from tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.classMethods.esnext.ts rename to tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.classMethods.es2018.ts index fbdcaab4998..6e7dc0622bc 100644 --- a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.classMethods.esnext.ts +++ b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.classMethods.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @filename: C1.ts class C1 { diff --git a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionDeclarations.esnext.ts b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es2018.ts similarity index 91% rename from tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionDeclarations.esnext.ts rename to tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es2018.ts index 2e529c5c92d..ebeee3e4e27 100644 --- a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionDeclarations.esnext.ts +++ b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @filename: F1.ts async function * f1() { diff --git a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionExpressions.esnext.ts b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionExpressions.es2018.ts similarity index 92% rename from tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionExpressions.esnext.ts rename to tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionExpressions.es2018.ts index 412e3a8a4d6..79bb5a3d255 100644 --- a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionExpressions.esnext.ts +++ b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionExpressions.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @filename: F1.ts const f1 = async function * () { diff --git a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.esnext.ts b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es2018.ts similarity index 90% rename from tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.esnext.ts rename to tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es2018.ts index ae41cff42b9..d5e1bc7b1f8 100644 --- a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.esnext.ts +++ b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @filename: O1.ts const o1 = { diff --git a/tests/cases/conformance/emitter/esnext/forAwait/emitter.forAwait.esnext.ts b/tests/cases/conformance/emitter/es2018/forAwait/emitter.forAwait.es2018.ts similarity index 92% rename from tests/cases/conformance/emitter/esnext/forAwait/emitter.forAwait.esnext.ts rename to tests/cases/conformance/emitter/es2018/forAwait/emitter.forAwait.es2018.ts index ea1b030599e..02e875fb7e4 100644 --- a/tests/cases/conformance/emitter/esnext/forAwait/emitter.forAwait.esnext.ts +++ b/tests/cases/conformance/emitter/es2018/forAwait/emitter.forAwait.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @filename: file1.ts async function f1() { @@ -39,4 +39,4 @@ async function* f6() { outer: for await (const x of y) { continue outer; } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.classMethods.esnext.ts b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.classMethods.es2018.ts similarity index 93% rename from tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.classMethods.esnext.ts rename to tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.classMethods.es2018.ts index ffbe79ee292..719d373983b 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.classMethods.esnext.ts +++ b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.classMethods.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true // @filename: methodIsOk.ts @@ -146,4 +146,4 @@ class C24 { // @filename: asyncGeneratorPropertyIsError.ts class C25 { async * x = 1; -} \ No newline at end of file +} diff --git a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionDeclarations.esnext.ts b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionDeclarations.es2018.ts similarity index 94% rename from tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionDeclarations.esnext.ts rename to tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionDeclarations.es2018.ts index fd212595a0c..10cbc2204bb 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionDeclarations.esnext.ts +++ b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionDeclarations.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true // @filename: functionDeclarationIsOk.ts @@ -84,4 +84,4 @@ async function * f20() { // @filename: yieldInNestedComputedPropertyIsOk.ts async function * f21() { const x = { [yield]: 1 }; -} \ No newline at end of file +} diff --git a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionExpressions.esnext.ts b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionExpressions.es2018.ts similarity index 95% rename from tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionExpressions.esnext.ts rename to tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionExpressions.es2018.ts index 1a740a5d5b4..92bbcf50c59 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionExpressions.esnext.ts +++ b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionExpressions.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true // @filename: functionExpressionIsOk.ts diff --git a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.es2018.ts similarity index 93% rename from tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts rename to tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.es2018.ts index 433c24ad2fa..dc9ffb4dddb 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts +++ b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @skipLibCheck: true // @lib: esnext // @noEmit: true @@ -142,4 +142,4 @@ const o23 = { // @filename: asyncGeneratorPropertyIsError.ts const o24 = { async * x: 1; -}; \ No newline at end of file +}; diff --git a/tests/cases/conformance/parser/ecmascriptnext/forAwait/parser.forAwait.esnext.ts b/tests/cases/conformance/parser/ecmascript2018/forAwait/parser.forAwait.es2018.ts similarity index 93% rename from tests/cases/conformance/parser/ecmascriptnext/forAwait/parser.forAwait.esnext.ts rename to tests/cases/conformance/parser/ecmascript2018/forAwait/parser.forAwait.es2018.ts index 61e9055b874..4619bacfc2a 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/forAwait/parser.forAwait.esnext.ts +++ b/tests/cases/conformance/parser/ecmascript2018/forAwait/parser.forAwait.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true // @filename: topLevelWithDeclIsError.ts @@ -60,4 +60,4 @@ function* f12() { let x: any, y: any; for await (x of y) { } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts b/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts similarity index 96% rename from tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts rename to tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts index 1d7ebd17807..f31f453ba5f 100644 --- a/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts +++ b/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true async function * inferReturnType1() { @@ -123,4 +123,4 @@ async function * awaitedType1() { } async function * awaitedType2() { const x = await Promise.resolve(1); -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts b/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts similarity index 96% rename from tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts rename to tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts index 3252189b798..0053f71b986 100644 --- a/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts +++ b/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true async function * inferReturnType1() { @@ -75,4 +75,4 @@ async function * explicitReturnType12(): Iterator { } async function * yieldStar() { yield* {}; -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts similarity index 93% rename from tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts rename to tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts index 8b5157250b8..50173378731 100644 --- a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts +++ b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true declare const asyncIterable: AsyncIterable; @@ -33,4 +33,4 @@ async function * f2() { } for await (y of iterableOfPromise) { } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts similarity index 90% rename from tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts rename to tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts index b9688862d61..97f4eeb07c6 100644 --- a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts +++ b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true declare const asyncIterable: AsyncIterable; @@ -18,4 +18,4 @@ async function f() { } for (y of asyncIterable) { } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts similarity index 87% rename from tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts rename to tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts index 3f74c17671a..f45adf23a0e 100644 --- a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts +++ b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: es5 // @noEmit: true async function f1() { @@ -14,4 +14,4 @@ async function* f2() { } for await (y of {}) { } -} \ No newline at end of file +} From 8e5dcfbde50a3e4a597f292a35efc0baea1c21d0 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 6 Feb 2019 16:59:26 -0800 Subject: [PATCH 20/20] Add try priors as finally lock label andecedents rather than pre finally label antecedents (#29790) --- src/compiler/binder.ts | 8 +++- .../controlFlowFinallyNoCatchAssignments.js | 33 +++++++++++++ ...ntrolFlowFinallyNoCatchAssignments.symbols | 38 +++++++++++++++ ...controlFlowFinallyNoCatchAssignments.types | 46 +++++++++++++++++++ .../controlFlowFinallyNoCatchAssignments.ts | 15 ++++++ 5 files changed, 138 insertions(+), 2 deletions(-) create mode 100644 tests/baselines/reference/controlFlowFinallyNoCatchAssignments.js create mode 100644 tests/baselines/reference/controlFlowFinallyNoCatchAssignments.symbols create mode 100644 tests/baselines/reference/controlFlowFinallyNoCatchAssignments.types create mode 100644 tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 9124bdf2939..f3494783514 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -1120,11 +1120,15 @@ namespace ts { // We add the nodes within the `try` block to the `finally`'s antecedents if there's no catch block // (If there is a `catch` block, it will have all these antecedents instead, and the `finally` will // have the end of the `try` block and the end of the `catch` block) + let preFinallyPrior = preTryFlow; if (!node.catchClause) { if (tryPriors.length) { + const preFinallyFlow = createBranchLabel(); + addAntecedent(preFinallyFlow, preTryFlow); for (const p of tryPriors) { - addAntecedent(preFinallyLabel, p); + addAntecedent(preFinallyFlow, p); } + preFinallyPrior = finishFlowLabel(preFinallyFlow); } } @@ -1156,7 +1160,7 @@ namespace ts { // // extra edges that we inject allows to control this behavior // if when walking the flow we step on post-finally edge - we can mark matching pre-finally edge as locked so it will be skipped. - const preFinallyFlow: PreFinallyFlow = { flags: FlowFlags.PreFinally, antecedent: preTryFlow, lock: {} }; + const preFinallyFlow: PreFinallyFlow = { flags: FlowFlags.PreFinally, antecedent: preFinallyPrior, lock: {} }; addAntecedent(preFinallyLabel, preFinallyFlow); currentFlow = finishFlowLabel(preFinallyLabel); diff --git a/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.js b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.js new file mode 100644 index 00000000000..3821fd1b278 --- /dev/null +++ b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.js @@ -0,0 +1,33 @@ +//// [controlFlowFinallyNoCatchAssignments.ts] +let x: number; +x = Math.random(); +let a: number; +try { + if (x) { + a = 1; + } else { + a = 2; + } +} finally { + console.log(x); +} + +console.log(a); // <- error here + +//// [controlFlowFinallyNoCatchAssignments.js] +"use strict"; +var x; +x = Math.random(); +var a; +try { + if (x) { + a = 1; + } + else { + a = 2; + } +} +finally { + console.log(x); +} +console.log(a); // <- error here diff --git a/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.symbols b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.symbols new file mode 100644 index 00000000000..f66f3bbe4b7 --- /dev/null +++ b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.symbols @@ -0,0 +1,38 @@ +=== tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts === +let x: number; +>x : Symbol(x, Decl(controlFlowFinallyNoCatchAssignments.ts, 0, 3)) + +x = Math.random(); +>x : Symbol(x, Decl(controlFlowFinallyNoCatchAssignments.ts, 0, 3)) +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) + +let a: number; +>a : Symbol(a, Decl(controlFlowFinallyNoCatchAssignments.ts, 2, 3)) + +try { + if (x) { +>x : Symbol(x, Decl(controlFlowFinallyNoCatchAssignments.ts, 0, 3)) + + a = 1; +>a : Symbol(a, Decl(controlFlowFinallyNoCatchAssignments.ts, 2, 3)) + + } else { + a = 2; +>a : Symbol(a, Decl(controlFlowFinallyNoCatchAssignments.ts, 2, 3)) + } +} finally { + console.log(x); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>x : Symbol(x, Decl(controlFlowFinallyNoCatchAssignments.ts, 0, 3)) +} + +console.log(a); // <- error here +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>a : Symbol(a, Decl(controlFlowFinallyNoCatchAssignments.ts, 2, 3)) + diff --git a/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.types b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.types new file mode 100644 index 00000000000..7199969d6c3 --- /dev/null +++ b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.types @@ -0,0 +1,46 @@ +=== tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts === +let x: number; +>x : number + +x = Math.random(); +>x = Math.random() : number +>x : number +>Math.random() : number +>Math.random : () => number +>Math : Math +>random : () => number + +let a: number; +>a : number + +try { + if (x) { +>x : number + + a = 1; +>a = 1 : 1 +>a : number +>1 : 1 + + } else { + a = 2; +>a = 2 : 2 +>a : number +>2 : 2 + } +} finally { + console.log(x); +>console.log(x) : void +>console.log : (message?: any, ...optionalParams: any[]) => void +>console : Console +>log : (message?: any, ...optionalParams: any[]) => void +>x : number +} + +console.log(a); // <- error here +>console.log(a) : void +>console.log : (message?: any, ...optionalParams: any[]) => void +>console : Console +>log : (message?: any, ...optionalParams: any[]) => void +>a : number + diff --git a/tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts b/tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts new file mode 100644 index 00000000000..7f8201ade14 --- /dev/null +++ b/tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts @@ -0,0 +1,15 @@ +// @strict: true +let x: number; +x = Math.random(); +let a: number; +try { + if (x) { + a = 1; + } else { + a = 2; + } +} finally { + console.log(x); +} + +console.log(a); // <- error here \ No newline at end of file