Cleanup and organization
This commit is contained in:
Ron Buckton
parent
152e3ebc44
commit
5d0797b2e0
|
|
@ -72,6 +72,7 @@ interface SyntaxMember {
|
|||
isNode?: boolean;
|
||||
isNodeArray?: boolean;
|
||||
isModifiersArray?: boolean;
|
||||
startsNewLexicalEnvironment?: boolean;
|
||||
}
|
||||
|
||||
interface EnumValue<T extends number> {
|
||||
|
|
@ -267,7 +268,9 @@ function discover() {
|
|||
propertyIsNodeArray ? normalizeTypeName((<TypeReferenceNode>typeNode).typeArguments[0].getText()) :
|
||||
propertyIsModifiersArray ? "Modifier" :
|
||||
undefined;
|
||||
|
||||
|
||||
let propertyStartsNewLexicalEnvironment = propertyIsNode && startsNewLexicalEnvironment(property);
|
||||
|
||||
members.push({
|
||||
propertyName: property.name,
|
||||
paramName: property.name === "arguments" ? "_arguments" : property.name,
|
||||
|
|
@ -277,7 +280,8 @@ function discover() {
|
|||
isFactoryParam: propertyIsFactoryParam,
|
||||
isNodeArray: propertyIsNodeArray,
|
||||
isModifiersArray: propertyIsModifiersArray,
|
||||
isNode: propertyIsNode
|
||||
isNode: propertyIsNode,
|
||||
startsNewLexicalEnvironment: propertyStartsNewLexicalEnvironment
|
||||
});
|
||||
|
||||
if (!propertyIsFactoryParam) {
|
||||
|
|
@ -470,7 +474,20 @@ function generateFactory(outputFile: string) {
|
|||
writer.write(`let node = createNode<${syntaxNode.typeName}>(SyntaxKind.${syntaxNode.kindName}, location, flags);`);
|
||||
writer.writeLine();
|
||||
if (syntaxNode.members.length > 1) {
|
||||
writer.write(`if (arguments.length) {`);
|
||||
writer.write(`if (`);
|
||||
|
||||
let first = true;
|
||||
for (let member of syntaxNode.members) {
|
||||
if (first) {
|
||||
first = false;
|
||||
}
|
||||
else {
|
||||
writer.write(` || `);
|
||||
}
|
||||
|
||||
writer.write(member.paramName);
|
||||
}
|
||||
writer.write(`) {`);
|
||||
writer.writeLine();
|
||||
writer.increaseIndent();
|
||||
}
|
||||
|
|
@ -744,78 +761,14 @@ function generateTransform(outputFile: string) {
|
|||
writer.writeLine();
|
||||
writer.increaseIndent();
|
||||
writeAcceptFunction();
|
||||
writeVisitNodesFunctions();
|
||||
writer.decreaseIndent();
|
||||
writer.write(`}`);
|
||||
writer.writeLine();
|
||||
|
||||
sys.writeFile(outputFile, writer.getText());
|
||||
|
||||
function writeVisitNodesFunctions() {
|
||||
// for (let typeName in memberTypeUsages) {
|
||||
// if (hasProperty(memberTypeUsages, typeName)) {
|
||||
// writeVisitNodeFunction(typeName);
|
||||
// }
|
||||
// }
|
||||
// for (let typeName in nodeArrayTypeUsages) {
|
||||
// if (getProperty(nodeArrayTypeUsages, typeName)) {
|
||||
// writeVisitNodesFunction(typeName);
|
||||
// }
|
||||
// }
|
||||
}
|
||||
|
||||
function writeVisitNodeFunction(typeName: string) {
|
||||
// if (typeName === "Node") {
|
||||
// return;
|
||||
// }
|
||||
|
||||
// // Skip the visit function for this node if it is defined in transform.ts
|
||||
// if (resolveQualifiedName(transformSourceFile, `ts.transform.visit${typeNameToMethodNameSuffix(typeName)}`, SymbolFlags.Function)) {
|
||||
// return;
|
||||
// }
|
||||
|
||||
// writer.write(`export function visit${typeNameToMethodNameSuffix(typeName)}(context: VisitorContext, node: ${typeName}, visitor: Visitor, mutator?: NodeWriter<${typeName}>): ${typeName} {`);
|
||||
// writer.writeLine();
|
||||
// writer.increaseIndent();
|
||||
|
||||
// writer.write(`let visited = visit(context, node, visitor, mutator);`);
|
||||
// writer.writeLine();
|
||||
|
||||
// writer.write(`Debug.assert(!visited || is${typeNameToMethodNameSuffix(typeName)}(visited), "Wrong node kind after visit.");`);
|
||||
// writer.writeLine();
|
||||
|
||||
// writer.write(`return <${typeName}>visited;`);
|
||||
// writer.writeLine();
|
||||
|
||||
// writer.decreaseIndent();
|
||||
// writer.write(`}`);
|
||||
// writer.writeLine();
|
||||
}
|
||||
|
||||
function writeVisitNodesFunction(typeName: string) {
|
||||
if (typeName === "Node") {
|
||||
return;
|
||||
}
|
||||
|
||||
// Skip the visitNodes function for this node if it is defined in transform.ts
|
||||
if (resolveQualifiedName(transformSourceFile, `ts.transform.visitNodeArrayOf${typeNameToMethodNameSuffix(typeName)}`, SymbolFlags.Function)) {
|
||||
return;
|
||||
}
|
||||
|
||||
writer.write(`export function visitNodeArrayOf${typeNameToMethodNameSuffix(typeName)}(context: VisitorContext, nodes: Array<${typeName}>, visitor: (context: VisitorContext, input: Node, write: (node: Node) => void) => void): NodeArray<${typeName}> {`);
|
||||
writer.writeLine();
|
||||
writer.increaseIndent();
|
||||
|
||||
writer.write(`return <NodeArray<${typeName}>>visitNodes(context, nodes, visitor, visit${typeNameToMethodNameSuffix(typeName)});`);
|
||||
writer.writeLine();
|
||||
|
||||
writer.decreaseIndent();
|
||||
writer.write(`}`);
|
||||
writer.writeLine();
|
||||
}
|
||||
|
||||
function writeAcceptFunction() {
|
||||
writer.write(`export function accept(context: VisitorContext, node: Node, visitor: Visitor, write: (node: Node) => void): void {`);
|
||||
writer.write(`export function accept(node: Node, visitor: (input: Node, write: (node: Node) => void) => void, write: (node: Node) => void): void {`);
|
||||
writer.writeLine();
|
||||
writer.increaseIndent();
|
||||
|
||||
|
|
@ -860,17 +813,13 @@ function generateTransform(outputFile: string) {
|
|||
writer.write(`(<${syntaxNode.typeName}>node).${member.propertyName}`);
|
||||
}
|
||||
else {
|
||||
// let visitorFunction =
|
||||
// member.visitorFunction ? member.visitorFunction :
|
||||
// member.isNodeArray || member.isModifiersArray ? `visitNodeArrayOf${typeNameToMethodNameSuffix(member.elementTypeName)}` :
|
||||
// `visit${typeNameToMethodNameSuffix(member.typeName)}`;
|
||||
|
||||
let visitorFunction =
|
||||
member.visitorFunction ? member.visitorFunction :
|
||||
member.isNodeArray || member.isModifiersArray ? `<NodeArray<${member.elementTypeName}>>visitNodes` :
|
||||
member.startsNewLexicalEnvironment ? `<${member.typeName}>visitNewLexicalEnvironment` :
|
||||
`<${member.typeName}>visitNode`;
|
||||
|
||||
writer.write(`${visitorFunction}(context, (<${syntaxNode.typeName}>node).${member.propertyName}, visitor)`);
|
||||
writer.write(`${visitorFunction}((<${syntaxNode.typeName}>node).${member.propertyName}, visitor)`);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1614,6 +1563,15 @@ class MemberVisitorAnnotation extends Annotation {
|
|||
}
|
||||
}
|
||||
|
||||
@annotation("newlexicalenvironment")
|
||||
class NewLexicalEnvironmentAnnotation extends Annotation {
|
||||
public name = "newlexicalenvironment";
|
||||
|
||||
public static match(annotation: Annotation): annotation is NewLexicalEnvironmentAnnotation {
|
||||
return annotation instanceof NewLexicalEnvironmentAnnotation;
|
||||
}
|
||||
}
|
||||
|
||||
function createAnnotation(name: string, _arguments: any[]): Annotation {
|
||||
let ctor = getProperty(annotationConstructors, name);
|
||||
if (ctor) {
|
||||
|
|
@ -1763,5 +1721,9 @@ function getFactoryOrder(symbol: Symbol, inherited?: boolean): string[] {
|
|||
return propertyNames;
|
||||
}
|
||||
|
||||
function startsNewLexicalEnvironment(symbol: Symbol): boolean {
|
||||
return !!findFirstAnnotation(symbol, NewLexicalEnvironmentAnnotation.match);
|
||||
}
|
||||
|
||||
// Main entry point
|
||||
main();
|
||||
|
|
@ -82,6 +82,10 @@ namespace ts {
|
|||
bindSourceFileWorker(file);
|
||||
bindTime += new Date().getTime() - start;
|
||||
}
|
||||
|
||||
// function computeTransformFlagsForNode(node: Node, subtreeFlags: TransformFlags) {
|
||||
// return 0;
|
||||
// }
|
||||
|
||||
function bindSourceFileWorker(file: SourceFile) {
|
||||
let parent: Node;
|
||||
|
|
@ -816,7 +820,7 @@ namespace ts {
|
|||
let saveTransformFlags = transformFlags;
|
||||
transformFlags = 0;
|
||||
let result = cbNode(node);
|
||||
transformFlags = saveTransformFlags | transform.computeTransformFlagsForNode(node, transformFlags);
|
||||
transformFlags = saveTransformFlags | computeTransformFlagsForNode(node, transformFlags);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -803,6 +803,10 @@ namespace ts {
|
|||
end: -1,
|
||||
flags: 0,
|
||||
parent: undefined,
|
||||
original: undefined,
|
||||
transformFlags: undefined,
|
||||
excludeTransformFlags: undefined,
|
||||
modifiers: undefined
|
||||
};
|
||||
return <any>Node;
|
||||
},
|
||||
|
|
|
|||
|
|
@ -7271,8 +7271,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
|
|||
// Process tree transformations
|
||||
let statements = node.statements;
|
||||
if (compilerOptions.experimentalTransforms) {
|
||||
let context = new transform.VisitorContext(compilerOptions, currentSourceFile, resolver, generatedNameSet, nodeToGeneratedName);
|
||||
statements = transformationChain(context, node.statements);
|
||||
statements = runTransformationChain(statements, transformationChain, compilerOptions, currentSourceFile, resolver, generatedNameSet, nodeToGeneratedName);
|
||||
}
|
||||
|
||||
// emit prologue directives prior to __extends
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ namespace ts {
|
|||
}
|
||||
export function createIdentifier(text?: string, originalKeywordKind?: SyntaxKind, location?: TextRange, flags?: NodeFlags): Identifier {
|
||||
let node = createNode<Identifier>(SyntaxKind.Identifier, location, flags);
|
||||
if (arguments.length) {
|
||||
if (text || originalKeywordKind) {
|
||||
node.text = text;
|
||||
node.originalKeywordKind = originalKeywordKind;
|
||||
}
|
||||
|
|
@ -60,7 +60,7 @@ namespace ts {
|
|||
}
|
||||
export function createQualifiedName(left?: EntityName, right?: Identifier, location?: TextRange, flags?: NodeFlags): QualifiedName {
|
||||
let node = createNode<QualifiedName>(SyntaxKind.QualifiedName, location, flags);
|
||||
if (arguments.length) {
|
||||
if (left || right) {
|
||||
node.left = left;
|
||||
node.right = right;
|
||||
}
|
||||
|
|
@ -88,7 +88,7 @@ namespace ts {
|
|||
export function createTypeParameter(name?: Identifier, constraint?: TypeNode, expression?: Expression,
|
||||
location?: TextRange, flags?: NodeFlags): TypeParameterDeclaration {
|
||||
let node = createNode<TypeParameterDeclaration>(SyntaxKind.TypeParameter, location, flags);
|
||||
if (arguments.length) {
|
||||
if (name || constraint || expression) {
|
||||
node.name = name;
|
||||
node.constraint = constraint;
|
||||
node.expression = expression;
|
||||
|
|
@ -107,7 +107,7 @@ namespace ts {
|
|||
name?: BindingPattern | Identifier, questionToken?: Node, type?: TypeNode, initializer?: Expression,
|
||||
location?: TextRange, flags?: NodeFlags): ParameterDeclaration {
|
||||
let node = createNode<ParameterDeclaration>(SyntaxKind.Parameter, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || dotDotDotToken || name || questionToken || type || initializer) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.dotDotDotToken = dotDotDotToken;
|
||||
|
|
@ -142,7 +142,7 @@ namespace ts {
|
|||
export function createPropertySignature(decorators?: Array<Decorator>, modifiers?: Array<Node>, name?: PropertyName, questionToken?: Node,
|
||||
type?: TypeNode, location?: TextRange, flags?: NodeFlags): PropertySignature {
|
||||
let node = createNode<PropertySignature>(SyntaxKind.PropertySignature, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || questionToken || type) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -162,7 +162,7 @@ namespace ts {
|
|||
export function createPropertyDeclaration(decorators?: Array<Decorator>, modifiers?: Array<Node>, name?: PropertyName, type?: TypeNode,
|
||||
initializer?: Expression, location?: TextRange, flags?: NodeFlags): PropertyDeclaration {
|
||||
let node = createNode<PropertyDeclaration>(SyntaxKind.PropertyDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || type || initializer) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -184,7 +184,7 @@ namespace ts {
|
|||
typeParameters?: Array<TypeParameterDeclaration>, parameters?: Array<ParameterDeclaration>, type?: TypeNode,
|
||||
location?: TextRange, flags?: NodeFlags): MethodSignature {
|
||||
let node = createNode<MethodSignature>(SyntaxKind.MethodSignature, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || questionToken || typeParameters || parameters || type) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -208,7 +208,7 @@ namespace ts {
|
|||
typeParameters?: Array<TypeParameterDeclaration>, parameters?: Array<ParameterDeclaration>, type?: TypeNode, body?: Block,
|
||||
location?: TextRange, flags?: NodeFlags): MethodDeclaration {
|
||||
let node = createNode<MethodDeclaration>(SyntaxKind.MethodDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || asteriskToken || name || typeParameters || parameters || type || body) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.asteriskToken = asteriskToken;
|
||||
|
|
@ -233,7 +233,7 @@ namespace ts {
|
|||
export function createConstructor(decorators?: Array<Decorator>, modifiers?: Array<Node>, parameters?: Array<ParameterDeclaration>,
|
||||
type?: TypeNode, body?: Block, location?: TextRange, flags?: NodeFlags): ConstructorDeclaration {
|
||||
let node = createNode<ConstructorDeclaration>(SyntaxKind.Constructor, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || parameters || type || body) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.parameters = parameters && createNodeArray(parameters)
|
||||
|
|
@ -255,7 +255,7 @@ namespace ts {
|
|||
parameters?: Array<ParameterDeclaration>, type?: TypeNode, body?: Block,
|
||||
location?: TextRange, flags?: NodeFlags): GetAccessorDeclaration {
|
||||
let node = createNode<GetAccessorDeclaration>(SyntaxKind.GetAccessor, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || parameters || type || body) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -278,7 +278,7 @@ namespace ts {
|
|||
parameters?: Array<ParameterDeclaration>, type?: TypeNode, body?: Block,
|
||||
location?: TextRange, flags?: NodeFlags): SetAccessorDeclaration {
|
||||
let node = createNode<SetAccessorDeclaration>(SyntaxKind.SetAccessor, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || parameters || type || body) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -300,7 +300,7 @@ namespace ts {
|
|||
export function createCallSignature(typeParameters?: Array<TypeParameterDeclaration>, parameters?: Array<ParameterDeclaration>,
|
||||
type?: TypeNode, questionToken?: Node, location?: TextRange, flags?: NodeFlags): CallSignatureDeclaration {
|
||||
let node = createNode<CallSignatureDeclaration>(SyntaxKind.CallSignature, location, flags);
|
||||
if (arguments.length) {
|
||||
if (typeParameters || parameters || type || questionToken) {
|
||||
node.typeParameters = typeParameters && createNodeArray(typeParameters)
|
||||
node.parameters = parameters && createNodeArray(parameters)
|
||||
node.type = type;
|
||||
|
|
@ -319,7 +319,7 @@ namespace ts {
|
|||
export function createConstructSignature(typeParameters?: Array<TypeParameterDeclaration>, parameters?: Array<ParameterDeclaration>,
|
||||
type?: TypeNode, questionToken?: Node, location?: TextRange, flags?: NodeFlags): ConstructSignatureDeclaration {
|
||||
let node = createNode<ConstructSignatureDeclaration>(SyntaxKind.ConstructSignature, location, flags);
|
||||
if (arguments.length) {
|
||||
if (typeParameters || parameters || type || questionToken) {
|
||||
node.typeParameters = typeParameters && createNodeArray(typeParameters)
|
||||
node.parameters = parameters && createNodeArray(parameters)
|
||||
node.type = type;
|
||||
|
|
@ -338,7 +338,7 @@ namespace ts {
|
|||
export function createIndexSignature(decorators?: Array<Decorator>, modifiers?: Array<Node>, parameters?: Array<ParameterDeclaration>,
|
||||
type?: TypeNode, questionToken?: Node, location?: TextRange, flags?: NodeFlags): IndexSignatureDeclaration {
|
||||
let node = createNode<IndexSignatureDeclaration>(SyntaxKind.IndexSignature, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || parameters || type || questionToken) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.parameters = parameters && createNodeArray(parameters)
|
||||
|
|
@ -358,7 +358,7 @@ namespace ts {
|
|||
export function createTypePredicate(parameterName?: Identifier, type?: TypeNode,
|
||||
location?: TextRange, flags?: NodeFlags): TypePredicateNode {
|
||||
let node = createNode<TypePredicateNode>(SyntaxKind.TypePredicate, location, flags);
|
||||
if (arguments.length) {
|
||||
if (parameterName || type) {
|
||||
node.parameterName = parameterName;
|
||||
node.type = type;
|
||||
}
|
||||
|
|
@ -374,7 +374,7 @@ namespace ts {
|
|||
export function createTypeReference(typeName?: EntityName, typeArguments?: Array<TypeNode>,
|
||||
location?: TextRange, flags?: NodeFlags): TypeReferenceNode {
|
||||
let node = createNode<TypeReferenceNode>(SyntaxKind.TypeReference, location, flags);
|
||||
if (arguments.length) {
|
||||
if (typeName || typeArguments) {
|
||||
node.typeName = typeName;
|
||||
node.typeArguments = typeArguments && createNodeArray(typeArguments)
|
||||
}
|
||||
|
|
@ -390,7 +390,7 @@ namespace ts {
|
|||
export function createFunctionType(typeParameters?: Array<TypeParameterDeclaration>, parameters?: Array<ParameterDeclaration>,
|
||||
type?: TypeNode, location?: TextRange, flags?: NodeFlags): FunctionTypeNode {
|
||||
let node = createNode<FunctionTypeNode>(SyntaxKind.FunctionType, location, flags);
|
||||
if (arguments.length) {
|
||||
if (typeParameters || parameters || type) {
|
||||
node.typeParameters = typeParameters && createNodeArray(typeParameters)
|
||||
node.parameters = parameters && createNodeArray(parameters)
|
||||
node.type = type;
|
||||
|
|
@ -408,7 +408,7 @@ namespace ts {
|
|||
export function createConstructorType(typeParameters?: Array<TypeParameterDeclaration>, parameters?: Array<ParameterDeclaration>,
|
||||
type?: TypeNode, location?: TextRange, flags?: NodeFlags): ConstructorTypeNode {
|
||||
let node = createNode<ConstructorTypeNode>(SyntaxKind.ConstructorType, location, flags);
|
||||
if (arguments.length) {
|
||||
if (typeParameters || parameters || type) {
|
||||
node.typeParameters = typeParameters && createNodeArray(typeParameters)
|
||||
node.parameters = parameters && createNodeArray(parameters)
|
||||
node.type = type;
|
||||
|
|
@ -535,7 +535,7 @@ namespace ts {
|
|||
dotDotDotToken?: Node, name?: BindingPattern | Identifier, initializer?: Expression,
|
||||
location?: TextRange, flags?: NodeFlags): BindingElement {
|
||||
let node = createNode<BindingElement>(SyntaxKind.BindingElement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || propertyName || dotDotDotToken || name || initializer) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.propertyName = propertyName;
|
||||
|
|
@ -569,7 +569,7 @@ namespace ts {
|
|||
export function createObjectLiteralExpression(decorators?: Array<Decorator>, modifiers?: Array<Node>,
|
||||
properties?: Array<ObjectLiteralElement>, location?: TextRange, flags?: NodeFlags): ObjectLiteralExpression {
|
||||
let node = createNode<ObjectLiteralExpression>(SyntaxKind.ObjectLiteralExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || properties) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.properties = properties && createNodeArray(properties)
|
||||
|
|
@ -587,7 +587,7 @@ namespace ts {
|
|||
export function createPropertyAccessExpression(expression?: LeftHandSideExpression, dotToken?: Node, name?: Identifier,
|
||||
location?: TextRange, flags?: NodeFlags): PropertyAccessExpression {
|
||||
let node = createNode<PropertyAccessExpression>(SyntaxKind.PropertyAccessExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || dotToken || name) {
|
||||
node.expression = expression;
|
||||
node.dotToken = dotToken;
|
||||
node.name = name;
|
||||
|
|
@ -605,7 +605,7 @@ namespace ts {
|
|||
export function createElementAccessExpression(expression?: LeftHandSideExpression, argumentExpression?: Expression,
|
||||
location?: TextRange, flags?: NodeFlags): ElementAccessExpression {
|
||||
let node = createNode<ElementAccessExpression>(SyntaxKind.ElementAccessExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || argumentExpression) {
|
||||
node.expression = expression;
|
||||
node.argumentExpression = argumentExpression;
|
||||
}
|
||||
|
|
@ -622,7 +622,7 @@ namespace ts {
|
|||
export function createCallExpression(expression?: LeftHandSideExpression, typeArguments?: Array<TypeNode>, _arguments?: Array<Expression>,
|
||||
location?: TextRange, flags?: NodeFlags): CallExpression {
|
||||
let node = createNode<CallExpression>(SyntaxKind.CallExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || typeArguments || _arguments) {
|
||||
node.expression = expression;
|
||||
node.typeArguments = typeArguments && createNodeArray(typeArguments)
|
||||
node.arguments = _arguments && createNodeArray(_arguments)
|
||||
|
|
@ -640,7 +640,7 @@ namespace ts {
|
|||
export function createNewExpression(expression?: LeftHandSideExpression, typeArguments?: Array<TypeNode>, _arguments?: Array<Expression>,
|
||||
location?: TextRange, flags?: NodeFlags): NewExpression {
|
||||
let node = createNode<NewExpression>(SyntaxKind.NewExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || typeArguments || _arguments) {
|
||||
node.expression = expression;
|
||||
node.typeArguments = typeArguments && createNodeArray(typeArguments)
|
||||
node.arguments = _arguments && createNodeArray(_arguments)
|
||||
|
|
@ -658,7 +658,7 @@ namespace ts {
|
|||
export function createTaggedTemplateExpression(tag?: LeftHandSideExpression, template?: LiteralExpression | TemplateExpression,
|
||||
location?: TextRange, flags?: NodeFlags): TaggedTemplateExpression {
|
||||
let node = createNode<TaggedTemplateExpression>(SyntaxKind.TaggedTemplateExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (tag || template) {
|
||||
node.tag = tag;
|
||||
node.template = template;
|
||||
}
|
||||
|
|
@ -675,7 +675,7 @@ namespace ts {
|
|||
export function createTypeAssertionExpression(type?: TypeNode, expression?: UnaryExpression,
|
||||
location?: TextRange, flags?: NodeFlags): TypeAssertion {
|
||||
let node = createNode<TypeAssertion>(SyntaxKind.TypeAssertionExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (type || expression) {
|
||||
node.type = type;
|
||||
node.expression = expression;
|
||||
}
|
||||
|
|
@ -704,7 +704,7 @@ namespace ts {
|
|||
typeParameters?: Array<TypeParameterDeclaration>, parameters?: Array<ParameterDeclaration>, type?: TypeNode, body?: Block | Expression,
|
||||
location?: TextRange, flags?: NodeFlags): FunctionExpression {
|
||||
let node = createNode<FunctionExpression>(SyntaxKind.FunctionExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || asteriskToken || name || typeParameters || parameters || type || body) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.asteriskToken = asteriskToken;
|
||||
|
|
@ -730,7 +730,7 @@ namespace ts {
|
|||
parameters?: Array<ParameterDeclaration>, type?: TypeNode, equalsGreaterThanToken?: Node, body?: Block | Expression,
|
||||
location?: TextRange, flags?: NodeFlags): ArrowFunction {
|
||||
let node = createNode<ArrowFunction>(SyntaxKind.ArrowFunction, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || typeParameters || parameters || type || equalsGreaterThanToken || body) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.typeParameters = typeParameters && createNodeArray(typeParameters)
|
||||
|
|
@ -802,7 +802,7 @@ namespace ts {
|
|||
export function createPrefixUnaryExpression(operator?: SyntaxKind, operand?: UnaryExpression,
|
||||
location?: TextRange, flags?: NodeFlags): PrefixUnaryExpression {
|
||||
let node = createNode<PrefixUnaryExpression>(SyntaxKind.PrefixUnaryExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (operator || operand) {
|
||||
node.operator = operator;
|
||||
node.operand = operand;
|
||||
}
|
||||
|
|
@ -818,7 +818,7 @@ namespace ts {
|
|||
export function createPostfixUnaryExpression(operand?: LeftHandSideExpression, operator?: SyntaxKind,
|
||||
location?: TextRange, flags?: NodeFlags): PostfixUnaryExpression {
|
||||
let node = createNode<PostfixUnaryExpression>(SyntaxKind.PostfixUnaryExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (operand || operator) {
|
||||
node.operand = operand;
|
||||
node.operator = operator;
|
||||
}
|
||||
|
|
@ -834,7 +834,7 @@ namespace ts {
|
|||
export function createBinaryExpression(left?: Expression, operatorToken?: Node, right?: Expression,
|
||||
location?: TextRange, flags?: NodeFlags): BinaryExpression {
|
||||
let node = createNode<BinaryExpression>(SyntaxKind.BinaryExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (left || operatorToken || right) {
|
||||
node.left = left;
|
||||
node.operatorToken = operatorToken;
|
||||
node.right = right;
|
||||
|
|
@ -851,7 +851,7 @@ namespace ts {
|
|||
export function createConditionalExpression(condition?: Expression, questionToken?: Node, whenTrue?: Expression, colonToken?: Node,
|
||||
whenFalse?: Expression, location?: TextRange, flags?: NodeFlags): ConditionalExpression {
|
||||
let node = createNode<ConditionalExpression>(SyntaxKind.ConditionalExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (condition || questionToken || whenTrue || colonToken || whenFalse) {
|
||||
node.condition = condition;
|
||||
node.questionToken = questionToken;
|
||||
node.whenTrue = whenTrue;
|
||||
|
|
@ -871,7 +871,7 @@ namespace ts {
|
|||
export function createTemplateExpression(head?: LiteralExpression, templateSpans?: Array<TemplateSpan>,
|
||||
location?: TextRange, flags?: NodeFlags): TemplateExpression {
|
||||
let node = createNode<TemplateExpression>(SyntaxKind.TemplateExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (head || templateSpans) {
|
||||
node.head = head;
|
||||
node.templateSpans = templateSpans && createNodeArray(templateSpans)
|
||||
}
|
||||
|
|
@ -888,7 +888,7 @@ namespace ts {
|
|||
export function createYieldExpression(asteriskToken?: Node, expression?: Expression,
|
||||
location?: TextRange, flags?: NodeFlags): YieldExpression {
|
||||
let node = createNode<YieldExpression>(SyntaxKind.YieldExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (asteriskToken || expression) {
|
||||
node.asteriskToken = asteriskToken;
|
||||
node.expression = expression;
|
||||
}
|
||||
|
|
@ -917,7 +917,7 @@ namespace ts {
|
|||
typeParameters?: Array<TypeParameterDeclaration>, heritageClauses?: Array<HeritageClause>, members?: Array<ClassElement>,
|
||||
location?: TextRange, flags?: NodeFlags): ClassExpression {
|
||||
let node = createNode<ClassExpression>(SyntaxKind.ClassExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || typeParameters || heritageClauses || members) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -943,7 +943,7 @@ namespace ts {
|
|||
export function createExpressionWithTypeArguments(expression?: LeftHandSideExpression, typeArguments?: Array<TypeNode>,
|
||||
location?: TextRange, flags?: NodeFlags): ExpressionWithTypeArguments {
|
||||
let node = createNode<ExpressionWithTypeArguments>(SyntaxKind.ExpressionWithTypeArguments, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || typeArguments) {
|
||||
node.expression = expression;
|
||||
node.typeArguments = typeArguments && createNodeArray(typeArguments)
|
||||
}
|
||||
|
|
@ -959,7 +959,7 @@ namespace ts {
|
|||
}
|
||||
export function createAsExpression(expression?: Expression, type?: TypeNode, location?: TextRange, flags?: NodeFlags): AsExpression {
|
||||
let node = createNode<AsExpression>(SyntaxKind.AsExpression, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || type) {
|
||||
node.expression = expression;
|
||||
node.type = type;
|
||||
}
|
||||
|
|
@ -975,7 +975,7 @@ namespace ts {
|
|||
export function createTemplateSpan(expression?: Expression, literal?: LiteralExpression,
|
||||
location?: TextRange, flags?: NodeFlags): TemplateSpan {
|
||||
let node = createNode<TemplateSpan>(SyntaxKind.TemplateSpan, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || literal) {
|
||||
node.expression = expression;
|
||||
node.literal = literal;
|
||||
}
|
||||
|
|
@ -1006,7 +1006,7 @@ namespace ts {
|
|||
export function createVariableStatement(decorators?: Array<Decorator>, modifiers?: Array<Node>, declarationList?: VariableDeclarationList,
|
||||
location?: TextRange, flags?: NodeFlags): VariableStatement {
|
||||
let node = createNode<VariableStatement>(SyntaxKind.VariableStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || declarationList) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.declarationList = declarationList;
|
||||
|
|
@ -1039,7 +1039,7 @@ namespace ts {
|
|||
export function createIfStatement(expression?: Expression, thenStatement?: Statement, elseStatement?: Statement,
|
||||
location?: TextRange, flags?: NodeFlags): IfStatement {
|
||||
let node = createNode<IfStatement>(SyntaxKind.IfStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || thenStatement || elseStatement) {
|
||||
node.expression = expression;
|
||||
node.thenStatement = thenStatement;
|
||||
node.elseStatement = elseStatement;
|
||||
|
|
@ -1056,7 +1056,7 @@ namespace ts {
|
|||
}
|
||||
export function createDoStatement(statement?: Statement, expression?: Expression, location?: TextRange, flags?: NodeFlags): DoStatement {
|
||||
let node = createNode<DoStatement>(SyntaxKind.DoStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (statement || expression) {
|
||||
node.statement = statement;
|
||||
node.expression = expression;
|
||||
}
|
||||
|
|
@ -1072,7 +1072,7 @@ namespace ts {
|
|||
export function createWhileStatement(expression?: Expression, statement?: Statement,
|
||||
location?: TextRange, flags?: NodeFlags): WhileStatement {
|
||||
let node = createNode<WhileStatement>(SyntaxKind.WhileStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || statement) {
|
||||
node.expression = expression;
|
||||
node.statement = statement;
|
||||
}
|
||||
|
|
@ -1088,7 +1088,7 @@ namespace ts {
|
|||
export function createForStatement(initializer?: Expression | VariableDeclarationList, condition?: Expression, incrementor?: Expression,
|
||||
statement?: Statement, location?: TextRange, flags?: NodeFlags): ForStatement {
|
||||
let node = createNode<ForStatement>(SyntaxKind.ForStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (initializer || condition || incrementor || statement) {
|
||||
node.initializer = initializer;
|
||||
node.condition = condition;
|
||||
node.incrementor = incrementor;
|
||||
|
|
@ -1108,7 +1108,7 @@ namespace ts {
|
|||
export function createForInStatement(initializer?: Expression | VariableDeclarationList, expression?: Expression, statement?: Statement,
|
||||
location?: TextRange, flags?: NodeFlags): ForInStatement {
|
||||
let node = createNode<ForInStatement>(SyntaxKind.ForInStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (initializer || expression || statement) {
|
||||
node.initializer = initializer;
|
||||
node.expression = expression;
|
||||
node.statement = statement;
|
||||
|
|
@ -1126,7 +1126,7 @@ namespace ts {
|
|||
export function createForOfStatement(initializer?: Expression | VariableDeclarationList, expression?: Expression, statement?: Statement,
|
||||
location?: TextRange, flags?: NodeFlags): ForOfStatement {
|
||||
let node = createNode<ForOfStatement>(SyntaxKind.ForOfStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (initializer || expression || statement) {
|
||||
node.initializer = initializer;
|
||||
node.expression = expression;
|
||||
node.statement = statement;
|
||||
|
|
@ -1179,7 +1179,7 @@ namespace ts {
|
|||
}
|
||||
export function createWithStatement(expression?: Expression, statement?: Statement, location?: TextRange, flags?: NodeFlags): WithStatement {
|
||||
let node = createNode<WithStatement>(SyntaxKind.WithStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || statement) {
|
||||
node.expression = expression;
|
||||
node.statement = statement;
|
||||
}
|
||||
|
|
@ -1195,7 +1195,7 @@ namespace ts {
|
|||
export function createSwitchStatement(expression?: Expression, caseBlock?: CaseBlock,
|
||||
location?: TextRange, flags?: NodeFlags): SwitchStatement {
|
||||
let node = createNode<SwitchStatement>(SyntaxKind.SwitchStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || caseBlock) {
|
||||
node.expression = expression;
|
||||
node.caseBlock = caseBlock;
|
||||
}
|
||||
|
|
@ -1211,7 +1211,7 @@ namespace ts {
|
|||
export function createLabeledStatement(label?: Identifier, statement?: Statement,
|
||||
location?: TextRange, flags?: NodeFlags): LabeledStatement {
|
||||
let node = createNode<LabeledStatement>(SyntaxKind.LabeledStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (label || statement) {
|
||||
node.label = label;
|
||||
node.statement = statement;
|
||||
}
|
||||
|
|
@ -1239,7 +1239,7 @@ namespace ts {
|
|||
export function createTryStatement(tryBlock?: Block, catchClause?: CatchClause, finallyBlock?: Block,
|
||||
location?: TextRange, flags?: NodeFlags): TryStatement {
|
||||
let node = createNode<TryStatement>(SyntaxKind.TryStatement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (tryBlock || catchClause || finallyBlock) {
|
||||
node.tryBlock = tryBlock;
|
||||
node.catchClause = catchClause;
|
||||
node.finallyBlock = finallyBlock;
|
||||
|
|
@ -1259,7 +1259,7 @@ namespace ts {
|
|||
export function createVariableDeclaration(name?: BindingPattern | Identifier, type?: TypeNode, initializer?: Expression,
|
||||
location?: TextRange, flags?: NodeFlags): VariableDeclaration {
|
||||
let node = createNode<VariableDeclaration>(SyntaxKind.VariableDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (name || type || initializer) {
|
||||
node.name = name;
|
||||
node.type = type;
|
||||
node.initializer = initializer;
|
||||
|
|
@ -1292,7 +1292,7 @@ namespace ts {
|
|||
typeParameters?: Array<TypeParameterDeclaration>, parameters?: Array<ParameterDeclaration>, type?: TypeNode, body?: Block,
|
||||
location?: TextRange, flags?: NodeFlags): FunctionDeclaration {
|
||||
let node = createNode<FunctionDeclaration>(SyntaxKind.FunctionDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || asteriskToken || name || typeParameters || parameters || type || body) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.asteriskToken = asteriskToken;
|
||||
|
|
@ -1318,7 +1318,7 @@ namespace ts {
|
|||
typeParameters?: Array<TypeParameterDeclaration>, heritageClauses?: Array<HeritageClause>, members?: Array<ClassElement>,
|
||||
location?: TextRange, flags?: NodeFlags): ClassDeclaration {
|
||||
let node = createNode<ClassDeclaration>(SyntaxKind.ClassDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || typeParameters || heritageClauses || members) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -1342,7 +1342,7 @@ namespace ts {
|
|||
typeParameters?: Array<TypeParameterDeclaration>, heritageClauses?: Array<HeritageClause>, members?: Array<TypeElement>,
|
||||
location?: TextRange, flags?: NodeFlags): InterfaceDeclaration {
|
||||
let node = createNode<InterfaceDeclaration>(SyntaxKind.InterfaceDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || typeParameters || heritageClauses || members) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -1365,7 +1365,7 @@ namespace ts {
|
|||
export function createTypeAliasDeclaration(decorators?: Array<Decorator>, modifiers?: Array<Node>, name?: Identifier,
|
||||
typeParameters?: Array<TypeParameterDeclaration>, type?: TypeNode, location?: TextRange, flags?: NodeFlags): TypeAliasDeclaration {
|
||||
let node = createNode<TypeAliasDeclaration>(SyntaxKind.TypeAliasDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || typeParameters || type) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -1386,7 +1386,7 @@ namespace ts {
|
|||
export function createEnumDeclaration(decorators?: Array<Decorator>, modifiers?: Array<Node>, name?: Identifier, members?: Array<EnumMember>,
|
||||
location?: TextRange, flags?: NodeFlags): EnumDeclaration {
|
||||
let node = createNode<EnumDeclaration>(SyntaxKind.EnumDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || members) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -1405,7 +1405,7 @@ namespace ts {
|
|||
export function createModuleDeclaration(decorators?: Array<Decorator>, modifiers?: Array<Node>, name?: Identifier | LiteralExpression,
|
||||
body?: ModuleBlock | ModuleDeclaration, location?: TextRange, flags?: NodeFlags): ModuleDeclaration {
|
||||
let node = createNode<ModuleDeclaration>(SyntaxKind.ModuleDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || body) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -1448,7 +1448,7 @@ namespace ts {
|
|||
export function createImportEqualsDeclaration(decorators?: Array<Decorator>, modifiers?: Array<Node>, name?: Identifier,
|
||||
moduleReference?: EntityName | ExternalModuleReference, location?: TextRange, flags?: NodeFlags): ImportEqualsDeclaration {
|
||||
let node = createNode<ImportEqualsDeclaration>(SyntaxKind.ImportEqualsDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || name || moduleReference) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.name = name;
|
||||
|
|
@ -1467,7 +1467,7 @@ namespace ts {
|
|||
export function createImportDeclaration(decorators?: Array<Decorator>, modifiers?: Array<Node>, importClause?: ImportClause,
|
||||
moduleSpecifier?: Expression, location?: TextRange, flags?: NodeFlags): ImportDeclaration {
|
||||
let node = createNode<ImportDeclaration>(SyntaxKind.ImportDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || importClause || moduleSpecifier) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.importClause = importClause;
|
||||
|
|
@ -1487,7 +1487,7 @@ namespace ts {
|
|||
export function createImportClause(name?: Identifier, namedBindings?: NamedImports | NamespaceImport,
|
||||
location?: TextRange, flags?: NodeFlags): ImportClause {
|
||||
let node = createNode<ImportClause>(SyntaxKind.ImportClause, location, flags);
|
||||
if (arguments.length) {
|
||||
if (name || namedBindings) {
|
||||
node.name = name;
|
||||
node.namedBindings = namedBindings;
|
||||
}
|
||||
|
|
@ -1527,7 +1527,7 @@ namespace ts {
|
|||
export function createImportSpecifier(propertyName?: Identifier, name?: Identifier,
|
||||
location?: TextRange, flags?: NodeFlags): ImportSpecifier {
|
||||
let node = createNode<ImportSpecifier>(SyntaxKind.ImportSpecifier, location, flags);
|
||||
if (arguments.length) {
|
||||
if (propertyName || name) {
|
||||
node.propertyName = propertyName;
|
||||
node.name = name;
|
||||
}
|
||||
|
|
@ -1543,7 +1543,7 @@ namespace ts {
|
|||
export function createExportAssignment(decorators?: Array<Decorator>, modifiers?: Array<Node>, expression?: Expression,
|
||||
location?: TextRange, flags?: NodeFlags): ExportAssignment {
|
||||
let node = createNode<ExportAssignment>(SyntaxKind.ExportAssignment, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || expression) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.expression = expression;
|
||||
|
|
@ -1561,7 +1561,7 @@ namespace ts {
|
|||
export function createExportDeclaration(decorators?: Array<Decorator>, modifiers?: Array<Node>, exportClause?: NamedExports,
|
||||
moduleSpecifier?: Expression, location?: TextRange, flags?: NodeFlags): ExportDeclaration {
|
||||
let node = createNode<ExportDeclaration>(SyntaxKind.ExportDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || exportClause || moduleSpecifier) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.exportClause = exportClause;
|
||||
|
|
@ -1593,7 +1593,7 @@ namespace ts {
|
|||
export function createExportSpecifier(propertyName?: Identifier, name?: Identifier,
|
||||
location?: TextRange, flags?: NodeFlags): ExportSpecifier {
|
||||
let node = createNode<ExportSpecifier>(SyntaxKind.ExportSpecifier, location, flags);
|
||||
if (arguments.length) {
|
||||
if (propertyName || name) {
|
||||
node.propertyName = propertyName;
|
||||
node.name = name;
|
||||
}
|
||||
|
|
@ -1609,7 +1609,7 @@ namespace ts {
|
|||
export function createMissingDeclaration(decorators?: Array<Decorator>, modifiers?: Array<Node>, questionToken?: Node,
|
||||
location?: TextRange, flags?: NodeFlags): MissingDeclaration {
|
||||
let node = createNode<MissingDeclaration>(SyntaxKind.MissingDeclaration, location, flags);
|
||||
if (arguments.length) {
|
||||
if (decorators || modifiers || questionToken) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
setModifiers(node, modifiers);
|
||||
node.questionToken = questionToken;
|
||||
|
|
@ -1639,7 +1639,7 @@ namespace ts {
|
|||
export function createJsxElement(openingElement?: JsxOpeningElement, children?: Array<JsxChild>, closingElement?: JsxClosingElement,
|
||||
location?: TextRange, flags?: NodeFlags): JsxElement {
|
||||
let node = createNode<JsxElement>(SyntaxKind.JsxElement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (openingElement || children || closingElement) {
|
||||
node.openingElement = openingElement;
|
||||
node.children = children && createNodeArray(children)
|
||||
node.closingElement = closingElement;
|
||||
|
|
@ -1657,7 +1657,7 @@ namespace ts {
|
|||
export function createJsxSelfClosingElement(tagName?: EntityName, attributes?: Array<JsxAttribute | JsxSpreadAttribute>,
|
||||
location?: TextRange, flags?: NodeFlags): JsxSelfClosingElement {
|
||||
let node = createNode<JsxSelfClosingElement>(SyntaxKind.JsxSelfClosingElement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (tagName || attributes) {
|
||||
node.tagName = tagName;
|
||||
node.attributes = attributes && createNodeArray(attributes)
|
||||
}
|
||||
|
|
@ -1674,7 +1674,7 @@ namespace ts {
|
|||
export function createJsxOpeningElement(tagName?: EntityName, attributes?: Array<JsxAttribute | JsxSpreadAttribute>,
|
||||
location?: TextRange, flags?: NodeFlags): JsxOpeningElement {
|
||||
let node = createNode<JsxOpeningElement>(SyntaxKind.JsxOpeningElement, location, flags);
|
||||
if (arguments.length) {
|
||||
if (tagName || attributes) {
|
||||
node.tagName = tagName;
|
||||
node.attributes = attributes && createNodeArray(attributes)
|
||||
}
|
||||
|
|
@ -1705,7 +1705,7 @@ namespace ts {
|
|||
}
|
||||
export function createJsxAttribute(name?: Identifier, initializer?: Expression, location?: TextRange, flags?: NodeFlags): JsxAttribute {
|
||||
let node = createNode<JsxAttribute>(SyntaxKind.JsxAttribute, location, flags);
|
||||
if (arguments.length) {
|
||||
if (name || initializer) {
|
||||
node.name = name;
|
||||
node.initializer = initializer;
|
||||
}
|
||||
|
|
@ -1745,7 +1745,7 @@ namespace ts {
|
|||
export function createCaseClause(expression?: Expression, statements?: Array<Statement>,
|
||||
location?: TextRange, flags?: NodeFlags): CaseClause {
|
||||
let node = createNode<CaseClause>(SyntaxKind.CaseClause, location, flags);
|
||||
if (arguments.length) {
|
||||
if (expression || statements) {
|
||||
node.expression = expression;
|
||||
node.statements = statements && createNodeArray(statements)
|
||||
}
|
||||
|
|
@ -1773,7 +1773,7 @@ namespace ts {
|
|||
export function createHeritageClause(token?: SyntaxKind, types?: Array<ExpressionWithTypeArguments>,
|
||||
location?: TextRange, flags?: NodeFlags): HeritageClause {
|
||||
let node = createNode<HeritageClause>(SyntaxKind.HeritageClause, location, flags);
|
||||
if (arguments.length) {
|
||||
if (token || types) {
|
||||
node.token = token;
|
||||
node.types = types && createNodeArray(types)
|
||||
}
|
||||
|
|
@ -1789,7 +1789,7 @@ namespace ts {
|
|||
export function createCatchClause(variableDeclaration?: VariableDeclaration, block?: Block,
|
||||
location?: TextRange, flags?: NodeFlags): CatchClause {
|
||||
let node = createNode<CatchClause>(SyntaxKind.CatchClause, location, flags);
|
||||
if (arguments.length) {
|
||||
if (variableDeclaration || block) {
|
||||
node.variableDeclaration = variableDeclaration;
|
||||
node.block = block;
|
||||
}
|
||||
|
|
@ -1805,7 +1805,7 @@ namespace ts {
|
|||
export function createPropertyAssignment(name?: PropertyName, initializer?: Expression,
|
||||
location?: TextRange, flags?: NodeFlags): PropertyAssignment {
|
||||
let node = createNode<PropertyAssignment>(SyntaxKind.PropertyAssignment, location, flags);
|
||||
if (arguments.length) {
|
||||
if (name || initializer) {
|
||||
node.name = name;
|
||||
node.initializer = initializer;
|
||||
}
|
||||
|
|
@ -1832,7 +1832,7 @@ namespace ts {
|
|||
}
|
||||
export function createEnumMember(name?: DeclarationName, initializer?: Expression, location?: TextRange, flags?: NodeFlags): EnumMember {
|
||||
let node = createNode<EnumMember>(SyntaxKind.EnumMember, location, flags);
|
||||
if (arguments.length) {
|
||||
if (name || initializer) {
|
||||
node.name = name;
|
||||
node.initializer = initializer;
|
||||
}
|
||||
|
|
@ -1938,7 +1938,7 @@ namespace ts {
|
|||
export function createJSDocRecordMember(name?: Identifier | LiteralExpression, type?: JSDocType,
|
||||
location?: TextRange, flags?: NodeFlags): JSDocRecordMember {
|
||||
let node = createNode<JSDocRecordMember>(SyntaxKind.JSDocRecordMember, location, flags);
|
||||
if (arguments.length) {
|
||||
if (name || type) {
|
||||
node.name = name;
|
||||
node.type = type;
|
||||
}
|
||||
|
|
@ -1954,7 +1954,7 @@ namespace ts {
|
|||
export function createJSDocTypeReference(name?: EntityName, typeArguments?: Array<JSDocType>,
|
||||
location?: TextRange, flags?: NodeFlags): JSDocTypeReference {
|
||||
let node = createNode<JSDocTypeReference>(SyntaxKind.JSDocTypeReference, location, flags);
|
||||
if (arguments.length) {
|
||||
if (name || typeArguments) {
|
||||
node.name = name;
|
||||
node.typeArguments = typeArguments && createNodeArray(typeArguments)
|
||||
}
|
||||
|
|
@ -1982,7 +1982,7 @@ namespace ts {
|
|||
export function createJSDocFunctionType(parameters?: Array<ParameterDeclaration>, type?: JSDocType,
|
||||
location?: TextRange, flags?: NodeFlags): JSDocFunctionType {
|
||||
let node = createNode<JSDocFunctionType>(SyntaxKind.JSDocFunctionType, location, flags);
|
||||
if (arguments.length) {
|
||||
if (parameters || type) {
|
||||
node.parameters = parameters && createNodeArray(parameters)
|
||||
node.type = type;
|
||||
}
|
||||
|
|
@ -2046,7 +2046,7 @@ namespace ts {
|
|||
}
|
||||
export function createJSDocTag(atToken?: Node, tagName?: Identifier, location?: TextRange, flags?: NodeFlags): JSDocTag {
|
||||
let node = createNode<JSDocTag>(SyntaxKind.JSDocTag, location, flags);
|
||||
if (arguments.length) {
|
||||
if (atToken || tagName) {
|
||||
node.atToken = atToken;
|
||||
node.tagName = tagName;
|
||||
}
|
||||
|
|
@ -2062,7 +2062,7 @@ namespace ts {
|
|||
export function createJSDocParameterTag(preParameterName?: Identifier, typeExpression?: JSDocTypeExpression, postParameterName?: Identifier,
|
||||
atToken?: Node, tagName?: Identifier, location?: TextRange, flags?: NodeFlags): JSDocParameterTag {
|
||||
let node = createNode<JSDocParameterTag>(SyntaxKind.JSDocParameterTag, location, flags);
|
||||
if (arguments.length) {
|
||||
if (preParameterName || typeExpression || postParameterName || atToken || tagName) {
|
||||
node.preParameterName = preParameterName;
|
||||
node.typeExpression = typeExpression;
|
||||
node.postParameterName = postParameterName;
|
||||
|
|
@ -2083,7 +2083,7 @@ namespace ts {
|
|||
export function createJSDocReturnTag(typeExpression?: JSDocTypeExpression, atToken?: Node, tagName?: Identifier,
|
||||
location?: TextRange, flags?: NodeFlags): JSDocReturnTag {
|
||||
let node = createNode<JSDocReturnTag>(SyntaxKind.JSDocReturnTag, location, flags);
|
||||
if (arguments.length) {
|
||||
if (typeExpression || atToken || tagName) {
|
||||
node.typeExpression = typeExpression;
|
||||
node.atToken = atToken;
|
||||
node.tagName = tagName;
|
||||
|
|
@ -2100,7 +2100,7 @@ namespace ts {
|
|||
export function createJSDocTypeTag(typeExpression?: JSDocTypeExpression, atToken?: Node, tagName?: Identifier,
|
||||
location?: TextRange, flags?: NodeFlags): JSDocTypeTag {
|
||||
let node = createNode<JSDocTypeTag>(SyntaxKind.JSDocTypeTag, location, flags);
|
||||
if (arguments.length) {
|
||||
if (typeExpression || atToken || tagName) {
|
||||
node.typeExpression = typeExpression;
|
||||
node.atToken = atToken;
|
||||
node.tagName = tagName;
|
||||
|
|
@ -2117,7 +2117,7 @@ namespace ts {
|
|||
export function createJSDocTemplateTag(typeParameters?: Array<TypeParameterDeclaration>, atToken?: Node, tagName?: Identifier,
|
||||
location?: TextRange, flags?: NodeFlags): JSDocTemplateTag {
|
||||
let node = createNode<JSDocTemplateTag>(SyntaxKind.JSDocTemplateTag, location, flags);
|
||||
if (arguments.length) {
|
||||
if (typeParameters || atToken || tagName) {
|
||||
node.typeParameters = typeParameters && createNodeArray(typeParameters)
|
||||
node.atToken = atToken;
|
||||
node.tagName = tagName;
|
||||
|
|
|
|||
|
|
@ -64,9 +64,11 @@ namespace ts {
|
|||
|
||||
newNode.flags = flags;
|
||||
newNode.original = oldNode;
|
||||
newNode.pos = oldNode.pos;
|
||||
newNode.end = oldNode.end;
|
||||
|
||||
mergeCommentRanges(oldNode, newNode);
|
||||
return setTextRange(newNode, oldNode);
|
||||
//mergeCommentRanges(oldNode, newNode);
|
||||
return newNode;
|
||||
}
|
||||
|
||||
function mergeCommentRanges(oldNode: Node, newNode: Node) {
|
||||
|
|
@ -83,21 +85,33 @@ namespace ts {
|
|||
}
|
||||
|
||||
export function createNode<T extends Node>(kind: SyntaxKind, location?: TextRange, flags?: NodeFlags): T {
|
||||
return setNodeFlags(setTextRange(<T>new (getNodeConstructor(kind))(), location), flags);
|
||||
let node = <T>new (getNodeConstructor(kind))();
|
||||
if (location) {
|
||||
node.pos = location.pos;
|
||||
node.end = location.end;
|
||||
}
|
||||
if (flags) {
|
||||
node.flags = flags;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
export function createNodeArray<T extends Node>(elements?: T[], location?: TextRange) {
|
||||
let nodes = <NodeArray<T>>(elements || []);
|
||||
if (nodes.pos === undefined) {
|
||||
if (location) {
|
||||
nodes.pos = location.pos;
|
||||
nodes.end = location.end;
|
||||
}
|
||||
else if (nodes.pos === undefined) {
|
||||
nodes.pos = -1;
|
||||
nodes.end = -1;
|
||||
}
|
||||
|
||||
return setTextRange(nodes, location);
|
||||
return nodes;
|
||||
}
|
||||
|
||||
export function createModifiersArray(elements?: Node[], location?: TextRange) {
|
||||
let modifiers = <ModifiersArray>(elements || []);
|
||||
let modifiers = <ModifiersArray>createNodeArray(elements || [], location);
|
||||
if (modifiers.flags === undefined) {
|
||||
let flags = 0;
|
||||
for (let modifier of modifiers) {
|
||||
|
|
@ -107,7 +121,7 @@ namespace ts {
|
|||
modifiers.flags = flags;
|
||||
}
|
||||
|
||||
return setTextRange(modifiers, location);
|
||||
return modifiers;
|
||||
}
|
||||
|
||||
export function createSourceFile(): SourceFile {
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -713,6 +713,10 @@ namespace ts {
|
|||
options.target !== ScriptTarget.ES6) {
|
||||
diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_experimentalAsyncFunctions_cannot_be_specified_when_targeting_ES5_or_lower));
|
||||
}
|
||||
|
||||
if (FORCE_TRANSFORMS) {
|
||||
options.experimentalTransforms = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
/// <reference path="transform.ts" />
|
||||
/* @internal */
|
||||
namespace ts.transform {
|
||||
export function accept(context: VisitorContext, node: Node, visitor: Visitor, write: (node: Node) => void): void {
|
||||
export function accept(node: Node, visitor: (input: Node, write: (node: Node) => void) => void, write: (node: Node) => void): void {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -11,684 +11,684 @@ namespace ts.transform {
|
|||
case SyntaxKind.QualifiedName:
|
||||
return write(factory.updateQualifiedName(
|
||||
<QualifiedName>node,
|
||||
<EntityName>visitNode(context, (<QualifiedName>node).left, visitor),
|
||||
<Identifier>visitNode(context, (<QualifiedName>node).right, visitor)));
|
||||
<EntityName>visitNode((<QualifiedName>node).left, visitor),
|
||||
<Identifier>visitNode((<QualifiedName>node).right, visitor)));
|
||||
case SyntaxKind.ComputedPropertyName:
|
||||
return write(factory.updateComputedPropertyName(
|
||||
<ComputedPropertyName>node,
|
||||
<Expression>visitNode(context, (<ComputedPropertyName>node).expression, visitor)));
|
||||
<Expression>visitNode((<ComputedPropertyName>node).expression, visitor)));
|
||||
case SyntaxKind.TypeParameter:
|
||||
return write(factory.updateTypeParameter(
|
||||
<TypeParameterDeclaration>node,
|
||||
<Identifier>visitNode(context, (<TypeParameterDeclaration>node).name, visitor),
|
||||
<TypeNode>visitNode(context, (<TypeParameterDeclaration>node).constraint, visitor),
|
||||
<Expression>visitNode(context, (<TypeParameterDeclaration>node).expression, visitor)));
|
||||
<Identifier>visitNode((<TypeParameterDeclaration>node).name, visitor),
|
||||
<TypeNode>visitNode((<TypeParameterDeclaration>node).constraint, visitor),
|
||||
<Expression>visitNode((<TypeParameterDeclaration>node).expression, visitor)));
|
||||
case SyntaxKind.Parameter:
|
||||
return write(factory.updateParameter(
|
||||
<ParameterDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ParameterDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ParameterDeclaration>node).modifiers, visitor),
|
||||
<BindingPattern | Identifier>visitNode(context, (<ParameterDeclaration>node).name, visitor),
|
||||
<NodeArray<Decorator>>visitNodes((<ParameterDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ParameterDeclaration>node).modifiers, visitor),
|
||||
<BindingPattern | Identifier>visitNode((<ParameterDeclaration>node).name, visitor),
|
||||
(<ParameterDeclaration>node).questionToken,
|
||||
<TypeNode>visitNode(context, (<ParameterDeclaration>node).type, visitor),
|
||||
<Expression>visitNode(context, (<ParameterDeclaration>node).initializer, visitor)));
|
||||
<TypeNode>visitNode((<ParameterDeclaration>node).type, visitor),
|
||||
<Expression>visitNode((<ParameterDeclaration>node).initializer, visitor)));
|
||||
case SyntaxKind.Decorator:
|
||||
return write(factory.updateDecorator(
|
||||
<Decorator>node,
|
||||
<LeftHandSideExpression>visitNode(context, (<Decorator>node).expression, visitor)));
|
||||
<LeftHandSideExpression>visitNode((<Decorator>node).expression, visitor)));
|
||||
case SyntaxKind.PropertySignature:
|
||||
return write(factory.updatePropertySignature(
|
||||
<PropertySignature>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<PropertySignature>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<PropertySignature>node).modifiers, visitor),
|
||||
<PropertyName>visitNode(context, (<PropertySignature>node).name, visitor),
|
||||
<TypeNode>visitNode(context, (<PropertySignature>node).type, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<PropertySignature>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<PropertySignature>node).modifiers, visitor),
|
||||
<PropertyName>visitNode((<PropertySignature>node).name, visitor),
|
||||
<TypeNode>visitNode((<PropertySignature>node).type, visitor)));
|
||||
case SyntaxKind.PropertyDeclaration:
|
||||
return write(factory.updatePropertyDeclaration(
|
||||
<PropertyDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<PropertyDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<PropertyDeclaration>node).modifiers, visitor),
|
||||
<PropertyName>visitNode(context, (<PropertyDeclaration>node).name, visitor),
|
||||
<TypeNode>visitNode(context, (<PropertyDeclaration>node).type, visitor),
|
||||
<Expression>visitNode(context, (<PropertyDeclaration>node).initializer, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<PropertyDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<PropertyDeclaration>node).modifiers, visitor),
|
||||
<PropertyName>visitNode((<PropertyDeclaration>node).name, visitor),
|
||||
<TypeNode>visitNode((<PropertyDeclaration>node).type, visitor),
|
||||
<Expression>visitNode((<PropertyDeclaration>node).initializer, visitor)));
|
||||
case SyntaxKind.MethodSignature:
|
||||
return write(factory.updateMethodSignature(
|
||||
<MethodSignature>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<MethodSignature>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<MethodSignature>node).modifiers, visitor),
|
||||
<PropertyName>visitNode(context, (<MethodSignature>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<MethodSignature>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<MethodSignature>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<MethodSignature>node).type, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<MethodSignature>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<MethodSignature>node).modifiers, visitor),
|
||||
<PropertyName>visitNode((<MethodSignature>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<MethodSignature>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<MethodSignature>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<MethodSignature>node).type, visitor)));
|
||||
case SyntaxKind.MethodDeclaration:
|
||||
return write(factory.updateMethodDeclaration(
|
||||
<MethodDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<MethodDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<MethodDeclaration>node).modifiers, visitor),
|
||||
<PropertyName>visitNode(context, (<MethodDeclaration>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<MethodDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<MethodDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<MethodDeclaration>node).type, visitor),
|
||||
<Block>visitNode(context, (<MethodDeclaration>node).body, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<MethodDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<MethodDeclaration>node).modifiers, visitor),
|
||||
<PropertyName>visitNode((<MethodDeclaration>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<MethodDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<MethodDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<MethodDeclaration>node).type, visitor),
|
||||
<Block>visitNewLexicalEnvironment((<MethodDeclaration>node).body, visitor)));
|
||||
case SyntaxKind.Constructor:
|
||||
return write(factory.updateConstructor(
|
||||
<ConstructorDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ConstructorDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ConstructorDeclaration>node).modifiers, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<ConstructorDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<ConstructorDeclaration>node).type, visitor),
|
||||
<Block>visitNode(context, (<ConstructorDeclaration>node).body, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<ConstructorDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ConstructorDeclaration>node).modifiers, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<ConstructorDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<ConstructorDeclaration>node).type, visitor),
|
||||
<Block>visitNewLexicalEnvironment((<ConstructorDeclaration>node).body, visitor)));
|
||||
case SyntaxKind.GetAccessor:
|
||||
return write(factory.updateGetAccessor(
|
||||
<GetAccessorDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<GetAccessorDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<GetAccessorDeclaration>node).modifiers, visitor),
|
||||
<PropertyName>visitNode(context, (<GetAccessorDeclaration>node).name, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<GetAccessorDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<GetAccessorDeclaration>node).type, visitor),
|
||||
visitBlockInNewLexicalEnvironment(context, (<GetAccessorDeclaration>node).body, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<GetAccessorDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<GetAccessorDeclaration>node).modifiers, visitor),
|
||||
<PropertyName>visitNode((<GetAccessorDeclaration>node).name, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<GetAccessorDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<GetAccessorDeclaration>node).type, visitor),
|
||||
<Block>visitNewLexicalEnvironment((<GetAccessorDeclaration>node).body, visitor)));
|
||||
case SyntaxKind.SetAccessor:
|
||||
return write(factory.updateSetAccessor(
|
||||
<SetAccessorDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<SetAccessorDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<SetAccessorDeclaration>node).modifiers, visitor),
|
||||
<PropertyName>visitNode(context, (<SetAccessorDeclaration>node).name, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<SetAccessorDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<SetAccessorDeclaration>node).type, visitor),
|
||||
visitBlockInNewLexicalEnvironment(context, (<SetAccessorDeclaration>node).body, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<SetAccessorDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<SetAccessorDeclaration>node).modifiers, visitor),
|
||||
<PropertyName>visitNode((<SetAccessorDeclaration>node).name, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<SetAccessorDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<SetAccessorDeclaration>node).type, visitor),
|
||||
<Block>visitNewLexicalEnvironment((<SetAccessorDeclaration>node).body, visitor)));
|
||||
case SyntaxKind.CallSignature:
|
||||
return write(factory.updateCallSignature(
|
||||
<CallSignatureDeclaration>node,
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<CallSignatureDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<CallSignatureDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<CallSignatureDeclaration>node).type, visitor)));
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<CallSignatureDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<CallSignatureDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<CallSignatureDeclaration>node).type, visitor)));
|
||||
case SyntaxKind.ConstructSignature:
|
||||
return write(factory.updateConstructSignature(
|
||||
<ConstructSignatureDeclaration>node,
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<ConstructSignatureDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<ConstructSignatureDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<ConstructSignatureDeclaration>node).type, visitor)));
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<ConstructSignatureDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<ConstructSignatureDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<ConstructSignatureDeclaration>node).type, visitor)));
|
||||
case SyntaxKind.IndexSignature:
|
||||
return write(factory.updateIndexSignature(
|
||||
<IndexSignatureDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<IndexSignatureDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<IndexSignatureDeclaration>node).modifiers, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<IndexSignatureDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<IndexSignatureDeclaration>node).type, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<IndexSignatureDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<IndexSignatureDeclaration>node).modifiers, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<IndexSignatureDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<IndexSignatureDeclaration>node).type, visitor)));
|
||||
case SyntaxKind.TypePredicate:
|
||||
return write(factory.updateTypePredicate(
|
||||
<TypePredicateNode>node,
|
||||
<Identifier>visitNode(context, (<TypePredicateNode>node).parameterName, visitor),
|
||||
<TypeNode>visitNode(context, (<TypePredicateNode>node).type, visitor)));
|
||||
<Identifier>visitNode((<TypePredicateNode>node).parameterName, visitor),
|
||||
<TypeNode>visitNode((<TypePredicateNode>node).type, visitor)));
|
||||
case SyntaxKind.TypeReference:
|
||||
return write(factory.updateTypeReference(
|
||||
<TypeReferenceNode>node,
|
||||
<EntityName>visitNode(context, (<TypeReferenceNode>node).typeName, visitor),
|
||||
<NodeArray<TypeNode>>visitNodes(context, (<TypeReferenceNode>node).typeArguments, visitor)));
|
||||
<EntityName>visitNode((<TypeReferenceNode>node).typeName, visitor),
|
||||
<NodeArray<TypeNode>>visitNodes((<TypeReferenceNode>node).typeArguments, visitor)));
|
||||
case SyntaxKind.FunctionType:
|
||||
return write(factory.updateFunctionType(
|
||||
<FunctionTypeNode>node,
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<FunctionTypeNode>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<FunctionTypeNode>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<FunctionTypeNode>node).type, visitor)));
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<FunctionTypeNode>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<FunctionTypeNode>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<FunctionTypeNode>node).type, visitor)));
|
||||
case SyntaxKind.ConstructorType:
|
||||
return write(factory.updateConstructorType(
|
||||
<ConstructorTypeNode>node,
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<ConstructorTypeNode>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<ConstructorTypeNode>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<ConstructorTypeNode>node).type, visitor)));
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<ConstructorTypeNode>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<ConstructorTypeNode>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<ConstructorTypeNode>node).type, visitor)));
|
||||
case SyntaxKind.TypeQuery:
|
||||
return write(factory.updateTypeQuery(
|
||||
<TypeQueryNode>node,
|
||||
<EntityName>visitNode(context, (<TypeQueryNode>node).exprName, visitor)));
|
||||
<EntityName>visitNode((<TypeQueryNode>node).exprName, visitor)));
|
||||
case SyntaxKind.TypeLiteral:
|
||||
return write(factory.updateTypeLiteral(
|
||||
<TypeLiteralNode>node,
|
||||
<NodeArray<TypeElement>>visitNodes(context, (<TypeLiteralNode>node).members, visitor)));
|
||||
<NodeArray<TypeElement>>visitNodes((<TypeLiteralNode>node).members, visitor)));
|
||||
case SyntaxKind.ArrayType:
|
||||
return write(factory.updateArrayType(
|
||||
<ArrayTypeNode>node,
|
||||
<TypeNode>visitNode(context, (<ArrayTypeNode>node).elementType, visitor)));
|
||||
<TypeNode>visitNode((<ArrayTypeNode>node).elementType, visitor)));
|
||||
case SyntaxKind.TupleType:
|
||||
return write(factory.updateTupleType(
|
||||
<TupleTypeNode>node,
|
||||
<NodeArray<TypeNode>>visitNodes(context, (<TupleTypeNode>node).elementTypes, visitor)));
|
||||
<NodeArray<TypeNode>>visitNodes((<TupleTypeNode>node).elementTypes, visitor)));
|
||||
case SyntaxKind.UnionType:
|
||||
return write(factory.updateUnionType(
|
||||
<UnionTypeNode>node,
|
||||
<NodeArray<TypeNode>>visitNodes(context, (<UnionTypeNode>node).types, visitor)));
|
||||
<NodeArray<TypeNode>>visitNodes((<UnionTypeNode>node).types, visitor)));
|
||||
case SyntaxKind.IntersectionType:
|
||||
return write(factory.updateIntersectionType(
|
||||
<IntersectionTypeNode>node,
|
||||
<NodeArray<TypeNode>>visitNodes(context, (<IntersectionTypeNode>node).types, visitor)));
|
||||
<NodeArray<TypeNode>>visitNodes((<IntersectionTypeNode>node).types, visitor)));
|
||||
case SyntaxKind.ParenthesizedType:
|
||||
return write(factory.updateParenthesizedType(
|
||||
<ParenthesizedTypeNode>node,
|
||||
<TypeNode>visitNode(context, (<ParenthesizedTypeNode>node).type, visitor)));
|
||||
<TypeNode>visitNode((<ParenthesizedTypeNode>node).type, visitor)));
|
||||
case SyntaxKind.ObjectBindingPattern:
|
||||
return write(factory.updateObjectBindingPattern(
|
||||
<ObjectBindingPattern>node,
|
||||
<NodeArray<BindingElement>>visitNodes(context, (<ObjectBindingPattern>node).elements, visitor)));
|
||||
<NodeArray<BindingElement>>visitNodes((<ObjectBindingPattern>node).elements, visitor)));
|
||||
case SyntaxKind.ArrayBindingPattern:
|
||||
return write(factory.updateArrayBindingPattern(
|
||||
<ArrayBindingPattern>node,
|
||||
<NodeArray<BindingElement>>visitNodes(context, (<ArrayBindingPattern>node).elements, visitor)));
|
||||
<NodeArray<BindingElement>>visitNodes((<ArrayBindingPattern>node).elements, visitor)));
|
||||
case SyntaxKind.BindingElement:
|
||||
return write(factory.updateBindingElement(
|
||||
<BindingElement>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<BindingElement>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<BindingElement>node).modifiers, visitor),
|
||||
<Identifier>visitNode(context, (<BindingElement>node).propertyName, visitor),
|
||||
<BindingPattern | Identifier>visitNode(context, (<BindingElement>node).name, visitor),
|
||||
<Expression>visitNode(context, (<BindingElement>node).initializer, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<BindingElement>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<BindingElement>node).modifiers, visitor),
|
||||
<Identifier>visitNode((<BindingElement>node).propertyName, visitor),
|
||||
<BindingPattern | Identifier>visitNode((<BindingElement>node).name, visitor),
|
||||
<Expression>visitNode((<BindingElement>node).initializer, visitor)));
|
||||
case SyntaxKind.ArrayLiteralExpression:
|
||||
return write(factory.updateArrayLiteralExpression(
|
||||
<ArrayLiteralExpression>node,
|
||||
<NodeArray<Expression>>visitNodes(context, (<ArrayLiteralExpression>node).elements, visitor)));
|
||||
<NodeArray<Expression>>visitNodes((<ArrayLiteralExpression>node).elements, visitor)));
|
||||
case SyntaxKind.ObjectLiteralExpression:
|
||||
return write(factory.updateObjectLiteralExpression(
|
||||
<ObjectLiteralExpression>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ObjectLiteralExpression>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ObjectLiteralExpression>node).modifiers, visitor),
|
||||
<NodeArray<ObjectLiteralElement>>visitNodes(context, (<ObjectLiteralExpression>node).properties, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<ObjectLiteralExpression>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ObjectLiteralExpression>node).modifiers, visitor),
|
||||
<NodeArray<ObjectLiteralElement>>visitNodes((<ObjectLiteralExpression>node).properties, visitor)));
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
return write(factory.updatePropertyAccessExpression(
|
||||
<PropertyAccessExpression>node,
|
||||
<LeftHandSideExpression>visitNode(context, (<PropertyAccessExpression>node).expression, visitor),
|
||||
<Identifier>visitNode(context, (<PropertyAccessExpression>node).name, visitor)));
|
||||
<LeftHandSideExpression>visitNode((<PropertyAccessExpression>node).expression, visitor),
|
||||
<Identifier>visitNode((<PropertyAccessExpression>node).name, visitor)));
|
||||
case SyntaxKind.ElementAccessExpression:
|
||||
return write(factory.updateElementAccessExpression(
|
||||
<ElementAccessExpression>node,
|
||||
<LeftHandSideExpression>visitNode(context, (<ElementAccessExpression>node).expression, visitor),
|
||||
<Expression>visitNode(context, (<ElementAccessExpression>node).argumentExpression, visitor)));
|
||||
<LeftHandSideExpression>visitNode((<ElementAccessExpression>node).expression, visitor),
|
||||
<Expression>visitNode((<ElementAccessExpression>node).argumentExpression, visitor)));
|
||||
case SyntaxKind.CallExpression:
|
||||
return write(factory.updateCallExpression(
|
||||
<CallExpression>node,
|
||||
<LeftHandSideExpression>visitNode(context, (<CallExpression>node).expression, visitor),
|
||||
<NodeArray<TypeNode>>visitNodes(context, (<CallExpression>node).typeArguments, visitor),
|
||||
<NodeArray<Expression>>visitNodes(context, (<CallExpression>node).arguments, visitor)));
|
||||
<LeftHandSideExpression>visitNode((<CallExpression>node).expression, visitor),
|
||||
<NodeArray<TypeNode>>visitNodes((<CallExpression>node).typeArguments, visitor),
|
||||
<NodeArray<Expression>>visitNodes((<CallExpression>node).arguments, visitor)));
|
||||
case SyntaxKind.NewExpression:
|
||||
return write(factory.updateNewExpression(
|
||||
<NewExpression>node,
|
||||
<LeftHandSideExpression>visitNode(context, (<NewExpression>node).expression, visitor),
|
||||
<NodeArray<TypeNode>>visitNodes(context, (<NewExpression>node).typeArguments, visitor),
|
||||
<NodeArray<Expression>>visitNodes(context, (<NewExpression>node).arguments, visitor)));
|
||||
<LeftHandSideExpression>visitNode((<NewExpression>node).expression, visitor),
|
||||
<NodeArray<TypeNode>>visitNodes((<NewExpression>node).typeArguments, visitor),
|
||||
<NodeArray<Expression>>visitNodes((<NewExpression>node).arguments, visitor)));
|
||||
case SyntaxKind.TaggedTemplateExpression:
|
||||
return write(factory.updateTaggedTemplateExpression(
|
||||
<TaggedTemplateExpression>node,
|
||||
<LeftHandSideExpression>visitNode(context, (<TaggedTemplateExpression>node).tag, visitor),
|
||||
<LiteralExpression | TemplateExpression>visitNode(context, (<TaggedTemplateExpression>node).template, visitor)));
|
||||
<LeftHandSideExpression>visitNode((<TaggedTemplateExpression>node).tag, visitor),
|
||||
<LiteralExpression | TemplateExpression>visitNode((<TaggedTemplateExpression>node).template, visitor)));
|
||||
case SyntaxKind.TypeAssertionExpression:
|
||||
return write(factory.updateTypeAssertionExpression(
|
||||
<TypeAssertion>node,
|
||||
<TypeNode>visitNode(context, (<TypeAssertion>node).type, visitor),
|
||||
<UnaryExpression>visitNode(context, (<TypeAssertion>node).expression, visitor)));
|
||||
<TypeNode>visitNode((<TypeAssertion>node).type, visitor),
|
||||
<UnaryExpression>visitNode((<TypeAssertion>node).expression, visitor)));
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
return write(factory.updateParenthesizedExpression(
|
||||
<ParenthesizedExpression>node,
|
||||
<Expression>visitNode(context, (<ParenthesizedExpression>node).expression, visitor)));
|
||||
<Expression>visitNode((<ParenthesizedExpression>node).expression, visitor)));
|
||||
case SyntaxKind.FunctionExpression:
|
||||
return write(factory.updateFunctionExpression(
|
||||
<FunctionExpression>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<FunctionExpression>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<FunctionExpression>node).modifiers, visitor),
|
||||
<Identifier>visitNode(context, (<FunctionExpression>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<FunctionExpression>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<FunctionExpression>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<FunctionExpression>node).type, visitor),
|
||||
visitBlockOrExpressionInNewLexicalEnvironment(context, (<FunctionExpression>node).body, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<FunctionExpression>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<FunctionExpression>node).modifiers, visitor),
|
||||
<Identifier>visitNode((<FunctionExpression>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<FunctionExpression>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<FunctionExpression>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<FunctionExpression>node).type, visitor),
|
||||
<Block | Expression>visitNewLexicalEnvironment((<FunctionExpression>node).body, visitor)));
|
||||
case SyntaxKind.ArrowFunction:
|
||||
return write(factory.updateArrowFunction(
|
||||
<ArrowFunction>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ArrowFunction>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ArrowFunction>node).modifiers, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<ArrowFunction>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<ArrowFunction>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<ArrowFunction>node).type, visitor),
|
||||
visitBlockOrExpressionInNewLexicalEnvironment(context, (<ArrowFunction>node).body, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<ArrowFunction>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ArrowFunction>node).modifiers, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<ArrowFunction>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<ArrowFunction>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<ArrowFunction>node).type, visitor),
|
||||
<Block | Expression>visitNewLexicalEnvironment((<ArrowFunction>node).body, visitor)));
|
||||
case SyntaxKind.DeleteExpression:
|
||||
return write(factory.updateDeleteExpression(
|
||||
<DeleteExpression>node,
|
||||
<UnaryExpression>visitNode(context, (<DeleteExpression>node).expression, visitor)));
|
||||
<UnaryExpression>visitNode((<DeleteExpression>node).expression, visitor)));
|
||||
case SyntaxKind.TypeOfExpression:
|
||||
return write(factory.updateTypeOfExpression(
|
||||
<TypeOfExpression>node,
|
||||
<UnaryExpression>visitNode(context, (<TypeOfExpression>node).expression, visitor)));
|
||||
<UnaryExpression>visitNode((<TypeOfExpression>node).expression, visitor)));
|
||||
case SyntaxKind.VoidExpression:
|
||||
return write(factory.updateVoidExpression(
|
||||
<VoidExpression>node,
|
||||
<UnaryExpression>visitNode(context, (<VoidExpression>node).expression, visitor)));
|
||||
<UnaryExpression>visitNode((<VoidExpression>node).expression, visitor)));
|
||||
case SyntaxKind.AwaitExpression:
|
||||
return write(factory.updateAwaitExpression(
|
||||
<AwaitExpression>node,
|
||||
<UnaryExpression>visitNode(context, (<AwaitExpression>node).expression, visitor)));
|
||||
<UnaryExpression>visitNode((<AwaitExpression>node).expression, visitor)));
|
||||
case SyntaxKind.PrefixUnaryExpression:
|
||||
return write(factory.updatePrefixUnaryExpression(
|
||||
<PrefixUnaryExpression>node,
|
||||
<UnaryExpression>visitNode(context, (<PrefixUnaryExpression>node).operand, visitor)));
|
||||
<UnaryExpression>visitNode((<PrefixUnaryExpression>node).operand, visitor)));
|
||||
case SyntaxKind.PostfixUnaryExpression:
|
||||
return write(factory.updatePostfixUnaryExpression(
|
||||
<PostfixUnaryExpression>node,
|
||||
<LeftHandSideExpression>visitNode(context, (<PostfixUnaryExpression>node).operand, visitor)));
|
||||
<LeftHandSideExpression>visitNode((<PostfixUnaryExpression>node).operand, visitor)));
|
||||
case SyntaxKind.BinaryExpression:
|
||||
return write(factory.updateBinaryExpression(
|
||||
<BinaryExpression>node,
|
||||
<Expression>visitNode(context, (<BinaryExpression>node).left, visitor),
|
||||
<Expression>visitNode(context, (<BinaryExpression>node).right, visitor)));
|
||||
<Expression>visitNode((<BinaryExpression>node).left, visitor),
|
||||
<Expression>visitNode((<BinaryExpression>node).right, visitor)));
|
||||
case SyntaxKind.ConditionalExpression:
|
||||
return write(factory.updateConditionalExpression(
|
||||
<ConditionalExpression>node,
|
||||
<Expression>visitNode(context, (<ConditionalExpression>node).condition, visitor),
|
||||
<Expression>visitNode(context, (<ConditionalExpression>node).whenTrue, visitor),
|
||||
<Expression>visitNode(context, (<ConditionalExpression>node).whenFalse, visitor)));
|
||||
<Expression>visitNode((<ConditionalExpression>node).condition, visitor),
|
||||
<Expression>visitNode((<ConditionalExpression>node).whenTrue, visitor),
|
||||
<Expression>visitNode((<ConditionalExpression>node).whenFalse, visitor)));
|
||||
case SyntaxKind.TemplateExpression:
|
||||
return write(factory.updateTemplateExpression(
|
||||
<TemplateExpression>node,
|
||||
<LiteralExpression>visitNode(context, (<TemplateExpression>node).head, visitor),
|
||||
<NodeArray<TemplateSpan>>visitNodes(context, (<TemplateExpression>node).templateSpans, visitor)));
|
||||
<LiteralExpression>visitNode((<TemplateExpression>node).head, visitor),
|
||||
<NodeArray<TemplateSpan>>visitNodes((<TemplateExpression>node).templateSpans, visitor)));
|
||||
case SyntaxKind.YieldExpression:
|
||||
return write(factory.updateYieldExpression(
|
||||
<YieldExpression>node,
|
||||
<Expression>visitNode(context, (<YieldExpression>node).expression, visitor)));
|
||||
<Expression>visitNode((<YieldExpression>node).expression, visitor)));
|
||||
case SyntaxKind.SpreadElementExpression:
|
||||
return write(factory.updateSpreadElementExpression(
|
||||
<SpreadElementExpression>node,
|
||||
<Expression>visitNode(context, (<SpreadElementExpression>node).expression, visitor)));
|
||||
<Expression>visitNode((<SpreadElementExpression>node).expression, visitor)));
|
||||
case SyntaxKind.ClassExpression:
|
||||
return write(factory.updateClassExpression(
|
||||
<ClassExpression>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ClassExpression>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ClassExpression>node).modifiers, visitor),
|
||||
<Identifier>visitNode(context, (<ClassExpression>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<ClassExpression>node).typeParameters, visitor),
|
||||
<NodeArray<HeritageClause>>visitNodes(context, (<ClassExpression>node).heritageClauses, visitor),
|
||||
<NodeArray<ClassElement>>visitNodes(context, (<ClassExpression>node).members, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<ClassExpression>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ClassExpression>node).modifiers, visitor),
|
||||
<Identifier>visitNode((<ClassExpression>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<ClassExpression>node).typeParameters, visitor),
|
||||
<NodeArray<HeritageClause>>visitNodes((<ClassExpression>node).heritageClauses, visitor),
|
||||
<NodeArray<ClassElement>>visitNodes((<ClassExpression>node).members, visitor)));
|
||||
case SyntaxKind.ExpressionWithTypeArguments:
|
||||
return write(factory.updateExpressionWithTypeArguments(
|
||||
<ExpressionWithTypeArguments>node,
|
||||
<LeftHandSideExpression>visitNode(context, (<ExpressionWithTypeArguments>node).expression, visitor),
|
||||
<NodeArray<TypeNode>>visitNodes(context, (<ExpressionWithTypeArguments>node).typeArguments, visitor)));
|
||||
<LeftHandSideExpression>visitNode((<ExpressionWithTypeArguments>node).expression, visitor),
|
||||
<NodeArray<TypeNode>>visitNodes((<ExpressionWithTypeArguments>node).typeArguments, visitor)));
|
||||
case SyntaxKind.AsExpression:
|
||||
return write(factory.updateAsExpression(
|
||||
<AsExpression>node,
|
||||
<Expression>visitNode(context, (<AsExpression>node).expression, visitor),
|
||||
<TypeNode>visitNode(context, (<AsExpression>node).type, visitor)));
|
||||
<Expression>visitNode((<AsExpression>node).expression, visitor),
|
||||
<TypeNode>visitNode((<AsExpression>node).type, visitor)));
|
||||
case SyntaxKind.TemplateSpan:
|
||||
return write(factory.updateTemplateSpan(
|
||||
<TemplateSpan>node,
|
||||
<Expression>visitNode(context, (<TemplateSpan>node).expression, visitor),
|
||||
<LiteralExpression>visitNode(context, (<TemplateSpan>node).literal, visitor)));
|
||||
<Expression>visitNode((<TemplateSpan>node).expression, visitor),
|
||||
<LiteralExpression>visitNode((<TemplateSpan>node).literal, visitor)));
|
||||
case SyntaxKind.Block:
|
||||
return write(factory.updateBlock(
|
||||
<Block>node,
|
||||
<NodeArray<Statement>>visitNodes(context, (<Block>node).statements, visitor)));
|
||||
<NodeArray<Statement>>visitNodes((<Block>node).statements, visitor)));
|
||||
case SyntaxKind.VariableStatement:
|
||||
return write(factory.updateVariableStatement(
|
||||
<VariableStatement>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<VariableStatement>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<VariableStatement>node).modifiers, visitor),
|
||||
<VariableDeclarationList>visitNode(context, (<VariableStatement>node).declarationList, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<VariableStatement>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<VariableStatement>node).modifiers, visitor),
|
||||
<VariableDeclarationList>visitNode((<VariableStatement>node).declarationList, visitor)));
|
||||
case SyntaxKind.ExpressionStatement:
|
||||
return write(factory.updateExpressionStatement(
|
||||
<ExpressionStatement>node,
|
||||
<Expression>visitNode(context, (<ExpressionStatement>node).expression, visitor)));
|
||||
<Expression>visitNode((<ExpressionStatement>node).expression, visitor)));
|
||||
case SyntaxKind.IfStatement:
|
||||
return write(factory.updateIfStatement(
|
||||
<IfStatement>node,
|
||||
<Expression>visitNode(context, (<IfStatement>node).expression, visitor),
|
||||
visitStatement(context, (<IfStatement>node).thenStatement, visitor),
|
||||
visitStatement(context, (<IfStatement>node).elseStatement, visitor)));
|
||||
<Expression>visitNode((<IfStatement>node).expression, visitor),
|
||||
visitStatement((<IfStatement>node).thenStatement, visitor),
|
||||
visitStatement((<IfStatement>node).elseStatement, visitor)));
|
||||
case SyntaxKind.DoStatement:
|
||||
return write(factory.updateDoStatement(
|
||||
<DoStatement>node,
|
||||
visitStatement(context, (<DoStatement>node).statement, visitor),
|
||||
<Expression>visitNode(context, (<DoStatement>node).expression, visitor)));
|
||||
visitStatement((<DoStatement>node).statement, visitor),
|
||||
<Expression>visitNode((<DoStatement>node).expression, visitor)));
|
||||
case SyntaxKind.WhileStatement:
|
||||
return write(factory.updateWhileStatement(
|
||||
<WhileStatement>node,
|
||||
<Expression>visitNode(context, (<WhileStatement>node).expression, visitor),
|
||||
visitStatement(context, (<WhileStatement>node).statement, visitor)));
|
||||
<Expression>visitNode((<WhileStatement>node).expression, visitor),
|
||||
visitStatement((<WhileStatement>node).statement, visitor)));
|
||||
case SyntaxKind.ForStatement:
|
||||
return write(factory.updateForStatement(
|
||||
<ForStatement>node,
|
||||
<Expression | VariableDeclarationList>visitNode(context, (<ForStatement>node).initializer, visitor),
|
||||
<Expression>visitNode(context, (<ForStatement>node).condition, visitor),
|
||||
<Expression>visitNode(context, (<ForStatement>node).incrementor, visitor),
|
||||
visitStatement(context, (<ForStatement>node).statement, visitor)));
|
||||
<Expression | VariableDeclarationList>visitNode((<ForStatement>node).initializer, visitor),
|
||||
<Expression>visitNode((<ForStatement>node).condition, visitor),
|
||||
<Expression>visitNode((<ForStatement>node).incrementor, visitor),
|
||||
visitStatement((<ForStatement>node).statement, visitor)));
|
||||
case SyntaxKind.ForInStatement:
|
||||
return write(factory.updateForInStatement(
|
||||
<ForInStatement>node,
|
||||
<Expression | VariableDeclarationList>visitNode(context, (<ForInStatement>node).initializer, visitor),
|
||||
<Expression>visitNode(context, (<ForInStatement>node).expression, visitor),
|
||||
visitStatement(context, (<ForInStatement>node).statement, visitor)));
|
||||
<Expression | VariableDeclarationList>visitNode((<ForInStatement>node).initializer, visitor),
|
||||
<Expression>visitNode((<ForInStatement>node).expression, visitor),
|
||||
visitStatement((<ForInStatement>node).statement, visitor)));
|
||||
case SyntaxKind.ForOfStatement:
|
||||
return write(factory.updateForOfStatement(
|
||||
<ForOfStatement>node,
|
||||
<Expression | VariableDeclarationList>visitNode(context, (<ForOfStatement>node).initializer, visitor),
|
||||
<Expression>visitNode(context, (<ForOfStatement>node).expression, visitor),
|
||||
visitStatement(context, (<ForOfStatement>node).statement, visitor)));
|
||||
<Expression | VariableDeclarationList>visitNode((<ForOfStatement>node).initializer, visitor),
|
||||
<Expression>visitNode((<ForOfStatement>node).expression, visitor),
|
||||
visitStatement((<ForOfStatement>node).statement, visitor)));
|
||||
case SyntaxKind.ContinueStatement:
|
||||
return write(factory.updateContinueStatement(
|
||||
<ContinueStatement>node,
|
||||
<Identifier>visitNode(context, (<ContinueStatement>node).label, visitor)));
|
||||
<Identifier>visitNode((<ContinueStatement>node).label, visitor)));
|
||||
case SyntaxKind.BreakStatement:
|
||||
return write(factory.updateBreakStatement(
|
||||
<BreakStatement>node,
|
||||
<Identifier>visitNode(context, (<BreakStatement>node).label, visitor)));
|
||||
<Identifier>visitNode((<BreakStatement>node).label, visitor)));
|
||||
case SyntaxKind.ReturnStatement:
|
||||
return write(factory.updateReturnStatement(
|
||||
<ReturnStatement>node,
|
||||
<Expression>visitNode(context, (<ReturnStatement>node).expression, visitor)));
|
||||
<Expression>visitNode((<ReturnStatement>node).expression, visitor)));
|
||||
case SyntaxKind.WithStatement:
|
||||
return write(factory.updateWithStatement(
|
||||
<WithStatement>node,
|
||||
<Expression>visitNode(context, (<WithStatement>node).expression, visitor),
|
||||
visitStatement(context, (<WithStatement>node).statement, visitor)));
|
||||
<Expression>visitNode((<WithStatement>node).expression, visitor),
|
||||
visitStatement((<WithStatement>node).statement, visitor)));
|
||||
case SyntaxKind.SwitchStatement:
|
||||
return write(factory.updateSwitchStatement(
|
||||
<SwitchStatement>node,
|
||||
<Expression>visitNode(context, (<SwitchStatement>node).expression, visitor),
|
||||
<CaseBlock>visitNode(context, (<SwitchStatement>node).caseBlock, visitor)));
|
||||
<Expression>visitNode((<SwitchStatement>node).expression, visitor),
|
||||
<CaseBlock>visitNode((<SwitchStatement>node).caseBlock, visitor)));
|
||||
case SyntaxKind.LabeledStatement:
|
||||
return write(factory.updateLabeledStatement(
|
||||
<LabeledStatement>node,
|
||||
<Identifier>visitNode(context, (<LabeledStatement>node).label, visitor),
|
||||
visitStatement(context, (<LabeledStatement>node).statement, visitor)));
|
||||
<Identifier>visitNode((<LabeledStatement>node).label, visitor),
|
||||
visitStatement((<LabeledStatement>node).statement, visitor)));
|
||||
case SyntaxKind.ThrowStatement:
|
||||
return write(factory.updateThrowStatement(
|
||||
<ThrowStatement>node,
|
||||
<Expression>visitNode(context, (<ThrowStatement>node).expression, visitor)));
|
||||
<Expression>visitNode((<ThrowStatement>node).expression, visitor)));
|
||||
case SyntaxKind.TryStatement:
|
||||
return write(factory.updateTryStatement(
|
||||
<TryStatement>node,
|
||||
<Block>visitNode(context, (<TryStatement>node).tryBlock, visitor),
|
||||
<CatchClause>visitNode(context, (<TryStatement>node).catchClause, visitor),
|
||||
<Block>visitNode(context, (<TryStatement>node).finallyBlock, visitor)));
|
||||
<Block>visitNode((<TryStatement>node).tryBlock, visitor),
|
||||
<CatchClause>visitNode((<TryStatement>node).catchClause, visitor),
|
||||
<Block>visitNode((<TryStatement>node).finallyBlock, visitor)));
|
||||
case SyntaxKind.VariableDeclaration:
|
||||
return write(factory.updateVariableDeclaration(
|
||||
<VariableDeclaration>node,
|
||||
<BindingPattern | Identifier>visitNode(context, (<VariableDeclaration>node).name, visitor),
|
||||
<TypeNode>visitNode(context, (<VariableDeclaration>node).type, visitor),
|
||||
<Expression>visitNode(context, (<VariableDeclaration>node).initializer, visitor)));
|
||||
<BindingPattern | Identifier>visitNode((<VariableDeclaration>node).name, visitor),
|
||||
<TypeNode>visitNode((<VariableDeclaration>node).type, visitor),
|
||||
<Expression>visitNode((<VariableDeclaration>node).initializer, visitor)));
|
||||
case SyntaxKind.VariableDeclarationList:
|
||||
return write(factory.updateVariableDeclarationList(
|
||||
<VariableDeclarationList>node,
|
||||
<NodeArray<VariableDeclaration>>visitNodes(context, (<VariableDeclarationList>node).declarations, visitor)));
|
||||
<NodeArray<VariableDeclaration>>visitNodes((<VariableDeclarationList>node).declarations, visitor)));
|
||||
case SyntaxKind.FunctionDeclaration:
|
||||
return write(factory.updateFunctionDeclaration(
|
||||
<FunctionDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<FunctionDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<FunctionDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode(context, (<FunctionDeclaration>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<FunctionDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<FunctionDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode(context, (<FunctionDeclaration>node).type, visitor),
|
||||
visitBlockInNewLexicalEnvironment(context, (<FunctionDeclaration>node).body, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<FunctionDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<FunctionDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode((<FunctionDeclaration>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<FunctionDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<FunctionDeclaration>node).parameters, visitor),
|
||||
<TypeNode>visitNode((<FunctionDeclaration>node).type, visitor),
|
||||
<Block>visitNewLexicalEnvironment((<FunctionDeclaration>node).body, visitor)));
|
||||
case SyntaxKind.ClassDeclaration:
|
||||
return write(factory.updateClassDeclaration(
|
||||
<ClassDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ClassDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ClassDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode(context, (<ClassDeclaration>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<ClassDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<HeritageClause>>visitNodes(context, (<ClassDeclaration>node).heritageClauses, visitor),
|
||||
<NodeArray<ClassElement>>visitNodes(context, (<ClassDeclaration>node).members, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<ClassDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ClassDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode((<ClassDeclaration>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<ClassDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<HeritageClause>>visitNodes((<ClassDeclaration>node).heritageClauses, visitor),
|
||||
<NodeArray<ClassElement>>visitNodes((<ClassDeclaration>node).members, visitor)));
|
||||
case SyntaxKind.InterfaceDeclaration:
|
||||
return write(factory.updateInterfaceDeclaration(
|
||||
<InterfaceDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<InterfaceDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<InterfaceDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode(context, (<InterfaceDeclaration>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<InterfaceDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<HeritageClause>>visitNodes(context, (<InterfaceDeclaration>node).heritageClauses, visitor),
|
||||
<NodeArray<TypeElement>>visitNodes(context, (<InterfaceDeclaration>node).members, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<InterfaceDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<InterfaceDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode((<InterfaceDeclaration>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<InterfaceDeclaration>node).typeParameters, visitor),
|
||||
<NodeArray<HeritageClause>>visitNodes((<InterfaceDeclaration>node).heritageClauses, visitor),
|
||||
<NodeArray<TypeElement>>visitNodes((<InterfaceDeclaration>node).members, visitor)));
|
||||
case SyntaxKind.TypeAliasDeclaration:
|
||||
return write(factory.updateTypeAliasDeclaration(
|
||||
<TypeAliasDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<TypeAliasDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<TypeAliasDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode(context, (<TypeAliasDeclaration>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<TypeAliasDeclaration>node).typeParameters, visitor),
|
||||
<TypeNode>visitNode(context, (<TypeAliasDeclaration>node).type, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<TypeAliasDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<TypeAliasDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode((<TypeAliasDeclaration>node).name, visitor),
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<TypeAliasDeclaration>node).typeParameters, visitor),
|
||||
<TypeNode>visitNode((<TypeAliasDeclaration>node).type, visitor)));
|
||||
case SyntaxKind.EnumDeclaration:
|
||||
return write(factory.updateEnumDeclaration(
|
||||
<EnumDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<EnumDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<EnumDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode(context, (<EnumDeclaration>node).name, visitor),
|
||||
<NodeArray<EnumMember>>visitNodes(context, (<EnumDeclaration>node).members, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<EnumDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<EnumDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode((<EnumDeclaration>node).name, visitor),
|
||||
<NodeArray<EnumMember>>visitNodes((<EnumDeclaration>node).members, visitor)));
|
||||
case SyntaxKind.ModuleDeclaration:
|
||||
return write(factory.updateModuleDeclaration(
|
||||
<ModuleDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ModuleDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ModuleDeclaration>node).modifiers, visitor),
|
||||
<Identifier | LiteralExpression>visitNode(context, (<ModuleDeclaration>node).name, visitor),
|
||||
visitModuleBlockOrModuleDeclarationInNewLexicalEnvironment(context, (<ModuleDeclaration>node).body, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<ModuleDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ModuleDeclaration>node).modifiers, visitor),
|
||||
<Identifier | LiteralExpression>visitNode((<ModuleDeclaration>node).name, visitor),
|
||||
<ModuleBlock | ModuleDeclaration>visitNewLexicalEnvironment((<ModuleDeclaration>node).body, visitor)));
|
||||
case SyntaxKind.ModuleBlock:
|
||||
return write(factory.updateModuleBlock(
|
||||
<ModuleBlock>node,
|
||||
<NodeArray<Statement>>visitNodes(context, (<ModuleBlock>node).statements, visitor)));
|
||||
<NodeArray<Statement>>visitNodes((<ModuleBlock>node).statements, visitor)));
|
||||
case SyntaxKind.CaseBlock:
|
||||
return write(factory.updateCaseBlock(
|
||||
<CaseBlock>node,
|
||||
<NodeArray<CaseOrDefaultClause>>visitNodes(context, (<CaseBlock>node).clauses, visitor)));
|
||||
<NodeArray<CaseOrDefaultClause>>visitNodes((<CaseBlock>node).clauses, visitor)));
|
||||
case SyntaxKind.ImportEqualsDeclaration:
|
||||
return write(factory.updateImportEqualsDeclaration(
|
||||
<ImportEqualsDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ImportEqualsDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ImportEqualsDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode(context, (<ImportEqualsDeclaration>node).name, visitor),
|
||||
<EntityName | ExternalModuleReference>visitNode(context, (<ImportEqualsDeclaration>node).moduleReference, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<ImportEqualsDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ImportEqualsDeclaration>node).modifiers, visitor),
|
||||
<Identifier>visitNode((<ImportEqualsDeclaration>node).name, visitor),
|
||||
<EntityName | ExternalModuleReference>visitNode((<ImportEqualsDeclaration>node).moduleReference, visitor)));
|
||||
case SyntaxKind.ImportDeclaration:
|
||||
return write(factory.updateImportDeclaration(
|
||||
<ImportDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ImportDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ImportDeclaration>node).modifiers, visitor),
|
||||
<ImportClause>visitNode(context, (<ImportDeclaration>node).importClause, visitor),
|
||||
<Expression>visitNode(context, (<ImportDeclaration>node).moduleSpecifier, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<ImportDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ImportDeclaration>node).modifiers, visitor),
|
||||
<ImportClause>visitNode((<ImportDeclaration>node).importClause, visitor),
|
||||
<Expression>visitNode((<ImportDeclaration>node).moduleSpecifier, visitor)));
|
||||
case SyntaxKind.ImportClause:
|
||||
return write(factory.updateImportClause(
|
||||
<ImportClause>node,
|
||||
<Identifier>visitNode(context, (<ImportClause>node).name, visitor),
|
||||
<NamedImports | NamespaceImport>visitNode(context, (<ImportClause>node).namedBindings, visitor)));
|
||||
<Identifier>visitNode((<ImportClause>node).name, visitor),
|
||||
<NamedImports | NamespaceImport>visitNode((<ImportClause>node).namedBindings, visitor)));
|
||||
case SyntaxKind.NamespaceImport:
|
||||
return write(factory.updateNamespaceImport(
|
||||
<NamespaceImport>node,
|
||||
<Identifier>visitNode(context, (<NamespaceImport>node).name, visitor)));
|
||||
<Identifier>visitNode((<NamespaceImport>node).name, visitor)));
|
||||
case SyntaxKind.NamedImports:
|
||||
return write(factory.updateNamedImports(
|
||||
<NamedImports>node,
|
||||
<NodeArray<ImportOrExportSpecifier>>visitNodes(context, (<NamedImports>node).elements, visitor)));
|
||||
<NodeArray<ImportOrExportSpecifier>>visitNodes((<NamedImports>node).elements, visitor)));
|
||||
case SyntaxKind.ImportSpecifier:
|
||||
return write(factory.updateImportSpecifier(
|
||||
<ImportSpecifier>node,
|
||||
<Identifier>visitNode(context, (<ImportSpecifier>node).propertyName, visitor),
|
||||
<Identifier>visitNode(context, (<ImportSpecifier>node).name, visitor)));
|
||||
<Identifier>visitNode((<ImportSpecifier>node).propertyName, visitor),
|
||||
<Identifier>visitNode((<ImportSpecifier>node).name, visitor)));
|
||||
case SyntaxKind.ExportAssignment:
|
||||
return write(factory.updateExportAssignment(
|
||||
<ExportAssignment>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ExportAssignment>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ExportAssignment>node).modifiers, visitor),
|
||||
<Expression>visitNode(context, (<ExportAssignment>node).expression, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<ExportAssignment>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ExportAssignment>node).modifiers, visitor),
|
||||
<Expression>visitNode((<ExportAssignment>node).expression, visitor)));
|
||||
case SyntaxKind.ExportDeclaration:
|
||||
return write(factory.updateExportDeclaration(
|
||||
<ExportDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<ExportDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<ExportDeclaration>node).modifiers, visitor),
|
||||
<NamedExports>visitNode(context, (<ExportDeclaration>node).exportClause, visitor),
|
||||
<Expression>visitNode(context, (<ExportDeclaration>node).moduleSpecifier, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<ExportDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<ExportDeclaration>node).modifiers, visitor),
|
||||
<NamedExports>visitNode((<ExportDeclaration>node).exportClause, visitor),
|
||||
<Expression>visitNode((<ExportDeclaration>node).moduleSpecifier, visitor)));
|
||||
case SyntaxKind.NamedExports:
|
||||
return write(factory.updateNamedExports(
|
||||
<NamedExports>node,
|
||||
<NodeArray<ImportOrExportSpecifier>>visitNodes(context, (<NamedExports>node).elements, visitor)));
|
||||
<NodeArray<ImportOrExportSpecifier>>visitNodes((<NamedExports>node).elements, visitor)));
|
||||
case SyntaxKind.ExportSpecifier:
|
||||
return write(factory.updateExportSpecifier(
|
||||
<ExportSpecifier>node,
|
||||
<Identifier>visitNode(context, (<ExportSpecifier>node).propertyName, visitor),
|
||||
<Identifier>visitNode(context, (<ExportSpecifier>node).name, visitor)));
|
||||
<Identifier>visitNode((<ExportSpecifier>node).propertyName, visitor),
|
||||
<Identifier>visitNode((<ExportSpecifier>node).name, visitor)));
|
||||
case SyntaxKind.MissingDeclaration:
|
||||
return write(factory.updateMissingDeclaration(
|
||||
<MissingDeclaration>node,
|
||||
<NodeArray<Decorator>>visitNodes(context, (<MissingDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes(context, (<MissingDeclaration>node).modifiers, visitor)));
|
||||
<NodeArray<Decorator>>visitNodes((<MissingDeclaration>node).decorators, visitor),
|
||||
<NodeArray<Modifier>>visitNodes((<MissingDeclaration>node).modifiers, visitor)));
|
||||
case SyntaxKind.ExternalModuleReference:
|
||||
return write(factory.updateExternalModuleReference(
|
||||
<ExternalModuleReference>node,
|
||||
<Expression>visitNode(context, (<ExternalModuleReference>node).expression, visitor)));
|
||||
<Expression>visitNode((<ExternalModuleReference>node).expression, visitor)));
|
||||
case SyntaxKind.JsxElement:
|
||||
return write(factory.updateJsxElement(
|
||||
<JsxElement>node,
|
||||
<JsxOpeningElement>visitNode(context, (<JsxElement>node).openingElement, visitor),
|
||||
<NodeArray<JsxChild>>visitNodes(context, (<JsxElement>node).children, visitor),
|
||||
<JsxClosingElement>visitNode(context, (<JsxElement>node).closingElement, visitor)));
|
||||
<JsxOpeningElement>visitNode((<JsxElement>node).openingElement, visitor),
|
||||
<NodeArray<JsxChild>>visitNodes((<JsxElement>node).children, visitor),
|
||||
<JsxClosingElement>visitNode((<JsxElement>node).closingElement, visitor)));
|
||||
case SyntaxKind.JsxSelfClosingElement:
|
||||
return write(factory.updateJsxSelfClosingElement(
|
||||
<JsxSelfClosingElement>node,
|
||||
<EntityName>visitNode(context, (<JsxSelfClosingElement>node).tagName, visitor),
|
||||
<NodeArray<JsxAttribute | JsxSpreadAttribute>>visitNodes(context, (<JsxSelfClosingElement>node).attributes, visitor)));
|
||||
<EntityName>visitNode((<JsxSelfClosingElement>node).tagName, visitor),
|
||||
<NodeArray<JsxAttribute | JsxSpreadAttribute>>visitNodes((<JsxSelfClosingElement>node).attributes, visitor)));
|
||||
case SyntaxKind.JsxOpeningElement:
|
||||
return write(factory.updateJsxOpeningElement(
|
||||
<JsxOpeningElement>node,
|
||||
<EntityName>visitNode(context, (<JsxOpeningElement>node).tagName, visitor),
|
||||
<NodeArray<JsxAttribute | JsxSpreadAttribute>>visitNodes(context, (<JsxOpeningElement>node).attributes, visitor)));
|
||||
<EntityName>visitNode((<JsxOpeningElement>node).tagName, visitor),
|
||||
<NodeArray<JsxAttribute | JsxSpreadAttribute>>visitNodes((<JsxOpeningElement>node).attributes, visitor)));
|
||||
case SyntaxKind.JsxClosingElement:
|
||||
return write(factory.updateJsxClosingElement(
|
||||
<JsxClosingElement>node,
|
||||
<EntityName>visitNode(context, (<JsxClosingElement>node).tagName, visitor)));
|
||||
<EntityName>visitNode((<JsxClosingElement>node).tagName, visitor)));
|
||||
case SyntaxKind.JsxAttribute:
|
||||
return write(factory.updateJsxAttribute(
|
||||
<JsxAttribute>node,
|
||||
<Identifier>visitNode(context, (<JsxAttribute>node).name, visitor),
|
||||
<Expression>visitNode(context, (<JsxAttribute>node).initializer, visitor)));
|
||||
<Identifier>visitNode((<JsxAttribute>node).name, visitor),
|
||||
<Expression>visitNode((<JsxAttribute>node).initializer, visitor)));
|
||||
case SyntaxKind.JsxSpreadAttribute:
|
||||
return write(factory.updateJsxSpreadAttribute(
|
||||
<JsxSpreadAttribute>node,
|
||||
<Expression>visitNode(context, (<JsxSpreadAttribute>node).expression, visitor)));
|
||||
<Expression>visitNode((<JsxSpreadAttribute>node).expression, visitor)));
|
||||
case SyntaxKind.JsxExpression:
|
||||
return write(factory.updateJsxExpression(
|
||||
<JsxExpression>node,
|
||||
<Expression>visitNode(context, (<JsxExpression>node).expression, visitor)));
|
||||
<Expression>visitNode((<JsxExpression>node).expression, visitor)));
|
||||
case SyntaxKind.CaseClause:
|
||||
return write(factory.updateCaseClause(
|
||||
<CaseClause>node,
|
||||
<Expression>visitNode(context, (<CaseClause>node).expression, visitor),
|
||||
<NodeArray<Statement>>visitNodes(context, (<CaseClause>node).statements, visitor)));
|
||||
<Expression>visitNode((<CaseClause>node).expression, visitor),
|
||||
<NodeArray<Statement>>visitNodes((<CaseClause>node).statements, visitor)));
|
||||
case SyntaxKind.DefaultClause:
|
||||
return write(factory.updateDefaultClause(
|
||||
<DefaultClause>node,
|
||||
<NodeArray<Statement>>visitNodes(context, (<DefaultClause>node).statements, visitor)));
|
||||
<NodeArray<Statement>>visitNodes((<DefaultClause>node).statements, visitor)));
|
||||
case SyntaxKind.HeritageClause:
|
||||
return write(factory.updateHeritageClause(
|
||||
<HeritageClause>node,
|
||||
<NodeArray<ExpressionWithTypeArguments>>visitNodes(context, (<HeritageClause>node).types, visitor)));
|
||||
<NodeArray<ExpressionWithTypeArguments>>visitNodes((<HeritageClause>node).types, visitor)));
|
||||
case SyntaxKind.CatchClause:
|
||||
return write(factory.updateCatchClause(
|
||||
<CatchClause>node,
|
||||
<VariableDeclaration>visitNode(context, (<CatchClause>node).variableDeclaration, visitor),
|
||||
<Block>visitNode(context, (<CatchClause>node).block, visitor)));
|
||||
<VariableDeclaration>visitNode((<CatchClause>node).variableDeclaration, visitor),
|
||||
<Block>visitNode((<CatchClause>node).block, visitor)));
|
||||
case SyntaxKind.PropertyAssignment:
|
||||
return write(factory.updatePropertyAssignment(
|
||||
<PropertyAssignment>node,
|
||||
<PropertyName>visitNode(context, (<PropertyAssignment>node).name, visitor),
|
||||
<Expression>visitNode(context, (<PropertyAssignment>node).initializer, visitor)));
|
||||
<PropertyName>visitNode((<PropertyAssignment>node).name, visitor),
|
||||
<Expression>visitNode((<PropertyAssignment>node).initializer, visitor)));
|
||||
case SyntaxKind.ShorthandPropertyAssignment:
|
||||
return write(factory.updateShorthandPropertyAssignment(
|
||||
<ShorthandPropertyAssignment>node,
|
||||
<Identifier>visitNode(context, (<ShorthandPropertyAssignment>node).name, visitor)));
|
||||
<Identifier>visitNode((<ShorthandPropertyAssignment>node).name, visitor)));
|
||||
case SyntaxKind.EnumMember:
|
||||
return write(factory.updateEnumMember(
|
||||
<EnumMember>node,
|
||||
<DeclarationName>visitNode(context, (<EnumMember>node).name, visitor),
|
||||
<Expression>visitNode(context, (<EnumMember>node).initializer, visitor)));
|
||||
<DeclarationName>visitNode((<EnumMember>node).name, visitor),
|
||||
<Expression>visitNode((<EnumMember>node).initializer, visitor)));
|
||||
case SyntaxKind.JSDocTypeExpression:
|
||||
return write(factory.updateJSDocTypeExpression(
|
||||
<JSDocTypeExpression>node,
|
||||
<JSDocType>visitNode(context, (<JSDocTypeExpression>node).type, visitor)));
|
||||
<JSDocType>visitNode((<JSDocTypeExpression>node).type, visitor)));
|
||||
case SyntaxKind.JSDocArrayType:
|
||||
return write(factory.updateJSDocArrayType(
|
||||
<JSDocArrayType>node,
|
||||
<JSDocType>visitNode(context, (<JSDocArrayType>node).elementType, visitor)));
|
||||
<JSDocType>visitNode((<JSDocArrayType>node).elementType, visitor)));
|
||||
case SyntaxKind.JSDocUnionType:
|
||||
return write(factory.updateJSDocUnionType(
|
||||
<JSDocUnionType>node,
|
||||
<NodeArray<JSDocType>>visitNodes(context, (<JSDocUnionType>node).types, visitor)));
|
||||
<NodeArray<JSDocType>>visitNodes((<JSDocUnionType>node).types, visitor)));
|
||||
case SyntaxKind.JSDocTupleType:
|
||||
return write(factory.updateJSDocTupleType(
|
||||
<JSDocTupleType>node,
|
||||
<NodeArray<JSDocType>>visitNodes(context, (<JSDocTupleType>node).types, visitor)));
|
||||
<NodeArray<JSDocType>>visitNodes((<JSDocTupleType>node).types, visitor)));
|
||||
case SyntaxKind.JSDocNullableType:
|
||||
return write(factory.updateJSDocNullableType(
|
||||
<JSDocNullableType>node,
|
||||
<JSDocType>visitNode(context, (<JSDocNullableType>node).type, visitor)));
|
||||
<JSDocType>visitNode((<JSDocNullableType>node).type, visitor)));
|
||||
case SyntaxKind.JSDocNonNullableType:
|
||||
return write(factory.updateJSDocNonNullableType(
|
||||
<JSDocNonNullableType>node,
|
||||
<JSDocType>visitNode(context, (<JSDocNonNullableType>node).type, visitor)));
|
||||
<JSDocType>visitNode((<JSDocNonNullableType>node).type, visitor)));
|
||||
case SyntaxKind.JSDocRecordType:
|
||||
return write(factory.updateJSDocRecordType(
|
||||
<JSDocRecordType>node,
|
||||
<NodeArray<JSDocRecordMember>>visitNodes(context, (<JSDocRecordType>node).members, visitor)));
|
||||
<NodeArray<JSDocRecordMember>>visitNodes((<JSDocRecordType>node).members, visitor)));
|
||||
case SyntaxKind.JSDocRecordMember:
|
||||
return write(factory.updateJSDocRecordMember(
|
||||
<JSDocRecordMember>node,
|
||||
<Identifier | LiteralExpression>visitNode(context, (<JSDocRecordMember>node).name, visitor),
|
||||
<JSDocType>visitNode(context, (<JSDocRecordMember>node).type, visitor)));
|
||||
<Identifier | LiteralExpression>visitNode((<JSDocRecordMember>node).name, visitor),
|
||||
<JSDocType>visitNode((<JSDocRecordMember>node).type, visitor)));
|
||||
case SyntaxKind.JSDocTypeReference:
|
||||
return write(factory.updateJSDocTypeReference(
|
||||
<JSDocTypeReference>node,
|
||||
<EntityName>visitNode(context, (<JSDocTypeReference>node).name, visitor),
|
||||
<NodeArray<JSDocType>>visitNodes(context, (<JSDocTypeReference>node).typeArguments, visitor)));
|
||||
<EntityName>visitNode((<JSDocTypeReference>node).name, visitor),
|
||||
<NodeArray<JSDocType>>visitNodes((<JSDocTypeReference>node).typeArguments, visitor)));
|
||||
case SyntaxKind.JSDocOptionalType:
|
||||
return write(factory.updateJSDocOptionalType(
|
||||
<JSDocOptionalType>node,
|
||||
<JSDocType>visitNode(context, (<JSDocOptionalType>node).type, visitor)));
|
||||
<JSDocType>visitNode((<JSDocOptionalType>node).type, visitor)));
|
||||
case SyntaxKind.JSDocFunctionType:
|
||||
return write(factory.updateJSDocFunctionType(
|
||||
<JSDocFunctionType>node,
|
||||
<NodeArray<ParameterDeclaration>>visitNodes(context, (<JSDocFunctionType>node).parameters, visitor),
|
||||
<JSDocType>visitNode(context, (<JSDocFunctionType>node).type, visitor)));
|
||||
<NodeArray<ParameterDeclaration>>visitNodes((<JSDocFunctionType>node).parameters, visitor),
|
||||
<JSDocType>visitNode((<JSDocFunctionType>node).type, visitor)));
|
||||
case SyntaxKind.JSDocVariadicType:
|
||||
return write(factory.updateJSDocVariadicType(
|
||||
<JSDocVariadicType>node,
|
||||
<JSDocType>visitNode(context, (<JSDocVariadicType>node).type, visitor)));
|
||||
<JSDocType>visitNode((<JSDocVariadicType>node).type, visitor)));
|
||||
case SyntaxKind.JSDocConstructorType:
|
||||
return write(factory.updateJSDocConstructorType(
|
||||
<JSDocConstructorType>node,
|
||||
<JSDocType>visitNode(context, (<JSDocConstructorType>node).type, visitor)));
|
||||
<JSDocType>visitNode((<JSDocConstructorType>node).type, visitor)));
|
||||
case SyntaxKind.JSDocThisType:
|
||||
return write(factory.updateJSDocThisType(
|
||||
<JSDocThisType>node,
|
||||
<JSDocType>visitNode(context, (<JSDocThisType>node).type, visitor)));
|
||||
<JSDocType>visitNode((<JSDocThisType>node).type, visitor)));
|
||||
case SyntaxKind.JSDocComment:
|
||||
return write(factory.updateJSDocComment(
|
||||
<JSDocComment>node,
|
||||
<NodeArray<JSDocTag>>visitNodes(context, (<JSDocComment>node).tags, visitor)));
|
||||
<NodeArray<JSDocTag>>visitNodes((<JSDocComment>node).tags, visitor)));
|
||||
case SyntaxKind.JSDocTag:
|
||||
return write(factory.updateJSDocTag(
|
||||
<JSDocTag>node,
|
||||
<Identifier>visitNode(context, (<JSDocTag>node).tagName, visitor)));
|
||||
<Identifier>visitNode((<JSDocTag>node).tagName, visitor)));
|
||||
case SyntaxKind.JSDocParameterTag:
|
||||
return write(factory.updateJSDocParameterTag(
|
||||
<JSDocParameterTag>node,
|
||||
<Identifier>visitNode(context, (<JSDocParameterTag>node).preParameterName, visitor),
|
||||
<JSDocTypeExpression>visitNode(context, (<JSDocParameterTag>node).typeExpression, visitor),
|
||||
<Identifier>visitNode(context, (<JSDocParameterTag>node).postParameterName, visitor),
|
||||
<Identifier>visitNode(context, (<JSDocParameterTag>node).tagName, visitor)));
|
||||
<Identifier>visitNode((<JSDocParameterTag>node).preParameterName, visitor),
|
||||
<JSDocTypeExpression>visitNode((<JSDocParameterTag>node).typeExpression, visitor),
|
||||
<Identifier>visitNode((<JSDocParameterTag>node).postParameterName, visitor),
|
||||
<Identifier>visitNode((<JSDocParameterTag>node).tagName, visitor)));
|
||||
case SyntaxKind.JSDocReturnTag:
|
||||
return write(factory.updateJSDocReturnTag(
|
||||
<JSDocReturnTag>node,
|
||||
<JSDocTypeExpression>visitNode(context, (<JSDocReturnTag>node).typeExpression, visitor),
|
||||
<Identifier>visitNode(context, (<JSDocReturnTag>node).tagName, visitor)));
|
||||
<JSDocTypeExpression>visitNode((<JSDocReturnTag>node).typeExpression, visitor),
|
||||
<Identifier>visitNode((<JSDocReturnTag>node).tagName, visitor)));
|
||||
case SyntaxKind.JSDocTypeTag:
|
||||
return write(factory.updateJSDocTypeTag(
|
||||
<JSDocTypeTag>node,
|
||||
<JSDocTypeExpression>visitNode(context, (<JSDocTypeTag>node).typeExpression, visitor),
|
||||
<Identifier>visitNode(context, (<JSDocTypeTag>node).tagName, visitor)));
|
||||
<JSDocTypeExpression>visitNode((<JSDocTypeTag>node).typeExpression, visitor),
|
||||
<Identifier>visitNode((<JSDocTypeTag>node).tagName, visitor)));
|
||||
case SyntaxKind.JSDocTemplateTag:
|
||||
return write(factory.updateJSDocTemplateTag(
|
||||
<JSDocTemplateTag>node,
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes(context, (<JSDocTemplateTag>node).typeParameters, visitor),
|
||||
<Identifier>visitNode(context, (<JSDocTemplateTag>node).tagName, visitor)));
|
||||
<NodeArray<TypeParameterDeclaration>>visitNodes((<JSDocTemplateTag>node).typeParameters, visitor),
|
||||
<Identifier>visitNode((<JSDocTemplateTag>node).tagName, visitor)));
|
||||
default:
|
||||
return write(node);
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -7,7 +7,7 @@ namespace ts.transform {
|
|||
|
||||
export let transformTime = 0;
|
||||
|
||||
export type TransformationChain = (context: VisitorContext, statements: NodeArray<Statement>) => NodeArray<Statement>;
|
||||
export type TransformationChain = (statements: NodeArray<Statement>) => NodeArray<Statement>;
|
||||
|
||||
export function getTransformationChain(options: CompilerOptions): TransformationChain {
|
||||
if ((options.target || ScriptTarget.ES3) < ScriptTarget.ES6) {
|
||||
|
|
@ -27,55 +27,47 @@ namespace ts.transform {
|
|||
}
|
||||
}
|
||||
|
||||
function runTransformation(chain: TransformationChain, context: VisitorContext, statements: NodeArray<Statement>) {
|
||||
function runTransformation(chain: TransformationChain, statements: NodeArray<Statement>) {
|
||||
let start = new Date().getTime();
|
||||
context.pushLexicalEnvironment();
|
||||
|
||||
let transformed = chain(context, statements);
|
||||
if (context.hasHoistedDeclarations()) {
|
||||
transformed = factory.cloneNodeArray(transformed);
|
||||
context.writeHoistedDeclarations(transformed);
|
||||
}
|
||||
|
||||
context.popLexicalEnvironment();
|
||||
let transformed = chain(statements);
|
||||
transformTime += new Date().getTime() - start;
|
||||
return transformed;
|
||||
}
|
||||
|
||||
function createUnaryTransformationChain(only: TransformationChain) {
|
||||
return function (context: VisitorContext, statements: NodeArray<Statement>) {
|
||||
if (only) statements = runTransformation(only, context, statements);
|
||||
return function (statements: NodeArray<Statement>) {
|
||||
if (only) statements = runTransformation(only, statements);
|
||||
return statements;
|
||||
};
|
||||
}
|
||||
|
||||
function createBinaryTransformationChain(first: TransformationChain, second: TransformationChain) {
|
||||
return function (context: VisitorContext, statements: NodeArray<Statement>) {
|
||||
if (first) statements = runTransformation(first, context, statements);
|
||||
if (second) statements = runTransformation(second, context, statements);
|
||||
return function (statements: NodeArray<Statement>) {
|
||||
if (first) statements = runTransformation(first, statements);
|
||||
if (second) statements = runTransformation(second, statements);
|
||||
return statements;
|
||||
};
|
||||
}
|
||||
|
||||
function createTrinaryTransformationChain(first: TransformationChain, second: TransformationChain, third: TransformationChain) {
|
||||
return function (context: VisitorContext, statements: NodeArray<Statement>) {
|
||||
if (first) statements = runTransformation(first, context, statements);
|
||||
if (second) statements = runTransformation(second, context, statements);
|
||||
if (third) statements = runTransformation(third, context, statements);
|
||||
return function (statements: NodeArray<Statement>) {
|
||||
if (first) statements = runTransformation(first, statements);
|
||||
if (second) statements = runTransformation(second, statements);
|
||||
if (third) statements = runTransformation(third, statements);
|
||||
return statements;
|
||||
};
|
||||
}
|
||||
|
||||
function createNaryTransformationChain(transformations: TransformationChain[]) {
|
||||
return function (context: VisitorContext, statements: NodeArray<Statement>) {
|
||||
return function (statements: NodeArray<Statement>) {
|
||||
for (let transformation of transformations) {
|
||||
if (transformation) statements = transformation(context, statements);
|
||||
if (transformation) statements = transformation(statements);
|
||||
}
|
||||
return statements;
|
||||
};
|
||||
}
|
||||
|
||||
function identityTransformation(context: VisitorContext, statements: NodeArray<Statement>): NodeArray<Statement> {
|
||||
function identityTransformation(statements: NodeArray<Statement>): NodeArray<Statement> {
|
||||
return statements;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,8 +1,8 @@
|
|||
/// <reference path="../transform.generated.ts" />
|
||||
/*@internal*/
|
||||
namespace ts.transform {
|
||||
export function toES5(context: VisitorContext, statements: NodeArray<Statement>) {
|
||||
return visitNodes(context, statements, transformNode);
|
||||
export function toES5(statements: NodeArray<Statement>) {
|
||||
return visitNodes(statements, transformNode, /*newLexicalEnvironment*/ true);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -22,7 +22,7 @@ namespace ts.transform {
|
|||
* If no part of this node or its subtree requires transformation, the node
|
||||
* is returned, unchanged.
|
||||
*/
|
||||
function transformNode(context: VisitorContext, node: Node, write: (node: Node) => void): void {
|
||||
function transformNode(node: Node, write: (node: Node) => void): void {
|
||||
if (!node) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -31,17 +31,18 @@ namespace ts.transform {
|
|||
// !needsTransform(node, TransformFlags.ThisNodeNeedsTransformToES6),
|
||||
// "Cannot transform node with post-ES6 syntax.");
|
||||
|
||||
if (needsTransform(node, TransformFlags.ThisNodeNeedsTransformToES5)) {
|
||||
return transformNodeWorker(context, node, write);
|
||||
if (node.transformFlags & TransformFlags.ThisNodeNeedsTransformToES5) {
|
||||
transformNodeWorker(node, write);
|
||||
}
|
||||
else if (node.flags & NodeFlags.GeneratedSuper && isExpressionStatement(node)) {
|
||||
return transformInitialSuperCall(context, node, write);
|
||||
transformInitialSuperCall(node, write);
|
||||
}
|
||||
else if (needsTransform(node, TransformFlags.SubtreeNeedsTransformToES5)) {
|
||||
return accept(context, node, transformNode, write);
|
||||
else if (node.transformFlags & TransformFlags.SubtreeNeedsTransformToES5) {
|
||||
accept(node, transformNode, write);
|
||||
}
|
||||
else {
|
||||
return write(node);
|
||||
}
|
||||
|
||||
return write(node);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -49,23 +50,23 @@ namespace ts.transform {
|
|||
* @param context Context information for the transform.
|
||||
* @param node The node to transform.
|
||||
*/
|
||||
function transformNodeWorker(context: VisitorContext, node: Node, write: (node: Node) => void): void {
|
||||
function transformNodeWorker(node: Node, write: (node: Node) => void): void {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.ClassDeclaration:
|
||||
return transformClassDeclaration(context, <ClassDeclaration>node, write);
|
||||
return transformClassDeclaration(<ClassDeclaration>node, write);
|
||||
|
||||
case SyntaxKind.ClassExpression:
|
||||
return transformClassExpression(context, <ClassExpression>node, write);
|
||||
return transformClassExpression(<ClassExpression>node, write);
|
||||
|
||||
case SyntaxKind.Parameter:
|
||||
return transformParameter(context, <ParameterDeclaration>node, write);
|
||||
return transformParameter(<ParameterDeclaration>node, write);
|
||||
|
||||
case SyntaxKind.FunctionDeclaration:
|
||||
return transformFunctionDeclaration(context, <FunctionDeclaration>node, write);
|
||||
return transformFunctionDeclaration(<FunctionDeclaration>node, write);
|
||||
|
||||
case SyntaxKind.ArrowFunction:
|
||||
case SyntaxKind.FunctionExpression:
|
||||
return transformFunctionExpression(context, <FunctionExpression>node, write);
|
||||
return transformFunctionExpression(<FunctionExpression>node, write);
|
||||
|
||||
case SyntaxKind.BindingElement:
|
||||
case SyntaxKind.ArrayBindingPattern:
|
||||
|
|
@ -92,105 +93,88 @@ namespace ts.transform {
|
|||
// TODO (rbuckton): ES6 syntax we're not yet transforming and are leaving for the emitter to handle.
|
||||
|
||||
default:
|
||||
return accept(context, node, transformNode, write);
|
||||
return accept(node, transformNode, write);
|
||||
}
|
||||
}
|
||||
|
||||
function transformClassDeclaration(context: VisitorContext, node: ClassDeclaration, write: (node: Statement) => void) {
|
||||
let name = context.getDeclarationName(node);
|
||||
let classInitExpr = transformClassLikeDeclaration(context, node, name);
|
||||
function transformClassDeclaration(node: ClassDeclaration, write: (node: Statement) => void) {
|
||||
let name = getDeclarationName(node);
|
||||
let classInitExpr = transformClassLikeDeclaration(node, name);
|
||||
let baseTypeNode = getClassExtendsHeritageClauseElement(node);
|
||||
let varDecl = factory.createVariableDeclaration2(name, classInitExpr);
|
||||
let varDecls = factory.createVariableDeclarationList([varDecl]);
|
||||
let varStmt = factory.createVariableStatement2(varDecls, /*location*/ node);
|
||||
return write(varStmt);
|
||||
// return tag_statement`
|
||||
// var ${name} = (function (${baseTypeNode && tag_id`_super`}) {
|
||||
// ${baseTypeNode && tag_statement`__extends(${name}, _super);`}
|
||||
// ${transformConstructor(context, node, baseTypeNode)}
|
||||
// ${transformMemberFunctions(context, node)}
|
||||
// return ${name};
|
||||
// })(${baseTypeNode && tag_id`_super`});
|
||||
// `;
|
||||
}
|
||||
|
||||
function transformClassExpression(context: VisitorContext, node: ClassExpression, write: (node: LeftHandSideExpression) => void) {
|
||||
let name = context.getDeclarationName(node);
|
||||
return write(transformClassLikeDeclaration(context, node, name));
|
||||
// let baseTypeNode = getClassExtendsHeritageClauseElement(node);
|
||||
// return tag_lhs_expression`
|
||||
// (function (${baseTypeNode && tag_id`_super`}) {
|
||||
// ${baseTypeNode && tag_statement`__extends(${name}, _super);`}
|
||||
// ${transformConstructor(context, node, baseTypeNode)}
|
||||
// ${transformMemberFunctions(context, node)}
|
||||
// return ${name};
|
||||
// })(${baseTypeNode && tag_id`_super`});
|
||||
// `;
|
||||
function transformClassExpression(node: ClassExpression, write: (node: LeftHandSideExpression) => void) {
|
||||
let name = getDeclarationName(node);
|
||||
return write(transformClassLikeDeclaration(node, name));
|
||||
}
|
||||
|
||||
function transformClassLikeDeclaration(context: VisitorContext, node: ClassLikeDeclaration, name: Identifier): LeftHandSideExpression {
|
||||
function transformClassLikeDeclaration(node: ClassLikeDeclaration, name: Identifier): LeftHandSideExpression {
|
||||
let baseTypeNode = getClassExtendsHeritageClauseElement(node);
|
||||
let superExpr = baseTypeNode ? visitNode(context, baseTypeNode.expression, transformNode) : undefined;
|
||||
let classBody = factory.createBlock([]);
|
||||
emitNode(node, classBody.statements, transformClassBody);
|
||||
|
||||
let superExpr = baseTypeNode ? visitNode(baseTypeNode.expression, transformNode) : undefined;
|
||||
let superName = baseTypeNode ? factory.createIdentifier("_super") : undefined;
|
||||
let superParam = baseTypeNode ? factory.createParameter2(superName) : undefined;
|
||||
let classBody = factory.createBlock([]);
|
||||
if (baseTypeNode) {
|
||||
let extendsExpr = factory.createExtendsHelperCall(name);
|
||||
let extendsStmt = factory.createExpressionStatement(extendsExpr);
|
||||
classBody.statements.push(extendsStmt);
|
||||
}
|
||||
|
||||
transformConstructor(context, node, name, baseTypeNode, classBody.statements);
|
||||
transformMemberFunctions(context, node, classBody.statements);
|
||||
|
||||
let returnStmt = factory.createReturnStatement(name);
|
||||
classBody.statements.push(returnStmt);
|
||||
|
||||
let classDecl = factory.createFunctionExpression2(/*name*/ undefined, baseTypeNode ? [superParam] : [], classBody);
|
||||
let parenExpr = factory.createParenthesizedExpression(classDecl);
|
||||
let callExpr = factory.createCallExpression2(parenExpr, baseTypeNode ? [superExpr] : undefined);
|
||||
return callExpr;
|
||||
}
|
||||
|
||||
function transformConstructor(context: VisitorContext, node: ClassLikeDeclaration, name: Identifier, baseTypeNode: ExpressionWithTypeArguments, classStatements: Statement[]) {
|
||||
context.pushLexicalEnvironment();
|
||||
|
||||
let constructor = getFirstConstructorWithBody(node);
|
||||
let parameters: ParameterDeclaration[] = constructor ? visitNodes(context, constructor.parameters, transformNode) : [];
|
||||
let body = factory.createBlock([]);
|
||||
|
||||
if (constructor) {
|
||||
transformCaptureThisForNode(context, constructor, body.statements);
|
||||
transformDefaultValueAssignments(context, constructor, body.statements);
|
||||
transformRestParameter(context, constructor, body.statements);
|
||||
function transformClassBody(node: ClassLikeDeclaration, write: (node: Statement) => void): void {
|
||||
let name = getDeclarationName(node);
|
||||
let baseTypeNode = getClassExtendsHeritageClauseElement(node);
|
||||
emitExtendsCall(node, name, baseTypeNode, write);
|
||||
emitConstructor(node, name, baseTypeNode, write);
|
||||
emitMemberFunctions(node, write);
|
||||
|
||||
let statements = visitNodes(context, constructor.body.statements, transformNode);
|
||||
body.statements.push(...statements);
|
||||
let returnStmt = factory.createReturnStatement(name);
|
||||
write(returnStmt);
|
||||
}
|
||||
|
||||
function emitExtendsCall(node: ClassLikeDeclaration, name: Identifier, baseTypeNode: ExpressionWithTypeArguments, write: (node: Statement) => void): void {
|
||||
if (!baseTypeNode) {
|
||||
return;
|
||||
}
|
||||
|
||||
let extendsExpr = factory.createExtendsHelperCall(name);
|
||||
let extendsStmt = factory.createExpressionStatement(extendsExpr);
|
||||
write(extendsStmt);
|
||||
}
|
||||
|
||||
function emitConstructor(node: ClassLikeDeclaration, name: Identifier, baseTypeNode: ExpressionWithTypeArguments, write: (node: Statement) => void) {
|
||||
let constructor = getFirstConstructorWithBody(node);
|
||||
let parameters: ParameterDeclaration[] = constructor ? visitNodes(constructor.parameters, transformNode) : [];
|
||||
let body = factory.createBlock([]);
|
||||
|
||||
if (constructor) {
|
||||
emitNode(constructor, body.statements, transformConstructor, /*newLexicalEnvironment*/ true);
|
||||
}
|
||||
else if (baseTypeNode) {
|
||||
let superCall = createDefaultSuperCall();
|
||||
body.statements.push(superCall);
|
||||
}
|
||||
|
||||
context.writeHoistedDeclarations(body.statements);
|
||||
context.popLexicalEnvironment();
|
||||
|
||||
|
||||
let constructorFunc = factory.createFunctionDeclaration2(name, parameters, body);
|
||||
classStatements.push(constructorFunc);
|
||||
// return tag_statement`
|
||||
// function ${name}(${transformSignatureParameters(context, constructor)}) {
|
||||
// ${transformCaptureThisForNode(context, constructor)}
|
||||
// ${transformDefaultValueAssignments(context, constructor)}
|
||||
// ${transformRestParameter(context, constructor)}
|
||||
// ${visitNodeArrayOfStatement(context, constructor && constructor.body.statements, transformNode)}
|
||||
// }
|
||||
// `;
|
||||
write(constructorFunc);
|
||||
}
|
||||
|
||||
function transformParameter(context: VisitorContext, node: ParameterDeclaration, write: (node: ParameterDeclaration) => void) {
|
||||
function transformConstructor(constructor: ConstructorDeclaration, write: (node: Statement) => void) {
|
||||
emitCaptureThisForNode(constructor, write);
|
||||
emitDefaultValueAssignments(constructor, write);
|
||||
emitRestParameter(constructor, write);
|
||||
pipeNodes(constructor.body.statements, write, transformNode);
|
||||
}
|
||||
|
||||
function transformParameter(node: ParameterDeclaration, write: (node: ParameterDeclaration) => void) {
|
||||
if (isBindingPattern(node.name)) {
|
||||
write(factory.createParameter2(
|
||||
context.getGeneratedNameForNode(node),
|
||||
getGeneratedNameForNode(node),
|
||||
/*initializer*/ undefined,
|
||||
/*location*/ node
|
||||
));
|
||||
|
|
@ -208,8 +192,8 @@ namespace ts.transform {
|
|||
}
|
||||
}
|
||||
|
||||
function transformDefaultValueAssignments(context: VisitorContext, node: FunctionLikeDeclaration, statements: Statement[]) {
|
||||
if (!needsTransform(node, TransformFlags.SubtreeContainsParameterInitializer | TransformFlags.SubtreeContainsParameterBindingPattern)) {
|
||||
function emitDefaultValueAssignments(node: FunctionLikeDeclaration, write: (node: Statement) => void) {
|
||||
if (!(node.transformFlags & (TransformFlags.SubtreeContainsParameterInitializer | TransformFlags.SubtreeContainsParameterBindingPattern))) {
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -223,16 +207,16 @@ namespace ts.transform {
|
|||
}
|
||||
|
||||
if (isBindingPattern(name)) {
|
||||
transformDefaultValueAssignmentForBindingPattern(context, parameter, name, initializer, statements);
|
||||
emitDefaultValueAssignmentForBindingPattern(parameter, name, initializer, write);
|
||||
}
|
||||
else if (initializer) {
|
||||
transformDefaultValueAssignmentForInitializer(context, parameter, name, initializer, statements);
|
||||
emitDefaultValueAssignmentForInitializer(parameter, name, initializer, write);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function transformDefaultValueAssignmentForBindingPattern(context: VisitorContext, parameter: ParameterDeclaration, name: BindingPattern, initializer: Expression, statements: Statement[]): void {
|
||||
let tempName = context.getGeneratedNameForNode(parameter);
|
||||
function emitDefaultValueAssignmentForBindingPattern(parameter: ParameterDeclaration, name: BindingPattern, initializer: Expression, write: (node: Statement) => void): void {
|
||||
let tempName = getGeneratedNameForNode(parameter);
|
||||
|
||||
// In cases where a binding pattern is simply '[]' or '{}',
|
||||
// we usually don't want to emit a var declaration; however, in the presence
|
||||
|
|
@ -240,29 +224,26 @@ namespace ts.transform {
|
|||
let hasBindingElements = name.elements.length > 0;
|
||||
if (hasBindingElements) {
|
||||
let varDecls = factory.createVariableDeclarationList([]);
|
||||
transformBindingElement(context, parameter, tempName, varDecls.declarations, /*assignments*/ undefined);
|
||||
transformBindingElement(parameter, tempName, varDecls.declarations, /*assignments*/ undefined);
|
||||
|
||||
let varStmt = factory.createVariableStatement2(varDecls);
|
||||
factory.startOnNewLine(varStmt);
|
||||
statements.push(varStmt);
|
||||
write(varStmt);
|
||||
}
|
||||
else if (initializer) {
|
||||
let initExpr = visitNode(context, initializer, transformNode);
|
||||
let initExpr = visitNode(initializer, transformNode);
|
||||
let assignExpr = factory.createAssignmentExpression(tempName, initExpr);
|
||||
let assignStmt = factory.createExpressionStatement(assignExpr);
|
||||
factory.startOnNewLine(assignStmt);
|
||||
statements.push(assignStmt);
|
||||
// return tag_statements`
|
||||
// ${tempName} = ${visit(context, initializer, transformNode)};
|
||||
// `;
|
||||
write(assignStmt);
|
||||
}
|
||||
}
|
||||
|
||||
function transformBindingElement(context: VisitorContext, target: BindingElement, value: Expression, declarations: VariableDeclaration[], assignments: Expression[]): void {
|
||||
function transformBindingElement(target: BindingElement, value: Expression, declarations: VariableDeclaration[], assignments: Expression[]): void {
|
||||
if (target.initializer) {
|
||||
// Combine value and initializer
|
||||
let initializer = visitNode(context, target.initializer, transformNode);
|
||||
value = value ? createDefaultValueCheck(context, value, initializer, declarations, assignments) : initializer;
|
||||
let initializer = visitNode(target.initializer, transformNode);
|
||||
value = value ? createDefaultValueCheck(value, initializer, declarations, assignments) : initializer;
|
||||
}
|
||||
else if (!value) {
|
||||
// Use 'void 0' in absence of value and initializer
|
||||
|
|
@ -275,22 +256,22 @@ namespace ts.transform {
|
|||
if (elements.length !== 1) {
|
||||
// For anything but a single element destructuring we need to generate a temporary
|
||||
// to ensure value is evaluated exactly once.
|
||||
value = ensureIdentifier(context, value, declarations, assignments);
|
||||
value = ensureIdentifier(value, declarations, assignments);
|
||||
}
|
||||
for (let i = 0; i < elements.length; i++) {
|
||||
let element = elements[i];
|
||||
if (name.kind === SyntaxKind.ObjectBindingPattern) {
|
||||
// Rewrite element to a declaration with an initializer that fetches property
|
||||
let propName = element.propertyName || <Identifier>element.name;
|
||||
transformBindingElement(context, element, factory.createPropertyOrElementAccessExpression(value, propName), declarations, assignments);
|
||||
transformBindingElement(element, factory.createPropertyOrElementAccessExpression(value, propName), declarations, assignments);
|
||||
}
|
||||
else if (element.kind !== SyntaxKind.OmittedExpression) {
|
||||
if (!element.dotDotDotToken) {
|
||||
// Rewrite element to a declaration that accesses array element at index i
|
||||
transformBindingElement(context, element, factory.createElementAccessExpression3(value, i), declarations, assignments);
|
||||
transformBindingElement(element, factory.createElementAccessExpression3(value, i), declarations, assignments);
|
||||
}
|
||||
else if (i === elements.length - 1) {
|
||||
transformBindingElement(context, element, factory.createSliceCall(value, i), declarations, assignments);
|
||||
transformBindingElement(element, factory.createSliceCall(value, i), declarations, assignments);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -310,43 +291,38 @@ namespace ts.transform {
|
|||
}
|
||||
}
|
||||
|
||||
function ensureIdentifier(context: VisitorContext, value: Expression, declarations: VariableDeclaration[], assignments: Expression[]) {
|
||||
function ensureIdentifier(value: Expression, declarations: VariableDeclaration[], assignments: Expression[]) {
|
||||
if (isIdentifier(value)) {
|
||||
return value;
|
||||
}
|
||||
else {
|
||||
let tempVar = context.createTempVariable(/*loopVariable*/ false);
|
||||
let tempVar = createTempVariable(/*loopVariable*/ false);
|
||||
appendAssignment(tempVar, value, declarations, assignments);
|
||||
return tempVar;
|
||||
}
|
||||
}
|
||||
|
||||
function createDefaultValueCheck(context: VisitorContext, value: Expression, defaultValue: Expression, declarations: VariableDeclaration[], assignments: Expression[]) {
|
||||
value = ensureIdentifier(context, value, declarations, assignments);
|
||||
function createDefaultValueCheck(value: Expression, defaultValue: Expression, declarations: VariableDeclaration[], assignments: Expression[]) {
|
||||
value = ensureIdentifier(value, declarations, assignments);
|
||||
let equalityExpr = factory.createStrictEqualityExpression(value, factory.createVoidZeroExpression());
|
||||
let conditionalExpr = factory.createConditionalExpression2(equalityExpr, defaultValue, value);
|
||||
return conditionalExpr;
|
||||
}
|
||||
|
||||
function transformDefaultValueAssignmentForInitializer(context: VisitorContext, parameter: ParameterDeclaration, name: Identifier, initializer: Expression, statements: Statement[]): void {
|
||||
function emitDefaultValueAssignmentForInitializer(parameter: ParameterDeclaration, name: Identifier, initializer: Expression, write: (node: Statement) => void): void {
|
||||
name = factory.cloneNode(name);
|
||||
let equalityExpr = factory.createStrictEqualityExpression(name, factory.createVoidZeroExpression());
|
||||
let initExpr = visitNode(context, initializer, transformNode);
|
||||
let initExpr = visitNode(initializer, transformNode);
|
||||
let assignExpr = factory.createAssignmentExpression(name, initExpr);
|
||||
let assignStmt = factory.createExpressionStatement(assignExpr);
|
||||
let trueStmt = factory.createBlock([assignStmt]);
|
||||
let ifStmt = factory.createIfStatement(equalityExpr, trueStmt);
|
||||
factory.startOnNewLine(ifStmt);
|
||||
statements.push(ifStmt);
|
||||
// return tag_statement`
|
||||
// if (${name} === void 0) {
|
||||
// ${name} = ${visit(context, initializer, transformNode)};
|
||||
// }
|
||||
// `;
|
||||
write(ifStmt);
|
||||
}
|
||||
|
||||
function transformRestParameter(context: VisitorContext, node: FunctionLikeDeclaration, statements: Statement[]): void {
|
||||
if (!needsTransform(node, TransformFlags.SubtreeContainsRestParameter)) {
|
||||
function emitRestParameter(node: FunctionLikeDeclaration, write: (node: Statement) => void): void {
|
||||
if (!(node.transformFlags & TransformFlags.SubtreeContainsRestParameter)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -356,14 +332,14 @@ namespace ts.transform {
|
|||
}
|
||||
|
||||
let restIndex = node.parameters.length - 1;
|
||||
let _i = context.createTempVariable(/*loopVariable*/ true);
|
||||
let name = <Identifier>context.getDeclarationName(restParam);
|
||||
let _i = createTempVariable(/*loopVariable*/ true);
|
||||
let name = <Identifier>getDeclarationName(restParam);
|
||||
let arrayExpr = factory.createArrayLiteralExpression([]);
|
||||
let paramVarDecl = factory.createVariableDeclaration2(name, arrayExpr);
|
||||
let paramVarDecls = factory.createVariableDeclarationList([paramVarDecl]);
|
||||
let paramVarStmt = factory.createVariableStatement2(paramVarDecls);
|
||||
factory.startOnNewLine(paramVarStmt);
|
||||
statements.push(paramVarStmt);
|
||||
write(paramVarStmt);
|
||||
|
||||
let restIndexExpr = factory.createNumericLiteral2(restIndex);
|
||||
let initializerVarDecl = factory.createVariableDeclaration2(_i, restIndexExpr);
|
||||
|
|
@ -383,17 +359,11 @@ namespace ts.transform {
|
|||
let forBody = factory.createBlock([assignStmt]);
|
||||
let forStmt = factory.createForStatement(initializerVarDecls, conditionExpr, incrementerExpr, forBody);
|
||||
factory.startOnNewLine(forStmt);
|
||||
statements.push(forStmt);
|
||||
// return tag_statements`
|
||||
// var ${name} = [];
|
||||
// for (var ${_i} = ${restIndex}; ${_i} < arguments.length; ${_i}++) {
|
||||
// ${name}[${_i}${restIndex ? tag_part` - ${restIndex}` : undefined}] = arguments[${_i}];
|
||||
// }
|
||||
// `;
|
||||
write(forStmt);
|
||||
}
|
||||
|
||||
function transformCaptureThisForNode(context: VisitorContext, node: Node, statements: Statement[]): void {
|
||||
if (isArrowFunction(node) || !needsTransform(node, TransformFlags.SubtreeCapturesLexicalThis)) {
|
||||
function emitCaptureThisForNode(node: Node, write: (node: Statement) => void): void {
|
||||
if (isArrowFunction(node) || !(node.transformFlags & TransformFlags.SubtreeCapturesLexicalThis)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -403,62 +373,57 @@ namespace ts.transform {
|
|||
let varDecls = factory.createVariableDeclarationList([varDecl]);
|
||||
let varStmt = factory.createVariableStatement2(varDecls);
|
||||
factory.startOnNewLine(varStmt);
|
||||
statements.push(varStmt);
|
||||
|
||||
// return tag_statement`
|
||||
// var _this = this;
|
||||
// `;
|
||||
write(varStmt);
|
||||
}
|
||||
|
||||
function transformMemberFunctions(context: VisitorContext, node: ClassLikeDeclaration, statements: Statement[]): void {
|
||||
function emitMemberFunctions(node: ClassLikeDeclaration, write: (node: Statement) => void): void {
|
||||
for (let member of node.members) {
|
||||
if (isSemicolonClassElement(member)) {
|
||||
transformSemicolonClassElement(context, member, statements);
|
||||
transformSemicolonClassElement(member, write);
|
||||
}
|
||||
else if (isMethodDeclaration(member)) {
|
||||
transformMethodDeclaration(context, node, member, statements);
|
||||
transformMethodDeclaration(node, member, write);
|
||||
}
|
||||
else if (isGetAccessor(member) || isSetAccessor(member)) {
|
||||
let accessors = getAllAccessorDeclarations(node.members, member);
|
||||
if (member === accessors.firstAccessor) {
|
||||
transformAccessorDeclaration(context, node, member, accessors, statements);
|
||||
transformAccessorDeclaration(node, accessors, write);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function transformSemicolonClassElement(context: VisitorContext, member: SemicolonClassElement, statements: Statement[]): void {
|
||||
function transformSemicolonClassElement(member: SemicolonClassElement, write: (node: Statement) => void): void {
|
||||
let stmt = factory.createEmptyStatement();
|
||||
factory.startOnNewLine(stmt);
|
||||
statements.push(stmt);
|
||||
write(stmt);
|
||||
}
|
||||
|
||||
function transformMethodDeclaration(context: VisitorContext, node: ClassLikeDeclaration, member: MethodDeclaration, classStatements: Statement[]): void {
|
||||
let prefix = context.getClassMemberPrefix(node, member);
|
||||
let propExpr = getMemberAccessForPropertyName(context, node, member);
|
||||
let funcExpr = transformToFunctionLikeDeclaration(context, member, /*name*/ undefined, /*location*/ undefined, factory.createFunctionExpression2);
|
||||
function transformMethodDeclaration(node: ClassLikeDeclaration, member: MethodDeclaration, write: (node: Statement) => void): void {
|
||||
let prefix = getClassMemberPrefix(node, member);
|
||||
let propExpr = getMemberAccessForPropertyName(node, member);
|
||||
let funcExpr = rewriteFunctionExpression(member, /*name*/ undefined, /*location*/ undefined);
|
||||
let assignExpr = factory.createAssignmentExpression(propExpr, funcExpr);
|
||||
let assignStmt = factory.createExpressionStatement(assignExpr, /*location*/ member);
|
||||
factory.startOnNewLine(assignStmt);
|
||||
classStatements.push(assignStmt);
|
||||
// return tag_statement`
|
||||
// ${property} = ${transformToFunctionExpression(context, member)};
|
||||
// `;
|
||||
write(assignStmt);
|
||||
}
|
||||
|
||||
function transformAccessorDeclaration(context: VisitorContext, node: ClassLikeDeclaration, member: AccessorDeclaration, accessors: AllAccessorDeclarations, classStatements: Statement[]): void {
|
||||
let prefix = context.getClassMemberPrefix(node, member);
|
||||
let name = getExpressionForPropertyName(context, member);
|
||||
function transformAccessorDeclaration(node: ClassLikeDeclaration, accessors: AllAccessorDeclarations, write: (node: Statement) => void): void {
|
||||
let firstAccessor = accessors.firstAccessor;
|
||||
let prefix = getClassMemberPrefix(node, firstAccessor);
|
||||
let name = getExpressionForPropertyName(firstAccessor);
|
||||
let descriptorExpr = factory.createObjectLiteralExpression2();
|
||||
if (accessors.getAccessor) {
|
||||
let funcExpr = transformToFunctionLikeDeclaration(context, accessors.getAccessor, /*name*/ undefined, /*location*/ accessors.getAccessor, factory.createFunctionExpression2);
|
||||
let funcExpr = rewriteFunctionExpression(accessors.getAccessor, /*name*/ undefined, /*location*/ accessors.getAccessor);
|
||||
let getName = factory.createIdentifier("get");
|
||||
let getProp = factory.createPropertyAssignment(getName, funcExpr);
|
||||
factory.startOnNewLine(getProp);
|
||||
descriptorExpr.properties.push(getProp);
|
||||
}
|
||||
|
||||
if (accessors.setAccessor) {
|
||||
let funcExpr = transformToFunctionLikeDeclaration(context, accessors.setAccessor, /*name*/ undefined, /*location*/ accessors.setAccessor, factory.createFunctionExpression2);
|
||||
let funcExpr = rewriteFunctionExpression(accessors.setAccessor, /*name*/ undefined, /*location*/ accessors.setAccessor);
|
||||
let setName = factory.createIdentifier("set");
|
||||
let setProp = factory.createPropertyAssignment(setName, funcExpr);
|
||||
factory.startOnNewLine(setProp);
|
||||
|
|
@ -478,84 +443,81 @@ namespace ts.transform {
|
|||
|
||||
let definePropertyExpr = factory.createDefinePropertyCall(prefix, name, descriptorExpr);
|
||||
let definePropertyStmt = factory.createExpressionStatement(definePropertyExpr);
|
||||
classStatements.push(definePropertyStmt);
|
||||
// return tag_statement`
|
||||
// Object.defineProperty(${prefix}, ${name}, {
|
||||
// ${accessors.getAccessor && tag_part`get: ${transformToFunctionExpression(context, accessors.getAccessor)}, `}
|
||||
// ${accessors.setAccessor && tag_part`set: ${transformToFunctionExpression(context, accessors.setAccessor)}, `}
|
||||
// enumerable: true,
|
||||
// configurable: true
|
||||
// });
|
||||
// `;
|
||||
write(definePropertyStmt);
|
||||
}
|
||||
|
||||
function transformFunctionExpression(context: VisitorContext, node: FunctionExpression, write: (node: Expression) => void): void {
|
||||
let func = transformToFunctionLikeDeclaration(context, node, node.name, /*location*/ node, factory.createFunctionExpression2);
|
||||
write(func);
|
||||
function transformFunctionExpression(node: FunctionExpression, write: (node: Expression) => void): void {
|
||||
write(rewriteFunctionExpression(node, node.name, /*location*/ node));
|
||||
}
|
||||
|
||||
function transformFunctionDeclaration(context: VisitorContext, node: FunctionDeclaration, write: (node: Statement) => void): void {
|
||||
let func = transformToFunctionLikeDeclaration(context, node, node.name, /*location*/ node, factory.createFunctionDeclaration2);
|
||||
write(func);
|
||||
function rewriteFunctionExpression(node: FunctionLikeDeclaration, name: Identifier, location: TextRange): FunctionExpression {
|
||||
let parameters = visitNodes(node.parameters, transformNode);
|
||||
let body = factory.createBlock([], node.body);
|
||||
emitNode(node, body.statements, transformFunctionBody, /*newLexicalEnvironment*/ true);
|
||||
return factory.createFunctionExpression2(name, parameters, body, location);
|
||||
}
|
||||
|
||||
function transformToFunctionLikeDeclaration<T extends FunctionLikeDeclaration>(context: VisitorContext, node: FunctionLikeDeclaration, name: Identifier, location: TextRange,
|
||||
createFunctionLike: (name: DeclarationName, parameters: ParameterDeclaration[], body: Block, location: TextRange) => T): T {
|
||||
function transformFunctionDeclaration(node: FunctionDeclaration, write: (node: Statement) => void): void {
|
||||
let parameters = visitNodes(node.parameters, transformNode);
|
||||
let body = factory.createBlock([], node.body);
|
||||
emitNode(node, body.statements, transformFunctionBody, /*newLexicalEnvironment*/ true);
|
||||
write(factory.createFunctionDeclaration2(node.name, parameters, body, /*location*/ node));
|
||||
}
|
||||
|
||||
function transformToFunctionLikeDeclaration<T extends FunctionLikeDeclaration>(node: FunctionLikeDeclaration, name: Identifier, location: TextRange,
|
||||
createfn: (name: DeclarationName, parameters: ParameterDeclaration[], body: Block, location: TextRange) => T): T {
|
||||
|
||||
context.pushLexicalEnvironment();
|
||||
|
||||
let parameters = visitNodes(context, node.parameters, transformNode);
|
||||
let newBody = factory.createBlock([]);
|
||||
|
||||
transformCaptureThisForNode(context, node, newBody.statements);
|
||||
transformDefaultValueAssignments(context, node, newBody.statements);
|
||||
transformRestParameter(context, node, newBody.statements);
|
||||
let parameters = visitNodes(node.parameters, transformNode);
|
||||
let newBody = factory.createBlock([], /*location*/ isBlock(node.body) ? node.body : undefined);
|
||||
emitNode(node, newBody.statements, transformFunctionBody, /*newLexicalEnvironment*/ true);
|
||||
|
||||
let originalBody = node.body;
|
||||
if (isBlock(originalBody)) {
|
||||
let statements = visitNodes(context, originalBody.statements, transformNode);
|
||||
newBody.statements.push(...statements);
|
||||
factory.setTextRange(newBody, originalBody);
|
||||
}
|
||||
else {
|
||||
let expr = visitNode(context, originalBody, transformNode);
|
||||
if (expr) {
|
||||
let returnStmt = factory.createReturnStatement(expr);
|
||||
newBody.statements.push(returnStmt);
|
||||
if (!context.childNodeStartPositionIsOnSameLine(node, originalBody)) {
|
||||
factory.startOnNewLine(returnStmt);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
context.writeHoistedDeclarations(newBody.statements);
|
||||
context.popLexicalEnvironment();
|
||||
|
||||
let func = createFunctionLike(name, parameters, newBody, location);
|
||||
let func = createfn(name, parameters, newBody, location);
|
||||
return func;
|
||||
}
|
||||
|
||||
function getExpressionForPropertyName(context: VisitorContext, member: ClassElement): Expression {
|
||||
function transformFunctionBody(node: FunctionLikeDeclaration, write: (node: Statement) => void) {
|
||||
emitCaptureThisForNode(node, write);
|
||||
emitDefaultValueAssignments(node, write);
|
||||
emitRestParameter(node, write);
|
||||
|
||||
let body = node.body;
|
||||
if (isBlock(body)) {
|
||||
pipeNodes(body.statements, write, transformNode);
|
||||
}
|
||||
else {
|
||||
let expr = visitNode(body, transformNode);
|
||||
if (expr) {
|
||||
let returnStmt = factory.createReturnStatement(expr);
|
||||
if (!childNodeStartPositionIsOnSameLine(node, body)) {
|
||||
factory.startOnNewLine(returnStmt);
|
||||
}
|
||||
|
||||
write(returnStmt);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function getExpressionForPropertyName(member: ClassElement): Expression {
|
||||
let memberName = <PropertyName>member.name;
|
||||
if (isIdentifier(memberName)) {
|
||||
return factory.createStringLiteral(memberName.text);
|
||||
}
|
||||
else if (isComputedPropertyName(memberName)) {
|
||||
return visitNode(context, memberName.expression, transformNode);
|
||||
return visitNode(memberName.expression, transformNode);
|
||||
}
|
||||
else {
|
||||
return factory.cloneNode(memberName);
|
||||
}
|
||||
}
|
||||
|
||||
function getMemberAccessForPropertyName(context: VisitorContext, node: ClassLikeDeclaration, member: ClassElement): LeftHandSideExpression {
|
||||
let target = context.getClassMemberPrefix(node, member);
|
||||
function getMemberAccessForPropertyName(node: ClassLikeDeclaration, member: ClassElement): LeftHandSideExpression {
|
||||
let target = getClassMemberPrefix(node, member);
|
||||
let memberName = <PropertyName>member.name;
|
||||
if (isIdentifier(memberName)) {
|
||||
return factory.createPropertyAccessExpression2(target, factory.cloneNode(memberName));
|
||||
}
|
||||
else if (isComputedPropertyName(memberName)) {
|
||||
let expression = visitNode(context, memberName.expression, transformNode);
|
||||
let expression = visitNode(memberName.expression, transformNode);
|
||||
return factory.createElementAccessExpression2(target, expression);
|
||||
}
|
||||
else {
|
||||
|
|
@ -563,22 +525,19 @@ namespace ts.transform {
|
|||
}
|
||||
}
|
||||
|
||||
function transformThisKeyword(context: VisitorContext, node: LeftHandSideExpression): LeftHandSideExpression {
|
||||
let container = getThisContainer(node, /*includeArrowFunctions*/ true, context.getAncestorOrSelfCallback, /*offset*/ 0);
|
||||
function transformThisKeyword(node: LeftHandSideExpression): LeftHandSideExpression {
|
||||
let container = getThisContainer(node, /*includeArrowFunctions*/ true, peekNode, /*offset*/ 0);
|
||||
if (isArrowFunction(container)) {
|
||||
let thisName = factory.createIdentifier("_this");
|
||||
return thisName;
|
||||
// return tag_id`_this`;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
function transformInitialSuperCall(context: VisitorContext, node: ExpressionStatement, write: (node: Statement) => void) {
|
||||
function transformInitialSuperCall(node: ExpressionStatement, write: (node: Statement) => void) {
|
||||
let statement = createDefaultSuperCall();
|
||||
return write(statement);
|
||||
// return tag_statement`
|
||||
// _super.apply(this, arguments);
|
||||
// `;
|
||||
}
|
||||
|
||||
function createDefaultSuperCall() {
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -316,7 +316,6 @@ namespace ts {
|
|||
bindTime = 0;
|
||||
checkTime = 0;
|
||||
emitTime = 0;
|
||||
transform.aggregateTime = 0;
|
||||
transform.transformTime = 0;
|
||||
|
||||
let program = createProgram(fileNames, compilerOptions, compilerHost);
|
||||
|
|
@ -350,7 +349,6 @@ namespace ts {
|
|||
reportTimeStatistic("Parse time", programTime);
|
||||
reportTimeStatistic("Bind time", bindTime);
|
||||
reportTimeStatistic("Check time", checkTime);
|
||||
reportTimeStatistic("Pre-transform time", transform.aggregateTime);
|
||||
reportTimeStatistic("Transform time", transform.transformTime);
|
||||
reportTimeStatistic("Emit time", emitTime);
|
||||
reportTimeStatistic("Total time", programTime + bindTime + checkTime + emitTime);
|
||||
|
|
|
|||
|
|
@ -430,76 +430,45 @@ namespace ts {
|
|||
|
||||
// A fact that states that a node is TypeScript syntax
|
||||
TypeScript = 1 << 1,
|
||||
|
||||
// A fact that states that this node or its subtree contains TypeScript
|
||||
// syntax
|
||||
ContainsTypeScript = 1 << 2,
|
||||
ContainsTypeScriptPropertyDeclarationWithInitializer = 1 << 3,
|
||||
ContainsTypeScriptClassSyntaxExtension = 1 << 4,
|
||||
ContainsTypeScriptDecorator = 1 << 6,
|
||||
ContainsTypeScriptClassSyntaxExtension = 1 << 3,
|
||||
ContainsTypeScriptDecorator = 1 << 4,
|
||||
ContainsTypeScriptModifier = 1 << 20,
|
||||
|
||||
// A fact that states that a node is ES6 syntax
|
||||
ES6 = 1 << 7,
|
||||
ES6 = 1 << 5,
|
||||
ContainsES6 = 1 << 6,
|
||||
ContainsES6Yield = 1 << 7,
|
||||
ContainsES6ParameterBindingPattern = 1 << 8,
|
||||
ContainsES6VariableBindingPattern = 1 << 9,
|
||||
ContainsES6RestParameter = 1 << 10,
|
||||
ContainsES6ParameterInitializer = 1 << 11,
|
||||
ContainsES6SpreadElement = 1 << 12,
|
||||
ContainsES6LetOrConst = 1 << 13,
|
||||
ContainsES6ComputedPropertyName = 1 << 14,
|
||||
|
||||
// A fact that states that this node or its subtree contains ES6 syntax
|
||||
ContainsES6 = 1 << 8,
|
||||
ContainsCapturedThis = 1 << 15,
|
||||
ContainsLexicalThis = 1 << 16,
|
||||
ContainsHoistedDeclaration = 1 << 17,
|
||||
ContainsCompletionStatement = 1 << 18,
|
||||
|
||||
ContainsES6Yield = 1 << 9,
|
||||
|
||||
// A fact that states that this node or its subtree contains an ES6 Binding Pattern
|
||||
ContainsES6ParameterBindingPattern = 1 << 10,
|
||||
ContainsES6VariableBindingPattern = 1 << 11,
|
||||
|
||||
// A fact that states that this node or its subtree contains an ES6 Rest Parameter
|
||||
ContainsES6RestParameter = 1 << 12,
|
||||
|
||||
// A fact that states that this node or its subtree contains an ES6 Parameter Initializer
|
||||
ContainsES6ParameterInitializer = 1 << 13,
|
||||
|
||||
ContainsES6SpreadElement = 1 << 14,
|
||||
|
||||
ContainsES6LetOrConst = 1 << 15,
|
||||
|
||||
ContainsES6ComputedPropertyName = 1 << 16,
|
||||
|
||||
// A fact that states that this node or its subtree contains a captured lexical `this` binding
|
||||
ContainsCapturedThis = 1 << 17,
|
||||
|
||||
// A fact that states that this node or its subtree contains a lexical `this` binding
|
||||
ContainsLexicalThis = 1 << 18,
|
||||
|
||||
ContainsHoistedDeclaration = 1 << 19,
|
||||
ContainsCompletionStatement = 1 << 20,
|
||||
|
||||
// Template Transform Facts
|
||||
ContainsTemplatePlaceholder = 1 << 21,
|
||||
LexicalEnvironment = 1 << 19,
|
||||
|
||||
//
|
||||
// Assertions
|
||||
//
|
||||
|
||||
ThisNodeIsTypeScript = TypeScript | ContainsTypeScript,
|
||||
ThisNodeIsTypeScriptModifier = ThisNodeIsTypeScript | ContainsTypeScriptModifier,
|
||||
ThisNodeIsTypeScriptClassSyntaxExtension = ThisNodeIsTypeScript | ContainsTypeScriptClassSyntaxExtension,
|
||||
ThisNodeIsTypeScriptDecorator = ThisNodeIsTypeScriptClassSyntaxExtension | ContainsTypeScriptDecorator,
|
||||
|
||||
// Asserts that this node is ES6, and any subtree that contains it contains ES6.
|
||||
ThisNodeIsES6 = ES6 | ContainsES6,
|
||||
|
||||
ThisNodeIsES6Yield = ThisNodeIsES6 | ContainsES6Yield,
|
||||
|
||||
// Asserts that this node is ES6, and any subtree that contains it contains an
|
||||
// ES6 binding pattern.
|
||||
ThisNodeIsES6ParameterBindingPattern = ThisNodeIsES6 | ContainsES6ParameterBindingPattern,
|
||||
ThisNodeIsES6VariableBindingPattern = ThisNodeIsES6 | ContainsES6VariableBindingPattern,
|
||||
|
||||
// Asserts that this node is ES6, and any subtree that contains it contains an
|
||||
// ES6 rest parameter.
|
||||
ThisNodeIsES6RestParameter = ThisNodeIsES6 | ContainsES6RestParameter,
|
||||
|
||||
// Asserts that this node is ES6, and any subtree that contains it contains an
|
||||
// ES6 parameter initializer.
|
||||
ThisNodeIsES6ParameterInitializer = ThisNodeIsES6 | ContainsES6ParameterInitializer,
|
||||
|
||||
ThisNodeIsES6SpreadElement = ThisNodeIsES6 | ContainsES6SpreadElement,
|
||||
ThisNodeIsES6LetOrConst = ThisNodeIsES6 | ContainsES6LetOrConst,
|
||||
|
||||
|
|
@ -508,6 +477,7 @@ namespace ts {
|
|||
ThisNodeIsThisKeyword = ContainsLexicalThis,
|
||||
ThisNodeIsHoistedDeclaration = ContainsHoistedDeclaration,
|
||||
ThisNodeIsCompletionStatement = ContainsCompletionStatement,
|
||||
ThisNodeStartsNewLexicalEnvironment = LexicalEnvironment,
|
||||
|
||||
//
|
||||
// Masks
|
||||
|
|
@ -581,9 +551,6 @@ namespace ts {
|
|||
ContainsES6RestParameter |
|
||||
ContainsCapturedThis,
|
||||
|
||||
SubtreeContainsTemplatePlaceholder =
|
||||
ContainsTemplatePlaceholder,
|
||||
|
||||
//
|
||||
// Scope Exclusions
|
||||
//
|
||||
|
|
@ -591,6 +558,9 @@ namespace ts {
|
|||
NodeExcludes =
|
||||
ThisNodeIsTypeScriptMask |
|
||||
ThisNodeIsES6Mask,
|
||||
|
||||
ParameterScopeExcludes =
|
||||
ContainsTypeScriptModifier,
|
||||
|
||||
ArrowFunctionScopeExcludes =
|
||||
ContainsES6Yield |
|
||||
|
|
@ -655,7 +625,7 @@ namespace ts {
|
|||
Failed = 2,
|
||||
FailedAndReported = 3
|
||||
}
|
||||
|
||||
|
||||
// @factoryhidden("decorators", true)
|
||||
// @factoryhidden("modifiers", true)
|
||||
// @factoryhidden("parent", true)
|
||||
|
|
@ -891,6 +861,7 @@ namespace ts {
|
|||
* MethodDeclaration
|
||||
* AccessorDeclaration
|
||||
*/
|
||||
// @
|
||||
export interface FunctionLikeDeclaration extends SignatureDeclaration {
|
||||
_functionLikeDeclarationBrand: any;
|
||||
|
||||
|
|
@ -899,7 +870,7 @@ namespace ts {
|
|||
// @factoryparam
|
||||
questionToken?: Node;
|
||||
|
||||
// @visitor("visitBlockOrExpressionInNewLexicalEnvironment")
|
||||
// @newlexicalenvironment()
|
||||
body?: Block | Expression;
|
||||
}
|
||||
|
||||
|
|
@ -909,7 +880,7 @@ namespace ts {
|
|||
export interface FunctionDeclaration extends FunctionLikeDeclaration, DeclarationStatement {
|
||||
name?: Identifier;
|
||||
|
||||
// @visitor("visitBlockInNewLexicalEnvironment")
|
||||
// @newlexicalenvironment()
|
||||
body?: Block;
|
||||
}
|
||||
|
||||
|
|
@ -936,6 +907,8 @@ namespace ts {
|
|||
// @factoryorder("decorators", "modifiers", "asteriskToken", "name", "typeParameters", "parameters", "type", "body")
|
||||
export interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
name: PropertyName;
|
||||
|
||||
// @newlexicalenvironment()
|
||||
body?: Block;
|
||||
}
|
||||
|
||||
|
|
@ -946,6 +919,7 @@ namespace ts {
|
|||
// @factoryhidden("name")
|
||||
// @factoryorder("decorators", "modifiers", "name", "parameters", "type", "body")
|
||||
export interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
|
||||
// @newlexicalenvironment()
|
||||
body?: Block;
|
||||
}
|
||||
|
||||
|
|
@ -965,7 +939,8 @@ namespace ts {
|
|||
export interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
_accessorDeclarationBrand: any;
|
||||
name: PropertyName;
|
||||
// @visitor("visitBlockInNewLexicalEnvironment")
|
||||
|
||||
// @newlexicalenvironment()
|
||||
body: Block;
|
||||
}
|
||||
|
||||
|
|
@ -1171,7 +1146,7 @@ namespace ts {
|
|||
export interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration {
|
||||
name?: Identifier;
|
||||
|
||||
// @visitor("visitBlockOrExpressionInNewLexicalEnvironment")
|
||||
// @newlexicalenvironment()
|
||||
body: Block | Expression; // Required, whereas the member inherited from FunctionDeclaration is optional
|
||||
}
|
||||
|
||||
|
|
@ -1568,7 +1543,7 @@ namespace ts {
|
|||
export interface ModuleDeclaration extends DeclarationStatement {
|
||||
name: Identifier | LiteralExpression;
|
||||
|
||||
// @visitor("visitModuleBlockOrModuleDeclarationInNewLexicalEnvironment")
|
||||
// @newlexicalenvironment()
|
||||
body: ModuleBlock | ModuleDeclaration;
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue