maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge branch 'transforms-transformer' into transforms-printer

Browse source
This commit is contained in:
Ron Buckton 2016-02-12 18:08:41 -08:00
commit c634a36ae4
8 changed files with 759 additions and 441 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
src/compiler/binder.ts
View file

@ -1962,16 +1962,20 @@ namespace ts {
transformFlags = TransformFlags.AssertTypeScript; transformFlags = TransformFlags.AssertTypeScript;
} }
} }
break; break;
case SyntaxKind.ExpressionStatement: case SyntaxKind.ExpressionStatement:
// if (node.flags & NodeFlags.Generated) { if (nodeIsSynthesized(node)) {
// let expression = (<ExpressionStatement>node).expression; const expression = (<ExpressionStatement>node).expression;
// if (expression.kind === SyntaxKind.CallExpression if (nodeIsSynthesized(expression)
// && (<CallExpression>expression).expression.kind === SyntaxKind.SuperKeyword) { && isCallExpression(expression)
// transformFlags |= TransformFlags.AssertES6; && expression.expression.kind === SyntaxKind.SuperKeyword) {
// } // A synthesized call to `super` should be transformed to a cleaner emit
// } // when transpiling to ES5/3.
transformFlags |= TransformFlags.AssertES6;
}
}
break; break;
@ -2082,17 +2086,16 @@ namespace ts {
case SyntaxKind.VariableDeclarationList: case SyntaxKind.VariableDeclarationList:
// If a VariableDeclarationList is `let` or `const`, then it is ES6 syntax. // If a VariableDeclarationList is `let` or `const`, then it is ES6 syntax.
if (node.flags & NodeFlags.Let if (node.flags & NodeFlags.BlockScoped) {
|| node.flags & NodeFlags.Const) {
transformFlags |= TransformFlags.AssertES6; transformFlags |= TransformFlags.AssertES6;
} }
break; break;
case SyntaxKind.VariableStatement: case SyntaxKind.VariableStatement:
// If a VariableStatement is exported, then it is ES6 syntax. // If a VariableStatement is exported, then it is either ES6 or TypeScript syntax.
if (node.flags & NodeFlags.Export) { if (node.flags & NodeFlags.Export) {
transformFlags |= TransformFlags.AssertES6; transformFlags |= TransformFlags.AssertES6 | TransformFlags.AssertTypeScript;
} }
break; break;
@ -2114,13 +2117,13 @@ namespace ts {
break; break;
case SyntaxKind.HeritageClause: case SyntaxKind.HeritageClause:
// An `extends` HertiageClause is ES6 syntax.
if ((<HeritageClause>node).token === SyntaxKind.ExtendsKeyword) { if ((<HeritageClause>node).token === SyntaxKind.ExtendsKeyword) {
// An `extends` HeritageClause is ES6 syntax.
transformFlags |= TransformFlags.AssertES6; transformFlags |= TransformFlags.AssertES6;
} }
else {
// An `implements` HeritageClause is TypeScript syntax. // An `implements` HeritageClause is TypeScript syntax.
else if ((<HeritageClause>node).token === SyntaxKind.ImplementsKeyword) { Debug.assert((<HeritageClause>node).token === SyntaxKind.ImplementsKeyword);
transformFlags |= TransformFlags.AssertTypeScript; transformFlags |= TransformFlags.AssertTypeScript;
} }

13
src/compiler/core.ts
View file

@ -169,8 +169,19 @@ namespace ts {
export function concatenate<T>(array1: T[], array2: T[]): T[] { export function concatenate<T>(array1: T[], array2: T[]): T[] {
if (!array2 || !array2.length) return array1; if (!array2 || !array2.length) return array1;
if (!array1 || !array1.length) return array2; if (!array1 || !array1.length) return array2;
return [...array1, ...array2];
}
return array1.concat(array2); export function append<T>(array: T[], value: T): T[] {
if (value === undefined) return array;
if (!array || !array.length) return [value];
return [...array, value];
}
export function prepend<T>(array: T[], value: T): T[] {
if (value === undefined) return array;
if (!array || !array.length) return [value];
return [value, ...array];
} }
export function deduplicate<T>(array: T[]): T[] { export function deduplicate<T>(array: T[]): T[] {

271
src/compiler/factory.ts
View file

@ -6,33 +6,91 @@ namespace ts {
let NodeConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node; let NodeConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;
let SourceFileConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node; let SourceFileConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;
function createNode(kind: SyntaxKind, location?: TextRange): Node { function createNode(kind: SyntaxKind, location?: TextRange, flags?: NodeFlags): Node {
const ConstructorForKind = kind === SyntaxKind.SourceFile const ConstructorForKind = kind === SyntaxKind.SourceFile
? (SourceFileConstructor || (SourceFileConstructor = objectAllocator.getSourceFileConstructor())) ? (SourceFileConstructor || (SourceFileConstructor = objectAllocator.getSourceFileConstructor()))
: (NodeConstructor || (NodeConstructor = objectAllocator.getNodeConstructor())); : (NodeConstructor || (NodeConstructor = objectAllocator.getNodeConstructor()));
return location const node = location
? new ConstructorForKind(kind, location.pos, location.end) ? new ConstructorForKind(kind, location.pos, location.end)
: new ConstructorForKind(kind, /*pos*/ -1, /*end*/ -1); : new ConstructorForKind(kind, /*pos*/ -1, /*end*/ -1);
if (flags) {
node.flags = flags;
}
return node;
} }
export function createNodeArray<T extends Node>(elements?: T[], pos?: number, end?: number): NodeArray<T> { export function createNodeArray<T extends Node>(elements?: T[], location?: TextRange): NodeArray<T> {
const array = <NodeArray<T>>(elements || []); if (elements !== undefined) {
array.pos = pos; if (isNodeArray(elements)) {
array.end = end; return elements;
}
}
else {
elements = [];
}
const array = <NodeArray<T>>elements;
if (location !== undefined) {
array.pos = location.pos;
array.end = location.end;
}
else {
array.pos = -1;
array.end = -1;
}
array.arrayKind = ArrayKind.NodeArray; array.arrayKind = ArrayKind.NodeArray;
return array; return array;
} }
export function createModifiersArray(elements?: Modifier[], pos?: number, end?: number): ModifiersArray { export function createModifiersArray(elements?: Modifier[], location?: TextRange): ModifiersArray {
const array = <ModifiersArray>(elements || []); let flags: NodeFlags;
array.pos = pos; if (elements !== undefined) {
array.end = end; if (isModifiersArray(elements)) {
return elements;
}
flags = 0;
for (const modifier of elements) {
flags |= modifierToFlag(modifier.kind);
}
}
else {
elements = [];
flags = 0;
}
const array = <ModifiersArray>elements;
if (location !== undefined) {
array.pos = location.pos;
array.end = location.end;
}
else {
array.pos = -1;
array.end = -1;
}
array.arrayKind = ArrayKind.ModifiersArray; array.arrayKind = ArrayKind.ModifiersArray;
array.flags = 0; array.flags = flags;
return array; return array;
} }
export function setModifiers<T extends Node>(node: T, modifiers: Modifier[]) {
if (modifiers !== undefined) {
const array = createModifiersArray(modifiers);
node.modifiers = array;
node.flags |= array.flags;
}
else {
node.modifiers = undefined;
}
return node;
}
export function createSynthesizedNode(kind: SyntaxKind, startsOnNewLine?: boolean): Node { export function createSynthesizedNode(kind: SyntaxKind, startsOnNewLine?: boolean): Node {
const node = <SynthesizedNode>createNode(kind, /*location*/ undefined); const node = <SynthesizedNode>createNode(kind, /*location*/ undefined);
node.startsOnNewLine = startsOnNewLine; node.startsOnNewLine = startsOnNewLine;
@ -40,11 +98,11 @@ namespace ts {
} }
export function createSynthesizedNodeArray<T extends Node>(elements?: T[]): NodeArray<T> { export function createSynthesizedNodeArray<T extends Node>(elements?: T[]): NodeArray<T> {
return createNodeArray(elements, /*pos*/ -1, /*end*/ -1); return createNodeArray(elements, /*location*/ undefined);
} }
export function createSynthesizedModifiersArray(elements?: Modifier[]): ModifiersArray { export function createSynthesizedModifiersArray(elements?: Modifier[]): ModifiersArray {
return createModifiersArray(elements, /*pos*/ -1, /*end*/ -1); return createModifiersArray(elements, /*location*/ undefined);
} }
/** /**
@ -175,14 +233,14 @@ namespace ts {
const node = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression); const node = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression);
node.expression = parenthesizeForAccess(expression); node.expression = parenthesizeForAccess(expression);
node.dotToken = createSynthesizedNode(SyntaxKind.DotToken); node.dotToken = createSynthesizedNode(SyntaxKind.DotToken);
node.name = coerceIdentifier(name); node.name = typeof name === "string" ? createIdentifier(name) : name;
return node; return node;
} }
export function createElementAccess(expression: Expression, index: string | number | Expression) { export function createElementAccess(expression: Expression, index: number | Expression) {
const node = <ElementAccessExpression>createNode(SyntaxKind.ElementAccessExpression); const node = <ElementAccessExpression>createNode(SyntaxKind.ElementAccessExpression);
node.expression = parenthesizeForAccess(expression); node.expression = parenthesizeForAccess(expression);
node.argumentExpression = coerceExpression(index); node.argumentExpression = typeof index === "number" ? createLiteral(index) : index;
return node; return node;
} }
@ -198,9 +256,9 @@ namespace ts {
export function createBinary(left: Expression, operator: SyntaxKind, right: Expression, location?: TextRange) { export function createBinary(left: Expression, operator: SyntaxKind, right: Expression, location?: TextRange) {
const node = <BinaryExpression>createNode(SyntaxKind.BinaryExpression, location); const node = <BinaryExpression>createNode(SyntaxKind.BinaryExpression, location);
node.left = parenthesizeForBinary(left, operator, BinaryOperand.Left); node.left = parenthesizeBinaryOperand(operator, left, /*isLeftSideOfBinary*/ true);
node.operatorToken = createSynthesizedNode(operator); node.operatorToken = createSynthesizedNode(operator);
node.right = parenthesizeForBinary(right, operator, BinaryOperand.Right); node.right = parenthesizeBinaryOperand(operator, right, /*isLeftSideOfBinary*/ false);
return node; return node;
} }
@ -224,7 +282,11 @@ namespace ts {
} }
export function createArraySlice(array: Expression, start?: number | Expression) { export function createArraySlice(array: Expression, start?: number | Expression) {
const argumentsList: Expression[] = start !== undefined ? [coerceExpression(start)] : []; const argumentsList: Expression[] = [];
if (start !== undefined) {
argumentsList.push(typeof start === "number" ? createLiteral(start) : start);
}
return createCall(createPropertyAccess(array, "slice"), argumentsList); return createCall(createPropertyAccess(array, "slice"), argumentsList);
} }
@ -238,94 +300,165 @@ namespace ts {
return reduceLeft(expressions, createComma); return reduceLeft(expressions, createComma);
} }
function coerceIdentifier(value: string | Identifier) { /**
if (typeof value === "string") { * Wraps the operand to a BinaryExpression in parentheses if they are needed to preserve the intended
return createIdentifier(value); * order of operations.
} *
else { * @param binaryOperator The operator for the BinaryExpression.
return value; * @param operand The operand for the BinaryExpression.
} * @param isLeftSideOfBinary A value indicating whether the operand is the left side of the
} * BinaryExpression.
*/
function coerceExpression(value: string | number | boolean | Expression): Expression { function parenthesizeBinaryOperand(binaryOperator: SyntaxKind, operand: Expression, isLeftSideOfBinary: boolean) {
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
return createLiteral(value);
}
else {
return value;
}
}
const enum BinaryOperand {
Left,
Right
}
function parenthesizeForBinary(operand: Expression, operator: SyntaxKind, side: BinaryOperand) {
// When diagnosing whether the expression needs parentheses, the decision should be based // When diagnosing whether the expression needs parentheses, the decision should be based
// on the innermost expression in a chain of nested type assertions. // on the innermost expression in a chain of nested type assertions.
while (operand.kind === SyntaxKind.TypeAssertionExpression || operand.kind === SyntaxKind.AsExpression) { operand = skipAssertions(operand);
operand = (<AssertionExpression>operand).expression;
}
// If the resulting expression is already parenthesized, we do not need to do any further processing. // If the resulting expression is already parenthesized, we do not need to do any further processing.
if (operand.kind === SyntaxKind.ParenthesizedExpression) { if (operand.kind === SyntaxKind.ParenthesizedExpression) {
return operand; return operand;
} }
return needsParenthesesForBinary(operand, operator, side) return binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary)
? parenthesizeExpression(operand) ? parenthesizeExpression(operand)
: operand; : operand;
} }
function needsParenthesesForBinary(operand: Expression, operator: SyntaxKind, side: BinaryOperand) { /**
* Determines whether the operand to a BinaryExpression needs to be parenthesized.
*
* @param binaryOperator The operator for the BinaryExpression.
* @param operand The operand for the BinaryExpression.
* @param isLeftSideOfBinary A value indicating whether the operand is the left side of the
* BinaryExpression.
*/
function binaryOperandNeedsParentheses(binaryOperator: SyntaxKind, operand: Expression, isLeftSideOfBinary: boolean) {
// If the operand has lower precedence, then it needs to be parenthesized to preserve the
// intent of the expression. For example, if the operand is `a + b` and the operator is
// `*`, then we need to parenthesize the operand to preserve the intended order of
// operations: `(a + b) * x`.
//
// If the operand has higher precedence, then it does not need to be parenthesized. For
// example, if the operand is `a * b` and the operator is `+`, then we do not need to
// parenthesize to preserve the intended order of operations: `a * b + x`.
//
// If the operand has the same precedence, then we need to check the associativity of
// the operator based on whether this is the left or right operand of the expression.
//
// For example, if `a / d` is on the right of operator `*`, we need to parenthesize
// to preserve the intended order of operations: `x * (a / d)`
//
// If `a ** d` is on the left of operator `**`, we need to parenthesize to preserve
// the intended order of operations: `(a ** b) ** c`
const binaryOperatorPrecedence = getOperatorPrecedence(SyntaxKind.BinaryExpression, binaryOperator);
const operandPrecedence = getExpressionPrecedence(operand); const operandPrecedence = getExpressionPrecedence(operand);
const operatorPrecedence = getOperatorPrecedence(SyntaxKind.BinaryExpression, operator); switch (compareValues(operandPrecedence, binaryOperatorPrecedence)) {
switch (compareValues(operandPrecedence, operatorPrecedence)) {
case Comparison.LessThan: case Comparison.LessThan:
return true; return true;
case Comparison.EqualTo:
return isRightAssociativeOperandOnLeftHandSide(operand, side)
|| isModuloOperandOnRightHandSide(operand, operator, side);
case Comparison.GreaterThan: case Comparison.GreaterThan:
return false; return false;
case Comparison.EqualTo:
if (isLeftSideOfBinary) {
// No need to parenthesize the left operand when the binary operator is
// left associative:
// (a*b)/x -> a*b/x
// (a**b)/x -> a**b/x
// Parentheses are needed for the left operand when the binary operator is
// right associative:
// (a/b)**x -> (a/b)**x
// (a**b)**x -> (a**b)**x
const binaryOperatorAssociativity = getOperatorAssociativity(SyntaxKind.BinaryExpression, binaryOperator);
return binaryOperatorAssociativity === Associativity.Right;
}
else {
// No need to parenthesize the right operand when the binary operator and
// operand are the same and one of the following:
// x*(a*b) => x*a*b
// x|(a|b) => x|a|b
// x&(a&b) => x&a&b
// x^(a^b) => x^a^b
if (isBinaryExpression(operand)
&& operand.operatorToken.kind === binaryOperator
&& isMathAssociativeOperator(binaryOperator)) {
return false;
}
// No need to parenthesize the right operand when the operand is right
// associative:
// x/(a**b) -> x/a**b
// x**(a**b) -> x**a**b
// Parentheses are needed for the right operand when the operand is left
// associative:
// x/(a*b) -> x/(a*b)
// x**(a/b) -> x**(a/b)
const operandAssociativity = getExpressionAssociativity(operand);
return operandAssociativity === Associativity.Left;
}
} }
} }
function isRightAssociativeOperandOnLeftHandSide(operand: Expression, side: BinaryOperand) { /**
return side === BinaryOperand.Left * Determines whether a binary operator is mathematically associative.
&& getExpressionAssociativity(operand) === Associativity.Right; *
} * @param binaryOperator The binary operator.
*/
function isModuloOperandOnRightHandSide(operand: Expression, operator: SyntaxKind, side: BinaryOperand) { function isMathAssociativeOperator(binaryOperator: SyntaxKind) {
return side === BinaryOperand.Right // The following operators are associative in JavaScript:
&& operator !== SyntaxKind.PercentToken // (a*b)*c -> a*(b*c) -> a*b*c
&& operand.kind === SyntaxKind.BinaryExpression // (a|b)|c -> a|(b|c) -> a|b|c
&& (<BinaryExpression>operand).operatorToken.kind === SyntaxKind.PercentToken; // (a&b)&c -> a&(b&c) -> a&b&c
// (a^b)^c -> a^(b^c) -> a^b^c
//
// While addition is associative in mathematics, JavaScript's `+` is not
// guaranteed to be associative as it is overloaded with string concatenation.
return binaryOperator === SyntaxKind.AsteriskToken
|| binaryOperator === SyntaxKind.BarToken
|| binaryOperator === SyntaxKind.AmpersandToken
|| binaryOperator === SyntaxKind.CaretToken;
} }
/**
* Wraps an expression in parentheses if it is needed in order to use the expression for
* property or element access.
*
* @param expr The expression node.
*/
function parenthesizeForAccess(expr: Expression): LeftHandSideExpression { function parenthesizeForAccess(expr: Expression): LeftHandSideExpression {
// When diagnosing whether the expression needs parentheses, the decision should be based // When diagnosing whether the expression needs parentheses, the decision should be based
// on the innermost expression in a chain of nested type assertions. // on the innermost expression in a chain of nested type assertions.
while (expr.kind === SyntaxKind.TypeAssertionExpression || expr.kind === SyntaxKind.AsExpression) { expr = skipAssertions(expr);
expr = (<AssertionExpression>expr).expression;
}
// isLeftHandSideExpression is almost the correct criterion for when it is not necessary // isLeftHandSideExpression is almost the correct criterion for when it is not necessary
// to parenthesize the expression before a dot. The known exceptions are: // to parenthesize the expression before a dot. The known exceptions are:
// //
// NewExpression: // NewExpression:
// new C.x -> not the same as (new C).x // new C.x -> not the same as (new C).x
// NumberLiteral // NumericLiteral
// 1.x -> not the same as (1).x // 1.x -> not the same as (1).x
// //
if (isLeftHandSideExpression(expr) && if (isLeftHandSideExpression(expr) &&
expr.kind !== SyntaxKind.NewExpression && expr.kind !== SyntaxKind.NewExpression &&
expr.kind !== SyntaxKind.NumericLiteral) { expr.kind !== SyntaxKind.NumericLiteral) {
return expr;
return <LeftHandSideExpression>expr;
} }
return parenthesizeExpression(expr); return parenthesizeExpression(expr);
} }
/**
* Skips past any TypeAssertionExpression or AsExpression nodes to their inner expression.
*
* @param node The expression node.
*/
function skipAssertions(node: Expression) {
while (node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression) {
node = (<AssertionExpression>node).expression;
}
return node;
}
} }

