Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #12346 from Microsoft/asyncGenerators

Browse Source 
Async Iteration and down-level Generators
This commit is contained in:
Ron Buckton
2017-02-16 17:40:39 -08:00
committed by GitHub
parent 8a5bebe4de 11f58ea2f0
commit 03b9066b7d
348 changed files with 16857 additions and 3085 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Gulpfile.ts
+10 -1
View File
@@ -138,6 +138,14 @@ const es2017LibrarySourceMap = es2017LibrarySource.map(function(source) {
return { target: "lib." + source, sources: ["header.d.ts", source] };
});
const esnextLibrarySource = [
"esnext.asynciterable.d.ts"
];
const esnextLibrarySourceMap = esnextLibrarySource.map(function (source) {
return { target: "lib." + source, sources: ["header.d.ts", source] };
});
const hostsLibrarySources = ["dom.generated.d.ts", "webworker.importscripts.d.ts", "scripthost.d.ts"];
const librarySourceMap = [
@@ -152,11 +160,12 @@ const librarySourceMap = [
{ target: "lib.es2015.d.ts", sources: ["header.d.ts", "es2015.d.ts"] },
{ target: "lib.es2016.d.ts", sources: ["header.d.ts", "es2016.d.ts"] },
{ target: "lib.es2017.d.ts", sources: ["header.d.ts", "es2017.d.ts"] },
{ target: "lib.esnext.d.ts", sources: ["header.d.ts", "esnext.d.ts"] },
// JavaScript + all host library
{ target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) },
{ target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") }
].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap);
].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap, esnextLibrarySourceMap);
const libraryTargets = librarySourceMap.map(function(f) {
return path.join(builtLocalDirectory, f.target);
Jakefile.js
+11 -2
View File
@@ -172,13 +172,21 @@ var es2016LibrarySourceMap = es2016LibrarySource.map(function (source) {
var es2017LibrarySource = [
"es2017.object.d.ts",
"es2017.sharedmemory.d.ts",
"es2017.string.d.ts",
"es2017.string.d.ts"
];
var es2017LibrarySourceMap = es2017LibrarySource.map(function (source) {
return { target: "lib." + source, sources: ["header.d.ts", source] };
});
var esnextLibrarySource = [
"esnext.asynciterable.d.ts"
];
var esnextLibrarySourceMap = esnextLibrarySource.map(function (source) {
return { target: "lib." + source, sources: ["header.d.ts", source] };
});
var hostsLibrarySources = ["dom.generated.d.ts", "webworker.importscripts.d.ts", "scripthost.d.ts"];
var librarySourceMap = [
@@ -193,11 +201,12 @@ var librarySourceMap = [
{ target: "lib.es2015.d.ts", sources: ["header.d.ts", "es2015.d.ts"] },
{ target: "lib.es2016.d.ts", sources: ["header.d.ts", "es2016.d.ts"] },
{ target: "lib.es2017.d.ts", sources: ["header.d.ts", "es2017.d.ts"] },
{ target: "lib.esnext.d.ts", sources: ["header.d.ts", "esnext.d.ts"] },
// JavaScript + all host library
{ target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) },
{ target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") }
].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap);
].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap, esnextLibrarySourceMap);
var libraryTargets = librarySourceMap.map(function (f) {
return path.join(builtLocalDirectory, f.target);
src/compiler/binder.ts
+25 -20
View File
@@ -957,6 +957,9 @@ namespace ts {
const postLoopLabel = createBranchLabel();
addAntecedent(preLoopLabel, currentFlow);
currentFlow = preLoopLabel;
if (node.kind === SyntaxKind.ForOfStatement) {
bind(node.awaitModifier);
}
bind(node.expression);
addAntecedent(postLoopLabel, currentFlow);
bind(node.initializer);
@@ -2407,7 +2410,7 @@ namespace ts {
function bindFunctionDeclaration(node: FunctionDeclaration) {
if (!isDeclarationFile(file) && !isInAmbientContext(node)) {
if (isAsyncFunctionLike(node)) {
if (isAsyncFunction(node)) {
emitFlags |= NodeFlags.HasAsyncFunctions;
}
}
@@ -2424,7 +2427,7 @@ namespace ts {
function bindFunctionExpression(node: FunctionExpression) {
if (!isDeclarationFile(file) && !isInAmbientContext(node)) {
if (isAsyncFunctionLike(node)) {
if (isAsyncFunction(node)) {
emitFlags |= NodeFlags.HasAsyncFunctions;
}
}
@@ -2438,7 +2441,7 @@ namespace ts {
function bindPropertyOrMethodOrAccessor(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags) {
if (!isDeclarationFile(file) && !isInAmbientContext(node)) {
if (isAsyncFunctionLike(node)) {
if (isAsyncFunction(node)) {
emitFlags |= NodeFlags.HasAsyncFunctions;
}
}
@@ -2872,11 +2875,10 @@ namespace ts {
// An async method declaration is ES2017 syntax.
if (hasModifier(node, ModifierFlags.Async)) {
transformFlags |= TransformFlags.AssertES2017;
transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017;
}
// Currently, we only support generators that were originally async function bodies.
if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) {
if (node.asteriskToken) {
transformFlags |= TransformFlags.AssertGenerator;
}
@@ -2942,7 +2944,7 @@ namespace ts {
// An async function declaration is ES2017 syntax.
if (modifierFlags & ModifierFlags.Async) {
transformFlags |= TransformFlags.AssertES2017;
transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017;
}
// function declarations with object rest destructuring are ES Next syntax
@@ -2962,7 +2964,7 @@ namespace ts {
// down-level generator.
// Currently we do not support transforming any other generator fucntions
// down level.
if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) {
if (node.asteriskToken) {
transformFlags |= TransformFlags.AssertGenerator;
}
}
@@ -2984,7 +2986,7 @@ namespace ts {
// An async function expression is ES2017 syntax.
if (hasModifier(node, ModifierFlags.Async)) {
transformFlags |= TransformFlags.AssertES2017;
transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017;
}
// function expressions with object rest destructuring are ES Next syntax
@@ -3003,9 +3005,7 @@ namespace ts {
// If a FunctionExpression is generator function and is the body of a
// transformed async function, then this node can be transformed to a
// down-level generator.
// Currently we do not support transforming any other generator fucntions
// down level.
if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) {
if (node.asteriskToken) {
transformFlags |= TransformFlags.AssertGenerator;
}
@@ -3173,8 +3173,8 @@ namespace ts {
switch (kind) {
case SyntaxKind.AsyncKeyword:
case SyntaxKind.AwaitExpression:
// async/await is ES2017 syntax
transformFlags |= TransformFlags.AssertES2017;
// async/await is ES2017 syntax, but may be ESNext syntax (for async generators)
transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2017;
break;
case SyntaxKind.PublicKeyword:
@@ -3206,10 +3206,6 @@ namespace ts {
transformFlags |= TransformFlags.AssertJsx;
break;
case SyntaxKind.ForOfStatement:
// for-of might be ESNext if it has a rest destructuring
transformFlags |= TransformFlags.AssertESNext;
// FALLTHROUGH
case SyntaxKind.NoSubstitutionTemplateLiteral:
case SyntaxKind.TemplateHead:
case SyntaxKind.TemplateMiddle:
@@ -3223,9 +3219,18 @@ namespace ts {
transformFlags |= TransformFlags.AssertES2015;
break;
case SyntaxKind.ForOfStatement:
// This node is either ES2015 syntax or ES2017 syntax (if it is a for-await-of).
if ((<ForOfStatement>node).awaitModifier) {
transformFlags |= TransformFlags.AssertESNext;
}
transformFlags |= TransformFlags.AssertES2015;
break;
case SyntaxKind.YieldExpression:
// This node is ES6 syntax.
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsYield;
// This node is either ES2015 syntax (in a generator) or ES2017 syntax (in an async
// generator).
transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.ContainsYield;
break;
case SyntaxKind.AnyKeyword:
src/compiler/checker.ts
+647 -508
View File
File diff suppressed because it is too large Load Diff
src/compiler/commandLineParser.ts
+7
View File
@@ -333,6 +333,11 @@ namespace ts {
type: "boolean",
description: Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
},
{
name: "downlevelIteration",
type: "boolean",
description: Diagnostics.Use_full_down_level_iteration_for_iterables_and_arrays_for_for_of_spread_and_destructuring_in_ES5_Slash3
},
{
name: "baseUrl",
type: "string",
@@ -418,6 +423,7 @@ namespace ts {
"es7": "lib.es2016.d.ts",
"es2016": "lib.es2016.d.ts",
"es2017": "lib.es2017.d.ts",
"esnext": "lib.esnext.d.ts",
// Host only
"dom": "lib.dom.d.ts",
"dom.iterable": "lib.dom.iterable.d.ts",
@@ -437,6 +443,7 @@ namespace ts {
"es2017.object": "lib.es2017.object.d.ts",
"es2017.sharedmemory": "lib.es2017.sharedmemory.d.ts",
"es2017.string": "lib.es2017.string.d.ts",
"esnext.asynciterable": "lib.esnext.asynciterable.d.ts",
}),
},
description: Diagnostics.Specify_library_files_to_be_included_in_the_compilation_Colon
src/compiler/diagnosticMessages.json
+32 -4
View File
@@ -175,15 +175,15 @@
"category": "Error",
"code": 1057
},
"Operand for 'await' does not have a valid callable 'then' member.": {
"Type used as operand to 'await' or the return type of an async function must either be a valid promise or must not contain a callable 'then' member.": {
"category": "Error",
"code": 1058
},
"Return expression in async function does not have a valid callable 'then' member.": {
"A promise must have a 'then' method.": {
"category": "Error",
"code": 1059
},
"Expression body for async arrow function does not have a valid callable 'then' member.": {
"The first parameter of the 'then' method of a promise must be a callback.": {
"category": "Error",
"code": 1060
},
@@ -191,7 +191,7 @@
"category": "Error",
"code": 1061
},
"{0} is referenced directly or indirectly in the fulfillment callback of its own 'then' method.": {
"Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method.": {
"category": "Error",
"code": 1062
},
@@ -291,6 +291,10 @@
"category": "Error",
"code": 1102
},
"A 'for-await-of' statement is only allowed within an async function or async generator.": {
"category": "Error",
"code": 1103
},
"A 'continue' statement can only be used within an enclosing iteration statement.": {
"category": "Error",
"code": 1104
@@ -1631,6 +1635,10 @@
"category": "Error",
"code": 2503
},
"Type must have a '[Symbol.asyncIterator]()' method that returns an async iterator.": {
"category": "Error",
"code": 2504
},
"A generator cannot have a 'void' type annotation.": {
"category": "Error",
"code": 2505
@@ -1687,6 +1695,10 @@
"category": "Error",
"code": 2518
},
"An async iterator must have a 'next()' method.": {
"category": "Error",
"code": 2519
},
"Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions.": {
"category": "Error",
"code": 2520
@@ -1795,6 +1807,18 @@
"category": "Error",
"code": 2546
},
"The type returned by the 'next()' method of an async iterator must be a promise for a type with a 'value' property.": {
"category": "Error",
"code": 2547
},
"Type '{0}' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator.": {
"category": "Error",
"code": 2548
},
"Type '{0}' is not an array type or a string type or does not have a '[Symbol.iterator]()' method that returns an iterator.": {
"category": "Error",
"code": 2549
},
"JSX element attributes type '{0}' may not be a union type.": {
"category": "Error",
"code": 2600
@@ -3017,6 +3041,10 @@
"category": "Message",
"code": 6148
},
"Use full down-level iteration for iterables and arrays for 'for-of', spread, and destructuring in ES5/3.": {
"category": "Message",
"code": 6149
},
"Variable '{0}' implicitly has an '{1}' type.": {
"category": "Error",
"code": 7005
src/compiler/emitter.ts
+2 -1
View File
@@ -1450,6 +1450,7 @@ namespace ts {
function emitForOfStatement(node: ForOfStatement) {
const openParenPos = writeToken(SyntaxKind.ForKeyword, node.pos);
write(" ");
emitWithSuffix(node.awaitModifier, " ");
writeToken(SyntaxKind.OpenParenToken, openParenPos);
emitForBinding(node.initializer);
write(" of ");
@@ -2915,4 +2916,4 @@ namespace ts {
Parameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | Parenthesis,
IndexSignatureParameters = CommaDelimited | SpaceBetweenSiblings | SingleLine | Indented | SquareBrackets,
}
}
}
src/compiler/factory.ts
+150 -10
View File
@@ -286,15 +286,16 @@ namespace ts {
return node;
}
export function updateMethod(node: MethodDeclaration, decorators: Decorator[], modifiers: Modifier[], name: PropertyName, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) {
export function updateMethod(node: MethodDeclaration, decorators: Decorator[], modifiers: Modifier[], asteriskToken: AsteriskToken, name: PropertyName, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) {
return node.decorators !== decorators
|| node.modifiers !== modifiers
|| node.asteriskToken !== asteriskToken
|| node.name !== name
|| node.typeParameters !== typeParameters
|| node.parameters !== parameters
|| node.type !== type
|| node.body !== body
? updateNode(createMethod(decorators, modifiers, node.asteriskToken, name, typeParameters, parameters, type, body), node)
? updateNode(createMethod(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body), node)
: node;
}
@@ -554,14 +555,15 @@ namespace ts {
return node;
}
export function updateFunctionExpression(node: FunctionExpression, modifiers: Modifier[], name: Identifier, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) {
export function updateFunctionExpression(node: FunctionExpression, modifiers: Modifier[], asteriskToken: AsteriskToken, name: Identifier, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) {
return node.name !== name
|| node.modifiers !== modifiers
|| node.asteriskToken !== asteriskToken
|| node.typeParameters !== typeParameters
|| node.parameters !== parameters
|| node.type !== type
|| node.body !== body
? updateNode(createFunctionExpression(modifiers, node.asteriskToken, name, typeParameters, parameters, type, body), node)
? updateNode(createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body), node)
: node;
}
@@ -972,19 +974,21 @@ namespace ts {
: node;
}
export function createForOf(initializer: ForInitializer, expression: Expression, statement: Statement) {
export function createForOf(awaitModifier: AwaitKeywordToken, initializer: ForInitializer, expression: Expression, statement: Statement) {
const node = <ForOfStatement>createSynthesizedNode(SyntaxKind.ForOfStatement);
node.awaitModifier = awaitModifier;
node.initializer = initializer;
node.expression = expression;
node.statement = statement;
return node;
}
export function updateForOf(node: ForOfStatement, initializer: ForInitializer, expression: Expression, statement: Statement) {
return node.initializer !== initializer
export function updateForOf(node: ForOfStatement, awaitModifier: AwaitKeywordToken, initializer: ForInitializer, expression: Expression, statement: Statement) {
return node.awaitModifier !== awaitModifier
|| node.initializer !== initializer
|| node.expression !== expression
|| node.statement !== statement
? updateNode(createForOf(initializer, expression, statement), node)
? updateNode(createForOf(awaitModifier, initializer, expression, statement), node)
: node;
}
@@ -1107,15 +1111,16 @@ namespace ts {
return node;
}
export function updateFunctionDeclaration(node: FunctionDeclaration, decorators: Decorator[], modifiers: Modifier[], name: Identifier, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) {
export function updateFunctionDeclaration(node: FunctionDeclaration, decorators: Decorator[], modifiers: Modifier[], asteriskToken: AsteriskToken, name: Identifier, typeParameters: TypeParameterDeclaration[], parameters: ParameterDeclaration[], type: TypeNode, body: Block) {
return node.decorators !== decorators
|| node.modifiers !== modifiers
|| node.asteriskToken !== asteriskToken
|| node.name !== name
|| node.typeParameters !== typeParameters
|| node.parameters !== parameters
|| node.type !== type
|| node.body !== body
? updateNode(createFunctionDeclaration(decorators, modifiers, node.asteriskToken, name, typeParameters, parameters, type, body), node)
? updateNode(createFunctionDeclaration(decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body), node)
: node;
}
@@ -2211,8 +2216,129 @@ namespace ts {
return setEmitFlags(createIdentifier(name), EmitFlags.HelperName | EmitFlags.AdviseOnEmitNode);
}
const valuesHelper: EmitHelper = {
name: "typescript:values",
scoped: false,
text: `
var __values = (this && this.__values) || function (o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
};
`
};
export function createValuesHelper(context: TransformationContext, expression: Expression, location?: TextRange) {
context.requestEmitHelper(valuesHelper);
return setTextRange(
createCall(
getHelperName("__values"),
/*typeArguments*/ undefined,
[expression]
),
location
);
}
const readHelper: EmitHelper = {
name: "typescript:read",
scoped: false,
text: `
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
`
};
export function createReadHelper(context: TransformationContext, iteratorRecord: Expression, count: number | undefined, location?: TextRange) {
context.requestEmitHelper(readHelper);
return setTextRange(
createCall(
getHelperName("__read"),
/*typeArguments*/ undefined,
count !== undefined
? [iteratorRecord, createLiteral(count)]
: [iteratorRecord]
),
location
);
}
const spreadHelper: EmitHelper = {
name: "typescript:spread",
scoped: false,
text: `
var __spread = (this && this.__spread) || function () {
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
return ar;
};`
};
export function createSpreadHelper(context: TransformationContext, argumentList: Expression[], location?: TextRange) {
context.requestEmitHelper(readHelper);
context.requestEmitHelper(spreadHelper);
return setTextRange(
createCall(
getHelperName("__spread"),
/*typeArguments*/ undefined,
argumentList
),
location
);
}
// Utilities
export function createForOfBindingStatement(node: ForInitializer, boundValue: Expression): Statement {
if (isVariableDeclarationList(node)) {
const firstDeclaration = firstOrUndefined(node.declarations);
const updatedDeclaration = updateVariableDeclaration(
firstDeclaration,
firstDeclaration.name,
/*typeNode*/ undefined,
boundValue
);
return setTextRange(
createVariableStatement(
/*modifiers*/ undefined,
updateVariableDeclarationList(node, [updatedDeclaration])
),
/*location*/ node
);
}
else {
const updatedExpression = setTextRange(createAssignment(node, boundValue), /*location*/ node);
return setTextRange(createStatement(updatedExpression), /*location*/ node);
}
}
export function insertLeadingStatement(dest: Statement, source: Statement) {
if (isBlock(dest)) {
return updateBlock(dest, setTextRange(createNodeArray([source, ...dest.statements]), dest.statements));
}
else {
return createBlock(createNodeArray([dest, source]), /*multiLine*/ true);
}
}
export function restoreEnclosingLabel(node: Statement, outermostLabeledStatement: LabeledStatement, afterRestoreLabelCallback?: (node: LabeledStatement) => void): Statement {
if (!outermostLabeledStatement) {
return node;
@@ -2271,6 +2397,10 @@ namespace ts {
? setTextRange(createIdentifier("_super"), callee)
: <PrimaryExpression>callee;
}
else if (getEmitFlags(callee) & EmitFlags.HelperName) {
thisArg = createVoidZero();
target = parenthesizeForAccess(callee);
}
else {
switch (callee.kind) {
case SyntaxKind.PropertyAccessExpression: {
@@ -2684,6 +2814,16 @@ namespace ts {
return statements;
}
export function parenthesizeConditionalHead(condition: Expression) {
const conditionalPrecedence = getOperatorPrecedence(SyntaxKind.ConditionalExpression, SyntaxKind.QuestionToken);
const emittedCondition = skipPartiallyEmittedExpressions(condition);
const conditionPrecedence = getExpressionPrecedence(emittedCondition);
if (compareValues(conditionPrecedence, conditionalPrecedence) === Comparison.LessThan) {
return createParen(condition);
}
return condition;
}
/**
* Wraps the operand to a BinaryExpression in parentheses if they are needed to preserve the intended
* order of operations.
src/compiler/parser.ts
+12 -9
View File
@@ -243,7 +243,8 @@ namespace ts {
visitNode(cbNode, (<ForInStatement>node).expression) ||
visitNode(cbNode, (<ForInStatement>node).statement);
case SyntaxKind.ForOfStatement:
return visitNode(cbNode, (<ForOfStatement>node).initializer) ||
return visitNode(cbNode, (<ForOfStatement>node).awaitModifier) ||
visitNode(cbNode, (<ForOfStatement>node).initializer) ||
visitNode(cbNode, (<ForOfStatement>node).expression) ||
visitNode(cbNode, (<ForOfStatement>node).statement);
case SyntaxKind.ContinueStatement:
@@ -4461,6 +4462,7 @@ namespace ts {
function parseForOrForInOrForOfStatement(): Statement {
const pos = getNodePos();
parseExpected(SyntaxKind.ForKeyword);
const awaitToken = parseOptionalToken(SyntaxKind.AwaitKeyword);
parseExpected(SyntaxKind.OpenParenToken);
let initializer: VariableDeclarationList | Expression = undefined;
@@ -4473,20 +4475,21 @@ namespace ts {
}
}
let forOrForInOrForOfStatement: IterationStatement;
if (parseOptional(SyntaxKind.InKeyword)) {
if (awaitToken ? parseExpected(SyntaxKind.OfKeyword) : parseOptional(SyntaxKind.OfKeyword)) {
const forOfStatement = <ForOfStatement>createNode(SyntaxKind.ForOfStatement, pos);
forOfStatement.awaitModifier = awaitToken;
forOfStatement.initializer = initializer;
forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher);
parseExpected(SyntaxKind.CloseParenToken);
forOrForInOrForOfStatement = forOfStatement;
}
else if (parseOptional(SyntaxKind.InKeyword)) {
const forInStatement = <ForInStatement>createNode(SyntaxKind.ForInStatement, pos);
forInStatement.initializer = initializer;
forInStatement.expression = allowInAnd(parseExpression);
parseExpected(SyntaxKind.CloseParenToken);
forOrForInOrForOfStatement = forInStatement;
}
else if (parseOptional(SyntaxKind.OfKeyword)) {
const forOfStatement = <ForOfStatement>createNode(SyntaxKind.ForOfStatement, pos);
forOfStatement.initializer = initializer;
forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher);
parseExpected(SyntaxKind.CloseParenToken);
forOrForInOrForOfStatement = forOfStatement;
}
else {
const forStatement = <ForStatement>createNode(SyntaxKind.ForStatement, pos);
forStatement.initializer = initializer;
src/compiler/transformers/destructuring.ts
+20 -1
View File
@@ -6,6 +6,7 @@ namespace ts {
interface FlattenContext {
context: TransformationContext;
level: FlattenLevel;
downlevelIteration: boolean;
hoistTempVariables: boolean;
emitExpression: (value: Expression) => void;
emitBindingOrAssignment: (target: BindingOrAssignmentElementTarget, value: Expression, location: TextRange, original: Node) => void;
@@ -57,6 +58,7 @@ namespace ts {
const flattenContext: FlattenContext = {
context,
level,
downlevelIteration: context.getCompilerOptions().downlevelIteration,
hoistTempVariables: true,
emitExpression,
emitBindingOrAssignment,
@@ -146,6 +148,7 @@ namespace ts {
const flattenContext: FlattenContext = {
context,
level,
downlevelIteration: context.getCompilerOptions().downlevelIteration,
hoistTempVariables,
emitExpression,
emitBindingOrAssignment,
@@ -312,7 +315,23 @@ namespace ts {
function flattenArrayBindingOrAssignmentPattern(flattenContext: FlattenContext, parent: BindingOrAssignmentElement, pattern: ArrayBindingOrAssignmentPattern, value: Expression, location: TextRange) {
const elements = getElementsOfBindingOrAssignmentPattern(pattern);
const numElements = elements.length;
if (numElements !== 1 && (flattenContext.level < FlattenLevel.ObjectRest || numElements === 0)) {
if (flattenContext.level < FlattenLevel.ObjectRest && flattenContext.downlevelIteration) {
// Read the elements of the iterable into an array
value = ensureIdentifier(
flattenContext,
createReadHelper(
flattenContext.context,
value,
numElements > 0 && getRestIndicatorOfBindingOrAssignmentElement(elements[numElements - 1])
? undefined
: numElements,
location
),
/*reuseIdentifierExpressions*/ false,
location
);
}
else if (numElements !== 1 && (flattenContext.level < FlattenLevel.ObjectRest || numElements === 0)) {
// For anything other than a single-element destructuring we need to generate a temporary
// to ensure value is evaluated exactly once. Additionally, if we have zero elements
// we need to emit *something* to ensure that in case a 'var' keyword was already emitted,
src/compiler/transformers/es2015.ts
+240 -115
View File
@@ -1,5 +1,6 @@
/// <reference path="../factory.ts" />
/// <reference path="../visitor.ts" />
/// <reference path="./destructuring.ts" />
/*@internal*/
namespace ts {
@@ -268,6 +269,7 @@ namespace ts {
hoistVariableDeclaration,
} = context;
const compilerOptions = context.getCompilerOptions();
const resolver = context.getEmitResolver();
const previousOnSubstituteNode = context.onSubstituteNode;
const previousOnEmitNode = context.onEmitNode;
@@ -1716,6 +1718,7 @@ namespace ts {
return updateFunctionExpression(
node,
/*modifiers*/ undefined,
node.asteriskToken,
name,
/*typeParameters*/ undefined,
parameters,
@@ -1747,6 +1750,7 @@ namespace ts {
node,
/*decorators*/ undefined,
visitNodes(node.modifiers, visitor, isModifier),
node.asteriskToken,
name,
/*typeParameters*/ undefined,
parameters,
@@ -1939,6 +1943,9 @@ namespace ts {
function visitParenthesizedExpression(node: ParenthesizedExpression, needsDestructuringValue: boolean): ParenthesizedExpression {
// If we are here it is most likely because our expression is a destructuring assignment.
if (!needsDestructuringValue) {
// By default we always emit the RHS at the end of a flattened destructuring
// expression. If we are in a state where we do not need the destructuring value,
// we pass that information along to the children that care about it.
switch (node.expression.kind) {
case SyntaxKind.ParenthesizedExpression:
return updateParen(node, visitParenthesizedExpression(<ParenthesizedExpression>node.expression, /*needsDestructuringValue*/ false));
@@ -1990,7 +1997,8 @@ namespace ts {
else {
assignment = createBinary(<Identifier>decl.name, SyntaxKind.EqualsToken, visitNode(decl.initializer, visitor, isExpression));
}
(assignments || (assignments = [])).push(assignment);
assignments = append(assignments, assignment);
}
}
if (assignments) {
@@ -2172,12 +2180,26 @@ namespace ts {
if (convertedLoopState && !convertedLoopState.labels) {
convertedLoopState.labels = createMap<string>();
}
const statement = unwrapInnermostStatmentOfLabel(node, convertedLoopState && recordLabel);
return isIterationStatement(statement, /*lookInLabeledStatements*/ false) && shouldConvertIterationStatementBody(statement)
const statement = unwrapInnermostStatementOfLabel(node, convertedLoopState && recordLabel);
return isIterationStatement(statement, /*lookInLabeledStatements*/ false)
? visitIterationStatement(statement, /*outermostLabeledStatement*/ node)
: restoreEnclosingLabel(visitNode(statement, visitor, isStatement), node, convertedLoopState && resetLabel);
}
function visitIterationStatement(node: IterationStatement, outermostLabeledStatement: LabeledStatement) {
switch (node.kind) {
case SyntaxKind.DoStatement:
case SyntaxKind.WhileStatement:
return visitDoOrWhileStatement(<DoStatement | WhileStatement>node, outermostLabeledStatement);
case SyntaxKind.ForStatement:
return visitForStatement(<ForStatement>node, outermostLabeledStatement);
case SyntaxKind.ForInStatement:
return visitForInStatement(<ForInStatement>node, outermostLabeledStatement);
case SyntaxKind.ForOfStatement:
return visitForOfStatement(<ForOfStatement>node, outermostLabeledStatement);
}
}
function visitIterationStatementWithFacts(excludeFacts: HierarchyFacts, includeFacts: HierarchyFacts, node: IterationStatement, outermostLabeledStatement: LabeledStatement, convert?: LoopConverter) {
const ancestorFacts = enterSubtree(excludeFacts, includeFacts);
const updated = convertIterationStatementBodyIfNecessary(node, outermostLabeledStatement, convert);
@@ -2215,54 +2237,17 @@ namespace ts {
HierarchyFacts.ForInOrForOfStatementIncludes,
node,
outermostLabeledStatement,
convertForOfToFor);
compilerOptions.downlevelIteration ? convertForOfStatementForIterable : convertForOfStatementForArray);
}
function convertForOfToFor(node: ForOfStatement, outermostLabeledStatement: LabeledStatement, convertedLoopBodyStatements: Statement[]): Statement {
// The following ES6 code:
//
// for (let v of expr) { }
//
// should be emitted as
//
// for (var _i = 0, _a = expr; _i < _a.length; _i++) {
// var v = _a[_i];
// }
//
// where _a and _i are temps emitted to capture the RHS and the counter,
// respectively.
// When the left hand side is an expression instead of a let declaration,
// the "let v" is not emitted.
// When the left hand side is a let/const, the v is renamed if there is
// another v in scope.
// Note that all assignments to the LHS are emitted in the body, including
// all destructuring.
// Note also that because an extra statement is needed to assign to the LHS,
// for-of bodies are always emitted as blocks.
const expression = visitNode(node.expression, visitor, isExpression);
const initializer = node.initializer;
function convertForOfStatementHead(node: ForOfStatement, boundValue: Expression, convertedLoopBodyStatements: Statement[]) {
const statements: Statement[] = [];
// In the case where the user wrote an identifier as the RHS, like this:
//
// for (let v of arr) { }
//
// we don't want to emit a temporary variable for the RHS, just use it directly.
const counter = createLoopVariable();
const rhsReference = expression.kind === SyntaxKind.Identifier
? createUniqueName(unescapeIdentifier((<Identifier>expression).text))
: createTempVariable(/*recordTempVariable*/ undefined);
const elementAccess = createElementAccess(rhsReference, counter);
// Initialize LHS
// var v = _a[_i];
if (isVariableDeclarationList(initializer)) {
if (initializer.flags & NodeFlags.BlockScoped) {
if (isVariableDeclarationList(node.initializer)) {
if (node.initializer.flags & NodeFlags.BlockScoped) {
enableSubstitutionsForBlockScopedBindings();
}
const firstOriginalDeclaration = firstOrUndefined(initializer.declarations);
const firstOriginalDeclaration = firstOrUndefined(node.initializer.declarations);
if (firstOriginalDeclaration && isBindingPattern(firstOriginalDeclaration.name)) {
// This works whether the declaration is a var, let, or const.
// It will use rhsIterationValue _a[_i] as the initializer.
@@ -2271,12 +2256,11 @@ namespace ts {
visitor,
context,
FlattenLevel.All,
elementAccess
boundValue
);
const declarationList = createVariableDeclarationList(declarations);
setOriginalNode(declarationList, initializer);
setTextRange(declarationList, initializer);
const declarationList = setTextRange(createVariableDeclarationList(declarations), node.initializer);
setOriginalNode(declarationList, node.initializer);
// Adjust the source map range for the first declaration to align with the old
// emitter.
@@ -2304,15 +2288,15 @@ namespace ts {
createVariableDeclaration(
firstOriginalDeclaration ? firstOriginalDeclaration.name : createTempVariable(/*recordTempVariable*/ undefined),
/*type*/ undefined,
createElementAccess(rhsReference, counter)
boundValue
)
]),
moveRangePos(initializer, -1)
moveRangePos(node.initializer, -1)
),
initializer
node.initializer
)
),
moveRangeEnd(initializer, -1)
moveRangeEnd(node.initializer, -1)
)
);
}
@@ -2320,25 +2304,14 @@ namespace ts {
else {
// Initializer is an expression. Emit the expression in the body, so that it's
// evaluated on every iteration.
const assignment = createAssignment(initializer, elementAccess);
const assignment = createAssignment(node.initializer, boundValue);
if (isDestructuringAssignment(assignment)) {
// This is a destructuring pattern, so we flatten the destructuring instead.
statements.push(
createStatement(
flattenDestructuringAssignment(
assignment,
visitor,
context,
FlattenLevel.All
)
)
);
aggregateTransformFlags(assignment);
statements.push(createStatement(visitBinaryExpression(assignment, /*needsDestructuringValue*/ false)));
}
else {
// Currently there is not way to check that assignment is binary expression of destructing assignment
// so we have to cast never type to binaryExpression
(<BinaryExpression>assignment).end = initializer.end;
statements.push(setTextRange(createStatement(assignment), moveRangeEnd(initializer, -1)));
assignment.end = node.initializer.end;
statements.push(setTextRange(createStatement(visitNode(assignment, visitor, isExpression)), moveRangeEnd(node.initializer, -1)));
}
}
@@ -2359,38 +2332,82 @@ namespace ts {
}
}
// The old emitter does not emit source maps for the block.
// We add the location to preserve comments.
return setEmitFlags(
setTextRange(
createBlock(
setTextRange(createNodeArray(statements), statementsLocation),
/*multiLine*/ true
),
bodyLocation,
),
EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps
);
}
function convertForOfStatementForArray(node: ForOfStatement, outermostLabeledStatement: LabeledStatement, convertedLoopBodyStatements: Statement[]): Statement {
// The following ES6 code:
//
// for (let v of expr) { }
//
// should be emitted as
//
// for (var _i = 0, _a = expr; _i < _a.length; _i++) {
// var v = _a[_i];
// }
//
// where _a and _i are temps emitted to capture the RHS and the counter,
// respectively.
// When the left hand side is an expression instead of a let declaration,
// the "let v" is not emitted.
// When the left hand side is a let/const, the v is renamed if there is
// another v in scope.
// Note that all assignments to the LHS are emitted in the body, including
// all destructuring.
// Note also that because an extra statement is needed to assign to the LHS,
// for-of bodies are always emitted as blocks.
const expression = visitNode(node.expression, visitor, isExpression);
// In the case where the user wrote an identifier as the RHS, like this:
//
// for (let v of arr) { }
//
// we don't want to emit a temporary variable for the RHS, just use it directly.
const counter = createLoopVariable();
const rhsReference = isIdentifier(expression) ? getGeneratedNameForNode(expression) : createTempVariable(/*recordTempVariable*/ undefined);
// The old emitter does not emit source maps for the expression
setEmitFlags(expression, EmitFlags.NoSourceMap | getEmitFlags(expression));
// The old emitter does not emit source maps for the block.
// We add the location to preserve comments.
const body = createBlock(setTextRange(createNodeArray(statements), /*location*/ statementsLocation));
setTextRange(body, bodyLocation);
setEmitFlags(body, EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps);
const forStatement = createFor(
setEmitFlags(
setTextRange(
createVariableDeclarationList([
setTextRange(createVariableDeclaration(counter, /*type*/ undefined, createLiteral(0)), moveRangePos(node.expression, -1)),
setTextRange(createVariableDeclaration(rhsReference, /*type*/ undefined, expression), node.expression)
]),
const forStatement = setTextRange(
createFor(
/*initializer*/ setEmitFlags(
setTextRange(
createVariableDeclarationList([
setTextRange(createVariableDeclaration(counter, /*type*/ undefined, createLiteral(0)), moveRangePos(node.expression, -1)),
setTextRange(createVariableDeclaration(rhsReference, /*type*/ undefined, expression), node.expression)
]),
node.expression
),
EmitFlags.NoHoisting
),
/*condition*/ setTextRange(
createLessThan(
counter,
createPropertyAccess(rhsReference, "length")
),
node.expression
),
EmitFlags.NoHoisting
/*incrementor*/ setTextRange(createPostfixIncrement(counter), node.expression),
/*statement*/ convertForOfStatementHead(
node,
createElementAccess(rhsReference, counter),
convertedLoopBodyStatements
)
),
setTextRange(
createLessThan(
counter,
createPropertyAccess(rhsReference, "length")
),
node.expression
),
setTextRange(
createPostfixIncrement(counter),
node.expression
),
body
/*location*/ node
);
// Disable trailing source maps for the OpenParenToken to align source map emit with the old emitter.
@@ -2399,18 +2416,110 @@ namespace ts {
return restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel);
}
function visitIterationStatement(node: IterationStatement, outermostLabeledStatement: LabeledStatement) {
switch (node.kind) {
case SyntaxKind.DoStatement:
case SyntaxKind.WhileStatement:
return visitDoOrWhileStatement(<DoStatement | WhileStatement>node, outermostLabeledStatement);
case SyntaxKind.ForStatement:
return visitForStatement(<ForStatement>node, outermostLabeledStatement);
case SyntaxKind.ForInStatement:
return visitForInStatement(<ForInStatement>node, outermostLabeledStatement);
case SyntaxKind.ForOfStatement:
return visitForOfStatement(<ForOfStatement>node, outermostLabeledStatement);
}
function convertForOfStatementForIterable(node: ForOfStatement, outermostLabeledStatement: LabeledStatement, convertedLoopBodyStatements: Statement[]): Statement {
const expression = visitNode(node.expression, visitor, isExpression);
const iterator = isIdentifier(expression) ? getGeneratedNameForNode(expression) : createTempVariable(/*recordTempVariable*/ undefined);
const result = isIdentifier(expression) ? getGeneratedNameForNode(iterator) : createTempVariable(/*recordTempVariable*/ undefined);
const errorRecord = createUniqueName("e");
const catchVariable = getGeneratedNameForNode(errorRecord);
const returnMethod = createTempVariable(/*recordTempVariable*/ undefined);
const values = createValuesHelper(context, expression, node.expression);
const next = createCall(createPropertyAccess(iterator, "next" ), /*typeArguments*/ undefined, []);
hoistVariableDeclaration(errorRecord);
hoistVariableDeclaration(returnMethod);
const forStatement = setEmitFlags(
setTextRange(
createFor(
/*initializer*/ setEmitFlags(
setTextRange(
createVariableDeclarationList([
setTextRange(createVariableDeclaration(iterator, /*type*/ undefined, values), node.expression),
createVariableDeclaration(result, /*type*/ undefined, next)
]),
node.expression
),
EmitFlags.NoHoisting
),
/*condition*/ createLogicalNot(createPropertyAccess(result, "done")),
/*incrementor*/ createAssignment(result, next),
/*statement*/ convertForOfStatementHead(
node,
createPropertyAccess(result, "value"),
convertedLoopBodyStatements
)
),
/*location*/ node
),
EmitFlags.NoTokenTrailingSourceMaps
);
return createTry(
createBlock([
restoreEnclosingLabel(
forStatement,
outermostLabeledStatement,
convertedLoopState && resetLabel
)
]),
createCatchClause(createVariableDeclaration(catchVariable),
setEmitFlags(
createBlock([
createStatement(
createAssignment(
errorRecord,
createObjectLiteral([
createPropertyAssignment("error", catchVariable)
])
)
)
]),
EmitFlags.SingleLine
)
),
createBlock([
createTry(
/*tryBlock*/ createBlock([
setEmitFlags(
createIf(
createLogicalAnd(
createLogicalAnd(
result,
createLogicalNot(
createPropertyAccess(result, "done")
)
),
createAssignment(
returnMethod,
createPropertyAccess(iterator, "return")
)
),
createStatement(
createFunctionCall(returnMethod, iterator, [])
)
),
EmitFlags.SingleLine
),
]),
/*catchClause*/ undefined,
/*finallyBlock*/ setEmitFlags(
createBlock([
setEmitFlags(
createIf(
errorRecord,
createThrow(
createPropertyAccess(errorRecord, "error")
)
),
EmitFlags.SingleLine
)
]),
EmitFlags.SingleLine
)
)
])
);
}
/**
@@ -2712,6 +2821,7 @@ namespace ts {
}
const convertedLoopBodyStatements = generateCallToConvertedLoop(functionName, loopParameters, currentState, isAsyncBlockContainingAwait);
let loop: Statement;
if (convert) {
loop = convert(node, outermostLabeledStatement, convertedLoopBodyStatements);
@@ -3239,15 +3349,30 @@ namespace ts {
)
);
if (segments.length === 1) {
const firstElement = elements[0];
return needsUniqueCopy && isSpreadExpression(firstElement) && firstElement.expression.kind !== SyntaxKind.ArrayLiteralExpression
? createArraySlice(segments[0])
: segments[0];
}
if (compilerOptions.downlevelIteration) {
if (segments.length === 1) {
const firstSegment = segments[0];
if (isCallExpression(firstSegment)
&& isIdentifier(firstSegment.expression)
&& (getEmitFlags(firstSegment.expression) & EmitFlags.HelperName)
&& firstSegment.expression.text === "___spread") {
return segments[0];
}
}
// Rewrite using the pattern <segment0>.concat(<segment1>, <segment2>, ...)
return createArrayConcat(segments.shift(), segments);
return createSpreadHelper(context, segments);
}
else {
if (segments.length === 1) {
const firstElement = elements[0];
return needsUniqueCopy && isSpreadExpression(firstElement) && firstElement.expression.kind !== SyntaxKind.ArrayLiteralExpression
? createArraySlice(segments[0])
: segments[0];
}
// Rewrite using the pattern <segment0>.concat(<segment1>, <segment2>, ...)
return createArrayConcat(segments.shift(), segments);
}
}
function partitionSpread(node: Expression) {
src/compiler/transformers/es2017.ts
+94 -116
View File
@@ -14,7 +14,7 @@ namespace ts {
const {
startLexicalEnvironment,
resumeLexicalEnvironment,
endLexicalEnvironment,
endLexicalEnvironment
} = context;
const resolver = context.getEmitResolver();
@@ -34,7 +34,7 @@ namespace ts {
* This keeps track of containers where `super` is valid, for use with
* just-in-time substitution for `super` expressions inside of async methods.
*/
let currentSuperContainer: SuperContainer;
let enclosingSuperContainerFlags: NodeCheckFlags = 0;
// Save the previous transformation hooks.
const previousOnEmitNode = context.onEmitNode;
@@ -71,23 +71,18 @@ namespace ts {
return undefined;
case SyntaxKind.AwaitExpression:
// ES2017 'await' expressions must be transformed for targets < ES2017.
return visitAwaitExpression(<AwaitExpression>node);
case SyntaxKind.MethodDeclaration:
// ES2017 method declarations may be 'async'
return visitMethodDeclaration(<MethodDeclaration>node);
case SyntaxKind.FunctionDeclaration:
// ES2017 function declarations may be 'async'
return visitFunctionDeclaration(<FunctionDeclaration>node);
case SyntaxKind.FunctionExpression:
// ES2017 function expressions may be 'async'
return visitFunctionExpression(<FunctionExpression>node);
case SyntaxKind.ArrowFunction:
// ES2017 arrow functions may be 'async'
return visitArrowFunction(<ArrowFunction>node);
default:
@@ -128,11 +123,12 @@ namespace ts {
node,
/*decorators*/ undefined,
visitNodes(node.modifiers, visitor, isModifier),
node.asteriskToken,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
isAsyncFunctionLike(node)
getFunctionFlags(node) & FunctionFlags.Async
? transformAsyncFunctionBody(node)
: visitFunctionBody(node.body, visitor, context)
);
@@ -151,11 +147,12 @@ namespace ts {
node,
/*decorators*/ undefined,
visitNodes(node.modifiers, visitor, isModifier),
node.asteriskToken,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
isAsyncFunctionLike(node)
getFunctionFlags(node) & FunctionFlags.Async
? transformAsyncFunctionBody(node)
: visitFunctionBody(node.body, visitor, context)
);
@@ -170,17 +167,15 @@ namespace ts {
* @param node The node to visit.
*/
function visitFunctionExpression(node: FunctionExpression): Expression {
if (nodeIsMissing(node.body)) {
return createOmittedExpression();
}
return updateFunctionExpression(
node,
/*modifiers*/ undefined,
visitNodes(node.modifiers, visitor, isModifier),
node.asteriskToken,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
isAsyncFunctionLike(node)
getFunctionFlags(node) & FunctionFlags.Async
? transformAsyncFunctionBody(node)
: visitFunctionBody(node.body, visitor, context)
);
@@ -201,7 +196,7 @@ namespace ts {
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
isAsyncFunctionLike(node)
getFunctionFlags(node) & FunctionFlags.Async
? transformAsyncFunctionBody(node)
: visitFunctionBody(node.body, visitor, context)
);
@@ -320,6 +315,44 @@ namespace ts {
}
}
/**
* Hook for node emit.
*
* @param hint A hint as to the intended usage of the node.
* @param node The node to emit.
* @param emit A callback used to emit the node in the printer.
*/
function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void {
// If we need to support substitutions for `super` in an async method,
// we should track it here.
if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) {
const superContainerFlags = resolver.getNodeCheckFlags(node) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding);
if (superContainerFlags !== enclosingSuperContainerFlags) {
const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
enclosingSuperContainerFlags = superContainerFlags;
previousOnEmitNode(hint, node, emitCallback);
enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags;
return;
}
}
previousOnEmitNode(hint, node, emitCallback);
}
/**
* Hooks node substitutions.
*
* @param hint A hint as to the intended usage of the node.
* @param node The node to substitute.
*/
function onSubstituteNode(hint: EmitHint, node: Node) {
node = previousOnSubstituteNode(hint, node);
if (hint === EmitHint.Expression && enclosingSuperContainerFlags) {
return substituteExpression(<Expression>node);
}
return node;
}
function substituteExpression(node: Expression) {
switch (node.kind) {
case SyntaxKind.PropertyAccessExpression:
@@ -327,62 +360,45 @@ namespace ts {
case SyntaxKind.ElementAccessExpression:
return substituteElementAccessExpression(<ElementAccessExpression>node);
case SyntaxKind.CallExpression:
if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper) {
return substituteCallExpression(<CallExpression>node);
}
break;
return substituteCallExpression(<CallExpression>node);
}
return node;
}
function substitutePropertyAccessExpression(node: PropertyAccessExpression) {
if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && node.expression.kind === SyntaxKind.SuperKeyword) {
const flags = getSuperContainerAsyncMethodFlags();
if (flags) {
return createSuperAccessInAsyncMethod(
createLiteral(node.name.text),
flags,
node
);
}
if (node.expression.kind === SyntaxKind.SuperKeyword) {
return createSuperAccessInAsyncMethod(
createLiteral(node.name.text),
node
);
}
return node;
}
function substituteElementAccessExpression(node: ElementAccessExpression) {
if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && node.expression.kind === SyntaxKind.SuperKeyword) {
const flags = getSuperContainerAsyncMethodFlags();
if (flags) {
return createSuperAccessInAsyncMethod(
node.argumentExpression,
flags,
node
);
}
if (node.expression.kind === SyntaxKind.SuperKeyword) {
return createSuperAccessInAsyncMethod(
node.argumentExpression,
node
);
}
return node;
}
function substituteCallExpression(node: CallExpression): Expression {
const expression = node.expression;
if (isSuperProperty(expression)) {
const flags = getSuperContainerAsyncMethodFlags();
if (flags) {
const argumentExpression = isPropertyAccessExpression(expression)
? substitutePropertyAccessExpression(expression)
: substituteElementAccessExpression(expression);
return createCall(
createPropertyAccess(argumentExpression, "call"),
/*typeArguments*/ undefined,
[
createThis(),
...node.arguments
]
);
}
const argumentExpression = isPropertyAccessExpression(expression)
? substitutePropertyAccessExpression(expression)
: substituteElementAccessExpression(expression);
return createCall(
createPropertyAccess(argumentExpression, "call"),
/*typeArguments*/ undefined,
[
createThis(),
...node.arguments
]
);
}
return node;
}
@@ -396,44 +412,8 @@ namespace ts {
|| kind === SyntaxKind.SetAccessor;
}
/**
* Hook for node emit.
*
* @param hint A hint as to the intended usage of the node.
* @param node The node to emit.
* @param emit A callback used to emit the node in the printer.
*/
function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void {
// If we need to support substitutions for `super` in an async method,
// we should track it here.
if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) {
const savedCurrentSuperContainer = currentSuperContainer;
currentSuperContainer = node;
previousOnEmitNode(hint, node, emitCallback);
currentSuperContainer = savedCurrentSuperContainer;
}
else {
previousOnEmitNode(hint, node, emitCallback);
}
}
/**
* Hooks node substitutions.
*
* @param hint A hint as to the intended usage of the node.
* @param node The node to substitute.
*/
function onSubstituteNode(hint: EmitHint, node: Node) {
node = previousOnSubstituteNode(hint, node);
if (hint === EmitHint.Expression) {
return substituteExpression(<Expression>node);
}
return node;
}
function createSuperAccessInAsyncMethod(argumentExpression: Expression, flags: NodeCheckFlags, location: TextRange): LeftHandSideExpression {
if (flags & NodeCheckFlags.AsyncMethodWithSuperBinding) {
function createSuperAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression {
if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) {
return setTextRange(
createPropertyAccess(
createCall(
@@ -457,15 +437,26 @@ namespace ts {
);
}
}
function getSuperContainerAsyncMethodFlags() {
return currentSuperContainer !== undefined
&& resolver.getNodeCheckFlags(currentSuperContainer) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding);
}
}
const awaiterHelper: EmitHelper = {
name: "typescript:awaiter",
scoped: false,
priority: 5,
text: `
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());
});
};`
};
function createAwaiterHelper(context: TransformationContext, hasLexicalArguments: boolean, promiseConstructor: EntityName | Expression, body: Block) {
context.requestEmitHelper(awaiterHelper);
const generatorFunc = createFunctionExpression(
/*modifiers*/ undefined,
createToken(SyntaxKind.AsteriskToken),
@@ -491,35 +482,22 @@ namespace ts {
);
}
const awaiterHelper: EmitHelper = {
name: "typescript:awaiter",
scoped: false,
priority: 5,
text: `
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());
});
};`
};
const asyncSuperHelper: EmitHelper = {
export const asyncSuperHelper: EmitHelper = {
name: "typescript:async-super",
scoped: true,
text: `
const _super = name => super[name];`
const _super = name => super[name];
`
};
const advancedAsyncSuperHelper: EmitHelper = {
export const advancedAsyncSuperHelper: EmitHelper = {
name: "typescript:advanced-async-super",
scoped: true,
text: `
const _super = (function (geti, seti) {
const cache = Object.create(null);
return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });
})(name => super[name], (name, value) => super[name] = value);`
})(name => super[name], (name, value) => super[name] = value);
`
};
}
src/compiler/transformers/esnext.ts
+606 -76
View File
@@ -1,13 +1,35 @@
/// <reference path="../factory.ts" />
/// <reference path="../visitor.ts" />
/// <reference path="es2017.ts" />
/*@internal*/
namespace ts {
const enum ESNextSubstitutionFlags {
/** Enables substitutions for async methods with `super` calls. */
AsyncMethodsWithSuper = 1 << 0
}
export function transformESNext(context: TransformationContext) {
const {
resumeLexicalEnvironment,
endLexicalEnvironment
endLexicalEnvironment,
hoistVariableDeclaration
} = context;
const resolver = context.getEmitResolver();
const compilerOptions = context.getCompilerOptions();
const languageVersion = getEmitScriptTarget(compilerOptions);
const previousOnEmitNode = context.onEmitNode;
context.onEmitNode = onEmitNode;
const previousOnSubstituteNode = context.onSubstituteNode;
context.onSubstituteNode = onSubstituteNode;
let enabledSubstitutions: ESNextSubstitutionFlags;
let enclosingFunctionFlags: FunctionFlags;
let enclosingSuperContainerFlags: NodeCheckFlags = 0;
return transformSourceFile;
function transformSourceFile(node: SourceFile) {
@@ -28,12 +50,25 @@ namespace ts {
return visitorWorker(node, /*noDestructuringValue*/ true);
}
function visitorNoAsyncModifier(node: Node): VisitResult<Node> {
if (node.kind === SyntaxKind.AsyncKeyword) {
return undefined;
}
return node;
}
function visitorWorker(node: Node, noDestructuringValue: boolean): VisitResult<Node> {
if ((node.transformFlags & TransformFlags.ContainsESNext) === 0) {
return node;
}
switch (node.kind) {
case SyntaxKind.AwaitExpression:
return visitAwaitExpression(node as AwaitExpression);
case SyntaxKind.YieldExpression:
return visitYieldExpression(node as YieldExpression);
case SyntaxKind.LabeledStatement:
return visitLabeledStatement(node as LabeledStatement);
case SyntaxKind.ObjectLiteralExpression:
return visitObjectLiteralExpression(node as ObjectLiteralExpression);
case SyntaxKind.BinaryExpression:
@@ -41,7 +76,7 @@ namespace ts {
case SyntaxKind.VariableDeclaration:
return visitVariableDeclaration(node as VariableDeclaration);
case SyntaxKind.ForOfStatement:
return visitForOfStatement(node as ForOfStatement);
return visitForOfStatement(node as ForOfStatement, /*outermostLabeledStatement*/ undefined);
case SyntaxKind.ForStatement:
return visitForStatement(node as ForStatement);
case SyntaxKind.VoidExpression:
@@ -71,6 +106,51 @@ namespace ts {
}
}
function visitAwaitExpression(node: AwaitExpression) {
if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) {
const expression = visitNode(node.expression, visitor, isExpression);
return setOriginalNode(
setTextRange(
createYield(
/*asteriskToken*/ undefined,
createArrayLiteral([createLiteral("await"), expression])
),
/*location*/ node
),
node
);
}
return visitEachChild(node, visitor, context);
}
function visitYieldExpression(node: YieldExpression) {
if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) {
const expression = visitNode(node.expression, visitor, isExpression);
return updateYield(
node,
node.asteriskToken
? createAsyncDelegatorHelper(context, expression, expression)
: createArrayLiteral(
expression
? [createLiteral("yield"), expression]
: [createLiteral("yield")]
)
);
}
return visitEachChild(node, visitor, context);
}
function visitLabeledStatement(node: LabeledStatement) {
if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) {
const statement = unwrapInnermostStatementOfLabel(node);
if (statement.kind === SyntaxKind.ForOfStatement && (<ForOfStatement>statement).awaitModifier) {
return visitForOfStatement(<ForOfStatement>statement, node);
}
return restoreEnclosingLabel(visitEachChild(node, visitor, context), node);
}
return visitEachChild(node, visitor, context);
}
function chunkObjectLiteralElements(elements: ObjectLiteralElement[]): Expression[] {
let chunkObject: (ShorthandPropertyAssignment | PropertyAssignment)[];
const objects: Expression[] = [];
@@ -189,67 +269,195 @@ namespace ts {
*
* @param node A ForOfStatement.
*/
function visitForOfStatement(node: ForOfStatement): VisitResult<Statement> {
let leadingStatements: Statement[];
let temp: Identifier;
const initializer = skipParentheses(node.initializer);
if (initializer.transformFlags & TransformFlags.ContainsObjectRest) {
if (isVariableDeclarationList(initializer)) {
temp = createTempVariable(/*recordTempVariable*/ undefined);
const firstDeclaration = firstOrUndefined(initializer.declarations);
const declarations = flattenDestructuringBinding(
firstDeclaration,
visitor,
context,
FlattenLevel.ObjectRest,
temp,
/*doNotRecordTempVariablesInLine*/ false,
/*skipInitializer*/ true,
);
if (some(declarations)) {
const statement = createVariableStatement(
/*modifiers*/ undefined,
updateVariableDeclarationList(initializer, declarations),
);
setTextRange(statement, initializer);
leadingStatements = append(leadingStatements, statement);
}
}
else if (isAssignmentPattern(initializer)) {
temp = createTempVariable(/*recordTempVariable*/ undefined);
const expression = flattenDestructuringAssignment(
aggregateTransformFlags(
setTextRange(
createAssignment(initializer, temp),
node.initializer
)
),
visitor,
context,
FlattenLevel.ObjectRest
);
leadingStatements = append(leadingStatements, setTextRange(createStatement(expression), node.initializer));
}
function visitForOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement): VisitResult<Statement> {
if (node.initializer.transformFlags & TransformFlags.ContainsObjectRest) {
node = transformForOfStatementWithObjectRest(node);
}
if (temp) {
const expression = visitNode(node.expression, visitor, isExpression);
const statement = visitNode(node.statement, visitor, isStatement);
const block = isBlock(statement)
? updateBlock(statement, setTextRange(createNodeArray(concatenate(leadingStatements, statement.statements)), statement.statements))
: setTextRange(createBlock(append(leadingStatements, statement), /*multiLine*/ true), statement);
if (node.awaitModifier) {
return transformForAwaitOfStatement(node, outermostLabeledStatement);
}
else {
return restoreEnclosingLabel(visitEachChild(node, visitor, context), outermostLabeledStatement);
}
}
function transformForOfStatementWithObjectRest(node: ForOfStatement) {
const initializerWithoutParens = skipParentheses(node.initializer) as ForInitializer;
if (isVariableDeclarationList(initializerWithoutParens) || isAssignmentPattern(initializerWithoutParens)) {
let bodyLocation: TextRange;
let statementsLocation: TextRange;
const temp = createTempVariable(/*recordTempVariable*/ undefined);
const statements: Statement[] = [createForOfBindingStatement(initializerWithoutParens, temp)];
if (isBlock(node.statement)) {
addRange(statements, node.statement.statements);
bodyLocation = node.statement;
statementsLocation = node.statement.statements;
}
return updateForOf(
node,
node.awaitModifier,
setTextRange(
createVariableDeclarationList([
setTextRange(createVariableDeclaration(temp), node.initializer)
], NodeFlags.Let),
createVariableDeclarationList(
[
setTextRange(createVariableDeclaration(temp), node.initializer)
],
NodeFlags.Let
),
node.initializer
),
expression,
block
node.expression,
setTextRange(
createBlock(
setTextRange(createNodeArray(statements), statementsLocation),
/*multiLine*/ true
),
bodyLocation
)
);
}
return visitEachChild(node, visitor, context);
return node;
}
function convertForOfStatementHead(node: ForOfStatement, boundValue: Expression) {
const binding = createForOfBindingStatement(node.initializer, boundValue);
let bodyLocation: TextRange;
let statementsLocation: TextRange;
const statements: Statement[] = [visitNode(binding, visitor, isStatement)];
const statement = visitNode(node.statement, visitor, isStatement);
if (isBlock(statement)) {
addRange(statements, statement.statements);
bodyLocation = statement;
statementsLocation = statement.statements;
}
else {
statements.push(statement);
}
return setEmitFlags(
setTextRange(
createBlock(
setTextRange(createNodeArray(statements), statementsLocation),
/*multiLine*/ true
),
bodyLocation
),
EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps
);
}
function transformForAwaitOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement) {
const expression = visitNode(node.expression, visitor, isExpression);
const iterator = isIdentifier(expression) ? getGeneratedNameForNode(expression) : createTempVariable(/*recordTempVariable*/ undefined);
const result = isIdentifier(expression) ? getGeneratedNameForNode(iterator) : createTempVariable(/*recordTempVariable*/ undefined);
const errorRecord = createUniqueName("e");
const catchVariable = getGeneratedNameForNode(errorRecord);
const returnMethod = createTempVariable(/*recordTempVariable*/ undefined);
const values = createAsyncValuesHelper(context, expression, /*location*/ node.expression);
const next = createYield(
/*asteriskToken*/ undefined,
createArrayLiteral([
createLiteral("await"),
createCall(createPropertyAccess(iterator, "next" ), /*typeArguments*/ undefined, [])
])
);
hoistVariableDeclaration(errorRecord);
hoistVariableDeclaration(returnMethod);
const forStatement = setEmitFlags(
setTextRange(
createFor(
/*initializer*/ setEmitFlags(
setTextRange(
createVariableDeclarationList([
setTextRange(createVariableDeclaration(iterator, /*type*/ undefined, values), node.expression),
createVariableDeclaration(result, /*type*/ undefined, next)
]),
node.expression
),
EmitFlags.NoHoisting
),
/*condition*/ createLogicalNot(createPropertyAccess(result, "done")),
/*incrementor*/ createAssignment(result, next),
/*statement*/ convertForOfStatementHead(node, createPropertyAccess(result, "value"))
),
/*location*/ node
),
EmitFlags.NoTokenTrailingSourceMaps
);
return createTry(
createBlock([
restoreEnclosingLabel(
forStatement,
outermostLabeledStatement
)
]),
createCatchClause(
createVariableDeclaration(catchVariable),
setEmitFlags(
createBlock([
createStatement(
createAssignment(
errorRecord,
createObjectLiteral([
createPropertyAssignment("error", catchVariable)
])
)
)
]),
EmitFlags.SingleLine
)
),
createBlock([
createTry(
/*tryBlock*/ createBlock([
setEmitFlags(
createIf(
createLogicalAnd(
createLogicalAnd(
result,
createLogicalNot(
createPropertyAccess(result, "done")
)
),
createAssignment(
returnMethod,
createPropertyAccess(iterator, "return")
)
),
createStatement(
createYield(
/*asteriskToken*/ undefined,
createArrayLiteral([
createLiteral("await"),
createFunctionCall(returnMethod, iterator, [])
])
)
)
),
EmitFlags.SingleLine
)
]),
/*catchClause*/ undefined,
/*finallyBlock*/ setEmitFlags(
createBlock([
setEmitFlags(
createIf(
errorRecord,
createThrow(
createPropertyAccess(errorRecord, "error")
)
),
EmitFlags.SingleLine
)
]),
EmitFlags.SingleLine
)
)
])
);
}
function visitParameter(node: ParameterDeclaration): ParameterDeclaration {
@@ -270,17 +478,23 @@ namespace ts {
}
function visitConstructorDeclaration(node: ConstructorDeclaration) {
return updateConstructor(
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = FunctionFlags.Normal;
const updated = updateConstructor(
node,
/*decorators*/ undefined,
node.modifiers,
visitParameterList(node.parameters, visitor, context),
transformFunctionBody(node)
);
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function visitGetAccessorDeclaration(node: GetAccessorDeclaration) {
return updateGetAccessor(
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = FunctionFlags.Normal;
const updated = updateGetAccessor(
node,
/*decorators*/ undefined,
node.modifiers,
@@ -289,10 +503,14 @@ namespace ts {
/*type*/ undefined,
transformFunctionBody(node)
);
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function visitSetAccessorDeclaration(node: SetAccessorDeclaration) {
return updateSetAccessor(
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = FunctionFlags.Normal;
const updated = updateSetAccessor(
node,
/*decorators*/ undefined,
node.modifiers,
@@ -300,36 +518,62 @@ namespace ts {
visitParameterList(node.parameters, visitor, context),
transformFunctionBody(node)
);
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function visitMethodDeclaration(node: MethodDeclaration) {
return updateMethod(
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = getFunctionFlags(node);
const updated = updateMethod(
node,
/*decorators*/ undefined,
node.modifiers,
enclosingFunctionFlags & FunctionFlags.Generator
? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier)
: node.modifiers,
enclosingFunctionFlags & FunctionFlags.Async
? undefined
: node.asteriskToken,
visitNode(node.name, visitor, isPropertyName),
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
transformFunctionBody(node)
enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator
? transformAsyncGeneratorFunctionBody(node)
: transformFunctionBody(node)
);
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function visitFunctionDeclaration(node: FunctionDeclaration) {
return updateFunctionDeclaration(
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = getFunctionFlags(node);
const updated = updateFunctionDeclaration(
node,
/*decorators*/ undefined,
node.modifiers,
enclosingFunctionFlags & FunctionFlags.Generator
? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier)
: node.modifiers,
enclosingFunctionFlags & FunctionFlags.Async
? undefined
: node.asteriskToken,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
transformFunctionBody(node)
enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator
? transformAsyncGeneratorFunctionBody(node)
: transformFunctionBody(node)
);
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function visitArrowFunction(node: ArrowFunction) {
return updateArrowFunction(
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = getFunctionFlags(node);
const updated = updateArrowFunction(
node,
node.modifiers,
/*typeParameters*/ undefined,
@@ -337,25 +581,92 @@ namespace ts {
/*type*/ undefined,
transformFunctionBody(node)
);
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function visitFunctionExpression(node: FunctionExpression) {
return updateFunctionExpression(
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
enclosingFunctionFlags = getFunctionFlags(node);
const updated = updateFunctionExpression(
node,
node.modifiers,
enclosingFunctionFlags & FunctionFlags.Generator
? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier)
: node.modifiers,
enclosingFunctionFlags & FunctionFlags.Async
? undefined
: node.asteriskToken,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
transformFunctionBody(node)
enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator
? transformAsyncGeneratorFunctionBody(node)
: transformFunctionBody(node)
);
enclosingFunctionFlags = savedEnclosingFunctionFlags;
return updated;
}
function transformAsyncGeneratorFunctionBody(node: MethodDeclaration | AccessorDeclaration | FunctionDeclaration | FunctionExpression): FunctionBody {
resumeLexicalEnvironment();
const statements: Statement[] = [];
const statementOffset = addPrologueDirectives(statements, node.body.statements, /*ensureUseStrict*/ false, visitor);
appendObjectRestAssignmentsIfNeeded(statements, node);
statements.push(
createReturn(
createAsyncGeneratorHelper(
context,
createFunctionExpression(
/*modifiers*/ undefined,
createToken(SyntaxKind.AsteriskToken),
node.name && getGeneratedNameForNode(node.name),
/*typeParameters*/ undefined,
/*parameters*/ [],
/*type*/ undefined,
updateBlock(
node.body,
visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset)
)
)
)
)
);
addRange(statements, endLexicalEnvironment());
const block = updateBlock(node.body, statements);
// Minor optimization, emit `_super` helper to capture `super` access in an arrow.
// This step isn't needed if we eventually transform this to ES5.
if (languageVersion >= ScriptTarget.ES2015) {
if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuperBinding) {
enableSubstitutionForAsyncMethodsWithSuper();
addEmitHelper(block, advancedAsyncSuperHelper);
}
else if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuper) {
enableSubstitutionForAsyncMethodsWithSuper();
addEmitHelper(block, asyncSuperHelper);
}
}
return block;
}
function transformFunctionBody(node: FunctionDeclaration | FunctionExpression | ConstructorDeclaration | MethodDeclaration | AccessorDeclaration): FunctionBody;
function transformFunctionBody(node: ArrowFunction): ConciseBody;
function transformFunctionBody(node: FunctionLikeDeclaration): ConciseBody {
resumeLexicalEnvironment();
let leadingStatements: Statement[];
const leadingStatements = appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node);
const body = visitNode(node.body, visitor, isConciseBody);
const trailingStatements = endLexicalEnvironment();
if (some(leadingStatements) || some(trailingStatements)) {
const block = convertToFunctionBody(body, /*multiLine*/ true);
return updateBlock(block, setTextRange(createNodeArray(concatenate(concatenate(leadingStatements, block.statements), trailingStatements)), block.statements));
}
return body;
}
function appendObjectRestAssignmentsIfNeeded(statements: Statement[], node: FunctionLikeDeclaration): Statement[] {
for (const parameter of node.parameters) {
if (parameter.transformFlags & TransformFlags.ContainsObjectRest) {
const temp = getGeneratedNameForNode(parameter);
@@ -376,17 +687,153 @@ namespace ts {
)
);
setEmitFlags(statement, EmitFlags.CustomPrologue);
leadingStatements = append(leadingStatements, statement);
statements = append(statements, statement);
}
}
}
const body = visitNode(node.body, visitor, isConciseBody);
const trailingStatements = endLexicalEnvironment();
if (some(leadingStatements) || some(trailingStatements)) {
const block = convertToFunctionBody(body, /*multiLine*/ true);
return updateBlock(block, setTextRange(createNodeArray(concatenate(concatenate(leadingStatements, block.statements), trailingStatements)), block.statements));
return statements;
}
function enableSubstitutionForAsyncMethodsWithSuper() {
if ((enabledSubstitutions & ESNextSubstitutionFlags.AsyncMethodsWithSuper) === 0) {
enabledSubstitutions |= ESNextSubstitutionFlags.AsyncMethodsWithSuper;
// We need to enable substitutions for call, property access, and element access
// if we need to rewrite super calls.
context.enableSubstitution(SyntaxKind.CallExpression);
context.enableSubstitution(SyntaxKind.PropertyAccessExpression);
context.enableSubstitution(SyntaxKind.ElementAccessExpression);
// We need to be notified when entering and exiting declarations that bind super.
context.enableEmitNotification(SyntaxKind.ClassDeclaration);
context.enableEmitNotification(SyntaxKind.MethodDeclaration);
context.enableEmitNotification(SyntaxKind.GetAccessor);
context.enableEmitNotification(SyntaxKind.SetAccessor);
context.enableEmitNotification(SyntaxKind.Constructor);
}
}
/**
* Called by the printer just before a node is printed.
*
* @param hint A hint as to the intended usage of the node.
* @param node The node to be printed.
* @param emitCallback The callback used to emit the node.
*/
function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) {
// If we need to support substitutions for `super` in an async method,
// we should track it here.
if (enabledSubstitutions & ESNextSubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) {
const superContainerFlags = resolver.getNodeCheckFlags(node) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding);
if (superContainerFlags !== enclosingSuperContainerFlags) {
const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
enclosingSuperContainerFlags = superContainerFlags;
previousOnEmitNode(hint, node, emitCallback);
enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags;
return;
}
}
previousOnEmitNode(hint, node, emitCallback);
}
/**
* Hooks node substitutions.
*
* @param hint The context for the emitter.
* @param node The node to substitute.
*/
function onSubstituteNode(hint: EmitHint, node: Node) {
node = previousOnSubstituteNode(hint, node);
if (hint === EmitHint.Expression && enclosingSuperContainerFlags) {
return substituteExpression(<Expression>node);
}
return node;
}
function substituteExpression(node: Expression) {
switch (node.kind) {
case SyntaxKind.PropertyAccessExpression:
return substitutePropertyAccessExpression(<PropertyAccessExpression>node);
case SyntaxKind.ElementAccessExpression:
return substituteElementAccessExpression(<ElementAccessExpression>node);
case SyntaxKind.CallExpression:
return substituteCallExpression(<CallExpression>node);
}
return node;
}
function substitutePropertyAccessExpression(node: PropertyAccessExpression) {
if (node.expression.kind === SyntaxKind.SuperKeyword) {
return createSuperAccessInAsyncMethod(
createLiteral(node.name.text),
node
);
}
return node;
}
function substituteElementAccessExpression(node: ElementAccessExpression) {
if (node.expression.kind === SyntaxKind.SuperKeyword) {
return createSuperAccessInAsyncMethod(
node.argumentExpression,
node
);
}
return node;
}
function substituteCallExpression(node: CallExpression): Expression {
const expression = node.expression;
if (isSuperProperty(expression)) {
const argumentExpression = isPropertyAccessExpression(expression)
? substitutePropertyAccessExpression(expression)
: substituteElementAccessExpression(expression);
return createCall(
createPropertyAccess(argumentExpression, "call"),
/*typeArguments*/ undefined,
[
createThis(),
...node.arguments
]
);
}
return node;
}
function isSuperContainer(node: Node) {
const kind = node.kind;
return kind === SyntaxKind.ClassDeclaration
|| kind === SyntaxKind.Constructor
|| kind === SyntaxKind.MethodDeclaration
|| kind === SyntaxKind.GetAccessor
|| kind === SyntaxKind.SetAccessor;
}
function createSuperAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression {
if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) {
return setTextRange(
createPropertyAccess(
createCall(
createIdentifier("_super"),
/*typeArguments*/ undefined,
[argumentExpression]
),
"value"
),
location
);
}
else {
return setTextRange(
createCall(
createIdentifier("_super"),
/*typeArguments*/ undefined,
[argumentExpression]
),
location
);
}
return body;
}
}
@@ -418,4 +865,87 @@ namespace ts {
attributesSegments
);
}
const asyncGeneratorHelper: EmitHelper = {
name: "typescript:asyncGenerator",
scoped: false,
text: `
var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
var g = generator.apply(thisArg, _arguments || []), q = [], c, i;
return i = { next: verb("next"), "throw": verb("throw"), "return": verb("return") }, i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { return function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]), next(); }); }; }
function next() { if (!c && q.length) resume((c = q.shift())[0], c[1]); }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(c[3], e); } }
function step(r) { r.done ? settle(c[2], r) : r.value[0] === "yield" ? settle(c[2], { value: r.value[1], done: false }) : Promise.resolve(r.value[1]).then(r.value[0] === "delegate" ? delegate : fulfill, reject); }
function delegate(r) { step(r.done ? r : { value: ["yield", r.value], done: false }); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { c = void 0, f(v), next(); }
};
`
};
function createAsyncGeneratorHelper(context: TransformationContext, generatorFunc: FunctionExpression) {
context.requestEmitHelper(asyncGeneratorHelper);
// Mark this node as originally an async function
(generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= EmitFlags.AsyncFunctionBody;
return createCall(
getHelperName("__asyncGenerator"),
/*typeArguments*/ undefined,
[
createThis(),
createIdentifier("arguments"),
generatorFunc
]
);
}
const asyncDelegator: EmitHelper = {
name: "typescript:asyncDelegator",
scoped: false,
text: `
var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
var i = { next: verb("next"), "throw": verb("throw", function (e) { throw e; }), "return": verb("return", function (v) { return { value: v, done: true }; }) };
return o = __asyncValues(o), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { return function (v) { return { value: ["delegate", (o[n] || f).call(o, v)], done: false }; }; }
};
`
};
function createAsyncDelegatorHelper(context: TransformationContext, expression: Expression, location?: TextRange) {
context.requestEmitHelper(asyncDelegator);
return setTextRange(
createCall(
getHelperName("__asyncDelegator"),
/*typeArguments*/ undefined,
[expression]
),
location
);
}
const asyncValues: EmitHelper = {
name: "typescript:asyncValues",
scoped: false,
text: `
var __asyncValues = (this && this.__asyncIterator) || function (o) {
var m = o[Symbol.asyncIterator];
return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator]();
};
`
};
function createAsyncValuesHelper(context: TransformationContext, expression: Expression, location?: TextRange) {
context.requestEmitHelper(asyncValues);
return setTextRange(
createCall(
getHelperName("__asyncValues"),
/*typeArguments*/ undefined,
[expression]
),
location
);
}
}
src/compiler/transformers/generators.ts
+16 -13
View File
@@ -232,7 +232,7 @@ namespace ts {
resumeLexicalEnvironment,
endLexicalEnvironment,
hoistFunctionDeclaration,
hoistVariableDeclaration,
hoistVariableDeclaration
} = context;
const compilerOptions = context.getCompilerOptions();
@@ -448,7 +448,7 @@ namespace ts {
*/
function visitFunctionDeclaration(node: FunctionDeclaration): Statement {
// Currently, we only support generators that were originally async functions.
if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) {
if (node.asteriskToken) {
node = setOriginalNode(
setTextRange(
createFunctionDeclaration(
@@ -498,7 +498,7 @@ namespace ts {
*/
function visitFunctionExpression(node: FunctionExpression): Expression {
// Currently, we only support generators that were originally async functions.
if (node.asteriskToken && getEmitFlags(node) & EmitFlags.AsyncFunctionBody) {
if (node.asteriskToken) {
node = setOriginalNode(
setTextRange(
createFunctionExpression(
@@ -936,11 +936,10 @@ namespace ts {
// .mark resumeLabel
// x = %sent%;
// NOTE: we are explicitly not handling YieldStar at this time.
const resumeLabel = defineLabel();
const expression = visitNode(node.expression, visitor, isExpression);
if (node.asteriskToken) {
emitYieldStar(expression, /*location*/ node);
emitYieldStar(createValuesHelper(context, expression, /*location*/ node), /*location*/ node);
}
else {
emitYield(expression, /*location*/ node);
@@ -978,9 +977,10 @@ namespace ts {
// ar = _a.concat([%sent%, 2]);
const numInitialElements = countInitialNodesWithoutYield(elements);
const temp = declareLocal();
let hasAssignedTemp = false;
let temp: Identifier;
if (numInitialElements > 0) {
temp = declareLocal();
const initialElements = visitNodes(elements, visitor, isExpression, 0, numInitialElements);
emitAssignment(temp,
createArrayLiteral(
@@ -990,11 +990,10 @@ namespace ts {
)
);
leadingElement = undefined;
hasAssignedTemp = true;
}
const expressions = reduceLeft(elements, reduceElement, <Expression[]>[], numInitialElements);
return hasAssignedTemp
return temp
? createArrayConcat(temp, [createArrayLiteral(expressions, multiLine)])
: setTextRange(
createArrayLiteral(leadingElement ? [leadingElement, ...expressions] : expressions, multiLine),
@@ -1003,6 +1002,11 @@ namespace ts {
function reduceElement(expressions: Expression[], element: Expression) {
if (containsYield(element) && expressions.length > 0) {
const hasAssignedTemp = temp !== undefined;
if (!temp) {
temp = declareLocal();
}
emitAssignment(
temp,
hasAssignedTemp
@@ -1015,7 +1019,6 @@ namespace ts {
multiLine
)
);
hasAssignedTemp = true;
leadingElement = undefined;
expressions = [];
}
@@ -1960,7 +1963,7 @@ namespace ts {
function cacheExpression(node: Expression): Identifier {
let temp: Identifier;
if (isGeneratedIdentifier(node)) {
if (isGeneratedIdentifier(node) || getEmitFlags(node) & EmitFlags.HelperName) {
return <Identifier>node;
}
@@ -3229,8 +3232,8 @@ namespace ts {
priority: 6,
text: `
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t;
return { next: verb(0), "throw": verb(1), "return": verb(2) };
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
src/compiler/transformers/jsx.ts
-5
View File
@@ -6,7 +6,6 @@
namespace ts {
export function transformJsx(context: TransformationContext) {
const compilerOptions = context.getCompilerOptions();
let currentSourceFile: SourceFile;
return transformSourceFile;
@@ -20,12 +19,8 @@ namespace ts {
return node;
}
currentSourceFile = node;
const visited = visitEachChild(node, visitor, context);
addEmitHelpers(visited, context.readEmitHelpers());
currentSourceFile = undefined;
return visited;
}
src/compiler/transformers/module/es2015.ts
+1
View File
@@ -101,6 +101,7 @@ namespace ts {
if (isIdentifier(node) && hint === EmitHint.Expression) {
return substituteExpressionIdentifier(node);
}
return node;
}
src/compiler/transformers/module/module.ts
+8 -4
View File
@@ -1,5 +1,6 @@
/// <reference path="../../factory.ts" />
/// <reference path="../../visitor.ts" />
/// <reference path="../destructuring.ts" />
/*@internal*/
namespace ts {
@@ -90,11 +91,13 @@ namespace ts {
append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, isStatement, /*optional*/ true));
addRange(statements, visitNodes(node.statements, sourceElementVisitor, isStatement, statementOffset));
addRange(statements, endLexicalEnvironment());
addExportEqualsIfNeeded(statements, /*emitAsReturn*/ false);
addRange(statements, endLexicalEnvironment());
const updated = updateSourceFileNode(node, setTextRange(createNodeArray(statements), node.statements));
if (currentModuleInfo.hasExportStarsToExportValues) {
// If we have any `export * from ...` declarations
// we need to inform the emitter to add the __export helper.
addEmitHelper(updated, exportStarHelper);
}
return updated;
@@ -383,13 +386,13 @@ namespace ts {
append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, isStatement, /*optional*/ true));
addRange(statements, visitNodes(node.statements, sourceElementVisitor, isStatement, statementOffset));
// Append the 'export =' statement if provided.
addExportEqualsIfNeeded(statements, /*emitAsReturn*/ true);
// End the lexical environment for the module body
// and merge any new lexical declarations.
addRange(statements, endLexicalEnvironment());
// Append the 'export =' statement if provided.
addExportEqualsIfNeeded(statements, /*emitAsReturn*/ true);
const body = createBlock(statements, /*multiLine*/ true);
if (currentModuleInfo.hasExportStarsToExportValues) {
// If we have any `export * from ...` declarations
@@ -1334,6 +1337,7 @@ namespace ts {
if (externalHelpersModuleName) {
return createPropertyAccess(externalHelpersModuleName, node);
}
return node;
}
src/compiler/transformers/module/system.ts
+5 -2
View File
@@ -1,5 +1,6 @@
/// <reference path="../../factory.ts" />
/// <reference path="../../visitor.ts" />
/// <reference path="../destructuring.ts" />
/*@internal*/
namespace ts {
@@ -136,7 +137,6 @@ namespace ts {
contextObject = undefined;
hoistedStatements = undefined;
enclosingBlockScopedContainer = undefined;
return aggregateTransformFlags(updated);
}
@@ -669,6 +669,7 @@ namespace ts {
node,
node.decorators,
visitNodes(node.modifiers, modifierVisitor, isModifier),
node.asteriskToken,
getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true),
/*typeParameters*/ undefined,
visitNodes(node.parameters, destructuringVisitor, isParameterDeclaration),
@@ -1258,6 +1259,7 @@ namespace ts {
node = updateForOf(
node,
node.awaitModifier,
visitForInitializer(node.initializer),
visitNode(node.expression, destructuringVisitor, isExpression),
visitNode(node.statement, nestedElementVisitor, isStatement, /*optional*/ false, liftToBlock)
@@ -1492,7 +1494,7 @@ namespace ts {
* @param node The destructuring target.
*/
function hasExportedReferenceInDestructuringTarget(node: Expression | ObjectLiteralElementLike): boolean {
if (isAssignmentExpression(node)) {
if (isAssignmentExpression(node, /*excludeCompoundAssignment*/ true)) {
return hasExportedReferenceInDestructuringTarget(node.left);
}
else if (isSpreadExpression(node)) {
@@ -1625,6 +1627,7 @@ namespace ts {
if (externalHelpersModuleName) {
return createPropertyAccess(externalHelpersModuleName, node);
}
return node;
}
src/compiler/transformers/ts.ts
+78 -63
View File
@@ -872,7 +872,7 @@ namespace ts {
* @param hasExtendsClause A value indicating whether the class has an extends clause.
*/
function transformConstructorBody(node: ClassExpression | ClassDeclaration, constructor: ConstructorDeclaration, hasExtendsClause: boolean) {
const statements: Statement[] = [];
let statements: Statement[] = [];
let indexOfFirstStatement = 0;
resumeLexicalEnvironment();
@@ -930,7 +930,7 @@ namespace ts {
}
// End the lexical environment.
addRange(statements, endLexicalEnvironment());
statements = mergeLexicalEnvironment(statements, endLexicalEnvironment());
return setTextRange(
createBlock(
setTextRange(
@@ -1651,7 +1651,7 @@ namespace ts {
if (isFunctionLike(node) && node.type) {
return serializeTypeNode(node.type);
}
else if (isAsyncFunctionLike(node)) {
else if (isAsyncFunction(node)) {
return createIdentifier("Promise");
}
@@ -2019,7 +2019,13 @@ namespace ts {
return undefined;
}
return visitEachChild(node, visitor, context);
return updateConstructor(
node,
visitNodes(node.decorators, visitor, isDecorator),
visitNodes(node.modifiers, visitor, isModifier),
visitParameterList(node.parameters, visitor, context),
visitFunctionBody(node.body, visitor, context)
);
}
/**
@@ -2040,6 +2046,7 @@ namespace ts {
node,
/*decorators*/ undefined,
visitNodes(node.modifiers, modifierVisitor, isModifier),
node.asteriskToken,
visitPropertyNameOfClassElement(node),
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
@@ -2144,6 +2151,7 @@ namespace ts {
node,
/*decorators*/ undefined,
visitNodes(node.modifiers, modifierVisitor, isModifier),
node.asteriskToken,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
@@ -2167,17 +2175,18 @@ namespace ts {
* @param node The function expression node.
*/
function visitFunctionExpression(node: FunctionExpression): Expression {
if (nodeIsMissing(node.body)) {
if (!shouldEmitFunctionLikeDeclaration(node)) {
return createOmittedExpression();
}
const updated = updateFunctionExpression(
node,
visitNodes(node.modifiers, modifierVisitor, isModifier),
node.asteriskToken,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
visitFunctionBody(node.body, visitor, context)
visitFunctionBody(node.body, visitor, context) || createBlock([])
);
return updated;
}
@@ -3187,6 +3196,11 @@ namespace ts {
*/
function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void {
const savedApplicableSubstitutions = applicableSubstitutions;
const savedCurrentSourceFile = currentSourceFile;
if (isSourceFile(node)) {
currentSourceFile = node;
}
if (enabledSubstitutions & TypeScriptSubstitutionFlags.NamespaceExports && isTransformedModuleDeclaration(node)) {
applicableSubstitutions |= TypeScriptSubstitutionFlags.NamespaceExports;
@@ -3199,6 +3213,7 @@ namespace ts {
previousOnEmitNode(hint, node, emitCallback);
applicableSubstitutions = savedApplicableSubstitutions;
currentSourceFile = savedCurrentSourceFile;
}
/**
@@ -3340,13 +3355,60 @@ namespace ts {
}
}
const paramHelper: EmitHelper = {
name: "typescript:param",
function createDecorateHelper(context: TransformationContext, decoratorExpressions: Expression[], target: Expression, memberName?: Expression, descriptor?: Expression, location?: TextRange) {
const argumentsArray: Expression[] = [];
argumentsArray.push(createArrayLiteral(decoratorExpressions, /*multiLine*/ true));
argumentsArray.push(target);
if (memberName) {
argumentsArray.push(memberName);
if (descriptor) {
argumentsArray.push(descriptor);
}
}
context.requestEmitHelper(decorateHelper);
return setTextRange(
createCall(
getHelperName("__decorate"),
/*typeArguments*/ undefined,
argumentsArray
),
location
);
}
const decorateHelper: EmitHelper = {
name: "typescript:decorate",
scoped: false,
priority: 4,
priority: 2,
text: `
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};`
};
function createMetadataHelper(context: TransformationContext, metadataKey: string, metadataValue: Expression) {
context.requestEmitHelper(metadataHelper);
return createCall(
getHelperName("__metadata"),
/*typeArguments*/ undefined,
[
createLiteral(metadataKey),
metadataValue
]
);
}
const metadataHelper: EmitHelper = {
name: "typescript:metadata",
scoped: false,
priority: 3,
text: `
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};`
};
@@ -3365,60 +3427,13 @@ namespace ts {
);
}
const metadataHelper: EmitHelper = {
name: "typescript:metadata",
const paramHelper: EmitHelper = {
name: "typescript:param",
scoped: false,
priority: 3,
priority: 4,
text: `
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};`
};
function createMetadataHelper(context: TransformationContext, metadataKey: string, metadataValue: Expression) {
context.requestEmitHelper(metadataHelper);
return createCall(
getHelperName("__metadata"),
/*typeArguments*/ undefined,
[
createLiteral(metadataKey),
metadataValue
]
);
}
const decorateHelper: EmitHelper = {
name: "typescript:decorate",
scoped: false,
priority: 2,
text: `
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};`
};
function createDecorateHelper(context: TransformationContext, decoratorExpressions: Expression[], target: Expression, memberName?: Expression, descriptor?: Expression, location?: TextRange) {
context.requestEmitHelper(decorateHelper);
const argumentsArray: Expression[] = [];
argumentsArray.push(createArrayLiteral(decoratorExpressions, /*multiLine*/ true));
argumentsArray.push(target);
if (memberName) {
argumentsArray.push(memberName);
if (descriptor) {
argumentsArray.push(descriptor);
}
}
return setTextRange(
createCall(
getHelperName("__decorate"),
/*typeArguments*/ undefined,
argumentsArray
),
location
);
}
}
src/compiler/types.ts
+37 -4
View File
@@ -542,6 +542,7 @@
export type EndOfFileToken = Token<SyntaxKind.EndOfFileToken>;
export type AtToken = Token<SyntaxKind.AtToken>;
export type ReadonlyToken = Token<SyntaxKind.ReadonlyKeyword>;
export type AwaitKeywordToken = Token<SyntaxKind.AwaitKeyword>;
export type Modifier
= Token<SyntaxKind.AbstractKeyword>
@@ -699,7 +700,13 @@
name?: PropertyName;
}
export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | MethodDeclaration | AccessorDeclaration | SpreadAssignment;
export type ObjectLiteralElementLike
= PropertyAssignment
| ShorthandPropertyAssignment
| SpreadAssignment
| MethodDeclaration
| AccessorDeclaration
;
export interface PropertyAssignment extends ObjectLiteralElement {
kind: SyntaxKind.PropertyAssignment;
@@ -1637,6 +1644,7 @@
export interface ForOfStatement extends IterationStatement {
kind: SyntaxKind.ForOfStatement;
awaitModifier?: AwaitKeywordToken;
initializer: ForInitializer;
expression: Expression;
}
@@ -3058,8 +3066,17 @@
// Just a place to cache element types of iterables and iterators
/* @internal */
export interface IterableOrIteratorType extends ObjectType, UnionType {
iterableElementType?: Type;
iteratorElementType?: Type;
iteratedTypeOfIterable?: Type;
iteratedTypeOfIterator?: Type;
iteratedTypeOfAsyncIterable?: Type;
iteratedTypeOfAsyncIterator?: Type;
}
/* @internal */
export interface PromiseOrAwaitableType extends ObjectType, UnionType {
promiseTypeOfPromiseConstructor?: Type;
promisedTypeOfPromise?: Type;
awaitedTypeOfType?: Type;
}
export interface TypeVariable extends Type {
@@ -3253,6 +3270,7 @@
/* @internal */ diagnostics?: boolean;
/* @internal */ extendedDiagnostics?: boolean;
disableSizeLimit?: boolean;
downlevelIteration?: boolean;
emitBOM?: boolean;
emitDecoratorMetadata?: boolean;
experimentalDecorators?: boolean;
@@ -3828,9 +3846,24 @@
Param = 1 << 5, // __param (used by TypeScript decorators transformation)
Awaiter = 1 << 6, // __awaiter (used by ES2017 async functions transformation)
Generator = 1 << 7, // __generator (used by ES2015 generator transformation)
Values = 1 << 8, // __values (used by ES2015 for..of and yield* transformations)
Read = 1 << 9, // __read (used by ES2015 iterator destructuring transformation)
Spread = 1 << 10, // __spread (used by ES2015 array spread and argument list spread transformations)
AsyncGenerator = 1 << 11, // __asyncGenerator (used by ES2017 async generator transformation)
AsyncDelegator = 1 << 12, // __asyncDelegator (used by ES2017 async generator yield* transformation)
AsyncValues = 1 << 13, // __asyncValues (used by ES2017 for..await..of transformation)
// Helpers included by ES2015 for..of
ForOfIncludes = Values,
// Helpers included by ES2017 for..await..of
ForAwaitOfIncludes = AsyncValues,
// Helpers included by ES2015 spread
SpreadIncludes = Read | Spread,
FirstEmitHelper = Extends,
LastEmitHelper = Generator
LastEmitHelper = AsyncValues
}
export const enum EmitHint {
src/compiler/utilities.ts
+46 -4
View File
@@ -960,7 +960,7 @@ namespace ts {
return false;
}
export function unwrapInnermostStatmentOfLabel(node: LabeledStatement, beforeUnwrapLabelCallback?: (node: LabeledStatement) => void) {
export function unwrapInnermostStatementOfLabel(node: LabeledStatement, beforeUnwrapLabelCallback?: (node: LabeledStatement) => void) {
while (true) {
if (beforeUnwrapLabelCallback) {
beforeUnwrapLabelCallback(node);
@@ -1950,8 +1950,51 @@ namespace ts {
return SyntaxKind.FirstTriviaToken <= token && token <= SyntaxKind.LastTriviaToken;
}
export function isAsyncFunctionLike(node: Node): boolean {
return isFunctionLike(node) && hasModifier(node, ModifierFlags.Async) && !isAccessor(node);
export const enum FunctionFlags {
Normal = 0,
Generator = 1 << 0,
Async = 1 << 1,
AsyncOrAsyncGenerator = Async | Generator,
Invalid = 1 << 2,
InvalidAsyncOrAsyncGenerator = AsyncOrAsyncGenerator | Invalid,
InvalidGenerator = Generator | Invalid,
}
export function getFunctionFlags(node: FunctionLikeDeclaration) {
let flags = FunctionFlags.Normal;
switch (node.kind) {
case SyntaxKind.FunctionDeclaration:
case SyntaxKind.FunctionExpression:
case SyntaxKind.MethodDeclaration:
if (node.asteriskToken) {
flags |= FunctionFlags.Generator;
}
// fall through
case SyntaxKind.ArrowFunction:
if (hasModifier(node, ModifierFlags.Async)) {
flags |= FunctionFlags.Async;
}
break;
}
if (!node.body) {
flags |= FunctionFlags.Invalid;
}
return flags;
}
export function isAsyncFunction(node: Node): boolean {
switch (node.kind) {
case SyntaxKind.FunctionDeclaration:
case SyntaxKind.FunctionExpression:
case SyntaxKind.ArrowFunction:
case SyntaxKind.MethodDeclaration:
return (<FunctionLikeDeclaration>node).body !== undefined
&& (<FunctionLikeDeclaration>node).asteriskToken === undefined
&& hasModifier(node, ModifierFlags.Async);
}
return false;
}
export function isStringOrNumericLiteral(node: Node): node is StringLiteral | NumericLiteral {
@@ -4170,7 +4213,6 @@ namespace ts {
return "lib.es2016.d.ts";
case ScriptTarget.ES2015:
return "lib.es6.d.ts";
default:
return "lib.d.ts";
}
src/compiler/visitor.ts
+8 -40
View File
@@ -4,7 +4,7 @@
/* @internal */
namespace ts {
export type VisitResult<T extends Node> = T | T[];
export type VisitResult<T extends Node> = T[] | T | undefined;
function reduceNode<T>(node: Node, f: (memo: T, node: Node) => T, initial: T) {
return node ? f(initial, node) : initial;
@@ -725,6 +725,7 @@ namespace ts {
return updateMethod(<MethodDeclaration>node,
visitNodes((<MethodDeclaration>node).decorators, visitor, isDecorator),
visitNodes((<MethodDeclaration>node).modifiers, visitor, isModifier),
(<MethodDeclaration>node).asteriskToken,
visitNode((<MethodDeclaration>node).name, visitor, isPropertyName),
visitNodes((<MethodDeclaration>node).typeParameters, visitor, isTypeParameter),
visitParameterList((<MethodDeclaration>node).parameters, visitor, context),
@@ -819,6 +820,7 @@ namespace ts {
case SyntaxKind.FunctionExpression:
return updateFunctionExpression(<FunctionExpression>node,
visitNodes((<FunctionExpression>node).modifiers, visitor, isModifier),
(<FunctionExpression>node).asteriskToken,
visitNode((<FunctionExpression>node).name, visitor, isPropertyName),
visitNodes((<FunctionExpression>node).typeParameters, visitor, isTypeParameter),
visitParameterList((<FunctionExpression>node).parameters, visitor, context),
@@ -954,6 +956,7 @@ namespace ts {
case SyntaxKind.ForOfStatement:
return updateForOf(<ForOfStatement>node,
(<ForOfStatement>node).awaitModifier,
visitNode((<ForOfStatement>node).initializer, visitor, isForInitializer),
visitNode((<ForOfStatement>node).expression, visitor, isExpression),
visitNode((<ForOfStatement>node).statement, visitor, isStatement, /*optional*/ false, liftToBlock));
@@ -1009,6 +1012,7 @@ namespace ts {
return updateFunctionDeclaration(<FunctionDeclaration>node,
visitNodes((<FunctionDeclaration>node).decorators, visitor, isDecorator),
visitNodes((<FunctionDeclaration>node).modifiers, visitor, isModifier),
(<FunctionDeclaration>node).asteriskToken,
visitNode((<FunctionDeclaration>node).name, visitor, isPropertyName),
visitNodes((<FunctionDeclaration>node).typeParameters, visitor, isTypeParameter),
visitParameterList((<FunctionDeclaration>node).parameters, visitor, context),
@@ -1199,9 +1203,10 @@ namespace ts {
}
/**
* Merges generated lexical declarations into a new statement list.
* Merges generated lexical declarations into a statement list, creating a new statement list.
*/
export function mergeLexicalEnvironment(statements: NodeArray<Statement>, declarations: Statement[]): NodeArray<Statement>;
/**
* Appends generated lexical declarations to an array of statements.
*/
@@ -1210,49 +1215,12 @@ namespace ts {
if (!some(declarations)) {
return statements;
}
return isNodeArray(statements)
? setTextRange(createNodeArray(concatenate(statements, declarations)), statements)
: addRange(statements, declarations);
}
/**
* Merges generated lexical declarations into the FunctionBody of a non-arrow function-like declaration.
*
* @param node The ConciseBody of an arrow function.
* @param declarations The lexical declarations to merge.
*/
export function mergeFunctionBodyLexicalEnvironment(body: FunctionBody, declarations: Statement[]): FunctionBody;
/**
* Merges generated lexical declarations into the ConciseBody of an ArrowFunction.
*
* @param node The ConciseBody of an arrow function.
* @param declarations The lexical declarations to merge.
*/
export function mergeFunctionBodyLexicalEnvironment(body: ConciseBody, declarations: Statement[]): ConciseBody;
export function mergeFunctionBodyLexicalEnvironment(body: ConciseBody, declarations: Statement[]): ConciseBody {
if (body && declarations !== undefined && declarations.length > 0) {
if (isBlock(body)) {
return updateBlock(body, setTextRange(createNodeArray(concatenate(body.statements, declarations)), body.statements));
}
else {
return setTextRange(
createBlock(
setTextRange(
createNodeArray([setTextRange(createReturn(body), body), ...declarations]),
body
),
/*multiLine*/ true
),
/*location*/ body
);
}
}
return body;
}
/**
* Lifts a NodeArray containing only Statement nodes to a block.
*
src/harness/unittests/commandLineParsing.ts
+3 -3
View File
@@ -60,7 +60,7 @@ namespace ts {
assertParseResult(["--lib", "es5,invalidOption", "0.ts"],
{
errors: [{
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'",
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'",
category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
@@ -263,7 +263,7 @@ namespace ts {
assertParseResult(["--lib", "es5,", "es7", "0.ts"],
{
errors: [{
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'",
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'",
category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
@@ -283,7 +283,7 @@ namespace ts {
assertParseResult(["--lib", "es5, ", "es7", "0.ts"],
{
errors: [{
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'",
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'",
category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
src/harness/unittests/convertCompilerOptionsFromJson.ts
+4 -4
View File
@@ -233,7 +233,7 @@ namespace ts {
file: undefined,
start: 0,
length: 0,
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'",
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'",
code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
}]
@@ -264,7 +264,7 @@ namespace ts {
file: undefined,
start: 0,
length: 0,
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'",
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'",
code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
}]
@@ -295,7 +295,7 @@ namespace ts {
file: undefined,
start: 0,
length: 0,
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'",
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'",
code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
}]
@@ -326,7 +326,7 @@ namespace ts {
file: undefined,
start: 0,
length: 0,
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string'",
messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'esnext', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'esnext.asynciterable'",
code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
}]
src/lib/es2015.iterable.d.ts
Vendored
+47 -47
View File
@@ -1,8 +1,8 @@
/// <reference path="lib.es2015.symbol.d.ts" />
interface SymbolConstructor {
/**
* A method that returns the default iterator for an object. Called by the semantics of the
/**
* A method that returns the default iterator for an object. Called by the semantics of the
* for-of statement.
*/
readonly iterator: symbol;
@@ -31,17 +31,17 @@ interface Array<T> {
/** Iterator */
[Symbol.iterator](): IterableIterator<T>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, T]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<T>;
@@ -55,7 +55,7 @@ interface ArrayConstructor {
* @param thisArg Value of 'this' used to invoke the mapfn.
*/
from<T, U>(iterable: Iterable<T>, mapfn: (v: T, k: number) => U, thisArg?: any): Array<U>;
/**
* Creates an array from an iterable object.
* @param iterable An iterable object to convert to an array.
@@ -67,17 +67,17 @@ interface ReadonlyArray<T> {
/** Iterator */
[Symbol.iterator](): IterableIterator<T>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, T]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<T>;
@@ -126,15 +126,15 @@ interface Promise<T> { }
interface PromiseConstructor {
/**
* Creates a Promise that is resolved with an array of results when all of the provided Promises
* Creates a Promise that is resolved with an array of results when all of the provided Promises
* resolve, or rejected when any Promise is rejected.
* @param values An array of Promises.
* @returns A new Promise.
*/
all<TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>;
/**
* Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
* Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
* or rejected.
* @param values An array of Promises.
* @returns A new Promise.
@@ -152,20 +152,20 @@ interface String {
}
/**
* A typed array of 8-bit integer values. The contents are initialized to 0. If the requested
* A typed array of 8-bit integer values. The contents are initialized to 0. If the requested
* number of bytes could not be allocated an exception is raised.
*/
interface Int8Array {
[Symbol.iterator](): IterableIterator<number>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, number]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<number>;
@@ -184,20 +184,20 @@ interface Int8ArrayConstructor {
}
/**
* A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the
* A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the
* requested number of bytes could not be allocated an exception is raised.
*/
interface Uint8Array {
[Symbol.iterator](): IterableIterator<number>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, number]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<number>;
@@ -216,22 +216,22 @@ interface Uint8ArrayConstructor {
}
/**
* A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0.
* A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0.
* If the requested number of bytes could not be allocated an exception is raised.
*/
interface Uint8ClampedArray {
[Symbol.iterator](): IterableIterator<number>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, number]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<number>;
@@ -251,22 +251,22 @@ interface Uint8ClampedArrayConstructor {
}
/**
* A typed array of 16-bit signed integer values. The contents are initialized to 0. If the
* A typed array of 16-bit signed integer values. The contents are initialized to 0. If the
* requested number of bytes could not be allocated an exception is raised.
*/
interface Int16Array {
[Symbol.iterator](): IterableIterator<number>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, number]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<number>;
@@ -285,20 +285,20 @@ interface Int16ArrayConstructor {
}
/**
* A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the
* A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the
* requested number of bytes could not be allocated an exception is raised.
*/
interface Uint16Array {
[Symbol.iterator](): IterableIterator<number>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, number]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<number>;
@@ -317,20 +317,20 @@ interface Uint16ArrayConstructor {
}
/**
* A typed array of 32-bit signed integer values. The contents are initialized to 0. If the
* A typed array of 32-bit signed integer values. The contents are initialized to 0. If the
* requested number of bytes could not be allocated an exception is raised.
*/
interface Int32Array {
[Symbol.iterator](): IterableIterator<number>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, number]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<number>;
@@ -349,20 +349,20 @@ interface Int32ArrayConstructor {
}
/**
* A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the
* A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the
* requested number of bytes could not be allocated an exception is raised.
*/
interface Uint32Array {
[Symbol.iterator](): IterableIterator<number>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, number]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<number>;
@@ -386,15 +386,15 @@ interface Uint32ArrayConstructor {
*/
interface Float32Array {
[Symbol.iterator](): IterableIterator<number>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, number]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<number>;
@@ -413,20 +413,20 @@ interface Float32ArrayConstructor {
}
/**
* A typed array of 64-bit float values. The contents are initialized to 0. If the requested
* A typed array of 64-bit float values. The contents are initialized to 0. If the requested
* number of bytes could not be allocated an exception is raised.
*/
interface Float64Array {
[Symbol.iterator](): IterableIterator<number>;
/**
/**
* Returns an array of key, value pairs for every entry in the array
*/
entries(): IterableIterator<[number, number]>;
/**
/**
* Returns an list of keys in the array
*/
keys(): IterableIterator<number>;
/**
/**
* Returns an list of values in the array
*/
values(): IterableIterator<number>;
src/lib/es2017.d.ts
Vendored
+1 -1
View File
@@ -1,4 +1,4 @@
/// <reference path="lib.es2016.d.ts" />
/// <reference path="lib.es2017.object.d.ts" />
/// <reference path="lib.es2017.sharedmemory.d.ts" />
/// <reference path="lib.es2017.string.d.ts" />
/// <reference path="lib.es2017.string.d.ts" />
src/lib/esnext.asynciterable.d.ts
Vendored
+24
View File
@@ -0,0 +1,24 @@
/// <reference path="lib.es2015.symbol.d.ts" />
/// <reference path="lib.es2015.iterable.d.ts" />
interface SymbolConstructor {
/**
* A method that returns the default async iterator for an object. Called by the semantics of
* the for-await-of statement.
*/
readonly asyncIterator: symbol;
}
interface AsyncIterator<T> {
next(value?: any): Promise<IteratorResult<T>>;
return?(value?: any): Promise<IteratorResult<T>>;
throw?(e?: any): Promise<IteratorResult<T>>;
}
interface AsyncIterable<T> {
[Symbol.asyncIterator](): AsyncIterator<T>;
}
interface AsyncIterableIterator<T> extends AsyncIterator<T> {
[Symbol.asyncIterator](): AsyncIterableIterator<T>;
}
src/lib/esnext.d.ts
Vendored
+2
View File
@@ -0,0 +1,2 @@
/// <reference path="lib.es2017.d.ts" />
/// <reference path="lib.esnext.asynciterable.d.ts" />
tests/baselines/reference/ES5For-of33.errors.txt
+9
View File
@@ -0,0 +1,9 @@
tests/cases/conformance/statements/for-ofStatements/ES5For-of33.ts(2,5): error TS2304: Cannot find name 'console'.
==== tests/cases/conformance/statements/for-ofStatements/ES5For-of33.ts (1 errors) ====
for (var v of ['a', 'b', 'c']) {
console.log(v);
~~~~~~~
!!! error TS2304: Cannot find name 'console'.
}
tests/baselines/reference/ES5For-of33.js
+31
View File
@@ -0,0 +1,31 @@
//// [ES5For-of33.ts]
for (var v of ['a', 'b', 'c']) {
console.log(v);
}
//// [ES5For-of33.js]
var __values = (this && this.__values) || function (o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
};
try {
for (var _a = __values(['a', 'b', 'c']), _b = _a.next(); !_b.done; _b = _a.next()) {
var v = _b.value;
console.log(v);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_b && !_b.done && (_c = _a["return"])) _c.call(_a);
}
finally { if (e_1) throw e_1.error; }
}
var e_1, _c;
//# sourceMappingURL=ES5For-of33.js.map
tests/baselines/reference/ES5For-of33.js.map
+2
View File
@@ -0,0 +1,2 @@
//// [ES5For-of33.js.map]
{"version":3,"file":"ES5For-of33.js","sourceRoot":"","sources":["ES5For-of33.ts"],"names":[],"mappings":";;;;;;;;;;;IAAA,GAAG,CAAC,CAAU,IAAA,KAAA,SAAA,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA,gBAAA;QAAxB,IAAI,CAAC,WAAA;QACN,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAClB"}
tests/baselines/reference/ES5For-of33.sourcemap.txt
+128
View File
@@ -0,0 +1,128 @@
===================================================================
JsFile: ES5For-of33.js
mapUrl: ES5For-of33.js.map
sourceRoot:
sources: ES5For-of33.ts
===================================================================
-------------------------------------------------------------------
emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of33.js
sourceFile:ES5For-of33.ts
-------------------------------------------------------------------
>>>var __values = (this && this.__values) || function (o) {
>>> var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
>>> if (m) return m.call(o);
>>> return {
>>> next: function () {
>>> if (o && i >= o.length) o = void 0;
>>> return { value: o && o[i++], done: !o };
>>> }
>>> };
>>>};
>>>try {
>>> for (var _a = __values(['a', 'b', 'c']), _b = _a.next(); !_b.done; _b = _a.next()) {
1 >^^^^
2 > ^^^
3 > ^
4 > ^
5 > ^^^^
6 > ^^^^^
7 > ^^^^^^^^^
8 > ^
9 > ^^^
10> ^^
11> ^^^
12> ^^
13> ^^^
14> ^
15> ^
16> ^^^^^^^^^^^^^^^^
1 >
2 > for
3 >
4 > (var v of
5 >
6 >
7 >
8 > [
9 > 'a'
10> ,
11> 'b'
12> ,
13> 'c'
14> ]
15>
16>
1 >Emitted(12, 5) Source(1, 1) + SourceIndex(0)
2 >Emitted(12, 8) Source(1, 4) + SourceIndex(0)
3 >Emitted(12, 9) Source(1, 5) + SourceIndex(0)
4 >Emitted(12, 10) Source(1, 15) + SourceIndex(0)
5 >Emitted(12, 14) Source(1, 15) + SourceIndex(0)
6 >Emitted(12, 19) Source(1, 15) + SourceIndex(0)
7 >Emitted(12, 28) Source(1, 15) + SourceIndex(0)
8 >Emitted(12, 29) Source(1, 16) + SourceIndex(0)
9 >Emitted(12, 32) Source(1, 19) + SourceIndex(0)
10>Emitted(12, 34) Source(1, 21) + SourceIndex(0)
11>Emitted(12, 37) Source(1, 24) + SourceIndex(0)
12>Emitted(12, 39) Source(1, 26) + SourceIndex(0)
13>Emitted(12, 42) Source(1, 29) + SourceIndex(0)
14>Emitted(12, 43) Source(1, 30) + SourceIndex(0)
15>Emitted(12, 44) Source(1, 30) + SourceIndex(0)
16>Emitted(12, 60) Source(1, 30) + SourceIndex(0)
---
>>> var v = _b.value;
1 >^^^^^^^^
2 > ^^^^
3 > ^
4 > ^^^^^^^^^^^
1 >
2 > var
3 > v
4 >
1 >Emitted(13, 9) Source(1, 6) + SourceIndex(0)
2 >Emitted(13, 13) Source(1, 10) + SourceIndex(0)
3 >Emitted(13, 14) Source(1, 11) + SourceIndex(0)
4 >Emitted(13, 25) Source(1, 11) + SourceIndex(0)
---
>>> console.log(v);
1 >^^^^^^^^
2 > ^^^^^^^
3 > ^
4 > ^^^
5 > ^
6 > ^
7 > ^
8 > ^
1 > of ['a', 'b', 'c']) {
>
2 > console
3 > .
4 > log
5 > (
6 > v
7 > )
8 > ;
1 >Emitted(14, 9) Source(2, 5) + SourceIndex(0)
2 >Emitted(14, 16) Source(2, 12) + SourceIndex(0)
3 >Emitted(14, 17) Source(2, 13) + SourceIndex(0)
4 >Emitted(14, 20) Source(2, 16) + SourceIndex(0)
5 >Emitted(14, 21) Source(2, 17) + SourceIndex(0)
6 >Emitted(14, 22) Source(2, 18) + SourceIndex(0)
7 >Emitted(14, 23) Source(2, 19) + SourceIndex(0)
8 >Emitted(14, 24) Source(2, 20) + SourceIndex(0)
---
>>> }
1 >^^^^^
1 >
>}
1 >Emitted(15, 6) Source(3, 2) + SourceIndex(0)
---
>>>}
>>>catch (e_1_1) { e_1 = { error: e_1_1 }; }
>>>finally {
>>> try {
>>> if (_b && !_b.done && (_c = _a["return"])) _c.call(_a);
>>> }
>>> finally { if (e_1) throw e_1.error; }
>>>}
>>>var e_1, _c;
>>>//# sourceMappingURL=ES5For-of33.js.map
tests/baselines/reference/ES5For-of34.errors.txt
+12
View File
@@ -0,0 +1,12 @@
tests/cases/conformance/statements/for-ofStatements/ES5For-of34.ts(4,6): error TS2322: Type 'string' is not assignable to type 'number'.
==== tests/cases/conformance/statements/for-ofStatements/ES5For-of34.ts (1 errors) ====
function foo() {
return { x: 0 };
}
for (foo().x of ['a', 'b', 'c']) {
~~~~~~~
!!! error TS2322: Type 'string' is not assignable to type 'number'.
var p = foo().x;
}
tests/baselines/reference/ES5For-of34.js
+37
View File
@@ -0,0 +1,37 @@
//// [ES5For-of34.ts]
function foo() {
return { x: 0 };
}
for (foo().x of ['a', 'b', 'c']) {
var p = foo().x;
}
//// [ES5For-of34.js]
var __values = (this && this.__values) || function (o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
};
function foo() {
return { x: 0 };
}
try {
for (var _a = __values(['a', 'b', 'c']), _b = _a.next(); !_b.done; _b = _a.next()) {
foo().x = _b.value;
var p = foo().x;
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_b && !_b.done && (_c = _a["return"])) _c.call(_a);
}
finally { if (e_1) throw e_1.error; }
}
var e_1, _c;
//# sourceMappingURL=ES5For-of34.js.map
tests/baselines/reference/ES5For-of34.js.map
+2
View File
@@ -0,0 +1,2 @@
//// [ES5For-of34.js.map]
{"version":3,"file":"ES5For-of34.js","sourceRoot":"","sources":["ES5For-of34.ts"],"names":[],"mappings":";;;;;;;;;;AAAA;IACI,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACpB,CAAC;;IACD,GAAG,CAAC,CAAY,IAAA,KAAA,SAAA,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA,gBAAA;QAA1B,GAAG,EAAE,CAAC,CAAC,WAAA;QACR,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC;KACnB"}
tests/baselines/reference/ES5For-of34.sourcemap.txt
+184
View File
@@ -0,0 +1,184 @@
===================================================================
JsFile: ES5For-of34.js
mapUrl: ES5For-of34.js.map
sourceRoot:
sources: ES5For-of34.ts
===================================================================
-------------------------------------------------------------------
emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of34.js
sourceFile:ES5For-of34.ts
-------------------------------------------------------------------
>>>var __values = (this && this.__values) || function (o) {
>>> var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
>>> if (m) return m.call(o);
>>> return {
>>> next: function () {
>>> if (o && i >= o.length) o = void 0;
>>> return { value: o && o[i++], done: !o };
>>> }
>>> };
>>>};
>>>function foo() {
1 >
2 >^^^^^^^^^^^^^^^^^^^^^->
1 >
1 >Emitted(11, 1) Source(1, 1) + SourceIndex(0)
---
>>> return { x: 0 };
1->^^^^
2 > ^^^^^^
3 > ^
4 > ^^
5 > ^
6 > ^^
7 > ^
8 > ^^
9 > ^
1->function foo() {
>
2 > return
3 >
4 > {
5 > x
6 > :
7 > 0
8 > }
9 > ;
1->Emitted(12, 5) Source(2, 5) + SourceIndex(0)
2 >Emitted(12, 11) Source(2, 11) + SourceIndex(0)
3 >Emitted(12, 12) Source(2, 12) + SourceIndex(0)
4 >Emitted(12, 14) Source(2, 14) + SourceIndex(0)
5 >Emitted(12, 15) Source(2, 15) + SourceIndex(0)
6 >Emitted(12, 17) Source(2, 17) + SourceIndex(0)
7 >Emitted(12, 18) Source(2, 18) + SourceIndex(0)
8 >Emitted(12, 20) Source(2, 20) + SourceIndex(0)
9 >Emitted(12, 21) Source(2, 21) + SourceIndex(0)
---
>>>}
1 >
2 >^
3 > ^^^^^->
1 >
>
2 >}
1 >Emitted(13, 1) Source(3, 1) + SourceIndex(0)
2 >Emitted(13, 2) Source(3, 2) + SourceIndex(0)
---
>>>try {
>>> for (var _a = __values(['a', 'b', 'c']), _b = _a.next(); !_b.done; _b = _a.next()) {
1->^^^^
2 > ^^^
3 > ^
4 > ^
5 > ^^^^
6 > ^^^^^
7 > ^^^^^^^^^
8 > ^
9 > ^^^
10> ^^
11> ^^^
12> ^^
13> ^^^
14> ^
15> ^
16> ^^^^^^^^^^^^^^^^
1->
>
2 > for
3 >
4 > (foo().x of
5 >
6 >
7 >
8 > [
9 > 'a'
10> ,
11> 'b'
12> ,
13> 'c'
14> ]
15>
16>
1->Emitted(15, 5) Source(4, 1) + SourceIndex(0)
2 >Emitted(15, 8) Source(4, 4) + SourceIndex(0)
3 >Emitted(15, 9) Source(4, 5) + SourceIndex(0)
4 >Emitted(15, 10) Source(4, 17) + SourceIndex(0)
5 >Emitted(15, 14) Source(4, 17) + SourceIndex(0)
6 >Emitted(15, 19) Source(4, 17) + SourceIndex(0)
7 >Emitted(15, 28) Source(4, 17) + SourceIndex(0)
8 >Emitted(15, 29) Source(4, 18) + SourceIndex(0)
9 >Emitted(15, 32) Source(4, 21) + SourceIndex(0)
10>Emitted(15, 34) Source(4, 23) + SourceIndex(0)
11>Emitted(15, 37) Source(4, 26) + SourceIndex(0)
12>Emitted(15, 39) Source(4, 28) + SourceIndex(0)
13>Emitted(15, 42) Source(4, 31) + SourceIndex(0)
14>Emitted(15, 43) Source(4, 32) + SourceIndex(0)
15>Emitted(15, 44) Source(4, 32) + SourceIndex(0)
16>Emitted(15, 60) Source(4, 32) + SourceIndex(0)
---
>>> foo().x = _b.value;
1 >^^^^^^^^
2 > ^^^
3 > ^^
4 > ^
5 > ^
6 > ^^^^^^^^^^^
1 >
2 > foo
3 > ()
4 > .
5 > x
6 >
1 >Emitted(16, 9) Source(4, 6) + SourceIndex(0)
2 >Emitted(16, 12) Source(4, 9) + SourceIndex(0)
3 >Emitted(16, 14) Source(4, 11) + SourceIndex(0)
4 >Emitted(16, 15) Source(4, 12) + SourceIndex(0)
5 >Emitted(16, 16) Source(4, 13) + SourceIndex(0)
6 >Emitted(16, 27) Source(4, 13) + SourceIndex(0)
---
>>> var p = foo().x;
1 >^^^^^^^^
2 > ^^^^
3 > ^
4 > ^^^
5 > ^^^
6 > ^^
7 > ^
8 > ^
9 > ^
1 > of ['a', 'b', 'c']) {
>
2 > var
3 > p
4 > =
5 > foo
6 > ()
7 > .
8 > x
9 > ;
1 >Emitted(17, 9) Source(5, 5) + SourceIndex(0)
2 >Emitted(17, 13) Source(5, 9) + SourceIndex(0)
3 >Emitted(17, 14) Source(5, 10) + SourceIndex(0)
4 >Emitted(17, 17) Source(5, 13) + SourceIndex(0)
5 >Emitted(17, 20) Source(5, 16) + SourceIndex(0)
6 >Emitted(17, 22) Source(5, 18) + SourceIndex(0)
7 >Emitted(17, 23) Source(5, 19) + SourceIndex(0)
8 >Emitted(17, 24) Source(5, 20) + SourceIndex(0)
9 >Emitted(17, 25) Source(5, 21) + SourceIndex(0)
---
>>> }
1 >^^^^^
1 >
>}
1 >Emitted(18, 6) Source(6, 2) + SourceIndex(0)
---
>>>}
>>>catch (e_1_1) { e_1 = { error: e_1_1 }; }
>>>finally {
>>> try {
>>> if (_b && !_b.done && (_c = _a["return"])) _c.call(_a);
>>> }
>>> finally { if (e_1) throw e_1.error; }
>>>}
>>>var e_1, _c;
>>>//# sourceMappingURL=ES5For-of34.js.map
tests/baselines/reference/ES5For-of35.errors.txt
+13
View File
@@ -0,0 +1,13 @@
tests/cases/conformance/statements/for-ofStatements/ES5For-of35.ts(1,13): error TS2459: Type 'number' has no property 'x' and no string index signature.
tests/cases/conformance/statements/for-ofStatements/ES5For-of35.ts(1,23): error TS2459: Type 'number' has no property 'y' and no string index signature.
==== tests/cases/conformance/statements/for-ofStatements/ES5For-of35.ts (2 errors) ====
for (const {x: a = 0, y: b = 1} of [2, 3]) {
~
!!! error TS2459: Type 'number' has no property 'x' and no string index signature.
~
!!! error TS2459: Type 'number' has no property 'y' and no string index signature.
a;
b;
}
tests/baselines/reference/ES5For-of35.js
+33
View File
@@ -0,0 +1,33 @@
//// [ES5For-of35.ts]
for (const {x: a = 0, y: b = 1} of [2, 3]) {
a;
b;
}
//// [ES5For-of35.js]
var __values = (this && this.__values) || function (o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
};
try {
for (var _a = __values([2, 3]), _b = _a.next(); !_b.done; _b = _a.next()) {
var _c = _b.value, _d = _c.x, a = _d === void 0 ? 0 : _d, _e = _c.y, b = _e === void 0 ? 1 : _e;
a;
b;
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_b && !_b.done && (_f = _a["return"])) _f.call(_a);
}
finally { if (e_1) throw e_1.error; }
}
var e_1, _f;
//# sourceMappingURL=ES5For-of35.js.map
tests/baselines/reference/ES5For-of35.js.map
+2
View File
@@ -0,0 +1,2 @@
//// [ES5For-of35.js.map]
{"version":3,"file":"ES5For-of35.js","sourceRoot":"","sources":["ES5For-of35.ts"],"names":[],"mappings":";;;;;;;;;;;IAAA,GAAG,CAAC,CAA+B,IAAA,KAAA,SAAA,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA,gBAAA;QAA9B,IAAA,aAAoB,EAAnB,SAAQ,EAAR,0BAAQ,EAAE,SAAQ,EAAR,0BAAQ;QAC1B,CAAC,CAAC;QACF,CAAC,CAAC;KACL"}
tests/baselines/reference/ES5For-of35.sourcemap.txt
+142
View File
@@ -0,0 +1,142 @@
===================================================================
JsFile: ES5For-of35.js
mapUrl: ES5For-of35.js.map
sourceRoot:
sources: ES5For-of35.ts
===================================================================
-------------------------------------------------------------------
emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of35.js
sourceFile:ES5For-of35.ts
-------------------------------------------------------------------
>>>var __values = (this && this.__values) || function (o) {
>>> var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
>>> if (m) return m.call(o);
>>> return {
>>> next: function () {
>>> if (o && i >= o.length) o = void 0;
>>> return { value: o && o[i++], done: !o };
>>> }
>>> };
>>>};
>>>try {
>>> for (var _a = __values([2, 3]), _b = _a.next(); !_b.done; _b = _a.next()) {
1 >^^^^
2 > ^^^
3 > ^
4 > ^
5 > ^^^^
6 > ^^^^^
7 > ^^^^^^^^^
8 > ^
9 > ^
10> ^^
11> ^
12> ^
13> ^
14> ^^^^^^^^^^^^^^^^
15> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
2 > for
3 >
4 > (const {x: a = 0, y: b = 1} of
5 >
6 >
7 >
8 > [
9 > 2
10> ,
11> 3
12> ]
13>
14>
1 >Emitted(12, 5) Source(1, 1) + SourceIndex(0)
2 >Emitted(12, 8) Source(1, 4) + SourceIndex(0)
3 >Emitted(12, 9) Source(1, 5) + SourceIndex(0)
4 >Emitted(12, 10) Source(1, 36) + SourceIndex(0)
5 >Emitted(12, 14) Source(1, 36) + SourceIndex(0)
6 >Emitted(12, 19) Source(1, 36) + SourceIndex(0)
7 >Emitted(12, 28) Source(1, 36) + SourceIndex(0)
8 >Emitted(12, 29) Source(1, 37) + SourceIndex(0)
9 >Emitted(12, 30) Source(1, 38) + SourceIndex(0)
10>Emitted(12, 32) Source(1, 40) + SourceIndex(0)
11>Emitted(12, 33) Source(1, 41) + SourceIndex(0)
12>Emitted(12, 34) Source(1, 42) + SourceIndex(0)
13>Emitted(12, 35) Source(1, 42) + SourceIndex(0)
14>Emitted(12, 51) Source(1, 42) + SourceIndex(0)
---
>>> var _c = _b.value, _d = _c.x, a = _d === void 0 ? 0 : _d, _e = _c.y, b = _e === void 0 ? 1 : _e;
1->^^^^^^^^
2 > ^^^^
3 > ^^^^^^^^^^^^^
4 > ^^
5 > ^^^^^^^^^
6 > ^^
7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^
8 > ^^
9 > ^^^^^^^^^
10> ^^
11> ^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >
3 > {x: a = 0, y: b = 1}
4 >
5 > x: a = 0
6 >
7 > x: a = 0
8 > ,
9 > y: b = 1
10>
11> y: b = 1
1->Emitted(13, 9) Source(1, 12) + SourceIndex(0)
2 >Emitted(13, 13) Source(1, 12) + SourceIndex(0)
3 >Emitted(13, 26) Source(1, 32) + SourceIndex(0)
4 >Emitted(13, 28) Source(1, 13) + SourceIndex(0)
5 >Emitted(13, 37) Source(1, 21) + SourceIndex(0)
6 >Emitted(13, 39) Source(1, 13) + SourceIndex(0)
7 >Emitted(13, 65) Source(1, 21) + SourceIndex(0)
8 >Emitted(13, 67) Source(1, 23) + SourceIndex(0)
9 >Emitted(13, 76) Source(1, 31) + SourceIndex(0)
10>Emitted(13, 78) Source(1, 23) + SourceIndex(0)
11>Emitted(13, 104) Source(1, 31) + SourceIndex(0)
---
>>> a;
1 >^^^^^^^^
2 > ^
3 > ^
4 > ^->
1 >} of [2, 3]) {
>
2 > a
3 > ;
1 >Emitted(14, 9) Source(2, 5) + SourceIndex(0)
2 >Emitted(14, 10) Source(2, 6) + SourceIndex(0)
3 >Emitted(14, 11) Source(2, 7) + SourceIndex(0)
---
>>> b;
1->^^^^^^^^
2 > ^
3 > ^
1->
>
2 > b
3 > ;
1->Emitted(15, 9) Source(3, 5) + SourceIndex(0)
2 >Emitted(15, 10) Source(3, 6) + SourceIndex(0)
3 >Emitted(15, 11) Source(3, 7) + SourceIndex(0)
---
>>> }
1 >^^^^^
1 >
>}
1 >Emitted(16, 6) Source(4, 2) + SourceIndex(0)
---
>>>}
>>>catch (e_1_1) { e_1 = { error: e_1_1 }; }
>>>finally {
>>> try {
>>> if (_b && !_b.done && (_f = _a["return"])) _f.call(_a);
>>> }
>>> finally { if (e_1) throw e_1.error; }
>>>}
>>>var e_1, _f;
>>>//# sourceMappingURL=ES5For-of35.js.map
tests/baselines/reference/ES5For-of36.errors.txt
+10
View File
@@ -0,0 +1,10 @@
tests/cases/conformance/statements/for-ofStatements/ES5For-of36.ts(1,10): error TS2548: Type 'number' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator.
==== tests/cases/conformance/statements/for-ofStatements/ES5For-of36.ts (1 errors) ====
for (let [a = 0, b = 1] of [2, 3]) {
~~~~~~~~~~~~~~
!!! error TS2548: Type 'number' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator.
a;
b;
}
tests/baselines/reference/ES5For-of36.js
+49
View File
@@ -0,0 +1,49 @@
//// [ES5For-of36.ts]
for (let [a = 0, b = 1] of [2, 3]) {
a;
b;
}
//// [ES5For-of36.js]
var __values = (this && this.__values) || function (o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
try {
for (var _a = __values([2, 3]), _b = _a.next(); !_b.done; _b = _a.next()) {
var _c = __read(_b.value, 2), _d = _c[0], a = _d === void 0 ? 0 : _d, _e = _c[1], b = _e === void 0 ? 1 : _e;
a;
b;
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_b && !_b.done && (_f = _a["return"])) _f.call(_a);
}
finally { if (e_1) throw e_1.error; }
}
var e_1, _f;
//# sourceMappingURL=ES5For-of36.js.map
tests/baselines/reference/ES5For-of36.js.map
+2
View File
@@ -0,0 +1,2 @@
//// [ES5For-of36.js.map]
{"version":3,"file":"ES5For-of36.js","sourceRoot":"","sources":["ES5For-of36.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;IAAA,GAAG,CAAC,CAAuB,IAAA,KAAA,SAAA,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA,gBAAA;QAAxB,IAAA,wBAAc,EAAb,UAAK,EAAL,0BAAK,EAAE,UAAK,EAAL,0BAAK;QAClB,CAAC,CAAC;QACF,CAAC,CAAC;KACL"}
tests/baselines/reference/ES5For-of36.sourcemap.txt
+158
View File
@@ -0,0 +1,158 @@
===================================================================
JsFile: ES5For-of36.js
mapUrl: ES5For-of36.js.map
sourceRoot:
sources: ES5For-of36.ts
===================================================================
-------------------------------------------------------------------
emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of36.js
sourceFile:ES5For-of36.ts
-------------------------------------------------------------------
>>>var __values = (this && this.__values) || function (o) {
>>> var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
>>> if (m) return m.call(o);
>>> return {
>>> next: function () {
>>> if (o && i >= o.length) o = void 0;
>>> return { value: o && o[i++], done: !o };
>>> }
>>> };
>>>};
>>>var __read = (this && this.__read) || function (o, n) {
>>> var m = typeof Symbol === "function" && o[Symbol.iterator];
>>> if (!m) return o;
>>> var i = m.call(o), r, ar = [], e;
>>> try {
>>> while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
>>> }
>>> catch (error) { e = { error: error }; }
>>> finally {
>>> try {
>>> if (r && !r.done && (m = i["return"])) m.call(i);
>>> }
>>> finally { if (e) throw e.error; }
>>> }
>>> return ar;
>>>};
>>>try {
>>> for (var _a = __values([2, 3]), _b = _a.next(); !_b.done; _b = _a.next()) {
1 >^^^^
2 > ^^^
3 > ^
4 > ^
5 > ^^^^
6 > ^^^^^
7 > ^^^^^^^^^
8 > ^
9 > ^
10> ^^
11> ^
12> ^
13> ^
14> ^^^^^^^^^^^^^^^^
15> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
2 > for
3 >
4 > (let [a = 0, b = 1] of
5 >
6 >
7 >
8 > [
9 > 2
10> ,
11> 3
12> ]
13>
14>
1 >Emitted(28, 5) Source(1, 1) + SourceIndex(0)
2 >Emitted(28, 8) Source(1, 4) + SourceIndex(0)
3 >Emitted(28, 9) Source(1, 5) + SourceIndex(0)
4 >Emitted(28, 10) Source(1, 28) + SourceIndex(0)
5 >Emitted(28, 14) Source(1, 28) + SourceIndex(0)
6 >Emitted(28, 19) Source(1, 28) + SourceIndex(0)
7 >Emitted(28, 28) Source(1, 28) + SourceIndex(0)
8 >Emitted(28, 29) Source(1, 29) + SourceIndex(0)
9 >Emitted(28, 30) Source(1, 30) + SourceIndex(0)
10>Emitted(28, 32) Source(1, 32) + SourceIndex(0)
11>Emitted(28, 33) Source(1, 33) + SourceIndex(0)
12>Emitted(28, 34) Source(1, 34) + SourceIndex(0)
13>Emitted(28, 35) Source(1, 34) + SourceIndex(0)
14>Emitted(28, 51) Source(1, 34) + SourceIndex(0)
---
>>> var _c = __read(_b.value, 2), _d = _c[0], a = _d === void 0 ? 0 : _d, _e = _c[1], b = _e === void 0 ? 1 : _e;
1->^^^^^^^^
2 > ^^^^
3 > ^^^^^^^^^^^^^^^^^^^^^^^^
4 > ^^
5 > ^^^^^^^^^^
6 > ^^
7 > ^^^^^^^^^^^^^^^^^^^^^^^^^^
8 > ^^
9 > ^^^^^^^^^^
10> ^^
11> ^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >
3 > [a = 0, b = 1]
4 >
5 > a = 0
6 >
7 > a = 0
8 > ,
9 > b = 1
10>
11> b = 1
1->Emitted(29, 9) Source(1, 10) + SourceIndex(0)
2 >Emitted(29, 13) Source(1, 10) + SourceIndex(0)
3 >Emitted(29, 37) Source(1, 24) + SourceIndex(0)
4 >Emitted(29, 39) Source(1, 11) + SourceIndex(0)
5 >Emitted(29, 49) Source(1, 16) + SourceIndex(0)
6 >Emitted(29, 51) Source(1, 11) + SourceIndex(0)
7 >Emitted(29, 77) Source(1, 16) + SourceIndex(0)
8 >Emitted(29, 79) Source(1, 18) + SourceIndex(0)
9 >Emitted(29, 89) Source(1, 23) + SourceIndex(0)
10>Emitted(29, 91) Source(1, 18) + SourceIndex(0)
11>Emitted(29, 117) Source(1, 23) + SourceIndex(0)
---
>>> a;
1 >^^^^^^^^
2 > ^
3 > ^
4 > ^->
1 >] of [2, 3]) {
>
2 > a
3 > ;
1 >Emitted(30, 9) Source(2, 5) + SourceIndex(0)
2 >Emitted(30, 10) Source(2, 6) + SourceIndex(0)
3 >Emitted(30, 11) Source(2, 7) + SourceIndex(0)
---
>>> b;
1->^^^^^^^^
2 > ^
3 > ^
1->
>
2 > b
3 > ;
1->Emitted(31, 9) Source(3, 5) + SourceIndex(0)
2 >Emitted(31, 10) Source(3, 6) + SourceIndex(0)
3 >Emitted(31, 11) Source(3, 7) + SourceIndex(0)
---
>>> }
1 >^^^^^
1 >
>}
1 >Emitted(32, 6) Source(4, 2) + SourceIndex(0)
---
>>>}
>>>catch (e_1_1) { e_1 = { error: e_1_1 }; }
>>>finally {
>>> try {
>>> if (_b && !_b.done && (_f = _a["return"])) _f.call(_a);
>>> }
>>> finally { if (e_1) throw e_1.error; }
>>>}
>>>var e_1, _f;
>>>//# sourceMappingURL=ES5For-of36.js.map
tests/baselines/reference/FunctionDeclaration10_es6.js
+1 -3
View File
@@ -3,9 +3,7 @@ function * foo(a = yield => yield) {
}
//// [FunctionDeclaration10_es6.js]
function* foo(a) {
if (a === void 0) { a = yield; }
}
function* foo(a = yield) { }
yield;
{
}
tests/baselines/reference/FunctionDeclaration11_es6.errors.txt
-8
View File
@@ -1,8 +0,0 @@
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts (1 errors) ====
function * yield() {
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
}
tests/baselines/reference/FunctionDeclaration11_es6.symbols
+4
View File
@@ -0,0 +1,4 @@
=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts ===
function * yield() {
>yield : Symbol(yield, Decl(FunctionDeclaration11_es6.ts, 0, 0))
}
tests/baselines/reference/FunctionDeclaration11_es6.types
+4
View File
@@ -0,0 +1,4 @@
=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts ===
function * yield() {
>yield : () => IterableIterator<any>
}
tests/baselines/reference/FunctionDeclaration12_es6.js
+1 -1
View File
@@ -2,4 +2,4 @@
var v = function * yield() { }
//// [FunctionDeclaration12_es6.js]
var v = function* () { }, yield = function () { };
var v = function* () { }, yield = () => { };
tests/baselines/reference/FunctionDeclaration13_es6.errors.txt
+1 -4
View File
@@ -1,11 +1,8 @@
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(3,11): error TS2304: Cannot find name 'yield'.
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts (2 errors) ====
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts (1 errors) ====
function * foo() {
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
// Legal to use 'yield' in a type context.
var v: yield;
~~~~~
tests/baselines/reference/FunctionDeclaration1_es6.errors.txt
-8
View File
@@ -1,8 +0,0 @@
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts (1 errors) ====
function * foo() {
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
}
tests/baselines/reference/FunctionDeclaration1_es6.symbols
+4
View File
@@ -0,0 +1,4 @@
=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts ===
function * foo() {
>foo : Symbol(foo, Decl(FunctionDeclaration1_es6.ts, 0, 0))
}
tests/baselines/reference/FunctionDeclaration1_es6.types
+4
View File
@@ -0,0 +1,4 @@
=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts ===
function * foo() {
>foo : () => IterableIterator<any>
}
tests/baselines/reference/FunctionDeclaration3_es6.js
+1 -2
View File
@@ -3,6 +3,5 @@ function f(yield = yield) {
}
//// [FunctionDeclaration3_es6.js]
function f(yield) {
if (yield === void 0) { yield = yield; }
function f(yield = yield) {
}
tests/baselines/reference/FunctionDeclaration6_es6.errors.txt
+1 -4
View File
@@ -1,11 +1,8 @@
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS2523: 'yield' expressions cannot be used in a parameter initializer.
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (2 errors) ====
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (1 errors) ====
function*foo(a = yield) {
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
~~~~~
!!! error TS2523: 'yield' expressions cannot be used in a parameter initializer.
}
tests/baselines/reference/FunctionDeclaration6_es6.js
+1 -2
View File
@@ -3,6 +3,5 @@ function*foo(a = yield) {
}
//// [FunctionDeclaration6_es6.js]
function* foo(a) {
if (a === void 0) { a = yield; }
function* foo(a = yield) {
}
tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
+1 -7
View File
@@ -1,16 +1,10 @@
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS2523: 'yield' expressions cannot be used in a parameter initializer.
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (3 errors) ====
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (1 errors) ====
function*bar() {
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
// 'yield' here is an identifier, and not a yield expression.
function*foo(a = yield) {
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
~~~~~
!!! error TS2523: 'yield' expressions cannot be used in a parameter initializer.
}
tests/baselines/reference/FunctionDeclaration7_es6.js
+1 -2
View File
@@ -8,7 +8,6 @@ function*bar() {
//// [FunctionDeclaration7_es6.js]
function* bar() {
// 'yield' here is an identifier, and not a yield expression.
function* foo(a) {
if (a === void 0) { a = yield; }
function* foo(a = yield) {
}
}
tests/baselines/reference/FunctionDeclaration9_es6.errors.txt
-9
View File
@@ -1,9 +0,0 @@
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts (1 errors) ====
function * foo() {
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
var v = { [yield]: foo }
}
tests/baselines/reference/FunctionDeclaration9_es6.js
+1 -2
View File
@@ -5,6 +5,5 @@ function * foo() {
//// [FunctionDeclaration9_es6.js]
function* foo() {
var v = (_a = {}, _a[yield] = foo, _a);
var _a;
var v = { [yield]: foo };
}
tests/baselines/reference/FunctionDeclaration9_es6.symbols
+8
View File
@@ -0,0 +1,8 @@
=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts ===
function * foo() {
>foo : Symbol(foo, Decl(FunctionDeclaration9_es6.ts, 0, 0))
var v = { [yield]: foo }
>v : Symbol(v, Decl(FunctionDeclaration9_es6.ts, 1, 5))
>foo : Symbol(foo, Decl(FunctionDeclaration9_es6.ts, 0, 0))
}
tests/baselines/reference/FunctionDeclaration9_es6.types
+10
View File
@@ -0,0 +1,10 @@
=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts ===
function * foo() {
>foo : () => IterableIterator<any>
var v = { [yield]: foo }
>v : { [x: number]: () => IterableIterator<any>; }
>{ [yield]: foo } : { [x: number]: () => IterableIterator<any>; }
>yield : any
>foo : () => IterableIterator<any>
}
tests/baselines/reference/FunctionExpression1_es6.errors.txt
-7
View File
@@ -1,7 +0,0 @@
tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts(1,18): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
==== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts (1 errors) ====
var v = function * () { }
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/baselines/reference/FunctionExpression1_es6.symbols
+4
View File
@@ -0,0 +1,4 @@
=== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts ===
var v = function * () { }
>v : Symbol(v, Decl(FunctionExpression1_es6.ts, 0, 3))
tests/baselines/reference/FunctionExpression1_es6.types
+5
View File
@@ -0,0 +1,5 @@
=== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts ===
var v = function * () { }
>v : () => IterableIterator<any>
>function * () { } : () => IterableIterator<any>
tests/baselines/reference/FunctionExpression2_es6.errors.txt
-7
View File
@@ -1,7 +0,0 @@
tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts(1,18): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
==== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts (1 errors) ====
var v = function * foo() { }
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/baselines/reference/FunctionExpression2_es6.symbols
+5
View File
@@ -0,0 +1,5 @@
=== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts ===
var v = function * foo() { }
>v : Symbol(v, Decl(FunctionExpression2_es6.ts, 0, 3))
>foo : Symbol(foo, Decl(FunctionExpression2_es6.ts, 0, 7))
tests/baselines/reference/FunctionExpression2_es6.types
+6
View File
@@ -0,0 +1,6 @@
=== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts ===
var v = function * foo() { }
>v : () => IterableIterator<any>
>function * foo() { } : () => IterableIterator<any>
>foo : () => IterableIterator<any>
tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt
-7
View File
@@ -1,7 +0,0 @@
tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts (1 errors) ====
var v = { *foo() { } }
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/baselines/reference/FunctionPropertyAssignments1_es6.js
+1 -1
View File
@@ -2,4 +2,4 @@
var v = { *foo() { } }
//// [FunctionPropertyAssignments1_es6.js]
var v = { foo: function* () { } };
var v = { *foo() { } };
tests/baselines/reference/FunctionPropertyAssignments1_es6.symbols
+5
View File
@@ -0,0 +1,5 @@
=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts ===
var v = { *foo() { } }
>v : Symbol(v, Decl(FunctionPropertyAssignments1_es6.ts, 0, 3))
>foo : Symbol(foo, Decl(FunctionPropertyAssignments1_es6.ts, 0, 9))
tests/baselines/reference/FunctionPropertyAssignments1_es6.types
+6
View File
@@ -0,0 +1,6 @@
=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts ===
var v = { *foo() { } }
>v : { foo(): IterableIterator<any>; }
>{ *foo() { } } : { foo(): IterableIterator<any>; }
>foo : () => IterableIterator<any>
tests/baselines/reference/FunctionPropertyAssignments2_es6.js
+1 -1
View File
@@ -2,4 +2,4 @@
var v = { *() { } }
//// [FunctionPropertyAssignments2_es6.js]
var v = { : function* () { } };
var v = { *() { } };
tests/baselines/reference/FunctionPropertyAssignments3_es6.js
+1 -1
View File
@@ -2,4 +2,4 @@
var v = { *{ } }
//// [FunctionPropertyAssignments3_es6.js]
var v = { : function* () { } };
var v = { *() { } };
tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
+1 -4
View File
@@ -1,10 +1,7 @@
tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,13): error TS2304: Cannot find name 'foo'.
==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (2 errors) ====
==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (1 errors) ====
var v = { *[foo()]() { } }
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
~~~
!!! error TS2304: Cannot find name 'foo'.
tests/baselines/reference/FunctionPropertyAssignments5_es6.js
+1 -2
View File
@@ -2,5 +2,4 @@
var v = { *[foo()]() { } }
//// [FunctionPropertyAssignments5_es6.js]
var v = (_a = {}, _a[foo()] = function* () { }, _a);
var _a;
var v = { *[foo()]() { } };
tests/baselines/reference/FunctionPropertyAssignments6_es6.js
+1 -1
View File
@@ -2,4 +2,4 @@
var v = { *<T>() { } }
//// [FunctionPropertyAssignments6_es6.js]
var v = { : function* () { } };
var v = { *() { } };
tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt
-9
View File
@@ -1,9 +0,0 @@
tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts (1 errors) ====
class C {
*foo() { }
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
}
tests/baselines/reference/MemberFunctionDeclaration1_es6.js
+3 -6
View File
@@ -4,9 +4,6 @@ class C {
}
//// [MemberFunctionDeclaration1_es6.js]
var C = (function () {
function C() {
}
C.prototype.foo = function* () { };
return C;
}());
class C {
*foo() { }
}
tests/baselines/reference/MemberFunctionDeclaration1_es6.symbols
+7
View File
@@ -0,0 +1,7 @@
=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts ===
class C {
>C : Symbol(C, Decl(MemberFunctionDeclaration1_es6.ts, 0, 0))
*foo() { }
>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration1_es6.ts, 0, 9))
}
tests/baselines/reference/MemberFunctionDeclaration1_es6.types
+7
View File
@@ -0,0 +1,7 @@
=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts ===
class C {
>C : C
*foo() { }
>foo : () => IterableIterator<any>
}
tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt
-9
View File
@@ -1,9 +0,0 @@
tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts(2,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts (1 errors) ====
class C {
public * foo() { }
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
}
tests/baselines/reference/MemberFunctionDeclaration2_es6.js
+3 -6
View File
@@ -4,9 +4,6 @@ class C {
}
//// [MemberFunctionDeclaration2_es6.js]
var C = (function () {
function C() {
}
C.prototype.foo = function* () { };
return C;
}());
class C {
*foo() { }
}
tests/baselines/reference/MemberFunctionDeclaration2_es6.symbols
+7
View File
@@ -0,0 +1,7 @@
=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts ===
class C {
>C : Symbol(C, Decl(MemberFunctionDeclaration2_es6.ts, 0, 0))
public * foo() { }
>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration2_es6.ts, 0, 9))
}
tests/baselines/reference/MemberFunctionDeclaration2_es6.types
+7
View File
@@ -0,0 +1,7 @@
=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts ===
class C {
>C : C
public * foo() { }
>foo : () => IterableIterator<any>
}
tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt
+1 -4
View File
@@ -1,12 +1,9 @@
tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,6): error TS2304: Cannot find name 'foo'.
==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts (2 errors) ====
==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts (1 errors) ====
class C {
*[foo]() { }
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
~~~
!!! error TS2304: Cannot find name 'foo'.
}
tests/baselines/reference/MemberFunctionDeclaration3_es6.js
+3 -6
View File
@@ -4,9 +4,6 @@ class C {
}
//// [MemberFunctionDeclaration3_es6.js]
var C = (function () {
function C() {
}
C.prototype[foo] = function* () { };
return C;
}());
class C {
*[foo]() { }
}
tests/baselines/reference/MemberFunctionDeclaration4_es6.js
+3 -6
View File
@@ -4,9 +4,6 @@ class C {
}
//// [MemberFunctionDeclaration4_es6.js]
var C = (function () {
function C() {
}
C.prototype. = function* () { };
return C;
}());
class C {
*() { }
}
tests/baselines/reference/MemberFunctionDeclaration5_es6.js
+2 -5
View File
@@ -4,8 +4,5 @@ class C {
}
//// [MemberFunctionDeclaration5_es6.js]
var C = (function () {
function C() {
}
return C;
}());
class C {
}
tests/baselines/reference/MemberFunctionDeclaration6_es6.js
+2 -5
View File
@@ -4,8 +4,5 @@ class C {
}
//// [MemberFunctionDeclaration6_es6.js]
var C = (function () {
function C() {
}
return C;
}());
class C {
}
tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt
-9
View File
@@ -1,9 +0,0 @@
tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts (1 errors) ====
class C {
*foo<T>() { }
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
}
tests/baselines/reference/MemberFunctionDeclaration7_es6.js
+3 -6
View File
@@ -4,9 +4,6 @@ class C {
}
//// [MemberFunctionDeclaration7_es6.js]
var C = (function () {
function C() {
}
C.prototype.foo = function* () { };
return C;
}());
class C {
*foo() { }
}
tests/baselines/reference/MemberFunctionDeclaration7_es6.symbols
+8
View File
@@ -0,0 +1,8 @@
=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts ===
class C {
>C : Symbol(C, Decl(MemberFunctionDeclaration7_es6.ts, 0, 0))
*foo<T>() { }
>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration7_es6.ts, 0, 9))
>T : Symbol(T, Decl(MemberFunctionDeclaration7_es6.ts, 1, 8))
}
tests/baselines/reference/MemberFunctionDeclaration7_es6.types
+8
View File
@@ -0,0 +1,8 @@
=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts ===
class C {
>C : C
*foo<T>() { }
>foo : <T>() => IterableIterator<any>
>T : T
}
tests/baselines/reference/MemberFunctionDeclaration8_es6.errors.txt
+1 -1
View File
@@ -18,7 +18,7 @@ tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration
!!! error TS1109: Expression expected.
~~~
!!! error TS2304: Cannot find name 'bar'.
return bar;
return bar;
~~~
!!! error TS2304: Cannot find name 'bar'.
}
tests/baselines/reference/MemberFunctionDeclaration8_es6.js
+5 -8
View File
@@ -3,20 +3,17 @@ class C {
foo() {
// Make sure we don't think of *bar as the start of a generator method.
if (a) # * bar;
return bar;
return bar;
}
}
//// [MemberFunctionDeclaration8_es6.js]
var C = (function () {
function C() {
}
C.prototype.foo = function () {
class C {
foo() {
// Make sure we don't think of *bar as the start of a generator method.
if (a)
;
* bar;
return bar;
};
return C;
}());
}
}
tests/baselines/reference/YieldExpression10_es6.errors.txt
+1 -4
View File
@@ -1,11 +1,8 @@
tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(2,11): error TS2304: Cannot find name 'foo'.
==== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts (2 errors) ====
==== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts (1 errors) ====
var v = { * foo() {
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
yield(foo);
~~~
!!! error TS2304: Cannot find name 'foo'.
tests/baselines/reference/YieldExpression10_es6.js
+1 -1
View File
@@ -6,7 +6,7 @@ var v = { * foo() {
//// [YieldExpression10_es6.js]
var v = { foo: function* () {
var v = { *foo() {
yield (foo);
}
};
tests/baselines/reference/YieldExpression11_es6.errors.txt
+1 -4
View File
@@ -1,12 +1,9 @@
tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(2,3): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(3,11): error TS2663: Cannot find name 'foo'. Did you mean the instance member 'this.foo'?
==== tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts (2 errors) ====
==== tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts (1 errors) ====
class C {
*foo() {
~
!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
yield(foo);
~~~
!!! error TS2663: Cannot find name 'foo'. Did you mean the instance member 'this.foo'?
tests/baselines/reference/YieldExpression11_es6.js
+4 -7
View File
@@ -6,11 +6,8 @@ class C {
}
//// [YieldExpression11_es6.js]
var C = (function () {
function C() {
}
C.prototype.foo = function* () {
class C {
*foo() {
yield (foo);
};
return C;
}());
}
}

Some files were not shown because too many files have changed in this diff Show More