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 +}