microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-15 12:51:30 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Merge pull request #1063 from Microsoft/nodeCleanup

Browse Source 
Node cleanup
This commit is contained in:
CyrusNajmabadi
2014-11-04 23:03:13 -08:00
parent d8080a0b46 5952036e2c
commit fff8ef8b84
14 changed files with 907 additions and 996 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
src/services/syntax/SyntaxGenerator.js
View File

@@ -1510,7 +1510,7 @@ var definitions = [
{
name: 'GetAccessorSyntax',
baseType: 'ISyntaxNode',
interfaces: ['IMemberDeclarationSyntax', 'IPropertyAssignmentSyntax'],
interfaces: ['IAccessorSyntax'],
children: [
{ name: 'modifiers', isList: true, elementType: 'ISyntaxToken', isTypeScriptSpecific: true },
{ name: 'getKeyword', isToken: true, excludeFromAST: true },
@@ -1522,7 +1522,7 @@ var definitions = [
{
name: 'SetAccessorSyntax',
baseType: 'ISyntaxNode',
interfaces: ['IMemberDeclarationSyntax', 'IPropertyAssignmentSyntax'],
interfaces: ['IAccessorSyntax'],
children: [
{ name: 'modifiers', isList: true, elementType: 'ISyntaxToken', isTypeScriptSpecific: true },
{ name: 'setKeyword', isToken: true, excludeFromAST: true },
@@ -1907,43 +1907,6 @@ function getSafeName(child) {
}
return child.name;
}
function generateBrands(definition, accessibility) {
var properties = "";
var types = [];
if (definition.interfaces) {
var ifaces = definition.interfaces.slice(0);
var i;
for (i = 0; i < ifaces.length; i++) {
var current = ifaces[i];
while (current !== undefined) {
if (!TypeScript.ArrayUtilities.contains(ifaces, current)) {
ifaces.push(current);
}
current = interfaces[current];
}
}
for (i = 0; i < ifaces.length; i++) {
var type = ifaces[i];
type = getStringWithoutSuffix(type);
if (isInterface(type)) {
type = "_" + type.substr(1, 1).toLowerCase() + type.substr(2) + "Brand";
}
types.push(type);
}
}
types.push("_syntaxNodeOrTokenBrand");
if (types.length > 0) {
properties += " ";
for (var i = 0; i < types.length; i++) {
if (accessibility) {
properties += " public ";
}
properties += types[i] + ": any;";
}
properties += "\r\n";
}
return properties;
}
function generateConstructorFunction(definition) {
var result = " export var " + definition.name + ": " + getNameWithoutSuffix(definition) + "Constructor = <any>function(data: number";
for (var i = 0; i < definition.children.length; i++) {
@@ -1983,6 +1946,19 @@ function generateConstructorFunction(definition) {
}
result += " };\r\n";
result += " " + definition.name + ".prototype.kind = SyntaxKind." + getNameWithoutSuffix(definition) + ";\r\n";
result += " " + definition.name + ".prototype.childCount = " + definition.children.length + ";\r\n";
result += " " + definition.name + ".prototype.childAt = function(index: number): ISyntaxElement {\r\n";
if (definition.children.length) {
result += " switch (index) {\r\n";
for (var j = 0; j < definition.children.length; j++) {
result += " case " + j + ": return this." + definition.children[j].name + ";\r\n";
}
result += " }\r\n";
}
else {
result += " throw Errors.invalidOperation();\r\n";
}
result += " }\r\n";
return result;
}
function generateSyntaxInterfaces() {
@@ -2233,72 +2209,16 @@ function generateVisitor() {
result += "\r\n}";
return result;
}
function generateServicesUtilities() {
var result = "";
result += "module TypeScript {\r\n";
result += " var childCountArray = [";
for (var i = 0, n = TypeScript.SyntaxKind.LastNode; i <= n; i++) {
if (i) {
result += ", ";
}
if (i <= TypeScript.SyntaxKind.LastToken) {
result += "0";
}
else {
var definition = TypeScript.ArrayUtilities.first(definitions, function (d) { return firstKind(d) === i; });
result += definition.children.length;
}
}
result += "];\r\n\r\n";
result += " export function childCount(element: ISyntaxElement): number {\r\n";
result += " if (isList(element)) { return (<ISyntaxNodeOrToken[]>element).length; }\r\n";
result += " return childCountArray[element.kind];\r\n";
result += " }\r\n\r\n";
result += " var childAtArray: ((nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement)[] = [\r\n ";
for (var i = 0; i < TypeScript.SyntaxKind.FirstNode; i++) {
if (i) {
result += ", ";
}
result += "undefined";
}
for (var i = 0; i < definitions.length; i++) {
var definition = definitions[i];
result += ",\r\n";
result += " (node: " + definition.name + ", index: number): ISyntaxElement => {\r\n";
if (definition.children.length) {
result += " switch (index) {\r\n";
for (var j = 0; j < definition.children.length; j++) {
result += " case " + j + ": return node." + definition.children[j].name + ";\r\n";
}
result += " }\r\n";
}
else {
result += " throw Errors.invalidOperation();\r\n";
}
result += " }";
}
result += "\r\n ];\r\n";
result += " export function childAt(element: ISyntaxElement, index: number): ISyntaxElement {\r\n";
result += " if (isList(element)) { return (<ISyntaxNodeOrToken[]>element)[index]; }\r\n";
result += " return childAtArray[element.kind](element, index);\r\n";
result += " }\r\n\r\n";
result += " export function getChildAtFunction(element: ISyntaxNodeOrToken): (nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement {\r\n";
result += " return childAtArray[element.kind];\r\n";
result += " }\r\n";
result += "}";
return result;
}
var syntaxNodesConcrete = generateNodes();
var syntaxInterfaces = generateSyntaxInterfaces();
var walker = generateWalker();
var scannerUtilities = generateScannerUtilities();
var visitor = generateVisitor();
var servicesUtilities = generateServicesUtilities();
var utilities = generateUtilities();
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\\syntaxWalker.generated.ts", walker, false);
sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\scannerUtilities.generated.ts", scannerUtilities, false);
sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxVisitor.generated.ts", visitor, false);
sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxUtilities.generated.ts", servicesUtilities, false);
sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\utilities.generated.ts", utilities, false);
//# sourceMappingURL=file:///C:/VSPro_1/src/typescript/public_cyrusn/src/services/syntax/SyntaxGenerator.js.map

1
src/services/syntax/SyntaxGenerator.js.map Normal file
View File

File diff suppressed because one or more lines are too long

2
src/services/syntax/parser.ts
View File

@@ -1134,7 +1134,7 @@ module TypeScript.Parser {
return isPropertyName(peekToken(modifierCount + 1), inErrorRecovery);
}
function parseAccessor(checkForStrictMode: boolean): ISyntaxNode {
function parseAccessor(checkForStrictMode: boolean): IAccessorSyntax {
var modifiers = parseModifiers();
var _currenToken = currentToken();
var tokenKind = _currenToken.kind;

2
src/services/syntax/prettyPrinter.ts
View File

@@ -35,7 +35,7 @@ module TypeScript.PrettyPrinter {
return 1;
}
private newLineCountBetweenStatements(element1: IClassElementSyntax, element2: IClassElementSyntax): number {
private newLineCountBetweenStatements(element1: IStatementSyntax, element2: IStatementSyntax): number {
if (!element1 || !element2) {
return 0;
}

1
src/services/syntax/references.ts
View File

@@ -28,7 +28,6 @@
///<reference path='syntaxTrivia.ts' />
///<reference path='syntaxTriviaList.ts' />
///<reference path='syntaxUtilities.ts' />
///<reference path='syntaxUtilities.generated.ts' />
///<reference path='syntaxVisitor.generated.ts' />
///<reference path='syntaxWalker.generated.ts' />

12
src/services/syntax/scanner.ts
View File

@@ -219,8 +219,9 @@ module TypeScript.Scanner {
}
class FixedWidthTokenWithNoTrivia implements ISyntaxToken {
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _syntaxNodeOrTokenBrand: any;
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _nameBrand: any;
public parent: ISyntaxElement;
public childCount: number;
constructor(private _fullStart: number, public kind: SyntaxKind) {
}
@@ -228,8 +229,7 @@ module TypeScript.Scanner {
public setFullStart(fullStart: number): void {
this._fullStart = fullStart;
}
public childCount() { return 0 }
public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
@@ -251,10 +251,12 @@ module TypeScript.Scanner {
public hasTrailingComment(): boolean { return false; }
public clone(): ISyntaxToken { return new FixedWidthTokenWithNoTrivia(this._fullStart, this.kind); }
}
FixedWidthTokenWithNoTrivia.prototype.childCount = 0;
class LargeScannerToken implements ISyntaxToken {
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _syntaxNodeOrTokenBrand: any;
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _nameBrand: any;
public parent: ISyntaxElement;
public childCount: number;
private cachedText: string;
@@ -268,7 +270,6 @@ module TypeScript.Scanner {
this._fullStart = fullStart;
}
public childCount() { return 0 }
public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
@@ -310,6 +311,7 @@ module TypeScript.Scanner {
public hasTrailingComment(): boolean { return largeTokenUnpackHasTrailingComment(this._packedFullWidthAndInfo); }
public clone(): ISyntaxToken { return new LargeScannerToken(this._fullStart, this.kind, this._packedFullWidthAndInfo, this.cachedText); }
}
LargeScannerToken.prototype.childCount = 0;
export interface DiagnosticCallback {
(position: number, width: number, key: string, arguments: any[]): void;

61
src/services/syntax/syntaxElement.ts
View File

@@ -144,9 +144,8 @@ module TypeScript {
return <ISyntaxToken>nodeOrToken;
}
var childAtFunction = getChildAtFunction(nodeOrToken);
for (var i = 0, n = childCount(nodeOrToken); i < n; i++) {
var child = childAtFunction(nodeOrToken, i);
var child = nodeOrToken.childAt(i);
if (child) {
var childFullWidth = fullWidth(child);
@@ -335,27 +334,52 @@ module TypeScript {
return info;
}
function computeData(element: ISyntaxElement): number {
var slotCount = childCount(element);
function combineData(fullWidth: number, isIncrementallyUnusable: boolean) {
return (fullWidth << SyntaxConstants.NodeFullWidthShift)
| (isIncrementallyUnusable ? SyntaxConstants.NodeIncrementallyUnusableMask : 0)
| SyntaxConstants.NodeDataComputed;
}
function listComputeData(list: ISyntaxNodeOrToken[]): number {
var fullWidth = 0;
var isIncrementallyUnusable = false;
for (var i = 0, n = list.length; i < n; i++) {
var child: ISyntaxElement = list[i];
fullWidth += TypeScript.fullWidth(child);
isIncrementallyUnusable = isIncrementallyUnusable || TypeScript.isIncrementallyUnusable(child);
}
return combineData(fullWidth, isIncrementallyUnusable);
}
function computeData(element: ISyntaxElement): number {
if (isList(element)) {
return listComputeData(<ISyntaxNodeOrToken[]>element);
}
else {
return nodeOrTokenComputeData(<ISyntaxNodeOrToken>element);
}
}
function nodeOrTokenComputeData(nodeOrToken: ISyntaxNodeOrToken) {
var fullWidth = 0;
var slotCount = nodeOrToken.childCount;
// If we have no children (like an OmmittedExpressionSyntax), we're automatically not reusable.
var isIncrementallyUnusable = slotCount === 0 && !isList(element);
var isIncrementallyUnusable = slotCount === 0;
for (var i = 0, n = slotCount; i < n; i++) {
var child = childAt(element, i);
var child = nodeOrToken.childAt(i);
if (child) {
fullWidth += TypeScript.fullWidth(child);
isIncrementallyUnusable = isIncrementallyUnusable || TypeScript.isIncrementallyUnusable(child);
}
}
return (fullWidth << SyntaxConstants.NodeFullWidthShift)
| (isIncrementallyUnusable ? SyntaxConstants.NodeIncrementallyUnusableMask : 0)
| SyntaxConstants.NodeDataComputed;
return combineData(fullWidth, isIncrementallyUnusable);
}
export function start(element: ISyntaxElement, text?: ISimpleText): number {
@@ -407,6 +431,7 @@ module TypeScript {
}
export interface IModuleElementSyntax extends ISyntaxNode {
_moduleElementBrand: any;
}
export interface IStatementSyntax extends IModuleElementSyntax {
@@ -414,15 +439,28 @@ module TypeScript {
}
export interface ITypeMemberSyntax extends ISyntaxNode {
_typeMemberBrand: any;
}
export interface IClassElementSyntax extends ISyntaxNode {
_classElementBrand: any;
}
export interface IMemberDeclarationSyntax extends IClassElementSyntax {
_memberDeclarationBrand: any;
}
export interface IPropertyAssignmentSyntax extends IClassElementSyntax {
export interface IPropertyAssignmentSyntax extends ISyntaxNode {
_propertyAssignmentBrand: any;
}
export interface IAccessorSyntax extends IPropertyAssignmentSyntax, IMemberDeclarationSyntax {
_accessorBrand: any;
modifiers: ISyntaxToken[];
propertyName: ISyntaxToken;
callSignature: CallSignatureSyntax;
block: BlockSyntax;
}
export interface ISwitchClauseSyntax extends ISyntaxNode {
@@ -464,5 +502,6 @@ module TypeScript {
}
export interface INameSyntax extends ITypeSyntax {
_nameBrand: any;
}
}

171
src/services/syntax/syntaxGenerator.ts
View File

@@ -660,7 +660,7 @@ var definitions:ITypeDefinition[] = [
<any>{
name: 'GetAccessorSyntax',
baseType: 'ISyntaxNode',
interfaces: ['IMemberDeclarationSyntax', 'IPropertyAssignmentSyntax' ],
interfaces: ['IAccessorSyntax' ],
children: [
<any>{ name: 'modifiers', isList: true, elementType: 'ISyntaxToken', isTypeScriptSpecific: true },
<any>{ name: 'getKeyword', isToken: true, excludeFromAST: true },
@@ -672,7 +672,7 @@ var definitions:ITypeDefinition[] = [
<any>{
name: 'SetAccessorSyntax',
baseType: 'ISyntaxNode',
interfaces: ['IMemberDeclarationSyntax', 'IPropertyAssignmentSyntax'],
interfaces: ['IAccessorSyntax'],
children: [
<any>{ name: 'modifiers', isList: true, elementType: 'ISyntaxToken', isTypeScriptSpecific: true },
<any>{ name: 'setKeyword', isToken: true, excludeFromAST: true },
@@ -1055,54 +1055,6 @@ function getSafeName(child: IMemberDefinition) {
return child.name;
}
function generateBrands(definition: ITypeDefinition, accessibility: boolean): string {
var properties = "";
var types: string[] = [];
if (definition.interfaces) {
var ifaces = definition.interfaces.slice(0);
var i: number;
for (i = 0; i < ifaces.length; i++) {
var current = ifaces[i];
while (current !== undefined) {
if (!TypeScript.ArrayUtilities.contains(ifaces, current)) {
ifaces.push(current);
}
current = interfaces[current];
}
}
for (i = 0; i < ifaces.length; i++) {
var type = ifaces[i];
type = getStringWithoutSuffix(type);
if (isInterface(type)) {
type = "_" + type.substr(1, 1).toLowerCase() + type.substr(2) + "Brand";
}
types.push(type);
}
}
types.push("_syntaxNodeOrTokenBrand");
if (types.length > 0) {
properties += " ";
for (var i = 0; i < types.length; i++) {
if (accessibility) {
properties += " public ";
}
properties += types[i] + ": any;";
}
properties += "\r\n";
}
return properties;
}
function generateConstructorFunction(definition: ITypeDefinition) {
var result = " export var " + definition.name + ": " + getNameWithoutSuffix(definition) + "Constructor = <any>function(data: number";
@@ -1154,6 +1106,21 @@ function generateConstructorFunction(definition: ITypeDefinition) {
result += " };\r\n";
result += " " + definition.name + ".prototype.kind = SyntaxKind." + getNameWithoutSuffix(definition) + ";\r\n";
result += " " + definition.name + ".prototype.childCount = " + definition.children.length + ";\r\n";
result += " " + definition.name + ".prototype.childAt = function(index: number): ISyntaxElement {\r\n";
if (definition.children.length) {
result += " switch (index) {\r\n";
for (var j = 0; j < definition.children.length; j++) {
result += " case " + j + ": return this." + definition.children[j].name + ";\r\n";
}
result += " }\r\n";
}
else {
result += " throw Errors.invalidOperation();\r\n";
}
result += " }\r\n";
return result;
}
@@ -1520,114 +1487,11 @@ function generateVisitor(): string {
return result;
}
function generateServicesUtilities(): string {
var result = "";
result += "module TypeScript {\r\n";
result += " var childCountArray = [";
for (var i = 0, n = TypeScript.SyntaxKind.LastNode; i <= n; i++) {
if (i) {
result += ", ";
}
if (i <= TypeScript.SyntaxKind.LastToken) {
result += "0";
}
else {
var definition = TypeScript.ArrayUtilities.first(definitions, d => firstKind(d) === i);
result += definition.children.length;
}
}
result += "];\r\n\r\n";
result += " export function childCount(element: ISyntaxElement): number {\r\n";
result += " if (isList(element)) { return (<ISyntaxNodeOrToken[]>element).length; }\r\n";
result += " return childCountArray[element.kind];\r\n";
result += " }\r\n\r\n";
result += " var childAtArray: ((nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement)[] = [\r\n ";
for (var i = 0; i < TypeScript.SyntaxKind.FirstNode; i++) {
if (i) {
result += ", ";
}
result += "undefined";
}
for (var i = 0; i < definitions.length; i++) {
var definition = definitions[i];
result += ",\r\n"
result += " (node: " + definition.name + ", index: number): ISyntaxElement => {\r\n";
if (definition.children.length) {
result += " switch (index) {\r\n";
for (var j = 0; j < definition.children.length; j++) {
result += " case " + j + ": return node." + definition.children[j].name + ";\r\n";
}
result += " }\r\n";
}
else {
result += " throw Errors.invalidOperation();\r\n";
}
result += " }";
}
result += "\r\n ];\r\n";
//for (var i = 0; i < definitions.length; i++) {
// var definition = definitions[i];
// result += " function " + camelCase(getNameWithoutSuffix(definition)) + "ChildAt(node: " + definition.name + ", index: number): ISyntaxElement {\r\n";
// if (definition.children.length) {
// result += " switch (index) {\r\n";
// for (var j = 0; j < definition.children.length; j++) {
// result += " case " + j + ": return node." + definition.children[j].name + ";\r\n";
// }
// result += " }\r\n";
// }
// else {
// result += " throw Errors.invalidOperation();\r\n";
// }
// result += " }\r\n";
//}
result += " export function childAt(element: ISyntaxElement, index: number): ISyntaxElement {\r\n";
result += " if (isList(element)) { return (<ISyntaxNodeOrToken[]>element)[index]; }\r\n";
result += " return childAtArray[element.kind](element, index);\r\n";
//result += " switch (element.kind) {\r\n";
//for (var i = 0; i < definitions.length; i++) {
// var definition = definitions[i];
// result += " case SyntaxKind." + getNameWithoutSuffix(definition) + ": return " + camelCase(getNameWithoutSuffix(definition)) + "ChildAt(<" + definition.name + ">element, index);\r\n";
//}
//result += " }\r\n";
result += " }\r\n\r\n";
result += " export function getChildAtFunction(element: ISyntaxNodeOrToken): (nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement {\r\n";
result += " return childAtArray[element.kind];\r\n";
result += " }\r\n";
result += "}";
return result;
}
var syntaxNodesConcrete = generateNodes();
var syntaxInterfaces = generateSyntaxInterfaces();
var walker = generateWalker();
var scannerUtilities = generateScannerUtilities();
var visitor = generateVisitor();
var servicesUtilities = generateServicesUtilities();
var utilities = generateUtilities();
sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxNodes.concrete.generated.ts", syntaxNodesConcrete, false);
@@ -1635,5 +1499,4 @@ sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxInterf
sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxWalker.generated.ts", walker, false);
sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\scannerUtilities.generated.ts", scannerUtilities, false);
sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxVisitor.generated.ts", visitor, false);
sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxUtilities.generated.ts", servicesUtilities, false);
sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\utilities.generated.ts", utilities, false);

4
src/services/syntax/syntaxInterfaces.generated.ts
View File

@@ -182,7 +182,7 @@ module TypeScript {
}
export interface IndexMemberDeclarationConstructor { new (data: number, modifiers: ISyntaxToken[], indexSignature: IndexSignatureSyntax, semicolonToken: ISyntaxToken): IndexMemberDeclarationSyntax }
export interface GetAccessorSyntax extends ISyntaxNode, IMemberDeclarationSyntax, IPropertyAssignmentSyntax {
export interface GetAccessorSyntax extends ISyntaxNode, IAccessorSyntax {
modifiers: ISyntaxToken[];
getKeyword: ISyntaxToken;
propertyName: ISyntaxToken;
@@ -191,7 +191,7 @@ module TypeScript {
}
export interface GetAccessorConstructor { new (data: number, modifiers: ISyntaxToken[], getKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): GetAccessorSyntax }
export interface SetAccessorSyntax extends ISyntaxNode, IMemberDeclarationSyntax, IPropertyAssignmentSyntax {
export interface SetAccessorSyntax extends ISyntaxNode, IAccessorSyntax {
modifiers: ISyntaxToken[];
setKeyword: ISyntaxToken;
propertyName: ISyntaxToken;

3
src/services/syntax/syntaxNodeOrToken.ts
View File

@@ -2,6 +2,7 @@
module TypeScript {
export interface ISyntaxNodeOrToken extends ISyntaxElement {
_syntaxNodeOrTokenBrand: any;
childCount: number;
childAt(index: number): ISyntaxElement;
}
}

774
src/services/syntax/syntaxNodes.concrete.generated.ts
View File

File diff suppressed because it is too large Load Diff

17
src/services/syntax/syntaxToken.ts
View File

@@ -304,8 +304,9 @@ module TypeScript.Syntax {
}
class EmptyToken implements ISyntaxToken {
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _syntaxNodeOrTokenBrand: any;
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _nameBrand: any;
public parent: ISyntaxElement;
public childCount: number;
constructor(public kind: SyntaxKind) {
}
@@ -314,7 +315,6 @@ module TypeScript.Syntax {
// An empty token is always at the -1 position.
}
public childCount() { return 0 }
public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
@@ -415,16 +415,19 @@ module TypeScript.Syntax {
public leadingTrivia(): ISyntaxTriviaList { return Syntax.emptyTriviaList; }
public trailingTrivia(): ISyntaxTriviaList { return Syntax.emptyTriviaList; }
}
EmptyToken.prototype.childCount = 0;
class RealizedToken implements ISyntaxToken {
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _nameBrand: any;
private _fullStart: number;
private _isKeywordConvertedToIdentifier: boolean;
private _leadingTrivia: ISyntaxTriviaList;
private _text: string;
private _trailingTrivia: ISyntaxTriviaList;
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _syntaxNodeOrTokenBrand: any;
public parent: ISyntaxElement;
public childCount: number;
constructor(fullStart: number,
public kind: SyntaxKind,
@@ -452,7 +455,6 @@ module TypeScript.Syntax {
this._fullStart = fullStart;
}
public childCount() { return 0 }
public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
@@ -486,11 +488,14 @@ module TypeScript.Syntax {
public leadingTrivia(): ISyntaxTriviaList { return this._leadingTrivia; }
public trailingTrivia(): ISyntaxTriviaList { return this._trailingTrivia; }
}
RealizedToken.prototype.childCount = 0;
class ConvertedKeywordToken implements ISyntaxToken {
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _syntaxNodeOrTokenBrand: any;
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _nameBrand: any;
public parent: ISyntaxElement;
public kind: SyntaxKind;
public childCount: number;
constructor(private underlyingToken: ISyntaxToken) {
}
@@ -499,7 +504,6 @@ module TypeScript.Syntax {
this.underlyingToken.setFullStart(fullStart);
}
public childCount() { return 0 }
public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
@@ -582,4 +586,5 @@ module TypeScript.Syntax {
}
}
ConvertedKeywordToken.prototype.kind = SyntaxKind.IdentifierName;
ConvertedKeywordToken.prototype.childCount = 0;
}

703
src/services/syntax/syntaxUtilities.generated.ts
View File

@@ -1,703 +0,0 @@
module TypeScript {
var childCountArray = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 3, 4, 3, 5, 2, 2, 3, 3, 3, 6, 6, 7, 8, 6, 6, 4, 5, 3, 5, 3, 5, 5, 3, 3, 2, 4, 3, 3, 6, 3, 2, 3, 7, 3, 3, 10, 8, 1, 3, 5, 4, 3, 7, 2, 5, 2, 2, 2, 2, 5, 3, 2, 3, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 0, 2, 2, 2, 3, 4, 3, 3, 3, 2, 2, 4, 3, 2, 6, 2, 2, 2, 2, 3, 3, 6, 2, 2, 4, 1];
export function childCount(element: ISyntaxElement): number {
if (isList(element)) { return (<ISyntaxNodeOrToken[]>element).length; }
return childCountArray[element.kind];
}
var childAtArray: ((nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement)[] = [
undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined,
(node: SourceUnitSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.moduleElements;
case 1: return node.endOfFileToken;
}
},
(node: QualifiedNameSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.left;
case 1: return node.dotToken;
case 2: return node.right;
}
},
(node: ObjectTypeSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.openBraceToken;
case 1: return node.typeMembers;
case 2: return node.closeBraceToken;
}
},
(node: FunctionTypeSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.typeParameterList;
case 1: return node.parameterList;
case 2: return node.equalsGreaterThanToken;
case 3: return node.type;
}
},
(node: ArrayTypeSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.type;
case 1: return node.openBracketToken;
case 2: return node.closeBracketToken;
}
},
(node: ConstructorTypeSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.newKeyword;
case 1: return node.typeParameterList;
case 2: return node.parameterList;
case 3: return node.equalsGreaterThanToken;
case 4: return node.type;
}
},
(node: GenericTypeSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.name;
case 1: return node.typeArgumentList;
}
},
(node: TypeQuerySyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.typeOfKeyword;
case 1: return node.name;
}
},
(node: TupleTypeSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.openBracketToken;
case 1: return node.types;
case 2: return node.closeBracketToken;
}
},
(node: UnionTypeSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.left;
case 1: return node.barToken;
case 2: return node.right;
}
},
(node: ParenthesizedTypeSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.openParenToken;
case 1: return node.type;
case 2: return node.closeParenToken;
}
},
(node: InterfaceDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.interfaceKeyword;
case 2: return node.identifier;
case 3: return node.typeParameterList;
case 4: return node.heritageClauses;
case 5: return node.body;
}
},
(node: FunctionDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.functionKeyword;
case 2: return node.identifier;
case 3: return node.callSignature;
case 4: return node.block;
case 5: return node.semicolonToken;
}
},
(node: ModuleDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.moduleKeyword;
case 2: return node.name;
case 3: return node.stringLiteral;
case 4: return node.openBraceToken;
case 5: return node.moduleElements;
case 6: return node.closeBraceToken;
}
},
(node: ClassDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.classKeyword;
case 2: return node.identifier;
case 3: return node.typeParameterList;
case 4: return node.heritageClauses;
case 5: return node.openBraceToken;
case 6: return node.classElements;
case 7: return node.closeBraceToken;
}
},
(node: EnumDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.enumKeyword;
case 2: return node.identifier;
case 3: return node.openBraceToken;
case 4: return node.enumElements;
case 5: return node.closeBraceToken;
}
},
(node: ImportDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.importKeyword;
case 2: return node.identifier;
case 3: return node.equalsToken;
case 4: return node.moduleReference;
case 5: return node.semicolonToken;
}
},
(node: ExportAssignmentSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.exportKeyword;
case 1: return node.equalsToken;
case 2: return node.identifier;
case 3: return node.semicolonToken;
}
},
(node: MemberFunctionDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.propertyName;
case 2: return node.callSignature;
case 3: return node.block;
case 4: return node.semicolonToken;
}
},
(node: MemberVariableDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.variableDeclarator;
case 2: return node.semicolonToken;
}
},
(node: ConstructorDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.constructorKeyword;
case 2: return node.callSignature;
case 3: return node.block;
case 4: return node.semicolonToken;
}
},
(node: IndexMemberDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.indexSignature;
case 2: return node.semicolonToken;
}
},
(node: GetAccessorSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.getKeyword;
case 2: return node.propertyName;
case 3: return node.callSignature;
case 4: return node.block;
}
},
(node: SetAccessorSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.setKeyword;
case 2: return node.propertyName;
case 3: return node.callSignature;
case 4: return node.block;
}
},
(node: PropertySignatureSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.propertyName;
case 1: return node.questionToken;
case 2: return node.typeAnnotation;
}
},
(node: CallSignatureSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.typeParameterList;
case 1: return node.parameterList;
case 2: return node.typeAnnotation;
}
},
(node: ConstructSignatureSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.newKeyword;
case 1: return node.callSignature;
}
},
(node: IndexSignatureSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.openBracketToken;
case 1: return node.parameters;
case 2: return node.closeBracketToken;
case 3: return node.typeAnnotation;
}
},
(node: MethodSignatureSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.propertyName;
case 1: return node.questionToken;
case 2: return node.callSignature;
}
},
(node: BlockSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.openBraceToken;
case 1: return node.statements;
case 2: return node.closeBraceToken;
}
},
(node: IfStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.ifKeyword;
case 1: return node.openParenToken;
case 2: return node.condition;
case 3: return node.closeParenToken;
case 4: return node.statement;
case 5: return node.elseClause;
}
},
(node: VariableStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.modifiers;
case 1: return node.variableDeclaration;
case 2: return node.semicolonToken;
}
},
(node: ExpressionStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.expression;
case 1: return node.semicolonToken;
}
},
(node: ReturnStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.returnKeyword;
case 1: return node.expression;
case 2: return node.semicolonToken;
}
},
(node: SwitchStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.switchKeyword;
case 1: return node.openParenToken;
case 2: return node.expression;
case 3: return node.closeParenToken;
case 4: return node.openBraceToken;
case 5: return node.switchClauses;
case 6: return node.closeBraceToken;
}
},
(node: BreakStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.breakKeyword;
case 1: return node.identifier;
case 2: return node.semicolonToken;
}
},
(node: ContinueStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.continueKeyword;
case 1: return node.identifier;
case 2: return node.semicolonToken;
}
},
(node: ForStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.forKeyword;
case 1: return node.openParenToken;
case 2: return node.variableDeclaration;
case 3: return node.initializer;
case 4: return node.firstSemicolonToken;
case 5: return node.condition;
case 6: return node.secondSemicolonToken;
case 7: return node.incrementor;
case 8: return node.closeParenToken;
case 9: return node.statement;
}
},
(node: ForInStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.forKeyword;
case 1: return node.openParenToken;
case 2: return node.variableDeclaration;
case 3: return node.left;
case 4: return node.inKeyword;
case 5: return node.expression;
case 6: return node.closeParenToken;
case 7: return node.statement;
}
},
(node: EmptyStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.semicolonToken;
}
},
(node: ThrowStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.throwKeyword;
case 1: return node.expression;
case 2: return node.semicolonToken;
}
},
(node: WhileStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.whileKeyword;
case 1: return node.openParenToken;
case 2: return node.condition;
case 3: return node.closeParenToken;
case 4: return node.statement;
}
},
(node: TryStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.tryKeyword;
case 1: return node.block;
case 2: return node.catchClause;
case 3: return node.finallyClause;
}
},
(node: LabeledStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.identifier;
case 1: return node.colonToken;
case 2: return node.statement;
}
},
(node: DoStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.doKeyword;
case 1: return node.statement;
case 2: return node.whileKeyword;
case 3: return node.openParenToken;
case 4: return node.condition;
case 5: return node.closeParenToken;
case 6: return node.semicolonToken;
}
},
(node: DebuggerStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.debuggerKeyword;
case 1: return node.semicolonToken;
}
},
(node: WithStatementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.withKeyword;
case 1: return node.openParenToken;
case 2: return node.condition;
case 3: return node.closeParenToken;
case 4: return node.statement;
}
},
(node: PrefixUnaryExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.operatorToken;
case 1: return node.operand;
}
},
(node: DeleteExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.deleteKeyword;
case 1: return node.expression;
}
},
(node: TypeOfExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.typeOfKeyword;
case 1: return node.expression;
}
},
(node: VoidExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.voidKeyword;
case 1: return node.expression;
}
},
(node: ConditionalExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.condition;
case 1: return node.questionToken;
case 2: return node.whenTrue;
case 3: return node.colonToken;
case 4: return node.whenFalse;
}
},
(node: BinaryExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.left;
case 1: return node.operatorToken;
case 2: return node.right;
}
},
(node: PostfixUnaryExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.operand;
case 1: return node.operatorToken;
}
},
(node: MemberAccessExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.expression;
case 1: return node.dotToken;
case 2: return node.name;
}
},
(node: InvocationExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.expression;
case 1: return node.argumentList;
}
},
(node: ArrayLiteralExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.openBracketToken;
case 1: return node.expressions;
case 2: return node.closeBracketToken;
}
},
(node: ObjectLiteralExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.openBraceToken;
case 1: return node.propertyAssignments;
case 2: return node.closeBraceToken;
}
},
(node: ObjectCreationExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.newKeyword;
case 1: return node.expression;
case 2: return node.argumentList;
}
},
(node: ParenthesizedExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.openParenToken;
case 1: return node.expression;
case 2: return node.closeParenToken;
}
},
(node: ParenthesizedArrowFunctionExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.callSignature;
case 1: return node.equalsGreaterThanToken;
case 2: return node.block;
case 3: return node.expression;
}
},
(node: SimpleArrowFunctionExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.parameter;
case 1: return node.equalsGreaterThanToken;
case 2: return node.block;
case 3: return node.expression;
}
},
(node: CastExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.lessThanToken;
case 1: return node.type;
case 2: return node.greaterThanToken;
case 3: return node.expression;
}
},
(node: ElementAccessExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.expression;
case 1: return node.openBracketToken;
case 2: return node.argumentExpression;
case 3: return node.closeBracketToken;
}
},
(node: FunctionExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.functionKeyword;
case 1: return node.identifier;
case 2: return node.callSignature;
case 3: return node.block;
}
},
(node: OmittedExpressionSyntax, index: number): ISyntaxElement => {
throw Errors.invalidOperation();
},
(node: TemplateExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.templateStartToken;
case 1: return node.templateClauses;
}
},
(node: TemplateAccessExpressionSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.expression;
case 1: return node.templateExpression;
}
},
(node: VariableDeclarationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.varKeyword;
case 1: return node.variableDeclarators;
}
},
(node: VariableDeclaratorSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.propertyName;
case 1: return node.typeAnnotation;
case 2: return node.equalsValueClause;
}
},
(node: ArgumentListSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.typeArgumentList;
case 1: return node.openParenToken;
case 2: return node.arguments;
case 3: return node.closeParenToken;
}
},
(node: ParameterListSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.openParenToken;
case 1: return node.parameters;
case 2: return node.closeParenToken;
}
},
(node: TypeArgumentListSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.lessThanToken;
case 1: return node.typeArguments;
case 2: return node.greaterThanToken;
}
},
(node: TypeParameterListSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.lessThanToken;
case 1: return node.typeParameters;
case 2: return node.greaterThanToken;
}
},
(node: HeritageClauseSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.extendsOrImplementsKeyword;
case 1: return node.typeNames;
}
},
(node: EqualsValueClauseSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.equalsToken;
case 1: return node.value;
}
},
(node: CaseSwitchClauseSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.caseKeyword;
case 1: return node.expression;
case 2: return node.colonToken;
case 3: return node.statements;
}
},
(node: DefaultSwitchClauseSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.defaultKeyword;
case 1: return node.colonToken;
case 2: return node.statements;
}
},
(node: ElseClauseSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.elseKeyword;
case 1: return node.statement;
}
},
(node: CatchClauseSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.catchKeyword;
case 1: return node.openParenToken;
case 2: return node.identifier;
case 3: return node.typeAnnotation;
case 4: return node.closeParenToken;
case 5: return node.block;
}
},
(node: FinallyClauseSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.finallyKeyword;
case 1: return node.block;
}
},
(node: TemplateClauseSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.expression;
case 1: return node.templateMiddleOrEndToken;
}
},
(node: TypeParameterSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.identifier;
case 1: return node.constraint;
}
},
(node: ConstraintSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.extendsKeyword;
case 1: return node.typeOrExpression;
}
},
(node: SimplePropertyAssignmentSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.propertyName;
case 1: return node.colonToken;
case 2: return node.expression;
}
},
(node: FunctionPropertyAssignmentSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.propertyName;
case 1: return node.callSignature;
case 2: return node.block;
}
},
(node: ParameterSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.dotDotDotToken;
case 1: return node.modifiers;
case 2: return node.identifier;
case 3: return node.questionToken;
case 4: return node.typeAnnotation;
case 5: return node.equalsValueClause;
}
},
(node: EnumElementSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.propertyName;
case 1: return node.equalsValueClause;
}
},
(node: TypeAnnotationSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.colonToken;
case 1: return node.type;
}
},
(node: ExternalModuleReferenceSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.requireKeyword;
case 1: return node.openParenToken;
case 2: return node.stringLiteral;
case 3: return node.closeParenToken;
}
},
(node: ModuleNameModuleReferenceSyntax, index: number): ISyntaxElement => {
switch (index) {
case 0: return node.moduleName;
}
}
];
export function childAt(element: ISyntaxElement, index: number): ISyntaxElement {
if (isList(element)) { return (<ISyntaxNodeOrToken[]>element)[index]; }
return childAtArray[element.kind](element, index);
}
export function getChildAtFunction(element: ISyntaxNodeOrToken): (nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement {
return childAtArray[element.kind];
}
}

40
src/services/syntax/syntaxUtilities.ts
View File

@@ -1,8 +1,18 @@
///<reference path='references.ts' />
module TypeScript {
export class SyntaxUtilities {
public static isAnyFunctionExpressionOrDeclaration(ast: ISyntaxElement): boolean {
export function childCount(element: ISyntaxElement): number {
if (isList(element)) { return (<ISyntaxNodeOrToken[]>element).length; }
return (<ISyntaxNodeOrToken>element).childCount;
}
export function childAt(element: ISyntaxElement, index: number): ISyntaxElement {
if (isList(element)) { return (<ISyntaxNodeOrToken[]>element)[index]; }
return (<ISyntaxNodeOrToken>element).childAt(index);
}
export module SyntaxUtilities {
export function isAnyFunctionExpressionOrDeclaration(ast: ISyntaxElement): boolean {
switch (ast.kind) {
case SyntaxKind.SimpleArrowFunctionExpression:
case SyntaxKind.ParenthesizedArrowFunctionExpression:
@@ -19,7 +29,7 @@ module TypeScript {
return false;
}
public static isLastTokenOnLine(token: ISyntaxToken, text: ISimpleText): boolean {
export function isLastTokenOnLine(token: ISyntaxToken, text: ISimpleText): boolean {
var _nextToken = nextToken(token, text);
if (_nextToken === undefined) {
return true;
@@ -32,7 +42,7 @@ module TypeScript {
return tokenLine !== nextTokenLine;
}
public static isLeftHandSizeExpression(element: ISyntaxElement) {
export function isLeftHandSizeExpression(element: ISyntaxElement) {
if (element) {
switch (element.kind) {
case SyntaxKind.MemberAccessExpression:
@@ -60,7 +70,7 @@ module TypeScript {
return false;
}
public static isSwitchClause(element: ISyntaxElement) {
export function isSwitchClause(element: ISyntaxElement) {
if (element) {
switch (element.kind) {
case SyntaxKind.CaseSwitchClause:
@@ -72,7 +82,7 @@ module TypeScript {
return false;
}
public static isTypeMember(element: ISyntaxElement) {
export function isTypeMember(element: ISyntaxElement) {
if (element) {
switch (element.kind) {
case SyntaxKind.ConstructSignature:
@@ -87,7 +97,7 @@ module TypeScript {
return false;
}
public static isClassElement(element: ISyntaxElement) {
export function isClassElement(element: ISyntaxElement) {
if (element) {
switch (element.kind) {
case SyntaxKind.ConstructorDeclaration:
@@ -104,7 +114,7 @@ module TypeScript {
return false;
}
public static isModuleElement(element: ISyntaxElement) {
export function isModuleElement(element: ISyntaxElement) {
if (element) {
switch (element.kind) {
case SyntaxKind.ImportDeclaration:
@@ -141,7 +151,7 @@ module TypeScript {
return false;
}
public static isStatement(element: ISyntaxElement) {
export function isStatement(element: ISyntaxElement) {
if (element) {
switch (element.kind) {
case SyntaxKind.FunctionDeclaration:
@@ -170,7 +180,7 @@ module TypeScript {
return false;
}
public static isAngleBracket(positionedElement: ISyntaxElement): boolean {
export function isAngleBracket(positionedElement: ISyntaxElement): boolean {
var element = positionedElement;
var parent = positionedElement.parent;
if (parent && (element.kind === SyntaxKind.LessThanToken || element.kind === SyntaxKind.GreaterThanToken)) {
@@ -185,7 +195,7 @@ module TypeScript {
return false;
}
public static getToken(list: ISyntaxToken[], kind: SyntaxKind): ISyntaxToken {
export function getToken(list: ISyntaxToken[], kind: SyntaxKind): ISyntaxToken {
for (var i = 0, n = list.length; i < n; i++) {
var token = list[i];
if (token.kind === kind) {
@@ -196,15 +206,15 @@ module TypeScript {
return undefined;
}
public static containsToken(list: ISyntaxToken[], kind: SyntaxKind): boolean {
export function containsToken(list: ISyntaxToken[], kind: SyntaxKind): boolean {
return !!SyntaxUtilities.getToken(list, kind);
}
public static hasExportKeyword(moduleElement: IModuleElementSyntax): boolean {
export function hasExportKeyword(moduleElement: IModuleElementSyntax): boolean {
return !!SyntaxUtilities.getExportKeyword(moduleElement);
}
public static getExportKeyword(moduleElement: IModuleElementSyntax): ISyntaxToken {
export function getExportKeyword(moduleElement: IModuleElementSyntax): ISyntaxToken {
switch (moduleElement.kind) {
case SyntaxKind.ModuleDeclaration:
case SyntaxKind.ClassDeclaration:
@@ -219,7 +229,7 @@ module TypeScript {
}
}
public static isAmbientDeclarationSyntax(positionNode: ISyntaxNode): boolean {
export function isAmbientDeclarationSyntax(positionNode: ISyntaxNode): boolean {
if (!positionNode) {
return false;
}