mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-02-08 18:11:45 -06:00
Generate transform.generated.ts from processTypes script
This commit is contained in:
Ron Buckton
parent
66d3060210
commit
a665ef0384
@ -41,6 +41,8 @@ var compilerSources = [
|
||||
"utilities.ts",
|
||||
"binder.ts",
|
||||
"checker.ts",
|
||||
"transform.ts",
|
||||
"transform.generated.ts",
|
||||
"declarationEmitter.ts",
|
||||
"emitter.ts",
|
||||
"program.ts",
|
||||
@ -60,6 +62,8 @@ var servicesSources = [
|
||||
"utilities.ts",
|
||||
"binder.ts",
|
||||
"checker.ts",
|
||||
"transform.ts",
|
||||
"transform.generated.ts",
|
||||
"declarationEmitter.ts",
|
||||
"emitter.ts",
|
||||
"program.ts",
|
||||
@ -357,6 +361,7 @@ var processTypesJs = path.join(scriptsDirectory, "processTypes.js");
|
||||
var processTypesTs = path.join(scriptsDirectory, "processTypes.ts");
|
||||
var typesTs = path.join(compilerDirectory, "types.ts");
|
||||
var factoryGeneratedTs = path.join(compilerDirectory, "factory.generated.ts");
|
||||
var transformGeneratedTs = path.join(compilerDirectory, "transform.generated.ts");
|
||||
|
||||
file(processTypesTs);
|
||||
|
||||
@ -384,8 +389,10 @@ file(factoryGeneratedTs, [processTypesJs, typesTs], function() {
|
||||
ex.run();
|
||||
}, { async: true });
|
||||
|
||||
file(transformGeneratedTs, [factoryGeneratedTs]);
|
||||
|
||||
desc("Generates a TypeScript file that contains factory methods to create each Syntax Node.")
|
||||
task("generate-factory", [factoryGeneratedTs]);
|
||||
task("generate-factory", [factoryGeneratedTs, transformGeneratedTs]);
|
||||
|
||||
// Local target to build the compiler and services
|
||||
var tscFile = path.join(builtLocalDirectory, compilerFilename);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -91,7 +91,7 @@ namespace ts {
|
||||
return node;
|
||||
}
|
||||
export function createParameter(decorators?: Array<Decorator>, modifiers?: Array<Node>, dotDotDotToken?: Node,
|
||||
name?: Identifier | BindingPattern, questionToken?: Node, type?: TypeNode, initializer?: Expression): ParameterDeclaration {
|
||||
name?: BindingPattern | Identifier, questionToken?: Node, type?: TypeNode, initializer?: Expression): ParameterDeclaration {
|
||||
let node = createNode<ParameterDeclaration>(SyntaxKind.Parameter);
|
||||
if (arguments.length) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
@ -105,7 +105,7 @@ namespace ts {
|
||||
return node;
|
||||
}
|
||||
export function updateParameter(node: ParameterDeclaration, decorators: Array<Decorator>, modifiers: Array<Node>,
|
||||
name: Identifier | BindingPattern, type: TypeNode, initializer: Expression): ParameterDeclaration {
|
||||
name: BindingPattern | Identifier, type: TypeNode, initializer: Expression): ParameterDeclaration {
|
||||
if (decorators !== node.decorators || modifiers !== node.modifiers || name !== node.name || type !== node.type ||
|
||||
initializer !== node.initializer) {
|
||||
let newNode = createParameter(decorators, modifiers, node.dotDotDotToken, name, node.questionToken, type, initializer);
|
||||
@ -510,7 +510,7 @@ namespace ts {
|
||||
return node;
|
||||
}
|
||||
export function createBindingElement(decorators?: Array<Decorator>, modifiers?: Array<Node>, propertyName?: Identifier,
|
||||
dotDotDotToken?: Node, name?: Identifier | BindingPattern, initializer?: Expression): BindingElement {
|
||||
dotDotDotToken?: Node, name?: BindingPattern | Identifier, initializer?: Expression): BindingElement {
|
||||
let node = createNode<BindingElement>(SyntaxKind.BindingElement);
|
||||
if (arguments.length) {
|
||||
node.decorators = decorators && createNodeArray(decorators)
|
||||
@ -523,7 +523,7 @@ namespace ts {
|
||||
return node;
|
||||
}
|
||||
export function updateBindingElement(node: BindingElement, decorators: Array<Decorator>, modifiers: Array<Node>, propertyName: Identifier,
|
||||
name: Identifier | BindingPattern, initializer: Expression): BindingElement {
|
||||
name: BindingPattern | Identifier, initializer: Expression): BindingElement {
|
||||
if (decorators !== node.decorators || modifiers !== node.modifiers || propertyName !== node.propertyName || name !== node.name ||
|
||||
initializer !== node.initializer) {
|
||||
let newNode = createBindingElement(decorators, modifiers, propertyName, node.dotDotDotToken, name, initializer);
|
||||
@ -984,8 +984,8 @@ namespace ts {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
export function createEmptyStatement(): Statement {
|
||||
return createNode<Statement>(SyntaxKind.EmptyStatement);
|
||||
export function createEmptyStatement(): EmptyStatement {
|
||||
return createNode<EmptyStatement>(SyntaxKind.EmptyStatement);
|
||||
}
|
||||
export function createExpressionStatement(expression?: Expression): ExpressionStatement {
|
||||
let node = createNode<ExpressionStatement>(SyntaxKind.ExpressionStatement);
|
||||
@ -1046,7 +1046,7 @@ namespace ts {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
export function createForStatement(initializer?: VariableDeclarationList | Expression, condition?: Expression, incrementor?: Expression,
|
||||
export function createForStatement(initializer?: Expression | VariableDeclarationList, condition?: Expression, incrementor?: Expression,
|
||||
statement?: Statement): ForStatement {
|
||||
let node = createNode<ForStatement>(SyntaxKind.ForStatement);
|
||||
if (arguments.length) {
|
||||
@ -1057,7 +1057,7 @@ namespace ts {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
export function updateForStatement(node: ForStatement, initializer: VariableDeclarationList | Expression, condition: Expression,
|
||||
export function updateForStatement(node: ForStatement, initializer: Expression | VariableDeclarationList, condition: Expression,
|
||||
incrementor: Expression, statement: Statement): ForStatement {
|
||||
if (initializer !== node.initializer || condition !== node.condition || incrementor !== node.incrementor || statement !== node.statement) {
|
||||
let newNode = createForStatement(initializer, condition, incrementor, statement);
|
||||
@ -1065,7 +1065,7 @@ namespace ts {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
export function createForInStatement(initializer?: VariableDeclarationList | Expression, expression?: Expression, statement?: Statement
|
||||
export function createForInStatement(initializer?: Expression | VariableDeclarationList, expression?: Expression, statement?: Statement
|
||||
): ForInStatement {
|
||||
let node = createNode<ForInStatement>(SyntaxKind.ForInStatement);
|
||||
if (arguments.length) {
|
||||
@ -1075,7 +1075,7 @@ namespace ts {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
export function updateForInStatement(node: ForInStatement, initializer: VariableDeclarationList | Expression, expression: Expression,
|
||||
export function updateForInStatement(node: ForInStatement, initializer: Expression | VariableDeclarationList, expression: Expression,
|
||||
statement: Statement): ForInStatement {
|
||||
if (initializer !== node.initializer || expression !== node.expression || statement !== node.statement) {
|
||||
let newNode = createForInStatement(initializer, expression, statement);
|
||||
@ -1083,7 +1083,7 @@ namespace ts {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
export function createForOfStatement(initializer?: VariableDeclarationList | Expression, expression?: Expression, statement?: Statement
|
||||
export function createForOfStatement(initializer?: Expression | VariableDeclarationList, expression?: Expression, statement?: Statement
|
||||
): ForOfStatement {
|
||||
let node = createNode<ForOfStatement>(SyntaxKind.ForOfStatement);
|
||||
if (arguments.length) {
|
||||
@ -1093,7 +1093,7 @@ namespace ts {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
export function updateForOfStatement(node: ForOfStatement, initializer: VariableDeclarationList | Expression, expression: Expression,
|
||||
export function updateForOfStatement(node: ForOfStatement, initializer: Expression | VariableDeclarationList, expression: Expression,
|
||||
statement: Statement): ForOfStatement {
|
||||
if (initializer !== node.initializer || expression !== node.expression || statement !== node.statement) {
|
||||
let newNode = createForOfStatement(initializer, expression, statement);
|
||||
@ -1210,10 +1210,10 @@ namespace ts {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
export function createDebuggerStatement(): Statement {
|
||||
return createNode<Statement>(SyntaxKind.DebuggerStatement);
|
||||
export function createDebuggerStatement(): DebuggerStatement {
|
||||
return createNode<DebuggerStatement>(SyntaxKind.DebuggerStatement);
|
||||
}
|
||||
export function createVariableDeclaration(decorators?: Array<Decorator>, modifiers?: Array<Node>, name?: Identifier | BindingPattern,
|
||||
export function createVariableDeclaration(decorators?: Array<Decorator>, modifiers?: Array<Node>, name?: BindingPattern | Identifier,
|
||||
type?: TypeNode, initializer?: Expression): VariableDeclaration {
|
||||
let node = createNode<VariableDeclaration>(SyntaxKind.VariableDeclaration);
|
||||
if (arguments.length) {
|
||||
@ -1226,7 +1226,7 @@ namespace ts {
|
||||
return node;
|
||||
}
|
||||
export function updateVariableDeclaration(node: VariableDeclaration, decorators: Array<Decorator>, modifiers: Array<Node>,
|
||||
name: Identifier | BindingPattern, type: TypeNode, initializer: Expression): VariableDeclaration {
|
||||
name: BindingPattern | Identifier, type: TypeNode, initializer: Expression): VariableDeclaration {
|
||||
if (decorators !== node.decorators || modifiers !== node.modifiers || name !== node.name || type !== node.type ||
|
||||
initializer !== node.initializer) {
|
||||
let newNode = createVariableDeclaration(decorators, modifiers, name, type, initializer);
|
||||
@ -1443,7 +1443,7 @@ namespace ts {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
export function createImportClause(name?: Identifier, namedBindings?: NamespaceImport | NamedImports): ImportClause {
|
||||
export function createImportClause(name?: Identifier, namedBindings?: NamedImports | NamespaceImport): ImportClause {
|
||||
let node = createNode<ImportClause>(SyntaxKind.ImportClause);
|
||||
if (arguments.length) {
|
||||
node.name = name;
|
||||
@ -1451,7 +1451,7 @@ namespace ts {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
export function updateImportClause(node: ImportClause, name: Identifier, namedBindings: NamespaceImport | NamedImports): ImportClause {
|
||||
export function updateImportClause(node: ImportClause, name: Identifier, namedBindings: NamedImports | NamespaceImport): ImportClause {
|
||||
if (name !== node.name || namedBindings !== node.namedBindings) {
|
||||
let newNode = createImportClause(name, namedBindings);
|
||||
return updateFrom(node, newNode);
|
||||
@ -2101,6 +2101,21 @@ namespace ts {
|
||||
export function isIdentifier(node: Node): node is Identifier {
|
||||
return node && node.kind === SyntaxKind.Identifier;
|
||||
}
|
||||
export function isFalseKeyword(node: Node): node is LeftHandSideExpression {
|
||||
return node && node.kind === SyntaxKind.FalseKeyword;
|
||||
}
|
||||
export function isNullKeyword(node: Node): node is LeftHandSideExpression {
|
||||
return node && node.kind === SyntaxKind.NullKeyword;
|
||||
}
|
||||
export function isSuperKeyword(node: Node): node is LeftHandSideExpression {
|
||||
return node && node.kind === SyntaxKind.SuperKeyword;
|
||||
}
|
||||
export function isThisKeyword(node: Node): node is LeftHandSideExpression {
|
||||
return node && node.kind === SyntaxKind.ThisKeyword;
|
||||
}
|
||||
export function isTrueKeyword(node: Node): node is LeftHandSideExpression {
|
||||
return node && node.kind === SyntaxKind.TrueKeyword;
|
||||
}
|
||||
export function isQualifiedName(node: Node): node is QualifiedName {
|
||||
return node && node.kind === SyntaxKind.QualifiedName;
|
||||
}
|
||||
@ -2278,7 +2293,7 @@ namespace ts {
|
||||
export function isVariableStatement(node: Node): node is VariableStatement {
|
||||
return node && node.kind === SyntaxKind.VariableStatement;
|
||||
}
|
||||
export function isEmptyStatement(node: Node): node is Statement {
|
||||
export function isEmptyStatement(node: Node): node is EmptyStatement {
|
||||
return node && node.kind === SyntaxKind.EmptyStatement;
|
||||
}
|
||||
export function isExpressionStatement(node: Node): node is ExpressionStatement {
|
||||
@ -2326,7 +2341,7 @@ namespace ts {
|
||||
export function isTryStatement(node: Node): node is TryStatement {
|
||||
return node && node.kind === SyntaxKind.TryStatement;
|
||||
}
|
||||
export function isDebuggerStatement(node: Node): node is Statement {
|
||||
export function isDebuggerStatement(node: Node): node is DebuggerStatement {
|
||||
return node && node.kind === SyntaxKind.DebuggerStatement;
|
||||
}
|
||||
export function isVariableDeclaration(node: Node): node is VariableDeclaration {
|
||||
@ -2506,4 +2521,338 @@ namespace ts {
|
||||
export function isJSDocTemplateTag(node: Node): node is JSDocTemplateTag {
|
||||
return node && node.kind === SyntaxKind.JSDocTemplateTag;
|
||||
}
|
||||
export function isEntityName(node: Node): node is EntityName {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.QualifiedName:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isBindingPatternOrIdentifier(node: Node): node is BindingPattern | Identifier {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.ObjectBindingPattern:
|
||||
case SyntaxKind.ArrayBindingPattern:
|
||||
case SyntaxKind.Identifier:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isUnaryExpression(node: Node): node is UnaryExpression {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.StringLiteral:
|
||||
case SyntaxKind.PrefixUnaryExpression:
|
||||
case SyntaxKind.PostfixUnaryExpression:
|
||||
case SyntaxKind.TrueKeyword:
|
||||
case SyntaxKind.FalseKeyword:
|
||||
case SyntaxKind.NullKeyword:
|
||||
case SyntaxKind.ThisKeyword:
|
||||
case SyntaxKind.SuperKeyword:
|
||||
case SyntaxKind.DeleteExpression:
|
||||
case SyntaxKind.TypeOfExpression:
|
||||
case SyntaxKind.VoidExpression:
|
||||
case SyntaxKind.AwaitExpression:
|
||||
case SyntaxKind.FunctionExpression:
|
||||
case SyntaxKind.NumericLiteral:
|
||||
case SyntaxKind.RegularExpressionLiteral:
|
||||
case SyntaxKind.NoSubstitutionTemplateLiteral:
|
||||
case SyntaxKind.TemplateHead:
|
||||
case SyntaxKind.TemplateMiddle:
|
||||
case SyntaxKind.TemplateTail:
|
||||
case SyntaxKind.TemplateExpression:
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
case SyntaxKind.ArrayLiteralExpression:
|
||||
case SyntaxKind.ObjectLiteralExpression:
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
case SyntaxKind.ElementAccessExpression:
|
||||
case SyntaxKind.CallExpression:
|
||||
case SyntaxKind.NewExpression:
|
||||
case SyntaxKind.TaggedTemplateExpression:
|
||||
case SyntaxKind.TypeAssertionExpression:
|
||||
case SyntaxKind.JsxElement:
|
||||
case SyntaxKind.JsxSelfClosingElement:
|
||||
case SyntaxKind.ClassExpression:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isBlockOrExpression(node: Node): node is Block | Expression {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.Block:
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.StringLiteral:
|
||||
case SyntaxKind.OmittedExpression:
|
||||
case SyntaxKind.PrefixUnaryExpression:
|
||||
case SyntaxKind.PostfixUnaryExpression:
|
||||
case SyntaxKind.TrueKeyword:
|
||||
case SyntaxKind.FalseKeyword:
|
||||
case SyntaxKind.NullKeyword:
|
||||
case SyntaxKind.ThisKeyword:
|
||||
case SyntaxKind.SuperKeyword:
|
||||
case SyntaxKind.DeleteExpression:
|
||||
case SyntaxKind.TypeOfExpression:
|
||||
case SyntaxKind.VoidExpression:
|
||||
case SyntaxKind.AwaitExpression:
|
||||
case SyntaxKind.YieldExpression:
|
||||
case SyntaxKind.BinaryExpression:
|
||||
case SyntaxKind.ConditionalExpression:
|
||||
case SyntaxKind.FunctionExpression:
|
||||
case SyntaxKind.ArrowFunction:
|
||||
case SyntaxKind.NumericLiteral:
|
||||
case SyntaxKind.RegularExpressionLiteral:
|
||||
case SyntaxKind.NoSubstitutionTemplateLiteral:
|
||||
case SyntaxKind.TemplateHead:
|
||||
case SyntaxKind.TemplateMiddle:
|
||||
case SyntaxKind.TemplateTail:
|
||||
case SyntaxKind.TemplateExpression:
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
case SyntaxKind.ArrayLiteralExpression:
|
||||
case SyntaxKind.SpreadElementExpression:
|
||||
case SyntaxKind.ObjectLiteralExpression:
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
case SyntaxKind.ElementAccessExpression:
|
||||
case SyntaxKind.CallExpression:
|
||||
case SyntaxKind.NewExpression:
|
||||
case SyntaxKind.TaggedTemplateExpression:
|
||||
case SyntaxKind.AsExpression:
|
||||
case SyntaxKind.TypeAssertionExpression:
|
||||
case SyntaxKind.JsxElement:
|
||||
case SyntaxKind.JsxOpeningElement:
|
||||
case SyntaxKind.JsxSelfClosingElement:
|
||||
case SyntaxKind.JsxExpression:
|
||||
case SyntaxKind.ClassExpression:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isLiteralExpression(node: Node): node is LiteralExpression {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.StringLiteral:
|
||||
case SyntaxKind.NumericLiteral:
|
||||
case SyntaxKind.RegularExpressionLiteral:
|
||||
case SyntaxKind.NoSubstitutionTemplateLiteral:
|
||||
case SyntaxKind.TemplateHead:
|
||||
case SyntaxKind.TemplateMiddle:
|
||||
case SyntaxKind.TemplateTail:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isObjectLiteralElement(node: Node): node is ObjectLiteralElement {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.PropertyAssignment:
|
||||
case SyntaxKind.ShorthandPropertyAssignment:
|
||||
case SyntaxKind.MethodDeclaration:
|
||||
case SyntaxKind.GetAccessor:
|
||||
case SyntaxKind.SetAccessor:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isLiteralExpressionOrTemplateExpression(node: Node): node is LiteralExpression | TemplateExpression {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.StringLiteral:
|
||||
case SyntaxKind.NumericLiteral:
|
||||
case SyntaxKind.RegularExpressionLiteral:
|
||||
case SyntaxKind.NoSubstitutionTemplateLiteral:
|
||||
case SyntaxKind.TemplateHead:
|
||||
case SyntaxKind.TemplateMiddle:
|
||||
case SyntaxKind.TemplateTail:
|
||||
case SyntaxKind.TemplateExpression:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isJsxChild(node: Node): node is JsxChild {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.JsxText:
|
||||
case SyntaxKind.JsxExpression:
|
||||
case SyntaxKind.JsxElement:
|
||||
case SyntaxKind.JsxSelfClosingElement:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isJsxAttributeOrJsxSpreadAttribute(node: Node): node is JsxAttribute | JsxSpreadAttribute {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.JsxAttribute:
|
||||
case SyntaxKind.JsxSpreadAttribute:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isExpressionOrVariableDeclarationList(node: Node): node is Expression | VariableDeclarationList {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.StringLiteral:
|
||||
case SyntaxKind.OmittedExpression:
|
||||
case SyntaxKind.PrefixUnaryExpression:
|
||||
case SyntaxKind.PostfixUnaryExpression:
|
||||
case SyntaxKind.TrueKeyword:
|
||||
case SyntaxKind.FalseKeyword:
|
||||
case SyntaxKind.NullKeyword:
|
||||
case SyntaxKind.ThisKeyword:
|
||||
case SyntaxKind.SuperKeyword:
|
||||
case SyntaxKind.DeleteExpression:
|
||||
case SyntaxKind.TypeOfExpression:
|
||||
case SyntaxKind.VoidExpression:
|
||||
case SyntaxKind.AwaitExpression:
|
||||
case SyntaxKind.YieldExpression:
|
||||
case SyntaxKind.BinaryExpression:
|
||||
case SyntaxKind.ConditionalExpression:
|
||||
case SyntaxKind.FunctionExpression:
|
||||
case SyntaxKind.ArrowFunction:
|
||||
case SyntaxKind.NumericLiteral:
|
||||
case SyntaxKind.RegularExpressionLiteral:
|
||||
case SyntaxKind.NoSubstitutionTemplateLiteral:
|
||||
case SyntaxKind.TemplateHead:
|
||||
case SyntaxKind.TemplateMiddle:
|
||||
case SyntaxKind.TemplateTail:
|
||||
case SyntaxKind.TemplateExpression:
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
case SyntaxKind.ArrayLiteralExpression:
|
||||
case SyntaxKind.SpreadElementExpression:
|
||||
case SyntaxKind.ObjectLiteralExpression:
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
case SyntaxKind.ElementAccessExpression:
|
||||
case SyntaxKind.CallExpression:
|
||||
case SyntaxKind.NewExpression:
|
||||
case SyntaxKind.TaggedTemplateExpression:
|
||||
case SyntaxKind.AsExpression:
|
||||
case SyntaxKind.TypeAssertionExpression:
|
||||
case SyntaxKind.JsxElement:
|
||||
case SyntaxKind.JsxOpeningElement:
|
||||
case SyntaxKind.JsxSelfClosingElement:
|
||||
case SyntaxKind.JsxExpression:
|
||||
case SyntaxKind.ClassExpression:
|
||||
case SyntaxKind.VariableDeclarationList:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isCaseOrDefaultClause(node: Node): node is CaseOrDefaultClause {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.CaseClause:
|
||||
case SyntaxKind.DefaultClause:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isClassElement(node: Node): node is ClassElement {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.PropertyDeclaration:
|
||||
case SyntaxKind.MethodDeclaration:
|
||||
case SyntaxKind.Constructor:
|
||||
case SyntaxKind.SemicolonClassElement:
|
||||
case SyntaxKind.GetAccessor:
|
||||
case SyntaxKind.SetAccessor:
|
||||
case SyntaxKind.IndexSignature:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isIdentifierOrLiteralExpression(node: Node): node is Identifier | LiteralExpression {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.StringLiteral:
|
||||
case SyntaxKind.NumericLiteral:
|
||||
case SyntaxKind.RegularExpressionLiteral:
|
||||
case SyntaxKind.NoSubstitutionTemplateLiteral:
|
||||
case SyntaxKind.TemplateHead:
|
||||
case SyntaxKind.TemplateMiddle:
|
||||
case SyntaxKind.TemplateTail:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isModuleBlockOrModuleDeclaration(node: Node): node is ModuleBlock | ModuleDeclaration {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.ModuleBlock:
|
||||
case SyntaxKind.ModuleDeclaration:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isEntityNameOrExternalModuleReference(node: Node): node is EntityName | ExternalModuleReference {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.QualifiedName:
|
||||
case SyntaxKind.ExternalModuleReference:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isNamedImportsOrNamespaceImport(node: Node): node is NamedImports | NamespaceImport {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.NamedImports:
|
||||
case SyntaxKind.NamespaceImport:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isImportOrExportSpecifier(node: Node): node is ImportOrExportSpecifier {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.ImportSpecifier:
|
||||
case SyntaxKind.ExportSpecifier:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function isJSDocType(node: Node): node is JSDocType {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.JSDocAllType:
|
||||
case SyntaxKind.JSDocUnknownType:
|
||||
case SyntaxKind.JSDocArrayType:
|
||||
case SyntaxKind.JSDocUnionType:
|
||||
case SyntaxKind.JSDocTupleType:
|
||||
case SyntaxKind.JSDocNonNullableType:
|
||||
case SyntaxKind.JSDocNullableType:
|
||||
case SyntaxKind.JSDocRecordType:
|
||||
case SyntaxKind.JSDocTypeReference:
|
||||
case SyntaxKind.JSDocOptionalType:
|
||||
case SyntaxKind.JSDocFunctionType:
|
||||
case SyntaxKind.JSDocVariadicType:
|
||||
case SyntaxKind.JSDocConstructorType:
|
||||
case SyntaxKind.JSDocThisType:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
696
src/compiler/transform.generated.ts
Normal file
696
src/compiler/transform.generated.ts
Normal file
@ -0,0 +1,696 @@
|
||||
// <auto-generated />
|
||||
/// <reference path="factory.ts" />
|
||||
/// <reference path="transform.ts" />
|
||||
/* @internal */
|
||||
namespace ts.transform {
|
||||
export function visitChildren<TNode extends Node>(node: TNode, transformer: Transformer): TNode;
|
||||
export function visitChildren(node: Node, transformer: Transformer): Node {
|
||||
if (!node || !transformer) {
|
||||
return node;
|
||||
}
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.QualifiedName:
|
||||
return factory.updateQualifiedName(
|
||||
<QualifiedName>node,
|
||||
visit((<QualifiedName>node).left, transformer),
|
||||
visit((<QualifiedName>node).right, transformer));
|
||||
case SyntaxKind.ComputedPropertyName:
|
||||
return factory.updateComputedPropertyName(
|
||||
<ComputedPropertyName>node,
|
||||
visit((<ComputedPropertyName>node).expression, transformer));
|
||||
case SyntaxKind.TypeParameter:
|
||||
return factory.updateTypeParameter(
|
||||
<TypeParameterDeclaration>node,
|
||||
visit((<TypeParameterDeclaration>node).name, transformer),
|
||||
visit((<TypeParameterDeclaration>node).constraint, transformer),
|
||||
visit((<TypeParameterDeclaration>node).expression, transformer));
|
||||
case SyntaxKind.Parameter:
|
||||
return factory.updateParameter(
|
||||
<ParameterDeclaration>node,
|
||||
visitNodes((<ParameterDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ParameterDeclaration>node).modifiers, transformer),
|
||||
visit((<ParameterDeclaration>node).name, transformer),
|
||||
visit((<ParameterDeclaration>node).type, transformer),
|
||||
visit((<ParameterDeclaration>node).initializer, transformer));
|
||||
case SyntaxKind.Decorator:
|
||||
return factory.updateDecorator(
|
||||
<Decorator>node,
|
||||
visit((<Decorator>node).expression, transformer));
|
||||
case SyntaxKind.PropertySignature:
|
||||
return factory.updatePropertySignature(
|
||||
<PropertySignature>node,
|
||||
visitNodes((<PropertySignature>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<PropertySignature>node).modifiers, transformer),
|
||||
visit((<PropertySignature>node).name, transformer),
|
||||
visit((<PropertySignature>node).type, transformer));
|
||||
case SyntaxKind.PropertyDeclaration:
|
||||
return factory.updatePropertyDeclaration(
|
||||
<PropertyDeclaration>node,
|
||||
visitNodes((<PropertyDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<PropertyDeclaration>node).modifiers, transformer),
|
||||
visit((<PropertyDeclaration>node).name, transformer),
|
||||
visit((<PropertyDeclaration>node).type, transformer),
|
||||
visit((<PropertyDeclaration>node).initializer, transformer));
|
||||
case SyntaxKind.MethodSignature:
|
||||
return factory.updateMethodSignature(
|
||||
<MethodSignature>node,
|
||||
visitNodes((<MethodSignature>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<MethodSignature>node).modifiers, transformer),
|
||||
visit((<MethodSignature>node).name, transformer),
|
||||
visitNodes((<MethodSignature>node).typeParameters, transformer),
|
||||
visitNodes((<MethodSignature>node).parameters, transformer),
|
||||
visit((<MethodSignature>node).type, transformer));
|
||||
case SyntaxKind.MethodDeclaration:
|
||||
return factory.updateMethodDeclaration(
|
||||
<MethodDeclaration>node,
|
||||
visitNodes((<MethodDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<MethodDeclaration>node).modifiers, transformer),
|
||||
visit((<MethodDeclaration>node).name, transformer),
|
||||
visitNodes((<MethodDeclaration>node).typeParameters, transformer),
|
||||
visitNodes((<MethodDeclaration>node).parameters, transformer),
|
||||
visit((<MethodDeclaration>node).type, transformer),
|
||||
visit((<MethodDeclaration>node).body, transformer));
|
||||
case SyntaxKind.Constructor:
|
||||
return factory.updateConstructor(
|
||||
<ConstructorDeclaration>node,
|
||||
visitNodes((<ConstructorDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ConstructorDeclaration>node).modifiers, transformer),
|
||||
visitNodes((<ConstructorDeclaration>node).parameters, transformer),
|
||||
visit((<ConstructorDeclaration>node).type, transformer),
|
||||
visit((<ConstructorDeclaration>node).body, transformer));
|
||||
case SyntaxKind.GetAccessor:
|
||||
return factory.updateGetAccessor(
|
||||
<GetAccessorDeclaration>node,
|
||||
visitNodes((<GetAccessorDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<GetAccessorDeclaration>node).modifiers, transformer),
|
||||
visit((<GetAccessorDeclaration>node).name, transformer),
|
||||
visitNodes((<GetAccessorDeclaration>node).parameters, transformer),
|
||||
visit((<GetAccessorDeclaration>node).type, transformer),
|
||||
visit((<GetAccessorDeclaration>node).body, transformer));
|
||||
case SyntaxKind.SetAccessor:
|
||||
return factory.updateSetAccessor(
|
||||
<SetAccessorDeclaration>node,
|
||||
visitNodes((<SetAccessorDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<SetAccessorDeclaration>node).modifiers, transformer),
|
||||
visit((<SetAccessorDeclaration>node).name, transformer),
|
||||
visitNodes((<SetAccessorDeclaration>node).parameters, transformer),
|
||||
visit((<SetAccessorDeclaration>node).type, transformer),
|
||||
visit((<SetAccessorDeclaration>node).body, transformer));
|
||||
case SyntaxKind.CallSignature:
|
||||
return factory.updateCallSignature(
|
||||
<CallSignatureDeclaration>node,
|
||||
visitNodes((<CallSignatureDeclaration>node).typeParameters, transformer),
|
||||
visitNodes((<CallSignatureDeclaration>node).parameters, transformer),
|
||||
visit((<CallSignatureDeclaration>node).type, transformer));
|
||||
case SyntaxKind.ConstructSignature:
|
||||
return factory.updateConstructSignature(
|
||||
<ConstructSignatureDeclaration>node,
|
||||
visitNodes((<ConstructSignatureDeclaration>node).typeParameters, transformer),
|
||||
visitNodes((<ConstructSignatureDeclaration>node).parameters, transformer),
|
||||
visit((<ConstructSignatureDeclaration>node).type, transformer));
|
||||
case SyntaxKind.IndexSignature:
|
||||
return factory.updateIndexSignature(
|
||||
<IndexSignatureDeclaration>node,
|
||||
visitNodes((<IndexSignatureDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<IndexSignatureDeclaration>node).modifiers, transformer),
|
||||
visitNodes((<IndexSignatureDeclaration>node).parameters, transformer),
|
||||
visit((<IndexSignatureDeclaration>node).type, transformer));
|
||||
case SyntaxKind.TypePredicate:
|
||||
return factory.updateTypePredicate(
|
||||
<TypePredicateNode>node,
|
||||
visit((<TypePredicateNode>node).parameterName, transformer),
|
||||
visit((<TypePredicateNode>node).type, transformer));
|
||||
case SyntaxKind.TypeReference:
|
||||
return factory.updateTypeReference(
|
||||
<TypeReferenceNode>node,
|
||||
visit((<TypeReferenceNode>node).typeName, transformer),
|
||||
visitNodes((<TypeReferenceNode>node).typeArguments, transformer));
|
||||
case SyntaxKind.FunctionType:
|
||||
return factory.updateFunctionType(
|
||||
<FunctionTypeNode>node,
|
||||
visitNodes((<FunctionTypeNode>node).typeParameters, transformer),
|
||||
visitNodes((<FunctionTypeNode>node).parameters, transformer),
|
||||
visit((<FunctionTypeNode>node).type, transformer));
|
||||
case SyntaxKind.ConstructorType:
|
||||
return factory.updateConstructorType(
|
||||
<ConstructorTypeNode>node,
|
||||
visitNodes((<ConstructorTypeNode>node).typeParameters, transformer),
|
||||
visitNodes((<ConstructorTypeNode>node).parameters, transformer),
|
||||
visit((<ConstructorTypeNode>node).type, transformer));
|
||||
case SyntaxKind.TypeQuery:
|
||||
return factory.updateTypeQuery(
|
||||
<TypeQueryNode>node,
|
||||
visit((<TypeQueryNode>node).exprName, transformer));
|
||||
case SyntaxKind.TypeLiteral:
|
||||
return factory.updateTypeLiteral(
|
||||
<TypeLiteralNode>node,
|
||||
visitNodes((<TypeLiteralNode>node).members, transformer));
|
||||
case SyntaxKind.ArrayType:
|
||||
return factory.updateArrayType(
|
||||
<ArrayTypeNode>node,
|
||||
visit((<ArrayTypeNode>node).elementType, transformer));
|
||||
case SyntaxKind.TupleType:
|
||||
return factory.updateTupleType(
|
||||
<TupleTypeNode>node,
|
||||
visitNodes((<TupleTypeNode>node).elementTypes, transformer));
|
||||
case SyntaxKind.UnionType:
|
||||
return factory.updateUnionType(
|
||||
<UnionTypeNode>node,
|
||||
visitNodes((<UnionTypeNode>node).types, transformer));
|
||||
case SyntaxKind.IntersectionType:
|
||||
return factory.updateIntersectionType(
|
||||
<IntersectionTypeNode>node,
|
||||
visitNodes((<IntersectionTypeNode>node).types, transformer));
|
||||
case SyntaxKind.ParenthesizedType:
|
||||
return factory.updateParenthesizedType(
|
||||
<ParenthesizedTypeNode>node,
|
||||
visit((<ParenthesizedTypeNode>node).type, transformer));
|
||||
case SyntaxKind.ObjectBindingPattern:
|
||||
return factory.updateObjectBindingPattern(
|
||||
<ObjectBindingPattern>node,
|
||||
visitNodes((<ObjectBindingPattern>node).elements, transformer));
|
||||
case SyntaxKind.ArrayBindingPattern:
|
||||
return factory.updateArrayBindingPattern(
|
||||
<ArrayBindingPattern>node,
|
||||
visitNodes((<ArrayBindingPattern>node).elements, transformer));
|
||||
case SyntaxKind.BindingElement:
|
||||
return factory.updateBindingElement(
|
||||
<BindingElement>node,
|
||||
visitNodes((<BindingElement>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<BindingElement>node).modifiers, transformer),
|
||||
visit((<BindingElement>node).propertyName, transformer),
|
||||
visit((<BindingElement>node).name, transformer),
|
||||
visit((<BindingElement>node).initializer, transformer));
|
||||
case SyntaxKind.ArrayLiteralExpression:
|
||||
return factory.updateArrayLiteralExpression(
|
||||
<ArrayLiteralExpression>node,
|
||||
visitNodes((<ArrayLiteralExpression>node).elements, transformer));
|
||||
case SyntaxKind.ObjectLiteralExpression:
|
||||
return factory.updateObjectLiteralExpression(
|
||||
<ObjectLiteralExpression>node,
|
||||
visitNodes((<ObjectLiteralExpression>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ObjectLiteralExpression>node).modifiers, transformer),
|
||||
visitNodes((<ObjectLiteralExpression>node).properties, transformer));
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
return factory.updatePropertyAccessExpression(
|
||||
<PropertyAccessExpression>node,
|
||||
visit((<PropertyAccessExpression>node).expression, transformer),
|
||||
visit((<PropertyAccessExpression>node).name, transformer));
|
||||
case SyntaxKind.ElementAccessExpression:
|
||||
return factory.updateElementAccessExpression(
|
||||
<ElementAccessExpression>node,
|
||||
visit((<ElementAccessExpression>node).expression, transformer),
|
||||
visit((<ElementAccessExpression>node).argumentExpression, transformer));
|
||||
case SyntaxKind.CallExpression:
|
||||
return factory.updateCallExpression(
|
||||
<CallExpression>node,
|
||||
visit((<CallExpression>node).expression, transformer),
|
||||
visitNodes((<CallExpression>node).typeArguments, transformer),
|
||||
visitNodes((<CallExpression>node).arguments, transformer));
|
||||
case SyntaxKind.NewExpression:
|
||||
return factory.updateNewExpression(
|
||||
<NewExpression>node,
|
||||
visit((<NewExpression>node).expression, transformer),
|
||||
visitNodes((<NewExpression>node).typeArguments, transformer),
|
||||
visitNodes((<NewExpression>node).arguments, transformer));
|
||||
case SyntaxKind.TaggedTemplateExpression:
|
||||
return factory.updateTaggedTemplateExpression(
|
||||
<TaggedTemplateExpression>node,
|
||||
visit((<TaggedTemplateExpression>node).tag, transformer),
|
||||
visit((<TaggedTemplateExpression>node).template, transformer));
|
||||
case SyntaxKind.TypeAssertionExpression:
|
||||
return factory.updateTypeAssertionExpression(
|
||||
<TypeAssertion>node,
|
||||
visit((<TypeAssertion>node).type, transformer),
|
||||
visit((<TypeAssertion>node).expression, transformer));
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
return factory.updateParenthesizedExpression(
|
||||
<ParenthesizedExpression>node,
|
||||
visit((<ParenthesizedExpression>node).expression, transformer));
|
||||
case SyntaxKind.FunctionExpression:
|
||||
return factory.updateFunctionExpression(
|
||||
<FunctionExpression>node,
|
||||
visitNodes((<FunctionExpression>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<FunctionExpression>node).modifiers, transformer),
|
||||
visit((<FunctionExpression>node).name, transformer),
|
||||
visitNodes((<FunctionExpression>node).typeParameters, transformer),
|
||||
visitNodes((<FunctionExpression>node).parameters, transformer),
|
||||
visit((<FunctionExpression>node).type, transformer),
|
||||
visit((<FunctionExpression>node).body, transformer));
|
||||
case SyntaxKind.ArrowFunction:
|
||||
return factory.updateArrowFunction(
|
||||
<ArrowFunction>node,
|
||||
visitNodes((<ArrowFunction>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ArrowFunction>node).modifiers, transformer),
|
||||
visitNodes((<ArrowFunction>node).typeParameters, transformer),
|
||||
visitNodes((<ArrowFunction>node).parameters, transformer),
|
||||
visit((<ArrowFunction>node).type, transformer),
|
||||
visit((<ArrowFunction>node).body, transformer));
|
||||
case SyntaxKind.DeleteExpression:
|
||||
return factory.updateDeleteExpression(
|
||||
<DeleteExpression>node,
|
||||
visit((<DeleteExpression>node).expression, transformer));
|
||||
case SyntaxKind.TypeOfExpression:
|
||||
return factory.updateTypeOfExpression(
|
||||
<TypeOfExpression>node,
|
||||
visit((<TypeOfExpression>node).expression, transformer));
|
||||
case SyntaxKind.VoidExpression:
|
||||
return factory.updateVoidExpression(
|
||||
<VoidExpression>node,
|
||||
visit((<VoidExpression>node).expression, transformer));
|
||||
case SyntaxKind.AwaitExpression:
|
||||
return factory.updateAwaitExpression(
|
||||
<AwaitExpression>node,
|
||||
visit((<AwaitExpression>node).expression, transformer));
|
||||
case SyntaxKind.PrefixUnaryExpression:
|
||||
return factory.updatePrefixUnaryExpression(
|
||||
<PrefixUnaryExpression>node,
|
||||
visit((<PrefixUnaryExpression>node).operand, transformer));
|
||||
case SyntaxKind.PostfixUnaryExpression:
|
||||
return factory.updatePostfixUnaryExpression(
|
||||
<PostfixUnaryExpression>node,
|
||||
visit((<PostfixUnaryExpression>node).operand, transformer));
|
||||
case SyntaxKind.BinaryExpression:
|
||||
return factory.updateBinaryExpression(
|
||||
<BinaryExpression>node,
|
||||
visit((<BinaryExpression>node).left, transformer),
|
||||
visit((<BinaryExpression>node).right, transformer));
|
||||
case SyntaxKind.ConditionalExpression:
|
||||
return factory.updateConditionalExpression(
|
||||
<ConditionalExpression>node,
|
||||
visit((<ConditionalExpression>node).condition, transformer),
|
||||
visit((<ConditionalExpression>node).whenTrue, transformer),
|
||||
visit((<ConditionalExpression>node).whenFalse, transformer));
|
||||
case SyntaxKind.TemplateExpression:
|
||||
return factory.updateTemplateExpression(
|
||||
<TemplateExpression>node,
|
||||
visit((<TemplateExpression>node).head, transformer),
|
||||
visitNodes((<TemplateExpression>node).templateSpans, transformer));
|
||||
case SyntaxKind.YieldExpression:
|
||||
return factory.updateYieldExpression(
|
||||
<YieldExpression>node,
|
||||
visit((<YieldExpression>node).expression, transformer));
|
||||
case SyntaxKind.SpreadElementExpression:
|
||||
return factory.updateSpreadElementExpression(
|
||||
<SpreadElementExpression>node,
|
||||
visit((<SpreadElementExpression>node).expression, transformer));
|
||||
case SyntaxKind.ClassExpression:
|
||||
return factory.updateClassExpression(
|
||||
<ClassExpression>node,
|
||||
visitNodes((<ClassExpression>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ClassExpression>node).modifiers, transformer),
|
||||
visit((<ClassExpression>node).name, transformer),
|
||||
visitNodes((<ClassExpression>node).typeParameters, transformer),
|
||||
visitNodes((<ClassExpression>node).heritageClauses, transformer),
|
||||
visitNodes((<ClassExpression>node).members, transformer));
|
||||
case SyntaxKind.ExpressionWithTypeArguments:
|
||||
return factory.updateExpressionWithTypeArguments(
|
||||
<ExpressionWithTypeArguments>node,
|
||||
visit((<ExpressionWithTypeArguments>node).expression, transformer),
|
||||
visitNodes((<ExpressionWithTypeArguments>node).typeArguments, transformer));
|
||||
case SyntaxKind.AsExpression:
|
||||
return factory.updateAsExpression(
|
||||
<AsExpression>node,
|
||||
visit((<AsExpression>node).expression, transformer),
|
||||
visit((<AsExpression>node).type, transformer));
|
||||
case SyntaxKind.TemplateSpan:
|
||||
return factory.updateTemplateSpan(
|
||||
<TemplateSpan>node,
|
||||
visit((<TemplateSpan>node).expression, transformer),
|
||||
visit((<TemplateSpan>node).literal, transformer));
|
||||
case SyntaxKind.Block:
|
||||
return factory.updateBlock(
|
||||
<Block>node,
|
||||
visitNodes((<Block>node).statements, transformer));
|
||||
case SyntaxKind.VariableStatement:
|
||||
return factory.updateVariableStatement(
|
||||
<VariableStatement>node,
|
||||
visit((<VariableStatement>node).declarationList, transformer));
|
||||
case SyntaxKind.ExpressionStatement:
|
||||
return factory.updateExpressionStatement(
|
||||
<ExpressionStatement>node,
|
||||
visit((<ExpressionStatement>node).expression, transformer));
|
||||
case SyntaxKind.IfStatement:
|
||||
return factory.updateIfStatement(
|
||||
<IfStatement>node,
|
||||
visit((<IfStatement>node).expression, transformer),
|
||||
visit((<IfStatement>node).thenStatement, transformer),
|
||||
visit((<IfStatement>node).elseStatement, transformer));
|
||||
case SyntaxKind.DoStatement:
|
||||
return factory.updateDoStatement(
|
||||
<DoStatement>node,
|
||||
visit((<DoStatement>node).statement, transformer),
|
||||
visit((<DoStatement>node).expression, transformer));
|
||||
case SyntaxKind.WhileStatement:
|
||||
return factory.updateWhileStatement(
|
||||
<WhileStatement>node,
|
||||
visit((<WhileStatement>node).expression, transformer),
|
||||
visit((<WhileStatement>node).statement, transformer));
|
||||
case SyntaxKind.ForStatement:
|
||||
return factory.updateForStatement(
|
||||
<ForStatement>node,
|
||||
visit((<ForStatement>node).initializer, transformer),
|
||||
visit((<ForStatement>node).condition, transformer),
|
||||
visit((<ForStatement>node).incrementor, transformer),
|
||||
visit((<ForStatement>node).statement, transformer));
|
||||
case SyntaxKind.ForInStatement:
|
||||
return factory.updateForInStatement(
|
||||
<ForInStatement>node,
|
||||
visit((<ForInStatement>node).initializer, transformer),
|
||||
visit((<ForInStatement>node).expression, transformer),
|
||||
visit((<ForInStatement>node).statement, transformer));
|
||||
case SyntaxKind.ForOfStatement:
|
||||
return factory.updateForOfStatement(
|
||||
<ForOfStatement>node,
|
||||
visit((<ForOfStatement>node).initializer, transformer),
|
||||
visit((<ForOfStatement>node).expression, transformer),
|
||||
visit((<ForOfStatement>node).statement, transformer));
|
||||
case SyntaxKind.ContinueStatement:
|
||||
return factory.updateContinueStatement(
|
||||
<ContinueStatement>node,
|
||||
visit((<ContinueStatement>node).label, transformer));
|
||||
case SyntaxKind.BreakStatement:
|
||||
return factory.updateBreakStatement(
|
||||
<BreakStatement>node,
|
||||
visit((<BreakStatement>node).label, transformer));
|
||||
case SyntaxKind.ReturnStatement:
|
||||
return factory.updateReturnStatement(
|
||||
<ReturnStatement>node,
|
||||
visit((<ReturnStatement>node).expression, transformer));
|
||||
case SyntaxKind.WithStatement:
|
||||
return factory.updateWithStatement(
|
||||
<WithStatement>node,
|
||||
visit((<WithStatement>node).expression, transformer),
|
||||
visit((<WithStatement>node).statement, transformer));
|
||||
case SyntaxKind.SwitchStatement:
|
||||
return factory.updateSwitchStatement(
|
||||
<SwitchStatement>node,
|
||||
visit((<SwitchStatement>node).expression, transformer),
|
||||
visit((<SwitchStatement>node).caseBlock, transformer));
|
||||
case SyntaxKind.LabeledStatement:
|
||||
return factory.updateLabeledStatement(
|
||||
<LabeledStatement>node,
|
||||
visit((<LabeledStatement>node).label, transformer),
|
||||
visit((<LabeledStatement>node).statement, transformer));
|
||||
case SyntaxKind.ThrowStatement:
|
||||
return factory.updateThrowStatement(
|
||||
<ThrowStatement>node,
|
||||
visit((<ThrowStatement>node).expression, transformer));
|
||||
case SyntaxKind.TryStatement:
|
||||
return factory.updateTryStatement(
|
||||
<TryStatement>node,
|
||||
visit((<TryStatement>node).tryBlock, transformer),
|
||||
visit((<TryStatement>node).catchClause, transformer),
|
||||
visit((<TryStatement>node).finallyBlock, transformer));
|
||||
case SyntaxKind.VariableDeclaration:
|
||||
return factory.updateVariableDeclaration(
|
||||
<VariableDeclaration>node,
|
||||
visitNodes((<VariableDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<VariableDeclaration>node).modifiers, transformer),
|
||||
visit((<VariableDeclaration>node).name, transformer),
|
||||
visit((<VariableDeclaration>node).type, transformer),
|
||||
visit((<VariableDeclaration>node).initializer, transformer));
|
||||
case SyntaxKind.VariableDeclarationList:
|
||||
return factory.updateVariableDeclarationList(
|
||||
<VariableDeclarationList>node,
|
||||
visitNodes((<VariableDeclarationList>node).declarations, transformer));
|
||||
case SyntaxKind.FunctionDeclaration:
|
||||
return factory.updateFunctionDeclaration(
|
||||
<FunctionDeclaration>node,
|
||||
visitNodes((<FunctionDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<FunctionDeclaration>node).modifiers, transformer),
|
||||
visit((<FunctionDeclaration>node).name, transformer),
|
||||
visitNodes((<FunctionDeclaration>node).typeParameters, transformer),
|
||||
visitNodes((<FunctionDeclaration>node).parameters, transformer),
|
||||
visit((<FunctionDeclaration>node).type, transformer),
|
||||
visit((<FunctionDeclaration>node).body, transformer));
|
||||
case SyntaxKind.ClassDeclaration:
|
||||
return factory.updateClassDeclaration(
|
||||
<ClassDeclaration>node,
|
||||
visitNodes((<ClassDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ClassDeclaration>node).modifiers, transformer),
|
||||
visit((<ClassDeclaration>node).name, transformer),
|
||||
visitNodes((<ClassDeclaration>node).typeParameters, transformer),
|
||||
visitNodes((<ClassDeclaration>node).heritageClauses, transformer),
|
||||
visitNodes((<ClassDeclaration>node).members, transformer));
|
||||
case SyntaxKind.InterfaceDeclaration:
|
||||
return factory.updateInterfaceDeclaration(
|
||||
<InterfaceDeclaration>node,
|
||||
visitNodes((<InterfaceDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<InterfaceDeclaration>node).modifiers, transformer),
|
||||
visit((<InterfaceDeclaration>node).name, transformer),
|
||||
visitNodes((<InterfaceDeclaration>node).typeParameters, transformer),
|
||||
visitNodes((<InterfaceDeclaration>node).heritageClauses, transformer),
|
||||
visitNodes((<InterfaceDeclaration>node).members, transformer));
|
||||
case SyntaxKind.TypeAliasDeclaration:
|
||||
return factory.updateTypeAliasDeclaration(
|
||||
<TypeAliasDeclaration>node,
|
||||
visitNodes((<TypeAliasDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<TypeAliasDeclaration>node).modifiers, transformer),
|
||||
visit((<TypeAliasDeclaration>node).name, transformer),
|
||||
visitNodes((<TypeAliasDeclaration>node).typeParameters, transformer),
|
||||
visit((<TypeAliasDeclaration>node).type, transformer));
|
||||
case SyntaxKind.EnumDeclaration:
|
||||
return factory.updateEnumDeclaration(
|
||||
<EnumDeclaration>node,
|
||||
visitNodes((<EnumDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<EnumDeclaration>node).modifiers, transformer),
|
||||
visit((<EnumDeclaration>node).name, transformer),
|
||||
visitNodes((<EnumDeclaration>node).members, transformer));
|
||||
case SyntaxKind.ModuleDeclaration:
|
||||
return factory.updateModuleDeclaration(
|
||||
<ModuleDeclaration>node,
|
||||
visitNodes((<ModuleDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ModuleDeclaration>node).modifiers, transformer),
|
||||
visit((<ModuleDeclaration>node).name, transformer),
|
||||
visit((<ModuleDeclaration>node).body, transformer));
|
||||
case SyntaxKind.ModuleBlock:
|
||||
return factory.updateModuleBlock(
|
||||
<ModuleBlock>node,
|
||||
visitNodes((<ModuleBlock>node).statements, transformer));
|
||||
case SyntaxKind.CaseBlock:
|
||||
return factory.updateCaseBlock(
|
||||
<CaseBlock>node,
|
||||
visitNodes((<CaseBlock>node).clauses, transformer));
|
||||
case SyntaxKind.ImportEqualsDeclaration:
|
||||
return factory.updateImportEqualsDeclaration(
|
||||
<ImportEqualsDeclaration>node,
|
||||
visitNodes((<ImportEqualsDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ImportEqualsDeclaration>node).modifiers, transformer),
|
||||
visit((<ImportEqualsDeclaration>node).name, transformer),
|
||||
visit((<ImportEqualsDeclaration>node).moduleReference, transformer));
|
||||
case SyntaxKind.ImportDeclaration:
|
||||
return factory.updateImportDeclaration(
|
||||
<ImportDeclaration>node,
|
||||
visitNodes((<ImportDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ImportDeclaration>node).modifiers, transformer),
|
||||
visit((<ImportDeclaration>node).importClause, transformer),
|
||||
visit((<ImportDeclaration>node).moduleSpecifier, transformer));
|
||||
case SyntaxKind.ImportClause:
|
||||
return factory.updateImportClause(
|
||||
<ImportClause>node,
|
||||
visit((<ImportClause>node).name, transformer),
|
||||
visit((<ImportClause>node).namedBindings, transformer));
|
||||
case SyntaxKind.NamespaceImport:
|
||||
return factory.updateNamespaceImport(
|
||||
<NamespaceImport>node,
|
||||
visit((<NamespaceImport>node).name, transformer));
|
||||
case SyntaxKind.NamedImports:
|
||||
return factory.updateNamedImports(
|
||||
<NamedImports>node,
|
||||
visitNodes((<NamedImports>node).elements, transformer));
|
||||
case SyntaxKind.ImportSpecifier:
|
||||
return factory.updateImportSpecifier(
|
||||
<ImportSpecifier>node,
|
||||
visit((<ImportSpecifier>node).propertyName, transformer),
|
||||
visit((<ImportSpecifier>node).name, transformer));
|
||||
case SyntaxKind.ExportAssignment:
|
||||
return factory.updateExportAssignment(
|
||||
<ExportAssignment>node,
|
||||
visitNodes((<ExportAssignment>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ExportAssignment>node).modifiers, transformer),
|
||||
visit((<ExportAssignment>node).expression, transformer));
|
||||
case SyntaxKind.ExportDeclaration:
|
||||
return factory.updateExportDeclaration(
|
||||
<ExportDeclaration>node,
|
||||
visitNodes((<ExportDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<ExportDeclaration>node).modifiers, transformer),
|
||||
visit((<ExportDeclaration>node).exportClause, transformer),
|
||||
visit((<ExportDeclaration>node).moduleSpecifier, transformer));
|
||||
case SyntaxKind.NamedExports:
|
||||
return factory.updateNamedExports(
|
||||
<NamedExports>node,
|
||||
visitNodes((<NamedExports>node).elements, transformer));
|
||||
case SyntaxKind.ExportSpecifier:
|
||||
return factory.updateExportSpecifier(
|
||||
<ExportSpecifier>node,
|
||||
visit((<ExportSpecifier>node).propertyName, transformer),
|
||||
visit((<ExportSpecifier>node).name, transformer));
|
||||
case SyntaxKind.MissingDeclaration:
|
||||
return factory.updateMissingDeclaration(
|
||||
<MissingDeclaration>node,
|
||||
visitNodes((<MissingDeclaration>node).decorators, transformer),
|
||||
<ModifiersArray>visitNodes((<MissingDeclaration>node).modifiers, transformer));
|
||||
case SyntaxKind.ExternalModuleReference:
|
||||
return factory.updateExternalModuleReference(
|
||||
<ExternalModuleReference>node,
|
||||
visit((<ExternalModuleReference>node).expression, transformer));
|
||||
case SyntaxKind.JsxElement:
|
||||
return factory.updateJsxElement(
|
||||
<JsxElement>node,
|
||||
visit((<JsxElement>node).openingElement, transformer),
|
||||
visitNodes((<JsxElement>node).children, transformer),
|
||||
visit((<JsxElement>node).closingElement, transformer));
|
||||
case SyntaxKind.JsxSelfClosingElement:
|
||||
return factory.updateJsxSelfClosingElement(
|
||||
<JsxSelfClosingElement>node,
|
||||
visit((<JsxSelfClosingElement>node).tagName, transformer),
|
||||
visitNodes((<JsxSelfClosingElement>node).attributes, transformer));
|
||||
case SyntaxKind.JsxOpeningElement:
|
||||
return factory.updateJsxOpeningElement(
|
||||
<JsxOpeningElement>node,
|
||||
visit((<JsxOpeningElement>node).tagName, transformer),
|
||||
visitNodes((<JsxOpeningElement>node).attributes, transformer));
|
||||
case SyntaxKind.JsxClosingElement:
|
||||
return factory.updateJsxClosingElement(
|
||||
<JsxClosingElement>node,
|
||||
visit((<JsxClosingElement>node).tagName, transformer));
|
||||
case SyntaxKind.JsxAttribute:
|
||||
return factory.updateJsxAttribute(
|
||||
<JsxAttribute>node,
|
||||
visit((<JsxAttribute>node).name, transformer),
|
||||
visit((<JsxAttribute>node).initializer, transformer));
|
||||
case SyntaxKind.JsxSpreadAttribute:
|
||||
return factory.updateJsxSpreadAttribute(
|
||||
<JsxSpreadAttribute>node,
|
||||
visit((<JsxSpreadAttribute>node).expression, transformer));
|
||||
case SyntaxKind.JsxExpression:
|
||||
return factory.updateJsxExpression(
|
||||
<JsxExpression>node,
|
||||
visit((<JsxExpression>node).expression, transformer));
|
||||
case SyntaxKind.CaseClause:
|
||||
return factory.updateCaseClause(
|
||||
<CaseClause>node,
|
||||
visit((<CaseClause>node).expression, transformer),
|
||||
visitNodes((<CaseClause>node).statements, transformer));
|
||||
case SyntaxKind.DefaultClause:
|
||||
return factory.updateDefaultClause(
|
||||
<DefaultClause>node,
|
||||
visitNodes((<DefaultClause>node).statements, transformer));
|
||||
case SyntaxKind.HeritageClause:
|
||||
return factory.updateHeritageClause(
|
||||
<HeritageClause>node,
|
||||
visitNodes((<HeritageClause>node).types, transformer));
|
||||
case SyntaxKind.CatchClause:
|
||||
return factory.updateCatchClause(
|
||||
<CatchClause>node,
|
||||
visit((<CatchClause>node).variableDeclaration, transformer),
|
||||
visit((<CatchClause>node).block, transformer));
|
||||
case SyntaxKind.PropertyAssignment:
|
||||
return factory.updatePropertyAssignment(
|
||||
<PropertyAssignment>node,
|
||||
visit((<PropertyAssignment>node).name, transformer),
|
||||
visit((<PropertyAssignment>node).initializer, transformer));
|
||||
case SyntaxKind.ShorthandPropertyAssignment:
|
||||
return factory.updateShorthandPropertyAssignment(
|
||||
<ShorthandPropertyAssignment>node,
|
||||
visit((<ShorthandPropertyAssignment>node).name, transformer));
|
||||
case SyntaxKind.EnumMember:
|
||||
return factory.updateEnumMember(
|
||||
<EnumMember>node,
|
||||
visit((<EnumMember>node).name, transformer),
|
||||
visit((<EnumMember>node).initializer, transformer));
|
||||
case SyntaxKind.JSDocTypeExpression:
|
||||
return factory.updateJSDocTypeExpression(
|
||||
<JSDocTypeExpression>node,
|
||||
visit((<JSDocTypeExpression>node).type, transformer));
|
||||
case SyntaxKind.JSDocArrayType:
|
||||
return factory.updateJSDocArrayType(
|
||||
<JSDocArrayType>node,
|
||||
visit((<JSDocArrayType>node).elementType, transformer));
|
||||
case SyntaxKind.JSDocUnionType:
|
||||
return factory.updateJSDocUnionType(
|
||||
<JSDocUnionType>node,
|
||||
visitNodes((<JSDocUnionType>node).types, transformer));
|
||||
case SyntaxKind.JSDocTupleType:
|
||||
return factory.updateJSDocTupleType(
|
||||
<JSDocTupleType>node,
|
||||
visitNodes((<JSDocTupleType>node).types, transformer));
|
||||
case SyntaxKind.JSDocNullableType:
|
||||
return factory.updateJSDocNullableType(
|
||||
<JSDocNullableType>node,
|
||||
visit((<JSDocNullableType>node).type, transformer));
|
||||
case SyntaxKind.JSDocNonNullableType:
|
||||
return factory.updateJSDocNonNullableType(
|
||||
<JSDocNonNullableType>node,
|
||||
visit((<JSDocNonNullableType>node).type, transformer));
|
||||
case SyntaxKind.JSDocRecordType:
|
||||
return factory.updateJSDocRecordType(
|
||||
<JSDocRecordType>node,
|
||||
visitNodes((<JSDocRecordType>node).members, transformer));
|
||||
case SyntaxKind.JSDocRecordMember:
|
||||
return factory.updateJSDocRecordMember(
|
||||
<JSDocRecordMember>node,
|
||||
visit((<JSDocRecordMember>node).name, transformer),
|
||||
visit((<JSDocRecordMember>node).type, transformer));
|
||||
case SyntaxKind.JSDocTypeReference:
|
||||
return factory.updateJSDocTypeReference(
|
||||
<JSDocTypeReference>node,
|
||||
visit((<JSDocTypeReference>node).name, transformer),
|
||||
visitNodes((<JSDocTypeReference>node).typeArguments, transformer));
|
||||
case SyntaxKind.JSDocOptionalType:
|
||||
return factory.updateJSDocOptionalType(
|
||||
<JSDocOptionalType>node,
|
||||
visit((<JSDocOptionalType>node).type, transformer));
|
||||
case SyntaxKind.JSDocFunctionType:
|
||||
return factory.updateJSDocFunctionType(
|
||||
<JSDocFunctionType>node,
|
||||
visitNodes((<JSDocFunctionType>node).parameters, transformer),
|
||||
visit((<JSDocFunctionType>node).type, transformer));
|
||||
case SyntaxKind.JSDocVariadicType:
|
||||
return factory.updateJSDocVariadicType(
|
||||
<JSDocVariadicType>node,
|
||||
visit((<JSDocVariadicType>node).type, transformer));
|
||||
case SyntaxKind.JSDocConstructorType:
|
||||
return factory.updateJSDocConstructorType(
|
||||
<JSDocConstructorType>node,
|
||||
visit((<JSDocConstructorType>node).type, transformer));
|
||||
case SyntaxKind.JSDocThisType:
|
||||
return factory.updateJSDocThisType(
|
||||
<JSDocThisType>node,
|
||||
visit((<JSDocThisType>node).type, transformer));
|
||||
case SyntaxKind.JSDocComment:
|
||||
return factory.updateJSDocComment(
|
||||
<JSDocComment>node,
|
||||
visitNodes((<JSDocComment>node).tags, transformer));
|
||||
case SyntaxKind.JSDocTag:
|
||||
return factory.updateJSDocTag(
|
||||
<JSDocTag>node,
|
||||
visit((<JSDocTag>node).tagName, transformer));
|
||||
case SyntaxKind.JSDocParameterTag:
|
||||
return factory.updateJSDocParameterTag(
|
||||
<JSDocParameterTag>node,
|
||||
visit((<JSDocParameterTag>node).preParameterName, transformer),
|
||||
visit((<JSDocParameterTag>node).typeExpression, transformer),
|
||||
visit((<JSDocParameterTag>node).postParameterName, transformer),
|
||||
visit((<JSDocParameterTag>node).tagName, transformer));
|
||||
case SyntaxKind.JSDocReturnTag:
|
||||
return factory.updateJSDocReturnTag(
|
||||
<JSDocReturnTag>node,
|
||||
visit((<JSDocReturnTag>node).typeExpression, transformer),
|
||||
visit((<JSDocReturnTag>node).tagName, transformer));
|
||||
case SyntaxKind.JSDocTypeTag:
|
||||
return factory.updateJSDocTypeTag(
|
||||
<JSDocTypeTag>node,
|
||||
visit((<JSDocTypeTag>node).typeExpression, transformer),
|
||||
visit((<JSDocTypeTag>node).tagName, transformer));
|
||||
case SyntaxKind.JSDocTemplateTag:
|
||||
return factory.updateJSDocTemplateTag(
|
||||
<JSDocTemplateTag>node,
|
||||
visitNodes((<JSDocTemplateTag>node).typeParameters, transformer),
|
||||
visit((<JSDocTemplateTag>node).tagName, transformer));
|
||||
default:
|
||||
return node;
|
||||
}
|
||||
}
|
||||
}
|
||||
124
src/compiler/transform.ts
Normal file
124
src/compiler/transform.ts
Normal file
@ -0,0 +1,124 @@
|
||||
/// <reference path="factory.ts" />
|
||||
/// <reference path="transform.generated.ts" />
|
||||
/* @internal */
|
||||
namespace ts.transform {
|
||||
export interface TransformerCacheControl<TNode extends Node> {
|
||||
shouldCachePreviousNodes(node: TNode): boolean;
|
||||
cacheNode(node: TNode): TNode;
|
||||
}
|
||||
|
||||
export class Transformer {
|
||||
private resolver: TransformResolver;
|
||||
|
||||
constructor(resolver: TransformResolver) {
|
||||
this.resolver = resolver;
|
||||
}
|
||||
|
||||
public shouldTransformNode(node: Node): boolean {
|
||||
return false;
|
||||
}
|
||||
|
||||
public shouldVisitChildrenOfNode(node: Node): boolean {
|
||||
return false;
|
||||
}
|
||||
|
||||
public transformNode<TNode extends Node>(node: TNode): TNode {
|
||||
if (this.shouldVisitChildrenOfNode(node)) {
|
||||
return visitChildren(node, this);
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
}
|
||||
|
||||
export function visit<TNode extends Node>(node: TNode, transformer: Transformer): TNode {
|
||||
if (!node || !transformer) {
|
||||
return node;
|
||||
}
|
||||
|
||||
let transformed: TNode;
|
||||
if (transformer.shouldTransformNode(node)) {
|
||||
transformed = transformer.transformNode(node);
|
||||
}
|
||||
else if (transformer.shouldVisitChildrenOfNode(node)) {
|
||||
transformed = visitChildren(node, transformer);
|
||||
}
|
||||
|
||||
if (transformed && transformed !== node) {
|
||||
aggregateTransformFlags(transformed);
|
||||
}
|
||||
|
||||
return transformed;
|
||||
}
|
||||
|
||||
export function visitNodes<TNode extends Node>(nodes: NodeArray<TNode>, transformer: Transformer, cache?: TransformerCacheControl<TNode>, removeMissingNodes?: boolean): NodeArray<TNode> {
|
||||
if (!nodes || !transformer) {
|
||||
return nodes;
|
||||
}
|
||||
|
||||
let updatedNodes: TNode[];
|
||||
let updatedOffset = 0;
|
||||
let cacheOffset = 0;
|
||||
|
||||
for (var i = 0; i < nodes.length; i++) {
|
||||
let updatedIndex = i - updatedOffset;
|
||||
let node = nodes[i];
|
||||
if (cache && cache.shouldCachePreviousNodes(node)) {
|
||||
if (!updatedNodes) {
|
||||
updatedNodes = nodes.slice(0, i);
|
||||
}
|
||||
|
||||
while (cacheOffset < updatedIndex) {
|
||||
updatedNodes[cacheOffset] = cache.cacheNode(updatedNodes[cacheOffset]);
|
||||
cacheOffset++;
|
||||
}
|
||||
|
||||
cacheOffset = updatedIndex;
|
||||
}
|
||||
|
||||
let updatedNode = visit(node, transformer);
|
||||
if ((updatedNodes || updatedNode !== node || (!updatedNode && removeMissingNodes))) {
|
||||
if (!updatedNodes) {
|
||||
updatedNodes = nodes.slice(0, i);
|
||||
}
|
||||
if (!updatedNode && removeMissingNodes) {
|
||||
updatedOffset++;
|
||||
}
|
||||
else {
|
||||
updatedNodes[i - updatedOffset] = updatedNode;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (updatedNodes) {
|
||||
return factory.setTextRange(
|
||||
factory.createNodeArray(updatedNodes),
|
||||
nodes
|
||||
);
|
||||
}
|
||||
|
||||
return nodes;
|
||||
}
|
||||
|
||||
let transformFlags: TransformFlags;
|
||||
|
||||
function aggregateChildTransformFlags(child: Node) {
|
||||
let saveTransformFlags = transformFlags;
|
||||
aggregateTransformFlags(child);
|
||||
transformFlags = saveTransformFlags | (transformFlags & ~TransformFlags.ThisNodeFlags);
|
||||
}
|
||||
|
||||
export function aggregateTransformFlags(node: Node) {
|
||||
transformFlags = node.transformFlags;
|
||||
if (transformFlags === undefined) {
|
||||
forEachChild(node, aggregateChildTransformFlags);
|
||||
|
||||
// TODO(rbuckton): Aggregate transform flags for each node type
|
||||
switch (node.kind) {
|
||||
|
||||
}
|
||||
|
||||
node.transformFlags = transformFlags;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -18,6 +18,8 @@
|
||||
"utilities.ts",
|
||||
"binder.ts",
|
||||
"checker.ts",
|
||||
"transform.ts",
|
||||
"transform.generated.ts",
|
||||
"emitter.ts",
|
||||
"program.ts",
|
||||
"commandLineParser.ts",
|
||||
|
||||
@ -418,6 +418,19 @@ namespace ts {
|
||||
// Used to know if we've computed data from children and cached it in this node.
|
||||
HasAggregatedChildData = 1 << 7
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
export const enum TransformFlags {
|
||||
ThisNodeFlags = 0
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
export interface TransformResolver {
|
||||
getGeneratedNameForNode(node: Node): string;
|
||||
makeTempVariableName(loopVariable: boolean): string;
|
||||
makeUniqueName(baseName: string): string;
|
||||
getEmitResolver(): EmitResolver;
|
||||
}
|
||||
|
||||
export const enum JsxFlags {
|
||||
None = 0,
|
||||
@ -443,12 +456,14 @@ namespace ts {
|
||||
// @factoryhidden("jsDocComment", true)
|
||||
// @factoryhidden("nextContainer", true)
|
||||
// @factoryorder("decorators", "modifiers")
|
||||
// @nofactorynodetest
|
||||
export interface Node extends TextRange {
|
||||
kind: SyntaxKind;
|
||||
flags: NodeFlags;
|
||||
// Specific context the parser was in when this node was created. Normally undefined.
|
||||
// Only set when the parser was in some interesting context (like async/yield).
|
||||
/* @internal */ parserContextFlags?: ParserContextFlags;
|
||||
/* @internal */ transformFlags?: TransformFlags;
|
||||
decorators?: NodeArray<Decorator>; // Array of decorators (in document order)
|
||||
modifiers?: ModifiersArray; // Array of modifiers
|
||||
/* @internal */ id?: number; // Unique id (used to look up NodeLinks)
|
||||
@ -485,10 +500,12 @@ namespace ts {
|
||||
|
||||
export type EntityName = Identifier | QualifiedName;
|
||||
|
||||
// @nofactorynodetest
|
||||
export type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName | BindingPattern;
|
||||
|
||||
// @factoryhidden("decorators", false)
|
||||
// @factoryhidden("modifiers", false)
|
||||
// @nofactorynodetest
|
||||
export interface Declaration extends Node {
|
||||
_declarationBrand: any;
|
||||
name?: DeclarationName;
|
||||
@ -569,7 +586,7 @@ namespace ts {
|
||||
}
|
||||
|
||||
// @kind(SyntaxKind.PropertySignature)
|
||||
export interface PropertySignature extends Declaration, ClassElement {
|
||||
export interface PropertySignature extends Declaration {
|
||||
name: DeclarationName; // Declared property name
|
||||
// @factoryparam
|
||||
questionToken?: Node; // Present on optional property
|
||||
@ -578,7 +595,8 @@ namespace ts {
|
||||
|
||||
// @kind(SyntaxKind.PropertyDeclaration)
|
||||
// @factoryorder("decorators", "modifiers", "name", "questionToken", "type", "initializer")
|
||||
export interface PropertyDeclaration extends PropertySignature {
|
||||
export interface PropertyDeclaration extends PropertySignature, ClassElement {
|
||||
name: DeclarationName; // Declared property name
|
||||
initializer?: Expression; // Optional initializer
|
||||
}
|
||||
|
||||
@ -664,7 +682,7 @@ namespace ts {
|
||||
// @factoryhidden("asteriskToken", true)
|
||||
// @factoryhidden("body", true)
|
||||
// @factoryorder("decorators", "modifiers", "asteriskToken", "name", "questionToken", "typeParameters", "parameters", "type")
|
||||
export interface MethodSignature extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
export interface MethodSignature extends FunctionLikeDeclaration {
|
||||
}
|
||||
|
||||
// Note that a MethodDeclaration is considered both a ClassElement and an ObjectLiteralElement.
|
||||
@ -680,7 +698,7 @@ namespace ts {
|
||||
// @factoryhidden("questionToken", true)
|
||||
// @factoryhidden("body", false)
|
||||
// @factoryorder("decorators", "modifiers", "asteriskToken", "name", "typeParameters", "parameters", "type", "body")
|
||||
export interface MethodDeclaration extends MethodSignature {
|
||||
export interface MethodDeclaration extends MethodSignature, ClassElement, ObjectLiteralElement {
|
||||
body?: Block;
|
||||
}
|
||||
|
||||
@ -733,6 +751,7 @@ namespace ts {
|
||||
_indexSignatureDeclarationBrand: any;
|
||||
}
|
||||
|
||||
// @nofactorynodetest
|
||||
export interface TypeNode extends Node {
|
||||
_typeNodeBrand: any;
|
||||
}
|
||||
@ -818,6 +837,7 @@ namespace ts {
|
||||
// checker actually thinks you have something of the right type. Note: the brands are
|
||||
// never actually given values. At runtime they have zero cost.
|
||||
// @kind(SyntaxKind.OmittedExpression)
|
||||
// @nofactorynodetest
|
||||
export interface Expression extends Node {
|
||||
_expressionBrand: any;
|
||||
contextualType?: Type; // Used to temporarily assign a contextual type during overload resolution
|
||||
@ -845,6 +865,12 @@ namespace ts {
|
||||
_postfixExpressionBrand: any;
|
||||
}
|
||||
|
||||
// @kind(SyntaxKind.TrueKeyword, { create: false })
|
||||
// @kind(SyntaxKind.FalseKeyword, { create: false })
|
||||
// @kind(SyntaxKind.NullKeyword, { create: false })
|
||||
// @kind(SyntaxKind.ThisKeyword, { create: false })
|
||||
// @kind(SyntaxKind.SuperKeyword, { create: false })
|
||||
// @nofactorynodetest
|
||||
export interface LeftHandSideExpression extends PostfixExpression {
|
||||
_leftHandSideExpressionBrand: any;
|
||||
}
|
||||
@ -1081,11 +1107,16 @@ namespace ts {
|
||||
|
||||
export type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement;
|
||||
|
||||
// @kind(SyntaxKind.EmptyStatement)
|
||||
// @kind(SyntaxKind.DebuggerStatement);
|
||||
// @nofactorynodetest
|
||||
export interface Statement extends Node {
|
||||
_statementBrand: any;
|
||||
}
|
||||
|
||||
// @kind(SyntaxKind.EmptyStatement)
|
||||
export type EmptyStatement = Statement;
|
||||
|
||||
// @kind(SyntaxKind.DebuggerStatement)
|
||||
export type DebuggerStatement = Statement;
|
||||
|
||||
// @kind(SyntaxKind.MissingDeclaration)
|
||||
// @factoryhidden("name", true)
|
||||
@ -1471,7 +1502,7 @@ namespace ts {
|
||||
// @factoryhidden("initializer", true)
|
||||
// @factoryhidden("decorators", true)
|
||||
// @factoryhidden("modifiers", true)
|
||||
export interface JSDocRecordMember extends PropertyDeclaration {
|
||||
export interface JSDocRecordMember extends PropertySignature {
|
||||
name: Identifier | LiteralExpression,
|
||||
type?: JSDocType
|
||||
}
|
||||
|
||||
@ -1100,7 +1100,7 @@ namespace ts {
|
||||
return false;
|
||||
}
|
||||
|
||||
export function isDeclaration(node: Node): boolean {
|
||||
export function isDeclaration(node: Node): node is Declaration {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.ArrowFunction:
|
||||
case SyntaxKind.BindingElement:
|
||||
@ -1135,7 +1135,7 @@ namespace ts {
|
||||
return false;
|
||||
}
|
||||
|
||||
export function isStatement(n: Node): boolean {
|
||||
export function isStatement(n: Node): n is Statement {
|
||||
switch (n.kind) {
|
||||
case SyntaxKind.BreakStatement:
|
||||
case SyntaxKind.ContinueStatement:
|
||||
@ -1162,21 +1162,6 @@ namespace ts {
|
||||
}
|
||||
}
|
||||
|
||||
export function isClassElement(n: Node): boolean {
|
||||
switch (n.kind) {
|
||||
case SyntaxKind.Constructor:
|
||||
case SyntaxKind.PropertyDeclaration:
|
||||
case SyntaxKind.MethodDeclaration:
|
||||
case SyntaxKind.GetAccessor:
|
||||
case SyntaxKind.SetAccessor:
|
||||
case SyntaxKind.MethodSignature:
|
||||
case SyntaxKind.IndexSignature:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// True if the given identifier, string literal, or number literal is the name of a declaration node
|
||||
export function isDeclarationName(name: Node): boolean {
|
||||
if (name.kind !== SyntaxKind.Identifier && name.kind !== SyntaxKind.StringLiteral && name.kind !== SyntaxKind.NumericLiteral) {
|
||||
@ -1896,7 +1881,7 @@ namespace ts {
|
||||
return 0;
|
||||
}
|
||||
|
||||
export function isLeftHandSideExpression(expr: Expression): boolean {
|
||||
export function isLeftHandSideExpression(expr: Node): boolean {
|
||||
if (expr) {
|
||||
switch (expr.kind) {
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user