2
src/compiler/printer.ts
View file

@ -1806,7 +1806,7 @@ function __export(m) {
function emitHelpers(node: Node) { function emitHelpers(node: Node) {
const emitFlags = getNodeEmitFlags(node); const emitFlags = getNodeEmitFlags(node);
let helpersEmitted = false; let helpersEmitted = false;
if (emitFlags & NodeEmitFlags.EmitHelpers) { if (emitFlags & NodeEmitFlags.EmitEmitHelpers) {
helpersEmitted = emitEmitHelpers(currentSourceFile); helpersEmitted = emitEmitHelpers(currentSourceFile);
} }

44
src/compiler/transformer.ts
View file

@ -2,6 +2,11 @@
/* @internal */ /* @internal */
namespace ts { namespace ts {
const enum SyntaxKindFeatureFlags {
ExpressionSubstitution = 1 << 0,
EmitNotifications = 1 << 1,
}
export function getTransformers(compilerOptions: CompilerOptions) { export function getTransformers(compilerOptions: CompilerOptions) {
const transformers: Transformer[] = []; const transformers: Transformer[] = [];
// TODO(rbuckton): Add transformers // TODO(rbuckton): Add transformers
@ -22,6 +27,7 @@ namespace ts {
const nodeEmitFlags: NodeEmitFlags[] = []; const nodeEmitFlags: NodeEmitFlags[] = [];
const lexicalEnvironmentVariableDeclarationsStack: VariableDeclaration[][] = []; const lexicalEnvironmentVariableDeclarationsStack: VariableDeclaration[][] = [];
const lexicalEnvironmentFunctionDeclarationsStack: FunctionDeclaration[][] = []; const lexicalEnvironmentFunctionDeclarationsStack: FunctionDeclaration[][] = [];
const enabledSyntaxKindFeatures = new Array<SyntaxKindFeatureFlags>(SyntaxKind.Count);
let lexicalEnvironmentStackOffset = 0; let lexicalEnvironmentStackOffset = 0;
let hoistedVariableDeclarations: VariableDeclaration[]; let hoistedVariableDeclarations: VariableDeclaration[];
let hoistedFunctionDeclarations: FunctionDeclaration[]; let hoistedFunctionDeclarations: FunctionDeclaration[];
@ -41,7 +47,11 @@ namespace ts {
hoistVariableDeclaration, hoistVariableDeclaration,
hoistFunctionDeclaration, hoistFunctionDeclaration,
startLexicalEnvironment, startLexicalEnvironment,
endLexicalEnvironment endLexicalEnvironment,
enableExpressionSubstitution,
isExpressionSubstitutionEnabled,
enableEmitNotification,
isEmitNotificationEnabled,
}; };
// Chain together and initialize each transformer. // Chain together and initialize each transformer.
@ -66,6 +76,23 @@ namespace ts {
return visited; return visited;
} }
function enableExpressionSubstitution(kind: SyntaxKind) {
enabledSyntaxKindFeatures[kind] |= SyntaxKindFeatureFlags.ExpressionSubstitution;
}
function isExpressionSubstitutionEnabled(node: Node) {
return (enabledSyntaxKindFeatures[node.kind] & SyntaxKindFeatureFlags.ExpressionSubstitution) !== 0;
}
function enableEmitNotification(kind: SyntaxKind) {
enabledSyntaxKindFeatures[kind] |= SyntaxKindFeatureFlags.EmitNotifications;
}
function isEmitNotificationEnabled(node: Node) {
return (enabledSyntaxKindFeatures[node.kind] & SyntaxKindFeatureFlags.EmitNotifications) !== 0
|| (getNodeEmitFlags(node) & NodeEmitFlags.AdviseOnEmitNode) !== 0;
}
/** /**
* Gets flags that control emit behavior of a node. * Gets flags that control emit behavior of a node.
*/ */
@ -168,6 +195,8 @@ namespace ts {
return generateNameForImportOrExportDeclaration(<ImportDeclaration | ExportDeclaration>node); return generateNameForImportOrExportDeclaration(<ImportDeclaration | ExportDeclaration>node);
case SyntaxKind.FunctionDeclaration: case SyntaxKind.FunctionDeclaration:
case SyntaxKind.ClassDeclaration: case SyntaxKind.ClassDeclaration:
Debug.assert((node.flags & NodeFlags.Default) !== 0, "Can only generate a name for a default export.");
return generateNameForExportDefault();
case SyntaxKind.ExportAssignment: case SyntaxKind.ExportAssignment:
return generateNameForExportDefault(); return generateNameForExportDefault();
case SyntaxKind.ClassExpression: case SyntaxKind.ClassExpression:
@ -233,7 +262,6 @@ namespace ts {
lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset] = hoistedVariableDeclarations; lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset] = hoistedVariableDeclarations;
lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset] = hoistedFunctionDeclarations; lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset] = hoistedFunctionDeclarations;
lexicalEnvironmentStackOffset++; lexicalEnvironmentStackOffset++;
hoistedVariableDeclarations = undefined; hoistedVariableDeclarations = undefined;
hoistedFunctionDeclarations = undefined; hoistedFunctionDeclarations = undefined;
} }
@ -245,15 +273,12 @@ namespace ts {
function endLexicalEnvironment(): Statement[] { function endLexicalEnvironment(): Statement[] {
let statements: Statement[]; let statements: Statement[];
if (hoistedVariableDeclarations || hoistedFunctionDeclarations) { if (hoistedVariableDeclarations || hoistedFunctionDeclarations) {
statements = [];
if (hoistedFunctionDeclarations) { if (hoistedFunctionDeclarations) {
for (const declaration of hoistedFunctionDeclarations) { statements = [...hoistedFunctionDeclarations];
statements.push(declaration);
}
} }
if (hoistedVariableDeclarations) { if (hoistedVariableDeclarations) {
statements.push( statements = append(statements,
createVariableStatement( createVariableStatement(
createVariableDeclarationList(hoistedVariableDeclarations) createVariableDeclarationList(hoistedVariableDeclarations)
) )
@ -331,8 +356,9 @@ namespace ts {
* Makes an array from an ArrayLike. * Makes an array from an ArrayLike.
*/ */
function arrayOf<T>(arrayLike: ArrayLike<T>) { function arrayOf<T>(arrayLike: ArrayLike<T>) {
const array: T[] = []; const length = arrayLike.length;
for (let i = 0; i < arrayLike.length; i++) { const array: T[] = new Array<T>(length);
for (let i = 0; i < length; i++) {
array[i] = arrayLike[i]; array[i] = arrayLike[i];
} }
return array; return array;

61
src/compiler/types.ts
View file

@ -2790,12 +2790,15 @@ namespace ts {
/* @internal */ /* @internal */
export const enum NodeEmitFlags { export const enum NodeEmitFlags {
EmitHelpers = 1 << 0, // Any emit helpers should be written to this node. EmitEmitHelpers = 1 << 0, // Any emit helpers should be written to this node.
EmitExportStar = 1 << 1, // The export * helper should be written to this node. EmitExportStar = 1 << 1, // The export * helper should be written to this node.
UMDDefine = 1 << 2, // This node should be replaced with the UMD define helper. EmitSuperHelper = 1 << 2, // Emit the basic _super helper for async methods.
NoLexicalEnvironment = 1 << 3, // A new LexicalEnvironment should *not* be introduced when emitting this node. EmitAdvancedSuperHelper = 1 << 3, // Emit the advanced _super helper for async methods.
SingleLine = 1 << 4, // The contents of this node should be emit on a single line. UMDDefine = 1 << 4, // This node should be replaced with the UMD define helper.
MultiLine = 1 << 5, // The contents of this node should be emit on multiple lines. NoLexicalEnvironment = 1 << 5, // A new LexicalEnvironment should *not* be introduced when emitting this node.
SingleLine = 1 << 6, // The contents of this node should be emit on a single line.
MultiLine = 1 << 7, // The contents of this node should be emit on multiple lines.
AdviseOnEmitNode = 1 << 8, // The node printer should invoke the onBeforeEmitNode and onAfterEmitNode callbacks when printing this node.
} }
/** Additional context provided to `visitEachChild` */ /** Additional context provided to `visitEachChild` */
@ -2819,8 +2822,54 @@ namespace ts {
getGeneratedNameForNode(node: Node): Identifier; getGeneratedNameForNode(node: Node): Identifier;
nodeHasGeneratedName(node: Node): boolean; nodeHasGeneratedName(node: Node): boolean;
makeUniqueName(baseName: string): Identifier; makeUniqueName(baseName: string): Identifier;
/**
* Hook used by transformers to substitute non-expression identifiers
* just before theyare emitted by the pretty printer.
*/
identifierSubstitution?: (node: Identifier) => Identifier; identifierSubstitution?: (node: Identifier) => Identifier;
/**
* Enables expression substitutions in the pretty printer for
* the provided SyntaxKind.
*/
enableExpressionSubstitution(kind: SyntaxKind): void;
/**
* Determines whether expression substitutions are enabled for the
* provided node.
*/
isExpressionSubstitutionEnabled(node: Node): boolean;
/**
* Hook used by transformers to substitute expressions just before they
* are emitted by the pretty printer.
*/
expressionSubstitution?: (node: Expression) => Expression; expressionSubstitution?: (node: Expression) => Expression;
/**
* Enables before/after emit notifications in the pretty printer for
* the provided SyntaxKind.
*/
enableEmitNotification(kind: SyntaxKind): void;
/**
* Determines whether before/after emit notifications should be raised
* in the pretty printer when it emits a node.
*/
isEmitNotificationEnabled(node: Node): boolean;
/**
* Hook used to notify transformers immediately before the pretty printer
* emits a node.
*/
onBeforeEmitNode?: (node: Node) => void;
/**
* Hook used to notify transformers immediately after the pretty printer
* emits a node.
*/
onAfterEmitNode?: (node: Node) => void;
} }
/* @internal */ /* @internal */

514
src/compiler/utilities.ts
View file

@ -1354,17 +1354,7 @@ namespace ts {
return false; return false;
} }
export function isLiteralKind(kind: SyntaxKind): boolean {
return SyntaxKind.FirstLiteralToken <= kind && kind <= SyntaxKind.LastLiteralToken;
}
export function isTextualLiteralKind(kind: SyntaxKind): boolean {
return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
}
export function isTemplateLiteralKind(kind: SyntaxKind): boolean {
return SyntaxKind.FirstTemplateToken <= kind && kind <= SyntaxKind.LastTemplateToken;
}
export function isNodeDescendentOf(node: Node, ancestor: Node): boolean { export function isNodeDescendentOf(node: Node, ancestor: Node): boolean {
while (node) { while (node) {
@ -1633,8 +1623,17 @@ namespace ts {
return node; return node;
} }
export function nodeStartsNewLexicalEnvironment(n: Node): boolean { export function nodeStartsNewLexicalEnvironment(node: Node): boolean {
return isFunctionLike(n) || n.kind === SyntaxKind.ModuleDeclaration || n.kind === SyntaxKind.SourceFile; const kind = node.kind;
return kind === SyntaxKind.Constructor
|| kind === SyntaxKind.FunctionExpression
|| kind === SyntaxKind.FunctionDeclaration
|| kind === SyntaxKind.ArrowFunction
|| kind === SyntaxKind.MethodDeclaration
|| kind === SyntaxKind.GetAccessor
|| kind === SyntaxKind.SetAccessor
|| kind === SyntaxKind.ModuleDeclaration
|| kind === SyntaxKind.SourceFile;
} }
/** /**
@ -2729,23 +2728,111 @@ namespace ts {
// All node tests in the following list should *not* reference parent pointers so that // All node tests in the following list should *not* reference parent pointers so that
// they may be used with transformations. // they may be used with transformations.
export function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression { // Node Arrays
return node.kind === SyntaxKind.PropertyAccessExpression;
export function isNodeArray<T extends Node>(array: T[]): array is NodeArray<T> {
return (<NodeArray<T>>array).arrayKind === ArrayKind.NodeArray;
} }
export function isElementAccessExpression(node: Node): node is ElementAccessExpression { export function isModifiersArray(array: Modifier[]): array is ModifiersArray {
return node.kind === SyntaxKind.ElementAccessExpression; return (<ModifiersArray>array).arrayKind === ArrayKind.ModifiersArray;
} }
function isBindingPatternKind(kind: SyntaxKind) { // Literals
return kind === SyntaxKind.ArrayBindingPattern
|| kind === SyntaxKind.ObjectBindingPattern; export function isLiteralKind(kind: SyntaxKind): boolean {
return SyntaxKind.FirstLiteralToken <= kind && kind <= SyntaxKind.LastLiteralToken;
} }
export function isBindingPattern(node: Node): node is BindingPattern { export function isTextualLiteralKind(kind: SyntaxKind): boolean {
return node && isBindingPatternKind(node.kind); return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
} }
export function isLiteralExpression(node: Node): node is LiteralExpression {
return isLiteralKind(node.kind);
}
// Pseudo-literals
export function isTemplateLiteralKind(kind: SyntaxKind): boolean {
return SyntaxKind.FirstTemplateToken <= kind && kind <= SyntaxKind.LastTemplateToken;
}
function isTemplateLiteralFragmentKind(kind: SyntaxKind) {
return kind === SyntaxKind.TemplateHead
|| kind === SyntaxKind.TemplateMiddle
|| kind === SyntaxKind.TemplateTail;
}
export function isTemplateLiteralFragment(node: Node): node is TemplateLiteralFragment {
return isTemplateLiteralFragmentKind(node.kind);
}
// Identifiers
export function isIdentifier(node: Node): node is Identifier {
return node.kind === SyntaxKind.Identifier;
}
// Keywords
export function isModifier(node: Node): node is Modifier {
return isModifierKind(node.kind);
}
// Names
export function isQualifiedName(node: Node): node is QualifiedName {
return node.kind === SyntaxKind.QualifiedName;
}
export function isComputedPropertyName(node: Node): node is ComputedPropertyName {
return node.kind === SyntaxKind.ComputedPropertyName;
}
export function isEntityName(node: Node): node is EntityName {
const kind = node.kind;
return kind === SyntaxKind.QualifiedName
|| kind === SyntaxKind.Identifier;
}
export function isPropertyName(node: Node): node is PropertyName {
const kind = node.kind;
return kind === SyntaxKind.Identifier
|| kind === SyntaxKind.StringLiteral
|| kind === SyntaxKind.NumericLiteral
|| kind === SyntaxKind.ComputedPropertyName;
}
export function isModuleName(node: Node): node is ModuleName {
const kind = node.kind;
return kind === SyntaxKind.Identifier
|| kind === SyntaxKind.StringLiteral;
}
export function isBindingName(node: Node): node is BindingName {
const kind = node.kind;
return kind === SyntaxKind.Identifier
|| kind === SyntaxKind.ObjectBindingPattern
|| kind === SyntaxKind.ArrayBindingPattern;
}
// Signature elements
export function isTypeParameter(node: Node): node is TypeParameterDeclaration {
return node.kind === SyntaxKind.TypeParameter;
}
export function isParameter(node: Node): node is ParameterDeclaration {
return node.kind === SyntaxKind.Parameter;
}
export function isDecorator(node: Node): node is Decorator {
return node.kind === SyntaxKind.Decorator;
}
// Type members
export function isClassElement(node: Node): node is ClassElement { export function isClassElement(node: Node): node is ClassElement {
const kind = node.kind; const kind = node.kind;
return kind === SyntaxKind.Constructor return kind === SyntaxKind.Constructor
@ -2757,37 +2844,80 @@ namespace ts {
|| kind === SyntaxKind.IndexSignature; || kind === SyntaxKind.IndexSignature;
} }
export function isQualifiedName(node: Node): node is QualifiedName { export function isObjectLiteralElement(node: Node): node is ObjectLiteralElement {
return node.kind === SyntaxKind.QualifiedName; const kind = node.kind;
return kind === SyntaxKind.PropertyAssignment
|| kind === SyntaxKind.ShorthandPropertyAssignment
|| kind === SyntaxKind.MethodDeclaration
|| kind === SyntaxKind.GetAccessor
|| kind === SyntaxKind.SetAccessor
|| kind === SyntaxKind.MissingDeclaration;
} }
export function isLiteralExpression(node: Node): node is LiteralExpression { // Type
return isLiteralKind(node.kind);
function isTypeNodeKind(kind: SyntaxKind) {
return (kind >= SyntaxKind.FirstTypeNode && kind <= SyntaxKind.LastTypeNode)
|| kind === SyntaxKind.AnyKeyword
|| kind === SyntaxKind.NumberKeyword
|| kind === SyntaxKind.BooleanKeyword
|| kind === SyntaxKind.StringKeyword
|| kind === SyntaxKind.SymbolKeyword
|| kind === SyntaxKind.VoidKeyword
|| kind === SyntaxKind.ExpressionWithTypeArguments;
} }
function isEntityNameKind(kind: SyntaxKind) { /**
return kind === SyntaxKind.QualifiedName * Node test that determines whether a node is a valid type node.
|| kind === SyntaxKind.Identifier; * This differs from the `isPartOfTypeNode` function which determines whether a node is *part*
* of a TypeNode.
*/
export function isTypeNode(node: Node): node is TypeNode {
return isTypeNodeKind(node.kind);
} }
export function isEntityName(node: Node): node is EntityName { // Binding patterns
return isEntityNameKind(node.kind);
export function isBindingPattern(node: Node): node is BindingPattern {
if (node) {
const kind = node.kind;
return kind === SyntaxKind.ArrayBindingPattern
|| kind === SyntaxKind.ObjectBindingPattern;
}
return false;
} }
export function isIdentifier(node: Node): node is Identifier { export function isBindingElement(node: Node): node is BindingElement {
return node.kind === SyntaxKind.Identifier; return node.kind === SyntaxKind.BindingElement;
} }
export function isComputedPropertyName(node: Node): node is ComputedPropertyName { // Expression
return node.kind === SyntaxKind.ComputedPropertyName;
export function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression {
return node.kind === SyntaxKind.PropertyAccessExpression;
}
export function isElementAccessExpression(node: Node): node is ElementAccessExpression {
return node.kind === SyntaxKind.ElementAccessExpression;
} }
export function isBinaryExpression(node: Node): node is BinaryExpression { export function isBinaryExpression(node: Node): node is BinaryExpression {
return node.kind === SyntaxKind.BinaryExpression; return node.kind === SyntaxKind.BinaryExpression;
} }
export function isShortHandPropertyAssignment(node: Node): node is ShorthandPropertyAssignment { export function isCallExpression(node: Node): node is CallExpression {
return node.kind === SyntaxKind.ShorthandPropertyAssignment; return node.kind === SyntaxKind.CallExpression;
}
export function isTemplate(node: Node): node is Template {
const kind = node.kind;
return kind === SyntaxKind.TemplateExpression
|| kind === SyntaxKind.NoSubstitutionTemplateLiteral;
}
export function isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments {
return node.kind === SyntaxKind.ExpressionWithTypeArguments;
} }
function isLeftHandSideExpressionKind(kind: SyntaxKind) { function isLeftHandSideExpressionKind(kind: SyntaxKind) {
@ -2814,7 +2944,7 @@ namespace ts {
|| kind === SyntaxKind.ThisKeyword || kind === SyntaxKind.ThisKeyword
|| kind === SyntaxKind.TrueKeyword || kind === SyntaxKind.TrueKeyword
|| kind === SyntaxKind.SuperKeyword; || kind === SyntaxKind.SuperKeyword;
} }
export function isLeftHandSideExpression(node: Node): node is LeftHandSideExpression { export function isLeftHandSideExpression(node: Node): node is LeftHandSideExpression {
return isLeftHandSideExpressionKind(node.kind); return isLeftHandSideExpressionKind(node.kind);
@ -2850,32 +2980,70 @@ namespace ts {
return isExpressionKind(node.kind); return isExpressionKind(node.kind);
} }
export function isDecorator(node: Node): node is Decorator { // Misc
return node.kind === SyntaxKind.Decorator;
export function isTemplateSpan(node: Node): node is TemplateSpan {
return node.kind === SyntaxKind.TemplateSpan;
} }
export function isModifier(node: Node): node is Modifier { // Element
return isModifierKind(node.kind);
export function isBlock(node: Node): node is Block {
return node.kind === SyntaxKind.Block;
} }
function isTypeNodeKind(kind: SyntaxKind) { export function isConciseBody(node: Node): node is ConciseBody {
return (kind >= SyntaxKind.FirstTypeNode && kind <= SyntaxKind.LastTypeNode) return isBlock(node)
|| kind === SyntaxKind.AnyKeyword || isExpression(node);
|| kind === SyntaxKind.NumberKeyword
|| kind === SyntaxKind.BooleanKeyword
|| kind === SyntaxKind.StringKeyword
|| kind === SyntaxKind.SymbolKeyword
|| kind === SyntaxKind.VoidKeyword
|| kind === SyntaxKind.ExpressionWithTypeArguments;
} }
/** export function isFunctionBody(node: Node): node is FunctionBody {
* Node test that determines whether a node is a valid type node. return isBlock(node);
* This differs from the `isPartOfTypeNode` function which determines whether a node is *part* }
* of a TypeNode.
*/ export function isForInitializer(node: Node): node is ForInitializer {
export function isTypeNode(node: Node): node is TypeNode { return isVariableDeclarationList(node)
return isTypeNodeKind(node.kind); || isExpression(node);
}
export function isVariableDeclaration(node: Node): node is VariableDeclaration {
return node.kind === SyntaxKind.VariableDeclaration;
}
export function isVariableDeclarationList(node: Node): node is VariableDeclarationList {
return node.kind === SyntaxKind.VariableDeclarationList;
}
export function isCaseBlock(node: Node): node is CaseBlock {
return node.kind === SyntaxKind.CaseBlock;
}
export function isModuleBody(node: Node): node is ModuleBody {
const kind = node.kind;
return kind === SyntaxKind.ModuleBlock
|| kind === SyntaxKind.ModuleDeclaration;
}
export function isImportClause(node: Node): node is ImportClause {
return node.kind === SyntaxKind.ImportClause;
}
export function isNamedImportBindings(node: Node): node is NamedImportBindings {
const kind = node.kind;
return kind === SyntaxKind.NamedImports
|| kind === SyntaxKind.NamespaceImport;
}
export function isImportSpecifier(node: Node): node is ImportSpecifier {
return node.kind === SyntaxKind.ImportSpecifier;
}
export function isNamedExports(node: Node): node is NamedExports {
return node.kind === SyntaxKind.NamedExports;
}
export function isExportSpecifier(node: Node): node is ExportSpecifier {
return node.kind === SyntaxKind.ExportSpecifier;
} }
function isDeclarationKind(kind: SyntaxKind) { function isDeclarationKind(kind: SyntaxKind) {
@ -2909,10 +3077,6 @@ namespace ts {
|| kind === SyntaxKind.VariableDeclaration; || kind === SyntaxKind.VariableDeclaration;
} }
export function isDeclaration(node: Node): node is Declaration {
return isDeclarationKind(node.kind);
}
function isDeclarationStatementKind(kind: SyntaxKind) { function isDeclarationStatementKind(kind: SyntaxKind) {
return kind === SyntaxKind.FunctionDeclaration return kind === SyntaxKind.FunctionDeclaration
|| kind === SyntaxKind.MissingDeclaration || kind === SyntaxKind.MissingDeclaration
@ -2926,10 +3090,6 @@ namespace ts {
|| kind === SyntaxKind.ExportAssignment; || kind === SyntaxKind.ExportAssignment;
} }
export function isDeclarationStatement(node: Node): node is DeclarationStatement {
return isDeclarationStatementKind(node.kind);
}
function isStatementKindButNotDeclarationKind(kind: SyntaxKind) { function isStatementKindButNotDeclarationKind(kind: SyntaxKind) {
return kind === SyntaxKind.BreakStatement return kind === SyntaxKind.BreakStatement
|| kind === SyntaxKind.ContinueStatement || kind === SyntaxKind.ContinueStatement
@ -2951,6 +3111,14 @@ namespace ts {
|| kind === SyntaxKind.WithStatement; || kind === SyntaxKind.WithStatement;
} }
export function isDeclaration(node: Node): node is Declaration {
return isDeclarationKind(node.kind);
}
export function isDeclarationStatement(node: Node): node is DeclarationStatement {
return isDeclarationStatementKind(node.kind);
}
/** /**
* Determines whether the node is a statement that is not also a declaration * Determines whether the node is a statement that is not also a declaration
*/ */
@ -2958,171 +3126,22 @@ namespace ts {
return isStatementKindButNotDeclarationKind(node.kind); return isStatementKindButNotDeclarationKind(node.kind);
} }
function isStatementKind(kind: SyntaxKind) { export function isStatement(node: Node): node is Statement {
const kind = node.kind;
return isStatementKindButNotDeclarationKind(kind) return isStatementKindButNotDeclarationKind(kind)
|| isDeclarationStatementKind(kind); || isDeclarationStatementKind(kind);
} }
export function isStatement(node: Node): node is Statement { // Module references
return isStatementKind(node.kind);
}
function isPropertyNameKind(kind: SyntaxKind) {
return kind === SyntaxKind.Identifier
|| kind === SyntaxKind.StringLiteral
|| kind === SyntaxKind.NumericLiteral
|| kind === SyntaxKind.ComputedPropertyName;
}
export function isPropertyName(node: Node): node is PropertyName {
return isPropertyNameKind(node.kind);
}
function isConciseBodyKind(kind: SyntaxKind) {
return kind === SyntaxKind.Block
|| isExpressionKind(kind);
}
export function isConciseBody(node: Node): node is ConciseBody {
return isConciseBodyKind(node.kind);
}
export function isTypeParameter(node: Node): node is TypeParameterDeclaration {
return node.kind === SyntaxKind.TypeParameter;
}
export function isParameter(node: Node): node is ParameterDeclaration {
return node.kind === SyntaxKind.Parameter;
}
export function isBindingElement(node: Node): node is BindingElement {
return node.kind === SyntaxKind.BindingElement;
}
function isObjectLiteralElementKind(kind: SyntaxKind) {
return kind === SyntaxKind.PropertyAssignment
|| kind === SyntaxKind.ShorthandPropertyAssignment
|| kind === SyntaxKind.MethodDeclaration
|| kind === SyntaxKind.GetAccessor
|| kind === SyntaxKind.SetAccessor
|| kind === SyntaxKind.MissingDeclaration;
}
export function isObjectLiteralElement(node: Node): node is ObjectLiteralElement {
return isObjectLiteralElementKind(node.kind);
}
function isTemplateKind(kind: SyntaxKind) {
return kind === SyntaxKind.TemplateExpression
|| kind === SyntaxKind.NoSubstitutionTemplateLiteral;
}
export function isTemplate(node: Node): node is Template {
return isTemplateKind(node.kind);
}
function isTemplateLiteralFragmentKind(kind: SyntaxKind) {
return kind === SyntaxKind.TemplateHead
|| kind === SyntaxKind.TemplateMiddle
|| kind === SyntaxKind.TemplateTail;
}
export function isTemplateLiteralFragment(node: Node): node is TemplateLiteralFragment {
return isTemplateLiteralFragmentKind(node.kind);
}
export function isTemplateSpan(node: Node): node is TemplateSpan {
return node.kind === SyntaxKind.TemplateSpan;
}
export function isHeritageClause(node: Node): node is HeritageClause {
return node.kind === SyntaxKind.HeritageClause;
}
export function isVariableDeclarationList(node: Node): node is VariableDeclarationList {
return node.kind === SyntaxKind.VariableDeclarationList;
}
function isForInitializerKind(kind: SyntaxKind) {
return kind === SyntaxKind.VariableDeclarationList
|| isExpressionKind(kind);
}
export function isForInitializer(node: Node): node is ForInitializer {
return isForInitializerKind(node.kind);
}
export function isCaseBlock(node: Node): node is CaseBlock {
return node.kind === SyntaxKind.CaseBlock;
}
export function isBlock(node: Node): node is Block {
return node.kind === SyntaxKind.Block;
}
export function isCatchClause(node: Node): node is CatchClause {
return node.kind === SyntaxKind.CatchClause;
}
export function isVariableDeclaration(node: Node): node is VariableDeclaration {
return node.kind === SyntaxKind.VariableDeclaration;
}
export function isEnumMember(node: Node): node is EnumMember {
return node.kind === SyntaxKind.EnumMember;
}
function isModuleNameKind(kind: SyntaxKind) {
return kind === SyntaxKind.Identifier
|| kind === SyntaxKind.StringLiteral;
}
export function isModuleName(node: Node): node is ModuleName {
return isModuleNameKind(node.kind);
}
function isCaseOrDefaultClauseKind(kind: SyntaxKind) {
return kind === SyntaxKind.CaseClause
|| kind === SyntaxKind.DefaultClause;
}
export function isCaseOrDefaultClause(node: Node): node is CaseOrDefaultClause {
return isCaseOrDefaultClauseKind(node.kind);
}
function isModuleReferenceKind(kind: SyntaxKind) {
return kind === SyntaxKind.ExternalModuleReference
|| isEntityNameKind(kind);
}
export function isModuleReference(node: Node): node is ModuleReference { export function isModuleReference(node: Node): node is ModuleReference {
return isModuleReferenceKind(node.kind); const kind = node.kind;
return kind === SyntaxKind.ExternalModuleReference
|| kind === SyntaxKind.QualifiedName
|| kind === SyntaxKind.Identifier;
} }
export function isImportClause(node: Node): node is ImportClause { // JSX
return node.kind === SyntaxKind.ImportClause;
}
function isNamedImportBindingsKind(kind: SyntaxKind) {
return kind === SyntaxKind.NamedImports
|| kind === SyntaxKind.NamespaceImport;
}
export function isNamedImportBindings(node: Node): node is NamedImportBindings {
return isNamedImportBindingsKind(node.kind);
}
export function isImportSpecifier(node: Node): node is ImportSpecifier {
return node.kind === SyntaxKind.ImportSpecifier;
}
export function isNamedExports(node: Node): node is NamedExports {
return node.kind === SyntaxKind.NamedExports;
}
export function isExportSpecifier(node: Node): node is ExportSpecifier {
return node.kind === SyntaxKind.ExportSpecifier;
}
export function isJsxOpeningElement(node: Node): node is JsxOpeningElement { export function isJsxOpeningElement(node: Node): node is JsxOpeningElement {
return node.kind === SyntaxKind.JsxOpeningElement; return node.kind === SyntaxKind.JsxOpeningElement;
@ -3132,55 +3151,56 @@ namespace ts {
return node.kind === SyntaxKind.JsxClosingElement; return node.kind === SyntaxKind.JsxClosingElement;
} }
function isJsxChildKind(kind: SyntaxKind) { export function isJsxChild(node: Node): node is JsxChild {
const kind = node.kind;
return kind === SyntaxKind.JsxElement return kind === SyntaxKind.JsxElement
|| kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxExpression
|| kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxSelfClosingElement
|| kind === SyntaxKind.JsxText; || kind === SyntaxKind.JsxText;
} }
export function isJsxChild(node: Node): node is JsxChild { export function isJsxAttributeLike(node: Node): node is JsxAttributeLike {
return isJsxChildKind(node.kind); const kind = node.kind;
}
function isJsxAttributeLikeKind(kind: SyntaxKind) {
return kind === SyntaxKind.JsxAttribute return kind === SyntaxKind.JsxAttribute
|| kind === SyntaxKind.JsxSpreadAttribute; || kind === SyntaxKind.JsxSpreadAttribute;
} }
export function isJsxAttributeLike(node: Node): node is JsxAttributeLike { // Clauses
return isJsxAttributeLikeKind(node.kind);
export function isCaseOrDefaultClause(node: Node): node is CaseOrDefaultClause {
const kind = node.kind;
return kind === SyntaxKind.CaseClause
|| kind === SyntaxKind.DefaultClause;
} }
export function isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments { export function isHeritageClause(node: Node): node is HeritageClause {
return node.kind === SyntaxKind.ExpressionWithTypeArguments; return node.kind === SyntaxKind.HeritageClause;
} }
function isModuleBodyKind(kind: SyntaxKind) { export function isCatchClause(node: Node): node is CatchClause {
return kind === SyntaxKind.ModuleBlock return node.kind === SyntaxKind.CatchClause;
|| kind === SyntaxKind.ModuleDeclaration;
} }
export function isModuleBody(node: Node): node is ModuleBody {
return isModuleBodyKind(node.kind); // Property assignments
export function isShortHandPropertyAssignment(node: Node): node is ShorthandPropertyAssignment {
const kind = node.kind;
return kind === SyntaxKind.ShorthandPropertyAssignment;
} }
function isBindingNameKind(kind: SyntaxKind) { // Enum
return kind === SyntaxKind.Identifier
|| isBindingPatternKind(kind); export function isEnumMember(node: Node): node is EnumMember {
return node.kind === SyntaxKind.EnumMember;
} }
export function isBindingName(node: Node): node is BindingName {
return isBindingNameKind(node.kind); // Synthesized
}
export function isNodeArrayNode<T extends Node>(node: Node): node is NodeArrayNode<T> { export function isNodeArrayNode<T extends Node>(node: Node): node is NodeArrayNode<T> {
return node.kind === SyntaxKind.NodeArrayNode; return node.kind === SyntaxKind.NodeArrayNode;
} }
export function isModifiersArray(array: NodeArray<Node>): array is ModifiersArray {
return array.arrayKind === ArrayKind.ModifiersArray;
}
} }
namespace ts { namespace ts {

262
src/compiler/visitor.ts
View file

@ -2,6 +2,7 @@
/* @internal */ /* @internal */
namespace ts { namespace ts {
export type OneOrMore<T extends Node> = T | NodeArrayNode<T>;
/** /**
* Describes an edge of a Node, used when traversing a syntax tree. * Describes an edge of a Node, used when traversing a syntax tree.
*/ */
@ -469,10 +470,10 @@ namespace ts {
* @param node The Node to visit. * @param node The Node to visit.
* @param visitor The callback used to visit the Node. * @param visitor The callback used to visit the Node.
* @param test A callback to execute to verify the Node is valid. * @param test A callback to execute to verify the Node is valid.
* @param lift A callback to execute to lift a NodeArrayNode into a valid Node. * @param optional An optional value indicating whether the Node is itself optional.
* @param optional A value indicating whether the Node is optional. * @param lift An optional callback to execute to lift a NodeArrayNode into a valid Node.
*/ */
export function visitNode<T extends Node>(node: T, visitor: (node: Node) => Node, test?: (node: Node) => boolean, lift?: (node: NodeArray<Node>) => T, optional?: boolean): T { export function visitNode<T extends Node>(node: T, visitor: (node: Node) => Node, test: (node: Node) => boolean, optional?: boolean, lift?: (node: NodeArray<Node>) => T): T {
if (node === undefined) { if (node === undefined) {
return undefined; return undefined;
} }
@ -499,55 +500,56 @@ namespace ts {
* @param nodes The NodeArray to visit. * @param nodes The NodeArray to visit.
* @param visitor The callback used to visit a Node. * @param visitor The callback used to visit a Node.
* @param test A node test to execute for each node. * @param test A node test to execute for each node.
* @param start An optional value indicating the starting offset at which to start visiting.
* @param count An optional value indicating the maximum number of nodes to visit.
*/ */
export function visitNodes<T extends Node, TArray extends NodeArray<T>>(nodes: TArray, visitor: (node: Node) => Node, test?: (node: Node) => boolean): TArray { export function visitNodes<T extends Node, TArray extends NodeArray<T>>(nodes: TArray, visitor: (node: Node) => Node, test: (node: Node) => boolean, start?: number, count?: number): TArray {
if (nodes === undefined) { if (nodes === undefined) {
return undefined; return undefined;
} }
let updated: NodeArray<T> | ModifiersArray; let updated: T[];
for (let i = 0, len = nodes.length; i < len; i++) {
const node = nodes[i];
if (node === undefined) {
continue;
}
const visited = visitor(node); // Ensure start and count have valid values
const length = nodes.length;
if (start === undefined || start < 0) {
start = 0;
}
if (count === undefined || count > length - start) {
count = length - start;
}
// If we are not visiting all of the original nodes, we must always create a new array.
if (start > 0 || count < length) {
updated = [];
}
// Visit each original node.
for (let i = 0; i < count; i++) {
const node = nodes[i + start];
const visited = node && <OneOrMore<T>>visitor(node);
if (updated !== undefined || visited === undefined || visited !== node) { if (updated !== undefined || visited === undefined || visited !== node) {
if (updated === undefined) { if (updated === undefined) {
updated = isModifiersArray(nodes) // Ensure we have a copy of `nodes`, up to the current index.
? createModifiersArray(nodes.slice(0, i), nodes.pos, nodes.end) updated = nodes.slice(0, i);
: createNodeArray<T>(nodes.slice(0, i), nodes.pos, nodes.end);
} }
if (visited === undefined) { if (visited !== node) {
continue; aggregateTransformFlags(visited);
} }
if (isNodeArrayNode<T>(visited)) { addNode(updated, visited, test);
spreadNodeArrayNode(visited, updated, test);
}
else if (visited !== undefined) {
Debug.assert(test === undefined || test(visited), "Wrong node type after visit.");
if (visited !== node) {
aggregateTransformFlags(visited);
}
updated.push(<T>visited);
}
} }
} }
if (updated && isModifiersArray(updated)) { if (updated !== undefined) {
let flags: NodeFlags = 0; return <TArray>(isModifiersArray(nodes)
for (const node of updated) { ? createModifiersArray(updated, nodes)
flags |= modifierToFlag(node.kind); : createNodeArray(updated, nodes));
}
updated.flags = flags;
} }
return <TArray>updated || nodes; return nodes;
} }
/** /**
@ -555,36 +557,40 @@ namespace ts {
* *
* @param node The Node whose children will be visited. * @param node The Node whose children will be visited.
* @param visitor The callback used to visit each child. * @param visitor The callback used to visit each child.
* @param environment An optional lexical environment context for the visitor. * @param context A lexical environment context for the visitor.
*/ */
export function visitEachChild<T extends Node>(node: T, visitor: (node: Node) => Node, environment?: LexicalEnvironment): T { export function visitEachChild<T extends Node>(node: T, visitor: (node: Node) => Node, context: LexicalEnvironment): T;
export function visitEachChild<T extends Node>(node: T & Map<any>, visitor: (node: Node) => Node, context: LexicalEnvironment): T {
if (node === undefined) { if (node === undefined) {
return undefined; return undefined;
} }
const isNewLexicalEnvironment = environment !== undefined && nodeStartsNewLexicalEnvironment(node); let updated: T & Map<any>;
// If this node starts a new lexical environment, start a new lexical environment on the context.
const isNewLexicalEnvironment = nodeStartsNewLexicalEnvironment(node);
if (isNewLexicalEnvironment) { if (isNewLexicalEnvironment) {
environment.startLexicalEnvironment(); context.startLexicalEnvironment();
} }
let modifiers: NodeFlags;
let updated: T & Map<any>;
const edgeTraversalPath = nodeEdgeTraversalMap[node.kind]; const edgeTraversalPath = nodeEdgeTraversalMap[node.kind];
if (edgeTraversalPath) { if (edgeTraversalPath) {
for (const edge of edgeTraversalPath) { for (const edge of edgeTraversalPath) {
const value = (<Map<any>>node)[edge.name]; const value = <Node | NodeArray<Node>>node[edge.name];
if (value !== undefined) { if (value !== undefined) {
const visited = visitEdge(edge, value, visitor); const visited = visitEdge(edge, value, visitor);
if (updated !== undefined || visited !== value) { if (updated !== undefined || visited !== value) {
if (updated === undefined) { if (updated === undefined) {
updated = cloneNode(node, /*location*/ undefined, node.flags & ~NodeFlags.Modifier, /*parent*/ undefined, /*original*/ node); updated = cloneNode(node, /*location*/ node, node.flags & ~NodeFlags.Modifier, /*parent*/ undefined, /*original*/ node);
} }
updated[edge.name] = visited; if (visited && isArray(visited) && isModifiersArray(visited)) {
} updated[edge.name] = visited;
updated.flags |= visited.flags;
if (visited && isArray(visited) && isModifiersArray(visited)) { }
modifiers = visited.flags; else {
updated[edge.name] = visited;
}
} }
} }
} }
@ -593,14 +599,11 @@ namespace ts {
if (updated === undefined) { if (updated === undefined) {
updated = node; updated = node;
} }
else if (modifiers) {
updated.flags |= modifiers;
}
if (isNewLexicalEnvironment) { if (isNewLexicalEnvironment) {
const declarations = environment.endLexicalEnvironment(); const declarations = context.endLexicalEnvironment();
if (declarations !== undefined && declarations.length > 0) { if (declarations !== undefined && declarations.length > 0) {
updated = <T>mergeLexicalEnvironment(updated, declarations, /*nodeIsMutable*/ updated !== node); updated = <T>mergeLexicalEnvironment(updated, declarations);
} }
} }
@ -620,104 +623,177 @@ namespace ts {
*/ */
function visitEdge(edge: NodeEdge, value: Node | NodeArray<Node>, visitor: (node: Node) => Node) { function visitEdge(edge: NodeEdge, value: Node | NodeArray<Node>, visitor: (node: Node) => Node) {
return isArray(value) return isArray(value)
? visitNodes(<NodeArray<Node>>value, visitor, edge.test) ? visitNodes(<NodeArray<Node>>value, visitor, edge.test, /*start*/ undefined, /*count*/ undefined)
: visitNode(<Node>value, visitor, edge.test, edge.lift, edge.optional); : visitNode(<Node>value, visitor, edge.test, edge.optional, edge.lift);
} }
/** /**
* Spreads a NodeArrayNode into a NodeArray. * Appends a node to an array.
* *
* @param source The source NodeArrayNode. * @param to The destination array.
* @param dest The destination NodeArray. * @param from The source Node or NodeArrayNode.
* @param test The node test used to validate each node. * @param test The node test used to validate each node.
*/ */
function spreadNodeArrayNode<T extends Node>(source: NodeArrayNode<T>, dest: NodeArray<T>, test: (node: Node) => boolean) { export function addNode<T extends Node>(to: T[], from: OneOrMore<T>, test?: (node: Node) => boolean) {
for (const element of source.nodes) { if (to !== undefined && from !== undefined) {
if (element === undefined) { if (isNodeArrayNode(from)) {
continue; addNodes(to, from.nodes, test);
} }
else {
Debug.assert(test === undefined || test(from), "Wrong node type after visit.");
to.push(from);
}
}
}
Debug.assert(test === undefined || test(element), "Wrong node type after visit."); /**
dest.push(element); * Appends an array of nodes to an array.
*
* @param to The destination NodeArray.
* @param from The source array of Node or NodeArrayNode.
* @param test The node test used to validate each node.
*/
export function addNodes<T extends Node>(to: T[], from: OneOrMore<T>[], test?: (node: Node) => boolean) {
if (to !== undefined && from !== undefined) {
for (const node of from) {
addNode(to, node, test);
}
} }
} }
/** /**
* Merge generated declarations of a lexical environment. * Merge generated declarations of a lexical environment.
*
* @param node The source node.
* @param declarations The generated lexical declarations.
*/ */
function mergeLexicalEnvironment(node: Node, declarations: Statement[], nodeIsMutable: boolean) { function mergeLexicalEnvironment(node: Node, declarations: Statement[]): Node {
const mutableNode = nodeIsMutable ? node : cloneNode(node, /*location*/ node, node.flags, /*parent*/ undefined, /*original*/ node);
switch (node.kind) { switch (node.kind) {
case SyntaxKind.SourceFile: case SyntaxKind.SourceFile:
mergeSourceFileLexicalEnvironment(<SourceFile>mutableNode, declarations); return mergeSourceFileLexicalEnvironment(<SourceFile>node, declarations);
break;
case SyntaxKind.ModuleDeclaration: case SyntaxKind.ModuleDeclaration:
mergeModuleDeclarationLexicalEnvironment(<ModuleDeclaration>mutableNode, declarations); return mergeModuleDeclarationLexicalEnvironment(<ModuleDeclaration>node, declarations);
break;
case SyntaxKind.FunctionDeclaration: case SyntaxKind.FunctionDeclaration:
case SyntaxKind.FunctionExpression: case SyntaxKind.FunctionExpression:
case SyntaxKind.ArrowFunction:
case SyntaxKind.MethodDeclaration: case SyntaxKind.MethodDeclaration:
case SyntaxKind.GetAccessor: case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor: case SyntaxKind.SetAccessor:
case SyntaxKind.Constructor: case SyntaxKind.Constructor:
mergeFunctionLikeLexicalEnvironment(<FunctionLikeDeclaration>mutableNode, declarations); case SyntaxKind.ArrowFunction:
break; return mergeFunctionLikeLexicalEnvironment(<FunctionLikeDeclaration>node, declarations);
case SyntaxKind.ModuleBlock:
case SyntaxKind.Block:
mergeBlockLexicalEnvironment(<Block>mutableNode, declarations);
break;
} }
return mutableNode; Debug.fail("Node is not a valid lexical environment.");
} }
/** /**
* Merge generated declarations of a lexical environment into a SourceFile. * Merge generated declarations of a lexical environment into a SourceFile.
*
* @param node The SourceFile node.
* @param declarations The generated lexical declarations.
*/ */
function mergeSourceFileLexicalEnvironment(node: SourceFile, declarations: Statement[]) { export function mergeSourceFileLexicalEnvironment(node: SourceFile, declarations: Statement[]) {
node.statements = mergeStatements(node.statements, declarations); if (declarations !== undefined && declarations.length) {
const mutableNode = cloneNode(node, /*location*/ node, node.flags, /*parent*/ undefined, /*original*/ node);
mutableNode.statements = mergeStatements(mutableNode.statements, declarations);
return mutableNode;
}
return node;
} }
/** /**
* Merge generated declarations of a lexical environment into a ModuleDeclaration. * Merge generated declarations of a lexical environment into a ModuleDeclaration.
*
* @param node The ModuleDeclaration node.
* @param declarations The generated lexical declarations.
*/ */
function mergeModuleDeclarationLexicalEnvironment(node: ModuleDeclaration, declarations: Statement[]) { export function mergeModuleDeclarationLexicalEnvironment(node: ModuleDeclaration, declarations: Statement[]) {
Debug.assert(node.body.kind === SyntaxKind.ModuleBlock); Debug.assert(node.body.kind === SyntaxKind.ModuleBlock);
node.body = <ModuleBlock>mergeLexicalEnvironment(node.body, declarations, /*nodeIsMutable*/ false); if (declarations !== undefined && declarations.length) {
const mutableNode = cloneNode(node, /*location*/ node, node.flags, /*parent*/ undefined, /*original*/ node);
mutableNode.body = mergeBlockLexicalEnvironment(<ModuleBlock>node.body, declarations);
return mutableNode;
}
return node;
} }
/** /**
* Merge generated declarations of a lexical environment into a FunctionLikeDeclaration. * Merge generated declarations of a lexical environment into a FunctionLikeDeclaration.
*
* @param node The function-like node.
* @param declarations The generated lexical declarations.
*/ */
function mergeFunctionLikeLexicalEnvironment(node: FunctionLikeDeclaration, declarations: Statement[]) { function mergeFunctionLikeLexicalEnvironment(node: FunctionLikeDeclaration, declarations: Statement[]) {
Debug.assert(node.body !== undefined); Debug.assert(node.body !== undefined);
if (node.body.kind === SyntaxKind.Block) { if (declarations !== undefined && declarations.length) {
node.body = <Block>mergeLexicalEnvironment(node.body, declarations, /*nodeIsMutable*/ false); const mutableNode = cloneNode(node, /*location*/ node, node.flags, /*parent*/ undefined, /*original*/ node);
mutableNode.body = mergeConciseBodyLexicalEnvironment(mutableNode.body, declarations);
return mutableNode;
} }
else {
node.body = createBlock([ return node;
createReturn(<Expression>node.body), }
...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[]) {
if (declarations !== undefined && declarations.length > 0) {
return mergeBlockLexicalEnvironment(body, declarations);
} }
return body;
}
/**
* 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 mergeConciseBodyLexicalEnvironment(body: ConciseBody, declarations: Statement[]) {
if (declarations !== undefined && declarations.length > 0) {
if (isBlock(body)) {
return mergeBlockLexicalEnvironment(body, declarations);
}
else {
return createBlock([
createReturn(body),
...declarations
]);
}
}
return body;
} }
/** /**
* Merge generated declarations of a lexical environment into a FunctionBody or ModuleBlock. * Merge generated declarations of a lexical environment into a FunctionBody or ModuleBlock.
*
* @param node The block into which to merge lexical declarations.
* @param declarations The lexical declarations to merge.
*/ */
function mergeBlockLexicalEnvironment(node: FunctionBody | ModuleBlock, declarations: Statement[]) { function mergeBlockLexicalEnvironment<T extends Block>(node: T, declarations: Statement[]) {
node.statements = mergeStatements(node.statements, declarations); const mutableNode = cloneNode(node, /*location*/ node, node.flags, /*parent*/ undefined, /*original*/ node);
mutableNode.statements = mergeStatements(node.statements, declarations);
return mutableNode;
} }
/** /**
* Merge generated declarations of a lexical environment into a NodeArray of Statement. * Merge generated declarations of a lexical environment into a NodeArray of Statement.
*
* @param statements The node array to concatentate with the supplied lexical declarations.
* @param declarations The lexical declarations to merge.
*/ */
function mergeStatements(statements: NodeArray<Statement>, declarations: Statement[]) { function mergeStatements(statements: NodeArray<Statement>, declarations: Statement[]) {
return createNodeArray(statements.concat(declarations), statements.pos, statements.end); return createNodeArray(concatenate(statements, declarations), /*location*/ statements);
} }
/** /**