diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index a5a7804b2af..ce0ee4678ee 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -2547,7 +2547,7 @@ namespace ts { transformFlags = TransformFlags.AssertTypeScript; } else { - transformFlags = subtreeFlags | TransformFlags.ContainsHoistedDeclaration; + transformFlags = subtreeFlags | TransformFlags.ContainsHoistedDeclarationOrCompletion; // If a FunctionDeclaration is exported, then it is either ES6 or TypeScript syntax. if (modifierFlags & ModifierFlags.Export) { @@ -2726,7 +2726,7 @@ namespace ts { } function computeVariableDeclarationList(node: VariableDeclarationList, subtreeFlags: TransformFlags) { - let transformFlags = subtreeFlags | TransformFlags.ContainsHoistedDeclaration; + let transformFlags = subtreeFlags | TransformFlags.ContainsHoistedDeclarationOrCompletion; if (subtreeFlags & TransformFlags.ContainsBindingPattern) { transformFlags |= TransformFlags.AssertES6; @@ -2794,6 +2794,7 @@ namespace ts { // These nodes are ES6 syntax. transformFlags |= TransformFlags.AssertES6; break; + case SyntaxKind.YieldExpression: // This node is ES6 syntax. transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsYield; @@ -2920,6 +2921,12 @@ namespace ts { } break; + + case SyntaxKind.ReturnStatement: + case SyntaxKind.ContinueStatement: + case SyntaxKind.BreakStatement: + transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion; + break; } node.transformFlags = transformFlags | TransformFlags.HasComputedFlags; diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 74af285bfcb..7c3ea929545 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -18069,10 +18069,6 @@ namespace ts { } function checkGrammarAsyncModifier(node: Node, asyncModifier: Node): boolean { - if (languageVersion < ScriptTarget.ES6) { - return grammarErrorOnNode(asyncModifier, Diagnostics.Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher); - } - switch (node.kind) { case SyntaxKind.MethodDeclaration: case SyntaxKind.FunctionDeclaration: diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 034bd27b147..d22497e4a63 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -831,10 +831,6 @@ "category": "Error", "code": 1308 }, - "Async functions are only available when targeting ECMAScript 6 and higher.": { - "category": "Error", - "code": 1311 - }, "'=' can only be used in an object literal property inside a destructuring assignment.": { "category": "Error", "code": 1312 diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index b066540c6b5..0ff60a0fe31 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -73,99 +73,52 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge const generatorHelper = ` var __generator = (this && this.__generator) || function (body) { - var done, finallyStack, executing, yieldStar, trys = [], state = { label: 0, trys: trys }; + var _ = { label: 0, sent: function() { if (sent[0] === 1 /*throw*/) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent; function step(op) { - if (executing) throw new TypeError("Generator is already executing."); + if (_.flag) throw new TypeError("Generator is already executing."); while (true) { - if (done) { - switch (op[0]) { - case 0 /*next*/: return { value: void 0, done: true }; - case 6 /*catch*/: - case 1 /*throw*/: throw op[1]; - case 2 /*return*/: return { value: op[1], done: true }; - } + if (_.done) switch (op[0]) { + case 0 /*next*/: return { value: void 0, done: true }; + case 1 /*throw*/: case 6 /*catch*/: throw op[1]; + case 2 /*return*/: return { value: op[1], done: true }; } try { - executing = true; - if (yieldStar) { - var verb = yieldStar[op[0] === 2 ? "return" : op[0] === 1 ? "throw" : "next"]; - if (verb) { - var yielded = verb.call(yieldStar, op[1]); - if (!yielded.done) return { value: yielded.value, done: false }; - op = [0 /*next*/, yielded.value]; - } - - yieldStar = void 0; - continue; - } - - switch (op[0]) { - case 0 /*next*/: - state.sent = function() { return op[1]; }; - break; - - case 1 /*throw*/: - state.sent = function() { throw op[1]; }; - break; - - case 4 /*yield*/: - state.label++; - return { value: op[1], done: false }; - - case 5 /*yieldstar*/: - state.label++; - yieldStar = op[1]; - op = [0 /*next*/, void 0]; - continue; - - case 7 /*endfinally*/: - op = finallyStack.pop(); - trys.pop(); - continue; - + switch (_.flag = true, op[0]) { + case 0 /*next*/: case 1 /*throw*/: sent = op; break; + case 4 /*yield*/: return _.label++, { value: op[1], done: false }; + case 7 /*endfinally*/: op = _.stack.pop(), _.trys.pop(); continue; default: - var rgn = trys.length && trys[trys.length - 1]; - if (!rgn && (op[0] === 6 /*catch*/ || op[0] === 1 /*throw*/ || op[0] === 2 /*return*/)) { - done = true; - finallyStack = void 0; + var r = _.trys.length > 0 && _.trys[_.trys.length - 1]; + if (!r && (op[0] === 1 /*throw*/ || op[0] === 6 /*catch*/ || op[0] === 2 /*return*/)) { + _.done = true; continue; } - else if (op[0] === 3 /*break*/ && (!rgn || (op[1] > rgn[0] && op[1] < rgn[3]))) { - state.label = op[1]; + if (op[0] === 3 /*break*/ && (!r || (op[1] > r[0] && op[1] < r[3]))) { + _.label = op[1]; } - else if (op[0] === 6 /*catch*/ && rgn && state.label < rgn[1]) { - state.error = op[1]; - state.label = rgn[1]; + else if (op[0] === 6 /*catch*/ && r && _.label < r[1]) { + _.label = r[1], sent = op; } - else if (rgn && state.label < rgn[2]) { - (finallyStack || []).push(op); - state.label = rgn[2]; + else if (r && _.label < r[2]) { + _.label = r[2], _.stack.push(op); } else { - if (rgn[2]) finallyStack.pop(); - trys.pop(); + if (r[2]) _.stack.pop(); + _.trys.pop(); continue; } } - - op = body(state); - } - catch (e) { - op = [6 /*catch*/, e]; - yieldStar = void 0; - } - finally { - executing = false; - verb = yielded = void 0; + op = body(_); } + catch (e) { op = [6 /*catch*/, e]; } + finally { _.flag = false, sent = void 0; } } } - var g = { + return { next: function (v) { return step([0 /*next*/, v]); }, "throw": function (v) { return step([1 /*throw*/, v]); }, "return": function (v) { return step([2 /*return*/, v]); } }; - return g; };`; // emit output for the __export helper function @@ -782,6 +735,8 @@ const _super = (function (geti, seti) { switch (kind) { // Literals case SyntaxKind.NumericLiteral: + return emitNumericLiteral(node); + case SyntaxKind.StringLiteral: case SyntaxKind.RegularExpressionLiteral: case SyntaxKind.NoSubstitutionTemplateLiteral: @@ -870,6 +825,13 @@ const _super = (function (geti, seti) { // // SyntaxKind.NumericLiteral + function emitNumericLiteral(node: NumericLiteral) { + emitLiteral(node); + if (node.trailingComment) { + write(` /*${node.trailingComment}*/`); + } + } + // SyntaxKind.StringLiteral // SyntaxKind.RegularExpressionLiteral // SyntaxKind.NoSubstitutionTemplateLiteral @@ -1653,15 +1615,21 @@ const _super = (function (geti, seti) { increaseIndent(); } - const savedTempFlags = tempFlags; - tempFlags = 0; - emitSignatureHead(node); - emitBlockFunctionBody(node, body); + if (node.emitFlags & NodeEmitFlags.ReuseTempVariableScope) { + emitSignatureHead(node); + emitBlockFunctionBody(node, body); + } + else { + const savedTempFlags = tempFlags; + tempFlags = 0; + emitSignatureHead(node); + emitBlockFunctionBody(node, body); + tempFlags = savedTempFlags; + } + if (indentedFlag) { decreaseIndent(); } - - tempFlags = savedTempFlags; } else { emitSignatureHead(node); diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts index f95245c4f27..ee1fe3bd2bb 100644 --- a/src/compiler/factory.ts +++ b/src/compiler/factory.ts @@ -139,7 +139,7 @@ namespace ts { return node; } - export function createTempVariable(recordTempVariable: (node: Identifier) => void, location?: TextRange): Identifier { + export function createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined, location?: TextRange): Identifier { const name = createNode(SyntaxKind.Identifier, location); name.text = ""; name.originalKeywordKind = SyntaxKind.Unknown; @@ -366,6 +366,13 @@ namespace ts { return node; } + export function updateElementAccess(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression) { + if (node.expression !== expression || node.argumentExpression !== argumentExpression) { + return updateNode(createElementAccess(expression, argumentExpression, node), node); + } + return node; + } + export function createCall(expression: Expression, typeArguments: TypeNode[], argumentsArray: Expression[], location?: TextRange, flags?: NodeFlags) { const node = createNode(SyntaxKind.CallExpression, location, flags); node.expression = parenthesizeForAccess(expression); @@ -1378,19 +1385,29 @@ namespace ts { thisArg: Expression; } - function shouldBeCapturedInTempVariable(node: Expression): boolean { - switch (skipParentheses(node).kind) { + function shouldBeCapturedInTempVariable(node: Expression, cacheIdentifiers: boolean): boolean { + const target = skipParentheses(node); + switch (target.kind) { case SyntaxKind.Identifier: + return cacheIdentifiers; case SyntaxKind.ThisKeyword: case SyntaxKind.NumericLiteral: case SyntaxKind.StringLiteral: return false; + case SyntaxKind.ArrayLiteralExpression: + const elements = (target).elements; + if (elements.length === 0) { + return false; + } + return true; + case SyntaxKind.ObjectLiteralExpression: + return (target).properties.length > 0; default: return true; } } - export function createCallBinding(expression: Expression, recordTempVariable: (temp: Identifier) => void, languageVersion?: ScriptTarget): CallBinding { + export function createCallBinding(expression: Expression, recordTempVariable: (temp: Identifier) => void, languageVersion?: ScriptTarget, cacheIdentifiers?: boolean): CallBinding { const callee = skipOuterExpressions(expression, OuterExpressionKinds.All); let thisArg: Expression; let target: LeftHandSideExpression; @@ -1405,7 +1422,7 @@ namespace ts { else { switch (callee.kind) { case SyntaxKind.PropertyAccessExpression: { - if (shouldBeCapturedInTempVariable((callee).expression)) { + if (shouldBeCapturedInTempVariable((callee).expression, cacheIdentifiers)) { // for `a.b()` target is `(_a = a).b` and thisArg is `_a` thisArg = createTempVariable(recordTempVariable); target = createPropertyAccess( @@ -1426,7 +1443,7 @@ namespace ts { } case SyntaxKind.ElementAccessExpression: { - if (shouldBeCapturedInTempVariable((callee).expression)) { + if (shouldBeCapturedInTempVariable((callee).expression, cacheIdentifiers)) { // for `a[b]()` target is `(_a = a)[b]` and thisArg is `_a` thisArg = createTempVariable(recordTempVariable); target = createElementAccess( diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts index 29aa55314d0..133ed01f091 100644 --- a/src/compiler/transformers/generators.ts +++ b/src/compiler/transformers/generators.ts @@ -235,9 +235,12 @@ namespace ts { hoistFunctionDeclaration, hoistVariableDeclaration, setSourceMapRange, - setCommentRange + setCommentRange, + setNodeEmitFlags } = context; + const compilerOptions = context.getCompilerOptions(); + const languageVersion = getEmitScriptTarget(compilerOptions); const resolver = context.getEmitResolver(); const previousOnSubstituteNode = context.onSubstituteNode; context.onSubstituteNode = onSubstituteNode; @@ -316,10 +319,10 @@ namespace ts { else if (inGeneratorFunctionBody) { return visitJavaScriptInGeneratorFunctionBody(node); } - else if (node.transformFlags & TransformFlags.Generator) { + else if (transformFlags & TransformFlags.Generator) { return visitGenerator(node); } - else if (node.transformFlags & TransformFlags.ContainsGenerator) { + else if (transformFlags & TransformFlags.ContainsGenerator) { return visitEachChild(node, visitor, context); } else { @@ -366,10 +369,6 @@ namespace ts { return visitDoStatement(node); case SyntaxKind.WhileStatement: return visitWhileStatement(node); - case SyntaxKind.ForStatement: - return visitForStatement(node); - case SyntaxKind.ForInStatement: - return visitForInStatement(node); case SyntaxKind.SwitchStatement: return visitSwitchStatement(node); case SyntaxKind.LabeledStatement: @@ -395,6 +394,10 @@ namespace ts { return visitAccessorDeclaration(node); case SyntaxKind.VariableStatement: return visitVariableStatement(node); + case SyntaxKind.ForStatement: + return visitForStatement(node); + case SyntaxKind.ForInStatement: + return visitForInStatement(node); case SyntaxKind.BreakStatement: return visitBreakStatement(node); case SyntaxKind.ContinueStatement: @@ -402,7 +405,7 @@ namespace ts { case SyntaxKind.ReturnStatement: return visitReturnStatement(node); default: - if (node.transformFlags & (TransformFlags.ContainsGenerator | TransformFlags.ContainsYield | TransformFlags.ContainsHoistedDeclaration)) { + if (node.transformFlags & (TransformFlags.ContainsGenerator | TransformFlags.ContainsYield | TransformFlags.ContainsHoistedDeclarationOrCompletion)) { return visitEachChild(node, visitor, context); } else { @@ -568,7 +571,7 @@ namespace ts { operations = undefined; operationArguments = undefined; operationLocations = undefined; - state = createUniqueName("state"); + state = createTempVariable(/*recordTempVariable*/ undefined); // Build the generator startLexicalEnvironment(); @@ -646,54 +649,98 @@ namespace ts { } } + function isCompoundAssignment(kind: SyntaxKind) { + return kind >= SyntaxKind.FirstCompoundAssignment + && kind <= SyntaxKind.LastCompoundAssignment; + } + + function getOperatorForCompoundAssignment(kind: SyntaxKind) { + switch (kind) { + case SyntaxKind.PlusEqualsToken: return SyntaxKind.PlusToken; + case SyntaxKind.MinusEqualsToken: return SyntaxKind.MinusToken; + case SyntaxKind.AsteriskEqualsToken: return SyntaxKind.AsteriskToken; + case SyntaxKind.AsteriskAsteriskEqualsToken: return SyntaxKind.AsteriskAsteriskToken; + case SyntaxKind.SlashEqualsToken: return SyntaxKind.SlashToken; + case SyntaxKind.PercentEqualsToken: return SyntaxKind.PercentToken; + case SyntaxKind.LessThanLessThanEqualsToken: return SyntaxKind.LessThanLessThanToken; + case SyntaxKind.GreaterThanGreaterThanEqualsToken: return SyntaxKind.GreaterThanGreaterThanToken; + case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: return SyntaxKind.GreaterThanGreaterThanGreaterThanToken; + case SyntaxKind.AmpersandEqualsToken: return SyntaxKind.AmpersandToken; + case SyntaxKind.BarEqualsToken: return SyntaxKind.BarToken; + case SyntaxKind.CaretEqualsToken: return SyntaxKind.CaretToken; + } + } + /** * Visits a right-associative binary expression containing `yield`. * * @param node The node to visit. */ function visitRightAssociativeBinaryExpression(node: BinaryExpression) { - switch (node.left.kind) { - case SyntaxKind.PropertyAccessExpression: { - // [source] - // a.b = yield; - // - // [intermediate] - // .local _a - // _a = a; - // .yield resumeLabel - // .mark resumeLabel - // _a.b = %sent%; + const { left, right } = node; + if (containsYield(right)) { + let target: Expression; + switch (left.kind) { + case SyntaxKind.PropertyAccessExpression: + // [source] + // a.b = yield; + // + // [intermediate] + // .local _a + // _a = a; + // .yield resumeLabel + // .mark resumeLabel + // _a.b = %sent%; - const clone = getMutableClone(node); - const propertyAccess = node.left; - const propertyAccessClone = getMutableClone(propertyAccess); - propertyAccessClone.expression = cacheExpression(visitNode(propertyAccess.expression, visitor, isLeftHandSideExpression)); - clone.left = propertyAccessClone; - clone.right = visitNode(node.right, visitor, isExpression); - return clone; + target = updatePropertyAccess( + left, + cacheExpression(visitNode((left).expression, visitor, isLeftHandSideExpression)), + (left).name + ); + break; + + case SyntaxKind.ElementAccessExpression: + // [source] + // a[b] = yield; + // + // [intermediate] + // .local _a, _b + // _a = a; + // _b = b; + // .yield resumeLabel + // .mark resumeLabel + // _a[_b] = %sent%; + + target = updateElementAccess(left, + cacheExpression(visitNode((left).expression, visitor, isLeftHandSideExpression)), + cacheExpression(visitNode((left).argumentExpression, visitor, isExpression)) + ); + break; + + default: + target = visitNode(left, visitor, isExpression); + break; } - case SyntaxKind.ElementAccessExpression: { - // [source] - // a[b] = yield; - // - // [intermediate] - // .local _a, _b - // _a = a; - // _b = b; - // .yield resumeLabel - // .mark resumeLabel - // _a[_b] = %sent%; - const clone = getMutableClone(node); - const elementAccess = node.left; - const elementAccessClone = getMutableClone(elementAccess); - elementAccessClone.expression = cacheExpression(visitNode(elementAccess.expression, visitor, isLeftHandSideExpression)); - elementAccessClone.argumentExpression = cacheExpression(visitNode(elementAccess.argumentExpression, visitor, isExpression)); - clone.left = elementAccessClone; - clone.right = visitNode(node.right, visitor, isExpression); - return clone; + const operator = node.operatorToken.kind; + if (isCompoundAssignment(operator)) { + return createBinary( + target, + SyntaxKind.EqualsToken, + createBinary( + cacheExpression(target), + getOperatorForCompoundAssignment(operator), + visitNode(right, visitor, isExpression), + node + ), + node + ); + } + else { + return updateBinary(node, target, visitNode(right, visitor, isExpression)); } } + return visitEachChild(node, visitor, context); } @@ -902,26 +949,34 @@ namespace ts { // ar = _a.concat([%sent%, 2]); const numInitialElements = countInitialNodesWithoutYield(elements); - const temp = declareLocal(); - emitAssignment(temp, - createArrayLiteral( - visitNodes(elements, visitor, isExpression, 0, numInitialElements) - ) - ); + let hasAssignedTemp = false; + if (numInitialElements > 0) { + emitAssignment(temp, + createArrayLiteral( + visitNodes(elements, visitor, isExpression, 0, numInitialElements) + ) + ); + hasAssignedTemp = true; + } const expressions = reduceLeft(elements, reduceElement, [], numInitialElements); - return createArrayConcat(temp, [createArrayLiteral(expressions)]); + return hasAssignedTemp + ? createArrayConcat(temp, [createArrayLiteral(expressions)]) + : createArrayLiteral(expressions); function reduceElement(expressions: Expression[], element: Expression) { if (containsYield(element) && expressions.length > 0) { emitAssignment( temp, - createArrayConcat( - temp, - [createArrayLiteral(expressions)] - ) + hasAssignedTemp + ? createArrayConcat( + temp, + [createArrayLiteral(expressions)] + ) + : createArrayLiteral(expressions) ); + hasAssignedTemp = true; expressions = []; } @@ -1017,7 +1072,7 @@ namespace ts { // .mark resumeLabel // _b.apply(_a, _c.concat([%sent%, 2])); - const { target, thisArg } = createCallBinding(node.expression, hoistVariableDeclaration); + const { target, thisArg } = createCallBinding(node.expression, hoistVariableDeclaration, languageVersion, /*cacheIdentifiers*/ true); return setOriginalNode( createFunctionApply( cacheExpression(visitNode(target, visitor, isLeftHandSideExpression)), @@ -1121,7 +1176,7 @@ namespace ts { case SyntaxKind.TryStatement: return transformAndEmitTryStatement(node); default: - return emitStatement(visitEachChild(node, visitor, context)); + return emitStatement(visitNode(node, visitor, isStatement, /*optional*/ true)); } } @@ -1398,14 +1453,14 @@ namespace ts { // } // // [intermediate] - // .local _a, _b, _c + // .local _a, _b, _i // _a = []; // for (_b in o) _a.push(_b); - // _c = 0; + // _i = 0; // .loop incrementLabel, endLoopLabel // .mark conditionLabel - // .brfalse endLoopLabel, (_c < _a.length) - // p = _a[_c]; + // .brfalse endLoopLabel, (_i < _a.length) + // p = _a[_i]; // /*body*/ // .mark incrementLabel // _b++; @@ -1415,9 +1470,9 @@ namespace ts { const keysArray = declareLocal(); // _a const key = declareLocal(); // _b - const keysIndex = declareLocal(); // _c + const keysIndex = createLoopVariable(); // _i const initializer = node.initializer; - + hoistVariableDeclaration(keysIndex); emitAssignment(keysArray, createArrayLiteral()); emitStatement( @@ -1440,6 +1495,9 @@ namespace ts { const incrementLabel = defineLabel(); const endLabel = beginLoopBlock(incrementLabel); + markLabel(conditionLabel); + emitBreakWhenFalse(endLabel, createLessThan(keysIndex, createPropertyAccess(keysArray, "length"))); + let variable: Expression; if (isVariableDeclarationList(initializer)) { for (const variable of initializer.declarations) { @@ -1449,13 +1507,10 @@ namespace ts { variable = getSynthesizedClone(initializer.declarations[0].name); } else { - variable = initializer; + variable = visitNode(initializer, visitor, isExpression); Debug.assert(isLeftHandSideExpression(variable)); } - markLabel(conditionLabel); - emitBreakWhenFalse(endLabel, createLessThan(keysIndex, createPropertyAccess(keysArray, "length"))); - emitAssignment(variable, createElementAccess(keysArray, keysIndex)); transformAndEmitEmbeddedStatement(node.statement); @@ -1580,7 +1635,7 @@ namespace ts { } function transformAndEmitSwitchStatement(node: SwitchStatement) { - if (containsYield(node)) { + if (containsYield(node.caseBlock)) { // [source] // switch (x) { // case a: @@ -1636,6 +1691,7 @@ namespace ts { let clausesWritten = 0; let pendingClauses: CaseClause[] = []; while (clausesWritten < numClauses) { + let defaultClausesSkipped = 0; for (let i = clausesWritten; i < numClauses; i++) { const clause = caseBlock.clauses[i]; if (clause.kind === SyntaxKind.CaseClause) { @@ -1653,6 +1709,9 @@ namespace ts { ) ); } + else { + defaultClausesSkipped++; + } } if (pendingClauses.length) { @@ -1660,6 +1719,10 @@ namespace ts { clausesWritten += pendingClauses.length; pendingClauses = []; } + if (defaultClausesSkipped > 0) { + clausesWritten += defaultClausesSkipped; + defaultClausesSkipped = 0; + } } if (defaultClauseIndex >= 0) { @@ -1772,10 +1835,6 @@ namespace ts { beginExceptionBlock(); transformAndEmitEmbeddedStatement(node.tryBlock); if (node.catchClause) { - if (!renamedCatchVariables) { - renamedCatchVariables = {}; - } - beginCatchBlock(node.catchClause.variableDeclaration); transformAndEmitEmbeddedStatement(node.catchClause.block); } @@ -1844,17 +1903,11 @@ namespace ts { function cacheExpression(node: Expression): Identifier { let temp: Identifier; - if (isIdentifier(node)) { - if (nodeIsSynthesized(node) || isGeneratedIdentifier(node)) { - return node; - } - - temp = createUniqueName(node.text); - } - else { - temp = createTempVariable(hoistVariableDeclaration); + if (isGeneratedIdentifier(node)) { + return node; } + temp = createTempVariable(hoistVariableDeclaration); emitAssignment(temp, node, /*location*/ node); return temp; } @@ -1862,7 +1915,7 @@ namespace ts { function declareLocal(name?: string): Identifier { const temp = name ? createUniqueName(name) - : createTempVariable(hoistVariableDeclaration); + : createTempVariable(/*recordTempVariable*/ undefined); hoistVariableDeclaration(temp); return temp; } @@ -1983,7 +2036,7 @@ namespace ts { startLabel, endLabel }); - emitWorker(OpCode.Nop); + emitNop(); return endLabel; } @@ -1996,7 +2049,7 @@ namespace ts { Debug.assert(peekBlockKind() === CodeBlockKind.Exception); const text = (variable.name).text; - const name = createUniqueName(text); + const name = declareLocal(text); if (!renamedCatchVariables) { renamedCatchVariables = {}; @@ -2019,8 +2072,8 @@ namespace ts { exception.catchVariable = name; exception.catchLabel = catchLabel; - emitAssignment(name, createPropertyAccess(state, "error")); - emitWorker(OpCode.Nop); + emitAssignment(name, createCall(createPropertyAccess(state, "sent"), /*typeArguments*/ undefined, [])); + emitNop(); } /** @@ -2056,6 +2109,7 @@ namespace ts { } markLabel(exception.endLabel); + emitNop(); exception.state = ExceptionBlockState.Done; } @@ -2352,6 +2406,13 @@ namespace ts { return createCall(createPropertyAccess(state, "sent"), /*typeArguments*/ undefined, [], location); } + /** + * Emits an empty instruction. + */ + function emitNop() { + emitWorker(OpCode.Nop); + } + /** * Emits a Statement. * @@ -2362,7 +2423,7 @@ namespace ts { emitWorker(OpCode.Statement, [node]); } else { - emitWorker(OpCode.Nop); + emitNop(); } } @@ -2487,18 +2548,24 @@ namespace ts { currentExceptionBlock = undefined; withBlockStack = undefined; + const buildResult = buildStatements(); return createCall( createIdentifier("__generator"), /*typeArguments*/ undefined, - [createFunctionExpression( - /*asteriskToken*/ undefined, - /*name*/ undefined, - /*typeParameters*/ undefined, - [createParameter(state)], - /*type*/ undefined, - createBlock( - buildStatements() - ) + [setNodeEmitFlags( + createFunctionExpression( + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, + [createParameter(state)], + /*type*/ undefined, + createBlock( + buildResult, + /*location*/ undefined, + /*multiLine*/ buildResult.length > 0 + ) + ), + NodeEmitFlags.ReuseTempVariableScope )] ); } @@ -2521,6 +2588,7 @@ namespace ts { if (clauses) { const labelExpression = createPropertyAccess(state, "label"); const switchStatement = createSwitch(labelExpression, createCaseBlock(clauses)); + switchStatement.startsOnNewLine = true; return [switchStatement]; } @@ -2552,6 +2620,7 @@ namespace ts { function flushFinalLabel(operationIndex: number): void { if (!lastOperationWasCompletion) { tryEnterLabel(operationIndex); + withBlockStack = undefined; writeReturn(/*expression*/ undefined, /*operationLocation*/ undefined); } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 25bbeff92b7..60ebb2d5d6b 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -359,6 +359,8 @@ namespace ts { // Markers FirstAssignment = EqualsToken, LastAssignment = CaretEqualsToken, + FirstCompoundAssignment = PlusEqualsToken, + LastCompoundAssignment = CaretEqualsToken, FirstReservedWord = BreakKeyword, LastReservedWord = WithKeyword, FirstKeyword = BreakKeyword, @@ -2987,7 +2989,7 @@ namespace ts { ContainsBlockScopedBinding = 1 << 20, ContainsBindingPattern = 1 << 21, ContainsYield = 1 << 22, - ContainsHoistedDeclaration = 1 << 23, + ContainsHoistedDeclarationOrCompletion = 1 << 23, HasComputedFlags = 1 << 29, // Transform flags have been computed. @@ -3002,13 +3004,13 @@ namespace ts { // Scope Exclusions // - Bitmasks that exclude flags from propagating out of a specific context // into the subtree flags of their container. - NodeExcludes = TypeScript | Jsx | ES7 | ES6 | DestructuringAssignment | HasComputedFlags, - ArrowFunctionExcludes = NodeExcludes | ContainsDecorators | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsParameterPropertyAssignments | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclaration, - FunctionExcludes = NodeExcludes | ContainsDecorators | ContainsDefaultValueAssignments | ContainsCapturedLexicalThis | ContainsLexicalThis | ContainsParameterPropertyAssignments | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclaration, - ConstructorExcludes = NodeExcludes | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclaration, - MethodOrAccessorExcludes = NodeExcludes | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclaration, + NodeExcludes = TypeScript | Jsx | ES7 | ES6 | DestructuringAssignment | Generator | HasComputedFlags, + ArrowFunctionExcludes = NodeExcludes | ContainsDecorators | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsParameterPropertyAssignments | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion, + FunctionExcludes = NodeExcludes | ContainsDecorators | ContainsDefaultValueAssignments | ContainsCapturedLexicalThis | ContainsLexicalThis | ContainsParameterPropertyAssignments | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion, + ConstructorExcludes = NodeExcludes | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion, + MethodOrAccessorExcludes = NodeExcludes | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion, ClassExcludes = NodeExcludes | ContainsDecorators | ContainsPropertyInitializer | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsComputedPropertyName | ContainsParameterPropertyAssignments | ContainsLexicalThisInComputedPropertyName, - ModuleExcludes = NodeExcludes | ContainsDecorators | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsHoistedDeclaration, + ModuleExcludes = NodeExcludes | ContainsDecorators | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsHoistedDeclarationOrCompletion, TypeExcludes = ~ContainsTypeScript, ObjectLiteralExcludes = NodeExcludes | ContainsDecorators | ContainsComputedPropertyName | ContainsLexicalThisInComputedPropertyName, ArrayLiteralOrCallOrNewExcludes = NodeExcludes | ContainsSpreadElementExpression, @@ -3047,13 +3049,14 @@ namespace ts { LocalName = 1 << 18, // Ensure an export prefix is not added for an identifier that points to an exported declaration. Indented = 1 << 19, // Adds an explicit extra indentation level for class and function bodies when printing (used to match old emitter). AsyncFunctionBody = 1 << 20, + ReuseTempVariableScope = 1 << 21, // Reuse the existing temp variable scope during emit. // SourceMap Specialization. // TODO(rbuckton): These should be removed once source maps are aligned with the old // emitter and new baselines are taken. This exists solely to // align with the old emitter. - SourceMapEmitOpenBraceAsToken = 1 << 21, // Emits the open brace of a block function body as a source mapped token. - SourceMapAdjustRestParameterLoop = 1 << 22, // Emits adjusted source map positions for a ForStatement generated when transforming a rest parameter for ES5/3. + SourceMapEmitOpenBraceAsToken = 1 << 22, // Emits the open brace of a block function body as a source mapped token. + SourceMapAdjustRestParameterLoop = 1 << 23, // Emits adjusted source map positions for a ForStatement generated when transforming a rest parameter for ES5/3. } /** Additional context provided to `visitEachChild` */ diff --git a/tests/baselines/reference/es5-asyncFunction.js b/tests/baselines/reference/es5-asyncFunction.js new file mode 100644 index 00000000000..28197f55bae --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunction.js @@ -0,0 +1,86 @@ +//// [es5-asyncFunction.ts] +declare var x; + +async function empty() { +} + +async function singleAwait() { + await x; +} + +//// [es5-asyncFunction.js] +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments)).next()); + }); +}; +var __generator = (this && this.__generator) || function (body) { + var _ = { label: 0, sent: function() { if (sent[0] === 1 /*throw*/) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent; + function step(op) { + if (_.flag) throw new TypeError("Generator is already executing."); + while (true) { + if (_.done) switch (op[0]) { + case 0 /*next*/: return { value: void 0, done: true }; + case 1 /*throw*/: case 6 /*catch*/: throw op[1]; + case 2 /*return*/: return { value: op[1], done: true }; + } + try { + switch (_.flag = true, op[0]) { + case 0 /*next*/: case 1 /*throw*/: sent = op; break; + case 4 /*yield*/: return _.label++, { value: op[1], done: false }; + case 7 /*endfinally*/: op = _.stack.pop(), _.trys.pop(); continue; + default: + var r = _.trys.length > 0 && _.trys[_.trys.length - 1]; + if (!r && (op[0] === 1 /*throw*/ || op[0] === 6 /*catch*/ || op[0] === 2 /*return*/)) { + _.done = true; + continue; + } + if (op[0] === 3 /*break*/ && (!r || (op[1] > r[0] && op[1] < r[3]))) { + _.label = op[1]; + } + else if (op[0] === 6 /*catch*/ && r && _.label < r[1]) { + _.label = r[1], sent = op; + } + else if (r && _.label < r[2]) { + _.label = r[2], _.stack.push(op); + } + else { + if (r[2]) _.stack.pop(); + _.trys.pop(); + continue; + } + } + op = body(_); + } + catch (e) { op = [6 /*catch*/, e]; } + finally { _.flag = false, sent = void 0; } + } + } + return { + next: function (v) { return step([0 /*next*/, v]); }, + "throw": function (v) { return step([1 /*throw*/, v]); }, + "return": function (v) { return step([2 /*return*/, v]); } + }; +}; +function empty() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + return [2 /*return*/]; + }); + }); +} +function singleAwait() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunction.symbols b/tests/baselines/reference/es5-asyncFunction.symbols new file mode 100644 index 00000000000..9a79e235090 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunction.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/es5-asyncFunction.ts === +declare var x; +>x : Symbol(x, Decl(es5-asyncFunction.ts, 0, 11)) + +async function empty() { +>empty : Symbol(empty, Decl(es5-asyncFunction.ts, 0, 14)) +} + +async function singleAwait() { +>singleAwait : Symbol(singleAwait, Decl(es5-asyncFunction.ts, 3, 1)) + + await x; +>x : Symbol(x, Decl(es5-asyncFunction.ts, 0, 11)) +} diff --git a/tests/baselines/reference/es5-asyncFunction.types b/tests/baselines/reference/es5-asyncFunction.types new file mode 100644 index 00000000000..71700db7c30 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunction.types @@ -0,0 +1,15 @@ +=== tests/cases/compiler/es5-asyncFunction.ts === +declare var x; +>x : any + +async function empty() { +>empty : () => Promise +} + +async function singleAwait() { +>singleAwait : () => Promise + + await x; +>await x : any +>x : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionArrayLiterals.js b/tests/baselines/reference/es5-asyncFunctionArrayLiterals.js new file mode 100644 index 00000000000..936e530ee2b --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionArrayLiterals.js @@ -0,0 +1,150 @@ +//// [es5-asyncFunctionArrayLiterals.ts] +declare var x, y, z, a; + +async function arrayLiteral0() { + x = [await y, z]; +} + +async function arrayLiteral1() { + x = [y, await z]; +} + +async function arrayLiteral2() { + x = [...(await y), z]; +} + +async function arrayLiteral3() { + x = [...y, await z]; +} + +async function arrayLiteral4() { + x = [await y, ...z]; +} + +async function arrayLiteral5() { + x = [y, ...(await z)]; +} + +async function arrayLiteral6() { + x = [y, await z, a]; +} + +async function arrayLiteral7() { + x = [await y, z, await a]; +} + +//// [es5-asyncFunctionArrayLiterals.js] +function arrayLiteral0() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: return [4 /*yield*/, y]; + case 1: + x = [_b.sent(), z]; + return [2 /*return*/]; + } + }); + }); +} +function arrayLiteral1() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = [y]; + return [4 /*yield*/, z]; + case 1: + x = _a.concat([_b.sent()]); + return [2 /*return*/]; + } + }); + }); +} +function arrayLiteral2() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, y]; + case 1: + x = (_a.sent()).concat([z]); + return [2 /*return*/]; + } + }); + }); +} +function arrayLiteral3() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c, _d; + return __generator(function (_e) { + switch (_e.label) { + case 0: + _b = (_a = y).concat; + return [4 /*yield*/, z]; + case 1: + x = _b.apply(_a, [[_e.sent()]]); + return [2 /*return*/]; + } + }); + }); +} +function arrayLiteral4() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: return [4 /*yield*/, y]; + case 1: + x = [_b.sent()].concat(z); + return [2 /*return*/]; + } + }); + }); +} +function arrayLiteral5() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _b = (_a = [y]).concat; + return [4 /*yield*/, z]; + case 1: + x = _b.apply(_a, [(_d.sent())]); + return [2 /*return*/]; + } + }); + }); +} +function arrayLiteral6() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = [y]; + return [4 /*yield*/, z]; + case 1: + x = _a.concat([_b.sent(), a]); + return [2 /*return*/]; + } + }); + }); +} +function arrayLiteral7() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: return [4 /*yield*/, y]; + case 1: + _a = [_b.sent(), z]; + return [4 /*yield*/, a]; + case 2: + x = _a.concat([_b.sent()]); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionArrayLiterals.symbols b/tests/baselines/reference/es5-asyncFunctionArrayLiterals.symbols new file mode 100644 index 00000000000..3bdfb070d1b --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionArrayLiterals.symbols @@ -0,0 +1,80 @@ +=== tests/cases/compiler/es5-asyncFunctionArrayLiterals.ts === +declare var x, y, z, a; +>x : Symbol(x, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 20)) + +async function arrayLiteral0() { +>arrayLiteral0 : Symbol(arrayLiteral0, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 23)) + + x = [await y, z]; +>x : Symbol(x, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 17)) +} + +async function arrayLiteral1() { +>arrayLiteral1 : Symbol(arrayLiteral1, Decl(es5-asyncFunctionArrayLiterals.ts, 4, 1)) + + x = [y, await z]; +>x : Symbol(x, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 17)) +} + +async function arrayLiteral2() { +>arrayLiteral2 : Symbol(arrayLiteral2, Decl(es5-asyncFunctionArrayLiterals.ts, 8, 1)) + + x = [...(await y), z]; +>x : Symbol(x, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 17)) +} + +async function arrayLiteral3() { +>arrayLiteral3 : Symbol(arrayLiteral3, Decl(es5-asyncFunctionArrayLiterals.ts, 12, 1)) + + x = [...y, await z]; +>x : Symbol(x, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 17)) +} + +async function arrayLiteral4() { +>arrayLiteral4 : Symbol(arrayLiteral4, Decl(es5-asyncFunctionArrayLiterals.ts, 16, 1)) + + x = [await y, ...z]; +>x : Symbol(x, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 17)) +} + +async function arrayLiteral5() { +>arrayLiteral5 : Symbol(arrayLiteral5, Decl(es5-asyncFunctionArrayLiterals.ts, 20, 1)) + + x = [y, ...(await z)]; +>x : Symbol(x, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 17)) +} + +async function arrayLiteral6() { +>arrayLiteral6 : Symbol(arrayLiteral6, Decl(es5-asyncFunctionArrayLiterals.ts, 24, 1)) + + x = [y, await z, a]; +>x : Symbol(x, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 20)) +} + +async function arrayLiteral7() { +>arrayLiteral7 : Symbol(arrayLiteral7, Decl(es5-asyncFunctionArrayLiterals.ts, 28, 1)) + + x = [await y, z, await a]; +>x : Symbol(x, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionArrayLiterals.ts, 0, 20)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionArrayLiterals.types b/tests/baselines/reference/es5-asyncFunctionArrayLiterals.types new file mode 100644 index 00000000000..80b4e095c9d --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionArrayLiterals.types @@ -0,0 +1,111 @@ +=== tests/cases/compiler/es5-asyncFunctionArrayLiterals.ts === +declare var x, y, z, a; +>x : any +>y : any +>z : any +>a : any + +async function arrayLiteral0() { +>arrayLiteral0 : () => Promise + + x = [await y, z]; +>x = [await y, z] : any[] +>x : any +>[await y, z] : any[] +>await y : any +>y : any +>z : any +} + +async function arrayLiteral1() { +>arrayLiteral1 : () => Promise + + x = [y, await z]; +>x = [y, await z] : any[] +>x : any +>[y, await z] : any[] +>y : any +>await z : any +>z : any +} + +async function arrayLiteral2() { +>arrayLiteral2 : () => Promise + + x = [...(await y), z]; +>x = [...(await y), z] : any[] +>x : any +>[...(await y), z] : any[] +>...(await y) : any +>(await y) : any +>await y : any +>y : any +>z : any +} + +async function arrayLiteral3() { +>arrayLiteral3 : () => Promise + + x = [...y, await z]; +>x = [...y, await z] : any[] +>x : any +>[...y, await z] : any[] +>...y : any +>y : any +>await z : any +>z : any +} + +async function arrayLiteral4() { +>arrayLiteral4 : () => Promise + + x = [await y, ...z]; +>x = [await y, ...z] : any[] +>x : any +>[await y, ...z] : any[] +>await y : any +>y : any +>...z : any +>z : any +} + +async function arrayLiteral5() { +>arrayLiteral5 : () => Promise + + x = [y, ...(await z)]; +>x = [y, ...(await z)] : any[] +>x : any +>[y, ...(await z)] : any[] +>y : any +>...(await z) : any +>(await z) : any +>await z : any +>z : any +} + +async function arrayLiteral6() { +>arrayLiteral6 : () => Promise + + x = [y, await z, a]; +>x = [y, await z, a] : any[] +>x : any +>[y, await z, a] : any[] +>y : any +>await z : any +>z : any +>a : any +} + +async function arrayLiteral7() { +>arrayLiteral7 : () => Promise + + x = [await y, z, await a]; +>x = [await y, z, await a] : any[] +>x : any +>[await y, z, await a] : any[] +>await y : any +>y : any +>z : any +>await a : any +>a : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.js b/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.js new file mode 100644 index 00000000000..936ca033954 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.js @@ -0,0 +1,561 @@ +//// [es5-asyncFunctionBinaryExpressions.ts] +declare var x, y, z, a, b, c; + +async function binaryPlus0() { + (await x) + y; +} + +async function binaryPlus1() { + x + await y; +} + +async function binaryLogicalAnd0() { + (await x) && y; +} + +async function binaryLogicalAnd1() { + x && await y; +} + +async function binaryAssignment0() { + x = await y; +} + +async function binaryAssignment1() { + x.a = await y; +} + +async function binaryAssignment2() { + x.a.b = await y; +} + +async function binaryAssignment3() { + x[z] = await y; +} + +async function binaryAssignment4() { + x[z].b = await y; +} + +async function binaryAssignment5() { + x.a[z] = await y; +} + +async function binaryAssignment6() { + (await x).a = y; +} + +async function binaryAssignment7() { + (await x.a).b = y; +} + +async function binaryAssignment8() { + (await x)[z] = y; +} + +async function binaryAssignment9() { + x[await z] = y; +} + +async function binaryAssignment10() { + x[await z].b = y; +} + +async function binaryAssignment11() { + (await x[z]).b = y; +} + +async function binaryAssignment12() { + x.a[await z] = y; +} + +async function binaryAssignment13() { + (await x.a)[z] = y; +} + +async function binaryCompoundAssignment0() { + x += await y; +} + +async function binaryCompoundAssignment1() { + x.a += await y; +} + +async function binaryCompoundAssignment2() { + x[a] += await y; +} + +async function binaryCompoundAssignment3() { + (await x).a += y; +} + +async function binaryCompoundAssignment4() { + (await x)[a] += y; +} + +async function binaryCompoundAssignment5() { + x[await a] += y; +} + +async function binaryCompoundAssignment6() { + (await x).a += await y; +} + +async function binaryCompoundAssignment7() { + (await x)[a] += await y; +} + +async function binaryCompoundAssignment8() { + x[await a] += await y; +} + +async function binaryExponentiation() { + (await x) ** y; + x ** await y; +} + +async function binaryComma0() { + return (await x), y; +} + +async function binaryComma1(): Promise { + return x, await y; +} + +//// [es5-asyncFunctionBinaryExpressions.js] +function binaryPlus0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + (_a.sent()) + y; + return [2 /*return*/]; + } + }); + }); +} +function binaryPlus1() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, y]; + case 1: + _a + (_b.sent()); + return [2 /*return*/]; + } + }); + }); +} +function binaryLogicalAnd0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + (_a.sent()) && y; + return [2 /*return*/]; + } + }); + }); +} +function binaryLogicalAnd1() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + if (!_a) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a = (_b.sent()); + _b.label = 2; + case 2: + _a; + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, y]; + case 1: + x = _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment1() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, y]; + case 1: + _a.a = _b.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment2() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x.a; + return [4 /*yield*/, y]; + case 1: + _a.b = _b.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment3() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = x; + _b = z; + return [4 /*yield*/, y]; + case 1: + _a[_b] = _c.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment4() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x[z]; + return [4 /*yield*/, y]; + case 1: + _a.b = _b.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment5() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = x.a; + _b = z; + return [4 /*yield*/, y]; + case 1: + _a[_b] = _c.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment6() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + (_a.sent()).a = y; + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment7() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x.a]; + case 1: + (_a.sent()).b = y; + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment8() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + (_a.sent())[z] = y; + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment9() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, z]; + case 1: + _a[_b.sent()] = y; + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment10() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, z]; + case 1: + _a[_b.sent()].b = y; + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment11() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x[z]]; + case 1: + (_a.sent()).b = y; + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment12() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x.a; + return [4 /*yield*/, z]; + case 1: + _a[_b.sent()] = y; + return [2 /*return*/]; + } + }); + }); +} +function binaryAssignment13() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x.a]; + case 1: + (_a.sent())[z] = y; + return [2 /*return*/]; + } + }); + }); +} +function binaryCompoundAssignment0() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, y]; + case 1: + x = _a + _b.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryCompoundAssignment1() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = x; + _b = _a.a; + return [4 /*yield*/, y]; + case 1: + _a.a = _b + _c.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryCompoundAssignment2() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _a = x; + _b = a; + _c = _a[_b]; + return [4 /*yield*/, y]; + case 1: + _a[_b] = _c + _d.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryCompoundAssignment3() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + (_a.sent()).a += y; + return [2 /*return*/]; + } + }); + }); +} +function binaryCompoundAssignment4() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + (_a.sent())[a] += y; + return [2 /*return*/]; + } + }); + }); +} +function binaryCompoundAssignment5() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, a]; + case 1: + _a[_b.sent()] += y; + return [2 /*return*/]; + } + }); + }); +} +function binaryCompoundAssignment6() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a = (_c.sent()); + _b = _a.a; + return [4 /*yield*/, y]; + case 2: + _a.a = _b + _c.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryCompoundAssignment7() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a = (_d.sent()); + _b = a; + _c = _a[_b]; + return [4 /*yield*/, y]; + case 2: + _a[_b] = _c + _d.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryCompoundAssignment8() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _a = x; + return [4 /*yield*/, a]; + case 1: + _b = _d.sent(); + _c = _a[_b]; + return [4 /*yield*/, y]; + case 2: + _a[_b] = _c + _d.sent(); + return [2 /*return*/]; + } + }); + }); +} +function binaryExponentiation() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c, _d, _e, _f; + return __generator(function (_g) { + switch (_g.label) { + case 0: + _b = (_a = Math).pow; + return [4 /*yield*/, x]; + case 1: + _b.apply(_a, [(_g.sent()), y]); + _e = (_d = Math).pow; + _f = [x]; + return [4 /*yield*/, y]; + case 2: + _e.apply(_d, _f.concat([_g.sent()])); + return [2 /*return*/]; + } + }); + }); +} +function binaryComma0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: return [2 /*return*/, ((_a.sent()), y)]; + } + }); + }); +} +function binaryComma1() { + return __awaiter(this, void 0, Promise, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + x; + return [4 /*yield*/, y]; + case 1: return [2 /*return*/, _a.sent()]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.symbols b/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.symbols new file mode 100644 index 00000000000..6c6a1820717 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.symbols @@ -0,0 +1,267 @@ +=== tests/cases/compiler/es5-asyncFunctionBinaryExpressions.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 26)) + +async function binaryPlus0() { +>binaryPlus0 : Symbol(binaryPlus0, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 29)) + + (await x) + y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryPlus1() { +>binaryPlus1 : Symbol(binaryPlus1, Decl(es5-asyncFunctionBinaryExpressions.ts, 4, 1)) + + x + await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryLogicalAnd0() { +>binaryLogicalAnd0 : Symbol(binaryLogicalAnd0, Decl(es5-asyncFunctionBinaryExpressions.ts, 8, 1)) + + (await x) && y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryLogicalAnd1() { +>binaryLogicalAnd1 : Symbol(binaryLogicalAnd1, Decl(es5-asyncFunctionBinaryExpressions.ts, 12, 1)) + + x && await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment0() { +>binaryAssignment0 : Symbol(binaryAssignment0, Decl(es5-asyncFunctionBinaryExpressions.ts, 16, 1)) + + x = await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment1() { +>binaryAssignment1 : Symbol(binaryAssignment1, Decl(es5-asyncFunctionBinaryExpressions.ts, 20, 1)) + + x.a = await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment2() { +>binaryAssignment2 : Symbol(binaryAssignment2, Decl(es5-asyncFunctionBinaryExpressions.ts, 24, 1)) + + x.a.b = await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment3() { +>binaryAssignment3 : Symbol(binaryAssignment3, Decl(es5-asyncFunctionBinaryExpressions.ts, 28, 1)) + + x[z] = await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>z : Symbol(z, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 17)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment4() { +>binaryAssignment4 : Symbol(binaryAssignment4, Decl(es5-asyncFunctionBinaryExpressions.ts, 32, 1)) + + x[z].b = await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>z : Symbol(z, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 17)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment5() { +>binaryAssignment5 : Symbol(binaryAssignment5, Decl(es5-asyncFunctionBinaryExpressions.ts, 36, 1)) + + x.a[z] = await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>z : Symbol(z, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 17)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment6() { +>binaryAssignment6 : Symbol(binaryAssignment6, Decl(es5-asyncFunctionBinaryExpressions.ts, 40, 1)) + + (await x).a = y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment7() { +>binaryAssignment7 : Symbol(binaryAssignment7, Decl(es5-asyncFunctionBinaryExpressions.ts, 44, 1)) + + (await x.a).b = y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment8() { +>binaryAssignment8 : Symbol(binaryAssignment8, Decl(es5-asyncFunctionBinaryExpressions.ts, 48, 1)) + + (await x)[z] = y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>z : Symbol(z, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 17)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment9() { +>binaryAssignment9 : Symbol(binaryAssignment9, Decl(es5-asyncFunctionBinaryExpressions.ts, 52, 1)) + + x[await z] = y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>z : Symbol(z, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 17)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment10() { +>binaryAssignment10 : Symbol(binaryAssignment10, Decl(es5-asyncFunctionBinaryExpressions.ts, 56, 1)) + + x[await z].b = y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>z : Symbol(z, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 17)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment11() { +>binaryAssignment11 : Symbol(binaryAssignment11, Decl(es5-asyncFunctionBinaryExpressions.ts, 60, 1)) + + (await x[z]).b = y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>z : Symbol(z, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 17)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment12() { +>binaryAssignment12 : Symbol(binaryAssignment12, Decl(es5-asyncFunctionBinaryExpressions.ts, 64, 1)) + + x.a[await z] = y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>z : Symbol(z, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 17)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryAssignment13() { +>binaryAssignment13 : Symbol(binaryAssignment13, Decl(es5-asyncFunctionBinaryExpressions.ts, 68, 1)) + + (await x.a)[z] = y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>z : Symbol(z, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 17)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryCompoundAssignment0() { +>binaryCompoundAssignment0 : Symbol(binaryCompoundAssignment0, Decl(es5-asyncFunctionBinaryExpressions.ts, 72, 1)) + + x += await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryCompoundAssignment1() { +>binaryCompoundAssignment1 : Symbol(binaryCompoundAssignment1, Decl(es5-asyncFunctionBinaryExpressions.ts, 76, 1)) + + x.a += await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryCompoundAssignment2() { +>binaryCompoundAssignment2 : Symbol(binaryCompoundAssignment2, Decl(es5-asyncFunctionBinaryExpressions.ts, 80, 1)) + + x[a] += await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryCompoundAssignment3() { +>binaryCompoundAssignment3 : Symbol(binaryCompoundAssignment3, Decl(es5-asyncFunctionBinaryExpressions.ts, 84, 1)) + + (await x).a += y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryCompoundAssignment4() { +>binaryCompoundAssignment4 : Symbol(binaryCompoundAssignment4, Decl(es5-asyncFunctionBinaryExpressions.ts, 88, 1)) + + (await x)[a] += y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryCompoundAssignment5() { +>binaryCompoundAssignment5 : Symbol(binaryCompoundAssignment5, Decl(es5-asyncFunctionBinaryExpressions.ts, 92, 1)) + + x[await a] += y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryCompoundAssignment6() { +>binaryCompoundAssignment6 : Symbol(binaryCompoundAssignment6, Decl(es5-asyncFunctionBinaryExpressions.ts, 96, 1)) + + (await x).a += await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryCompoundAssignment7() { +>binaryCompoundAssignment7 : Symbol(binaryCompoundAssignment7, Decl(es5-asyncFunctionBinaryExpressions.ts, 100, 1)) + + (await x)[a] += await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryCompoundAssignment8() { +>binaryCompoundAssignment8 : Symbol(binaryCompoundAssignment8, Decl(es5-asyncFunctionBinaryExpressions.ts, 104, 1)) + + x[await a] += await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryExponentiation() { +>binaryExponentiation : Symbol(binaryExponentiation, Decl(es5-asyncFunctionBinaryExpressions.ts, 108, 1)) + + (await x) ** y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) + + x ** await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryComma0() { +>binaryComma0 : Symbol(binaryComma0, Decl(es5-asyncFunctionBinaryExpressions.ts, 113, 1)) + + return (await x), y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} + +async function binaryComma1(): Promise { +>binaryComma1 : Symbol(binaryComma1, Decl(es5-asyncFunctionBinaryExpressions.ts, 117, 1)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + return x, await y; +>x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 14)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.types b/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.types new file mode 100644 index 00000000000..54afaee22c5 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.types @@ -0,0 +1,389 @@ +=== tests/cases/compiler/es5-asyncFunctionBinaryExpressions.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function binaryPlus0() { +>binaryPlus0 : () => Promise + + (await x) + y; +>(await x) + y : any +>(await x) : any +>await x : any +>x : any +>y : any +} + +async function binaryPlus1() { +>binaryPlus1 : () => Promise + + x + await y; +>x + await y : any +>x : any +>await y : any +>y : any +} + +async function binaryLogicalAnd0() { +>binaryLogicalAnd0 : () => Promise + + (await x) && y; +>(await x) && y : any +>(await x) : any +>await x : any +>x : any +>y : any +} + +async function binaryLogicalAnd1() { +>binaryLogicalAnd1 : () => Promise + + x && await y; +>x && await y : any +>x : any +>await y : any +>y : any +} + +async function binaryAssignment0() { +>binaryAssignment0 : () => Promise + + x = await y; +>x = await y : any +>x : any +>await y : any +>y : any +} + +async function binaryAssignment1() { +>binaryAssignment1 : () => Promise + + x.a = await y; +>x.a = await y : any +>x.a : any +>x : any +>a : any +>await y : any +>y : any +} + +async function binaryAssignment2() { +>binaryAssignment2 : () => Promise + + x.a.b = await y; +>x.a.b = await y : any +>x.a.b : any +>x.a : any +>x : any +>a : any +>b : any +>await y : any +>y : any +} + +async function binaryAssignment3() { +>binaryAssignment3 : () => Promise + + x[z] = await y; +>x[z] = await y : any +>x[z] : any +>x : any +>z : any +>await y : any +>y : any +} + +async function binaryAssignment4() { +>binaryAssignment4 : () => Promise + + x[z].b = await y; +>x[z].b = await y : any +>x[z].b : any +>x[z] : any +>x : any +>z : any +>b : any +>await y : any +>y : any +} + +async function binaryAssignment5() { +>binaryAssignment5 : () => Promise + + x.a[z] = await y; +>x.a[z] = await y : any +>x.a[z] : any +>x.a : any +>x : any +>a : any +>z : any +>await y : any +>y : any +} + +async function binaryAssignment6() { +>binaryAssignment6 : () => Promise + + (await x).a = y; +>(await x).a = y : any +>(await x).a : any +>(await x) : any +>await x : any +>x : any +>a : any +>y : any +} + +async function binaryAssignment7() { +>binaryAssignment7 : () => Promise + + (await x.a).b = y; +>(await x.a).b = y : any +>(await x.a).b : any +>(await x.a) : any +>await x.a : any +>x.a : any +>x : any +>a : any +>b : any +>y : any +} + +async function binaryAssignment8() { +>binaryAssignment8 : () => Promise + + (await x)[z] = y; +>(await x)[z] = y : any +>(await x)[z] : any +>(await x) : any +>await x : any +>x : any +>z : any +>y : any +} + +async function binaryAssignment9() { +>binaryAssignment9 : () => Promise + + x[await z] = y; +>x[await z] = y : any +>x[await z] : any +>x : any +>await z : any +>z : any +>y : any +} + +async function binaryAssignment10() { +>binaryAssignment10 : () => Promise + + x[await z].b = y; +>x[await z].b = y : any +>x[await z].b : any +>x[await z] : any +>x : any +>await z : any +>z : any +>b : any +>y : any +} + +async function binaryAssignment11() { +>binaryAssignment11 : () => Promise + + (await x[z]).b = y; +>(await x[z]).b = y : any +>(await x[z]).b : any +>(await x[z]) : any +>await x[z] : any +>x[z] : any +>x : any +>z : any +>b : any +>y : any +} + +async function binaryAssignment12() { +>binaryAssignment12 : () => Promise + + x.a[await z] = y; +>x.a[await z] = y : any +>x.a[await z] : any +>x.a : any +>x : any +>a : any +>await z : any +>z : any +>y : any +} + +async function binaryAssignment13() { +>binaryAssignment13 : () => Promise + + (await x.a)[z] = y; +>(await x.a)[z] = y : any +>(await x.a)[z] : any +>(await x.a) : any +>await x.a : any +>x.a : any +>x : any +>a : any +>z : any +>y : any +} + +async function binaryCompoundAssignment0() { +>binaryCompoundAssignment0 : () => Promise + + x += await y; +>x += await y : any +>x : any +>await y : any +>y : any +} + +async function binaryCompoundAssignment1() { +>binaryCompoundAssignment1 : () => Promise + + x.a += await y; +>x.a += await y : any +>x.a : any +>x : any +>a : any +>await y : any +>y : any +} + +async function binaryCompoundAssignment2() { +>binaryCompoundAssignment2 : () => Promise + + x[a] += await y; +>x[a] += await y : any +>x[a] : any +>x : any +>a : any +>await y : any +>y : any +} + +async function binaryCompoundAssignment3() { +>binaryCompoundAssignment3 : () => Promise + + (await x).a += y; +>(await x).a += y : any +>(await x).a : any +>(await x) : any +>await x : any +>x : any +>a : any +>y : any +} + +async function binaryCompoundAssignment4() { +>binaryCompoundAssignment4 : () => Promise + + (await x)[a] += y; +>(await x)[a] += y : any +>(await x)[a] : any +>(await x) : any +>await x : any +>x : any +>a : any +>y : any +} + +async function binaryCompoundAssignment5() { +>binaryCompoundAssignment5 : () => Promise + + x[await a] += y; +>x[await a] += y : any +>x[await a] : any +>x : any +>await a : any +>a : any +>y : any +} + +async function binaryCompoundAssignment6() { +>binaryCompoundAssignment6 : () => Promise + + (await x).a += await y; +>(await x).a += await y : any +>(await x).a : any +>(await x) : any +>await x : any +>x : any +>a : any +>await y : any +>y : any +} + +async function binaryCompoundAssignment7() { +>binaryCompoundAssignment7 : () => Promise + + (await x)[a] += await y; +>(await x)[a] += await y : any +>(await x)[a] : any +>(await x) : any +>await x : any +>x : any +>a : any +>await y : any +>y : any +} + +async function binaryCompoundAssignment8() { +>binaryCompoundAssignment8 : () => Promise + + x[await a] += await y; +>x[await a] += await y : any +>x[await a] : any +>x : any +>await a : any +>a : any +>await y : any +>y : any +} + +async function binaryExponentiation() { +>binaryExponentiation : () => Promise + + (await x) ** y; +>(await x) ** y : number +>(await x) : any +>await x : any +>x : any +>y : any + + x ** await y; +>x ** await y : number +>x : any +>await y : any +>y : any +} + +async function binaryComma0() { +>binaryComma0 : () => Promise + + return (await x), y; +>(await x), y : any +>(await x) : any +>await x : any +>x : any +>y : any +} + +async function binaryComma1(): Promise { +>binaryComma1 : () => Promise +>Promise : Promise + + return x, await y; +>x, await y : any +>x : any +>await y : any +>y : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionCallExpressions.js b/tests/baselines/reference/es5-asyncFunctionCallExpressions.js new file mode 100644 index 00000000000..8f0d17e7c14 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionCallExpressions.js @@ -0,0 +1,383 @@ +//// [es5-asyncFunctionCallExpressions.ts] +declare var x, y, z, a, b, c; + +async function callExpression0() { + await x(y, z); +} + +async function callExpression1() { + (await x)(y, z); +} + +async function callExpression2() { + x(await y, z); +} + +async function callExpression3() { + x(y, await z); +} + +async function callExpression4() { + await x(...y, z); +} + +async function callExpression5() { + (await x)(...y, z); +} + +async function callExpression6() { + x(...(await y), z); +} + +async function callExpression7() { + x(...y, await z); +} + +async function callExpression8() { + x(await y, ...z); +} + +async function callExpression9() { + x(y, ...(await z)); +} + +async function callExpression10() { + await x.a(y, z); +} + +async function callExpression11() { + (await x.a)(y, z); +} + +async function callExpression12() { + (await x).a(y, z); +} + +async function callExpression13() { + x.a(await y, z); +} + +async function callExpression14() { + x.a(y, await z); +} + +async function callExpression15() { + await x[a](y, z); +} + +async function callExpression16() { + (await x[a])(y, z); +} + +async function callExpression17() { + (await x)[a](y, z); +} + +async function callExpression18() { + x[await a](y, z); +} + +async function callExpression19() { + x[a](await y, z); +} + +async function callExpression20() { + x[a](y, await z); +} + + +//// [es5-asyncFunctionCallExpressions.js] +function callExpression0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x(y, z)]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function callExpression1() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + (_a.sent())(y, z); + return [2 /*return*/]; + } + }); + }); +} +function callExpression2() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = x; + return [4 /*yield*/, y]; + case 1: + _a.apply(void 0, [_c.sent(), z]); + return [2 /*return*/]; + } + }); + }); +} +function callExpression3() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = x; + _b = [y]; + return [4 /*yield*/, z]; + case 1: + _a.apply(void 0, _b.concat([_c.sent()])); + return [2 /*return*/]; + } + }); + }); +} +function callExpression4() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x.apply(void 0, y.concat([z]))]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function callExpression5() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + (_a.sent()).apply(void 0, y.concat([z])); + return [2 /*return*/]; + } + }); + }); +} +function callExpression6() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _b = (_a = x).apply; + _c = [void 0]; + return [4 /*yield*/, y]; + case 1: + _b.apply(_a, _c.concat([(_d.sent()).concat([z])])); + return [2 /*return*/]; + } + }); + }); +} +function callExpression7() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c, _d, _e, _f, _g; + return __generator(function (_h) { + switch (_h.label) { + case 0: + _b = (_a = x).apply; + _c = [void 0]; + _e = (_d = y).concat; + return [4 /*yield*/, z]; + case 1: + _b.apply(_a, _c.concat([_e.apply(_d, [[_h.sent()]])])); + return [2 /*return*/]; + } + }); + }); +} +function callExpression8() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c, _d; + return __generator(function (_e) { + switch (_e.label) { + case 0: + _b = (_a = x).apply; + _c = [void 0]; + return [4 /*yield*/, y]; + case 1: + _b.apply(_a, _c.concat([[_e.sent()].concat(z)])); + return [2 /*return*/]; + } + }); + }); +} +function callExpression9() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c, _d, _e, _f; + return __generator(function (_g) { + switch (_g.label) { + case 0: + _b = (_a = x).apply; + _c = [void 0]; + _e = (_d = [y]).concat; + return [4 /*yield*/, z]; + case 1: + _b.apply(_a, _c.concat([_e.apply(_d, [(_g.sent())])])); + return [2 /*return*/]; + } + }); + }); +} +function callExpression10() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x.a(y, z)]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function callExpression11() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x.a]; + case 1: + (_a.sent())(y, z); + return [2 /*return*/]; + } + }); + }); +} +function callExpression12() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + (_a.sent()).a(y, z); + return [2 /*return*/]; + } + }); + }); +} +function callExpression13() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _b = (_a = x).a; + return [4 /*yield*/, y]; + case 1: + _b.apply(_a, [_d.sent(), z]); + return [2 /*return*/]; + } + }); + }); +} +function callExpression14() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _b = (_a = x).a; + _c = [y]; + return [4 /*yield*/, z]; + case 1: + _b.apply(_a, _c.concat([_d.sent()])); + return [2 /*return*/]; + } + }); + }); +} +function callExpression15() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x[a](y, z)]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function callExpression16() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x[a]]; + case 1: + (_a.sent())(y, z); + return [2 /*return*/]; + } + }); + }); +} +function callExpression17() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + (_a.sent())[a](y, z); + return [2 /*return*/]; + } + }); + }); +} +function callExpression18() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, a]; + case 1: + _a[_b.sent()](y, z); + return [2 /*return*/]; + } + }); + }); +} +function callExpression19() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _b = (_a = x)[a]; + return [4 /*yield*/, y]; + case 1: + _b.apply(_a, [_d.sent(), z]); + return [2 /*return*/]; + } + }); + }); +} +function callExpression20() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _b = (_a = x)[a]; + _c = [y]; + return [4 /*yield*/, z]; + case 1: + _b.apply(_a, _c.concat([_d.sent()])); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionCallExpressions.symbols b/tests/baselines/reference/es5-asyncFunctionCallExpressions.symbols new file mode 100644 index 00000000000..4a73045b5f3 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionCallExpressions.symbols @@ -0,0 +1,204 @@ +=== tests/cases/compiler/es5-asyncFunctionCallExpressions.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionCallExpressions.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionCallExpressions.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionCallExpressions.ts, 0, 26)) + +async function callExpression0() { +>callExpression0 : Symbol(callExpression0, Decl(es5-asyncFunctionCallExpressions.ts, 0, 29)) + + await x(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression1() { +>callExpression1 : Symbol(callExpression1, Decl(es5-asyncFunctionCallExpressions.ts, 4, 1)) + + (await x)(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression2() { +>callExpression2 : Symbol(callExpression2, Decl(es5-asyncFunctionCallExpressions.ts, 8, 1)) + + x(await y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression3() { +>callExpression3 : Symbol(callExpression3, Decl(es5-asyncFunctionCallExpressions.ts, 12, 1)) + + x(y, await z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression4() { +>callExpression4 : Symbol(callExpression4, Decl(es5-asyncFunctionCallExpressions.ts, 16, 1)) + + await x(...y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression5() { +>callExpression5 : Symbol(callExpression5, Decl(es5-asyncFunctionCallExpressions.ts, 20, 1)) + + (await x)(...y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression6() { +>callExpression6 : Symbol(callExpression6, Decl(es5-asyncFunctionCallExpressions.ts, 24, 1)) + + x(...(await y), z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression7() { +>callExpression7 : Symbol(callExpression7, Decl(es5-asyncFunctionCallExpressions.ts, 28, 1)) + + x(...y, await z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression8() { +>callExpression8 : Symbol(callExpression8, Decl(es5-asyncFunctionCallExpressions.ts, 32, 1)) + + x(await y, ...z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression9() { +>callExpression9 : Symbol(callExpression9, Decl(es5-asyncFunctionCallExpressions.ts, 36, 1)) + + x(y, ...(await z)); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression10() { +>callExpression10 : Symbol(callExpression10, Decl(es5-asyncFunctionCallExpressions.ts, 40, 1)) + + await x.a(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression11() { +>callExpression11 : Symbol(callExpression11, Decl(es5-asyncFunctionCallExpressions.ts, 44, 1)) + + (await x.a)(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression12() { +>callExpression12 : Symbol(callExpression12, Decl(es5-asyncFunctionCallExpressions.ts, 48, 1)) + + (await x).a(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression13() { +>callExpression13 : Symbol(callExpression13, Decl(es5-asyncFunctionCallExpressions.ts, 52, 1)) + + x.a(await y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression14() { +>callExpression14 : Symbol(callExpression14, Decl(es5-asyncFunctionCallExpressions.ts, 56, 1)) + + x.a(y, await z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression15() { +>callExpression15 : Symbol(callExpression15, Decl(es5-asyncFunctionCallExpressions.ts, 60, 1)) + + await x[a](y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionCallExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression16() { +>callExpression16 : Symbol(callExpression16, Decl(es5-asyncFunctionCallExpressions.ts, 64, 1)) + + (await x[a])(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionCallExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression17() { +>callExpression17 : Symbol(callExpression17, Decl(es5-asyncFunctionCallExpressions.ts, 68, 1)) + + (await x)[a](y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionCallExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression18() { +>callExpression18 : Symbol(callExpression18, Decl(es5-asyncFunctionCallExpressions.ts, 72, 1)) + + x[await a](y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionCallExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression19() { +>callExpression19 : Symbol(callExpression19, Decl(es5-asyncFunctionCallExpressions.ts, 76, 1)) + + x[a](await y, z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionCallExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + +async function callExpression20() { +>callExpression20 : Symbol(callExpression20, Decl(es5-asyncFunctionCallExpressions.ts, 80, 1)) + + x[a](y, await z); +>x : Symbol(x, Decl(es5-asyncFunctionCallExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionCallExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionCallExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionCallExpressions.ts, 0, 17)) +} + diff --git a/tests/baselines/reference/es5-asyncFunctionCallExpressions.types b/tests/baselines/reference/es5-asyncFunctionCallExpressions.types new file mode 100644 index 00000000000..82207b218d2 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionCallExpressions.types @@ -0,0 +1,276 @@ +=== tests/cases/compiler/es5-asyncFunctionCallExpressions.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function callExpression0() { +>callExpression0 : () => Promise + + await x(y, z); +>await x(y, z) : any +>x(y, z) : any +>x : any +>y : any +>z : any +} + +async function callExpression1() { +>callExpression1 : () => Promise + + (await x)(y, z); +>(await x)(y, z) : any +>(await x) : any +>await x : any +>x : any +>y : any +>z : any +} + +async function callExpression2() { +>callExpression2 : () => Promise + + x(await y, z); +>x(await y, z) : any +>x : any +>await y : any +>y : any +>z : any +} + +async function callExpression3() { +>callExpression3 : () => Promise + + x(y, await z); +>x(y, await z) : any +>x : any +>y : any +>await z : any +>z : any +} + +async function callExpression4() { +>callExpression4 : () => Promise + + await x(...y, z); +>await x(...y, z) : any +>x(...y, z) : any +>x : any +>...y : any +>y : any +>z : any +} + +async function callExpression5() { +>callExpression5 : () => Promise + + (await x)(...y, z); +>(await x)(...y, z) : any +>(await x) : any +>await x : any +>x : any +>...y : any +>y : any +>z : any +} + +async function callExpression6() { +>callExpression6 : () => Promise + + x(...(await y), z); +>x(...(await y), z) : any +>x : any +>...(await y) : any +>(await y) : any +>await y : any +>y : any +>z : any +} + +async function callExpression7() { +>callExpression7 : () => Promise + + x(...y, await z); +>x(...y, await z) : any +>x : any +>...y : any +>y : any +>await z : any +>z : any +} + +async function callExpression8() { +>callExpression8 : () => Promise + + x(await y, ...z); +>x(await y, ...z) : any +>x : any +>await y : any +>y : any +>...z : any +>z : any +} + +async function callExpression9() { +>callExpression9 : () => Promise + + x(y, ...(await z)); +>x(y, ...(await z)) : any +>x : any +>y : any +>...(await z) : any +>(await z) : any +>await z : any +>z : any +} + +async function callExpression10() { +>callExpression10 : () => Promise + + await x.a(y, z); +>await x.a(y, z) : any +>x.a(y, z) : any +>x.a : any +>x : any +>a : any +>y : any +>z : any +} + +async function callExpression11() { +>callExpression11 : () => Promise + + (await x.a)(y, z); +>(await x.a)(y, z) : any +>(await x.a) : any +>await x.a : any +>x.a : any +>x : any +>a : any +>y : any +>z : any +} + +async function callExpression12() { +>callExpression12 : () => Promise + + (await x).a(y, z); +>(await x).a(y, z) : any +>(await x).a : any +>(await x) : any +>await x : any +>x : any +>a : any +>y : any +>z : any +} + +async function callExpression13() { +>callExpression13 : () => Promise + + x.a(await y, z); +>x.a(await y, z) : any +>x.a : any +>x : any +>a : any +>await y : any +>y : any +>z : any +} + +async function callExpression14() { +>callExpression14 : () => Promise + + x.a(y, await z); +>x.a(y, await z) : any +>x.a : any +>x : any +>a : any +>y : any +>await z : any +>z : any +} + +async function callExpression15() { +>callExpression15 : () => Promise + + await x[a](y, z); +>await x[a](y, z) : any +>x[a](y, z) : any +>x[a] : any +>x : any +>a : any +>y : any +>z : any +} + +async function callExpression16() { +>callExpression16 : () => Promise + + (await x[a])(y, z); +>(await x[a])(y, z) : any +>(await x[a]) : any +>await x[a] : any +>x[a] : any +>x : any +>a : any +>y : any +>z : any +} + +async function callExpression17() { +>callExpression17 : () => Promise + + (await x)[a](y, z); +>(await x)[a](y, z) : any +>(await x)[a] : any +>(await x) : any +>await x : any +>x : any +>a : any +>y : any +>z : any +} + +async function callExpression18() { +>callExpression18 : () => Promise + + x[await a](y, z); +>x[await a](y, z) : any +>x[await a] : any +>x : any +>await a : any +>a : any +>y : any +>z : any +} + +async function callExpression19() { +>callExpression19 : () => Promise + + x[a](await y, z); +>x[a](await y, z) : any +>x[a] : any +>x : any +>a : any +>await y : any +>y : any +>z : any +} + +async function callExpression20() { +>callExpression20 : () => Promise + + x[a](y, await z); +>x[a](y, await z) : any +>x[a] : any +>x : any +>a : any +>y : any +>await z : any +>z : any +} + diff --git a/tests/baselines/reference/es5-asyncFunctionConditionals.js b/tests/baselines/reference/es5-asyncFunctionConditionals.js new file mode 100644 index 00000000000..f559e1f962d --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionConditionals.js @@ -0,0 +1,71 @@ +//// [es5-asyncFunctionConditionals.ts] +declare var x, y, z, a, b, c; + +async function conditional0() { + a = (await x) ? y : z; +} + +async function conditional1() { + a = x ? await y : z; +} + +async function conditional2() { + a = x ? y : await z; +} + +//// [es5-asyncFunctionConditionals.js] +function conditional0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + a = (_a.sent()) ? y : z; + return [2 /*return*/]; + } + }); + }); +} +function conditional1() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a = _b.sent(); + return [3 /*break*/, 3]; + case 2: + _a = z; + _b.label = 3; + case 3: + a = _a; + return [2 /*return*/]; + } + }); + }); +} +function conditional2() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + if (!x) + return [3 /*break*/, 1]; + _a = y; + return [3 /*break*/, 3]; + case 1: return [4 /*yield*/, z]; + case 2: + _a = _b.sent(); + _b.label = 3; + case 3: + a = _a; + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionConditionals.symbols b/tests/baselines/reference/es5-asyncFunctionConditionals.symbols new file mode 100644 index 00000000000..8efa16840f2 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionConditionals.symbols @@ -0,0 +1,38 @@ +=== tests/cases/compiler/es5-asyncFunctionConditionals.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionConditionals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionConditionals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionConditionals.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionConditionals.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionConditionals.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionConditionals.ts, 0, 26)) + +async function conditional0() { +>conditional0 : Symbol(conditional0, Decl(es5-asyncFunctionConditionals.ts, 0, 29)) + + a = (await x) ? y : z; +>a : Symbol(a, Decl(es5-asyncFunctionConditionals.ts, 0, 20)) +>x : Symbol(x, Decl(es5-asyncFunctionConditionals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionConditionals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionConditionals.ts, 0, 17)) +} + +async function conditional1() { +>conditional1 : Symbol(conditional1, Decl(es5-asyncFunctionConditionals.ts, 4, 1)) + + a = x ? await y : z; +>a : Symbol(a, Decl(es5-asyncFunctionConditionals.ts, 0, 20)) +>x : Symbol(x, Decl(es5-asyncFunctionConditionals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionConditionals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionConditionals.ts, 0, 17)) +} + +async function conditional2() { +>conditional2 : Symbol(conditional2, Decl(es5-asyncFunctionConditionals.ts, 8, 1)) + + a = x ? y : await z; +>a : Symbol(a, Decl(es5-asyncFunctionConditionals.ts, 0, 20)) +>x : Symbol(x, Decl(es5-asyncFunctionConditionals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionConditionals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionConditionals.ts, 0, 17)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionConditionals.types b/tests/baselines/reference/es5-asyncFunctionConditionals.types new file mode 100644 index 00000000000..21f13585e89 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionConditionals.types @@ -0,0 +1,48 @@ +=== tests/cases/compiler/es5-asyncFunctionConditionals.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function conditional0() { +>conditional0 : () => Promise + + a = (await x) ? y : z; +>a = (await x) ? y : z : any +>a : any +>(await x) ? y : z : any +>(await x) : any +>await x : any +>x : any +>y : any +>z : any +} + +async function conditional1() { +>conditional1 : () => Promise + + a = x ? await y : z; +>a = x ? await y : z : any +>a : any +>x ? await y : z : any +>x : any +>await y : any +>y : any +>z : any +} + +async function conditional2() { +>conditional2 : () => Promise + + a = x ? y : await z; +>a = x ? y : await z : any +>a : any +>x ? y : await z : any +>x : any +>y : any +>await z : any +>z : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionDoStatements.js b/tests/baselines/reference/es5-asyncFunctionDoStatements.js new file mode 100644 index 00000000000..f2052ab378d --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionDoStatements.js @@ -0,0 +1,372 @@ +//// [es5-asyncFunctionDoStatements.ts] +declare var x, y, z, a, b, c; + +async function doStatement0() { + do { x; } while (y); +} + +async function doStatement1() { + do { await x; } while (y); +} + +async function doStatement2() { + do { x; } while (await y); +} + +async function doStatement3() { + do { continue; } while (y); +} + +async function doStatement4() { + do { await x; continue; } while (y); +} + +async function doStatement5() { + do { if (1) continue; await x; } while (y); +} + +async function doStatement6() { + do { continue; } while (await y); +} + +async function doStatement7() { + A: do { continue A; } while (y); +} + +async function doStatement8() { + B: do { await x; continue B; } while (y); +} + +async function doStatement9() { + C: do { if (1) continue C; await x; } while (y); +} + +async function doStatement10() { + D: do { continue D; } while (await y); +} + +async function doStatement11() { + do { break; } while (y); +} + +async function doStatement12() { + do { await x; break; } while (y); +} + +async function doStatement13() { + do { if (1) break; await x; } while (y); +} + +async function doStatement14() { + do { break; } while (await y); +} + +async function doStatement15() { + E: do { break E; } while (y); +} + +async function doStatement16() { + F: do { await x; break F; } while (y); +} + +async function doStatement17() { + G: do { if (1) break G; await x; } while (y); +} + +async function doStatement18() { + H: do { break H; } while (await y); +} + +//// [es5-asyncFunctionDoStatements.js] +function doStatement0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + do { + x; + } while (y); + return [2 /*return*/]; + }); + }); +} +function doStatement1() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a.sent(); + _a.label = 2; + case 2: + if (y) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement2() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + x; + _a.label = 1; + case 1: return [4 /*yield*/, y]; + case 2: + if (_a.sent()) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement3() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + do { + continue; + } while (y); + return [2 /*return*/]; + }); + }); +} +function doStatement4() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a.sent(); + return [3 /*break*/, 2]; + case 2: + if (y) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement5() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (1) + return [3 /*break*/, 2]; + return [4 /*yield*/, x]; + case 1: + _a.sent(); + _a.label = 2; + case 2: + if (y) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement6() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [3 /*break*/, 1]; + case 1: return [4 /*yield*/, y]; + case 2: + if (_a.sent()) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement7() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + A: do { + continue A; + } while (y); + return [2 /*return*/]; + }); + }); +} +function doStatement8() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a.sent(); + return [3 /*break*/, 2]; + case 2: + if (y) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement9() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (1) + return [3 /*break*/, 2]; + return [4 /*yield*/, x]; + case 1: + _a.sent(); + _a.label = 2; + case 2: + if (y) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement10() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [3 /*break*/, 1]; + case 1: return [4 /*yield*/, y]; + case 2: + if (_a.sent()) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement11() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + do { + break; + } while (y); + return [2 /*return*/]; + }); + }); +} +function doStatement12() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a.sent(); + return [3 /*break*/, 3]; + case 2: + if (y) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement13() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (1) + return [3 /*break*/, 3]; + return [4 /*yield*/, x]; + case 1: + _a.sent(); + _a.label = 2; + case 2: + if (y) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement14() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [3 /*break*/, 3]; + case 1: return [4 /*yield*/, y]; + case 2: + if (_a.sent()) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement15() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + E: do { + break E; + } while (y); + return [2 /*return*/]; + }); + }); +} +function doStatement16() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a.sent(); + return [3 /*break*/, 3]; + case 2: + if (y) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement17() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (1) + return [3 /*break*/, 3]; + return [4 /*yield*/, x]; + case 1: + _a.sent(); + _a.label = 2; + case 2: + if (y) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function doStatement18() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [3 /*break*/, 3]; + case 1: return [4 /*yield*/, y]; + case 2: + if (_a.sent()) + return [3 /*break*/, 0]; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionDoStatements.symbols b/tests/baselines/reference/es5-asyncFunctionDoStatements.symbols new file mode 100644 index 00000000000..4f234828e63 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionDoStatements.symbols @@ -0,0 +1,152 @@ +=== tests/cases/compiler/es5-asyncFunctionDoStatements.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionDoStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionDoStatements.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionDoStatements.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionDoStatements.ts, 0, 26)) + +async function doStatement0() { +>doStatement0 : Symbol(doStatement0, Decl(es5-asyncFunctionDoStatements.ts, 0, 29)) + + do { x; } while (y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement1() { +>doStatement1 : Symbol(doStatement1, Decl(es5-asyncFunctionDoStatements.ts, 4, 1)) + + do { await x; } while (y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement2() { +>doStatement2 : Symbol(doStatement2, Decl(es5-asyncFunctionDoStatements.ts, 8, 1)) + + do { x; } while (await y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement3() { +>doStatement3 : Symbol(doStatement3, Decl(es5-asyncFunctionDoStatements.ts, 12, 1)) + + do { continue; } while (y); +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement4() { +>doStatement4 : Symbol(doStatement4, Decl(es5-asyncFunctionDoStatements.ts, 16, 1)) + + do { await x; continue; } while (y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement5() { +>doStatement5 : Symbol(doStatement5, Decl(es5-asyncFunctionDoStatements.ts, 20, 1)) + + do { if (1) continue; await x; } while (y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement6() { +>doStatement6 : Symbol(doStatement6, Decl(es5-asyncFunctionDoStatements.ts, 24, 1)) + + do { continue; } while (await y); +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement7() { +>doStatement7 : Symbol(doStatement7, Decl(es5-asyncFunctionDoStatements.ts, 28, 1)) + + A: do { continue A; } while (y); +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement8() { +>doStatement8 : Symbol(doStatement8, Decl(es5-asyncFunctionDoStatements.ts, 32, 1)) + + B: do { await x; continue B; } while (y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement9() { +>doStatement9 : Symbol(doStatement9, Decl(es5-asyncFunctionDoStatements.ts, 36, 1)) + + C: do { if (1) continue C; await x; } while (y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement10() { +>doStatement10 : Symbol(doStatement10, Decl(es5-asyncFunctionDoStatements.ts, 40, 1)) + + D: do { continue D; } while (await y); +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement11() { +>doStatement11 : Symbol(doStatement11, Decl(es5-asyncFunctionDoStatements.ts, 44, 1)) + + do { break; } while (y); +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement12() { +>doStatement12 : Symbol(doStatement12, Decl(es5-asyncFunctionDoStatements.ts, 48, 1)) + + do { await x; break; } while (y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement13() { +>doStatement13 : Symbol(doStatement13, Decl(es5-asyncFunctionDoStatements.ts, 52, 1)) + + do { if (1) break; await x; } while (y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement14() { +>doStatement14 : Symbol(doStatement14, Decl(es5-asyncFunctionDoStatements.ts, 56, 1)) + + do { break; } while (await y); +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement15() { +>doStatement15 : Symbol(doStatement15, Decl(es5-asyncFunctionDoStatements.ts, 60, 1)) + + E: do { break E; } while (y); +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement16() { +>doStatement16 : Symbol(doStatement16, Decl(es5-asyncFunctionDoStatements.ts, 64, 1)) + + F: do { await x; break F; } while (y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement17() { +>doStatement17 : Symbol(doStatement17, Decl(es5-asyncFunctionDoStatements.ts, 68, 1)) + + G: do { if (1) break G; await x; } while (y); +>x : Symbol(x, Decl(es5-asyncFunctionDoStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} + +async function doStatement18() { +>doStatement18 : Symbol(doStatement18, Decl(es5-asyncFunctionDoStatements.ts, 72, 1)) + + H: do { break H; } while (await y); +>y : Symbol(y, Decl(es5-asyncFunctionDoStatements.ts, 0, 14)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionDoStatements.types b/tests/baselines/reference/es5-asyncFunctionDoStatements.types new file mode 100644 index 00000000000..cfec3eebcfb --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionDoStatements.types @@ -0,0 +1,186 @@ +=== tests/cases/compiler/es5-asyncFunctionDoStatements.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function doStatement0() { +>doStatement0 : () => Promise + + do { x; } while (y); +>x : any +>y : any +} + +async function doStatement1() { +>doStatement1 : () => Promise + + do { await x; } while (y); +>await x : any +>x : any +>y : any +} + +async function doStatement2() { +>doStatement2 : () => Promise + + do { x; } while (await y); +>x : any +>await y : any +>y : any +} + +async function doStatement3() { +>doStatement3 : () => Promise + + do { continue; } while (y); +>y : any +} + +async function doStatement4() { +>doStatement4 : () => Promise + + do { await x; continue; } while (y); +>await x : any +>x : any +>y : any +} + +async function doStatement5() { +>doStatement5 : () => Promise + + do { if (1) continue; await x; } while (y); +>1 : number +>await x : any +>x : any +>y : any +} + +async function doStatement6() { +>doStatement6 : () => Promise + + do { continue; } while (await y); +>await y : any +>y : any +} + +async function doStatement7() { +>doStatement7 : () => Promise + + A: do { continue A; } while (y); +>A : any +>A : any +>y : any +} + +async function doStatement8() { +>doStatement8 : () => Promise + + B: do { await x; continue B; } while (y); +>B : any +>await x : any +>x : any +>B : any +>y : any +} + +async function doStatement9() { +>doStatement9 : () => Promise + + C: do { if (1) continue C; await x; } while (y); +>C : any +>1 : number +>C : any +>await x : any +>x : any +>y : any +} + +async function doStatement10() { +>doStatement10 : () => Promise + + D: do { continue D; } while (await y); +>D : any +>D : any +>await y : any +>y : any +} + +async function doStatement11() { +>doStatement11 : () => Promise + + do { break; } while (y); +>y : any +} + +async function doStatement12() { +>doStatement12 : () => Promise + + do { await x; break; } while (y); +>await x : any +>x : any +>y : any +} + +async function doStatement13() { +>doStatement13 : () => Promise + + do { if (1) break; await x; } while (y); +>1 : number +>await x : any +>x : any +>y : any +} + +async function doStatement14() { +>doStatement14 : () => Promise + + do { break; } while (await y); +>await y : any +>y : any +} + +async function doStatement15() { +>doStatement15 : () => Promise + + E: do { break E; } while (y); +>E : any +>E : any +>y : any +} + +async function doStatement16() { +>doStatement16 : () => Promise + + F: do { await x; break F; } while (y); +>F : any +>await x : any +>x : any +>F : any +>y : any +} + +async function doStatement17() { +>doStatement17 : () => Promise + + G: do { if (1) break G; await x; } while (y); +>G : any +>1 : number +>G : any +>await x : any +>x : any +>y : any +} + +async function doStatement18() { +>doStatement18 : () => Promise + + H: do { break H; } while (await y); +>H : any +>H : any +>await y : any +>y : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionElementAccess.js b/tests/baselines/reference/es5-asyncFunctionElementAccess.js new file mode 100644 index 00000000000..4595cc219e9 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionElementAccess.js @@ -0,0 +1,56 @@ +//// [es5-asyncFunctionElementAccess.ts] +declare var x, y, z, a, b, c; + +async function elementAccess0() { + z = await x[y]; +} + +async function elementAccess1() { + z = (await x)[y]; +} + +async function elementAccess2() { + z = x[await y]; +} + + +//// [es5-asyncFunctionElementAccess.js] +function elementAccess0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x[y]]; + case 1: + z = _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function elementAccess1() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + z = (_a.sent())[y]; + return [2 /*return*/]; + } + }); + }); +} +function elementAccess2() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, y]; + case 1: + z = _a[_b.sent()]; + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionElementAccess.symbols b/tests/baselines/reference/es5-asyncFunctionElementAccess.symbols new file mode 100644 index 00000000000..b4c9968e7b9 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionElementAccess.symbols @@ -0,0 +1,36 @@ +=== tests/cases/compiler/es5-asyncFunctionElementAccess.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionElementAccess.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionElementAccess.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionElementAccess.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionElementAccess.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionElementAccess.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionElementAccess.ts, 0, 26)) + +async function elementAccess0() { +>elementAccess0 : Symbol(elementAccess0, Decl(es5-asyncFunctionElementAccess.ts, 0, 29)) + + z = await x[y]; +>z : Symbol(z, Decl(es5-asyncFunctionElementAccess.ts, 0, 17)) +>x : Symbol(x, Decl(es5-asyncFunctionElementAccess.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionElementAccess.ts, 0, 14)) +} + +async function elementAccess1() { +>elementAccess1 : Symbol(elementAccess1, Decl(es5-asyncFunctionElementAccess.ts, 4, 1)) + + z = (await x)[y]; +>z : Symbol(z, Decl(es5-asyncFunctionElementAccess.ts, 0, 17)) +>x : Symbol(x, Decl(es5-asyncFunctionElementAccess.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionElementAccess.ts, 0, 14)) +} + +async function elementAccess2() { +>elementAccess2 : Symbol(elementAccess2, Decl(es5-asyncFunctionElementAccess.ts, 8, 1)) + + z = x[await y]; +>z : Symbol(z, Decl(es5-asyncFunctionElementAccess.ts, 0, 17)) +>x : Symbol(x, Decl(es5-asyncFunctionElementAccess.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionElementAccess.ts, 0, 14)) +} + diff --git a/tests/baselines/reference/es5-asyncFunctionElementAccess.types b/tests/baselines/reference/es5-asyncFunctionElementAccess.types new file mode 100644 index 00000000000..ab5c31ad09a --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionElementAccess.types @@ -0,0 +1,46 @@ +=== tests/cases/compiler/es5-asyncFunctionElementAccess.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function elementAccess0() { +>elementAccess0 : () => Promise + + z = await x[y]; +>z = await x[y] : any +>z : any +>await x[y] : any +>x[y] : any +>x : any +>y : any +} + +async function elementAccess1() { +>elementAccess1 : () => Promise + + z = (await x)[y]; +>z = (await x)[y] : any +>z : any +>(await x)[y] : any +>(await x) : any +>await x : any +>x : any +>y : any +} + +async function elementAccess2() { +>elementAccess2 : () => Promise + + z = x[await y]; +>z = x[await y] : any +>z : any +>x[await y] : any +>x : any +>await y : any +>y : any +} + diff --git a/tests/baselines/reference/es5-asyncFunctionForInStatements.js b/tests/baselines/reference/es5-asyncFunctionForInStatements.js new file mode 100644 index 00000000000..4ce6e5e4a19 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionForInStatements.js @@ -0,0 +1,250 @@ +//// [es5-asyncFunctionForInStatements.ts] +declare var x, y, z, a, b, c; + +async function forInStatement0() { + for (x in y) { z; } +} + +async function forInStatement1() { + for (x in await y) { z; } +} + +async function forInStatement2() { + for (x in y) { await z; } +} + +async function forInStatement3() { + for ((await x).a in y) { z; } +} + +async function forInStatement4() { + for (x.a in await y) { z; } +} + +async function forInStatement5() { + for (x.a in y) { await z; } +} + +async function forInStatement6() { + for (var a in y) { z; } +} + +async function forInStatement7() { + for (var b in await y) { z; } +} + +async function forInStatement8() { + for (var c in y) { await z; } +} + +//// [es5-asyncFunctionForInStatements.js] +function forInStatement0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + for (x in y) { + z; + } + return [2 /*return*/]; + }); + }); +} +function forInStatement1() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _i; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = []; + return [4 /*yield*/, y]; + case 1: + for (_b in _c.sent()) + _a.push(_b); + _i = 0; + _c.label = 2; + case 2: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + x = _a[_i]; + z; + _c.label = 3; + case 3: + _i++; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forInStatement2() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _i; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = []; + for (_b in y) + _a.push(_b); + _i = 0; + _c.label = 1; + case 1: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + x = _a[_i]; + return [4 /*yield*/, z]; + case 2: + _c.sent(); + _c.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forInStatement3() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _i; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = []; + for (_b in y) + _a.push(_b); + _i = 0; + _c.label = 1; + case 1: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + return [4 /*yield*/, x]; + case 2: + (_c.sent()).a = _a[_i]; + z; + _c.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forInStatement4() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _i; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = []; + return [4 /*yield*/, y]; + case 1: + for (_b in _c.sent()) + _a.push(_b); + _i = 0; + _c.label = 2; + case 2: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + x.a = _a[_i]; + z; + _c.label = 3; + case 3: + _i++; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forInStatement5() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _i; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = []; + for (_b in y) + _a.push(_b); + _i = 0; + _c.label = 1; + case 1: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + x.a = _a[_i]; + return [4 /*yield*/, z]; + case 2: + _c.sent(); + _c.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forInStatement6() { + return __awaiter(this, void 0, void 0, function () { + var a; + return __generator(function (_a) { + for (a in y) { + z; + } + return [2 /*return*/]; + }); + }); +} +function forInStatement7() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _i, b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = []; + return [4 /*yield*/, y]; + case 1: + for (_b in _c.sent()) + _a.push(_b); + _i = 0; + _c.label = 2; + case 2: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + b = _a[_i]; + z; + _c.label = 3; + case 3: + _i++; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forInStatement8() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _i, c; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = []; + for (_b in y) + _a.push(_b); + _i = 0; + _c.label = 1; + case 1: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + c = _a[_i]; + return [4 /*yield*/, z]; + case 2: + _c.sent(); + _c.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionForInStatements.symbols b/tests/baselines/reference/es5-asyncFunctionForInStatements.symbols new file mode 100644 index 00000000000..623978f0b64 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionForInStatements.symbols @@ -0,0 +1,89 @@ +=== tests/cases/compiler/es5-asyncFunctionForInStatements.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionForInStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForInStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForInStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionForInStatements.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionForInStatements.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionForInStatements.ts, 0, 26)) + +async function forInStatement0() { +>forInStatement0 : Symbol(forInStatement0, Decl(es5-asyncFunctionForInStatements.ts, 0, 29)) + + for (x in y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForInStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForInStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForInStatements.ts, 0, 17)) +} + +async function forInStatement1() { +>forInStatement1 : Symbol(forInStatement1, Decl(es5-asyncFunctionForInStatements.ts, 4, 1)) + + for (x in await y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForInStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForInStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForInStatements.ts, 0, 17)) +} + +async function forInStatement2() { +>forInStatement2 : Symbol(forInStatement2, Decl(es5-asyncFunctionForInStatements.ts, 8, 1)) + + for (x in y) { await z; } +>x : Symbol(x, Decl(es5-asyncFunctionForInStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForInStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForInStatements.ts, 0, 17)) +} + +async function forInStatement3() { +>forInStatement3 : Symbol(forInStatement3, Decl(es5-asyncFunctionForInStatements.ts, 12, 1)) + + for ((await x).a in y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForInStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForInStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForInStatements.ts, 0, 17)) +} + +async function forInStatement4() { +>forInStatement4 : Symbol(forInStatement4, Decl(es5-asyncFunctionForInStatements.ts, 16, 1)) + + for (x.a in await y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForInStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForInStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForInStatements.ts, 0, 17)) +} + +async function forInStatement5() { +>forInStatement5 : Symbol(forInStatement5, Decl(es5-asyncFunctionForInStatements.ts, 20, 1)) + + for (x.a in y) { await z; } +>x : Symbol(x, Decl(es5-asyncFunctionForInStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForInStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForInStatements.ts, 0, 17)) +} + +async function forInStatement6() { +>forInStatement6 : Symbol(forInStatement6, Decl(es5-asyncFunctionForInStatements.ts, 24, 1)) + + for (var a in y) { z; } +>a : Symbol(a, Decl(es5-asyncFunctionForInStatements.ts, 27, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionForInStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForInStatements.ts, 0, 17)) +} + +async function forInStatement7() { +>forInStatement7 : Symbol(forInStatement7, Decl(es5-asyncFunctionForInStatements.ts, 28, 1)) + + for (var b in await y) { z; } +>b : Symbol(b, Decl(es5-asyncFunctionForInStatements.ts, 31, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionForInStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForInStatements.ts, 0, 17)) +} + +async function forInStatement8() { +>forInStatement8 : Symbol(forInStatement8, Decl(es5-asyncFunctionForInStatements.ts, 32, 1)) + + for (var c in y) { await z; } +>c : Symbol(c, Decl(es5-asyncFunctionForInStatements.ts, 35, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionForInStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForInStatements.ts, 0, 17)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionForInStatements.types b/tests/baselines/reference/es5-asyncFunctionForInStatements.types new file mode 100644 index 00000000000..dcdb276cc90 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionForInStatements.types @@ -0,0 +1,103 @@ +=== tests/cases/compiler/es5-asyncFunctionForInStatements.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function forInStatement0() { +>forInStatement0 : () => Promise + + for (x in y) { z; } +>x : any +>y : any +>z : any +} + +async function forInStatement1() { +>forInStatement1 : () => Promise + + for (x in await y) { z; } +>x : any +>await y : any +>y : any +>z : any +} + +async function forInStatement2() { +>forInStatement2 : () => Promise + + for (x in y) { await z; } +>x : any +>y : any +>await z : any +>z : any +} + +async function forInStatement3() { +>forInStatement3 : () => Promise + + for ((await x).a in y) { z; } +>(await x).a : any +>(await x) : any +>await x : any +>x : any +>a : any +>y : any +>z : any +} + +async function forInStatement4() { +>forInStatement4 : () => Promise + + for (x.a in await y) { z; } +>x.a : any +>x : any +>a : any +>await y : any +>y : any +>z : any +} + +async function forInStatement5() { +>forInStatement5 : () => Promise + + for (x.a in y) { await z; } +>x.a : any +>x : any +>a : any +>y : any +>await z : any +>z : any +} + +async function forInStatement6() { +>forInStatement6 : () => Promise + + for (var a in y) { z; } +>a : string +>y : any +>z : any +} + +async function forInStatement7() { +>forInStatement7 : () => Promise + + for (var b in await y) { z; } +>b : string +>await y : any +>y : any +>z : any +} + +async function forInStatement8() { +>forInStatement8 : () => Promise + + for (var c in y) { await z; } +>c : string +>y : any +>await z : any +>z : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionForOfStatements.js b/tests/baselines/reference/es5-asyncFunctionForOfStatements.js new file mode 100644 index 00000000000..0d5c7753da9 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionForOfStatements.js @@ -0,0 +1,537 @@ +//// [es5-asyncFunctionForOfStatements.ts] +declare var x, y, z, a, b, c; + +async function forOfStatement0() { + for (x of y) { z; } +} + +async function forOfStatement1() { + for (x of await y) { z; } +} + +async function forOfStatement2() { + for (x of y) { await z; } +} + +async function forOfStatement3() { + for ((await x).a of y) { z; } +} + +async function forOfStatement4() { + for (x.a of await y) { z; } +} + +async function forOfStatement5() { + for (x.a of y) { await z; } +} + +async function forOfStatement6() { + for (var b of y) { z; } +} + +async function forOfStatement7() { + for (var c of await y) { z; } +} + +async function forOfStatement8() { + for (var d of y) { await z; } +} + +async function forOfStatement9() { + for ([x] of await y) { z; } +} + +async function forOfStatement10() { + for ([x] of y) { await z; } +} + +async function forOfStatement11() { + for ([x = await a] of y) { z; } +} + +async function forOfStatement12() { + for ([x = a] of await y) { z; } +} + +async function forOfStatement13() { + for ([x = a] of y) { await z; } +} + +async function forOfStatement14() { + for ({ x } of await y) { z; } +} + +async function forOfStatement15() { + for ({ x } of y) { await z; } +} + +async function forOfStatement16() { + for ({ x = await a } of y) { z; } +} + +async function forOfStatement17() { + for ({ x = a } of await y) { z; } +} + +async function forOfStatement18() { + for ({ x = a } of y) { await z; } +} + +//// [es5-asyncFunctionForOfStatements.js] +function forOfStatement0() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_1; + return __generator(function (_a) { + for (_i = 0, y_1 = y; _i < y_1.length; _i++) { + x = y_1[_i]; + z; + } + return [2 /*return*/]; + }); + }); +} +function forOfStatement1() { + return __awaiter(this, void 0, void 0, function () { + var _i, _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _i = 0; + return [4 /*yield*/, y]; + case 1: + _a = _b.sent(); + _b.label = 2; + case 2: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + x = _a[_i]; + z; + _b.label = 3; + case 3: + _i++; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement2() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_2; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _i = 0, y_2 = y; + _a.label = 1; + case 1: + if (!(_i < y_2.length)) + return [3 /*break*/, 4]; + x = y_2[_i]; + return [4 /*yield*/, z]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement3() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_3; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _i = 0, y_3 = y; + _a.label = 1; + case 1: + if (!(_i < y_3.length)) + return [3 /*break*/, 4]; + return [4 /*yield*/, x]; + case 2: + (_a.sent()).a = y_3[_i]; + z; + _a.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement4() { + return __awaiter(this, void 0, void 0, function () { + var _i, _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _i = 0; + return [4 /*yield*/, y]; + case 1: + _a = _b.sent(); + _b.label = 2; + case 2: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + x.a = _a[_i]; + z; + _b.label = 3; + case 3: + _i++; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement5() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_4; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _i = 0, y_4 = y; + _a.label = 1; + case 1: + if (!(_i < y_4.length)) + return [3 /*break*/, 4]; + x.a = y_4[_i]; + return [4 /*yield*/, z]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement6() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_5, b; + return __generator(function (_a) { + for (_i = 0, y_5 = y; _i < y_5.length; _i++) { + b = y_5[_i]; + z; + } + return [2 /*return*/]; + }); + }); +} +function forOfStatement7() { + return __awaiter(this, void 0, void 0, function () { + var _i, _a, c; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _i = 0; + return [4 /*yield*/, y]; + case 1: + _a = _b.sent(); + _b.label = 2; + case 2: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + c = _a[_i]; + z; + _b.label = 3; + case 3: + _i++; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement8() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_6, d; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _i = 0, y_6 = y; + _a.label = 1; + case 1: + if (!(_i < y_6.length)) + return [3 /*break*/, 4]; + d = y_6[_i]; + return [4 /*yield*/, z]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement9() { + return __awaiter(this, void 0, void 0, function () { + var _i, _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _i = 0; + return [4 /*yield*/, y]; + case 1: + _a = _b.sent(); + _b.label = 2; + case 2: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + x = _a[_i][0]; + z; + _b.label = 3; + case 3: + _i++; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement10() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_7; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _i = 0, y_7 = y; + _a.label = 1; + case 1: + if (!(_i < y_7.length)) + return [3 /*break*/, 4]; + x = y_7[_i][0]; + return [4 /*yield*/, z]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement11() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_8, _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _i = 0, y_8 = y; + _c.label = 1; + case 1: + if (!(_i < y_8.length)) + return [3 /*break*/, 6]; + _b = y_8[_i][0]; + if (!(_b === void 0)) + return [3 /*break*/, 3]; + return [4 /*yield*/, a]; + case 2: + _a = _c.sent(); + return [3 /*break*/, 4]; + case 3: + _a = _b; + _c.label = 4; + case 4: + x = _a; + z; + _c.label = 5; + case 5: + _i++; + return [3 /*break*/, 1]; + case 6: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement12() { + return __awaiter(this, void 0, void 0, function () { + var _i, _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _i = 0; + return [4 /*yield*/, y]; + case 1: + _a = _c.sent(); + _c.label = 2; + case 2: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + _b = _a[_i][0], x = _b === void 0 ? a : _b; + z; + _c.label = 3; + case 3: + _i++; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement13() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_9, _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _i = 0, y_9 = y; + _b.label = 1; + case 1: + if (!(_i < y_9.length)) + return [3 /*break*/, 4]; + _a = y_9[_i][0], x = _a === void 0 ? a : _a; + return [4 /*yield*/, z]; + case 2: + _b.sent(); + _b.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement14() { + return __awaiter(this, void 0, void 0, function () { + var _i, _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _i = 0; + return [4 /*yield*/, y]; + case 1: + _a = _b.sent(); + _b.label = 2; + case 2: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + x = _a[_i].x; + z; + _b.label = 3; + case 3: + _i++; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement15() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_10; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _i = 0, y_10 = y; + _a.label = 1; + case 1: + if (!(_i < y_10.length)) + return [3 /*break*/, 4]; + x = y_10[_i].x; + return [4 /*yield*/, z]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement16() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_11, _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _i = 0, y_11 = y; + _c.label = 1; + case 1: + if (!(_i < y_11.length)) + return [3 /*break*/, 6]; + _b = y_11[_i].x; + if (!(_b === void 0)) + return [3 /*break*/, 3]; + return [4 /*yield*/, a]; + case 2: + _a = _c.sent(); + return [3 /*break*/, 4]; + case 3: + _a = _b; + _c.label = 4; + case 4: + x = _a; + z; + _c.label = 5; + case 5: + _i++; + return [3 /*break*/, 1]; + case 6: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement17() { + return __awaiter(this, void 0, void 0, function () { + var _i, _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _i = 0; + return [4 /*yield*/, y]; + case 1: + _a = _c.sent(); + _c.label = 2; + case 2: + if (!(_i < _a.length)) + return [3 /*break*/, 4]; + _b = _a[_i].x, x = _b === void 0 ? a : _b; + z; + _c.label = 3; + case 3: + _i++; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forOfStatement18() { + return __awaiter(this, void 0, void 0, function () { + var _i, y_12, _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _i = 0, y_12 = y; + _b.label = 1; + case 1: + if (!(_i < y_12.length)) + return [3 /*break*/, 4]; + _a = y_12[_i].x, x = _a === void 0 ? a : _a; + return [4 /*yield*/, z]; + case 2: + _b.sent(); + _b.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionForOfStatements.symbols b/tests/baselines/reference/es5-asyncFunctionForOfStatements.symbols new file mode 100644 index 00000000000..15742967e09 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionForOfStatements.symbols @@ -0,0 +1,183 @@ +=== tests/cases/compiler/es5-asyncFunctionForOfStatements.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionForOfStatements.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionForOfStatements.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionForOfStatements.ts, 0, 26)) + +async function forOfStatement0() { +>forOfStatement0 : Symbol(forOfStatement0, Decl(es5-asyncFunctionForOfStatements.ts, 0, 29)) + + for (x of y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement1() { +>forOfStatement1 : Symbol(forOfStatement1, Decl(es5-asyncFunctionForOfStatements.ts, 4, 1)) + + for (x of await y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement2() { +>forOfStatement2 : Symbol(forOfStatement2, Decl(es5-asyncFunctionForOfStatements.ts, 8, 1)) + + for (x of y) { await z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement3() { +>forOfStatement3 : Symbol(forOfStatement3, Decl(es5-asyncFunctionForOfStatements.ts, 12, 1)) + + for ((await x).a of y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement4() { +>forOfStatement4 : Symbol(forOfStatement4, Decl(es5-asyncFunctionForOfStatements.ts, 16, 1)) + + for (x.a of await y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement5() { +>forOfStatement5 : Symbol(forOfStatement5, Decl(es5-asyncFunctionForOfStatements.ts, 20, 1)) + + for (x.a of y) { await z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement6() { +>forOfStatement6 : Symbol(forOfStatement6, Decl(es5-asyncFunctionForOfStatements.ts, 24, 1)) + + for (var b of y) { z; } +>b : Symbol(b, Decl(es5-asyncFunctionForOfStatements.ts, 27, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement7() { +>forOfStatement7 : Symbol(forOfStatement7, Decl(es5-asyncFunctionForOfStatements.ts, 28, 1)) + + for (var c of await y) { z; } +>c : Symbol(c, Decl(es5-asyncFunctionForOfStatements.ts, 31, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement8() { +>forOfStatement8 : Symbol(forOfStatement8, Decl(es5-asyncFunctionForOfStatements.ts, 32, 1)) + + for (var d of y) { await z; } +>d : Symbol(d, Decl(es5-asyncFunctionForOfStatements.ts, 35, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement9() { +>forOfStatement9 : Symbol(forOfStatement9, Decl(es5-asyncFunctionForOfStatements.ts, 36, 1)) + + for ([x] of await y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement10() { +>forOfStatement10 : Symbol(forOfStatement10, Decl(es5-asyncFunctionForOfStatements.ts, 40, 1)) + + for ([x] of y) { await z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement11() { +>forOfStatement11 : Symbol(forOfStatement11, Decl(es5-asyncFunctionForOfStatements.ts, 44, 1)) + + for ([x = await a] of y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionForOfStatements.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement12() { +>forOfStatement12 : Symbol(forOfStatement12, Decl(es5-asyncFunctionForOfStatements.ts, 48, 1)) + + for ([x = a] of await y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionForOfStatements.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement13() { +>forOfStatement13 : Symbol(forOfStatement13, Decl(es5-asyncFunctionForOfStatements.ts, 52, 1)) + + for ([x = a] of y) { await z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionForOfStatements.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement14() { +>forOfStatement14 : Symbol(forOfStatement14, Decl(es5-asyncFunctionForOfStatements.ts, 56, 1)) + + for ({ x } of await y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 59, 10)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement15() { +>forOfStatement15 : Symbol(forOfStatement15, Decl(es5-asyncFunctionForOfStatements.ts, 60, 1)) + + for ({ x } of y) { await z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 63, 10)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement16() { +>forOfStatement16 : Symbol(forOfStatement16, Decl(es5-asyncFunctionForOfStatements.ts, 64, 1)) + + for ({ x = await a } of y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 67, 10)) +>a : Symbol(a, Decl(es5-asyncFunctionForOfStatements.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement17() { +>forOfStatement17 : Symbol(forOfStatement17, Decl(es5-asyncFunctionForOfStatements.ts, 68, 1)) + + for ({ x = a } of await y) { z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 71, 10)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} + +async function forOfStatement18() { +>forOfStatement18 : Symbol(forOfStatement18, Decl(es5-asyncFunctionForOfStatements.ts, 72, 1)) + + for ({ x = a } of y) { await z; } +>x : Symbol(x, Decl(es5-asyncFunctionForOfStatements.ts, 75, 10)) +>y : Symbol(y, Decl(es5-asyncFunctionForOfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForOfStatements.ts, 0, 17)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionForOfStatements.types b/tests/baselines/reference/es5-asyncFunctionForOfStatements.types new file mode 100644 index 00000000000..24c5e5eb83c --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionForOfStatements.types @@ -0,0 +1,222 @@ +=== tests/cases/compiler/es5-asyncFunctionForOfStatements.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function forOfStatement0() { +>forOfStatement0 : () => Promise + + for (x of y) { z; } +>x : any +>y : any +>z : any +} + +async function forOfStatement1() { +>forOfStatement1 : () => Promise + + for (x of await y) { z; } +>x : any +>await y : any +>y : any +>z : any +} + +async function forOfStatement2() { +>forOfStatement2 : () => Promise + + for (x of y) { await z; } +>x : any +>y : any +>await z : any +>z : any +} + +async function forOfStatement3() { +>forOfStatement3 : () => Promise + + for ((await x).a of y) { z; } +>(await x).a : any +>(await x) : any +>await x : any +>x : any +>a : any +>y : any +>z : any +} + +async function forOfStatement4() { +>forOfStatement4 : () => Promise + + for (x.a of await y) { z; } +>x.a : any +>x : any +>a : any +>await y : any +>y : any +>z : any +} + +async function forOfStatement5() { +>forOfStatement5 : () => Promise + + for (x.a of y) { await z; } +>x.a : any +>x : any +>a : any +>y : any +>await z : any +>z : any +} + +async function forOfStatement6() { +>forOfStatement6 : () => Promise + + for (var b of y) { z; } +>b : any +>y : any +>z : any +} + +async function forOfStatement7() { +>forOfStatement7 : () => Promise + + for (var c of await y) { z; } +>c : any +>await y : any +>y : any +>z : any +} + +async function forOfStatement8() { +>forOfStatement8 : () => Promise + + for (var d of y) { await z; } +>d : any +>y : any +>await z : any +>z : any +} + +async function forOfStatement9() { +>forOfStatement9 : () => Promise + + for ([x] of await y) { z; } +>[x] : [any] +>x : any +>await y : any +>y : any +>z : any +} + +async function forOfStatement10() { +>forOfStatement10 : () => Promise + + for ([x] of y) { await z; } +>[x] : [any] +>x : any +>y : any +>await z : any +>z : any +} + +async function forOfStatement11() { +>forOfStatement11 : () => Promise + + for ([x = await a] of y) { z; } +>[x = await a] : [any] +>x = await a : any +>x : any +>await a : any +>a : any +>y : any +>z : any +} + +async function forOfStatement12() { +>forOfStatement12 : () => Promise + + for ([x = a] of await y) { z; } +>[x = a] : [any] +>x = a : any +>x : any +>a : any +>await y : any +>y : any +>z : any +} + +async function forOfStatement13() { +>forOfStatement13 : () => Promise + + for ([x = a] of y) { await z; } +>[x = a] : [any] +>x = a : any +>x : any +>a : any +>y : any +>await z : any +>z : any +} + +async function forOfStatement14() { +>forOfStatement14 : () => Promise + + for ({ x } of await y) { z; } +>{ x } : { x: any; } +>x : any +>await y : any +>y : any +>z : any +} + +async function forOfStatement15() { +>forOfStatement15 : () => Promise + + for ({ x } of y) { await z; } +>{ x } : { x: any; } +>x : any +>y : any +>await z : any +>z : any +} + +async function forOfStatement16() { +>forOfStatement16 : () => Promise + + for ({ x = await a } of y) { z; } +>{ x = await a } : { x?: any; } +>x : any +>await a : any +>a : any +>y : any +>z : any +} + +async function forOfStatement17() { +>forOfStatement17 : () => Promise + + for ({ x = a } of await y) { z; } +>{ x = a } : { x?: any; } +>x : any +>a : any +>await y : any +>y : any +>z : any +} + +async function forOfStatement18() { +>forOfStatement18 : () => Promise + + for ({ x = a } of y) { await z; } +>{ x = a } : { x?: any; } +>x : any +>a : any +>y : any +>await z : any +>z : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionForStatements.js b/tests/baselines/reference/es5-asyncFunctionForStatements.js new file mode 100644 index 00000000000..bea0d5838a4 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionForStatements.js @@ -0,0 +1,149 @@ +//// [es5-asyncFunctionForStatements.ts] +declare var x, y, z, a, b, c; + +async function forStatement0() { + for (x; y; z) { a; } +} + +async function forStatement1() { + for (await x; y; z) { a; } +} + +async function forStatement2() { + for (x; await y; z) { a; } +} + +async function forStatement3() { + for (x; y; await z) { a; } +} + +async function forStatement4() { + for (x; y; z) { await a; } +} + +async function forStatement5() { + for (var b; y; z) { a; } +} + +async function forStatement6() { + for (var c = x; y; z) { a; } +} + +//// [es5-asyncFunctionForStatements.js] +function forStatement0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + for (x; y; z) { + a; + } + return [2 /*return*/]; + }); + }); +} +function forStatement1() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a.sent(); + _a.label = 2; + case 2: + if (!y) + return [3 /*break*/, 4]; + a; + _a.label = 3; + case 3: + z; + return [3 /*break*/, 2]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forStatement2() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + x; + _a.label = 1; + case 1: return [4 /*yield*/, y]; + case 2: + if (!_a.sent()) + return [3 /*break*/, 4]; + a; + _a.label = 3; + case 3: + z; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forStatement3() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + x; + _a.label = 1; + case 1: + if (!y) + return [3 /*break*/, 4]; + a; + _a.label = 2; + case 2: return [4 /*yield*/, z]; + case 3: + _a.sent(); + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forStatement4() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + x; + _a.label = 1; + case 1: + if (!y) + return [3 /*break*/, 4]; + return [4 /*yield*/, a]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + z; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function forStatement5() { + return __awaiter(this, void 0, void 0, function () { + var b; + return __generator(function (_a) { + for (; y; z) { + a; + } + return [2 /*return*/]; + }); + }); +} +function forStatement6() { + return __awaiter(this, void 0, void 0, function () { + var c; + return __generator(function (_a) { + for (c = x; y; z) { + a; + } + return [2 /*return*/]; + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionForStatements.symbols b/tests/baselines/reference/es5-asyncFunctionForStatements.symbols new file mode 100644 index 00000000000..878c29e4847 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionForStatements.symbols @@ -0,0 +1,79 @@ +=== tests/cases/compiler/es5-asyncFunctionForStatements.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionForStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionForStatements.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionForStatements.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionForStatements.ts, 0, 26)) + +async function forStatement0() { +>forStatement0 : Symbol(forStatement0, Decl(es5-asyncFunctionForStatements.ts, 0, 29)) + + for (x; y; z) { a; } +>x : Symbol(x, Decl(es5-asyncFunctionForStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionForStatements.ts, 0, 20)) +} + +async function forStatement1() { +>forStatement1 : Symbol(forStatement1, Decl(es5-asyncFunctionForStatements.ts, 4, 1)) + + for (await x; y; z) { a; } +>x : Symbol(x, Decl(es5-asyncFunctionForStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionForStatements.ts, 0, 20)) +} + +async function forStatement2() { +>forStatement2 : Symbol(forStatement2, Decl(es5-asyncFunctionForStatements.ts, 8, 1)) + + for (x; await y; z) { a; } +>x : Symbol(x, Decl(es5-asyncFunctionForStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionForStatements.ts, 0, 20)) +} + +async function forStatement3() { +>forStatement3 : Symbol(forStatement3, Decl(es5-asyncFunctionForStatements.ts, 12, 1)) + + for (x; y; await z) { a; } +>x : Symbol(x, Decl(es5-asyncFunctionForStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionForStatements.ts, 0, 20)) +} + +async function forStatement4() { +>forStatement4 : Symbol(forStatement4, Decl(es5-asyncFunctionForStatements.ts, 16, 1)) + + for (x; y; z) { await a; } +>x : Symbol(x, Decl(es5-asyncFunctionForStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionForStatements.ts, 0, 20)) +} + +async function forStatement5() { +>forStatement5 : Symbol(forStatement5, Decl(es5-asyncFunctionForStatements.ts, 20, 1)) + + for (var b; y; z) { a; } +>b : Symbol(b, Decl(es5-asyncFunctionForStatements.ts, 23, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionForStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionForStatements.ts, 0, 20)) +} + +async function forStatement6() { +>forStatement6 : Symbol(forStatement6, Decl(es5-asyncFunctionForStatements.ts, 24, 1)) + + for (var c = x; y; z) { a; } +>c : Symbol(c, Decl(es5-asyncFunctionForStatements.ts, 27, 12)) +>x : Symbol(x, Decl(es5-asyncFunctionForStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionForStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionForStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionForStatements.ts, 0, 20)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionForStatements.types b/tests/baselines/reference/es5-asyncFunctionForStatements.types new file mode 100644 index 00000000000..0b060f5b708 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionForStatements.types @@ -0,0 +1,83 @@ +=== tests/cases/compiler/es5-asyncFunctionForStatements.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function forStatement0() { +>forStatement0 : () => Promise + + for (x; y; z) { a; } +>x : any +>y : any +>z : any +>a : any +} + +async function forStatement1() { +>forStatement1 : () => Promise + + for (await x; y; z) { a; } +>await x : any +>x : any +>y : any +>z : any +>a : any +} + +async function forStatement2() { +>forStatement2 : () => Promise + + for (x; await y; z) { a; } +>x : any +>await y : any +>y : any +>z : any +>a : any +} + +async function forStatement3() { +>forStatement3 : () => Promise + + for (x; y; await z) { a; } +>x : any +>y : any +>await z : any +>z : any +>a : any +} + +async function forStatement4() { +>forStatement4 : () => Promise + + for (x; y; z) { await a; } +>x : any +>y : any +>z : any +>await a : any +>a : any +} + +async function forStatement5() { +>forStatement5 : () => Promise + + for (var b; y; z) { a; } +>b : any +>y : any +>z : any +>a : any +} + +async function forStatement6() { +>forStatement6 : () => Promise + + for (var c = x; y; z) { a; } +>c : any +>x : any +>y : any +>z : any +>a : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionHoisting.js b/tests/baselines/reference/es5-asyncFunctionHoisting.js new file mode 100644 index 00000000000..6dc05e65bf3 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionHoisting.js @@ -0,0 +1,105 @@ +//// [es5-asyncFunctionHoisting.ts] +declare var y; + +async function hoisting() { + var a0, a1 = 1; + function z() { + var b0, b1 = 1; + } + + if (true) { + var c0, c1 = 1; + } + + for (var a = 0; y;) { + + } + + for (var b in y) { + + } + + for (var c of y) { + + } +} + +async function hoistingWithAwait() { + var a0, a1 = 1; + + function z() { + var b0, b1 = 1; + } + + await 0; + + if (true) { + var c0, c1 = 1; + } + + for (var a = 0; y;) { + + } + + for (var b in y) { + + } + + for (var c of y) { + + } +} + + + +//// [es5-asyncFunctionHoisting.js] +function hoisting() { + return __awaiter(this, void 0, void 0, function () { + function z() { + var b0, b1 = 1; + } + var a0, a1, c0, c1, a, b, _i, y_1, c; + return __generator(function (_a) { + a1 = 1; + if (true) { + c1 = 1; + } + for (a = 0; y;) { + } + for (b in y) { + } + for (_i = 0, y_1 = y; _i < y_1.length; _i++) { + c = y_1[_i]; + } + return [2 /*return*/]; + }); + }); +} +function hoistingWithAwait() { + return __awaiter(this, void 0, void 0, function () { + function z() { + var b0, b1 = 1; + } + var a0, a1, c0, c1, a, b, _i, y_2, c; + return __generator(function (_a) { + switch (_a.label) { + case 0: + a1 = 1; + return [4 /*yield*/, 0]; + case 1: + _a.sent(); + if (true) { + c1 = 1; + } + for (a = 0; y;) { + } + for (b in y) { + } + for (_i = 0, y_2 = y; _i < y_2.length; _i++) { + c = y_2[_i]; + } + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionHoisting.symbols b/tests/baselines/reference/es5-asyncFunctionHoisting.symbols new file mode 100644 index 00000000000..24106028622 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionHoisting.symbols @@ -0,0 +1,87 @@ +=== tests/cases/compiler/es5-asyncFunctionHoisting.ts === +declare var y; +>y : Symbol(y, Decl(es5-asyncFunctionHoisting.ts, 0, 11)) + +async function hoisting() { +>hoisting : Symbol(hoisting, Decl(es5-asyncFunctionHoisting.ts, 0, 14)) + + var a0, a1 = 1; +>a0 : Symbol(a0, Decl(es5-asyncFunctionHoisting.ts, 3, 7)) +>a1 : Symbol(a1, Decl(es5-asyncFunctionHoisting.ts, 3, 11)) + + function z() { +>z : Symbol(z, Decl(es5-asyncFunctionHoisting.ts, 3, 19)) + + var b0, b1 = 1; +>b0 : Symbol(b0, Decl(es5-asyncFunctionHoisting.ts, 5, 11)) +>b1 : Symbol(b1, Decl(es5-asyncFunctionHoisting.ts, 5, 15)) + } + + if (true) { + var c0, c1 = 1; +>c0 : Symbol(c0, Decl(es5-asyncFunctionHoisting.ts, 9, 11)) +>c1 : Symbol(c1, Decl(es5-asyncFunctionHoisting.ts, 9, 15)) + } + + for (var a = 0; y;) { +>a : Symbol(a, Decl(es5-asyncFunctionHoisting.ts, 12, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionHoisting.ts, 0, 11)) + + } + + for (var b in y) { +>b : Symbol(b, Decl(es5-asyncFunctionHoisting.ts, 16, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionHoisting.ts, 0, 11)) + + } + + for (var c of y) { +>c : Symbol(c, Decl(es5-asyncFunctionHoisting.ts, 20, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionHoisting.ts, 0, 11)) + + } +} + +async function hoistingWithAwait() { +>hoistingWithAwait : Symbol(hoistingWithAwait, Decl(es5-asyncFunctionHoisting.ts, 23, 1)) + + var a0, a1 = 1; +>a0 : Symbol(a0, Decl(es5-asyncFunctionHoisting.ts, 26, 7)) +>a1 : Symbol(a1, Decl(es5-asyncFunctionHoisting.ts, 26, 11)) + + function z() { +>z : Symbol(z, Decl(es5-asyncFunctionHoisting.ts, 26, 19)) + + var b0, b1 = 1; +>b0 : Symbol(b0, Decl(es5-asyncFunctionHoisting.ts, 29, 11)) +>b1 : Symbol(b1, Decl(es5-asyncFunctionHoisting.ts, 29, 15)) + } + + await 0; + + if (true) { + var c0, c1 = 1; +>c0 : Symbol(c0, Decl(es5-asyncFunctionHoisting.ts, 35, 11)) +>c1 : Symbol(c1, Decl(es5-asyncFunctionHoisting.ts, 35, 15)) + } + + for (var a = 0; y;) { +>a : Symbol(a, Decl(es5-asyncFunctionHoisting.ts, 38, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionHoisting.ts, 0, 11)) + + } + + for (var b in y) { +>b : Symbol(b, Decl(es5-asyncFunctionHoisting.ts, 42, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionHoisting.ts, 0, 11)) + + } + + for (var c of y) { +>c : Symbol(c, Decl(es5-asyncFunctionHoisting.ts, 46, 12)) +>y : Symbol(y, Decl(es5-asyncFunctionHoisting.ts, 0, 11)) + + } +} + + diff --git a/tests/baselines/reference/es5-asyncFunctionHoisting.types b/tests/baselines/reference/es5-asyncFunctionHoisting.types new file mode 100644 index 00000000000..04b968c571d --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionHoisting.types @@ -0,0 +1,101 @@ +=== tests/cases/compiler/es5-asyncFunctionHoisting.ts === +declare var y; +>y : any + +async function hoisting() { +>hoisting : () => Promise + + var a0, a1 = 1; +>a0 : any +>a1 : number +>1 : number + + function z() { +>z : () => void + + var b0, b1 = 1; +>b0 : any +>b1 : number +>1 : number + } + + if (true) { +>true : boolean + + var c0, c1 = 1; +>c0 : any +>c1 : number +>1 : number + } + + for (var a = 0; y;) { +>a : number +>0 : number +>y : any + + } + + for (var b in y) { +>b : string +>y : any + + } + + for (var c of y) { +>c : any +>y : any + + } +} + +async function hoistingWithAwait() { +>hoistingWithAwait : () => Promise + + var a0, a1 = 1; +>a0 : any +>a1 : number +>1 : number + + function z() { +>z : () => void + + var b0, b1 = 1; +>b0 : any +>b1 : number +>1 : number + } + + await 0; +>await 0 : number +>0 : number + + if (true) { +>true : boolean + + var c0, c1 = 1; +>c0 : any +>c1 : number +>1 : number + } + + for (var a = 0; y;) { +>a : number +>0 : number +>y : any + + } + + for (var b in y) { +>b : string +>y : any + + } + + for (var c of y) { +>c : any +>y : any + + } +} + + diff --git a/tests/baselines/reference/es5-asyncFunctionIfStatements.js b/tests/baselines/reference/es5-asyncFunctionIfStatements.js new file mode 100644 index 00000000000..9f7c71a7f3f --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionIfStatements.js @@ -0,0 +1,70 @@ +//// [es5-asyncFunctionIfStatements.ts] +declare var x, y, z, a, b, c; + +async function ifStatement1() { + if (await x) { y; } else { z; } +} + +async function ifStatement2() { + if (x) { await y; } else { z; } +} + +async function ifStatement3() { + if (x) { y; } else { await z; } +} + +//// [es5-asyncFunctionIfStatements.js] +function ifStatement1() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + if (_a.sent()) { + y; + } + else { + z; + } + return [2 /*return*/]; + } + }); + }); +} +function ifStatement2() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + return [3 /*break*/, 3]; + case 2: + z; + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function ifStatement3() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 1]; + y; + return [3 /*break*/, 3]; + case 1: return [4 /*yield*/, z]; + case 2: + _a.sent(); + _a.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionIfStatements.symbols b/tests/baselines/reference/es5-asyncFunctionIfStatements.symbols new file mode 100644 index 00000000000..b8d8387eaec --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionIfStatements.symbols @@ -0,0 +1,35 @@ +=== tests/cases/compiler/es5-asyncFunctionIfStatements.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionIfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionIfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionIfStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionIfStatements.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionIfStatements.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionIfStatements.ts, 0, 26)) + +async function ifStatement1() { +>ifStatement1 : Symbol(ifStatement1, Decl(es5-asyncFunctionIfStatements.ts, 0, 29)) + + if (await x) { y; } else { z; } +>x : Symbol(x, Decl(es5-asyncFunctionIfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionIfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionIfStatements.ts, 0, 17)) +} + +async function ifStatement2() { +>ifStatement2 : Symbol(ifStatement2, Decl(es5-asyncFunctionIfStatements.ts, 4, 1)) + + if (x) { await y; } else { z; } +>x : Symbol(x, Decl(es5-asyncFunctionIfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionIfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionIfStatements.ts, 0, 17)) +} + +async function ifStatement3() { +>ifStatement3 : Symbol(ifStatement3, Decl(es5-asyncFunctionIfStatements.ts, 8, 1)) + + if (x) { y; } else { await z; } +>x : Symbol(x, Decl(es5-asyncFunctionIfStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionIfStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionIfStatements.ts, 0, 17)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionIfStatements.types b/tests/baselines/reference/es5-asyncFunctionIfStatements.types new file mode 100644 index 00000000000..9cecdcb9f60 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionIfStatements.types @@ -0,0 +1,38 @@ +=== tests/cases/compiler/es5-asyncFunctionIfStatements.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function ifStatement1() { +>ifStatement1 : () => Promise + + if (await x) { y; } else { z; } +>await x : any +>x : any +>y : any +>z : any +} + +async function ifStatement2() { +>ifStatement2 : () => Promise + + if (x) { await y; } else { z; } +>x : any +>await y : any +>y : any +>z : any +} + +async function ifStatement3() { +>ifStatement3 : () => Promise + + if (x) { y; } else { await z; } +>x : any +>y : any +>await z : any +>z : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionNestedLoops.js b/tests/baselines/reference/es5-asyncFunctionNestedLoops.js new file mode 100644 index 00000000000..3290965d6cf --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionNestedLoops.js @@ -0,0 +1,38 @@ +//// [es5-asyncFunctionNestedLoops.ts] +declare var x, y, z, a, b, c; + +async function nestedLoops() { + A: while (x) { + await y; + while (z) { + continue A; + } + while (a) { + continue; + } + } +} + +//// [es5-asyncFunctionNestedLoops.js] +function nestedLoops() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + while (z) { + return [3 /*break*/, 0]; + } + while (a) { + continue; + } + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionNestedLoops.symbols b/tests/baselines/reference/es5-asyncFunctionNestedLoops.symbols new file mode 100644 index 00000000000..45d9cdc781b --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionNestedLoops.symbols @@ -0,0 +1,30 @@ +=== tests/cases/compiler/es5-asyncFunctionNestedLoops.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionNestedLoops.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNestedLoops.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNestedLoops.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionNestedLoops.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionNestedLoops.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionNestedLoops.ts, 0, 26)) + +async function nestedLoops() { +>nestedLoops : Symbol(nestedLoops, Decl(es5-asyncFunctionNestedLoops.ts, 0, 29)) + + A: while (x) { +>x : Symbol(x, Decl(es5-asyncFunctionNestedLoops.ts, 0, 11)) + + await y; +>y : Symbol(y, Decl(es5-asyncFunctionNestedLoops.ts, 0, 14)) + + while (z) { +>z : Symbol(z, Decl(es5-asyncFunctionNestedLoops.ts, 0, 17)) + + continue A; + } + while (a) { +>a : Symbol(a, Decl(es5-asyncFunctionNestedLoops.ts, 0, 20)) + + continue; + } + } +} diff --git a/tests/baselines/reference/es5-asyncFunctionNestedLoops.types b/tests/baselines/reference/es5-asyncFunctionNestedLoops.types new file mode 100644 index 00000000000..3a2913e65b1 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionNestedLoops.types @@ -0,0 +1,33 @@ +=== tests/cases/compiler/es5-asyncFunctionNestedLoops.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function nestedLoops() { +>nestedLoops : () => Promise + + A: while (x) { +>A : any +>x : any + + await y; +>await y : any +>y : any + + while (z) { +>z : any + + continue A; +>A : any + } + while (a) { +>a : any + + continue; + } + } +} diff --git a/tests/baselines/reference/es5-asyncFunctionNewExpressions.js b/tests/baselines/reference/es5-asyncFunctionNewExpressions.js new file mode 100644 index 00000000000..b7d4514d24e --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionNewExpressions.js @@ -0,0 +1,386 @@ +//// [es5-asyncFunctionNewExpressions.ts] +declare var x, y, z, a, b, c; + +async function newExpression0() { + await new x(y, z); +} + +async function newExpression1() { + new (await x)(y, z); +} + +async function newExpression2() { + new x(await y, z); +} + +async function newExpression3() { + new x(y, await z); +} + +async function newExpression4() { + await new x(...y, z); +} + +async function newExpression5() { + new (await x)(...y, z); +} + +async function newExpression6() { + new x(...(await y), z); +} + +async function newExpression7() { + new x(...y, await z); +} + +async function newExpression8() { + new x(await y, ...z); +} + +async function newExpression9() { + new x(y, ...(await z)); +} + +async function newExpression10() { + await new x.a(y, z); +} + +async function newExpression11() { + new (await x.a)(y, z); +} + +async function newExpression12() { + new (await x).a(y, z); +} + +async function newExpression13() { + new x.a(await y, z); +} + +async function newExpression14() { + new x.a(y, await z); +} + +async function newExpression15() { + await new x[a](y, z); +} + +async function newExpression16() { + new (await x[a])(y, z); +} + +async function newExpression17() { + new (await x)[a](y, z); +} + +async function newExpression18() { + new x[await a](y, z); +} + +async function newExpression19() { + new x[a](await y, z); +} + +async function newExpression20() { + new x[a](y, await z); +} + +//// [es5-asyncFunctionNewExpressions.js] +function newExpression0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, new x(y, z)]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression1() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + new (_a.sent())(y, z); + return [2 /*return*/]; + } + }); + }); +} +function newExpression2() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = x.bind; + return [4 /*yield*/, y]; + case 1: + new (_a.apply(x, [_c.sent(), z]))(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression3() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = x.bind; + _b = [y]; + return [4 /*yield*/, z]; + case 1: + new (_a.apply(x, _b.concat([_c.sent()])))(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression4() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, new (x.bind.apply(x, [void 0].concat(y, [z])))()]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression5() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: return [4 /*yield*/, x]; + case 1: + new ((_a = (_b.sent())).bind.apply(_a, [void 0].concat(y, [z])))(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression6() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c, _d, _e, _f; + return __generator(function (_g) { + switch (_g.label) { + case 0: + _b = (_a = x.bind).apply; + _c = [x]; + _e = (_d = [void 0]).concat; + return [4 /*yield*/, y]; + case 1: + new (_b.apply(_a, _c.concat([_e.apply(_d, [(_g.sent()), [z]])])))(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression7() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c, _d, _e, _f, _g; + return __generator(function (_h) { + switch (_h.label) { + case 0: + _b = (_a = x.bind).apply; + _c = [x]; + _e = (_d = [void 0]).concat; + _f = [y]; + return [4 /*yield*/, z]; + case 1: + new (_b.apply(_a, _c.concat([_e.apply(_d, _f.concat([[_h.sent()]]))])))(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression8() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c, _d; + return __generator(function (_e) { + switch (_e.label) { + case 0: + _b = (_a = x.bind).apply; + _c = [x]; + _d = [void 0]; + return [4 /*yield*/, y]; + case 1: + new (_b.apply(_a, _c.concat([_d.concat([_e.sent()]).concat(z)])))(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression9() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c, _d, _e, _f; + return __generator(function (_g) { + switch (_g.label) { + case 0: + _b = (_a = x.bind).apply; + _c = [x]; + _e = (_d = [void 0, y]).concat; + return [4 /*yield*/, z]; + case 1: + new (_b.apply(_a, _c.concat([_e.apply(_d, [(_g.sent())])])))(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression10() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, new x.a(y, z)]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression11() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x.a]; + case 1: + new (_a.sent())(y, z); + return [2 /*return*/]; + } + }); + }); +} +function newExpression12() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + new (_a.sent()).a(y, z); + return [2 /*return*/]; + } + }); + }); +} +function newExpression13() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _b = (_a = x.a).bind; + return [4 /*yield*/, y]; + case 1: + new (_b.apply(_a, [_d.sent(), z]))(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression14() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _b = (_a = x.a).bind; + _c = [y]; + return [4 /*yield*/, z]; + case 1: + new (_b.apply(_a, _c.concat([_d.sent()])))(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression15() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, new x[a](y, z)]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression16() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x[a]]; + case 1: + new (_a.sent())(y, z); + return [2 /*return*/]; + } + }); + }); +} +function newExpression17() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + new (_a.sent())[a](y, z); + return [2 /*return*/]; + } + }); + }); +} +function newExpression18() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, a]; + case 1: + new _a[_b.sent()](y, z); + return [2 /*return*/]; + } + }); + }); +} +function newExpression19() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _b = (_a = x[a]).bind; + return [4 /*yield*/, y]; + case 1: + new (_b.apply(_a, [_d.sent(), z]))(); + return [2 /*return*/]; + } + }); + }); +} +function newExpression20() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + _b = (_a = x[a]).bind; + _c = [y]; + return [4 /*yield*/, z]; + case 1: + new (_b.apply(_a, _c.concat([_d.sent()])))(); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionNewExpressions.symbols b/tests/baselines/reference/es5-asyncFunctionNewExpressions.symbols new file mode 100644 index 00000000000..19309bd19fe --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionNewExpressions.symbols @@ -0,0 +1,203 @@ +=== tests/cases/compiler/es5-asyncFunctionNewExpressions.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionNewExpressions.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionNewExpressions.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionNewExpressions.ts, 0, 26)) + +async function newExpression0() { +>newExpression0 : Symbol(newExpression0, Decl(es5-asyncFunctionNewExpressions.ts, 0, 29)) + + await new x(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression1() { +>newExpression1 : Symbol(newExpression1, Decl(es5-asyncFunctionNewExpressions.ts, 4, 1)) + + new (await x)(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression2() { +>newExpression2 : Symbol(newExpression2, Decl(es5-asyncFunctionNewExpressions.ts, 8, 1)) + + new x(await y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression3() { +>newExpression3 : Symbol(newExpression3, Decl(es5-asyncFunctionNewExpressions.ts, 12, 1)) + + new x(y, await z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression4() { +>newExpression4 : Symbol(newExpression4, Decl(es5-asyncFunctionNewExpressions.ts, 16, 1)) + + await new x(...y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression5() { +>newExpression5 : Symbol(newExpression5, Decl(es5-asyncFunctionNewExpressions.ts, 20, 1)) + + new (await x)(...y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression6() { +>newExpression6 : Symbol(newExpression6, Decl(es5-asyncFunctionNewExpressions.ts, 24, 1)) + + new x(...(await y), z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression7() { +>newExpression7 : Symbol(newExpression7, Decl(es5-asyncFunctionNewExpressions.ts, 28, 1)) + + new x(...y, await z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression8() { +>newExpression8 : Symbol(newExpression8, Decl(es5-asyncFunctionNewExpressions.ts, 32, 1)) + + new x(await y, ...z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression9() { +>newExpression9 : Symbol(newExpression9, Decl(es5-asyncFunctionNewExpressions.ts, 36, 1)) + + new x(y, ...(await z)); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression10() { +>newExpression10 : Symbol(newExpression10, Decl(es5-asyncFunctionNewExpressions.ts, 40, 1)) + + await new x.a(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression11() { +>newExpression11 : Symbol(newExpression11, Decl(es5-asyncFunctionNewExpressions.ts, 44, 1)) + + new (await x.a)(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression12() { +>newExpression12 : Symbol(newExpression12, Decl(es5-asyncFunctionNewExpressions.ts, 48, 1)) + + new (await x).a(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression13() { +>newExpression13 : Symbol(newExpression13, Decl(es5-asyncFunctionNewExpressions.ts, 52, 1)) + + new x.a(await y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression14() { +>newExpression14 : Symbol(newExpression14, Decl(es5-asyncFunctionNewExpressions.ts, 56, 1)) + + new x.a(y, await z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression15() { +>newExpression15 : Symbol(newExpression15, Decl(es5-asyncFunctionNewExpressions.ts, 60, 1)) + + await new x[a](y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionNewExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression16() { +>newExpression16 : Symbol(newExpression16, Decl(es5-asyncFunctionNewExpressions.ts, 64, 1)) + + new (await x[a])(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionNewExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression17() { +>newExpression17 : Symbol(newExpression17, Decl(es5-asyncFunctionNewExpressions.ts, 68, 1)) + + new (await x)[a](y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionNewExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression18() { +>newExpression18 : Symbol(newExpression18, Decl(es5-asyncFunctionNewExpressions.ts, 72, 1)) + + new x[await a](y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionNewExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression19() { +>newExpression19 : Symbol(newExpression19, Decl(es5-asyncFunctionNewExpressions.ts, 76, 1)) + + new x[a](await y, z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionNewExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} + +async function newExpression20() { +>newExpression20 : Symbol(newExpression20, Decl(es5-asyncFunctionNewExpressions.ts, 80, 1)) + + new x[a](y, await z); +>x : Symbol(x, Decl(es5-asyncFunctionNewExpressions.ts, 0, 11)) +>a : Symbol(a, Decl(es5-asyncFunctionNewExpressions.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionNewExpressions.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionNewExpressions.ts, 0, 17)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionNewExpressions.types b/tests/baselines/reference/es5-asyncFunctionNewExpressions.types new file mode 100644 index 00000000000..c6390430380 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionNewExpressions.types @@ -0,0 +1,275 @@ +=== tests/cases/compiler/es5-asyncFunctionNewExpressions.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function newExpression0() { +>newExpression0 : () => Promise + + await new x(y, z); +>await new x(y, z) : any +>new x(y, z) : any +>x : any +>y : any +>z : any +} + +async function newExpression1() { +>newExpression1 : () => Promise + + new (await x)(y, z); +>new (await x)(y, z) : any +>(await x) : any +>await x : any +>x : any +>y : any +>z : any +} + +async function newExpression2() { +>newExpression2 : () => Promise + + new x(await y, z); +>new x(await y, z) : any +>x : any +>await y : any +>y : any +>z : any +} + +async function newExpression3() { +>newExpression3 : () => Promise + + new x(y, await z); +>new x(y, await z) : any +>x : any +>y : any +>await z : any +>z : any +} + +async function newExpression4() { +>newExpression4 : () => Promise + + await new x(...y, z); +>await new x(...y, z) : any +>new x(...y, z) : any +>x : any +>...y : any +>y : any +>z : any +} + +async function newExpression5() { +>newExpression5 : () => Promise + + new (await x)(...y, z); +>new (await x)(...y, z) : any +>(await x) : any +>await x : any +>x : any +>...y : any +>y : any +>z : any +} + +async function newExpression6() { +>newExpression6 : () => Promise + + new x(...(await y), z); +>new x(...(await y), z) : any +>x : any +>...(await y) : any +>(await y) : any +>await y : any +>y : any +>z : any +} + +async function newExpression7() { +>newExpression7 : () => Promise + + new x(...y, await z); +>new x(...y, await z) : any +>x : any +>...y : any +>y : any +>await z : any +>z : any +} + +async function newExpression8() { +>newExpression8 : () => Promise + + new x(await y, ...z); +>new x(await y, ...z) : any +>x : any +>await y : any +>y : any +>...z : any +>z : any +} + +async function newExpression9() { +>newExpression9 : () => Promise + + new x(y, ...(await z)); +>new x(y, ...(await z)) : any +>x : any +>y : any +>...(await z) : any +>(await z) : any +>await z : any +>z : any +} + +async function newExpression10() { +>newExpression10 : () => Promise + + await new x.a(y, z); +>await new x.a(y, z) : any +>new x.a(y, z) : any +>x.a : any +>x : any +>a : any +>y : any +>z : any +} + +async function newExpression11() { +>newExpression11 : () => Promise + + new (await x.a)(y, z); +>new (await x.a)(y, z) : any +>(await x.a) : any +>await x.a : any +>x.a : any +>x : any +>a : any +>y : any +>z : any +} + +async function newExpression12() { +>newExpression12 : () => Promise + + new (await x).a(y, z); +>new (await x).a(y, z) : any +>(await x).a : any +>(await x) : any +>await x : any +>x : any +>a : any +>y : any +>z : any +} + +async function newExpression13() { +>newExpression13 : () => Promise + + new x.a(await y, z); +>new x.a(await y, z) : any +>x.a : any +>x : any +>a : any +>await y : any +>y : any +>z : any +} + +async function newExpression14() { +>newExpression14 : () => Promise + + new x.a(y, await z); +>new x.a(y, await z) : any +>x.a : any +>x : any +>a : any +>y : any +>await z : any +>z : any +} + +async function newExpression15() { +>newExpression15 : () => Promise + + await new x[a](y, z); +>await new x[a](y, z) : any +>new x[a](y, z) : any +>x[a] : any +>x : any +>a : any +>y : any +>z : any +} + +async function newExpression16() { +>newExpression16 : () => Promise + + new (await x[a])(y, z); +>new (await x[a])(y, z) : any +>(await x[a]) : any +>await x[a] : any +>x[a] : any +>x : any +>a : any +>y : any +>z : any +} + +async function newExpression17() { +>newExpression17 : () => Promise + + new (await x)[a](y, z); +>new (await x)[a](y, z) : any +>(await x)[a] : any +>(await x) : any +>await x : any +>x : any +>a : any +>y : any +>z : any +} + +async function newExpression18() { +>newExpression18 : () => Promise + + new x[await a](y, z); +>new x[await a](y, z) : any +>x[await a] : any +>x : any +>await a : any +>a : any +>y : any +>z : any +} + +async function newExpression19() { +>newExpression19 : () => Promise + + new x[a](await y, z); +>new x[a](await y, z) : any +>x[a] : any +>x : any +>a : any +>await y : any +>y : any +>z : any +} + +async function newExpression20() { +>newExpression20 : () => Promise + + new x[a](y, await z); +>new x[a](y, await z) : any +>x[a] : any +>x : any +>a : any +>y : any +>await z : any +>z : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionObjectLiterals.js b/tests/baselines/reference/es5-asyncFunctionObjectLiterals.js new file mode 100644 index 00000000000..1c5d1fcd23b --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionObjectLiterals.js @@ -0,0 +1,177 @@ +//// [es5-asyncFunctionObjectLiterals.ts] +declare var x, y, z, a, b, c; + +async function objectLiteral0() { + x = { + a: await y, + b: z + }; +} + +async function objectLiteral1() { + x = { + a: y, + b: await z + }; +} + +async function objectLiteral2() { + x = { + [await a]: y, + b: z + }; +} + +async function objectLiteral3() { + x = { + [a]: await y, + b: z + }; +} + +async function objectLiteral4() { + x = { + a: await y, + [b]: z + }; +} + +async function objectLiteral5() { + x = { + a: y, + [await b]: z + }; +} + +async function objectLiteral6() { + x = { + a: y, + [b]: await z + }; +} + +//// [es5-asyncFunctionObjectLiterals.js] +function objectLiteral0() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = {}; + return [4 /*yield*/, y]; + case 1: + x = (_a.a = _b.sent(), + _a.b = z, + _a); + return [2 /*return*/]; + } + }); + }); +} +function objectLiteral1() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = { + a: y + }; + return [4 /*yield*/, z]; + case 1: + x = (_a.b = _b.sent(), + _a); + return [2 /*return*/]; + } + }); + }); +} +function objectLiteral2() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = {}; + return [4 /*yield*/, a]; + case 1: + x = (_a[_b.sent()] = y, + _a.b = z, + _a); + return [2 /*return*/]; + } + }); + }); +} +function objectLiteral3() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _b = {}; + _a = a; + return [4 /*yield*/, y]; + case 1: + x = (_b[_a] = _c.sent(), + _b.b = z, + _b); + return [2 /*return*/]; + } + }); + }); +} +function objectLiteral4() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = {}; + return [4 /*yield*/, y]; + case 1: + x = (_a.a = _b.sent(), + _a[b] = z, + _a); + return [2 /*return*/]; + } + }); + }); +} +function objectLiteral5() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = { + a: y + }; + return [4 /*yield*/, b]; + case 1: + x = (_a[_b.sent()] = z, + _a); + return [2 /*return*/]; + } + }); + }); +} +function objectLiteral6() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _b = { + a: y + }; + _a = b; + return [4 /*yield*/, z]; + case 1: + x = (_b[_a] = _c.sent(), + _b); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionObjectLiterals.symbols b/tests/baselines/reference/es5-asyncFunctionObjectLiterals.symbols new file mode 100644 index 00000000000..dd84a5c11f4 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionObjectLiterals.symbols @@ -0,0 +1,127 @@ +=== tests/cases/compiler/es5-asyncFunctionObjectLiterals.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 26)) + +async function objectLiteral0() { +>objectLiteral0 : Symbol(objectLiteral0, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 29)) + + x = { +>x : Symbol(x, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 11)) + + a: await y, +>a : Symbol(a, Decl(es5-asyncFunctionObjectLiterals.ts, 3, 9)) +>y : Symbol(y, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 14)) + + b: z +>b : Symbol(b, Decl(es5-asyncFunctionObjectLiterals.ts, 4, 19)) +>z : Symbol(z, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 17)) + + }; +} + +async function objectLiteral1() { +>objectLiteral1 : Symbol(objectLiteral1, Decl(es5-asyncFunctionObjectLiterals.ts, 7, 1)) + + x = { +>x : Symbol(x, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 11)) + + a: y, +>a : Symbol(a, Decl(es5-asyncFunctionObjectLiterals.ts, 10, 9)) +>y : Symbol(y, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 14)) + + b: await z +>b : Symbol(b, Decl(es5-asyncFunctionObjectLiterals.ts, 11, 13)) +>z : Symbol(z, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 17)) + + }; +} + +async function objectLiteral2() { +>objectLiteral2 : Symbol(objectLiteral2, Decl(es5-asyncFunctionObjectLiterals.ts, 14, 1)) + + x = { +>x : Symbol(x, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 11)) + + [await a]: y, +>a : Symbol(a, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 14)) + + b: z +>b : Symbol(b, Decl(es5-asyncFunctionObjectLiterals.ts, 18, 21)) +>z : Symbol(z, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 17)) + + }; +} + +async function objectLiteral3() { +>objectLiteral3 : Symbol(objectLiteral3, Decl(es5-asyncFunctionObjectLiterals.ts, 21, 1)) + + x = { +>x : Symbol(x, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 11)) + + [a]: await y, +>a : Symbol(a, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 20)) +>y : Symbol(y, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 14)) + + b: z +>b : Symbol(b, Decl(es5-asyncFunctionObjectLiterals.ts, 25, 21)) +>z : Symbol(z, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 17)) + + }; +} + +async function objectLiteral4() { +>objectLiteral4 : Symbol(objectLiteral4, Decl(es5-asyncFunctionObjectLiterals.ts, 28, 1)) + + x = { +>x : Symbol(x, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 11)) + + a: await y, +>a : Symbol(a, Decl(es5-asyncFunctionObjectLiterals.ts, 31, 9)) +>y : Symbol(y, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 14)) + + [b]: z +>b : Symbol(b, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 23)) +>z : Symbol(z, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 17)) + + }; +} + +async function objectLiteral5() { +>objectLiteral5 : Symbol(objectLiteral5, Decl(es5-asyncFunctionObjectLiterals.ts, 35, 1)) + + x = { +>x : Symbol(x, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 11)) + + a: y, +>a : Symbol(a, Decl(es5-asyncFunctionObjectLiterals.ts, 38, 9)) +>y : Symbol(y, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 14)) + + [await b]: z +>b : Symbol(b, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 23)) +>z : Symbol(z, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 17)) + + }; +} + +async function objectLiteral6() { +>objectLiteral6 : Symbol(objectLiteral6, Decl(es5-asyncFunctionObjectLiterals.ts, 42, 1)) + + x = { +>x : Symbol(x, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 11)) + + a: y, +>a : Symbol(a, Decl(es5-asyncFunctionObjectLiterals.ts, 45, 9)) +>y : Symbol(y, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 14)) + + [b]: await z +>b : Symbol(b, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 23)) +>z : Symbol(z, Decl(es5-asyncFunctionObjectLiterals.ts, 0, 17)) + + }; +} diff --git a/tests/baselines/reference/es5-asyncFunctionObjectLiterals.types b/tests/baselines/reference/es5-asyncFunctionObjectLiterals.types new file mode 100644 index 00000000000..d37dd8a6ceb --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionObjectLiterals.types @@ -0,0 +1,148 @@ +=== tests/cases/compiler/es5-asyncFunctionObjectLiterals.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function objectLiteral0() { +>objectLiteral0 : () => Promise + + x = { +>x = { a: await y, b: z } : { a: any; b: any; } +>x : any +>{ a: await y, b: z } : { a: any; b: any; } + + a: await y, +>a : any +>await y : any +>y : any + + b: z +>b : any +>z : any + + }; +} + +async function objectLiteral1() { +>objectLiteral1 : () => Promise + + x = { +>x = { a: y, b: await z } : { a: any; b: any; } +>x : any +>{ a: y, b: await z } : { a: any; b: any; } + + a: y, +>a : any +>y : any + + b: await z +>b : any +>await z : any +>z : any + + }; +} + +async function objectLiteral2() { +>objectLiteral2 : () => Promise + + x = { +>x = { [await a]: y, b: z } : { [x: number]: any; b: any; } +>x : any +>{ [await a]: y, b: z } : { [x: number]: any; b: any; } + + [await a]: y, +>await a : any +>a : any +>y : any + + b: z +>b : any +>z : any + + }; +} + +async function objectLiteral3() { +>objectLiteral3 : () => Promise + + x = { +>x = { [a]: await y, b: z } : { [x: number]: any; b: any; } +>x : any +>{ [a]: await y, b: z } : { [x: number]: any; b: any; } + + [a]: await y, +>a : any +>await y : any +>y : any + + b: z +>b : any +>z : any + + }; +} + +async function objectLiteral4() { +>objectLiteral4 : () => Promise + + x = { +>x = { a: await y, [b]: z } : { [x: number]: any; a: any; } +>x : any +>{ a: await y, [b]: z } : { [x: number]: any; a: any; } + + a: await y, +>a : any +>await y : any +>y : any + + [b]: z +>b : any +>z : any + + }; +} + +async function objectLiteral5() { +>objectLiteral5 : () => Promise + + x = { +>x = { a: y, [await b]: z } : { [x: number]: any; a: any; } +>x : any +>{ a: y, [await b]: z } : { [x: number]: any; a: any; } + + a: y, +>a : any +>y : any + + [await b]: z +>await b : any +>b : any +>z : any + + }; +} + +async function objectLiteral6() { +>objectLiteral6 : () => Promise + + x = { +>x = { a: y, [b]: await z } : { [x: number]: any; a: any; } +>x : any +>{ a: y, [b]: await z } : { [x: number]: any; a: any; } + + a: y, +>a : any +>y : any + + [b]: await z +>b : any +>await z : any +>z : any + + }; +} diff --git a/tests/baselines/reference/es5-asyncFunctionPropertyAccess.js b/tests/baselines/reference/es5-asyncFunctionPropertyAccess.js new file mode 100644 index 00000000000..47110ff11bc --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionPropertyAccess.js @@ -0,0 +1,52 @@ +//// [es5-asyncFunctionPropertyAccess.ts] +declare var x, y, z, a, b, c; + +async function propertyAccess0() { + y = await x.a; +} + +async function propertyAccess1() { + y = (await x).a; +} + +async function callExpression0() { + await x(y, z); +} + +//// [es5-asyncFunctionPropertyAccess.js] +function propertyAccess0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x.a]; + case 1: + y = _a.sent(); + return [2 /*return*/]; + } + }); + }); +} +function propertyAccess1() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + y = (_a.sent()).a; + return [2 /*return*/]; + } + }); + }); +} +function callExpression0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x(y, z)]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionPropertyAccess.symbols b/tests/baselines/reference/es5-asyncFunctionPropertyAccess.symbols new file mode 100644 index 00000000000..22f7bcc9546 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionPropertyAccess.symbols @@ -0,0 +1,33 @@ +=== tests/cases/compiler/es5-asyncFunctionPropertyAccess.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 26)) + +async function propertyAccess0() { +>propertyAccess0 : Symbol(propertyAccess0, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 29)) + + y = await x.a; +>y : Symbol(y, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 14)) +>x : Symbol(x, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 11)) +} + +async function propertyAccess1() { +>propertyAccess1 : Symbol(propertyAccess1, Decl(es5-asyncFunctionPropertyAccess.ts, 4, 1)) + + y = (await x).a; +>y : Symbol(y, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 14)) +>x : Symbol(x, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 11)) +} + +async function callExpression0() { +>callExpression0 : Symbol(callExpression0, Decl(es5-asyncFunctionPropertyAccess.ts, 8, 1)) + + await x(y, z); +>x : Symbol(x, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionPropertyAccess.ts, 0, 17)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionPropertyAccess.types b/tests/baselines/reference/es5-asyncFunctionPropertyAccess.types new file mode 100644 index 00000000000..a6f7980e8ba --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionPropertyAccess.types @@ -0,0 +1,44 @@ +=== tests/cases/compiler/es5-asyncFunctionPropertyAccess.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function propertyAccess0() { +>propertyAccess0 : () => Promise + + y = await x.a; +>y = await x.a : any +>y : any +>await x.a : any +>x.a : any +>x : any +>a : any +} + +async function propertyAccess1() { +>propertyAccess1 : () => Promise + + y = (await x).a; +>y = (await x).a : any +>y : any +>(await x).a : any +>(await x) : any +>await x : any +>x : any +>a : any +} + +async function callExpression0() { +>callExpression0 : () => Promise + + await x(y, z); +>await x(y, z) : any +>x(y, z) : any +>x : any +>y : any +>z : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionReturnStatements.js b/tests/baselines/reference/es5-asyncFunctionReturnStatements.js new file mode 100644 index 00000000000..df279f3680d --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionReturnStatements.js @@ -0,0 +1,88 @@ +//// [es5-asyncFunctionReturnStatements.ts] +declare var x, y, z, a, b, c; + +async function returnStatement0(): Promise { + return; +} + +async function returnStatement1(): Promise { + return x; +} + +async function returnStatement2(): Promise { + return await x; +} + +async function returnStatement3(): Promise { + { return; } +} + +async function returnStatement4(): Promise { + await x; + { return; } +} + +async function returnStatement5(): Promise{ + { return await x; } +} + +//// [es5-asyncFunctionReturnStatements.js] +function returnStatement0() { + return __awaiter(this, void 0, Promise, function () { + return __generator(function (_a) { + return [2 /*return*/]; + }); + }); +} +function returnStatement1() { + return __awaiter(this, void 0, Promise, function () { + return __generator(function (_a) { + return [2 /*return*/, x]; + }); + }); +} +function returnStatement2() { + return __awaiter(this, void 0, Promise, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: return [2 /*return*/, _a.sent()]; + } + }); + }); +} +function returnStatement3() { + return __awaiter(this, void 0, Promise, function () { + return __generator(function (_a) { + { + return [2 /*return*/]; + } + return [2 /*return*/]; + }); + }); +} +function returnStatement4() { + return __awaiter(this, void 0, Promise, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a.sent(); + { + return [2 /*return*/]; + } + return [2 /*return*/]; + } + }); + }); +} +function returnStatement5() { + return __awaiter(this, void 0, Promise, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: return [2 /*return*/, _a.sent()]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionReturnStatements.symbols b/tests/baselines/reference/es5-asyncFunctionReturnStatements.symbols new file mode 100644 index 00000000000..651af244e70 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionReturnStatements.symbols @@ -0,0 +1,56 @@ +=== tests/cases/compiler/es5-asyncFunctionReturnStatements.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionReturnStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionReturnStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionReturnStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionReturnStatements.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionReturnStatements.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionReturnStatements.ts, 0, 26)) + +async function returnStatement0(): Promise { +>returnStatement0 : Symbol(returnStatement0, Decl(es5-asyncFunctionReturnStatements.ts, 0, 29)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + return; +} + +async function returnStatement1(): Promise { +>returnStatement1 : Symbol(returnStatement1, Decl(es5-asyncFunctionReturnStatements.ts, 4, 1)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + return x; +>x : Symbol(x, Decl(es5-asyncFunctionReturnStatements.ts, 0, 11)) +} + +async function returnStatement2(): Promise { +>returnStatement2 : Symbol(returnStatement2, Decl(es5-asyncFunctionReturnStatements.ts, 8, 1)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + return await x; +>x : Symbol(x, Decl(es5-asyncFunctionReturnStatements.ts, 0, 11)) +} + +async function returnStatement3(): Promise { +>returnStatement3 : Symbol(returnStatement3, Decl(es5-asyncFunctionReturnStatements.ts, 12, 1)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + { return; } +} + +async function returnStatement4(): Promise { +>returnStatement4 : Symbol(returnStatement4, Decl(es5-asyncFunctionReturnStatements.ts, 16, 1)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + await x; +>x : Symbol(x, Decl(es5-asyncFunctionReturnStatements.ts, 0, 11)) + + { return; } +} + +async function returnStatement5(): Promise{ +>returnStatement5 : Symbol(returnStatement5, Decl(es5-asyncFunctionReturnStatements.ts, 21, 1)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + { return await x; } +>x : Symbol(x, Decl(es5-asyncFunctionReturnStatements.ts, 0, 11)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionReturnStatements.types b/tests/baselines/reference/es5-asyncFunctionReturnStatements.types new file mode 100644 index 00000000000..486bc5c5566 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionReturnStatements.types @@ -0,0 +1,59 @@ +=== tests/cases/compiler/es5-asyncFunctionReturnStatements.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function returnStatement0(): Promise { +>returnStatement0 : () => Promise +>Promise : Promise + + return; +} + +async function returnStatement1(): Promise { +>returnStatement1 : () => Promise +>Promise : Promise + + return x; +>x : any +} + +async function returnStatement2(): Promise { +>returnStatement2 : () => Promise +>Promise : Promise + + return await x; +>await x : any +>x : any +} + +async function returnStatement3(): Promise { +>returnStatement3 : () => Promise +>Promise : Promise + + { return; } +} + +async function returnStatement4(): Promise { +>returnStatement4 : () => Promise +>Promise : Promise + + await x; +>await x : any +>x : any + + { return; } +} + +async function returnStatement5(): Promise{ +>returnStatement5 : () => Promise +>Promise : Promise + + { return await x; } +>await x : any +>x : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionSwitchStatements.js b/tests/baselines/reference/es5-asyncFunctionSwitchStatements.js new file mode 100644 index 00000000000..7c6da63dfe4 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionSwitchStatements.js @@ -0,0 +1,289 @@ +//// [es5-asyncFunctionSwitchStatements.ts] +declare var x, y, z, a, b, c; + +async function switchStatement0() { + switch (x) { + case y: a; break; + default: b; break; + } +} + +async function switchStatement1() { + switch (await x) { + case y: a; break; + default: b; break; + } +} + +async function switchStatement2() { + switch (x) { + case await y: a; break; + default: b; break; + } +} + +async function switchStatement3() { + switch (x) { + case y: await a; break; + default: b; break; + } +} + +async function switchStatement4() { + switch (x) { + case y: a; break; + default: await b; break; + } +} + +async function switchStatement5() { + switch (x) { + case y: a; break; + case await z: b; break; + } +} + +async function switchStatement6() { + switch (x) { + default: c; break; + case await y: a; break; + case z: b; break; + } +} + +async function switchStatement7() { + switch (x) { + default: c; break; + case y: a; break; + case await z: b; break; + } +} + +async function switchStatement8() { + switch (x) { + default: c; + case y: a; break; + case await z: b; break; + } +} + +//// [es5-asyncFunctionSwitchStatements.js] +function switchStatement0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (x) { + case y: + a; + break; + default: + b; + break; + } + return [2 /*return*/]; + }); + }); +} +function switchStatement1() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + switch (_a.sent()) { + case y: + a; + break; + default: + b; + break; + } + return [2 /*return*/]; + } + }); + }); +} +function switchStatement2() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, y]; + case 1: + switch (_a) { + case _b.sent(): return [3 /*break*/, 2]; + } + return [3 /*break*/, 3]; + case 2: + a; + return [3 /*break*/, 4]; + case 3: + b; + return [3 /*break*/, 4]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function switchStatement3() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + switch (_a) { + case y: return [3 /*break*/, 1]; + } + return [3 /*break*/, 3]; + case 1: return [4 /*yield*/, a]; + case 2: + _b.sent(); + return [3 /*break*/, 4]; + case 3: + b; + return [3 /*break*/, 4]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function switchStatement4() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + switch (_a) { + case y: return [3 /*break*/, 1]; + } + return [3 /*break*/, 2]; + case 1: + a; + return [3 /*break*/, 4]; + case 2: return [4 /*yield*/, b]; + case 3: + _b.sent(); + return [3 /*break*/, 4]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function switchStatement5() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + switch (_a) { + case y: return [3 /*break*/, 2]; + } + return [4 /*yield*/, z]; + case 1: + switch (_a) { + case _b.sent(): return [3 /*break*/, 3]; + } + return [3 /*break*/, 4]; + case 2: + a; + return [3 /*break*/, 4]; + case 3: + b; + return [3 /*break*/, 4]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function switchStatement6() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + return [4 /*yield*/, y]; + case 1: + switch (_a) { + case _b.sent(): return [3 /*break*/, 3]; + case z: return [3 /*break*/, 4]; + } + return [3 /*break*/, 2]; + case 2: + c; + return [3 /*break*/, 5]; + case 3: + a; + return [3 /*break*/, 5]; + case 4: + b; + return [3 /*break*/, 5]; + case 5: return [2 /*return*/]; + } + }); + }); +} +function switchStatement7() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + switch (_a) { + case y: return [3 /*break*/, 3]; + } + return [4 /*yield*/, z]; + case 1: + switch (_a) { + case _b.sent(): return [3 /*break*/, 4]; + } + return [3 /*break*/, 2]; + case 2: + c; + return [3 /*break*/, 5]; + case 3: + a; + return [3 /*break*/, 5]; + case 4: + b; + return [3 /*break*/, 5]; + case 5: return [2 /*return*/]; + } + }); + }); +} +function switchStatement8() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + switch (_a) { + case y: return [3 /*break*/, 3]; + } + return [4 /*yield*/, z]; + case 1: + switch (_a) { + case _b.sent(): return [3 /*break*/, 4]; + } + return [3 /*break*/, 2]; + case 2: + c; + _b.label = 3; + case 3: + a; + return [3 /*break*/, 5]; + case 4: + b; + return [3 /*break*/, 5]; + case 5: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionSwitchStatements.symbols b/tests/baselines/reference/es5-asyncFunctionSwitchStatements.symbols new file mode 100644 index 00000000000..668339af576 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionSwitchStatements.symbols @@ -0,0 +1,156 @@ +=== tests/cases/compiler/es5-asyncFunctionSwitchStatements.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 26)) + +async function switchStatement0() { +>switchStatement0 : Symbol(switchStatement0, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 29)) + + switch (x) { +>x : Symbol(x, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 11)) + + case y: a; break; +>y : Symbol(y, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 14)) +>a : Symbol(a, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 20)) + + default: b; break; +>b : Symbol(b, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 23)) + } +} + +async function switchStatement1() { +>switchStatement1 : Symbol(switchStatement1, Decl(es5-asyncFunctionSwitchStatements.ts, 7, 1)) + + switch (await x) { +>x : Symbol(x, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 11)) + + case y: a; break; +>y : Symbol(y, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 14)) +>a : Symbol(a, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 20)) + + default: b; break; +>b : Symbol(b, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 23)) + } +} + +async function switchStatement2() { +>switchStatement2 : Symbol(switchStatement2, Decl(es5-asyncFunctionSwitchStatements.ts, 14, 1)) + + switch (x) { +>x : Symbol(x, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 11)) + + case await y: a; break; +>y : Symbol(y, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 14)) +>a : Symbol(a, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 20)) + + default: b; break; +>b : Symbol(b, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 23)) + } +} + +async function switchStatement3() { +>switchStatement3 : Symbol(switchStatement3, Decl(es5-asyncFunctionSwitchStatements.ts, 21, 1)) + + switch (x) { +>x : Symbol(x, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 11)) + + case y: await a; break; +>y : Symbol(y, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 14)) +>a : Symbol(a, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 20)) + + default: b; break; +>b : Symbol(b, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 23)) + } +} + +async function switchStatement4() { +>switchStatement4 : Symbol(switchStatement4, Decl(es5-asyncFunctionSwitchStatements.ts, 28, 1)) + + switch (x) { +>x : Symbol(x, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 11)) + + case y: a; break; +>y : Symbol(y, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 14)) +>a : Symbol(a, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 20)) + + default: await b; break; +>b : Symbol(b, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 23)) + } +} + +async function switchStatement5() { +>switchStatement5 : Symbol(switchStatement5, Decl(es5-asyncFunctionSwitchStatements.ts, 35, 1)) + + switch (x) { +>x : Symbol(x, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 11)) + + case y: a; break; +>y : Symbol(y, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 14)) +>a : Symbol(a, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 20)) + + case await z: b; break; +>z : Symbol(z, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 17)) +>b : Symbol(b, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 23)) + } +} + +async function switchStatement6() { +>switchStatement6 : Symbol(switchStatement6, Decl(es5-asyncFunctionSwitchStatements.ts, 42, 1)) + + switch (x) { +>x : Symbol(x, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 11)) + + default: c; break; +>c : Symbol(c, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 26)) + + case await y: a; break; +>y : Symbol(y, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 14)) +>a : Symbol(a, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 20)) + + case z: b; break; +>z : Symbol(z, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 17)) +>b : Symbol(b, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 23)) + } +} + +async function switchStatement7() { +>switchStatement7 : Symbol(switchStatement7, Decl(es5-asyncFunctionSwitchStatements.ts, 50, 1)) + + switch (x) { +>x : Symbol(x, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 11)) + + default: c; break; +>c : Symbol(c, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 26)) + + case y: a; break; +>y : Symbol(y, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 14)) +>a : Symbol(a, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 20)) + + case await z: b; break; +>z : Symbol(z, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 17)) +>b : Symbol(b, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 23)) + } +} + +async function switchStatement8() { +>switchStatement8 : Symbol(switchStatement8, Decl(es5-asyncFunctionSwitchStatements.ts, 58, 1)) + + switch (x) { +>x : Symbol(x, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 11)) + + default: c; +>c : Symbol(c, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 26)) + + case y: a; break; +>y : Symbol(y, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 14)) +>a : Symbol(a, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 20)) + + case await z: b; break; +>z : Symbol(z, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 17)) +>b : Symbol(b, Decl(es5-asyncFunctionSwitchStatements.ts, 0, 23)) + } +} diff --git a/tests/baselines/reference/es5-asyncFunctionSwitchStatements.types b/tests/baselines/reference/es5-asyncFunctionSwitchStatements.types new file mode 100644 index 00000000000..694e7cdc89d --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionSwitchStatements.types @@ -0,0 +1,164 @@ +=== tests/cases/compiler/es5-asyncFunctionSwitchStatements.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function switchStatement0() { +>switchStatement0 : () => Promise + + switch (x) { +>x : any + + case y: a; break; +>y : any +>a : any + + default: b; break; +>b : any + } +} + +async function switchStatement1() { +>switchStatement1 : () => Promise + + switch (await x) { +>await x : any +>x : any + + case y: a; break; +>y : any +>a : any + + default: b; break; +>b : any + } +} + +async function switchStatement2() { +>switchStatement2 : () => Promise + + switch (x) { +>x : any + + case await y: a; break; +>await y : any +>y : any +>a : any + + default: b; break; +>b : any + } +} + +async function switchStatement3() { +>switchStatement3 : () => Promise + + switch (x) { +>x : any + + case y: await a; break; +>y : any +>await a : any +>a : any + + default: b; break; +>b : any + } +} + +async function switchStatement4() { +>switchStatement4 : () => Promise + + switch (x) { +>x : any + + case y: a; break; +>y : any +>a : any + + default: await b; break; +>await b : any +>b : any + } +} + +async function switchStatement5() { +>switchStatement5 : () => Promise + + switch (x) { +>x : any + + case y: a; break; +>y : any +>a : any + + case await z: b; break; +>await z : any +>z : any +>b : any + } +} + +async function switchStatement6() { +>switchStatement6 : () => Promise + + switch (x) { +>x : any + + default: c; break; +>c : any + + case await y: a; break; +>await y : any +>y : any +>a : any + + case z: b; break; +>z : any +>b : any + } +} + +async function switchStatement7() { +>switchStatement7 : () => Promise + + switch (x) { +>x : any + + default: c; break; +>c : any + + case y: a; break; +>y : any +>a : any + + case await z: b; break; +>await z : any +>z : any +>b : any + } +} + +async function switchStatement8() { +>switchStatement8 : () => Promise + + switch (x) { +>x : any + + default: c; +>c : any + + case y: a; break; +>y : any +>a : any + + case await z: b; break; +>await z : any +>z : any +>b : any + } +} diff --git a/tests/baselines/reference/es5-asyncFunctionTryStatements.js b/tests/baselines/reference/es5-asyncFunctionTryStatements.js new file mode 100644 index 00000000000..54371c5842f --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionTryStatements.js @@ -0,0 +1,334 @@ +//// [es5-asyncFunctionTryStatements.ts] +declare var x, y, z, a, b, c; + +async function tryCatch0() { + var x, y; + try { + x; + } + catch (e) { + y; + } +} + +async function tryCatch1() { + var x, y; + try { + await x; + } + catch (e) { + y; + } +} + +async function tryCatch2() { + var x, y; + try { + x; + } + catch (e) { + await y; + } +} + +async function tryCatch3(): Promise { + var x, y; + try { + await x; + } + catch (e) { + return () => e; + } +} +async function tryFinally0() { + var x, y; + try { + x; + } + finally { + y; + } +} + +async function tryFinally1() { + var x, y; + try { + await x; + } + finally { + y; + } +} + +async function tryFinally2() { + var x, y; + try { + x; + } + finally { + await y; + } +} + +async function tryCatchFinally0() { + var x, y, z; + try { + x; + } + catch (e) { + y; + } + finally { + z; + } +} + +async function tryCatchFinally1() { + var x, y, z; + try { + await x; + } + catch (e) { + y; + } + finally { + z; + } +} + +async function tryCatchFinally2() { + var x, y, z; + try { + x; + } + catch (e) { + await y; + } + finally { + z; + } +} + +async function tryCatchFinally3() { + var x, y, z; + try { + x; + } + catch (e) { + y; + } + finally { + await z; + } +} + +//// [es5-asyncFunctionTryStatements.js] +function tryCatch0() { + return __awaiter(this, void 0, void 0, function () { + var x, y; + return __generator(function (_a) { + try { + x; + } + catch (e) { + y; + } + return [2 /*return*/]; + }); + }); +} +function tryCatch1() { + return __awaiter(this, void 0, void 0, function () { + var x, y, e_1; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _a.trys.push([0, 2, , 3]); + return [4 /*yield*/, x]; + case 1: + _a.sent(); + return [3 /*break*/, 3]; + case 2: + e_1 = _a.sent(); + y; + return [3 /*break*/, 3]; + case 3: return [2 /*return*/]; + } + }); + }); +} +function tryCatch2() { + return __awaiter(this, void 0, void 0, function () { + var x, y, e_2; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _a.trys.push([0, 1, , 3]); + x; + return [3 /*break*/, 3]; + case 1: + e_2 = _a.sent(); + return [4 /*yield*/, y]; + case 2: + _a.sent(); + return [3 /*break*/, 3]; + case 3: return [2 /*return*/]; + } + }); + }); +} +function tryCatch3() { + return __awaiter(this, void 0, Promise, function () { + var x, y, e_3; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _a.trys.push([0, 2, , 3]); + return [4 /*yield*/, x]; + case 1: + _a.sent(); + return [3 /*break*/, 3]; + case 2: + e_3 = _a.sent(); + return [2 /*return*/, function () { return e_3; }]; + case 3: return [2 /*return*/]; + } + }); + }); +} +function tryFinally0() { + return __awaiter(this, void 0, void 0, function () { + var x, y; + return __generator(function (_a) { + try { + x; + } + finally { + y; + } + return [2 /*return*/]; + }); + }); +} +function tryFinally1() { + return __awaiter(this, void 0, void 0, function () { + var x, y; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _a.trys.push([0, , 2, 3]); + return [4 /*yield*/, x]; + case 1: + _a.sent(); + return [3 /*break*/, 3]; + case 2: + y; + return [7 /*endfinally*/]; + case 3: return [2 /*return*/]; + } + }); + }); +} +function tryFinally2() { + return __awaiter(this, void 0, void 0, function () { + var x, y; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _a.trys.push([0, , 1, 3]); + x; + return [3 /*break*/, 3]; + case 1: return [4 /*yield*/, y]; + case 2: + _a.sent(); + return [7 /*endfinally*/]; + case 3: return [2 /*return*/]; + } + }); + }); +} +function tryCatchFinally0() { + return __awaiter(this, void 0, void 0, function () { + var x, y, z; + return __generator(function (_a) { + try { + x; + } + catch (e) { + y; + } + finally { + z; + } + return [2 /*return*/]; + }); + }); +} +function tryCatchFinally1() { + return __awaiter(this, void 0, void 0, function () { + var x, y, z, e_4; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _a.trys.push([0, 2, 3, 4]); + return [4 /*yield*/, x]; + case 1: + _a.sent(); + return [3 /*break*/, 4]; + case 2: + e_4 = _a.sent(); + y; + return [3 /*break*/, 4]; + case 3: + z; + return [7 /*endfinally*/]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function tryCatchFinally2() { + return __awaiter(this, void 0, void 0, function () { + var x, y, z, e_5; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _a.trys.push([0, 1, 3, 4]); + x; + return [3 /*break*/, 4]; + case 1: + e_5 = _a.sent(); + return [4 /*yield*/, y]; + case 2: + _a.sent(); + return [3 /*break*/, 4]; + case 3: + z; + return [7 /*endfinally*/]; + case 4: return [2 /*return*/]; + } + }); + }); +} +function tryCatchFinally3() { + return __awaiter(this, void 0, void 0, function () { + var x, y, z, e_6; + return __generator(function (_a) { + switch (_a.label) { + case 0: + _a.trys.push([0, 1, 2, 4]); + x; + return [3 /*break*/, 4]; + case 1: + e_6 = _a.sent(); + y; + return [3 /*break*/, 4]; + case 2: return [4 /*yield*/, z]; + case 3: + _a.sent(); + return [7 /*endfinally*/]; + case 4: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionTryStatements.symbols b/tests/baselines/reference/es5-asyncFunctionTryStatements.symbols new file mode 100644 index 00000000000..ecf8fbc505b --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionTryStatements.symbols @@ -0,0 +1,232 @@ +=== tests/cases/compiler/es5-asyncFunctionTryStatements.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionTryStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionTryStatements.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionTryStatements.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionTryStatements.ts, 0, 26)) + +async function tryCatch0() { +>tryCatch0 : Symbol(tryCatch0, Decl(es5-asyncFunctionTryStatements.ts, 0, 29)) + + var x, y; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 3, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 3, 10)) + + try { + x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 3, 7)) + } + catch (e) { +>e : Symbol(e, Decl(es5-asyncFunctionTryStatements.ts, 7, 11)) + + y; +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 3, 10)) + } +} + +async function tryCatch1() { +>tryCatch1 : Symbol(tryCatch1, Decl(es5-asyncFunctionTryStatements.ts, 10, 1)) + + var x, y; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 13, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 13, 10)) + + try { + await x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 13, 7)) + } + catch (e) { +>e : Symbol(e, Decl(es5-asyncFunctionTryStatements.ts, 17, 11)) + + y; +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 13, 10)) + } +} + +async function tryCatch2() { +>tryCatch2 : Symbol(tryCatch2, Decl(es5-asyncFunctionTryStatements.ts, 20, 1)) + + var x, y; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 23, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 23, 10)) + + try { + x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 23, 7)) + } + catch (e) { +>e : Symbol(e, Decl(es5-asyncFunctionTryStatements.ts, 27, 11)) + + await y; +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 23, 10)) + } +} + +async function tryCatch3(): Promise { +>tryCatch3 : Symbol(tryCatch3, Decl(es5-asyncFunctionTryStatements.ts, 30, 1)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + var x, y; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 33, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 33, 10)) + + try { + await x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 33, 7)) + } + catch (e) { +>e : Symbol(e, Decl(es5-asyncFunctionTryStatements.ts, 37, 11)) + + return () => e; +>e : Symbol(e, Decl(es5-asyncFunctionTryStatements.ts, 37, 11)) + } +} +async function tryFinally0() { +>tryFinally0 : Symbol(tryFinally0, Decl(es5-asyncFunctionTryStatements.ts, 40, 1)) + + var x, y; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 42, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 42, 10)) + + try { + x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 42, 7)) + } + finally { + y; +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 42, 10)) + } +} + +async function tryFinally1() { +>tryFinally1 : Symbol(tryFinally1, Decl(es5-asyncFunctionTryStatements.ts, 49, 1)) + + var x, y; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 52, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 52, 10)) + + try { + await x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 52, 7)) + } + finally { + y; +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 52, 10)) + } +} + +async function tryFinally2() { +>tryFinally2 : Symbol(tryFinally2, Decl(es5-asyncFunctionTryStatements.ts, 59, 1)) + + var x, y; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 62, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 62, 10)) + + try { + x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 62, 7)) + } + finally { + await y; +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 62, 10)) + } +} + +async function tryCatchFinally0() { +>tryCatchFinally0 : Symbol(tryCatchFinally0, Decl(es5-asyncFunctionTryStatements.ts, 69, 1)) + + var x, y, z; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 72, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 72, 10)) +>z : Symbol(z, Decl(es5-asyncFunctionTryStatements.ts, 72, 13)) + + try { + x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 72, 7)) + } + catch (e) { +>e : Symbol(e, Decl(es5-asyncFunctionTryStatements.ts, 76, 11)) + + y; +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 72, 10)) + } + finally { + z; +>z : Symbol(z, Decl(es5-asyncFunctionTryStatements.ts, 72, 13)) + } +} + +async function tryCatchFinally1() { +>tryCatchFinally1 : Symbol(tryCatchFinally1, Decl(es5-asyncFunctionTryStatements.ts, 82, 1)) + + var x, y, z; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 85, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 85, 10)) +>z : Symbol(z, Decl(es5-asyncFunctionTryStatements.ts, 85, 13)) + + try { + await x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 85, 7)) + } + catch (e) { +>e : Symbol(e, Decl(es5-asyncFunctionTryStatements.ts, 89, 11)) + + y; +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 85, 10)) + } + finally { + z; +>z : Symbol(z, Decl(es5-asyncFunctionTryStatements.ts, 85, 13)) + } +} + +async function tryCatchFinally2() { +>tryCatchFinally2 : Symbol(tryCatchFinally2, Decl(es5-asyncFunctionTryStatements.ts, 95, 1)) + + var x, y, z; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 98, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 98, 10)) +>z : Symbol(z, Decl(es5-asyncFunctionTryStatements.ts, 98, 13)) + + try { + x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 98, 7)) + } + catch (e) { +>e : Symbol(e, Decl(es5-asyncFunctionTryStatements.ts, 102, 11)) + + await y; +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 98, 10)) + } + finally { + z; +>z : Symbol(z, Decl(es5-asyncFunctionTryStatements.ts, 98, 13)) + } +} + +async function tryCatchFinally3() { +>tryCatchFinally3 : Symbol(tryCatchFinally3, Decl(es5-asyncFunctionTryStatements.ts, 108, 1)) + + var x, y, z; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 111, 7)) +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 111, 10)) +>z : Symbol(z, Decl(es5-asyncFunctionTryStatements.ts, 111, 13)) + + try { + x; +>x : Symbol(x, Decl(es5-asyncFunctionTryStatements.ts, 111, 7)) + } + catch (e) { +>e : Symbol(e, Decl(es5-asyncFunctionTryStatements.ts, 115, 11)) + + y; +>y : Symbol(y, Decl(es5-asyncFunctionTryStatements.ts, 111, 10)) + } + finally { + await z; +>z : Symbol(z, Decl(es5-asyncFunctionTryStatements.ts, 111, 13)) + } +} diff --git a/tests/baselines/reference/es5-asyncFunctionTryStatements.types b/tests/baselines/reference/es5-asyncFunctionTryStatements.types new file mode 100644 index 00000000000..ab1cd845616 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionTryStatements.types @@ -0,0 +1,241 @@ +=== tests/cases/compiler/es5-asyncFunctionTryStatements.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function tryCatch0() { +>tryCatch0 : () => Promise + + var x, y; +>x : any +>y : any + + try { + x; +>x : any + } + catch (e) { +>e : any + + y; +>y : any + } +} + +async function tryCatch1() { +>tryCatch1 : () => Promise + + var x, y; +>x : any +>y : any + + try { + await x; +>await x : any +>x : any + } + catch (e) { +>e : any + + y; +>y : any + } +} + +async function tryCatch2() { +>tryCatch2 : () => Promise + + var x, y; +>x : any +>y : any + + try { + x; +>x : any + } + catch (e) { +>e : any + + await y; +>await y : any +>y : any + } +} + +async function tryCatch3(): Promise { +>tryCatch3 : () => Promise +>Promise : Promise +>Function : Function + + var x, y; +>x : any +>y : any + + try { + await x; +>await x : any +>x : any + } + catch (e) { +>e : any + + return () => e; +>() => e : () => any +>e : any + } +} +async function tryFinally0() { +>tryFinally0 : () => Promise + + var x, y; +>x : any +>y : any + + try { + x; +>x : any + } + finally { + y; +>y : any + } +} + +async function tryFinally1() { +>tryFinally1 : () => Promise + + var x, y; +>x : any +>y : any + + try { + await x; +>await x : any +>x : any + } + finally { + y; +>y : any + } +} + +async function tryFinally2() { +>tryFinally2 : () => Promise + + var x, y; +>x : any +>y : any + + try { + x; +>x : any + } + finally { + await y; +>await y : any +>y : any + } +} + +async function tryCatchFinally0() { +>tryCatchFinally0 : () => Promise + + var x, y, z; +>x : any +>y : any +>z : any + + try { + x; +>x : any + } + catch (e) { +>e : any + + y; +>y : any + } + finally { + z; +>z : any + } +} + +async function tryCatchFinally1() { +>tryCatchFinally1 : () => Promise + + var x, y, z; +>x : any +>y : any +>z : any + + try { + await x; +>await x : any +>x : any + } + catch (e) { +>e : any + + y; +>y : any + } + finally { + z; +>z : any + } +} + +async function tryCatchFinally2() { +>tryCatchFinally2 : () => Promise + + var x, y, z; +>x : any +>y : any +>z : any + + try { + x; +>x : any + } + catch (e) { +>e : any + + await y; +>await y : any +>y : any + } + finally { + z; +>z : any + } +} + +async function tryCatchFinally3() { +>tryCatchFinally3 : () => Promise + + var x, y, z; +>x : any +>y : any +>z : any + + try { + x; +>x : any + } + catch (e) { +>e : any + + y; +>y : any + } + finally { + await z; +>await z : any +>z : any + } +} diff --git a/tests/baselines/reference/es5-asyncFunctionWhileStatements.js b/tests/baselines/reference/es5-asyncFunctionWhileStatements.js new file mode 100644 index 00000000000..53ca2a2da37 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionWhileStatements.js @@ -0,0 +1,353 @@ +//// [es5-asyncFunctionWhileStatements.ts] +declare var x, y, z, a, b, c; + +async function whileStatement0() { + while (x) { y; } +} + +async function whileStatement1() { + while (await x) { y; } +} + +async function whileStatement2() { + while (x) { await y; } +} + +async function whileStatement3() { + while (x) { continue; } +} + +async function whileStatement4() { + while (await x) { continue; } +} + +async function whileStatement5() { + while (x) { await y; continue; } +} + +async function whileStatement6() { + while (x) { if (1) continue; await y; } +} + +async function whileStatement7() { + A: while (x) { continue A; } +} + +async function whileStatement8() { + B: while (await x) { continue B; } +} + +async function whileStatement9() { + C: while (x) { await y; continue C; } +} + +async function whileStatement10() { + D: while (x) { if (1) continue D; await y; } +} + +async function whileStatement11() { + while (x) { break; } +} + +async function whileStatement12() { + while (await x) { break; } +} + +async function whileStatement13() { + while (x) { await y; break; } +} + +async function whileStatement14() { + while (x) { if (1) break; await y; } +} + +async function whileStatement15() { + E: while (x) { break E; } +} + +async function whileStatement16() { + F: while (await x) { break F; } +} + +async function whileStatement17() { + G: while (x) { await y; break G; } +} + +async function whileStatement18() { + H: while (x) { if (1) break H; await y; } +} + +//// [es5-asyncFunctionWhileStatements.js] +function whileStatement0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + while (x) { + y; + } + return [2 /*return*/]; + }); + }); +} +function whileStatement1() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + if (!_a.sent()) + return [3 /*break*/, 2]; + y; + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement2() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement3() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + while (x) { + continue; + } + return [2 /*return*/]; + }); + }); +} +function whileStatement4() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + if (!_a.sent()) + return [3 /*break*/, 2]; + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement5() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement6() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + if (1) + return [3 /*break*/, 0]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement7() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + A: while (x) { + continue A; + } + return [2 /*return*/]; + }); + }); +} +function whileStatement8() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + if (!_a.sent()) + return [3 /*break*/, 2]; + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement9() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement10() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + if (1) + return [3 /*break*/, 0]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement11() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + while (x) { + break; + } + return [2 /*return*/]; + }); + }); +} +function whileStatement12() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + if (!_a.sent()) + return [3 /*break*/, 2]; + return [3 /*break*/, 2]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement13() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + return [3 /*break*/, 2]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement14() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + if (1) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement15() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + E: while (x) { + break E; + } + return [2 /*return*/]; + }); + }); +} +function whileStatement16() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, x]; + case 1: + if (!_a.sent()) + return [3 /*break*/, 2]; + return [3 /*break*/, 2]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement17() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + return [3 /*break*/, 2]; + case 2: return [2 /*return*/]; + } + }); + }); +} +function whileStatement18() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + switch (_a.label) { + case 0: + if (!x) + return [3 /*break*/, 2]; + if (1) + return [3 /*break*/, 2]; + return [4 /*yield*/, y]; + case 1: + _a.sent(); + return [3 /*break*/, 0]; + case 2: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/es5-asyncFunctionWhileStatements.symbols b/tests/baselines/reference/es5-asyncFunctionWhileStatements.symbols new file mode 100644 index 00000000000..31c38da4693 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionWhileStatements.symbols @@ -0,0 +1,152 @@ +=== tests/cases/compiler/es5-asyncFunctionWhileStatements.ts === +declare var x, y, z, a, b, c; +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +>z : Symbol(z, Decl(es5-asyncFunctionWhileStatements.ts, 0, 17)) +>a : Symbol(a, Decl(es5-asyncFunctionWhileStatements.ts, 0, 20)) +>b : Symbol(b, Decl(es5-asyncFunctionWhileStatements.ts, 0, 23)) +>c : Symbol(c, Decl(es5-asyncFunctionWhileStatements.ts, 0, 26)) + +async function whileStatement0() { +>whileStatement0 : Symbol(whileStatement0, Decl(es5-asyncFunctionWhileStatements.ts, 0, 29)) + + while (x) { y; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} + +async function whileStatement1() { +>whileStatement1 : Symbol(whileStatement1, Decl(es5-asyncFunctionWhileStatements.ts, 4, 1)) + + while (await x) { y; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} + +async function whileStatement2() { +>whileStatement2 : Symbol(whileStatement2, Decl(es5-asyncFunctionWhileStatements.ts, 8, 1)) + + while (x) { await y; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} + +async function whileStatement3() { +>whileStatement3 : Symbol(whileStatement3, Decl(es5-asyncFunctionWhileStatements.ts, 12, 1)) + + while (x) { continue; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +} + +async function whileStatement4() { +>whileStatement4 : Symbol(whileStatement4, Decl(es5-asyncFunctionWhileStatements.ts, 16, 1)) + + while (await x) { continue; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +} + +async function whileStatement5() { +>whileStatement5 : Symbol(whileStatement5, Decl(es5-asyncFunctionWhileStatements.ts, 20, 1)) + + while (x) { await y; continue; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} + +async function whileStatement6() { +>whileStatement6 : Symbol(whileStatement6, Decl(es5-asyncFunctionWhileStatements.ts, 24, 1)) + + while (x) { if (1) continue; await y; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} + +async function whileStatement7() { +>whileStatement7 : Symbol(whileStatement7, Decl(es5-asyncFunctionWhileStatements.ts, 28, 1)) + + A: while (x) { continue A; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +} + +async function whileStatement8() { +>whileStatement8 : Symbol(whileStatement8, Decl(es5-asyncFunctionWhileStatements.ts, 32, 1)) + + B: while (await x) { continue B; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +} + +async function whileStatement9() { +>whileStatement9 : Symbol(whileStatement9, Decl(es5-asyncFunctionWhileStatements.ts, 36, 1)) + + C: while (x) { await y; continue C; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} + +async function whileStatement10() { +>whileStatement10 : Symbol(whileStatement10, Decl(es5-asyncFunctionWhileStatements.ts, 40, 1)) + + D: while (x) { if (1) continue D; await y; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} + +async function whileStatement11() { +>whileStatement11 : Symbol(whileStatement11, Decl(es5-asyncFunctionWhileStatements.ts, 44, 1)) + + while (x) { break; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +} + +async function whileStatement12() { +>whileStatement12 : Symbol(whileStatement12, Decl(es5-asyncFunctionWhileStatements.ts, 48, 1)) + + while (await x) { break; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +} + +async function whileStatement13() { +>whileStatement13 : Symbol(whileStatement13, Decl(es5-asyncFunctionWhileStatements.ts, 52, 1)) + + while (x) { await y; break; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} + +async function whileStatement14() { +>whileStatement14 : Symbol(whileStatement14, Decl(es5-asyncFunctionWhileStatements.ts, 56, 1)) + + while (x) { if (1) break; await y; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} + +async function whileStatement15() { +>whileStatement15 : Symbol(whileStatement15, Decl(es5-asyncFunctionWhileStatements.ts, 60, 1)) + + E: while (x) { break E; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +} + +async function whileStatement16() { +>whileStatement16 : Symbol(whileStatement16, Decl(es5-asyncFunctionWhileStatements.ts, 64, 1)) + + F: while (await x) { break F; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +} + +async function whileStatement17() { +>whileStatement17 : Symbol(whileStatement17, Decl(es5-asyncFunctionWhileStatements.ts, 68, 1)) + + G: while (x) { await y; break G; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} + +async function whileStatement18() { +>whileStatement18 : Symbol(whileStatement18, Decl(es5-asyncFunctionWhileStatements.ts, 72, 1)) + + H: while (x) { if (1) break H; await y; } +>x : Symbol(x, Decl(es5-asyncFunctionWhileStatements.ts, 0, 11)) +>y : Symbol(y, Decl(es5-asyncFunctionWhileStatements.ts, 0, 14)) +} diff --git a/tests/baselines/reference/es5-asyncFunctionWhileStatements.types b/tests/baselines/reference/es5-asyncFunctionWhileStatements.types new file mode 100644 index 00000000000..2410befa043 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionWhileStatements.types @@ -0,0 +1,186 @@ +=== tests/cases/compiler/es5-asyncFunctionWhileStatements.ts === +declare var x, y, z, a, b, c; +>x : any +>y : any +>z : any +>a : any +>b : any +>c : any + +async function whileStatement0() { +>whileStatement0 : () => Promise + + while (x) { y; } +>x : any +>y : any +} + +async function whileStatement1() { +>whileStatement1 : () => Promise + + while (await x) { y; } +>await x : any +>x : any +>y : any +} + +async function whileStatement2() { +>whileStatement2 : () => Promise + + while (x) { await y; } +>x : any +>await y : any +>y : any +} + +async function whileStatement3() { +>whileStatement3 : () => Promise + + while (x) { continue; } +>x : any +} + +async function whileStatement4() { +>whileStatement4 : () => Promise + + while (await x) { continue; } +>await x : any +>x : any +} + +async function whileStatement5() { +>whileStatement5 : () => Promise + + while (x) { await y; continue; } +>x : any +>await y : any +>y : any +} + +async function whileStatement6() { +>whileStatement6 : () => Promise + + while (x) { if (1) continue; await y; } +>x : any +>1 : number +>await y : any +>y : any +} + +async function whileStatement7() { +>whileStatement7 : () => Promise + + A: while (x) { continue A; } +>A : any +>x : any +>A : any +} + +async function whileStatement8() { +>whileStatement8 : () => Promise + + B: while (await x) { continue B; } +>B : any +>await x : any +>x : any +>B : any +} + +async function whileStatement9() { +>whileStatement9 : () => Promise + + C: while (x) { await y; continue C; } +>C : any +>x : any +>await y : any +>y : any +>C : any +} + +async function whileStatement10() { +>whileStatement10 : () => Promise + + D: while (x) { if (1) continue D; await y; } +>D : any +>x : any +>1 : number +>D : any +>await y : any +>y : any +} + +async function whileStatement11() { +>whileStatement11 : () => Promise + + while (x) { break; } +>x : any +} + +async function whileStatement12() { +>whileStatement12 : () => Promise + + while (await x) { break; } +>await x : any +>x : any +} + +async function whileStatement13() { +>whileStatement13 : () => Promise + + while (x) { await y; break; } +>x : any +>await y : any +>y : any +} + +async function whileStatement14() { +>whileStatement14 : () => Promise + + while (x) { if (1) break; await y; } +>x : any +>1 : number +>await y : any +>y : any +} + +async function whileStatement15() { +>whileStatement15 : () => Promise + + E: while (x) { break E; } +>E : any +>x : any +>E : any +} + +async function whileStatement16() { +>whileStatement16 : () => Promise + + F: while (await x) { break F; } +>F : any +>await x : any +>x : any +>F : any +} + +async function whileStatement17() { +>whileStatement17 : () => Promise + + G: while (x) { await y; break G; } +>G : any +>x : any +>await y : any +>y : any +>G : any +} + +async function whileStatement18() { +>whileStatement18 : () => Promise + + H: while (x) { if (1) break H; await y; } +>H : any +>x : any +>1 : number +>H : any +>await y : any +>y : any +} diff --git a/tests/baselines/reference/es5-asyncFunctionWithStatements.errors.txt b/tests/baselines/reference/es5-asyncFunctionWithStatements.errors.txt new file mode 100644 index 00000000000..560612bc81e --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionWithStatements.errors.txt @@ -0,0 +1,58 @@ +tests/cases/compiler/es5-asyncFunctionWithStatements.ts(4,5): error TS1300: 'with' statements are not allowed in an async function block. +tests/cases/compiler/es5-asyncFunctionWithStatements.ts(4,11): error TS2410: All symbols within a 'with' block will be resolved to 'any'. +tests/cases/compiler/es5-asyncFunctionWithStatements.ts(10,5): error TS1300: 'with' statements are not allowed in an async function block. +tests/cases/compiler/es5-asyncFunctionWithStatements.ts(10,11): error TS2410: All symbols within a 'with' block will be resolved to 'any'. +tests/cases/compiler/es5-asyncFunctionWithStatements.ts(16,5): error TS1300: 'with' statements are not allowed in an async function block. +tests/cases/compiler/es5-asyncFunctionWithStatements.ts(16,11): error TS2410: All symbols within a 'with' block will be resolved to 'any'. +tests/cases/compiler/es5-asyncFunctionWithStatements.ts(24,5): error TS1300: 'with' statements are not allowed in an async function block. +tests/cases/compiler/es5-asyncFunctionWithStatements.ts(24,11): error TS2410: All symbols within a 'with' block will be resolved to 'any'. + + +==== tests/cases/compiler/es5-asyncFunctionWithStatements.ts (8 errors) ==== + declare var x, y, z, a, b, c; + + async function withStatement0() { + with (x) { + ~~~~ +!!! error TS1300: 'with' statements are not allowed in an async function block. + ~ +!!! error TS2410: All symbols within a 'with' block will be resolved to 'any'. + y; + } + } + + async function withStatement1() { + with (await x) { + ~~~~ +!!! error TS1300: 'with' statements are not allowed in an async function block. + ~~~~~~~ +!!! error TS2410: All symbols within a 'with' block will be resolved to 'any'. + y; + } + } + + async function withStatement2() { + with (x) { + ~~~~ +!!! error TS1300: 'with' statements are not allowed in an async function block. + ~ +!!! error TS2410: All symbols within a 'with' block will be resolved to 'any'. + a; + await y; + b; + } + } + + async function withStatement3() { + with (x) { + ~~~~ +!!! error TS1300: 'with' statements are not allowed in an async function block. + ~ +!!! error TS2410: All symbols within a 'with' block will be resolved to 'any'. + with (z) { + a; + await y; + b; + } + } + } \ No newline at end of file diff --git a/tests/baselines/reference/es5-asyncFunctionWithStatements.js b/tests/baselines/reference/es5-asyncFunctionWithStatements.js new file mode 100644 index 00000000000..20bedc25da9 --- /dev/null +++ b/tests/baselines/reference/es5-asyncFunctionWithStatements.js @@ -0,0 +1,118 @@ +//// [es5-asyncFunctionWithStatements.ts] +declare var x, y, z, a, b, c; + +async function withStatement0() { + with (x) { + y; + } +} + +async function withStatement1() { + with (await x) { + y; + } +} + +async function withStatement2() { + with (x) { + a; + await y; + b; + } +} + +async function withStatement3() { + with (x) { + with (z) { + a; + await y; + b; + } + } +} + +//// [es5-asyncFunctionWithStatements.js] +function withStatement0() { + return __awaiter(this, void 0, void 0, function () { + return __generator(function (_a) { + with (x) { + y; + } + return [2 /*return*/]; + }); + }); +} +function withStatement1() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: return [4 /*yield*/, x]; + case 1: + _a = _b.sent(); + _b.label = 2; + case 2: + with (_a) { + y; + } + _b.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function withStatement2() { + return __awaiter(this, void 0, void 0, function () { + var _a; + return __generator(function (_b) { + switch (_b.label) { + case 0: + _a = x; + _b.label = 1; + case 1: with (_a) { + a; + return [4 /*yield*/, y]; + } + case 2: + with (_a) { + _b.sent(); + b; + } + _b.label = 3; + case 3: return [2 /*return*/]; + } + }); + }); +} +function withStatement3() { + return __awaiter(this, void 0, void 0, function () { + var _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + _a = x; + _c.label = 1; + case 1: + with (_a) { + _b = z; + } + _c.label = 2; + case 2: with (_a) { + with (_b) { + a; + return [4 /*yield*/, y]; + } + } + case 3: + with (_a) { + with (_b) { + _c.sent(); + b; + } + } + _c.label = 4; + case 4: return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/cases/compiler/es5-asyncFunction.ts b/tests/cases/compiler/es5-asyncFunction.ts new file mode 100644 index 00000000000..2ee2ccb3f91 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunction.ts @@ -0,0 +1,10 @@ +// @lib: es5,es2015.promise +// @target: ES5 +declare var x; + +async function empty() { +} + +async function singleAwait() { + await x; +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionArrayLiterals.ts b/tests/cases/compiler/es5-asyncFunctionArrayLiterals.ts new file mode 100644 index 00000000000..69240010c27 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionArrayLiterals.ts @@ -0,0 +1,36 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a; + +async function arrayLiteral0() { + x = [await y, z]; +} + +async function arrayLiteral1() { + x = [y, await z]; +} + +async function arrayLiteral2() { + x = [...(await y), z]; +} + +async function arrayLiteral3() { + x = [...y, await z]; +} + +async function arrayLiteral4() { + x = [await y, ...z]; +} + +async function arrayLiteral5() { + x = [y, ...(await z)]; +} + +async function arrayLiteral6() { + x = [y, await z, a]; +} + +async function arrayLiteral7() { + x = [await y, z, await a]; +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionBinaryExpressions.ts b/tests/cases/compiler/es5-asyncFunctionBinaryExpressions.ts new file mode 100644 index 00000000000..cb633640466 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionBinaryExpressions.ts @@ -0,0 +1,125 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function binaryPlus0() { + (await x) + y; +} + +async function binaryPlus1() { + x + await y; +} + +async function binaryLogicalAnd0() { + (await x) && y; +} + +async function binaryLogicalAnd1() { + x && await y; +} + +async function binaryAssignment0() { + x = await y; +} + +async function binaryAssignment1() { + x.a = await y; +} + +async function binaryAssignment2() { + x.a.b = await y; +} + +async function binaryAssignment3() { + x[z] = await y; +} + +async function binaryAssignment4() { + x[z].b = await y; +} + +async function binaryAssignment5() { + x.a[z] = await y; +} + +async function binaryAssignment6() { + (await x).a = y; +} + +async function binaryAssignment7() { + (await x.a).b = y; +} + +async function binaryAssignment8() { + (await x)[z] = y; +} + +async function binaryAssignment9() { + x[await z] = y; +} + +async function binaryAssignment10() { + x[await z].b = y; +} + +async function binaryAssignment11() { + (await x[z]).b = y; +} + +async function binaryAssignment12() { + x.a[await z] = y; +} + +async function binaryAssignment13() { + (await x.a)[z] = y; +} + +async function binaryCompoundAssignment0() { + x += await y; +} + +async function binaryCompoundAssignment1() { + x.a += await y; +} + +async function binaryCompoundAssignment2() { + x[a] += await y; +} + +async function binaryCompoundAssignment3() { + (await x).a += y; +} + +async function binaryCompoundAssignment4() { + (await x)[a] += y; +} + +async function binaryCompoundAssignment5() { + x[await a] += y; +} + +async function binaryCompoundAssignment6() { + (await x).a += await y; +} + +async function binaryCompoundAssignment7() { + (await x)[a] += await y; +} + +async function binaryCompoundAssignment8() { + x[await a] += await y; +} + +async function binaryExponentiation() { + (await x) ** y; + x ** await y; +} + +async function binaryComma0() { + return (await x), y; +} + +async function binaryComma1(): Promise { + return x, await y; +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionCallExpressions.ts b/tests/cases/compiler/es5-asyncFunctionCallExpressions.ts new file mode 100644 index 00000000000..7b748b95bdf --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionCallExpressions.ts @@ -0,0 +1,88 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function callExpression0() { + await x(y, z); +} + +async function callExpression1() { + (await x)(y, z); +} + +async function callExpression2() { + x(await y, z); +} + +async function callExpression3() { + x(y, await z); +} + +async function callExpression4() { + await x(...y, z); +} + +async function callExpression5() { + (await x)(...y, z); +} + +async function callExpression6() { + x(...(await y), z); +} + +async function callExpression7() { + x(...y, await z); +} + +async function callExpression8() { + x(await y, ...z); +} + +async function callExpression9() { + x(y, ...(await z)); +} + +async function callExpression10() { + await x.a(y, z); +} + +async function callExpression11() { + (await x.a)(y, z); +} + +async function callExpression12() { + (await x).a(y, z); +} + +async function callExpression13() { + x.a(await y, z); +} + +async function callExpression14() { + x.a(y, await z); +} + +async function callExpression15() { + await x[a](y, z); +} + +async function callExpression16() { + (await x[a])(y, z); +} + +async function callExpression17() { + (await x)[a](y, z); +} + +async function callExpression18() { + x[await a](y, z); +} + +async function callExpression19() { + x[a](await y, z); +} + +async function callExpression20() { + x[a](y, await z); +} diff --git a/tests/cases/compiler/es5-asyncFunctionConditionals.ts b/tests/cases/compiler/es5-asyncFunctionConditionals.ts new file mode 100644 index 00000000000..fbc577b9833 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionConditionals.ts @@ -0,0 +1,16 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function conditional0() { + a = (await x) ? y : z; +} + +async function conditional1() { + a = x ? await y : z; +} + +async function conditional2() { + a = x ? y : await z; +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionDoStatements.ts b/tests/cases/compiler/es5-asyncFunctionDoStatements.ts new file mode 100644 index 00000000000..6501e27769f --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionDoStatements.ts @@ -0,0 +1,80 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function doStatement0() { + do { x; } while (y); +} + +async function doStatement1() { + do { await x; } while (y); +} + +async function doStatement2() { + do { x; } while (await y); +} + +async function doStatement3() { + do { continue; } while (y); +} + +async function doStatement4() { + do { await x; continue; } while (y); +} + +async function doStatement5() { + do { if (1) continue; await x; } while (y); +} + +async function doStatement6() { + do { continue; } while (await y); +} + +async function doStatement7() { + A: do { continue A; } while (y); +} + +async function doStatement8() { + B: do { await x; continue B; } while (y); +} + +async function doStatement9() { + C: do { if (1) continue C; await x; } while (y); +} + +async function doStatement10() { + D: do { continue D; } while (await y); +} + +async function doStatement11() { + do { break; } while (y); +} + +async function doStatement12() { + do { await x; break; } while (y); +} + +async function doStatement13() { + do { if (1) break; await x; } while (y); +} + +async function doStatement14() { + do { break; } while (await y); +} + +async function doStatement15() { + E: do { break E; } while (y); +} + +async function doStatement16() { + F: do { await x; break F; } while (y); +} + +async function doStatement17() { + G: do { if (1) break G; await x; } while (y); +} + +async function doStatement18() { + H: do { break H; } while (await y); +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionElementAccess.ts b/tests/cases/compiler/es5-asyncFunctionElementAccess.ts new file mode 100644 index 00000000000..01372b43f5e --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionElementAccess.ts @@ -0,0 +1,16 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function elementAccess0() { + z = await x[y]; +} + +async function elementAccess1() { + z = (await x)[y]; +} + +async function elementAccess2() { + z = x[await y]; +} diff --git a/tests/cases/compiler/es5-asyncFunctionForInStatements.ts b/tests/cases/compiler/es5-asyncFunctionForInStatements.ts new file mode 100644 index 00000000000..b1593041080 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionForInStatements.ts @@ -0,0 +1,40 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function forInStatement0() { + for (x in y) { z; } +} + +async function forInStatement1() { + for (x in await y) { z; } +} + +async function forInStatement2() { + for (x in y) { await z; } +} + +async function forInStatement3() { + for ((await x).a in y) { z; } +} + +async function forInStatement4() { + for (x.a in await y) { z; } +} + +async function forInStatement5() { + for (x.a in y) { await z; } +} + +async function forInStatement6() { + for (var a in y) { z; } +} + +async function forInStatement7() { + for (var b in await y) { z; } +} + +async function forInStatement8() { + for (var c in y) { await z; } +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionForOfStatements.ts b/tests/cases/compiler/es5-asyncFunctionForOfStatements.ts new file mode 100644 index 00000000000..d741c55e31e --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionForOfStatements.ts @@ -0,0 +1,80 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function forOfStatement0() { + for (x of y) { z; } +} + +async function forOfStatement1() { + for (x of await y) { z; } +} + +async function forOfStatement2() { + for (x of y) { await z; } +} + +async function forOfStatement3() { + for ((await x).a of y) { z; } +} + +async function forOfStatement4() { + for (x.a of await y) { z; } +} + +async function forOfStatement5() { + for (x.a of y) { await z; } +} + +async function forOfStatement6() { + for (var b of y) { z; } +} + +async function forOfStatement7() { + for (var c of await y) { z; } +} + +async function forOfStatement8() { + for (var d of y) { await z; } +} + +async function forOfStatement9() { + for ([x] of await y) { z; } +} + +async function forOfStatement10() { + for ([x] of y) { await z; } +} + +async function forOfStatement11() { + for ([x = await a] of y) { z; } +} + +async function forOfStatement12() { + for ([x = a] of await y) { z; } +} + +async function forOfStatement13() { + for ([x = a] of y) { await z; } +} + +async function forOfStatement14() { + for ({ x } of await y) { z; } +} + +async function forOfStatement15() { + for ({ x } of y) { await z; } +} + +async function forOfStatement16() { + for ({ x = await a } of y) { z; } +} + +async function forOfStatement17() { + for ({ x = a } of await y) { z; } +} + +async function forOfStatement18() { + for ({ x = a } of y) { await z; } +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionForStatements.ts b/tests/cases/compiler/es5-asyncFunctionForStatements.ts new file mode 100644 index 00000000000..4fddf395588 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionForStatements.ts @@ -0,0 +1,32 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function forStatement0() { + for (x; y; z) { a; } +} + +async function forStatement1() { + for (await x; y; z) { a; } +} + +async function forStatement2() { + for (x; await y; z) { a; } +} + +async function forStatement3() { + for (x; y; await z) { a; } +} + +async function forStatement4() { + for (x; y; z) { await a; } +} + +async function forStatement5() { + for (var b; y; z) { a; } +} + +async function forStatement6() { + for (var c = x; y; z) { a; } +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionHoisting.ts b/tests/cases/compiler/es5-asyncFunctionHoisting.ts new file mode 100644 index 00000000000..7c05372ada9 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionHoisting.ts @@ -0,0 +1,54 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var y; + +async function hoisting() { + var a0, a1 = 1; + function z() { + var b0, b1 = 1; + } + + if (true) { + var c0, c1 = 1; + } + + for (var a = 0; y;) { + + } + + for (var b in y) { + + } + + for (var c of y) { + + } +} + +async function hoistingWithAwait() { + var a0, a1 = 1; + + function z() { + var b0, b1 = 1; + } + + await 0; + + if (true) { + var c0, c1 = 1; + } + + for (var a = 0; y;) { + + } + + for (var b in y) { + + } + + for (var c of y) { + + } +} + diff --git a/tests/cases/compiler/es5-asyncFunctionIfStatements.ts b/tests/cases/compiler/es5-asyncFunctionIfStatements.ts new file mode 100644 index 00000000000..65bda05ee79 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionIfStatements.ts @@ -0,0 +1,16 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function ifStatement1() { + if (await x) { y; } else { z; } +} + +async function ifStatement2() { + if (x) { await y; } else { z; } +} + +async function ifStatement3() { + if (x) { y; } else { await z; } +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionNestedLoops.ts b/tests/cases/compiler/es5-asyncFunctionNestedLoops.ts new file mode 100644 index 00000000000..dd6f3126bcf --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionNestedLoops.ts @@ -0,0 +1,16 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function nestedLoops() { + A: while (x) { + await y; + while (z) { + continue A; + } + while (a) { + continue; + } + } +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionNewExpressions.ts b/tests/cases/compiler/es5-asyncFunctionNewExpressions.ts new file mode 100644 index 00000000000..d7f0da9f433 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionNewExpressions.ts @@ -0,0 +1,88 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function newExpression0() { + await new x(y, z); +} + +async function newExpression1() { + new (await x)(y, z); +} + +async function newExpression2() { + new x(await y, z); +} + +async function newExpression3() { + new x(y, await z); +} + +async function newExpression4() { + await new x(...y, z); +} + +async function newExpression5() { + new (await x)(...y, z); +} + +async function newExpression6() { + new x(...(await y), z); +} + +async function newExpression7() { + new x(...y, await z); +} + +async function newExpression8() { + new x(await y, ...z); +} + +async function newExpression9() { + new x(y, ...(await z)); +} + +async function newExpression10() { + await new x.a(y, z); +} + +async function newExpression11() { + new (await x.a)(y, z); +} + +async function newExpression12() { + new (await x).a(y, z); +} + +async function newExpression13() { + new x.a(await y, z); +} + +async function newExpression14() { + new x.a(y, await z); +} + +async function newExpression15() { + await new x[a](y, z); +} + +async function newExpression16() { + new (await x[a])(y, z); +} + +async function newExpression17() { + new (await x)[a](y, z); +} + +async function newExpression18() { + new x[await a](y, z); +} + +async function newExpression19() { + new x[a](await y, z); +} + +async function newExpression20() { + new x[a](y, await z); +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionObjectLiterals.ts b/tests/cases/compiler/es5-asyncFunctionObjectLiterals.ts new file mode 100644 index 00000000000..42d03f90494 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionObjectLiterals.ts @@ -0,0 +1,53 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function objectLiteral0() { + x = { + a: await y, + b: z + }; +} + +async function objectLiteral1() { + x = { + a: y, + b: await z + }; +} + +async function objectLiteral2() { + x = { + [await a]: y, + b: z + }; +} + +async function objectLiteral3() { + x = { + [a]: await y, + b: z + }; +} + +async function objectLiteral4() { + x = { + a: await y, + [b]: z + }; +} + +async function objectLiteral5() { + x = { + a: y, + [await b]: z + }; +} + +async function objectLiteral6() { + x = { + a: y, + [b]: await z + }; +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionPropertyAccess.ts b/tests/cases/compiler/es5-asyncFunctionPropertyAccess.ts new file mode 100644 index 00000000000..3541c1b354b --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionPropertyAccess.ts @@ -0,0 +1,16 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function propertyAccess0() { + y = await x.a; +} + +async function propertyAccess1() { + y = (await x).a; +} + +async function callExpression0() { + await x(y, z); +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionReturnStatements.ts b/tests/cases/compiler/es5-asyncFunctionReturnStatements.ts new file mode 100644 index 00000000000..944c61b568c --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionReturnStatements.ts @@ -0,0 +1,29 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function returnStatement0(): Promise { + return; +} + +async function returnStatement1(): Promise { + return x; +} + +async function returnStatement2(): Promise { + return await x; +} + +async function returnStatement3(): Promise { + { return; } +} + +async function returnStatement4(): Promise { + await x; + { return; } +} + +async function returnStatement5(): Promise{ + { return await x; } +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionSwitchStatements.ts b/tests/cases/compiler/es5-asyncFunctionSwitchStatements.ts new file mode 100644 index 00000000000..b321c7115ce --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionSwitchStatements.ts @@ -0,0 +1,70 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function switchStatement0() { + switch (x) { + case y: a; break; + default: b; break; + } +} + +async function switchStatement1() { + switch (await x) { + case y: a; break; + default: b; break; + } +} + +async function switchStatement2() { + switch (x) { + case await y: a; break; + default: b; break; + } +} + +async function switchStatement3() { + switch (x) { + case y: await a; break; + default: b; break; + } +} + +async function switchStatement4() { + switch (x) { + case y: a; break; + default: await b; break; + } +} + +async function switchStatement5() { + switch (x) { + case y: a; break; + case await z: b; break; + } +} + +async function switchStatement6() { + switch (x) { + default: c; break; + case await y: a; break; + case z: b; break; + } +} + +async function switchStatement7() { + switch (x) { + default: c; break; + case y: a; break; + case await z: b; break; + } +} + +async function switchStatement8() { + switch (x) { + default: c; + case y: a; break; + case await z: b; break; + } +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionTryStatements.ts b/tests/cases/compiler/es5-asyncFunctionTryStatements.ts new file mode 100644 index 00000000000..11459295f47 --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionTryStatements.ts @@ -0,0 +1,125 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function tryCatch0() { + var x, y; + try { + x; + } + catch (e) { + y; + } +} + +async function tryCatch1() { + var x, y; + try { + await x; + } + catch (e) { + y; + } +} + +async function tryCatch2() { + var x, y; + try { + x; + } + catch (e) { + await y; + } +} + +async function tryCatch3(): Promise { + var x, y; + try { + await x; + } + catch (e) { + return () => e; + } +} +async function tryFinally0() { + var x, y; + try { + x; + } + finally { + y; + } +} + +async function tryFinally1() { + var x, y; + try { + await x; + } + finally { + y; + } +} + +async function tryFinally2() { + var x, y; + try { + x; + } + finally { + await y; + } +} + +async function tryCatchFinally0() { + var x, y, z; + try { + x; + } + catch (e) { + y; + } + finally { + z; + } +} + +async function tryCatchFinally1() { + var x, y, z; + try { + await x; + } + catch (e) { + y; + } + finally { + z; + } +} + +async function tryCatchFinally2() { + var x, y, z; + try { + x; + } + catch (e) { + await y; + } + finally { + z; + } +} + +async function tryCatchFinally3() { + var x, y, z; + try { + x; + } + catch (e) { + y; + } + finally { + await z; + } +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionWhileStatements.ts b/tests/cases/compiler/es5-asyncFunctionWhileStatements.ts new file mode 100644 index 00000000000..d31ab21ab7b --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionWhileStatements.ts @@ -0,0 +1,80 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function whileStatement0() { + while (x) { y; } +} + +async function whileStatement1() { + while (await x) { y; } +} + +async function whileStatement2() { + while (x) { await y; } +} + +async function whileStatement3() { + while (x) { continue; } +} + +async function whileStatement4() { + while (await x) { continue; } +} + +async function whileStatement5() { + while (x) { await y; continue; } +} + +async function whileStatement6() { + while (x) { if (1) continue; await y; } +} + +async function whileStatement7() { + A: while (x) { continue A; } +} + +async function whileStatement8() { + B: while (await x) { continue B; } +} + +async function whileStatement9() { + C: while (x) { await y; continue C; } +} + +async function whileStatement10() { + D: while (x) { if (1) continue D; await y; } +} + +async function whileStatement11() { + while (x) { break; } +} + +async function whileStatement12() { + while (await x) { break; } +} + +async function whileStatement13() { + while (x) { await y; break; } +} + +async function whileStatement14() { + while (x) { if (1) break; await y; } +} + +async function whileStatement15() { + E: while (x) { break E; } +} + +async function whileStatement16() { + F: while (await x) { break F; } +} + +async function whileStatement17() { + G: while (x) { await y; break G; } +} + +async function whileStatement18() { + H: while (x) { if (1) break H; await y; } +} \ No newline at end of file diff --git a/tests/cases/compiler/es5-asyncFunctionWithStatements.ts b/tests/cases/compiler/es5-asyncFunctionWithStatements.ts new file mode 100644 index 00000000000..c82901ac9fd --- /dev/null +++ b/tests/cases/compiler/es5-asyncFunctionWithStatements.ts @@ -0,0 +1,34 @@ +// @lib: es5,es2015.promise +// @noEmitHelpers: true +// @target: ES5 +declare var x, y, z, a, b, c; + +async function withStatement0() { + with (x) { + y; + } +} + +async function withStatement1() { + with (await x) { + y; + } +} + +async function withStatement2() { + with (x) { + a; + await y; + b; + } +} + +async function withStatement3() { + with (x) { + with (z) { + a; + await y; + b; + } + } +} \ No newline at end of file