From 02ad58c7c7da7e64dd88cb6ede98947c7389b116 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Sun, 2 Nov 2014 23:02:42 -0800 Subject: [PATCH] Use functions instead of classes --- src/services/syntax/SyntaxGenerator.js | 53 +- src/services/syntax/parser.ts | 2 +- src/services/syntax/references.ts | 1 + src/services/syntax/syntaxGenerator.ts | 70 +- .../syntax/syntaxInterfaces.generated.ts | 181 ++ .../syntax/syntaxNodes.concrete.generated.ts | 2843 +++++------------ 6 files changed, 1170 insertions(+), 1980 deletions(-) diff --git a/src/services/syntax/SyntaxGenerator.js b/src/services/syntax/SyntaxGenerator.js index f4f7b43074a..883c9eb93fd 100644 --- a/src/services/syntax/SyntaxGenerator.js +++ b/src/services/syntax/SyntaxGenerator.js @@ -2587,6 +2587,26 @@ function generateNode(definition, abstract) { result += " }"; return result; } +function generateConstructorFunction(definition) { + var result = " function " + camelCase(definition.name) + "(data: number"; + for (var i = 0; i < definition.children.length; i++) { + var child = definition.children[i]; + result += ", "; + result += getSafeName(child); + result += ": " + getType(child); + } + result += ") {\r\n"; + for (var i = 0; i < definition.children.length; i++) { + var child = definition.children[i]; + result += " this." + child.name + " = " + getSafeName(child) + ";\r\n"; + } + result += " finishNode(this, data);\r\n"; + result += " }\r\n"; + result += " " + camelCase(definition.name) + ".prototype.kind = function() { return SyntaxKind." + getNameWithoutSuffix(definition) + "; }\r\n"; + result += " export var " + definition.name + ": " + getNameWithoutSuffix(definition) + "Constructor"; + result += " = " + camelCase(definition.name) + ";\r\n"; + return result; +} function syntaxKindName(kind) { for (var name in TypeScript.SyntaxKind) { if (TypeScript.SyntaxKind[name] === kind) { @@ -2614,7 +2634,6 @@ function generateSyntaxInterfaces() { } result += generateSyntaxInterface(definition); } - result += "\r\n"; result += "}"; return result; } @@ -2632,21 +2651,40 @@ function generateSyntaxInterface(definition) { var child = definition.children[i]; result += " " + child.name + ": " + getType(child) + ";\r\n"; } - result += " }"; + result += " }\r\n"; + result += " export interface " + getNameWithoutSuffix(definition) + "Constructor {"; + result += " new (data: number"; + for (var i = 0; i < definition.children.length; i++) { + var child = definition.children[i]; + result += ", "; + result += getSafeName(child); + result += ": " + getType(child); + } + result += "): " + definition.name; + result += " }\r\n"; return result; } function generateNodes(abstract) { var result = "///\r\n\r\n"; result += "module TypeScript"; result += " {\r\n"; + result += " function finishNode(node: ISyntaxNode, data: number) {\r\n"; + result += " for (var name in node) {\r\n"; + result += " if (node.hasOwnProperty(name)) {\r\n"; + result += " (node)[name] = node;\r\n"; + result += " }\r\n"; + result += " }\r\n"; + result += "\r\n"; + result += " if (data) {\r\n"; + result += " node.__data = data;\r\n"; + result += " }\r\n"; + result += " }\r\n"; for (var i = 0; i < definitions.length; i++) { var definition = definitions[i]; - if (i > 0) { - result += "\r\n"; - } - result += generateNode(definition, abstract); + result += "\r\n"; + result += generateConstructorFunction(definition); } - result += "\r\n}"; + result += "}"; return result; } function isInterface(name) { @@ -3042,6 +3080,7 @@ var visitor = generateVisitor(); var defaultVisitor = generateDefaultVisitor(); var servicesUtilities = generateServicesUtilities(); sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxNodes.concrete.generated.ts", syntaxNodesConcrete, false); +sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxInterfaces.generated.ts", syntaxInterfaces, false); sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxRewriter.generated.ts", rewriter, false); sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxWalker.generated.ts", walker, false); sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\scannerUtilities.generated.ts", scannerUtilities, false); diff --git a/src/services/syntax/parser.ts b/src/services/syntax/parser.ts index fd7f4ab1342..6f35b45428b 100644 --- a/src/services/syntax/parser.ts +++ b/src/services/syntax/parser.ts @@ -695,7 +695,7 @@ module TypeScript.Parser { var moduleElements = parseSyntaxList(ListParsingState.SourceUnit_ModuleElements, skippedTokens, updateStrictModeState); setStrictMode(savedIsInStrictMode); - + var sourceUnit = new SourceUnitSyntax(parseNodeData, moduleElements, currentToken()); sourceUnit = addSkippedTokensBeforeNode(sourceUnit, skippedTokens); diff --git a/src/services/syntax/references.ts b/src/services/syntax/references.ts index 722ea1b6a5f..888ee443e12 100644 --- a/src/services/syntax/references.ts +++ b/src/services/syntax/references.ts @@ -41,6 +41,7 @@ /// // Concrete nodes depend on the parser. +/// /// // SyntaxTree depends on PositionTrackingWalker diff --git a/src/services/syntax/syntaxGenerator.ts b/src/services/syntax/syntaxGenerator.ts index 3197d831ffa..67d0822a282 100644 --- a/src/services/syntax/syntaxGenerator.ts +++ b/src/services/syntax/syntaxGenerator.ts @@ -2015,6 +2015,34 @@ function generateNode(definition: ITypeDefinition, abstract: boolean): string { return result; } +function generateConstructorFunction(definition: ITypeDefinition) { + var result = " function " + camelCase(definition.name) + "(data: number"; + + for (var i = 0; i < definition.children.length; i++) { + var child = definition.children[i]; + result += ", "; + result += getSafeName(child); + result += ": " + getType(child); + } + + result += ") {\r\n"; + + for (var i = 0; i < definition.children.length; i++) { + var child = definition.children[i]; + result += " this." + child.name + " = " + getSafeName(child) + ";\r\n"; + } + + result += " finishNode(this, data);\r\n"; + + result += " }\r\n"; + result += " " + camelCase(definition.name) + ".prototype.kind = function() { return SyntaxKind." + getNameWithoutSuffix(definition) + "; }\r\n"; + + result += " export var " + definition.name + ": " + getNameWithoutSuffix(definition) + "Constructor"; + result += " = " + camelCase(definition.name) + ";\r\n"; + + return result; +} + function syntaxKindName(kind: TypeScript.SyntaxKind): string { for (var name in TypeScript.SyntaxKind) { if (TypeScript.SyntaxKind[name] === kind) { @@ -2052,8 +2080,6 @@ function generateSyntaxInterfaces(): string { result += generateSyntaxInterface(definition); } - result += "\r\n"; - result += "}"; return result; } @@ -2077,7 +2103,19 @@ function generateSyntaxInterface(definition: ITypeDefinition): string { result += " " + child.name + ": " + getType(child) + ";\r\n"; } - result += " }"; + result += " }\r\n"; + result += " export interface " + getNameWithoutSuffix(definition) + "Constructor {"; + result += " new (data: number"; + + for (var i = 0; i < definition.children.length; i++) { + var child = definition.children[i]; + result += ", "; + result += getSafeName(child); + result += ": " + getType(child); + } + + result += "): " + definition.name; + result += " }\r\n"; return result; } @@ -2089,17 +2127,30 @@ function generateNodes(abstract: boolean): string { result += "module TypeScript"; result += " {\r\n"; + result += " function finishNode(node: ISyntaxNode, data: number) {\r\n"; + result += " for (var i = 0, n = childCount(node); i < n; i++) {\r\n"; + result += " childAt(node, i).parent = node;\r\n"; + result += " }\r\n"; + //result += " for (var name in node) {\r\n"; + //result += " if (node.hasOwnProperty(name)) {\r\n"; + //result += " (node)[name] = node;\r\n"; + //result += " }\r\n"; + //result += " }\r\n"; + result += "\r\n"; + result += " if (data) {\r\n"; + result += " node.__data = data;\r\n"; + result += " }\r\n"; + result += " }\r\n"; + for (var i = 0; i < definitions.length; i++) { var definition = definitions[i]; - if (i > 0) { - result += "\r\n"; - } - - result += generateNode(definition, abstract); + result += "\r\n"; + result += generateConstructorFunction(definition); + // result += generateNode(definition, abstract); } - result += "\r\n}"; + result += "}"; return result; } @@ -2700,6 +2751,7 @@ var defaultVisitor = generateDefaultVisitor(); var servicesUtilities = generateServicesUtilities(); sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxNodes.concrete.generated.ts", syntaxNodesConcrete, false); +sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxInterfaces.generated.ts", syntaxInterfaces, false); sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxRewriter.generated.ts", rewriter, false); sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxWalker.generated.ts", walker, false); sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\scannerUtilities.generated.ts", scannerUtilities, false); diff --git a/src/services/syntax/syntaxInterfaces.generated.ts b/src/services/syntax/syntaxInterfaces.generated.ts index fe7660af07f..ba1b6a7298a 100644 --- a/src/services/syntax/syntaxInterfaces.generated.ts +++ b/src/services/syntax/syntaxInterfaces.generated.ts @@ -6,27 +6,37 @@ module TypeScript { moduleElements: IModuleElementSyntax[]; endOfFileToken: ISyntaxToken; } + export interface SourceUnitConstructor { new (data: number, moduleElements: IModuleElementSyntax[], endOfFileToken: ISyntaxToken): SourceUnitSyntax } + export interface QualifiedNameSyntax extends ISyntaxNode, INameSyntax { left: INameSyntax; dotToken: ISyntaxToken; right: ISyntaxToken; } + export interface QualifiedNameConstructor { new (data: number, left: INameSyntax, dotToken: ISyntaxToken, right: ISyntaxToken): QualifiedNameSyntax } + export interface ObjectTypeSyntax extends ISyntaxNode, ITypeSyntax { openBraceToken: ISyntaxToken; typeMembers: ISeparatedSyntaxList; closeBraceToken: ISyntaxToken; } + export interface ObjectTypeConstructor { new (data: number, openBraceToken: ISyntaxToken, typeMembers: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken): ObjectTypeSyntax } + export interface FunctionTypeSyntax extends ISyntaxNode, ITypeSyntax { typeParameterList: TypeParameterListSyntax; parameterList: ParameterListSyntax; equalsGreaterThanToken: ISyntaxToken; type: ITypeSyntax; } + export interface FunctionTypeConstructor { new (data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax): FunctionTypeSyntax } + export interface ArrayTypeSyntax extends ISyntaxNode, ITypeSyntax { type: ITypeSyntax; openBracketToken: ISyntaxToken; closeBracketToken: ISyntaxToken; } + export interface ArrayTypeConstructor { new (data: number, type: ITypeSyntax, openBracketToken: ISyntaxToken, closeBracketToken: ISyntaxToken): ArrayTypeSyntax } + export interface ConstructorTypeSyntax extends ISyntaxNode, ITypeSyntax { newKeyword: ISyntaxToken; typeParameterList: TypeParameterListSyntax; @@ -34,29 +44,41 @@ module TypeScript { equalsGreaterThanToken: ISyntaxToken; type: ITypeSyntax; } + export interface ConstructorTypeConstructor { new (data: number, newKeyword: ISyntaxToken, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax): ConstructorTypeSyntax } + export interface GenericTypeSyntax extends ISyntaxNode, ITypeSyntax { name: INameSyntax; typeArgumentList: TypeArgumentListSyntax; } + export interface GenericTypeConstructor { new (data: number, name: INameSyntax, typeArgumentList: TypeArgumentListSyntax): GenericTypeSyntax } + export interface TypeQuerySyntax extends ISyntaxNode, ITypeSyntax { typeOfKeyword: ISyntaxToken; name: INameSyntax; } + export interface TypeQueryConstructor { new (data: number, typeOfKeyword: ISyntaxToken, name: INameSyntax): TypeQuerySyntax } + export interface TupleTypeSyntax extends ISyntaxNode, ITypeSyntax { openBracketToken: ISyntaxToken; types: ISeparatedSyntaxList; closeBracketToken: ISyntaxToken; } + export interface TupleTypeConstructor { new (data: number, openBracketToken: ISyntaxToken, types: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken): TupleTypeSyntax } + export interface UnionTypeSyntax extends ISyntaxNode, ITypeSyntax { left: ITypeSyntax; barToken: ISyntaxToken; right: ITypeSyntax; } + export interface UnionTypeConstructor { new (data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax): UnionTypeSyntax } + export interface ParenthesizedTypeSyntax extends ISyntaxNode, ITypeSyntax { openParenToken: ISyntaxToken; type: ITypeSyntax; closeParenToken: ISyntaxToken; } + export interface ParenthesizedTypeConstructor { new (data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken): ParenthesizedTypeSyntax } + export interface InterfaceDeclarationSyntax extends ISyntaxNode, IModuleElementSyntax { modifiers: ISyntaxToken[]; interfaceKeyword: ISyntaxToken; @@ -65,6 +87,8 @@ module TypeScript { heritageClauses: HeritageClauseSyntax[]; body: ObjectTypeSyntax; } + export interface InterfaceDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], interfaceKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], body: ObjectTypeSyntax): InterfaceDeclarationSyntax } + export interface FunctionDeclarationSyntax extends ISyntaxNode, IStatementSyntax { modifiers: ISyntaxToken[]; functionKeyword: ISyntaxToken; @@ -73,6 +97,8 @@ module TypeScript { block: BlockSyntax; semicolonToken: ISyntaxToken; } + export interface FunctionDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): FunctionDeclarationSyntax } + export interface ModuleDeclarationSyntax extends ISyntaxNode, IModuleElementSyntax { modifiers: ISyntaxToken[]; moduleKeyword: ISyntaxToken; @@ -82,6 +108,8 @@ module TypeScript { moduleElements: IModuleElementSyntax[]; closeBraceToken: ISyntaxToken; } + export interface ModuleDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], moduleKeyword: ISyntaxToken, name: INameSyntax, stringLiteral: ISyntaxToken, openBraceToken: ISyntaxToken, moduleElements: IModuleElementSyntax[], closeBraceToken: ISyntaxToken): ModuleDeclarationSyntax } + export interface ClassDeclarationSyntax extends ISyntaxNode, IModuleElementSyntax { modifiers: ISyntaxToken[]; classKeyword: ISyntaxToken; @@ -92,6 +120,8 @@ module TypeScript { classElements: IClassElementSyntax[]; closeBraceToken: ISyntaxToken; } + export interface ClassDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], classKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], openBraceToken: ISyntaxToken, classElements: IClassElementSyntax[], closeBraceToken: ISyntaxToken): ClassDeclarationSyntax } + export interface EnumDeclarationSyntax extends ISyntaxNode, IModuleElementSyntax { modifiers: ISyntaxToken[]; enumKeyword: ISyntaxToken; @@ -100,6 +130,8 @@ module TypeScript { enumElements: ISeparatedSyntaxList; closeBraceToken: ISyntaxToken; } + export interface EnumDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken): EnumDeclarationSyntax } + export interface ImportDeclarationSyntax extends ISyntaxNode, IModuleElementSyntax { modifiers: ISyntaxToken[]; importKeyword: ISyntaxToken; @@ -108,12 +140,16 @@ module TypeScript { moduleReference: IModuleReferenceSyntax; semicolonToken: ISyntaxToken; } + export interface ImportDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], importKeyword: ISyntaxToken, identifier: ISyntaxToken, equalsToken: ISyntaxToken, moduleReference: IModuleReferenceSyntax, semicolonToken: ISyntaxToken): ImportDeclarationSyntax } + export interface ExportAssignmentSyntax extends ISyntaxNode, IModuleElementSyntax { exportKeyword: ISyntaxToken; equalsToken: ISyntaxToken; identifier: ISyntaxToken; semicolonToken: ISyntaxToken; } + export interface ExportAssignmentConstructor { new (data: number, exportKeyword: ISyntaxToken, equalsToken: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken): ExportAssignmentSyntax } + export interface MemberFunctionDeclarationSyntax extends ISyntaxNode, IMemberDeclarationSyntax { modifiers: ISyntaxToken[]; propertyName: ISyntaxToken; @@ -121,11 +157,15 @@ module TypeScript { block: BlockSyntax; semicolonToken: ISyntaxToken; } + export interface MemberFunctionDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): MemberFunctionDeclarationSyntax } + export interface MemberVariableDeclarationSyntax extends ISyntaxNode, IMemberDeclarationSyntax { modifiers: ISyntaxToken[]; variableDeclarator: VariableDeclaratorSyntax; semicolonToken: ISyntaxToken; } + export interface MemberVariableDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], variableDeclarator: VariableDeclaratorSyntax, semicolonToken: ISyntaxToken): MemberVariableDeclarationSyntax } + export interface ConstructorDeclarationSyntax extends ISyntaxNode, IClassElementSyntax { modifiers: ISyntaxToken[]; constructorKeyword: ISyntaxToken; @@ -133,11 +173,15 @@ module TypeScript { block: BlockSyntax; semicolonToken: ISyntaxToken; } + export interface ConstructorDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], constructorKeyword: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): ConstructorDeclarationSyntax } + export interface IndexMemberDeclarationSyntax extends ISyntaxNode, IClassElementSyntax { modifiers: ISyntaxToken[]; indexSignature: IndexSignatureSyntax; semicolonToken: ISyntaxToken; } + export interface IndexMemberDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], indexSignature: IndexSignatureSyntax, semicolonToken: ISyntaxToken): IndexMemberDeclarationSyntax } + export interface GetAccessorSyntax extends ISyntaxNode, IMemberDeclarationSyntax, IPropertyAssignmentSyntax { modifiers: ISyntaxToken[]; getKeyword: ISyntaxToken; @@ -145,6 +189,8 @@ module TypeScript { callSignature: CallSignatureSyntax; block: BlockSyntax; } + export interface GetAccessorConstructor { new (data: number, modifiers: ISyntaxToken[], getKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): GetAccessorSyntax } + export interface SetAccessorSyntax extends ISyntaxNode, IMemberDeclarationSyntax, IPropertyAssignmentSyntax { modifiers: ISyntaxToken[]; setKeyword: ISyntaxToken; @@ -152,36 +198,50 @@ module TypeScript { callSignature: CallSignatureSyntax; block: BlockSyntax; } + export interface SetAccessorConstructor { new (data: number, modifiers: ISyntaxToken[], setKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): SetAccessorSyntax } + export interface PropertySignatureSyntax extends ISyntaxNode, ITypeMemberSyntax { propertyName: ISyntaxToken; questionToken: ISyntaxToken; typeAnnotation: TypeAnnotationSyntax; } + export interface PropertySignatureConstructor { new (data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax): PropertySignatureSyntax } + export interface CallSignatureSyntax extends ISyntaxNode, ITypeMemberSyntax { typeParameterList: TypeParameterListSyntax; parameterList: ParameterListSyntax; typeAnnotation: TypeAnnotationSyntax; } + export interface CallSignatureConstructor { new (data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, typeAnnotation: TypeAnnotationSyntax): CallSignatureSyntax } + export interface ConstructSignatureSyntax extends ISyntaxNode, ITypeMemberSyntax { newKeyword: ISyntaxToken; callSignature: CallSignatureSyntax; } + export interface ConstructSignatureConstructor { new (data: number, newKeyword: ISyntaxToken, callSignature: CallSignatureSyntax): ConstructSignatureSyntax } + export interface IndexSignatureSyntax extends ISyntaxNode, ITypeMemberSyntax { openBracketToken: ISyntaxToken; parameters: ISeparatedSyntaxList; closeBracketToken: ISyntaxToken; typeAnnotation: TypeAnnotationSyntax; } + export interface IndexSignatureConstructor { new (data: number, openBracketToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax): IndexSignatureSyntax } + export interface MethodSignatureSyntax extends ISyntaxNode, ITypeMemberSyntax { propertyName: ISyntaxToken; questionToken: ISyntaxToken; callSignature: CallSignatureSyntax; } + export interface MethodSignatureConstructor { new (data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, callSignature: CallSignatureSyntax): MethodSignatureSyntax } + export interface BlockSyntax extends ISyntaxNode, IStatementSyntax { openBraceToken: ISyntaxToken; statements: IStatementSyntax[]; closeBraceToken: ISyntaxToken; } + export interface BlockConstructor { new (data: number, openBraceToken: ISyntaxToken, statements: IStatementSyntax[], closeBraceToken: ISyntaxToken): BlockSyntax } + export interface IfStatementSyntax extends ISyntaxNode, IStatementSyntax { ifKeyword: ISyntaxToken; openParenToken: ISyntaxToken; @@ -190,20 +250,28 @@ module TypeScript { statement: IStatementSyntax; elseClause: ElseClauseSyntax; } + export interface IfStatementConstructor { new (data: number, ifKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax, elseClause: ElseClauseSyntax): IfStatementSyntax } + export interface VariableStatementSyntax extends ISyntaxNode, IStatementSyntax { modifiers: ISyntaxToken[]; variableDeclaration: VariableDeclarationSyntax; semicolonToken: ISyntaxToken; } + export interface VariableStatementConstructor { new (data: number, modifiers: ISyntaxToken[], variableDeclaration: VariableDeclarationSyntax, semicolonToken: ISyntaxToken): VariableStatementSyntax } + export interface ExpressionStatementSyntax extends ISyntaxNode, IStatementSyntax { expression: IExpressionSyntax; semicolonToken: ISyntaxToken; } + export interface ExpressionStatementConstructor { new (data: number, expression: IExpressionSyntax, semicolonToken: ISyntaxToken): ExpressionStatementSyntax } + export interface ReturnStatementSyntax extends ISyntaxNode, IStatementSyntax { returnKeyword: ISyntaxToken; expression: IExpressionSyntax; semicolonToken: ISyntaxToken; } + export interface ReturnStatementConstructor { new (data: number, returnKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken): ReturnStatementSyntax } + export interface SwitchStatementSyntax extends ISyntaxNode, IStatementSyntax { switchKeyword: ISyntaxToken; openParenToken: ISyntaxToken; @@ -213,16 +281,22 @@ module TypeScript { switchClauses: ISwitchClauseSyntax[]; closeBraceToken: ISyntaxToken; } + export interface SwitchStatementConstructor { new (data: number, switchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, openBraceToken: ISyntaxToken, switchClauses: ISwitchClauseSyntax[], closeBraceToken: ISyntaxToken): SwitchStatementSyntax } + export interface BreakStatementSyntax extends ISyntaxNode, IStatementSyntax { breakKeyword: ISyntaxToken; identifier: ISyntaxToken; semicolonToken: ISyntaxToken; } + export interface BreakStatementConstructor { new (data: number, breakKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken): BreakStatementSyntax } + export interface ContinueStatementSyntax extends ISyntaxNode, IStatementSyntax { continueKeyword: ISyntaxToken; identifier: ISyntaxToken; semicolonToken: ISyntaxToken; } + export interface ContinueStatementConstructor { new (data: number, continueKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken): ContinueStatementSyntax } + export interface ForStatementSyntax extends ISyntaxNode, IStatementSyntax { forKeyword: ISyntaxToken; openParenToken: ISyntaxToken; @@ -235,6 +309,8 @@ module TypeScript { closeParenToken: ISyntaxToken; statement: IStatementSyntax; } + export interface ForStatementConstructor { new (data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, initializer: IExpressionSyntax, firstSemicolonToken: ISyntaxToken, condition: IExpressionSyntax, secondSemicolonToken: ISyntaxToken, incrementor: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax): ForStatementSyntax } + export interface ForInStatementSyntax extends ISyntaxNode, IStatementSyntax { forKeyword: ISyntaxToken; openParenToken: ISyntaxToken; @@ -245,14 +321,20 @@ module TypeScript { closeParenToken: ISyntaxToken; statement: IStatementSyntax; } + export interface ForInStatementConstructor { new (data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, left: IExpressionSyntax, inKeyword: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax): ForInStatementSyntax } + export interface EmptyStatementSyntax extends ISyntaxNode, IStatementSyntax { semicolonToken: ISyntaxToken; } + export interface EmptyStatementConstructor { new (data: number, semicolonToken: ISyntaxToken): EmptyStatementSyntax } + export interface ThrowStatementSyntax extends ISyntaxNode, IStatementSyntax { throwKeyword: ISyntaxToken; expression: IExpressionSyntax; semicolonToken: ISyntaxToken; } + export interface ThrowStatementConstructor { new (data: number, throwKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken): ThrowStatementSyntax } + export interface WhileStatementSyntax extends ISyntaxNode, IStatementSyntax { whileKeyword: ISyntaxToken; openParenToken: ISyntaxToken; @@ -260,17 +342,23 @@ module TypeScript { closeParenToken: ISyntaxToken; statement: IStatementSyntax; } + export interface WhileStatementConstructor { new (data: number, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax): WhileStatementSyntax } + export interface TryStatementSyntax extends ISyntaxNode, IStatementSyntax { tryKeyword: ISyntaxToken; block: BlockSyntax; catchClause: CatchClauseSyntax; finallyClause: FinallyClauseSyntax; } + export interface TryStatementConstructor { new (data: number, tryKeyword: ISyntaxToken, block: BlockSyntax, catchClause: CatchClauseSyntax, finallyClause: FinallyClauseSyntax): TryStatementSyntax } + export interface LabeledStatementSyntax extends ISyntaxNode, IStatementSyntax { identifier: ISyntaxToken; colonToken: ISyntaxToken; statement: IStatementSyntax; } + export interface LabeledStatementConstructor { new (data: number, identifier: ISyntaxToken, colonToken: ISyntaxToken, statement: IStatementSyntax): LabeledStatementSyntax } + export interface DoStatementSyntax extends ISyntaxNode, IStatementSyntax { doKeyword: ISyntaxToken; statement: IStatementSyntax; @@ -280,10 +368,14 @@ module TypeScript { closeParenToken: ISyntaxToken; semicolonToken: ISyntaxToken; } + export interface DoStatementConstructor { new (data: number, doKeyword: ISyntaxToken, statement: IStatementSyntax, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, semicolonToken: ISyntaxToken): DoStatementSyntax } + export interface DebuggerStatementSyntax extends ISyntaxNode, IStatementSyntax { debuggerKeyword: ISyntaxToken; semicolonToken: ISyntaxToken; } + export interface DebuggerStatementConstructor { new (data: number, debuggerKeyword: ISyntaxToken, semicolonToken: ISyntaxToken): DebuggerStatementSyntax } + export interface WithStatementSyntax extends ISyntaxNode, IStatementSyntax { withKeyword: ISyntaxToken; openParenToken: ISyntaxToken; @@ -291,22 +383,32 @@ module TypeScript { closeParenToken: ISyntaxToken; statement: IStatementSyntax; } + export interface WithStatementConstructor { new (data: number, withKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax): WithStatementSyntax } + export interface PrefixUnaryExpressionSyntax extends ISyntaxNode, IUnaryExpressionSyntax { operatorToken: ISyntaxToken; operand: IUnaryExpressionSyntax; } + export interface PrefixUnaryExpressionConstructor { new (data: number, operatorToken: ISyntaxToken, operand: IUnaryExpressionSyntax): PrefixUnaryExpressionSyntax } + export interface DeleteExpressionSyntax extends ISyntaxNode, IUnaryExpressionSyntax { deleteKeyword: ISyntaxToken; expression: IUnaryExpressionSyntax; } + export interface DeleteExpressionConstructor { new (data: number, deleteKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax): DeleteExpressionSyntax } + export interface TypeOfExpressionSyntax extends ISyntaxNode, IUnaryExpressionSyntax { typeOfKeyword: ISyntaxToken; expression: IUnaryExpressionSyntax; } + export interface TypeOfExpressionConstructor { new (data: number, typeOfKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax): TypeOfExpressionSyntax } + export interface VoidExpressionSyntax extends ISyntaxNode, IUnaryExpressionSyntax { voidKeyword: ISyntaxToken; expression: IUnaryExpressionSyntax; } + export interface VoidExpressionConstructor { new (data: number, voidKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax): VoidExpressionSyntax } + export interface ConditionalExpressionSyntax extends ISyntaxNode, IExpressionSyntax { condition: IExpressionSyntax; questionToken: ISyntaxToken; @@ -314,137 +416,193 @@ module TypeScript { colonToken: ISyntaxToken; whenFalse: IExpressionSyntax; } + export interface ConditionalExpressionConstructor { new (data: number, condition: IExpressionSyntax, questionToken: ISyntaxToken, whenTrue: IExpressionSyntax, colonToken: ISyntaxToken, whenFalse: IExpressionSyntax): ConditionalExpressionSyntax } + export interface BinaryExpressionSyntax extends ISyntaxNode, IExpressionSyntax { left: IExpressionSyntax; operatorToken: ISyntaxToken; right: IExpressionSyntax; } + export interface BinaryExpressionConstructor { new (data: number, left: IExpressionSyntax, operatorToken: ISyntaxToken, right: IExpressionSyntax): BinaryExpressionSyntax } + export interface PostfixUnaryExpressionSyntax extends ISyntaxNode, IPostfixExpressionSyntax { operand: ILeftHandSideExpressionSyntax; operatorToken: ISyntaxToken; } + export interface PostfixUnaryExpressionConstructor { new (data: number, operand: ILeftHandSideExpressionSyntax, operatorToken: ISyntaxToken): PostfixUnaryExpressionSyntax } + export interface MemberAccessExpressionSyntax extends ISyntaxNode, IMemberExpressionSyntax, ICallExpressionSyntax { expression: ILeftHandSideExpressionSyntax; dotToken: ISyntaxToken; name: ISyntaxToken; } + export interface MemberAccessExpressionConstructor { new (data: number, expression: ILeftHandSideExpressionSyntax, dotToken: ISyntaxToken, name: ISyntaxToken): MemberAccessExpressionSyntax } + export interface InvocationExpressionSyntax extends ISyntaxNode, ICallExpressionSyntax { expression: ILeftHandSideExpressionSyntax; argumentList: ArgumentListSyntax; } + export interface InvocationExpressionConstructor { new (data: number, expression: ILeftHandSideExpressionSyntax, argumentList: ArgumentListSyntax): InvocationExpressionSyntax } + export interface ArrayLiteralExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax { openBracketToken: ISyntaxToken; expressions: ISeparatedSyntaxList; closeBracketToken: ISyntaxToken; } + export interface ArrayLiteralExpressionConstructor { new (data: number, openBracketToken: ISyntaxToken, expressions: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken): ArrayLiteralExpressionSyntax } + export interface ObjectLiteralExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax { openBraceToken: ISyntaxToken; propertyAssignments: ISeparatedSyntaxList; closeBraceToken: ISyntaxToken; } + export interface ObjectLiteralExpressionConstructor { new (data: number, openBraceToken: ISyntaxToken, propertyAssignments: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken): ObjectLiteralExpressionSyntax } + export interface ObjectCreationExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax { newKeyword: ISyntaxToken; expression: IMemberExpressionSyntax; argumentList: ArgumentListSyntax; } + export interface ObjectCreationExpressionConstructor { new (data: number, newKeyword: ISyntaxToken, expression: IMemberExpressionSyntax, argumentList: ArgumentListSyntax): ObjectCreationExpressionSyntax } + export interface ParenthesizedExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax { openParenToken: ISyntaxToken; expression: IExpressionSyntax; closeParenToken: ISyntaxToken; } + export interface ParenthesizedExpressionConstructor { new (data: number, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken): ParenthesizedExpressionSyntax } + export interface ParenthesizedArrowFunctionExpressionSyntax extends ISyntaxNode, IUnaryExpressionSyntax { callSignature: CallSignatureSyntax; equalsGreaterThanToken: ISyntaxToken; block: BlockSyntax; expression: IExpressionSyntax; } + export interface ParenthesizedArrowFunctionExpressionConstructor { new (data: number, callSignature: CallSignatureSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax): ParenthesizedArrowFunctionExpressionSyntax } + export interface SimpleArrowFunctionExpressionSyntax extends ISyntaxNode, IUnaryExpressionSyntax { parameter: ParameterSyntax; equalsGreaterThanToken: ISyntaxToken; block: BlockSyntax; expression: IExpressionSyntax; } + export interface SimpleArrowFunctionExpressionConstructor { new (data: number, parameter: ParameterSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax): SimpleArrowFunctionExpressionSyntax } + export interface CastExpressionSyntax extends ISyntaxNode, IUnaryExpressionSyntax { lessThanToken: ISyntaxToken; type: ITypeSyntax; greaterThanToken: ISyntaxToken; expression: IUnaryExpressionSyntax; } + export interface CastExpressionConstructor { new (data: number, lessThanToken: ISyntaxToken, type: ITypeSyntax, greaterThanToken: ISyntaxToken, expression: IUnaryExpressionSyntax): CastExpressionSyntax } + export interface ElementAccessExpressionSyntax extends ISyntaxNode, IMemberExpressionSyntax, ICallExpressionSyntax { expression: ILeftHandSideExpressionSyntax; openBracketToken: ISyntaxToken; argumentExpression: IExpressionSyntax; closeBracketToken: ISyntaxToken; } + export interface ElementAccessExpressionConstructor { new (data: number, expression: ILeftHandSideExpressionSyntax, openBracketToken: ISyntaxToken, argumentExpression: IExpressionSyntax, closeBracketToken: ISyntaxToken): ElementAccessExpressionSyntax } + export interface FunctionExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax { functionKeyword: ISyntaxToken; identifier: ISyntaxToken; callSignature: CallSignatureSyntax; block: BlockSyntax; } + export interface FunctionExpressionConstructor { new (data: number, functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): FunctionExpressionSyntax } + export interface OmittedExpressionSyntax extends ISyntaxNode, IExpressionSyntax { } + export interface OmittedExpressionConstructor { new (data: number): OmittedExpressionSyntax } + export interface TemplateExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax { templateStartToken: ISyntaxToken; templateClauses: TemplateClauseSyntax[]; } + export interface TemplateExpressionConstructor { new (data: number, templateStartToken: ISyntaxToken, templateClauses: TemplateClauseSyntax[]): TemplateExpressionSyntax } + export interface TemplateAccessExpressionSyntax extends ISyntaxNode, IMemberExpressionSyntax, ICallExpressionSyntax { expression: ILeftHandSideExpressionSyntax; templateExpression: IPrimaryExpressionSyntax; } + export interface TemplateAccessExpressionConstructor { new (data: number, expression: ILeftHandSideExpressionSyntax, templateExpression: IPrimaryExpressionSyntax): TemplateAccessExpressionSyntax } + export interface VariableDeclarationSyntax extends ISyntaxNode { varKeyword: ISyntaxToken; variableDeclarators: ISeparatedSyntaxList; } + export interface VariableDeclarationConstructor { new (data: number, varKeyword: ISyntaxToken, variableDeclarators: ISeparatedSyntaxList): VariableDeclarationSyntax } + export interface VariableDeclaratorSyntax extends ISyntaxNode { propertyName: ISyntaxToken; typeAnnotation: TypeAnnotationSyntax; equalsValueClause: EqualsValueClauseSyntax; } + export interface VariableDeclaratorConstructor { new (data: number, propertyName: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax): VariableDeclaratorSyntax } + export interface ArgumentListSyntax extends ISyntaxNode { typeArgumentList: TypeArgumentListSyntax; openParenToken: ISyntaxToken; arguments: ISeparatedSyntaxList; closeParenToken: ISyntaxToken; } + export interface ArgumentListConstructor { new (data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, _arguments: ISeparatedSyntaxList, closeParenToken: ISyntaxToken): ArgumentListSyntax } + export interface ParameterListSyntax extends ISyntaxNode { openParenToken: ISyntaxToken; parameters: ISeparatedSyntaxList; closeParenToken: ISyntaxToken; } + export interface ParameterListConstructor { new (data: number, openParenToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeParenToken: ISyntaxToken): ParameterListSyntax } + export interface TypeArgumentListSyntax extends ISyntaxNode { lessThanToken: ISyntaxToken; typeArguments: ISeparatedSyntaxList; greaterThanToken: ISyntaxToken; } + export interface TypeArgumentListConstructor { new (data: number, lessThanToken: ISyntaxToken, typeArguments: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken): TypeArgumentListSyntax } + export interface TypeParameterListSyntax extends ISyntaxNode { lessThanToken: ISyntaxToken; typeParameters: ISeparatedSyntaxList; greaterThanToken: ISyntaxToken; } + export interface TypeParameterListConstructor { new (data: number, lessThanToken: ISyntaxToken, typeParameters: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken): TypeParameterListSyntax } + export interface HeritageClauseSyntax extends ISyntaxNode { extendsOrImplementsKeyword: ISyntaxToken; typeNames: ISeparatedSyntaxList; } + export interface HeritageClauseConstructor { new (data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: ISeparatedSyntaxList): HeritageClauseSyntax } + export interface EqualsValueClauseSyntax extends ISyntaxNode { equalsToken: ISyntaxToken; value: IExpressionSyntax; } + export interface EqualsValueClauseConstructor { new (data: number, equalsToken: ISyntaxToken, value: IExpressionSyntax): EqualsValueClauseSyntax } + export interface CaseSwitchClauseSyntax extends ISyntaxNode, ISwitchClauseSyntax { caseKeyword: ISyntaxToken; expression: IExpressionSyntax; colonToken: ISyntaxToken; statements: IStatementSyntax[]; } + export interface CaseSwitchClauseConstructor { new (data: number, caseKeyword: ISyntaxToken, expression: IExpressionSyntax, colonToken: ISyntaxToken, statements: IStatementSyntax[]): CaseSwitchClauseSyntax } + export interface DefaultSwitchClauseSyntax extends ISyntaxNode, ISwitchClauseSyntax { defaultKeyword: ISyntaxToken; colonToken: ISyntaxToken; statements: IStatementSyntax[]; } + export interface DefaultSwitchClauseConstructor { new (data: number, defaultKeyword: ISyntaxToken, colonToken: ISyntaxToken, statements: IStatementSyntax[]): DefaultSwitchClauseSyntax } + export interface ElseClauseSyntax extends ISyntaxNode { elseKeyword: ISyntaxToken; statement: IStatementSyntax; } + export interface ElseClauseConstructor { new (data: number, elseKeyword: ISyntaxToken, statement: IStatementSyntax): ElseClauseSyntax } + export interface CatchClauseSyntax extends ISyntaxNode { catchKeyword: ISyntaxToken; openParenToken: ISyntaxToken; @@ -453,32 +611,46 @@ module TypeScript { closeParenToken: ISyntaxToken; block: BlockSyntax; } + export interface CatchClauseConstructor { new (data: number, catchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, identifier: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, closeParenToken: ISyntaxToken, block: BlockSyntax): CatchClauseSyntax } + export interface FinallyClauseSyntax extends ISyntaxNode { finallyKeyword: ISyntaxToken; block: BlockSyntax; } + export interface FinallyClauseConstructor { new (data: number, finallyKeyword: ISyntaxToken, block: BlockSyntax): FinallyClauseSyntax } + export interface TemplateClauseSyntax extends ISyntaxNode { expression: IExpressionSyntax; templateMiddleOrEndToken: ISyntaxToken; } + export interface TemplateClauseConstructor { new (data: number, expression: IExpressionSyntax, templateMiddleOrEndToken: ISyntaxToken): TemplateClauseSyntax } + export interface TypeParameterSyntax extends ISyntaxNode { identifier: ISyntaxToken; constraint: ConstraintSyntax; } + export interface TypeParameterConstructor { new (data: number, identifier: ISyntaxToken, constraint: ConstraintSyntax): TypeParameterSyntax } + export interface ConstraintSyntax extends ISyntaxNode { extendsKeyword: ISyntaxToken; typeOrExpression: ISyntaxNodeOrToken; } + export interface ConstraintConstructor { new (data: number, extendsKeyword: ISyntaxToken, typeOrExpression: ISyntaxNodeOrToken): ConstraintSyntax } + export interface SimplePropertyAssignmentSyntax extends ISyntaxNode, IPropertyAssignmentSyntax { propertyName: ISyntaxToken; colonToken: ISyntaxToken; expression: IExpressionSyntax; } + export interface SimplePropertyAssignmentConstructor { new (data: number, propertyName: ISyntaxToken, colonToken: ISyntaxToken, expression: IExpressionSyntax): SimplePropertyAssignmentSyntax } + export interface FunctionPropertyAssignmentSyntax extends ISyntaxNode, IPropertyAssignmentSyntax { propertyName: ISyntaxToken; callSignature: CallSignatureSyntax; block: BlockSyntax; } + export interface FunctionPropertyAssignmentConstructor { new (data: number, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): FunctionPropertyAssignmentSyntax } + export interface ParameterSyntax extends ISyntaxNode { dotDotDotToken: ISyntaxToken; modifiers: ISyntaxToken[]; @@ -487,21 +659,30 @@ module TypeScript { typeAnnotation: TypeAnnotationSyntax; equalsValueClause: EqualsValueClauseSyntax; } + export interface ParameterConstructor { new (data: number, dotDotDotToken: ISyntaxToken, modifiers: ISyntaxToken[], identifier: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax): ParameterSyntax } + export interface EnumElementSyntax extends ISyntaxNode { propertyName: ISyntaxToken; equalsValueClause: EqualsValueClauseSyntax; } + export interface EnumElementConstructor { new (data: number, propertyName: ISyntaxToken, equalsValueClause: EqualsValueClauseSyntax): EnumElementSyntax } + export interface TypeAnnotationSyntax extends ISyntaxNode { colonToken: ISyntaxToken; type: ITypeSyntax; } + export interface TypeAnnotationConstructor { new (data: number, colonToken: ISyntaxToken, type: ITypeSyntax): TypeAnnotationSyntax } + export interface ExternalModuleReferenceSyntax extends ISyntaxNode, IModuleReferenceSyntax { requireKeyword: ISyntaxToken; openParenToken: ISyntaxToken; stringLiteral: ISyntaxToken; closeParenToken: ISyntaxToken; } + export interface ExternalModuleReferenceConstructor { new (data: number, requireKeyword: ISyntaxToken, openParenToken: ISyntaxToken, stringLiteral: ISyntaxToken, closeParenToken: ISyntaxToken): ExternalModuleReferenceSyntax } + export interface ModuleNameModuleReferenceSyntax extends ISyntaxNode, IModuleReferenceSyntax { moduleName: INameSyntax; } + export interface ModuleNameModuleReferenceConstructor { new (data: number, moduleName: INameSyntax): ModuleNameModuleReferenceSyntax } } \ No newline at end of file diff --git a/src/services/syntax/syntaxNodes.concrete.generated.ts b/src/services/syntax/syntaxNodes.concrete.generated.ts index 4dd7500f9f1..94a10967f51 100644 --- a/src/services/syntax/syntaxNodes.concrete.generated.ts +++ b/src/services/syntax/syntaxNodes.concrete.generated.ts @@ -1,1967 +1,884 @@ /// module TypeScript { - export class SourceUnitSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public syntaxTree: SyntaxTree = undefined; - public moduleElements: IModuleElementSyntax[]; - public endOfFileToken: ISyntaxToken; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, moduleElements: IModuleElementSyntax[], endOfFileToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.parent = undefined, - this.moduleElements = moduleElements, - this.endOfFileToken = endOfFileToken, - moduleElements.parent = this, - endOfFileToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.SourceUnit; - } - } - export class QualifiedNameSyntax implements ISyntaxNode, INameSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public left: INameSyntax; - public dotToken: ISyntaxToken; - public right: ISyntaxToken; - public _nameBrand: any; public _typeBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, left: INameSyntax, dotToken: ISyntaxToken, right: ISyntaxToken) { - if (data) { this.__data = data; } - this.left = left, - this.dotToken = dotToken, - this.right = right, - left.parent = this, - dotToken.parent = this, - right.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.QualifiedName; - } - } - export class ObjectTypeSyntax implements ISyntaxNode, ITypeSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public openBraceToken: ISyntaxToken; - public typeMembers: ISeparatedSyntaxList; - public closeBraceToken: ISyntaxToken; - public _typeBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, openBraceToken: ISyntaxToken, typeMembers: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.openBraceToken = openBraceToken, - this.typeMembers = typeMembers, - this.closeBraceToken = closeBraceToken, - openBraceToken.parent = this, - typeMembers.parent = this, - closeBraceToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ObjectType; - } - } - export class FunctionTypeSyntax implements ISyntaxNode, ITypeSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public typeParameterList: TypeParameterListSyntax; - public parameterList: ParameterListSyntax; - public equalsGreaterThanToken: ISyntaxToken; - public type: ITypeSyntax; - public _typeBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax) { - if (data) { this.__data = data; } - this.typeParameterList = typeParameterList, - this.parameterList = parameterList, - this.equalsGreaterThanToken = equalsGreaterThanToken, - this.type = type, - typeParameterList && (typeParameterList.parent = this), - parameterList.parent = this, - equalsGreaterThanToken.parent = this, - type.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.FunctionType; - } - } - export class ArrayTypeSyntax implements ISyntaxNode, ITypeSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public type: ITypeSyntax; - public openBracketToken: ISyntaxToken; - public closeBracketToken: ISyntaxToken; - public _typeBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, type: ITypeSyntax, openBracketToken: ISyntaxToken, closeBracketToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.type = type, - this.openBracketToken = openBracketToken, - this.closeBracketToken = closeBracketToken, - type.parent = this, - openBracketToken.parent = this, - closeBracketToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ArrayType; - } - } - export class ConstructorTypeSyntax implements ISyntaxNode, ITypeSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public newKeyword: ISyntaxToken; - public typeParameterList: TypeParameterListSyntax; - public parameterList: ParameterListSyntax; - public equalsGreaterThanToken: ISyntaxToken; - public type: ITypeSyntax; - public _typeBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, newKeyword: ISyntaxToken, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax) { - if (data) { this.__data = data; } - this.newKeyword = newKeyword, - this.typeParameterList = typeParameterList, - this.parameterList = parameterList, - this.equalsGreaterThanToken = equalsGreaterThanToken, - this.type = type, - newKeyword.parent = this, - typeParameterList && (typeParameterList.parent = this), - parameterList.parent = this, - equalsGreaterThanToken.parent = this, - type.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ConstructorType; - } - } - export class GenericTypeSyntax implements ISyntaxNode, ITypeSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public name: INameSyntax; - public typeArgumentList: TypeArgumentListSyntax; - public _typeBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, name: INameSyntax, typeArgumentList: TypeArgumentListSyntax) { - if (data) { this.__data = data; } - this.name = name, - this.typeArgumentList = typeArgumentList, - name.parent = this, - typeArgumentList.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.GenericType; - } - } - export class TypeQuerySyntax implements ISyntaxNode, ITypeSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public typeOfKeyword: ISyntaxToken; - public name: INameSyntax; - public _typeBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, typeOfKeyword: ISyntaxToken, name: INameSyntax) { - if (data) { this.__data = data; } - this.typeOfKeyword = typeOfKeyword, - this.name = name, - typeOfKeyword.parent = this, - name.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.TypeQuery; - } - } - export class TupleTypeSyntax implements ISyntaxNode, ITypeSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public openBracketToken: ISyntaxToken; - public types: ISeparatedSyntaxList; - public closeBracketToken: ISyntaxToken; - public _typeBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, openBracketToken: ISyntaxToken, types: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.openBracketToken = openBracketToken, - this.types = types, - this.closeBracketToken = closeBracketToken, - openBracketToken.parent = this, - types.parent = this, - closeBracketToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.TupleType; - } - } - export class UnionTypeSyntax implements ISyntaxNode, ITypeSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public left: ITypeSyntax; - public barToken: ISyntaxToken; - public right: ITypeSyntax; - public _typeBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax) { - if (data) { this.__data = data; } - this.left = left, - this.barToken = barToken, - this.right = right, - left.parent = this, - barToken.parent = this, - right.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.UnionType; - } - } - export class ParenthesizedTypeSyntax implements ISyntaxNode, ITypeSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public openParenToken: ISyntaxToken; - public type: ITypeSyntax; - public closeParenToken: ISyntaxToken; - public _typeBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.openParenToken = openParenToken, - this.type = type, - this.closeParenToken = closeParenToken, - openParenToken.parent = this, - type.parent = this, - closeParenToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ParenthesizedType; - } - } - export class InterfaceDeclarationSyntax implements ISyntaxNode, IModuleElementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public interfaceKeyword: ISyntaxToken; - public identifier: ISyntaxToken; - public typeParameterList: TypeParameterListSyntax; - public heritageClauses: HeritageClauseSyntax[]; - public body: ObjectTypeSyntax; - public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], interfaceKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], body: ObjectTypeSyntax) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.interfaceKeyword = interfaceKeyword, - this.identifier = identifier, - this.typeParameterList = typeParameterList, - this.heritageClauses = heritageClauses, - this.body = body, - modifiers.parent = this, - interfaceKeyword.parent = this, - identifier.parent = this, - typeParameterList && (typeParameterList.parent = this), - heritageClauses.parent = this, - body.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.InterfaceDeclaration; - } - } - export class FunctionDeclarationSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public functionKeyword: ISyntaxToken; - public identifier: ISyntaxToken; - public callSignature: CallSignatureSyntax; - public block: BlockSyntax; - public semicolonToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.functionKeyword = functionKeyword, - this.identifier = identifier, - this.callSignature = callSignature, - this.block = block, - this.semicolonToken = semicolonToken, - modifiers.parent = this, - functionKeyword.parent = this, - identifier.parent = this, - callSignature.parent = this, - block && (block.parent = this), - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.FunctionDeclaration; - } - } - export class ModuleDeclarationSyntax implements ISyntaxNode, IModuleElementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public moduleKeyword: ISyntaxToken; - public name: INameSyntax; - public stringLiteral: ISyntaxToken; - public openBraceToken: ISyntaxToken; - public moduleElements: IModuleElementSyntax[]; - public closeBraceToken: ISyntaxToken; - public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], moduleKeyword: ISyntaxToken, name: INameSyntax, stringLiteral: ISyntaxToken, openBraceToken: ISyntaxToken, moduleElements: IModuleElementSyntax[], closeBraceToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.moduleKeyword = moduleKeyword, - this.name = name, - this.stringLiteral = stringLiteral, - this.openBraceToken = openBraceToken, - this.moduleElements = moduleElements, - this.closeBraceToken = closeBraceToken, - modifiers.parent = this, - moduleKeyword.parent = this, - name && (name.parent = this), - stringLiteral && (stringLiteral.parent = this), - openBraceToken.parent = this, - moduleElements.parent = this, - closeBraceToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ModuleDeclaration; - } - } - export class ClassDeclarationSyntax implements ISyntaxNode, IModuleElementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public classKeyword: ISyntaxToken; - public identifier: ISyntaxToken; - public typeParameterList: TypeParameterListSyntax; - public heritageClauses: HeritageClauseSyntax[]; - public openBraceToken: ISyntaxToken; - public classElements: IClassElementSyntax[]; - public closeBraceToken: ISyntaxToken; - public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], classKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], openBraceToken: ISyntaxToken, classElements: IClassElementSyntax[], closeBraceToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.classKeyword = classKeyword, - this.identifier = identifier, - this.typeParameterList = typeParameterList, - this.heritageClauses = heritageClauses, - this.openBraceToken = openBraceToken, - this.classElements = classElements, - this.closeBraceToken = closeBraceToken, - modifiers.parent = this, - classKeyword.parent = this, - identifier.parent = this, - typeParameterList && (typeParameterList.parent = this), - heritageClauses.parent = this, - openBraceToken.parent = this, - classElements.parent = this, - closeBraceToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ClassDeclaration; - } - } - export class EnumDeclarationSyntax implements ISyntaxNode, IModuleElementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public enumKeyword: ISyntaxToken; - public identifier: ISyntaxToken; - public openBraceToken: ISyntaxToken; - public enumElements: ISeparatedSyntaxList; - public closeBraceToken: ISyntaxToken; - public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.enumKeyword = enumKeyword, - this.identifier = identifier, - this.openBraceToken = openBraceToken, - this.enumElements = enumElements, - this.closeBraceToken = closeBraceToken, - modifiers.parent = this, - enumKeyword.parent = this, - identifier.parent = this, - openBraceToken.parent = this, - enumElements.parent = this, - closeBraceToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.EnumDeclaration; - } - } - export class ImportDeclarationSyntax implements ISyntaxNode, IModuleElementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public importKeyword: ISyntaxToken; - public identifier: ISyntaxToken; - public equalsToken: ISyntaxToken; - public moduleReference: IModuleReferenceSyntax; - public semicolonToken: ISyntaxToken; - public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], importKeyword: ISyntaxToken, identifier: ISyntaxToken, equalsToken: ISyntaxToken, moduleReference: IModuleReferenceSyntax, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.importKeyword = importKeyword, - this.identifier = identifier, - this.equalsToken = equalsToken, - this.moduleReference = moduleReference, - this.semicolonToken = semicolonToken, - modifiers.parent = this, - importKeyword.parent = this, - identifier.parent = this, - equalsToken.parent = this, - moduleReference.parent = this, - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.ImportDeclaration; - } - } - export class ExportAssignmentSyntax implements ISyntaxNode, IModuleElementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public exportKeyword: ISyntaxToken; - public equalsToken: ISyntaxToken; - public identifier: ISyntaxToken; - public semicolonToken: ISyntaxToken; - public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, exportKeyword: ISyntaxToken, equalsToken: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.exportKeyword = exportKeyword, - this.equalsToken = equalsToken, - this.identifier = identifier, - this.semicolonToken = semicolonToken, - exportKeyword.parent = this, - equalsToken.parent = this, - identifier.parent = this, - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.ExportAssignment; - } - } - export class MemberFunctionDeclarationSyntax implements ISyntaxNode, IMemberDeclarationSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public propertyName: ISyntaxToken; - public callSignature: CallSignatureSyntax; - public block: BlockSyntax; - public semicolonToken: ISyntaxToken; - public _memberDeclarationBrand: any; public _classElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.propertyName = propertyName, - this.callSignature = callSignature, - this.block = block, - this.semicolonToken = semicolonToken, - modifiers.parent = this, - propertyName.parent = this, - callSignature.parent = this, - block && (block.parent = this), - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.MemberFunctionDeclaration; - } - } - export class MemberVariableDeclarationSyntax implements ISyntaxNode, IMemberDeclarationSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public variableDeclarator: VariableDeclaratorSyntax; - public semicolonToken: ISyntaxToken; - public _memberDeclarationBrand: any; public _classElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], variableDeclarator: VariableDeclaratorSyntax, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.variableDeclarator = variableDeclarator, - this.semicolonToken = semicolonToken, - modifiers.parent = this, - variableDeclarator.parent = this, - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.MemberVariableDeclaration; - } - } - export class ConstructorDeclarationSyntax implements ISyntaxNode, IClassElementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public constructorKeyword: ISyntaxToken; - public callSignature: CallSignatureSyntax; - public block: BlockSyntax; - public semicolonToken: ISyntaxToken; - public _classElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], constructorKeyword: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.constructorKeyword = constructorKeyword, - this.callSignature = callSignature, - this.block = block, - this.semicolonToken = semicolonToken, - modifiers.parent = this, - constructorKeyword.parent = this, - callSignature.parent = this, - block && (block.parent = this), - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.ConstructorDeclaration; - } - } - export class IndexMemberDeclarationSyntax implements ISyntaxNode, IClassElementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public indexSignature: IndexSignatureSyntax; - public semicolonToken: ISyntaxToken; - public _classElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], indexSignature: IndexSignatureSyntax, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.indexSignature = indexSignature, - this.semicolonToken = semicolonToken, - modifiers.parent = this, - indexSignature.parent = this, - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.IndexMemberDeclaration; - } - } - export class GetAccessorSyntax implements ISyntaxNode, IMemberDeclarationSyntax, IPropertyAssignmentSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public getKeyword: ISyntaxToken; - public propertyName: ISyntaxToken; - public callSignature: CallSignatureSyntax; - public block: BlockSyntax; - public _memberDeclarationBrand: any; public _propertyAssignmentBrand: any; public _classElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], getKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.getKeyword = getKeyword, - this.propertyName = propertyName, - this.callSignature = callSignature, - this.block = block, - modifiers.parent = this, - getKeyword.parent = this, - propertyName.parent = this, - callSignature.parent = this, - block.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.GetAccessor; - } - } - export class SetAccessorSyntax implements ISyntaxNode, IMemberDeclarationSyntax, IPropertyAssignmentSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public setKeyword: ISyntaxToken; - public propertyName: ISyntaxToken; - public callSignature: CallSignatureSyntax; - public block: BlockSyntax; - public _memberDeclarationBrand: any; public _propertyAssignmentBrand: any; public _classElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], setKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.setKeyword = setKeyword, - this.propertyName = propertyName, - this.callSignature = callSignature, - this.block = block, - modifiers.parent = this, - setKeyword.parent = this, - propertyName.parent = this, - callSignature.parent = this, - block.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.SetAccessor; - } - } - export class PropertySignatureSyntax implements ISyntaxNode, ITypeMemberSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public propertyName: ISyntaxToken; - public questionToken: ISyntaxToken; - public typeAnnotation: TypeAnnotationSyntax; - public _typeMemberBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) { - if (data) { this.__data = data; } - this.propertyName = propertyName, - this.questionToken = questionToken, - this.typeAnnotation = typeAnnotation, - propertyName.parent = this, - questionToken && (questionToken.parent = this), - typeAnnotation && (typeAnnotation.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.PropertySignature; - } - } - export class CallSignatureSyntax implements ISyntaxNode, ITypeMemberSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public typeParameterList: TypeParameterListSyntax; - public parameterList: ParameterListSyntax; - public typeAnnotation: TypeAnnotationSyntax; - public _typeMemberBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, typeAnnotation: TypeAnnotationSyntax) { - if (data) { this.__data = data; } - this.typeParameterList = typeParameterList, - this.parameterList = parameterList, - this.typeAnnotation = typeAnnotation, - typeParameterList && (typeParameterList.parent = this), - parameterList.parent = this, - typeAnnotation && (typeAnnotation.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.CallSignature; - } - } - export class ConstructSignatureSyntax implements ISyntaxNode, ITypeMemberSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public newKeyword: ISyntaxToken; - public callSignature: CallSignatureSyntax; - public _typeMemberBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, newKeyword: ISyntaxToken, callSignature: CallSignatureSyntax) { - if (data) { this.__data = data; } - this.newKeyword = newKeyword, - this.callSignature = callSignature, - newKeyword.parent = this, - callSignature.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ConstructSignature; - } - } - export class IndexSignatureSyntax implements ISyntaxNode, ITypeMemberSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public openBracketToken: ISyntaxToken; - public parameters: ISeparatedSyntaxList; - public closeBracketToken: ISyntaxToken; - public typeAnnotation: TypeAnnotationSyntax; - public _typeMemberBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, openBracketToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) { - if (data) { this.__data = data; } - this.openBracketToken = openBracketToken, - this.parameters = parameters, - this.closeBracketToken = closeBracketToken, - this.typeAnnotation = typeAnnotation, - openBracketToken.parent = this, - parameters.parent = this, - closeBracketToken.parent = this, - typeAnnotation && (typeAnnotation.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.IndexSignature; - } - } - export class MethodSignatureSyntax implements ISyntaxNode, ITypeMemberSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public propertyName: ISyntaxToken; - public questionToken: ISyntaxToken; - public callSignature: CallSignatureSyntax; - public _typeMemberBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, callSignature: CallSignatureSyntax) { - if (data) { this.__data = data; } - this.propertyName = propertyName, - this.questionToken = questionToken, - this.callSignature = callSignature, - propertyName.parent = this, - questionToken && (questionToken.parent = this), - callSignature.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.MethodSignature; - } - } - export class BlockSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public openBraceToken: ISyntaxToken; - public statements: IStatementSyntax[]; - public closeBraceToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, openBraceToken: ISyntaxToken, statements: IStatementSyntax[], closeBraceToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.openBraceToken = openBraceToken, - this.statements = statements, - this.closeBraceToken = closeBraceToken, - openBraceToken.parent = this, - statements.parent = this, - closeBraceToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.Block; - } - } - export class IfStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public ifKeyword: ISyntaxToken; - public openParenToken: ISyntaxToken; - public condition: IExpressionSyntax; - public closeParenToken: ISyntaxToken; - public statement: IStatementSyntax; - public elseClause: ElseClauseSyntax; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, ifKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax, elseClause: ElseClauseSyntax) { - if (data) { this.__data = data; } - this.ifKeyword = ifKeyword, - this.openParenToken = openParenToken, - this.condition = condition, - this.closeParenToken = closeParenToken, - this.statement = statement, - this.elseClause = elseClause, - ifKeyword.parent = this, - openParenToken.parent = this, - condition.parent = this, - closeParenToken.parent = this, - statement.parent = this, - elseClause && (elseClause.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.IfStatement; - } - } - export class VariableStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public modifiers: ISyntaxToken[]; - public variableDeclaration: VariableDeclarationSyntax; - public semicolonToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, modifiers: ISyntaxToken[], variableDeclaration: VariableDeclarationSyntax, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.modifiers = modifiers, - this.variableDeclaration = variableDeclaration, - this.semicolonToken = semicolonToken, - modifiers.parent = this, - variableDeclaration.parent = this, - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.VariableStatement; - } - } - export class ExpressionStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public expression: IExpressionSyntax; - public semicolonToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.expression = expression, - this.semicolonToken = semicolonToken, - expression.parent = this, - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.ExpressionStatement; - } - } - export class ReturnStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public returnKeyword: ISyntaxToken; - public expression: IExpressionSyntax; - public semicolonToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, returnKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.returnKeyword = returnKeyword, - this.expression = expression, - this.semicolonToken = semicolonToken, - returnKeyword.parent = this, - expression && (expression.parent = this), - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.ReturnStatement; - } - } - export class SwitchStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public switchKeyword: ISyntaxToken; - public openParenToken: ISyntaxToken; - public expression: IExpressionSyntax; - public closeParenToken: ISyntaxToken; - public openBraceToken: ISyntaxToken; - public switchClauses: ISwitchClauseSyntax[]; - public closeBraceToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, switchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, openBraceToken: ISyntaxToken, switchClauses: ISwitchClauseSyntax[], closeBraceToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.switchKeyword = switchKeyword, - this.openParenToken = openParenToken, - this.expression = expression, - this.closeParenToken = closeParenToken, - this.openBraceToken = openBraceToken, - this.switchClauses = switchClauses, - this.closeBraceToken = closeBraceToken, - switchKeyword.parent = this, - openParenToken.parent = this, - expression.parent = this, - closeParenToken.parent = this, - openBraceToken.parent = this, - switchClauses.parent = this, - closeBraceToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.SwitchStatement; - } - } - export class BreakStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public breakKeyword: ISyntaxToken; - public identifier: ISyntaxToken; - public semicolonToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, breakKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.breakKeyword = breakKeyword, - this.identifier = identifier, - this.semicolonToken = semicolonToken, - breakKeyword.parent = this, - identifier && (identifier.parent = this), - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.BreakStatement; - } - } - export class ContinueStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public continueKeyword: ISyntaxToken; - public identifier: ISyntaxToken; - public semicolonToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, continueKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.continueKeyword = continueKeyword, - this.identifier = identifier, - this.semicolonToken = semicolonToken, - continueKeyword.parent = this, - identifier && (identifier.parent = this), - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.ContinueStatement; - } - } - export class ForStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public forKeyword: ISyntaxToken; - public openParenToken: ISyntaxToken; - public variableDeclaration: VariableDeclarationSyntax; - public initializer: IExpressionSyntax; - public firstSemicolonToken: ISyntaxToken; - public condition: IExpressionSyntax; - public secondSemicolonToken: ISyntaxToken; - public incrementor: IExpressionSyntax; - public closeParenToken: ISyntaxToken; - public statement: IStatementSyntax; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, initializer: IExpressionSyntax, firstSemicolonToken: ISyntaxToken, condition: IExpressionSyntax, secondSemicolonToken: ISyntaxToken, incrementor: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) { - if (data) { this.__data = data; } - this.forKeyword = forKeyword, - this.openParenToken = openParenToken, - this.variableDeclaration = variableDeclaration, - this.initializer = initializer, - this.firstSemicolonToken = firstSemicolonToken, - this.condition = condition, - this.secondSemicolonToken = secondSemicolonToken, - this.incrementor = incrementor, - this.closeParenToken = closeParenToken, - this.statement = statement, - forKeyword.parent = this, - openParenToken.parent = this, - variableDeclaration && (variableDeclaration.parent = this), - initializer && (initializer.parent = this), - firstSemicolonToken.parent = this, - condition && (condition.parent = this), - secondSemicolonToken.parent = this, - incrementor && (incrementor.parent = this), - closeParenToken.parent = this, - statement.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ForStatement; - } - } - export class ForInStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public forKeyword: ISyntaxToken; - public openParenToken: ISyntaxToken; - public variableDeclaration: VariableDeclarationSyntax; - public left: IExpressionSyntax; - public inKeyword: ISyntaxToken; - public expression: IExpressionSyntax; - public closeParenToken: ISyntaxToken; - public statement: IStatementSyntax; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, left: IExpressionSyntax, inKeyword: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) { - if (data) { this.__data = data; } - this.forKeyword = forKeyword, - this.openParenToken = openParenToken, - this.variableDeclaration = variableDeclaration, - this.left = left, - this.inKeyword = inKeyword, - this.expression = expression, - this.closeParenToken = closeParenToken, - this.statement = statement, - forKeyword.parent = this, - openParenToken.parent = this, - variableDeclaration && (variableDeclaration.parent = this), - left && (left.parent = this), - inKeyword.parent = this, - expression.parent = this, - closeParenToken.parent = this, - statement.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ForInStatement; - } - } - export class EmptyStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public semicolonToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.semicolonToken = semicolonToken, - semicolonToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.EmptyStatement; - } - } - export class ThrowStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public throwKeyword: ISyntaxToken; - public expression: IExpressionSyntax; - public semicolonToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, throwKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.throwKeyword = throwKeyword, - this.expression = expression, - this.semicolonToken = semicolonToken, - throwKeyword.parent = this, - expression.parent = this, - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.ThrowStatement; - } - } - export class WhileStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public whileKeyword: ISyntaxToken; - public openParenToken: ISyntaxToken; - public condition: IExpressionSyntax; - public closeParenToken: ISyntaxToken; - public statement: IStatementSyntax; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) { - if (data) { this.__data = data; } - this.whileKeyword = whileKeyword, - this.openParenToken = openParenToken, - this.condition = condition, - this.closeParenToken = closeParenToken, - this.statement = statement, - whileKeyword.parent = this, - openParenToken.parent = this, - condition.parent = this, - closeParenToken.parent = this, - statement.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.WhileStatement; - } - } - export class TryStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public tryKeyword: ISyntaxToken; - public block: BlockSyntax; - public catchClause: CatchClauseSyntax; - public finallyClause: FinallyClauseSyntax; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, tryKeyword: ISyntaxToken, block: BlockSyntax, catchClause: CatchClauseSyntax, finallyClause: FinallyClauseSyntax) { - if (data) { this.__data = data; } - this.tryKeyword = tryKeyword, - this.block = block, - this.catchClause = catchClause, - this.finallyClause = finallyClause, - tryKeyword.parent = this, - block.parent = this, - catchClause && (catchClause.parent = this), - finallyClause && (finallyClause.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.TryStatement; - } - } - export class LabeledStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public identifier: ISyntaxToken; - public colonToken: ISyntaxToken; - public statement: IStatementSyntax; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, identifier: ISyntaxToken, colonToken: ISyntaxToken, statement: IStatementSyntax) { - if (data) { this.__data = data; } - this.identifier = identifier, - this.colonToken = colonToken, - this.statement = statement, - identifier.parent = this, - colonToken.parent = this, - statement.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.LabeledStatement; - } - } - export class DoStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public doKeyword: ISyntaxToken; - public statement: IStatementSyntax; - public whileKeyword: ISyntaxToken; - public openParenToken: ISyntaxToken; - public condition: IExpressionSyntax; - public closeParenToken: ISyntaxToken; - public semicolonToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, doKeyword: ISyntaxToken, statement: IStatementSyntax, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.doKeyword = doKeyword, - this.statement = statement, - this.whileKeyword = whileKeyword, - this.openParenToken = openParenToken, - this.condition = condition, - this.closeParenToken = closeParenToken, - this.semicolonToken = semicolonToken, - doKeyword.parent = this, - statement.parent = this, - whileKeyword.parent = this, - openParenToken.parent = this, - condition.parent = this, - closeParenToken.parent = this, - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.DoStatement; - } - } - export class DebuggerStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public debuggerKeyword: ISyntaxToken; - public semicolonToken: ISyntaxToken; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, debuggerKeyword: ISyntaxToken, semicolonToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.debuggerKeyword = debuggerKeyword, - this.semicolonToken = semicolonToken, - debuggerKeyword.parent = this, - semicolonToken && (semicolonToken.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.DebuggerStatement; - } - } - export class WithStatementSyntax implements ISyntaxNode, IStatementSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public withKeyword: ISyntaxToken; - public openParenToken: ISyntaxToken; - public condition: IExpressionSyntax; - public closeParenToken: ISyntaxToken; - public statement: IStatementSyntax; - public _statementBrand: any; public _moduleElementBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, withKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) { - if (data) { this.__data = data; } - this.withKeyword = withKeyword, - this.openParenToken = openParenToken, - this.condition = condition, - this.closeParenToken = closeParenToken, - this.statement = statement, - withKeyword.parent = this, - openParenToken.parent = this, - condition.parent = this, - closeParenToken.parent = this, - statement.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.WithStatement; - } - } - export class PrefixUnaryExpressionSyntax implements ISyntaxNode, IUnaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public operatorToken: ISyntaxToken; - public operand: IUnaryExpressionSyntax; - public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, operatorToken: ISyntaxToken, operand: IUnaryExpressionSyntax) { - if (data) { this.__data = data; } - this.operatorToken = operatorToken, - this.operand = operand, - operatorToken.parent = this, - operand.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.PrefixUnaryExpression; - } - } - export class DeleteExpressionSyntax implements ISyntaxNode, IUnaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public deleteKeyword: ISyntaxToken; - public expression: IUnaryExpressionSyntax; - public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, deleteKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) { - if (data) { this.__data = data; } - this.deleteKeyword = deleteKeyword, - this.expression = expression, - deleteKeyword.parent = this, - expression.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.DeleteExpression; - } - } - export class TypeOfExpressionSyntax implements ISyntaxNode, IUnaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public typeOfKeyword: ISyntaxToken; - public expression: IUnaryExpressionSyntax; - public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, typeOfKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) { - if (data) { this.__data = data; } - this.typeOfKeyword = typeOfKeyword, - this.expression = expression, - typeOfKeyword.parent = this, - expression.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.TypeOfExpression; - } - } - export class VoidExpressionSyntax implements ISyntaxNode, IUnaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public voidKeyword: ISyntaxToken; - public expression: IUnaryExpressionSyntax; - public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, voidKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) { - if (data) { this.__data = data; } - this.voidKeyword = voidKeyword, - this.expression = expression, - voidKeyword.parent = this, - expression.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.VoidExpression; - } - } - export class ConditionalExpressionSyntax implements ISyntaxNode, IExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public condition: IExpressionSyntax; - public questionToken: ISyntaxToken; - public whenTrue: IExpressionSyntax; - public colonToken: ISyntaxToken; - public whenFalse: IExpressionSyntax; - public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, condition: IExpressionSyntax, questionToken: ISyntaxToken, whenTrue: IExpressionSyntax, colonToken: ISyntaxToken, whenFalse: IExpressionSyntax) { - if (data) { this.__data = data; } - this.condition = condition, - this.questionToken = questionToken, - this.whenTrue = whenTrue, - this.colonToken = colonToken, - this.whenFalse = whenFalse, - condition.parent = this, - questionToken.parent = this, - whenTrue.parent = this, - colonToken.parent = this, - whenFalse.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ConditionalExpression; - } - } - export class BinaryExpressionSyntax implements ISyntaxNode, IExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public left: IExpressionSyntax; - public operatorToken: ISyntaxToken; - public right: IExpressionSyntax; - public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, left: IExpressionSyntax, operatorToken: ISyntaxToken, right: IExpressionSyntax) { - if (data) { this.__data = data; } - this.left = left, - this.operatorToken = operatorToken, - this.right = right, - left.parent = this, - operatorToken.parent = this, - right.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.BinaryExpression; - } - } - export class PostfixUnaryExpressionSyntax implements ISyntaxNode, IPostfixExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public operand: ILeftHandSideExpressionSyntax; - public operatorToken: ISyntaxToken; - public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, operand: ILeftHandSideExpressionSyntax, operatorToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.operand = operand, - this.operatorToken = operatorToken, - operand.parent = this, - operatorToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.PostfixUnaryExpression; - } - } - export class MemberAccessExpressionSyntax implements ISyntaxNode, IMemberExpressionSyntax, ICallExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public expression: ILeftHandSideExpressionSyntax; - public dotToken: ISyntaxToken; - public name: ISyntaxToken; - public _memberExpressionBrand: any; public _callExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, expression: ILeftHandSideExpressionSyntax, dotToken: ISyntaxToken, name: ISyntaxToken) { - if (data) { this.__data = data; } - this.expression = expression, - this.dotToken = dotToken, - this.name = name, - expression.parent = this, - dotToken.parent = this, - name.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.MemberAccessExpression; - } - } - export class InvocationExpressionSyntax implements ISyntaxNode, ICallExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public expression: ILeftHandSideExpressionSyntax; - public argumentList: ArgumentListSyntax; - public _callExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, expression: ILeftHandSideExpressionSyntax, argumentList: ArgumentListSyntax) { - if (data) { this.__data = data; } - this.expression = expression, - this.argumentList = argumentList, - expression.parent = this, - argumentList.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.InvocationExpression; - } - } - export class ArrayLiteralExpressionSyntax implements ISyntaxNode, IPrimaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public openBracketToken: ISyntaxToken; - public expressions: ISeparatedSyntaxList; - public closeBracketToken: ISyntaxToken; - public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, openBracketToken: ISyntaxToken, expressions: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.openBracketToken = openBracketToken, - this.expressions = expressions, - this.closeBracketToken = closeBracketToken, - openBracketToken.parent = this, - expressions.parent = this, - closeBracketToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ArrayLiteralExpression; - } - } - export class ObjectLiteralExpressionSyntax implements ISyntaxNode, IPrimaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public openBraceToken: ISyntaxToken; - public propertyAssignments: ISeparatedSyntaxList; - public closeBraceToken: ISyntaxToken; - public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, openBraceToken: ISyntaxToken, propertyAssignments: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.openBraceToken = openBraceToken, - this.propertyAssignments = propertyAssignments, - this.closeBraceToken = closeBraceToken, - openBraceToken.parent = this, - propertyAssignments.parent = this, - closeBraceToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ObjectLiteralExpression; - } - } - export class ObjectCreationExpressionSyntax implements ISyntaxNode, IPrimaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public newKeyword: ISyntaxToken; - public expression: IMemberExpressionSyntax; - public argumentList: ArgumentListSyntax; - public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, newKeyword: ISyntaxToken, expression: IMemberExpressionSyntax, argumentList: ArgumentListSyntax) { - if (data) { this.__data = data; } - this.newKeyword = newKeyword, - this.expression = expression, - this.argumentList = argumentList, - newKeyword.parent = this, - expression.parent = this, - argumentList && (argumentList.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.ObjectCreationExpression; - } - } - export class ParenthesizedExpressionSyntax implements ISyntaxNode, IPrimaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public openParenToken: ISyntaxToken; - public expression: IExpressionSyntax; - public closeParenToken: ISyntaxToken; - public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.openParenToken = openParenToken, - this.expression = expression, - this.closeParenToken = closeParenToken, - openParenToken.parent = this, - expression.parent = this, - closeParenToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ParenthesizedExpression; - } - } - export class ParenthesizedArrowFunctionExpressionSyntax implements ISyntaxNode, IUnaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public callSignature: CallSignatureSyntax; - public equalsGreaterThanToken: ISyntaxToken; - public block: BlockSyntax; - public expression: IExpressionSyntax; - public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, callSignature: CallSignatureSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax) { - if (data) { this.__data = data; } - this.callSignature = callSignature, - this.equalsGreaterThanToken = equalsGreaterThanToken, - this.block = block, - this.expression = expression, - callSignature.parent = this, - equalsGreaterThanToken.parent = this, - block && (block.parent = this), - expression && (expression.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.ParenthesizedArrowFunctionExpression; - } - } - export class SimpleArrowFunctionExpressionSyntax implements ISyntaxNode, IUnaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public parameter: ParameterSyntax; - public equalsGreaterThanToken: ISyntaxToken; - public block: BlockSyntax; - public expression: IExpressionSyntax; - public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, parameter: ParameterSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax) { - if (data) { this.__data = data; } - this.parameter = parameter, - this.equalsGreaterThanToken = equalsGreaterThanToken, - this.block = block, - this.expression = expression, - parameter.parent = this, - equalsGreaterThanToken.parent = this, - block && (block.parent = this), - expression && (expression.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.SimpleArrowFunctionExpression; - } - } - export class CastExpressionSyntax implements ISyntaxNode, IUnaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public lessThanToken: ISyntaxToken; - public type: ITypeSyntax; - public greaterThanToken: ISyntaxToken; - public expression: IUnaryExpressionSyntax; - public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, lessThanToken: ISyntaxToken, type: ITypeSyntax, greaterThanToken: ISyntaxToken, expression: IUnaryExpressionSyntax) { - if (data) { this.__data = data; } - this.lessThanToken = lessThanToken, - this.type = type, - this.greaterThanToken = greaterThanToken, - this.expression = expression, - lessThanToken.parent = this, - type.parent = this, - greaterThanToken.parent = this, - expression.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.CastExpression; - } - } - export class ElementAccessExpressionSyntax implements ISyntaxNode, IMemberExpressionSyntax, ICallExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public expression: ILeftHandSideExpressionSyntax; - public openBracketToken: ISyntaxToken; - public argumentExpression: IExpressionSyntax; - public closeBracketToken: ISyntaxToken; - public _memberExpressionBrand: any; public _callExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, expression: ILeftHandSideExpressionSyntax, openBracketToken: ISyntaxToken, argumentExpression: IExpressionSyntax, closeBracketToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.expression = expression, - this.openBracketToken = openBracketToken, - this.argumentExpression = argumentExpression, - this.closeBracketToken = closeBracketToken, - expression.parent = this, - openBracketToken.parent = this, - argumentExpression.parent = this, - closeBracketToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ElementAccessExpression; - } - } - export class FunctionExpressionSyntax implements ISyntaxNode, IPrimaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public functionKeyword: ISyntaxToken; - public identifier: ISyntaxToken; - public callSignature: CallSignatureSyntax; - public block: BlockSyntax; - public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) { - if (data) { this.__data = data; } - this.functionKeyword = functionKeyword, - this.identifier = identifier, - this.callSignature = callSignature, - this.block = block, - functionKeyword.parent = this, - identifier && (identifier.parent = this), - callSignature.parent = this, - block.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.FunctionExpression; - } - } - export class OmittedExpressionSyntax implements ISyntaxNode, IExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number) { - if (data) { this.__data = data; } - } - - public kind(): SyntaxKind { - return SyntaxKind.OmittedExpression; - } - } - export class TemplateExpressionSyntax implements ISyntaxNode, IPrimaryExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public templateStartToken: ISyntaxToken; - public templateClauses: TemplateClauseSyntax[]; - public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, templateStartToken: ISyntaxToken, templateClauses: TemplateClauseSyntax[]) { - if (data) { this.__data = data; } - this.templateStartToken = templateStartToken, - this.templateClauses = templateClauses, - templateStartToken.parent = this, - templateClauses.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.TemplateExpression; - } - } - export class TemplateAccessExpressionSyntax implements ISyntaxNode, IMemberExpressionSyntax, ICallExpressionSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public expression: ILeftHandSideExpressionSyntax; - public templateExpression: IPrimaryExpressionSyntax; - public _memberExpressionBrand: any; public _callExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, expression: ILeftHandSideExpressionSyntax, templateExpression: IPrimaryExpressionSyntax) { - if (data) { this.__data = data; } - this.expression = expression, - this.templateExpression = templateExpression, - expression.parent = this, - templateExpression.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.TemplateAccessExpression; - } - } - export class VariableDeclarationSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public varKeyword: ISyntaxToken; - public variableDeclarators: ISeparatedSyntaxList; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, varKeyword: ISyntaxToken, variableDeclarators: ISeparatedSyntaxList) { - if (data) { this.__data = data; } - this.varKeyword = varKeyword, - this.variableDeclarators = variableDeclarators, - varKeyword.parent = this, - variableDeclarators.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.VariableDeclaration; - } - } - export class VariableDeclaratorSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public propertyName: ISyntaxToken; - public typeAnnotation: TypeAnnotationSyntax; - public equalsValueClause: EqualsValueClauseSyntax; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, propertyName: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax) { - if (data) { this.__data = data; } - this.propertyName = propertyName, - this.typeAnnotation = typeAnnotation, - this.equalsValueClause = equalsValueClause, - propertyName.parent = this, - typeAnnotation && (typeAnnotation.parent = this), - equalsValueClause && (equalsValueClause.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.VariableDeclarator; - } - } - export class ArgumentListSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public typeArgumentList: TypeArgumentListSyntax; - public openParenToken: ISyntaxToken; - public arguments: ISeparatedSyntaxList; - public closeParenToken: ISyntaxToken; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, _arguments: ISeparatedSyntaxList, closeParenToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.typeArgumentList = typeArgumentList, - this.openParenToken = openParenToken, - this.arguments = _arguments, - this.closeParenToken = closeParenToken, - typeArgumentList && (typeArgumentList.parent = this), - openParenToken.parent = this, - _arguments.parent = this, - closeParenToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ArgumentList; - } - } - export class ParameterListSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public openParenToken: ISyntaxToken; - public parameters: ISeparatedSyntaxList; - public closeParenToken: ISyntaxToken; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, openParenToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeParenToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.openParenToken = openParenToken, - this.parameters = parameters, - this.closeParenToken = closeParenToken, - openParenToken.parent = this, - parameters.parent = this, - closeParenToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ParameterList; - } - } - export class TypeArgumentListSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public lessThanToken: ISyntaxToken; - public typeArguments: ISeparatedSyntaxList; - public greaterThanToken: ISyntaxToken; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, lessThanToken: ISyntaxToken, typeArguments: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.lessThanToken = lessThanToken, - this.typeArguments = typeArguments, - this.greaterThanToken = greaterThanToken, - lessThanToken.parent = this, - typeArguments.parent = this, - greaterThanToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.TypeArgumentList; - } - } - export class TypeParameterListSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public lessThanToken: ISyntaxToken; - public typeParameters: ISeparatedSyntaxList; - public greaterThanToken: ISyntaxToken; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, lessThanToken: ISyntaxToken, typeParameters: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.lessThanToken = lessThanToken, - this.typeParameters = typeParameters, - this.greaterThanToken = greaterThanToken, - lessThanToken.parent = this, - typeParameters.parent = this, - greaterThanToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.TypeParameterList; - } - } - export class HeritageClauseSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public extendsOrImplementsKeyword: ISyntaxToken; - public typeNames: ISeparatedSyntaxList; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: ISeparatedSyntaxList) { - if (data) { this.__data = data; } - this.extendsOrImplementsKeyword = extendsOrImplementsKeyword, - this.typeNames = typeNames, - extendsOrImplementsKeyword.parent = this, - typeNames.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.HeritageClause; - } - } - export class EqualsValueClauseSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public equalsToken: ISyntaxToken; - public value: IExpressionSyntax; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, equalsToken: ISyntaxToken, value: IExpressionSyntax) { - if (data) { this.__data = data; } - this.equalsToken = equalsToken, - this.value = value, - equalsToken.parent = this, - value.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.EqualsValueClause; - } - } - export class CaseSwitchClauseSyntax implements ISyntaxNode, ISwitchClauseSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public caseKeyword: ISyntaxToken; - public expression: IExpressionSyntax; - public colonToken: ISyntaxToken; - public statements: IStatementSyntax[]; - public _switchClauseBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, caseKeyword: ISyntaxToken, expression: IExpressionSyntax, colonToken: ISyntaxToken, statements: IStatementSyntax[]) { - if (data) { this.__data = data; } - this.caseKeyword = caseKeyword, - this.expression = expression, - this.colonToken = colonToken, - this.statements = statements, - caseKeyword.parent = this, - expression.parent = this, - colonToken.parent = this, - statements.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.CaseSwitchClause; - } - } - export class DefaultSwitchClauseSyntax implements ISyntaxNode, ISwitchClauseSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public defaultKeyword: ISyntaxToken; - public colonToken: ISyntaxToken; - public statements: IStatementSyntax[]; - public _switchClauseBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, defaultKeyword: ISyntaxToken, colonToken: ISyntaxToken, statements: IStatementSyntax[]) { - if (data) { this.__data = data; } - this.defaultKeyword = defaultKeyword, - this.colonToken = colonToken, - this.statements = statements, - defaultKeyword.parent = this, - colonToken.parent = this, - statements.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.DefaultSwitchClause; - } - } - export class ElseClauseSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public elseKeyword: ISyntaxToken; - public statement: IStatementSyntax; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, elseKeyword: ISyntaxToken, statement: IStatementSyntax) { - if (data) { this.__data = data; } - this.elseKeyword = elseKeyword, - this.statement = statement, - elseKeyword.parent = this, - statement.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ElseClause; - } - } - export class CatchClauseSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public catchKeyword: ISyntaxToken; - public openParenToken: ISyntaxToken; - public identifier: ISyntaxToken; - public typeAnnotation: TypeAnnotationSyntax; - public closeParenToken: ISyntaxToken; - public block: BlockSyntax; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, catchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, identifier: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, closeParenToken: ISyntaxToken, block: BlockSyntax) { - if (data) { this.__data = data; } - this.catchKeyword = catchKeyword, - this.openParenToken = openParenToken, - this.identifier = identifier, - this.typeAnnotation = typeAnnotation, - this.closeParenToken = closeParenToken, - this.block = block, - catchKeyword.parent = this, - openParenToken.parent = this, - identifier.parent = this, - typeAnnotation && (typeAnnotation.parent = this), - closeParenToken.parent = this, - block.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.CatchClause; - } - } - export class FinallyClauseSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public finallyKeyword: ISyntaxToken; - public block: BlockSyntax; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, finallyKeyword: ISyntaxToken, block: BlockSyntax) { - if (data) { this.__data = data; } - this.finallyKeyword = finallyKeyword, - this.block = block, - finallyKeyword.parent = this, - block.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.FinallyClause; - } - } - export class TemplateClauseSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public expression: IExpressionSyntax; - public templateMiddleOrEndToken: ISyntaxToken; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, expression: IExpressionSyntax, templateMiddleOrEndToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.expression = expression, - this.templateMiddleOrEndToken = templateMiddleOrEndToken, - expression.parent = this, - templateMiddleOrEndToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.TemplateClause; - } - } - export class TypeParameterSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public identifier: ISyntaxToken; - public constraint: ConstraintSyntax; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, identifier: ISyntaxToken, constraint: ConstraintSyntax) { - if (data) { this.__data = data; } - this.identifier = identifier, - this.constraint = constraint, - identifier.parent = this, - constraint && (constraint.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.TypeParameter; - } - } - export class ConstraintSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public extendsKeyword: ISyntaxToken; - public typeOrExpression: ISyntaxNodeOrToken; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, extendsKeyword: ISyntaxToken, typeOrExpression: ISyntaxNodeOrToken) { - if (data) { this.__data = data; } - this.extendsKeyword = extendsKeyword, - this.typeOrExpression = typeOrExpression, - extendsKeyword.parent = this, - typeOrExpression.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.Constraint; - } - } - export class SimplePropertyAssignmentSyntax implements ISyntaxNode, IPropertyAssignmentSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public propertyName: ISyntaxToken; - public colonToken: ISyntaxToken; - public expression: IExpressionSyntax; - public _propertyAssignmentBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, propertyName: ISyntaxToken, colonToken: ISyntaxToken, expression: IExpressionSyntax) { - if (data) { this.__data = data; } - this.propertyName = propertyName, - this.colonToken = colonToken, - this.expression = expression, - propertyName.parent = this, - colonToken.parent = this, - expression.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.SimplePropertyAssignment; - } - } - export class FunctionPropertyAssignmentSyntax implements ISyntaxNode, IPropertyAssignmentSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public propertyName: ISyntaxToken; - public callSignature: CallSignatureSyntax; - public block: BlockSyntax; - public _propertyAssignmentBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) { - if (data) { this.__data = data; } - this.propertyName = propertyName, - this.callSignature = callSignature, - this.block = block, - propertyName.parent = this, - callSignature.parent = this, - block.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.FunctionPropertyAssignment; - } - } - export class ParameterSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public dotDotDotToken: ISyntaxToken; - public modifiers: ISyntaxToken[]; - public identifier: ISyntaxToken; - public questionToken: ISyntaxToken; - public typeAnnotation: TypeAnnotationSyntax; - public equalsValueClause: EqualsValueClauseSyntax; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, dotDotDotToken: ISyntaxToken, modifiers: ISyntaxToken[], identifier: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax) { - if (data) { this.__data = data; } - this.dotDotDotToken = dotDotDotToken, - this.modifiers = modifiers, - this.identifier = identifier, - this.questionToken = questionToken, - this.typeAnnotation = typeAnnotation, - this.equalsValueClause = equalsValueClause, - dotDotDotToken && (dotDotDotToken.parent = this), - modifiers.parent = this, - identifier.parent = this, - questionToken && (questionToken.parent = this), - typeAnnotation && (typeAnnotation.parent = this), - equalsValueClause && (equalsValueClause.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.Parameter; - } - } - export class EnumElementSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public propertyName: ISyntaxToken; - public equalsValueClause: EqualsValueClauseSyntax; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, propertyName: ISyntaxToken, equalsValueClause: EqualsValueClauseSyntax) { - if (data) { this.__data = data; } - this.propertyName = propertyName, - this.equalsValueClause = equalsValueClause, - propertyName.parent = this, - equalsValueClause && (equalsValueClause.parent = this); - } - - public kind(): SyntaxKind { - return SyntaxKind.EnumElement; - } - } - export class TypeAnnotationSyntax implements ISyntaxNode { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public colonToken: ISyntaxToken; - public type: ITypeSyntax; - public _syntaxNodeOrTokenBrand: any; - constructor(data: number, colonToken: ISyntaxToken, type: ITypeSyntax) { - if (data) { this.__data = data; } - this.colonToken = colonToken, - this.type = type, - colonToken.parent = this, - type.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.TypeAnnotation; - } - } - export class ExternalModuleReferenceSyntax implements ISyntaxNode, IModuleReferenceSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public requireKeyword: ISyntaxToken; - public openParenToken: ISyntaxToken; - public stringLiteral: ISyntaxToken; - public closeParenToken: ISyntaxToken; - public _moduleReferenceBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, requireKeyword: ISyntaxToken, openParenToken: ISyntaxToken, stringLiteral: ISyntaxToken, closeParenToken: ISyntaxToken) { - if (data) { this.__data = data; } - this.requireKeyword = requireKeyword, - this.openParenToken = openParenToken, - this.stringLiteral = stringLiteral, - this.closeParenToken = closeParenToken, - requireKeyword.parent = this, - openParenToken.parent = this, - stringLiteral.parent = this, - closeParenToken.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ExternalModuleReference; - } - } - export class ModuleNameModuleReferenceSyntax implements ISyntaxNode, IModuleReferenceSyntax { - public __data: number; public __cachedTokens: ISyntaxToken[]; public parent: ISyntaxElement; - public moduleName: INameSyntax; - public _moduleReferenceBrand: any; public _syntaxNodeOrTokenBrand: any; - constructor(data: number, moduleName: INameSyntax) { - if (data) { this.__data = data; } - this.moduleName = moduleName, - moduleName.parent = this; - } - - public kind(): SyntaxKind { - return SyntaxKind.ModuleNameModuleReference; - } - } + function finishNode(node: ISyntaxNode, data: number) { + for (var name in node) { + if (node.hasOwnProperty(name)) { + var child: ISyntaxElement = (node)[name]; + if (child) { + child.parent = node; + } + } + } + + if (data) { + node.__data = data; + } + } + + function sourceUnitSyntax(data: number, moduleElements: IModuleElementSyntax[], endOfFileToken: ISyntaxToken) { + this.moduleElements = moduleElements; + this.endOfFileToken = endOfFileToken; + finishNode(this, data); + } + sourceUnitSyntax.prototype.kind = function() { return SyntaxKind.SourceUnit; } + export var SourceUnitSyntax: SourceUnitConstructor = sourceUnitSyntax; + + function qualifiedNameSyntax(data: number, left: INameSyntax, dotToken: ISyntaxToken, right: ISyntaxToken) { + this.left = left; + this.dotToken = dotToken; + this.right = right; + finishNode(this, data); + } + qualifiedNameSyntax.prototype.kind = function() { return SyntaxKind.QualifiedName; } + export var QualifiedNameSyntax: QualifiedNameConstructor = qualifiedNameSyntax; + + function objectTypeSyntax(data: number, openBraceToken: ISyntaxToken, typeMembers: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken) { + this.openBraceToken = openBraceToken; + this.typeMembers = typeMembers; + this.closeBraceToken = closeBraceToken; + finishNode(this, data); + } + objectTypeSyntax.prototype.kind = function() { return SyntaxKind.ObjectType; } + export var ObjectTypeSyntax: ObjectTypeConstructor = objectTypeSyntax; + + function functionTypeSyntax(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax) { + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.type = type; + finishNode(this, data); + } + functionTypeSyntax.prototype.kind = function() { return SyntaxKind.FunctionType; } + export var FunctionTypeSyntax: FunctionTypeConstructor = functionTypeSyntax; + + function arrayTypeSyntax(data: number, type: ITypeSyntax, openBracketToken: ISyntaxToken, closeBracketToken: ISyntaxToken) { + this.type = type; + this.openBracketToken = openBracketToken; + this.closeBracketToken = closeBracketToken; + finishNode(this, data); + } + arrayTypeSyntax.prototype.kind = function() { return SyntaxKind.ArrayType; } + export var ArrayTypeSyntax: ArrayTypeConstructor = arrayTypeSyntax; + + function constructorTypeSyntax(data: number, newKeyword: ISyntaxToken, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax) { + this.newKeyword = newKeyword; + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.type = type; + finishNode(this, data); + } + constructorTypeSyntax.prototype.kind = function() { return SyntaxKind.ConstructorType; } + export var ConstructorTypeSyntax: ConstructorTypeConstructor = constructorTypeSyntax; + + function genericTypeSyntax(data: number, name: INameSyntax, typeArgumentList: TypeArgumentListSyntax) { + this.name = name; + this.typeArgumentList = typeArgumentList; + finishNode(this, data); + } + genericTypeSyntax.prototype.kind = function() { return SyntaxKind.GenericType; } + export var GenericTypeSyntax: GenericTypeConstructor = genericTypeSyntax; + + function typeQuerySyntax(data: number, typeOfKeyword: ISyntaxToken, name: INameSyntax) { + this.typeOfKeyword = typeOfKeyword; + this.name = name; + finishNode(this, data); + } + typeQuerySyntax.prototype.kind = function() { return SyntaxKind.TypeQuery; } + export var TypeQuerySyntax: TypeQueryConstructor = typeQuerySyntax; + + function tupleTypeSyntax(data: number, openBracketToken: ISyntaxToken, types: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken) { + this.openBracketToken = openBracketToken; + this.types = types; + this.closeBracketToken = closeBracketToken; + finishNode(this, data); + } + tupleTypeSyntax.prototype.kind = function() { return SyntaxKind.TupleType; } + export var TupleTypeSyntax: TupleTypeConstructor = tupleTypeSyntax; + + function unionTypeSyntax(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax) { + this.left = left; + this.barToken = barToken; + this.right = right; + finishNode(this, data); + } + unionTypeSyntax.prototype.kind = function() { return SyntaxKind.UnionType; } + export var UnionTypeSyntax: UnionTypeConstructor = unionTypeSyntax; + + function parenthesizedTypeSyntax(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken) { + this.openParenToken = openParenToken; + this.type = type; + this.closeParenToken = closeParenToken; + finishNode(this, data); + } + parenthesizedTypeSyntax.prototype.kind = function() { return SyntaxKind.ParenthesizedType; } + export var ParenthesizedTypeSyntax: ParenthesizedTypeConstructor = parenthesizedTypeSyntax; + + function interfaceDeclarationSyntax(data: number, modifiers: ISyntaxToken[], interfaceKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], body: ObjectTypeSyntax) { + this.modifiers = modifiers; + this.interfaceKeyword = interfaceKeyword; + this.identifier = identifier; + this.typeParameterList = typeParameterList; + this.heritageClauses = heritageClauses; + this.body = body; + finishNode(this, data); + } + interfaceDeclarationSyntax.prototype.kind = function() { return SyntaxKind.InterfaceDeclaration; } + export var InterfaceDeclarationSyntax: InterfaceDeclarationConstructor = interfaceDeclarationSyntax; + + function functionDeclarationSyntax(data: number, modifiers: ISyntaxToken[], functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) { + this.modifiers = modifiers; + this.functionKeyword = functionKeyword; + this.identifier = identifier; + this.callSignature = callSignature; + this.block = block; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + functionDeclarationSyntax.prototype.kind = function() { return SyntaxKind.FunctionDeclaration; } + export var FunctionDeclarationSyntax: FunctionDeclarationConstructor = functionDeclarationSyntax; + + function moduleDeclarationSyntax(data: number, modifiers: ISyntaxToken[], moduleKeyword: ISyntaxToken, name: INameSyntax, stringLiteral: ISyntaxToken, openBraceToken: ISyntaxToken, moduleElements: IModuleElementSyntax[], closeBraceToken: ISyntaxToken) { + this.modifiers = modifiers; + this.moduleKeyword = moduleKeyword; + this.name = name; + this.stringLiteral = stringLiteral; + this.openBraceToken = openBraceToken; + this.moduleElements = moduleElements; + this.closeBraceToken = closeBraceToken; + finishNode(this, data); + } + moduleDeclarationSyntax.prototype.kind = function() { return SyntaxKind.ModuleDeclaration; } + export var ModuleDeclarationSyntax: ModuleDeclarationConstructor = moduleDeclarationSyntax; + + function classDeclarationSyntax(data: number, modifiers: ISyntaxToken[], classKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], openBraceToken: ISyntaxToken, classElements: IClassElementSyntax[], closeBraceToken: ISyntaxToken) { + this.modifiers = modifiers; + this.classKeyword = classKeyword; + this.identifier = identifier; + this.typeParameterList = typeParameterList; + this.heritageClauses = heritageClauses; + this.openBraceToken = openBraceToken; + this.classElements = classElements; + this.closeBraceToken = closeBraceToken; + finishNode(this, data); + } + classDeclarationSyntax.prototype.kind = function() { return SyntaxKind.ClassDeclaration; } + export var ClassDeclarationSyntax: ClassDeclarationConstructor = classDeclarationSyntax; + + function enumDeclarationSyntax(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken) { + this.modifiers = modifiers; + this.enumKeyword = enumKeyword; + this.identifier = identifier; + this.openBraceToken = openBraceToken; + this.enumElements = enumElements; + this.closeBraceToken = closeBraceToken; + finishNode(this, data); + } + enumDeclarationSyntax.prototype.kind = function() { return SyntaxKind.EnumDeclaration; } + export var EnumDeclarationSyntax: EnumDeclarationConstructor = enumDeclarationSyntax; + + function importDeclarationSyntax(data: number, modifiers: ISyntaxToken[], importKeyword: ISyntaxToken, identifier: ISyntaxToken, equalsToken: ISyntaxToken, moduleReference: IModuleReferenceSyntax, semicolonToken: ISyntaxToken) { + this.modifiers = modifiers; + this.importKeyword = importKeyword; + this.identifier = identifier; + this.equalsToken = equalsToken; + this.moduleReference = moduleReference; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + importDeclarationSyntax.prototype.kind = function() { return SyntaxKind.ImportDeclaration; } + export var ImportDeclarationSyntax: ImportDeclarationConstructor = importDeclarationSyntax; + + function exportAssignmentSyntax(data: number, exportKeyword: ISyntaxToken, equalsToken: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) { + this.exportKeyword = exportKeyword; + this.equalsToken = equalsToken; + this.identifier = identifier; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + exportAssignmentSyntax.prototype.kind = function() { return SyntaxKind.ExportAssignment; } + export var ExportAssignmentSyntax: ExportAssignmentConstructor = exportAssignmentSyntax; + + function memberFunctionDeclarationSyntax(data: number, modifiers: ISyntaxToken[], propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) { + this.modifiers = modifiers; + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + memberFunctionDeclarationSyntax.prototype.kind = function() { return SyntaxKind.MemberFunctionDeclaration; } + export var MemberFunctionDeclarationSyntax: MemberFunctionDeclarationConstructor = memberFunctionDeclarationSyntax; + + function memberVariableDeclarationSyntax(data: number, modifiers: ISyntaxToken[], variableDeclarator: VariableDeclaratorSyntax, semicolonToken: ISyntaxToken) { + this.modifiers = modifiers; + this.variableDeclarator = variableDeclarator; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + memberVariableDeclarationSyntax.prototype.kind = function() { return SyntaxKind.MemberVariableDeclaration; } + export var MemberVariableDeclarationSyntax: MemberVariableDeclarationConstructor = memberVariableDeclarationSyntax; + + function constructorDeclarationSyntax(data: number, modifiers: ISyntaxToken[], constructorKeyword: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) { + this.modifiers = modifiers; + this.constructorKeyword = constructorKeyword; + this.callSignature = callSignature; + this.block = block; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + constructorDeclarationSyntax.prototype.kind = function() { return SyntaxKind.ConstructorDeclaration; } + export var ConstructorDeclarationSyntax: ConstructorDeclarationConstructor = constructorDeclarationSyntax; + + function indexMemberDeclarationSyntax(data: number, modifiers: ISyntaxToken[], indexSignature: IndexSignatureSyntax, semicolonToken: ISyntaxToken) { + this.modifiers = modifiers; + this.indexSignature = indexSignature; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + indexMemberDeclarationSyntax.prototype.kind = function() { return SyntaxKind.IndexMemberDeclaration; } + export var IndexMemberDeclarationSyntax: IndexMemberDeclarationConstructor = indexMemberDeclarationSyntax; + + function getAccessorSyntax(data: number, modifiers: ISyntaxToken[], getKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) { + this.modifiers = modifiers; + this.getKeyword = getKeyword; + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + finishNode(this, data); + } + getAccessorSyntax.prototype.kind = function() { return SyntaxKind.GetAccessor; } + export var GetAccessorSyntax: GetAccessorConstructor = getAccessorSyntax; + + function setAccessorSyntax(data: number, modifiers: ISyntaxToken[], setKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) { + this.modifiers = modifiers; + this.setKeyword = setKeyword; + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + finishNode(this, data); + } + setAccessorSyntax.prototype.kind = function() { return SyntaxKind.SetAccessor; } + export var SetAccessorSyntax: SetAccessorConstructor = setAccessorSyntax; + + function propertySignatureSyntax(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) { + this.propertyName = propertyName; + this.questionToken = questionToken; + this.typeAnnotation = typeAnnotation; + finishNode(this, data); + } + propertySignatureSyntax.prototype.kind = function() { return SyntaxKind.PropertySignature; } + export var PropertySignatureSyntax: PropertySignatureConstructor = propertySignatureSyntax; + + function callSignatureSyntax(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, typeAnnotation: TypeAnnotationSyntax) { + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.typeAnnotation = typeAnnotation; + finishNode(this, data); + } + callSignatureSyntax.prototype.kind = function() { return SyntaxKind.CallSignature; } + export var CallSignatureSyntax: CallSignatureConstructor = callSignatureSyntax; + + function constructSignatureSyntax(data: number, newKeyword: ISyntaxToken, callSignature: CallSignatureSyntax) { + this.newKeyword = newKeyword; + this.callSignature = callSignature; + finishNode(this, data); + } + constructSignatureSyntax.prototype.kind = function() { return SyntaxKind.ConstructSignature; } + export var ConstructSignatureSyntax: ConstructSignatureConstructor = constructSignatureSyntax; + + function indexSignatureSyntax(data: number, openBracketToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) { + this.openBracketToken = openBracketToken; + this.parameters = parameters; + this.closeBracketToken = closeBracketToken; + this.typeAnnotation = typeAnnotation; + finishNode(this, data); + } + indexSignatureSyntax.prototype.kind = function() { return SyntaxKind.IndexSignature; } + export var IndexSignatureSyntax: IndexSignatureConstructor = indexSignatureSyntax; + + function methodSignatureSyntax(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, callSignature: CallSignatureSyntax) { + this.propertyName = propertyName; + this.questionToken = questionToken; + this.callSignature = callSignature; + finishNode(this, data); + } + methodSignatureSyntax.prototype.kind = function() { return SyntaxKind.MethodSignature; } + export var MethodSignatureSyntax: MethodSignatureConstructor = methodSignatureSyntax; + + function blockSyntax(data: number, openBraceToken: ISyntaxToken, statements: IStatementSyntax[], closeBraceToken: ISyntaxToken) { + this.openBraceToken = openBraceToken; + this.statements = statements; + this.closeBraceToken = closeBraceToken; + finishNode(this, data); + } + blockSyntax.prototype.kind = function() { return SyntaxKind.Block; } + export var BlockSyntax: BlockConstructor = blockSyntax; + + function ifStatementSyntax(data: number, ifKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax, elseClause: ElseClauseSyntax) { + this.ifKeyword = ifKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.statement = statement; + this.elseClause = elseClause; + finishNode(this, data); + } + ifStatementSyntax.prototype.kind = function() { return SyntaxKind.IfStatement; } + export var IfStatementSyntax: IfStatementConstructor = ifStatementSyntax; + + function variableStatementSyntax(data: number, modifiers: ISyntaxToken[], variableDeclaration: VariableDeclarationSyntax, semicolonToken: ISyntaxToken) { + this.modifiers = modifiers; + this.variableDeclaration = variableDeclaration; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + variableStatementSyntax.prototype.kind = function() { return SyntaxKind.VariableStatement; } + export var VariableStatementSyntax: VariableStatementConstructor = variableStatementSyntax; + + function expressionStatementSyntax(data: number, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) { + this.expression = expression; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + expressionStatementSyntax.prototype.kind = function() { return SyntaxKind.ExpressionStatement; } + export var ExpressionStatementSyntax: ExpressionStatementConstructor = expressionStatementSyntax; + + function returnStatementSyntax(data: number, returnKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) { + this.returnKeyword = returnKeyword; + this.expression = expression; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + returnStatementSyntax.prototype.kind = function() { return SyntaxKind.ReturnStatement; } + export var ReturnStatementSyntax: ReturnStatementConstructor = returnStatementSyntax; + + function switchStatementSyntax(data: number, switchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, openBraceToken: ISyntaxToken, switchClauses: ISwitchClauseSyntax[], closeBraceToken: ISyntaxToken) { + this.switchKeyword = switchKeyword; + this.openParenToken = openParenToken; + this.expression = expression; + this.closeParenToken = closeParenToken; + this.openBraceToken = openBraceToken; + this.switchClauses = switchClauses; + this.closeBraceToken = closeBraceToken; + finishNode(this, data); + } + switchStatementSyntax.prototype.kind = function() { return SyntaxKind.SwitchStatement; } + export var SwitchStatementSyntax: SwitchStatementConstructor = switchStatementSyntax; + + function breakStatementSyntax(data: number, breakKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) { + this.breakKeyword = breakKeyword; + this.identifier = identifier; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + breakStatementSyntax.prototype.kind = function() { return SyntaxKind.BreakStatement; } + export var BreakStatementSyntax: BreakStatementConstructor = breakStatementSyntax; + + function continueStatementSyntax(data: number, continueKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) { + this.continueKeyword = continueKeyword; + this.identifier = identifier; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + continueStatementSyntax.prototype.kind = function() { return SyntaxKind.ContinueStatement; } + export var ContinueStatementSyntax: ContinueStatementConstructor = continueStatementSyntax; + + function forStatementSyntax(data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, initializer: IExpressionSyntax, firstSemicolonToken: ISyntaxToken, condition: IExpressionSyntax, secondSemicolonToken: ISyntaxToken, incrementor: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) { + this.forKeyword = forKeyword; + this.openParenToken = openParenToken; + this.variableDeclaration = variableDeclaration; + this.initializer = initializer; + this.firstSemicolonToken = firstSemicolonToken; + this.condition = condition; + this.secondSemicolonToken = secondSemicolonToken; + this.incrementor = incrementor; + this.closeParenToken = closeParenToken; + this.statement = statement; + finishNode(this, data); + } + forStatementSyntax.prototype.kind = function() { return SyntaxKind.ForStatement; } + export var ForStatementSyntax: ForStatementConstructor = forStatementSyntax; + + function forInStatementSyntax(data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, left: IExpressionSyntax, inKeyword: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) { + this.forKeyword = forKeyword; + this.openParenToken = openParenToken; + this.variableDeclaration = variableDeclaration; + this.left = left; + this.inKeyword = inKeyword; + this.expression = expression; + this.closeParenToken = closeParenToken; + this.statement = statement; + finishNode(this, data); + } + forInStatementSyntax.prototype.kind = function() { return SyntaxKind.ForInStatement; } + export var ForInStatementSyntax: ForInStatementConstructor = forInStatementSyntax; + + function emptyStatementSyntax(data: number, semicolonToken: ISyntaxToken) { + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + emptyStatementSyntax.prototype.kind = function() { return SyntaxKind.EmptyStatement; } + export var EmptyStatementSyntax: EmptyStatementConstructor = emptyStatementSyntax; + + function throwStatementSyntax(data: number, throwKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) { + this.throwKeyword = throwKeyword; + this.expression = expression; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + throwStatementSyntax.prototype.kind = function() { return SyntaxKind.ThrowStatement; } + export var ThrowStatementSyntax: ThrowStatementConstructor = throwStatementSyntax; + + function whileStatementSyntax(data: number, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) { + this.whileKeyword = whileKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.statement = statement; + finishNode(this, data); + } + whileStatementSyntax.prototype.kind = function() { return SyntaxKind.WhileStatement; } + export var WhileStatementSyntax: WhileStatementConstructor = whileStatementSyntax; + + function tryStatementSyntax(data: number, tryKeyword: ISyntaxToken, block: BlockSyntax, catchClause: CatchClauseSyntax, finallyClause: FinallyClauseSyntax) { + this.tryKeyword = tryKeyword; + this.block = block; + this.catchClause = catchClause; + this.finallyClause = finallyClause; + finishNode(this, data); + } + tryStatementSyntax.prototype.kind = function() { return SyntaxKind.TryStatement; } + export var TryStatementSyntax: TryStatementConstructor = tryStatementSyntax; + + function labeledStatementSyntax(data: number, identifier: ISyntaxToken, colonToken: ISyntaxToken, statement: IStatementSyntax) { + this.identifier = identifier; + this.colonToken = colonToken; + this.statement = statement; + finishNode(this, data); + } + labeledStatementSyntax.prototype.kind = function() { return SyntaxKind.LabeledStatement; } + export var LabeledStatementSyntax: LabeledStatementConstructor = labeledStatementSyntax; + + function doStatementSyntax(data: number, doKeyword: ISyntaxToken, statement: IStatementSyntax, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, semicolonToken: ISyntaxToken) { + this.doKeyword = doKeyword; + this.statement = statement; + this.whileKeyword = whileKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + doStatementSyntax.prototype.kind = function() { return SyntaxKind.DoStatement; } + export var DoStatementSyntax: DoStatementConstructor = doStatementSyntax; + + function debuggerStatementSyntax(data: number, debuggerKeyword: ISyntaxToken, semicolonToken: ISyntaxToken) { + this.debuggerKeyword = debuggerKeyword; + this.semicolonToken = semicolonToken; + finishNode(this, data); + } + debuggerStatementSyntax.prototype.kind = function() { return SyntaxKind.DebuggerStatement; } + export var DebuggerStatementSyntax: DebuggerStatementConstructor = debuggerStatementSyntax; + + function withStatementSyntax(data: number, withKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) { + this.withKeyword = withKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.statement = statement; + finishNode(this, data); + } + withStatementSyntax.prototype.kind = function() { return SyntaxKind.WithStatement; } + export var WithStatementSyntax: WithStatementConstructor = withStatementSyntax; + + function prefixUnaryExpressionSyntax(data: number, operatorToken: ISyntaxToken, operand: IUnaryExpressionSyntax) { + this.operatorToken = operatorToken; + this.operand = operand; + finishNode(this, data); + } + prefixUnaryExpressionSyntax.prototype.kind = function() { return SyntaxKind.PrefixUnaryExpression; } + export var PrefixUnaryExpressionSyntax: PrefixUnaryExpressionConstructor = prefixUnaryExpressionSyntax; + + function deleteExpressionSyntax(data: number, deleteKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) { + this.deleteKeyword = deleteKeyword; + this.expression = expression; + finishNode(this, data); + } + deleteExpressionSyntax.prototype.kind = function() { return SyntaxKind.DeleteExpression; } + export var DeleteExpressionSyntax: DeleteExpressionConstructor = deleteExpressionSyntax; + + function typeOfExpressionSyntax(data: number, typeOfKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) { + this.typeOfKeyword = typeOfKeyword; + this.expression = expression; + finishNode(this, data); + } + typeOfExpressionSyntax.prototype.kind = function() { return SyntaxKind.TypeOfExpression; } + export var TypeOfExpressionSyntax: TypeOfExpressionConstructor = typeOfExpressionSyntax; + + function voidExpressionSyntax(data: number, voidKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) { + this.voidKeyword = voidKeyword; + this.expression = expression; + finishNode(this, data); + } + voidExpressionSyntax.prototype.kind = function() { return SyntaxKind.VoidExpression; } + export var VoidExpressionSyntax: VoidExpressionConstructor = voidExpressionSyntax; + + function conditionalExpressionSyntax(data: number, condition: IExpressionSyntax, questionToken: ISyntaxToken, whenTrue: IExpressionSyntax, colonToken: ISyntaxToken, whenFalse: IExpressionSyntax) { + this.condition = condition; + this.questionToken = questionToken; + this.whenTrue = whenTrue; + this.colonToken = colonToken; + this.whenFalse = whenFalse; + finishNode(this, data); + } + conditionalExpressionSyntax.prototype.kind = function() { return SyntaxKind.ConditionalExpression; } + export var ConditionalExpressionSyntax: ConditionalExpressionConstructor = conditionalExpressionSyntax; + + function binaryExpressionSyntax(data: number, left: IExpressionSyntax, operatorToken: ISyntaxToken, right: IExpressionSyntax) { + this.left = left; + this.operatorToken = operatorToken; + this.right = right; + finishNode(this, data); + } + binaryExpressionSyntax.prototype.kind = function() { return SyntaxKind.BinaryExpression; } + export var BinaryExpressionSyntax: BinaryExpressionConstructor = binaryExpressionSyntax; + + function postfixUnaryExpressionSyntax(data: number, operand: ILeftHandSideExpressionSyntax, operatorToken: ISyntaxToken) { + this.operand = operand; + this.operatorToken = operatorToken; + finishNode(this, data); + } + postfixUnaryExpressionSyntax.prototype.kind = function() { return SyntaxKind.PostfixUnaryExpression; } + export var PostfixUnaryExpressionSyntax: PostfixUnaryExpressionConstructor = postfixUnaryExpressionSyntax; + + function memberAccessExpressionSyntax(data: number, expression: ILeftHandSideExpressionSyntax, dotToken: ISyntaxToken, name: ISyntaxToken) { + this.expression = expression; + this.dotToken = dotToken; + this.name = name; + finishNode(this, data); + } + memberAccessExpressionSyntax.prototype.kind = function() { return SyntaxKind.MemberAccessExpression; } + export var MemberAccessExpressionSyntax: MemberAccessExpressionConstructor = memberAccessExpressionSyntax; + + function invocationExpressionSyntax(data: number, expression: ILeftHandSideExpressionSyntax, argumentList: ArgumentListSyntax) { + this.expression = expression; + this.argumentList = argumentList; + finishNode(this, data); + } + invocationExpressionSyntax.prototype.kind = function() { return SyntaxKind.InvocationExpression; } + export var InvocationExpressionSyntax: InvocationExpressionConstructor = invocationExpressionSyntax; + + function arrayLiteralExpressionSyntax(data: number, openBracketToken: ISyntaxToken, expressions: ISeparatedSyntaxList, closeBracketToken: ISyntaxToken) { + this.openBracketToken = openBracketToken; + this.expressions = expressions; + this.closeBracketToken = closeBracketToken; + finishNode(this, data); + } + arrayLiteralExpressionSyntax.prototype.kind = function() { return SyntaxKind.ArrayLiteralExpression; } + export var ArrayLiteralExpressionSyntax: ArrayLiteralExpressionConstructor = arrayLiteralExpressionSyntax; + + function objectLiteralExpressionSyntax(data: number, openBraceToken: ISyntaxToken, propertyAssignments: ISeparatedSyntaxList, closeBraceToken: ISyntaxToken) { + this.openBraceToken = openBraceToken; + this.propertyAssignments = propertyAssignments; + this.closeBraceToken = closeBraceToken; + finishNode(this, data); + } + objectLiteralExpressionSyntax.prototype.kind = function() { return SyntaxKind.ObjectLiteralExpression; } + export var ObjectLiteralExpressionSyntax: ObjectLiteralExpressionConstructor = objectLiteralExpressionSyntax; + + function objectCreationExpressionSyntax(data: number, newKeyword: ISyntaxToken, expression: IMemberExpressionSyntax, argumentList: ArgumentListSyntax) { + this.newKeyword = newKeyword; + this.expression = expression; + this.argumentList = argumentList; + finishNode(this, data); + } + objectCreationExpressionSyntax.prototype.kind = function() { return SyntaxKind.ObjectCreationExpression; } + export var ObjectCreationExpressionSyntax: ObjectCreationExpressionConstructor = objectCreationExpressionSyntax; + + function parenthesizedExpressionSyntax(data: number, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken) { + this.openParenToken = openParenToken; + this.expression = expression; + this.closeParenToken = closeParenToken; + finishNode(this, data); + } + parenthesizedExpressionSyntax.prototype.kind = function() { return SyntaxKind.ParenthesizedExpression; } + export var ParenthesizedExpressionSyntax: ParenthesizedExpressionConstructor = parenthesizedExpressionSyntax; + + function parenthesizedArrowFunctionExpressionSyntax(data: number, callSignature: CallSignatureSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax) { + this.callSignature = callSignature; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.block = block; + this.expression = expression; + finishNode(this, data); + } + parenthesizedArrowFunctionExpressionSyntax.prototype.kind = function() { return SyntaxKind.ParenthesizedArrowFunctionExpression; } + export var ParenthesizedArrowFunctionExpressionSyntax: ParenthesizedArrowFunctionExpressionConstructor = parenthesizedArrowFunctionExpressionSyntax; + + function simpleArrowFunctionExpressionSyntax(data: number, parameter: ParameterSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax) { + this.parameter = parameter; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.block = block; + this.expression = expression; + finishNode(this, data); + } + simpleArrowFunctionExpressionSyntax.prototype.kind = function() { return SyntaxKind.SimpleArrowFunctionExpression; } + export var SimpleArrowFunctionExpressionSyntax: SimpleArrowFunctionExpressionConstructor = simpleArrowFunctionExpressionSyntax; + + function castExpressionSyntax(data: number, lessThanToken: ISyntaxToken, type: ITypeSyntax, greaterThanToken: ISyntaxToken, expression: IUnaryExpressionSyntax) { + this.lessThanToken = lessThanToken; + this.type = type; + this.greaterThanToken = greaterThanToken; + this.expression = expression; + finishNode(this, data); + } + castExpressionSyntax.prototype.kind = function() { return SyntaxKind.CastExpression; } + export var CastExpressionSyntax: CastExpressionConstructor = castExpressionSyntax; + + function elementAccessExpressionSyntax(data: number, expression: ILeftHandSideExpressionSyntax, openBracketToken: ISyntaxToken, argumentExpression: IExpressionSyntax, closeBracketToken: ISyntaxToken) { + this.expression = expression; + this.openBracketToken = openBracketToken; + this.argumentExpression = argumentExpression; + this.closeBracketToken = closeBracketToken; + finishNode(this, data); + } + elementAccessExpressionSyntax.prototype.kind = function() { return SyntaxKind.ElementAccessExpression; } + export var ElementAccessExpressionSyntax: ElementAccessExpressionConstructor = elementAccessExpressionSyntax; + + function functionExpressionSyntax(data: number, functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) { + this.functionKeyword = functionKeyword; + this.identifier = identifier; + this.callSignature = callSignature; + this.block = block; + finishNode(this, data); + } + functionExpressionSyntax.prototype.kind = function() { return SyntaxKind.FunctionExpression; } + export var FunctionExpressionSyntax: FunctionExpressionConstructor = functionExpressionSyntax; + + function omittedExpressionSyntax(data: number) { + finishNode(this, data); + } + omittedExpressionSyntax.prototype.kind = function() { return SyntaxKind.OmittedExpression; } + export var OmittedExpressionSyntax: OmittedExpressionConstructor = omittedExpressionSyntax; + + function templateExpressionSyntax(data: number, templateStartToken: ISyntaxToken, templateClauses: TemplateClauseSyntax[]) { + this.templateStartToken = templateStartToken; + this.templateClauses = templateClauses; + finishNode(this, data); + } + templateExpressionSyntax.prototype.kind = function() { return SyntaxKind.TemplateExpression; } + export var TemplateExpressionSyntax: TemplateExpressionConstructor = templateExpressionSyntax; + + function templateAccessExpressionSyntax(data: number, expression: ILeftHandSideExpressionSyntax, templateExpression: IPrimaryExpressionSyntax) { + this.expression = expression; + this.templateExpression = templateExpression; + finishNode(this, data); + } + templateAccessExpressionSyntax.prototype.kind = function() { return SyntaxKind.TemplateAccessExpression; } + export var TemplateAccessExpressionSyntax: TemplateAccessExpressionConstructor = templateAccessExpressionSyntax; + + function variableDeclarationSyntax(data: number, varKeyword: ISyntaxToken, variableDeclarators: ISeparatedSyntaxList) { + this.varKeyword = varKeyword; + this.variableDeclarators = variableDeclarators; + finishNode(this, data); + } + variableDeclarationSyntax.prototype.kind = function() { return SyntaxKind.VariableDeclaration; } + export var VariableDeclarationSyntax: VariableDeclarationConstructor = variableDeclarationSyntax; + + function variableDeclaratorSyntax(data: number, propertyName: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax) { + this.propertyName = propertyName; + this.typeAnnotation = typeAnnotation; + this.equalsValueClause = equalsValueClause; + finishNode(this, data); + } + variableDeclaratorSyntax.prototype.kind = function() { return SyntaxKind.VariableDeclarator; } + export var VariableDeclaratorSyntax: VariableDeclaratorConstructor = variableDeclaratorSyntax; + + function argumentListSyntax(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, _arguments: ISeparatedSyntaxList, closeParenToken: ISyntaxToken) { + this.typeArgumentList = typeArgumentList; + this.openParenToken = openParenToken; + this.arguments = _arguments; + this.closeParenToken = closeParenToken; + finishNode(this, data); + } + argumentListSyntax.prototype.kind = function() { return SyntaxKind.ArgumentList; } + export var ArgumentListSyntax: ArgumentListConstructor = argumentListSyntax; + + function parameterListSyntax(data: number, openParenToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeParenToken: ISyntaxToken) { + this.openParenToken = openParenToken; + this.parameters = parameters; + this.closeParenToken = closeParenToken; + finishNode(this, data); + } + parameterListSyntax.prototype.kind = function() { return SyntaxKind.ParameterList; } + export var ParameterListSyntax: ParameterListConstructor = parameterListSyntax; + + function typeArgumentListSyntax(data: number, lessThanToken: ISyntaxToken, typeArguments: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken) { + this.lessThanToken = lessThanToken; + this.typeArguments = typeArguments; + this.greaterThanToken = greaterThanToken; + finishNode(this, data); + } + typeArgumentListSyntax.prototype.kind = function() { return SyntaxKind.TypeArgumentList; } + export var TypeArgumentListSyntax: TypeArgumentListConstructor = typeArgumentListSyntax; + + function typeParameterListSyntax(data: number, lessThanToken: ISyntaxToken, typeParameters: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken) { + this.lessThanToken = lessThanToken; + this.typeParameters = typeParameters; + this.greaterThanToken = greaterThanToken; + finishNode(this, data); + } + typeParameterListSyntax.prototype.kind = function() { return SyntaxKind.TypeParameterList; } + export var TypeParameterListSyntax: TypeParameterListConstructor = typeParameterListSyntax; + + function heritageClauseSyntax(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: ISeparatedSyntaxList) { + this.extendsOrImplementsKeyword = extendsOrImplementsKeyword; + this.typeNames = typeNames; + finishNode(this, data); + } + heritageClauseSyntax.prototype.kind = function() { return SyntaxKind.HeritageClause; } + export var HeritageClauseSyntax: HeritageClauseConstructor = heritageClauseSyntax; + + function equalsValueClauseSyntax(data: number, equalsToken: ISyntaxToken, value: IExpressionSyntax) { + this.equalsToken = equalsToken; + this.value = value; + finishNode(this, data); + } + equalsValueClauseSyntax.prototype.kind = function() { return SyntaxKind.EqualsValueClause; } + export var EqualsValueClauseSyntax: EqualsValueClauseConstructor = equalsValueClauseSyntax; + + function caseSwitchClauseSyntax(data: number, caseKeyword: ISyntaxToken, expression: IExpressionSyntax, colonToken: ISyntaxToken, statements: IStatementSyntax[]) { + this.caseKeyword = caseKeyword; + this.expression = expression; + this.colonToken = colonToken; + this.statements = statements; + finishNode(this, data); + } + caseSwitchClauseSyntax.prototype.kind = function() { return SyntaxKind.CaseSwitchClause; } + export var CaseSwitchClauseSyntax: CaseSwitchClauseConstructor = caseSwitchClauseSyntax; + + function defaultSwitchClauseSyntax(data: number, defaultKeyword: ISyntaxToken, colonToken: ISyntaxToken, statements: IStatementSyntax[]) { + this.defaultKeyword = defaultKeyword; + this.colonToken = colonToken; + this.statements = statements; + finishNode(this, data); + } + defaultSwitchClauseSyntax.prototype.kind = function() { return SyntaxKind.DefaultSwitchClause; } + export var DefaultSwitchClauseSyntax: DefaultSwitchClauseConstructor = defaultSwitchClauseSyntax; + + function elseClauseSyntax(data: number, elseKeyword: ISyntaxToken, statement: IStatementSyntax) { + this.elseKeyword = elseKeyword; + this.statement = statement; + finishNode(this, data); + } + elseClauseSyntax.prototype.kind = function() { return SyntaxKind.ElseClause; } + export var ElseClauseSyntax: ElseClauseConstructor = elseClauseSyntax; + + function catchClauseSyntax(data: number, catchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, identifier: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, closeParenToken: ISyntaxToken, block: BlockSyntax) { + this.catchKeyword = catchKeyword; + this.openParenToken = openParenToken; + this.identifier = identifier; + this.typeAnnotation = typeAnnotation; + this.closeParenToken = closeParenToken; + this.block = block; + finishNode(this, data); + } + catchClauseSyntax.prototype.kind = function() { return SyntaxKind.CatchClause; } + export var CatchClauseSyntax: CatchClauseConstructor = catchClauseSyntax; + + function finallyClauseSyntax(data: number, finallyKeyword: ISyntaxToken, block: BlockSyntax) { + this.finallyKeyword = finallyKeyword; + this.block = block; + finishNode(this, data); + } + finallyClauseSyntax.prototype.kind = function() { return SyntaxKind.FinallyClause; } + export var FinallyClauseSyntax: FinallyClauseConstructor = finallyClauseSyntax; + + function templateClauseSyntax(data: number, expression: IExpressionSyntax, templateMiddleOrEndToken: ISyntaxToken) { + this.expression = expression; + this.templateMiddleOrEndToken = templateMiddleOrEndToken; + finishNode(this, data); + } + templateClauseSyntax.prototype.kind = function() { return SyntaxKind.TemplateClause; } + export var TemplateClauseSyntax: TemplateClauseConstructor = templateClauseSyntax; + + function typeParameterSyntax(data: number, identifier: ISyntaxToken, constraint: ConstraintSyntax) { + this.identifier = identifier; + this.constraint = constraint; + finishNode(this, data); + } + typeParameterSyntax.prototype.kind = function() { return SyntaxKind.TypeParameter; } + export var TypeParameterSyntax: TypeParameterConstructor = typeParameterSyntax; + + function constraintSyntax(data: number, extendsKeyword: ISyntaxToken, typeOrExpression: ISyntaxNodeOrToken) { + this.extendsKeyword = extendsKeyword; + this.typeOrExpression = typeOrExpression; + finishNode(this, data); + } + constraintSyntax.prototype.kind = function() { return SyntaxKind.Constraint; } + export var ConstraintSyntax: ConstraintConstructor = constraintSyntax; + + function simplePropertyAssignmentSyntax(data: number, propertyName: ISyntaxToken, colonToken: ISyntaxToken, expression: IExpressionSyntax) { + this.propertyName = propertyName; + this.colonToken = colonToken; + this.expression = expression; + finishNode(this, data); + } + simplePropertyAssignmentSyntax.prototype.kind = function() { return SyntaxKind.SimplePropertyAssignment; } + export var SimplePropertyAssignmentSyntax: SimplePropertyAssignmentConstructor = simplePropertyAssignmentSyntax; + + function functionPropertyAssignmentSyntax(data: number, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) { + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + finishNode(this, data); + } + functionPropertyAssignmentSyntax.prototype.kind = function() { return SyntaxKind.FunctionPropertyAssignment; } + export var FunctionPropertyAssignmentSyntax: FunctionPropertyAssignmentConstructor = functionPropertyAssignmentSyntax; + + function parameterSyntax(data: number, dotDotDotToken: ISyntaxToken, modifiers: ISyntaxToken[], identifier: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax) { + this.dotDotDotToken = dotDotDotToken; + this.modifiers = modifiers; + this.identifier = identifier; + this.questionToken = questionToken; + this.typeAnnotation = typeAnnotation; + this.equalsValueClause = equalsValueClause; + finishNode(this, data); + } + parameterSyntax.prototype.kind = function() { return SyntaxKind.Parameter; } + export var ParameterSyntax: ParameterConstructor = parameterSyntax; + + function enumElementSyntax(data: number, propertyName: ISyntaxToken, equalsValueClause: EqualsValueClauseSyntax) { + this.propertyName = propertyName; + this.equalsValueClause = equalsValueClause; + finishNode(this, data); + } + enumElementSyntax.prototype.kind = function() { return SyntaxKind.EnumElement; } + export var EnumElementSyntax: EnumElementConstructor = enumElementSyntax; + + function typeAnnotationSyntax(data: number, colonToken: ISyntaxToken, type: ITypeSyntax) { + this.colonToken = colonToken; + this.type = type; + finishNode(this, data); + } + typeAnnotationSyntax.prototype.kind = function() { return SyntaxKind.TypeAnnotation; } + export var TypeAnnotationSyntax: TypeAnnotationConstructor = typeAnnotationSyntax; + + function externalModuleReferenceSyntax(data: number, requireKeyword: ISyntaxToken, openParenToken: ISyntaxToken, stringLiteral: ISyntaxToken, closeParenToken: ISyntaxToken) { + this.requireKeyword = requireKeyword; + this.openParenToken = openParenToken; + this.stringLiteral = stringLiteral; + this.closeParenToken = closeParenToken; + finishNode(this, data); + } + externalModuleReferenceSyntax.prototype.kind = function() { return SyntaxKind.ExternalModuleReference; } + export var ExternalModuleReferenceSyntax: ExternalModuleReferenceConstructor = externalModuleReferenceSyntax; + + function moduleNameModuleReferenceSyntax(data: number, moduleName: INameSyntax) { + this.moduleName = moduleName; + finishNode(this, data); + } + moduleNameModuleReferenceSyntax.prototype.kind = function() { return SyntaxKind.ModuleNameModuleReference; } + export var ModuleNameModuleReferenceSyntax: ModuleNameModuleReferenceConstructor = moduleNameModuleReferenceSyntax; } \ No newline at end of file