microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-06 20:14:01 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Use a flat list for separated syntax lists.

Browse Source
This commit is contained in:
Cyrus Najmabadi 2014-11-01 16:02:39 -07:00
parent 3ed6b4f5f8
commit c4d6b7c22e
14 changed files with 517 additions and 829 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/services/formatting/indentationTrackingWalker.ts
View File

@ -103,7 +103,7 @@ module TypeScript.Services.Formatting {
if (isToken(element)) {
this.visitToken(<ISyntaxToken>element);
}
else if (element.kind() === SyntaxKind.List || element.kind() === SyntaxKind.SeparatedList) {
else if (element.kind() === SyntaxKind.List) {
for (var i = 0, n = element.childCount(); i < n; i++) {
this.walk(element.childAt(i));
}

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

File diff suppressed because it is too large Load Diff

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

@ -777,7 +777,7 @@ module TypeScript.IncrementalParser {
function moveToFirstChildIfList(): void {
var element = pieces[currentPieceIndex].element;
if (isList(element) || isSeparatedList(element)) {
if (isList(element)) {
// We cannot ever get an empty list in our piece path. Empty lists are 'shared' and
// we make sure to filter that out before pushing any children.
// Debug.assert(childCount(element) > 0);

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

@ -557,7 +557,7 @@ module TypeScript.Parser {
// when next requested.
while (true) {
// Parent must be a list or a node. All of those have a 'data' element.
Debug.assert(isNode(parent) || isList(parent) || isSeparatedList(parent));
Debug.assert(isNode(parent) || isList(parent));
var dataElement = <{ data: number }><any>parent;
if (dataElement.data) {
dataElement.data &= SyntaxConstants.NodeParsedInStrictModeMask
@ -592,20 +592,6 @@ module TypeScript.Parser {
}
}
}
else if (isSeparatedList(parent)) {
var list2 = <ISyntaxNodeOrToken[]>parent;
for (var i = 0, n = list2.childCount(); i < n; i++) {
if (list2.childAt(i) === oldToken) {
if (i % 2 === 0) {
list2[i / 2] = newToken;
}
else {
list2.separators[(i - 1) / 2] = newToken;
}
return;
}
}
}
throw Errors.invalidOperation();
}
@ -3786,7 +3772,7 @@ module TypeScript.Parser {
return result;
}
function parseSeparatedSyntaxList<T extends ISyntaxNodeOrToken>(currentListType: ListParsingState, skippedTokens: ISyntaxToken[]): T[] {
function parseSeparatedSyntaxList<T extends ISyntaxNodeOrToken>(currentListType: ListParsingState, skippedTokens: ISyntaxToken[]): ISeparatedSyntaxList<T> {
var savedListParsingState = listParsingState;
listParsingState |= (1 << currentListType);
@ -3799,7 +3785,7 @@ module TypeScript.Parser {
// Returns true if we should abort parsing.
function abortParsingListOrMoveToNextToken<T extends ISyntaxNodeOrToken>(
currentListType: ListParsingState, nodes: T[], separators: ISyntaxToken[], skippedTokens: ISyntaxToken[]): boolean {
currentListType: ListParsingState, nodeAndSeparators: ISyntaxNodeOrToken[], skippedTokens: ISyntaxToken[]): boolean {
// Ok. We're at a token that is not a terminator for the list and wasn't the start of
// an item in the list. Definitely report an error for this token.
reportUnexpectedTokenDiagnostic(currentListType);
@ -3819,30 +3805,27 @@ module TypeScript.Parser {
// Otherwise, if none of the lists we're in can capture this token, then we need to
// unilaterally skip it. Note: we've already reported an error above.
addSkippedTokenToList(nodes, separators, skippedTokens, consumeToken(currentToken()));
addSkippedTokenToList(nodeAndSeparators, skippedTokens, consumeToken(currentToken()));
// Continue parsing this list. Attach this token to whatever we've seen already.
return false;
}
function addSkippedTokenToList<T extends ISyntaxNodeOrToken>(
nodes: T[], separators: ISyntaxToken[], skippedTokens: ISyntaxToken[], skippedToken: ISyntaxToken): void {
function addSkippedTokenToList(
nodesAndSeparators: ISyntaxNodeOrToken[], skippedTokens: ISyntaxToken[], skippedToken: ISyntaxToken): void {
// Now, add this skipped token to the last item we successfully parsed in the list. Or
// add it to the list of skipped tokens if we haven't parsed anything. Our caller will
// have to deal with them.
//
// Note: we only bother doing this if we're creating a concrete syntax tree.
if (syntaxFactory.isConcrete) {
var length = nodes.length + (separators ? separators.length : 0);
var length = nodesAndSeparators.length;
for (var i = length - 1; i >= 0; i--) {
var array: ISyntaxNodeOrToken[] = separators && (i % 2 === 1) ? separators : nodes;
var arrayIndex = separators ? IntegerUtilities.integerDivide(i, 2) : i;
var item = array[arrayIndex];
var item = nodesAndSeparators[i];
var _lastToken = lastToken(item);
if (_lastToken && _lastToken.fullWidth() > 0) {
array[arrayIndex] = <T>addSkippedTokenAfterNodeOrToken(item, skippedToken);
nodesAndSeparators[i] = addSkippedTokenAfterNodeOrToken(item, skippedToken);
return;
}
}
@ -3895,7 +3878,7 @@ module TypeScript.Parser {
// List wasn't complete and we didn't get an item. Figure out if we should bail out
// or skip a token and continue.
var abort = abortParsingListOrMoveToNextToken(currentListType, items, /*separators:*/ undefined, skippedTokens);
var abort = abortParsingListOrMoveToNextToken(currentListType, items, skippedTokens);
if (abort) {
break;
}
@ -3914,9 +3897,8 @@ module TypeScript.Parser {
return result;
}
function parseSeparatedSyntaxListWorker<T extends ISyntaxNodeOrToken>(currentListType: ListParsingState, skippedTokens: ISyntaxToken[]): T[] {
var nodes: T[] = getArray();
var separators: ISyntaxToken[] = getArray();
function parseSeparatedSyntaxListWorker<T extends ISyntaxNodeOrToken>(currentListType: ListParsingState, skippedTokens: ISyntaxToken[]): ISeparatedSyntaxList<T> {
var nodesAndSeparators: ISyntaxNodeOrToken[] = getArray();
// Debug.assert(nodes.length === 0);
// Debug.assert(separators.length === 0);
@ -3934,7 +3916,7 @@ module TypeScript.Parser {
// continue parsing.
// Debug.assert(oldItemsCount % 2 === 0);
var succeeded = tryParseExpectedListItem(currentListType, inErrorRecovery, nodes, /*processItems:*/ undefined);
var succeeded = tryParseExpectedListItem(currentListType, inErrorRecovery, nodesAndSeparators, /*processItems:*/ undefined);
if (!succeeded) {
// We weren't able to parse out a list element.
@ -3948,7 +3930,7 @@ module TypeScript.Parser {
// List wasn't complete and we didn't get an item. Figure out if we should bail out
// or skip a token and continue.
var abort = abortParsingListOrMoveToNextToken(currentListType, nodes, separators, skippedTokens);
var abort = abortParsingListOrMoveToNextToken(currentListType, nodesAndSeparators, skippedTokens);
if (abort) {
break;
}
@ -3973,7 +3955,7 @@ module TypeScript.Parser {
var tokenKind = _currentToken.kind();
if (tokenKind === _separatorKind || tokenKind === SyntaxKind.CommaToken) {
// Consume the last separator and continue parsing list elements.
separators.push(consumeToken(_currentToken));
nodesAndSeparators.push(consumeToken(_currentToken));
continue;
}
@ -4001,7 +3983,7 @@ module TypeScript.Parser {
if (allowAutomaticSemicolonInsertion && canEatAutomaticSemicolon(/*allowWithoutNewline:*/ false)) {
var semicolonToken = eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false) || Syntax.emptyToken(SyntaxKind.SemicolonToken);
separators.push(semicolonToken);
nodesAndSeparators.push(semicolonToken);
// Debug.assert(items.length % 2 === 0);
continue;
}
@ -4011,7 +3993,7 @@ module TypeScript.Parser {
// This time mark that we're in error recovery mode though.
//
// Note: trying to eat this token will emit the appropriate diagnostic.
separators.push(eatToken(_separatorKind));
nodesAndSeparators.push(eatToken(_separatorKind));
// Now that we're in 'error recovery' mode we cantweak some parsing rules as
// appropriate. For example, if we have:
@ -4027,12 +4009,11 @@ module TypeScript.Parser {
inErrorRecovery = true;
}
var result = Syntax.separatedList<T>(nodes, separators);
var result = Syntax.separatedList<T>(nodesAndSeparators);
// Can't return if it has more then 0 elements. In that case, the list will have been
// copied into the SyntaxList.
returnZeroLengthArray(nodes);
returnZeroLengthArray(separators);
returnZeroLengthArray(nodesAndSeparators);
return result;
}

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

@ -8,7 +8,7 @@ module TypeScript {
// nodes don't have positions or parents.
export function isShared(element: ISyntaxElement): boolean {
var kind = element.kind();
return (kind === SyntaxKind.List || kind === SyntaxKind.SeparatedList) && (<ISyntaxNodeOrToken[]>element).length === 0;
return kind === SyntaxKind.List && (<ISyntaxNodeOrToken[]>element).length === 0;
}
export function syntaxTree(element: ISyntaxElement): SyntaxTree {
@ -225,10 +225,6 @@ module TypeScript {
return element && element.kind() === SyntaxKind.List;
}
export function isSeparatedList(element: ISyntaxElement): boolean {
return element && element.kind() === SyntaxKind.SeparatedList;
}
export function syntaxID(element: ISyntaxElement): number {
if (isShared(element)) {
throw Errors.invalidOperation("Should not use shared syntax element as a key.");
@ -350,7 +346,7 @@ module TypeScript {
}
function data(element: ISyntaxElement): number {
Debug.assert(isNode(element) || isList(element) || isSeparatedList(element));
Debug.assert(isNode(element) || isList(element));
// Lists and nodes all have a 'data' element.
var dataElement = <{ data: number }><any>element;

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

@ -1028,7 +1028,7 @@ function getType(child: IMemberDefinition): string {
return "ISyntaxToken";
}
else if (child.isSeparatedList) {
return child.elementType + "[]";
return "ISeparatedSyntaxList<" + child.elementType + ">";
}
else if (child.isList) {
return child.elementType + "[]";
@ -2180,12 +2180,12 @@ function generateRewriter(): string {
" return isToken(node) ? <ISyntaxNodeOrToken>this.visitToken(<ISyntaxToken>node) : this.visitNode(<ISyntaxNode>node);\r\n" +
" }\r\n" +
"\r\n" +
" public visitList<T extends ISyntaxNodeOrToken>(list: T[]): T[] {\r\n" +
" var newItems: T[] = undefined;\r\n" +
" public visitList<T extends ISyntaxNodeOrToken[]>(list: T): T {\r\n" +
" var newItems: T = undefined;\r\n" +
"\r\n" +
" for (var i = 0, n = list.length; i < n; i++) {\r\n" +
" var item = list[i];\r\n" +
" var newItem = <T>this.visitNodeOrToken(item);\r\n" +
" var newItem = this.visitNodeOrToken(item);\r\n" +
"\r\n" +
" if (item !== newItem && !newItems) {\r\n" +
" newItems = [];\r\n" +
@ -2200,31 +2200,9 @@ function generateRewriter(): string {
" }\r\n" +
"\r\n" +
" // Debug.assert(!newItems || newItems.length === childCount(list));\r\n" +
" return !newItems ? list : Syntax.list<T>(newItems);\r\n" +
" return !newItems ? list : <T>Syntax.list(newItems);\r\n" +
" }\r\n" +
"\r\n" +
" public visitSeparatedList<T extends ISyntaxNodeOrToken>(list: T[]): T[] {\r\n" +
" var newItems: ISyntaxNodeOrToken[] = undefined;\r\n" +
"\r\n" +
" for (var i = 0, n = childCount(list); i < n; i++) {\r\n" +
" var item = childAt(list, i);\r\n" +
" var newItem = isToken(item) ? <ISyntaxNodeOrToken>this.visitToken(<ISyntaxToken>item) : this.visitNode(<ISyntaxNode>item);\r\n" +
"\r\n" +
" if (item !== newItem && !newItems) {\r\n" +
" newItems = [];\r\n" +
" for (var j = 0; j < i; j++) {\r\n" +
" newItems.push(childAt(list, j));\r\n" +
" }\r\n" +
" }\r\n" +
"\r\n" +
" if (newItems) {\r\n" +
" newItems.push(newItem);\r\n" +
" }\r\n" +
" }\r\n" +
"\r\n" +
" // Debug.assert(newItems === undefined || newItems.length === childCount(list));\r\n" +
" return !newItems ? list : Syntax.separatedList<T>(newItems);\r\n" +
" }\r\n";
"\r\n"
for (var i = 0; i < definitions.length; i++) {
var definition = definitions[i];
@ -2256,12 +2234,9 @@ function generateRewriter(): string {
if (child.isToken) {
result += "this.visitToken(node." + child.name + ")";
}
else if (child.isList) {
else if (child.isList || child.isSeparatedList) {
result += "this.visitList(node." + child.name + ")";
}
else if (child.isSeparatedList) {
result += "this.visitSeparatedList(node." + child.name + ")";
}
else if (child.type === "SyntaxKind") {
result += "node.kind";
}
@ -2318,17 +2293,7 @@ function generateWalker(): string {
" list[i].accept(this);\r\n" +
" }\r\n" +
" }\r\n" +
"\r\n" +
" public visitSeparatedList(list: ISyntaxNodeOrToken[]): void {\r\n" +
" for (var i = 0, n = separatedListChildCount(list); i < n; i++) {\r\n" +
" if (i % 2 === 0) {\r\n" +
" list[i >> 1].accept(this);\r\n" +
" }\r\n" +
" else {\r\n" +
" this.visitToken(list.separators[i >> 1]);\r\n" +
" }\r\n" +
" }\r\n" +
" }\r\n";
"\r\n";
for (var i = 0; i < definitions.length; i++) {
var definition = definitions[i];
@ -2347,12 +2312,9 @@ function generateWalker(): string {
result += " this.visitToken(node." + child.name + ");\r\n";
}
}
else if (child.isList) {
else if (child.isList || child.isSeparatedList) {
result += " this.visitList(node." + child.name + ");\r\n";
}
else if (child.isSeparatedList) {
result += " this.visitSeparatedList(node." + child.name + ");\r\n";
}
else if (isNodeOrToken(child)) {
if (child.isOptional) {
result += " visitNodeOrToken(this, node." + child.name + ");\r\n";
@ -2721,15 +2683,6 @@ function generateIsTypeScriptSpecific(): string {
result += "module TypeScript {\r\n";
result += " function isSeparatedListTypeScriptSpecific(list: ISyntaxNodeOrToken[]): boolean {\r\n"
result += " for (var i = 0, n = list.childCount(); i < n; i++) {\r\n";
result += " if (isTypeScriptSpecific(list.childAt(i))) {\r\n";
result += " return true;\r\n";
result += " }\r\n";
result += " }\r\n\r\n";
result += " return false;\r\n";
result += " }\r\n\r\n";
result += " function isListTypeScriptSpecific(list: ISyntaxNodeOrToken[]): boolean {\r\n"
result += " for (var i = 0, n = list.length; i < n; i++) {\r\n";
result += " if (isTypeScriptSpecific(list[i])) {\r\n";
@ -2743,7 +2696,6 @@ function generateIsTypeScriptSpecific(): string {
result += " if (!element) { return false; }\r\n";
result += " if (isToken(element)) { return false; }\r\n";
result += " if (isList(element)) { return isListTypeScriptSpecific(<ISyntaxNodeOrToken[]>element); }\r\n";
result += " if (isSeparatedList(element)) { return isSeparatedListTypeScriptSpecific(<ISyntaxNodeOrToken[]>element); }\r\n\r\n";
result += " switch (element.kind()) {\r\n";
for (var i = 0; i < definitions.length; i++) {
@ -2850,12 +2802,9 @@ function generateIsTypeScriptSpecificMethod(definition: ITypeDefinition): string
addedCheck = true;
if (child.isTypeScriptSpecific) {
if (child.isList) {
if (child.isList || child.isSeparatedList) {
result += getPropertyAccess(child, "node") + ".length > 0";
}
else if (child.isSeparatedList) {
result += getPropertyAccess(child, "node") + ".childCount() > 0";
}
else {
result += "!!" + getPropertyAccess(child, "node");
}

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

@ -5,8 +5,6 @@ module TypeScript {
// Variable width tokens, trivia and lists.
None,
List,
SeparatedList,
TriviaList,
// Trivia
WhitespaceTrivia,

72
src/services/syntax/syntaxList.ts
View File

@ -2,34 +2,27 @@
interface Array<T> {
data: number;
separators?: TypeScript.ISyntaxToken[];
separatedListLength?: number;
kind(): TypeScript.SyntaxKind;
parent: TypeScript.ISyntaxElement;
separatorCount(): number;
separatorAt(index: number): TypeScript.ISyntaxToken;
childCount(): number;
childAt(index: number): TypeScript.ISyntaxNodeOrToken;
}
module TypeScript {
export function separatedListChildAt(list: ISyntaxNodeOrToken[], index: number) {
return index % 2 === 0 ? list[index >> 1] : list.separators[index >> 1];
export interface ISeparatedSyntaxList<T extends ISyntaxNodeOrToken> extends Array<ISyntaxNodeOrToken> {
separatorCount(): number;
separatorAt(index: number): TypeScript.ISyntaxToken;
nonSeparatorCount(): number;
nonSeparatorAt(index: number): T;
}
}
module TypeScript.Syntax {
var _emptyList: ISyntaxNodeOrToken[] = [];
var _emptySeparatedList: ISyntaxNodeOrToken[] = [];
var _emptySeparators: ISyntaxToken[] = [];
_emptySeparatedList.separators = _emptySeparators;
_emptySeparatedList.separatedListLength = 0;
function assertEmptyLists() {
// Debug.assert(_emptyList.length === 0);
// var separators = _emptySeparatedList.separators;
@ -46,41 +39,49 @@ module TypeScript.Syntax {
}
addArrayFunction("kind", function () {
return this.separators === undefined ? SyntaxKind.List : SyntaxKind.SeparatedList;
return SyntaxKind.List;
});
addArrayFunction("childCount", function (): number {
return this.separators ? this.separatedListLength : this.length;
return this.length;
});
addArrayFunction("childAt", function (index: number): ISyntaxNodeOrToken {
if (this.separators) {
return index % 2 === 0 ? this[index >> 1] : this.separators[index >> 1];
}
else {
return this[index];
}
return this[index];
});
addArrayFunction("separatorCount", function (): number {
assertEmptyLists();
// Debug.assert(this.kind === SyntaxKind.SeparatedList);
return this.separators.length;
return this.length >> 1;
});
addArrayFunction("nonSeparatorCount", function (): number {
assertEmptyLists();
// Debug.assert(this.kind === SyntaxKind.SeparatedList);
return (this.length + 1) >> 1;
});
addArrayFunction("separatorAt", function (index: number): ISyntaxToken {
assertEmptyLists();
// Debug.assert(this.kind === SyntaxKind.SeparatedList);
// Debug.assert(index >= 0 && index < this.separators.length);
return this.separators[index];
return this[(index << 1) + 1];
});
addArrayFunction("nonSeparatorAt", function (index: number): ISyntaxToken {
assertEmptyLists();
// Debug.assert(this.kind === SyntaxKind.SeparatedList);
// Debug.assert(index >= 0 && index < this.separators.length);
return this[index << 1];
});
export function emptyList<T extends ISyntaxNodeOrToken>(): T[] {
return <T[]><any>_emptyList;
return <T[]>_emptyList;
}
export function emptySeparatedList<T extends ISyntaxNodeOrToken>(): T[] {
return <T[]><any>_emptySeparatedList;
export function emptySeparatedList<T extends ISyntaxNodeOrToken>(): ISeparatedSyntaxList<T> {
return <ISeparatedSyntaxList<T>>_emptyList;
}
export function list<T extends ISyntaxNodeOrToken>(nodes: T[]): T[] {
@ -95,25 +96,18 @@ module TypeScript.Syntax {
return nodes;
}
export function separatedList<T extends ISyntaxNodeOrToken>(nodes: T[], separators: ISyntaxToken[]): T[] {
if (!nodes || nodes.length === 0) {
return emptySeparatedList<T>();
export function separatedList<T extends ISyntaxNodeOrToken>(nodesAndTokens: ISyntaxNodeOrToken[]): ISeparatedSyntaxList<T> {
if (!nodesAndTokens || nodesAndTokens.length === 0) {
return <ISeparatedSyntaxList<T>>emptyList<ISyntaxNodeOrToken>();
}
// Debug.assert(separators.length === nodes.length || separators.length == (nodes.length - 1));
for (var i = 0, n = nodes.length; i < n; i++) {
nodes[i].parent = nodes;
for (var i = 0, n = nodesAndTokens.length; i < n; i++) {
nodesAndTokens[i].parent = nodesAndTokens;
}
for (var i = 0, n = separators.length; i < n; i++) {
separators[i].parent = nodes;
}
nodes.separators = separators.length === 0 ? _emptySeparators : separators;
nodes.separatedListLength = nodes.length + separators.length;
return nodes;
return <ISeparatedSyntaxList<T>>nodesAndTokens;
}
export function nonSeparatorIndexOf<T extends ISyntaxNodeOrToken>(list: T[], ast: ISyntaxNodeOrToken): number {

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

@ -76,10 +76,10 @@ module TypeScript.Syntax.Concrete {
}
export class ObjectTypeSyntax extends SyntaxNode implements ITypeSyntax {
public openBraceToken: ISyntaxToken;
public typeMembers: ITypeMemberSyntax[];
public typeMembers: ISeparatedSyntaxList<ITypeMemberSyntax>;
public closeBraceToken: ISyntaxToken;
public _typeBrand: any;
constructor(data: number, openBraceToken: ISyntaxToken, typeMembers: ITypeMemberSyntax[], closeBraceToken: ISyntaxToken) {
constructor(data: number, openBraceToken: ISyntaxToken, typeMembers: ISeparatedSyntaxList<ITypeMemberSyntax>, closeBraceToken: ISyntaxToken) {
super(data);
this.openBraceToken = openBraceToken,
this.typeMembers = typeMembers,
@ -296,10 +296,10 @@ module TypeScript.Syntax.Concrete {
}
export class TupleTypeSyntax extends SyntaxNode implements ITypeSyntax {
public openBracketToken: ISyntaxToken;
public types: ITypeSyntax[];
public types: ISeparatedSyntaxList<ITypeSyntax>;
public closeBracketToken: ISyntaxToken;
public _typeBrand: any;
constructor(data: number, openBracketToken: ISyntaxToken, types: ITypeSyntax[], closeBracketToken: ISyntaxToken) {
constructor(data: number, openBracketToken: ISyntaxToken, types: ISeparatedSyntaxList<ITypeSyntax>, closeBracketToken: ISyntaxToken) {
super(data);
this.openBracketToken = openBracketToken,
this.types = types,
@ -611,10 +611,10 @@ module TypeScript.Syntax.Concrete {
public enumKeyword: ISyntaxToken;
public identifier: ISyntaxToken;
public openBraceToken: ISyntaxToken;
public enumElements: EnumElementSyntax[];
public enumElements: ISeparatedSyntaxList<EnumElementSyntax>;
public closeBraceToken: ISyntaxToken;
public _moduleElementBrand: any;
constructor(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: EnumElementSyntax[], closeBraceToken: ISyntaxToken) {
constructor(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: ISeparatedSyntaxList<EnumElementSyntax>, closeBraceToken: ISyntaxToken) {
super(data);
this.modifiers = modifiers,
this.enumKeyword = enumKeyword,
@ -1096,11 +1096,11 @@ module TypeScript.Syntax.Concrete {
}
export class IndexSignatureSyntax extends SyntaxNode implements ITypeMemberSyntax {
public openBracketToken: ISyntaxToken;
public parameters: ParameterSyntax[];
public parameters: ISeparatedSyntaxList<ParameterSyntax>;
public closeBracketToken: ISyntaxToken;
public typeAnnotation: TypeAnnotationSyntax;
public _typeMemberBrand: any;
constructor(data: number, openBracketToken: ISyntaxToken, parameters: ParameterSyntax[], closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) {
constructor(data: number, openBracketToken: ISyntaxToken, parameters: ISeparatedSyntaxList<ParameterSyntax>, closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) {
super(data);
this.openBracketToken = openBracketToken,
this.parameters = parameters,
@ -2224,10 +2224,10 @@ module TypeScript.Syntax.Concrete {
}
export class ArrayLiteralExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
public openBracketToken: ISyntaxToken;
public expressions: IExpressionSyntax[];
public expressions: ISeparatedSyntaxList<IExpressionSyntax>;
public closeBracketToken: ISyntaxToken;
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
constructor(data: number, openBracketToken: ISyntaxToken, expressions: IExpressionSyntax[], closeBracketToken: ISyntaxToken) {
constructor(data: number, openBracketToken: ISyntaxToken, expressions: ISeparatedSyntaxList<IExpressionSyntax>, closeBracketToken: ISyntaxToken) {
super(data);
this.openBracketToken = openBracketToken,
this.expressions = expressions,
@ -2260,10 +2260,10 @@ module TypeScript.Syntax.Concrete {
}
export class ObjectLiteralExpressionSyntax extends SyntaxNode implements IPrimaryExpressionSyntax {
public openBraceToken: ISyntaxToken;
public propertyAssignments: IPropertyAssignmentSyntax[];
public propertyAssignments: ISeparatedSyntaxList<IPropertyAssignmentSyntax>;
public closeBraceToken: ISyntaxToken;
public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any;
constructor(data: number, openBraceToken: ISyntaxToken, propertyAssignments: IPropertyAssignmentSyntax[], closeBraceToken: ISyntaxToken) {
constructor(data: number, openBraceToken: ISyntaxToken, propertyAssignments: ISeparatedSyntaxList<IPropertyAssignmentSyntax>, closeBraceToken: ISyntaxToken) {
super(data);
this.openBraceToken = openBraceToken,
this.propertyAssignments = propertyAssignments,
@ -2590,8 +2590,8 @@ module TypeScript.Syntax.Concrete {
}
export class VariableDeclarationSyntax extends SyntaxNode {
public varKeyword: ISyntaxToken;
public variableDeclarators: VariableDeclaratorSyntax[];
constructor(data: number, varKeyword: ISyntaxToken, variableDeclarators: VariableDeclaratorSyntax[]) {
public variableDeclarators: ISeparatedSyntaxList<VariableDeclaratorSyntax>;
constructor(data: number, varKeyword: ISyntaxToken, variableDeclarators: ISeparatedSyntaxList<VariableDeclaratorSyntax>) {
super(data);
this.varKeyword = varKeyword,
this.variableDeclarators = variableDeclarators,
@ -2657,9 +2657,9 @@ module TypeScript.Syntax.Concrete {
export class ArgumentListSyntax extends SyntaxNode {
public typeArgumentList: TypeArgumentListSyntax;
public openParenToken: ISyntaxToken;
public arguments: IExpressionSyntax[];
public arguments: ISeparatedSyntaxList<IExpressionSyntax>;
public closeParenToken: ISyntaxToken;
constructor(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, _arguments: IExpressionSyntax[], closeParenToken: ISyntaxToken) {
constructor(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, _arguments: ISeparatedSyntaxList<IExpressionSyntax>, closeParenToken: ISyntaxToken) {
super(data);
this.typeArgumentList = typeArgumentList,
this.openParenToken = openParenToken,
@ -2695,9 +2695,9 @@ module TypeScript.Syntax.Concrete {
}
export class ParameterListSyntax extends SyntaxNode {
public openParenToken: ISyntaxToken;
public parameters: ParameterSyntax[];
public parameters: ISeparatedSyntaxList<ParameterSyntax>;
public closeParenToken: ISyntaxToken;
constructor(data: number, openParenToken: ISyntaxToken, parameters: ParameterSyntax[], closeParenToken: ISyntaxToken) {
constructor(data: number, openParenToken: ISyntaxToken, parameters: ISeparatedSyntaxList<ParameterSyntax>, closeParenToken: ISyntaxToken) {
super(data);
this.openParenToken = openParenToken,
this.parameters = parameters,
@ -2730,9 +2730,9 @@ module TypeScript.Syntax.Concrete {
}
export class TypeArgumentListSyntax extends SyntaxNode {
public lessThanToken: ISyntaxToken;
public typeArguments: ITypeSyntax[];
public typeArguments: ISeparatedSyntaxList<ITypeSyntax>;
public greaterThanToken: ISyntaxToken;
constructor(data: number, lessThanToken: ISyntaxToken, typeArguments: ITypeSyntax[], greaterThanToken: ISyntaxToken) {
constructor(data: number, lessThanToken: ISyntaxToken, typeArguments: ISeparatedSyntaxList<ITypeSyntax>, greaterThanToken: ISyntaxToken) {
super(data);
this.lessThanToken = lessThanToken,
this.typeArguments = typeArguments,
@ -2765,9 +2765,9 @@ module TypeScript.Syntax.Concrete {
}
export class TypeParameterListSyntax extends SyntaxNode {
public lessThanToken: ISyntaxToken;
public typeParameters: TypeParameterSyntax[];
public typeParameters: ISeparatedSyntaxList<TypeParameterSyntax>;
public greaterThanToken: ISyntaxToken;
constructor(data: number, lessThanToken: ISyntaxToken, typeParameters: TypeParameterSyntax[], greaterThanToken: ISyntaxToken) {
constructor(data: number, lessThanToken: ISyntaxToken, typeParameters: ISeparatedSyntaxList<TypeParameterSyntax>, greaterThanToken: ISyntaxToken) {
super(data);
this.lessThanToken = lessThanToken,
this.typeParameters = typeParameters,
@ -2800,8 +2800,8 @@ module TypeScript.Syntax.Concrete {
}
export class HeritageClauseSyntax extends SyntaxNode {
public extendsOrImplementsKeyword: ISyntaxToken;
public typeNames: INameSyntax[];
constructor(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: INameSyntax[]) {
public typeNames: ISeparatedSyntaxList<INameSyntax>;
constructor(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: ISeparatedSyntaxList<INameSyntax>) {
super(data);
this.extendsOrImplementsKeyword = extendsOrImplementsKeyword,
this.typeNames = typeNames,

48
src/services/syntax/syntaxNodes.interfaces.generated.ts
View File

@ -13,7 +13,7 @@ module TypeScript {
}
export interface ObjectTypeSyntax extends ISyntaxNode, ITypeSyntax {
openBraceToken: ISyntaxToken;
typeMembers: ITypeMemberSyntax[];
typeMembers: ISeparatedSyntaxList<ITypeMemberSyntax>;
closeBraceToken: ISyntaxToken;
}
export interface FunctionTypeSyntax extends ISyntaxNode, ITypeSyntax {
@ -44,7 +44,7 @@ module TypeScript {
}
export interface TupleTypeSyntax extends ISyntaxNode, ITypeSyntax {
openBracketToken: ISyntaxToken;
types: ITypeSyntax[];
types: ISeparatedSyntaxList<ITypeSyntax>;
closeBracketToken: ISyntaxToken;
}
export interface UnionTypeSyntax extends ISyntaxNode, ITypeSyntax {
@ -97,7 +97,7 @@ module TypeScript {
enumKeyword: ISyntaxToken;
identifier: ISyntaxToken;
openBraceToken: ISyntaxToken;
enumElements: EnumElementSyntax[];
enumElements: ISeparatedSyntaxList<EnumElementSyntax>;
closeBraceToken: ISyntaxToken;
}
export interface ImportDeclarationSyntax extends ISyntaxNode, IModuleElementSyntax {
@ -168,7 +168,7 @@ module TypeScript {
}
export interface IndexSignatureSyntax extends ISyntaxNode, ITypeMemberSyntax {
openBracketToken: ISyntaxToken;
parameters: ParameterSyntax[];
parameters: ISeparatedSyntaxList<ParameterSyntax>;
closeBracketToken: ISyntaxToken;
typeAnnotation: TypeAnnotationSyntax;
}
@ -334,12 +334,12 @@ module TypeScript {
}
export interface ArrayLiteralExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax {
openBracketToken: ISyntaxToken;
expressions: IExpressionSyntax[];
expressions: ISeparatedSyntaxList<IExpressionSyntax>;
closeBracketToken: ISyntaxToken;
}
export interface ObjectLiteralExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax {
openBraceToken: ISyntaxToken;
propertyAssignments: IPropertyAssignmentSyntax[];
propertyAssignments: ISeparatedSyntaxList<IPropertyAssignmentSyntax>;
closeBraceToken: ISyntaxToken;
}
export interface ObjectCreationExpressionSyntax extends ISyntaxNode, IPrimaryExpressionSyntax {
@ -386,7 +386,7 @@ module TypeScript {
}
export interface VariableDeclarationSyntax extends ISyntaxNode {
varKeyword: ISyntaxToken;
variableDeclarators: VariableDeclaratorSyntax[];
variableDeclarators: ISeparatedSyntaxList<VariableDeclaratorSyntax>;
}
export interface VariableDeclaratorSyntax extends ISyntaxNode {
propertyName: ISyntaxToken;
@ -396,27 +396,27 @@ module TypeScript {
export interface ArgumentListSyntax extends ISyntaxNode {
typeArgumentList: TypeArgumentListSyntax;
openParenToken: ISyntaxToken;
arguments: IExpressionSyntax[];
arguments: ISeparatedSyntaxList<IExpressionSyntax>;
closeParenToken: ISyntaxToken;
}
export interface ParameterListSyntax extends ISyntaxNode {
openParenToken: ISyntaxToken;
parameters: ParameterSyntax[];
parameters: ISeparatedSyntaxList<ParameterSyntax>;
closeParenToken: ISyntaxToken;
}
export interface TypeArgumentListSyntax extends ISyntaxNode {
lessThanToken: ISyntaxToken;
typeArguments: ITypeSyntax[];
typeArguments: ISeparatedSyntaxList<ITypeSyntax>;
greaterThanToken: ISyntaxToken;
}
export interface TypeParameterListSyntax extends ISyntaxNode {
lessThanToken: ISyntaxToken;
typeParameters: TypeParameterSyntax[];
typeParameters: ISeparatedSyntaxList<TypeParameterSyntax>;
greaterThanToken: ISyntaxToken;
}
export interface HeritageClauseSyntax extends ISyntaxNode {
extendsOrImplementsKeyword: ISyntaxToken;
typeNames: INameSyntax[];
typeNames: ISeparatedSyntaxList<INameSyntax>;
}
export interface EqualsValueClauseSyntax extends ISyntaxNode {
equalsToken: ISyntaxToken;
@ -498,20 +498,20 @@ module TypeScript {
isConcrete: boolean;
SourceUnitSyntax: { new(data: number, moduleElements: IModuleElementSyntax[], endOfFileToken: ISyntaxToken): SourceUnitSyntax };
QualifiedNameSyntax: { new(data: number, left: INameSyntax, dotToken: ISyntaxToken, right: ISyntaxToken): QualifiedNameSyntax };
ObjectTypeSyntax: { new(data: number, openBraceToken: ISyntaxToken, typeMembers: ITypeMemberSyntax[], closeBraceToken: ISyntaxToken): ObjectTypeSyntax };
ObjectTypeSyntax: { new(data: number, openBraceToken: ISyntaxToken, typeMembers: ISeparatedSyntaxList<ITypeMemberSyntax>, closeBraceToken: ISyntaxToken): ObjectTypeSyntax };
FunctionTypeSyntax: { new(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax): FunctionTypeSyntax };
ArrayTypeSyntax: { new(data: number, type: ITypeSyntax, openBracketToken: ISyntaxToken, closeBracketToken: ISyntaxToken): ArrayTypeSyntax };
ConstructorTypeSyntax: { new(data: number, newKeyword: ISyntaxToken, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax): ConstructorTypeSyntax };
GenericTypeSyntax: { new(data: number, name: INameSyntax, typeArgumentList: TypeArgumentListSyntax): GenericTypeSyntax };
TypeQuerySyntax: { new(data: number, typeOfKeyword: ISyntaxToken, name: INameSyntax): TypeQuerySyntax };
TupleTypeSyntax: { new(data: number, openBracketToken: ISyntaxToken, types: ITypeSyntax[], closeBracketToken: ISyntaxToken): TupleTypeSyntax };
TupleTypeSyntax: { new(data: number, openBracketToken: ISyntaxToken, types: ISeparatedSyntaxList<ITypeSyntax>, closeBracketToken: ISyntaxToken): TupleTypeSyntax };
UnionTypeSyntax: { new(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax): UnionTypeSyntax };
ParenthesizedTypeSyntax: { new(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken): ParenthesizedTypeSyntax };
InterfaceDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], interfaceKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], body: ObjectTypeSyntax): InterfaceDeclarationSyntax };
FunctionDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): FunctionDeclarationSyntax };
ModuleDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], moduleKeyword: ISyntaxToken, name: INameSyntax, stringLiteral: ISyntaxToken, openBraceToken: ISyntaxToken, moduleElements: IModuleElementSyntax[], closeBraceToken: ISyntaxToken): ModuleDeclarationSyntax };
ClassDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], classKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], openBraceToken: ISyntaxToken, classElements: IClassElementSyntax[], closeBraceToken: ISyntaxToken): ClassDeclarationSyntax };
EnumDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: EnumElementSyntax[], closeBraceToken: ISyntaxToken): EnumDeclarationSyntax };
EnumDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: ISeparatedSyntaxList<EnumElementSyntax>, closeBraceToken: ISyntaxToken): EnumDeclarationSyntax };
ImportDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], importKeyword: ISyntaxToken, identifier: ISyntaxToken, equalsToken: ISyntaxToken, moduleReference: IModuleReferenceSyntax, semicolonToken: ISyntaxToken): ImportDeclarationSyntax };
ExportAssignmentSyntax: { new(data: number, exportKeyword: ISyntaxToken, equalsToken: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken): ExportAssignmentSyntax };
MemberFunctionDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): MemberFunctionDeclarationSyntax };
@ -523,7 +523,7 @@ module TypeScript {
PropertySignatureSyntax: { new(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax): PropertySignatureSyntax };
CallSignatureSyntax: { new(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, typeAnnotation: TypeAnnotationSyntax): CallSignatureSyntax };
ConstructSignatureSyntax: { new(data: number, newKeyword: ISyntaxToken, callSignature: CallSignatureSyntax): ConstructSignatureSyntax };
IndexSignatureSyntax: { new(data: number, openBracketToken: ISyntaxToken, parameters: ParameterSyntax[], closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax): IndexSignatureSyntax };
IndexSignatureSyntax: { new(data: number, openBracketToken: ISyntaxToken, parameters: ISeparatedSyntaxList<ParameterSyntax>, closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax): IndexSignatureSyntax };
MethodSignatureSyntax: { new(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, callSignature: CallSignatureSyntax): MethodSignatureSyntax };
BlockSyntax: { new(data: number, openBraceToken: ISyntaxToken, statements: IStatementSyntax[], closeBraceToken: ISyntaxToken): BlockSyntax };
IfStatementSyntax: { new(data: number, ifKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax, elseClause: ElseClauseSyntax): IfStatementSyntax };
@ -552,8 +552,8 @@ module TypeScript {
PostfixUnaryExpressionSyntax: { new(data: number, operand: ILeftHandSideExpressionSyntax, operatorToken: ISyntaxToken): PostfixUnaryExpressionSyntax };
MemberAccessExpressionSyntax: { new(data: number, expression: ILeftHandSideExpressionSyntax, dotToken: ISyntaxToken, name: ISyntaxToken): MemberAccessExpressionSyntax };
InvocationExpressionSyntax: { new(data: number, expression: ILeftHandSideExpressionSyntax, argumentList: ArgumentListSyntax): InvocationExpressionSyntax };
ArrayLiteralExpressionSyntax: { new(data: number, openBracketToken: ISyntaxToken, expressions: IExpressionSyntax[], closeBracketToken: ISyntaxToken): ArrayLiteralExpressionSyntax };
ObjectLiteralExpressionSyntax: { new(data: number, openBraceToken: ISyntaxToken, propertyAssignments: IPropertyAssignmentSyntax[], closeBraceToken: ISyntaxToken): ObjectLiteralExpressionSyntax };
ArrayLiteralExpressionSyntax: { new(data: number, openBracketToken: ISyntaxToken, expressions: ISeparatedSyntaxList<IExpressionSyntax>, closeBracketToken: ISyntaxToken): ArrayLiteralExpressionSyntax };
ObjectLiteralExpressionSyntax: { new(data: number, openBraceToken: ISyntaxToken, propertyAssignments: ISeparatedSyntaxList<IPropertyAssignmentSyntax>, closeBraceToken: ISyntaxToken): ObjectLiteralExpressionSyntax };
ObjectCreationExpressionSyntax: { new(data: number, newKeyword: ISyntaxToken, expression: IMemberExpressionSyntax, argumentList: ArgumentListSyntax): ObjectCreationExpressionSyntax };
ParenthesizedExpressionSyntax: { new(data: number, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken): ParenthesizedExpressionSyntax };
ParenthesizedArrowFunctionExpressionSyntax: { new(data: number, callSignature: CallSignatureSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax): ParenthesizedArrowFunctionExpressionSyntax };
@ -562,13 +562,13 @@ module TypeScript {
ElementAccessExpressionSyntax: { new(data: number, expression: ILeftHandSideExpressionSyntax, openBracketToken: ISyntaxToken, argumentExpression: IExpressionSyntax, closeBracketToken: ISyntaxToken): ElementAccessExpressionSyntax };
FunctionExpressionSyntax: { new(data: number, functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): FunctionExpressionSyntax };
OmittedExpressionSyntax: { new(data: number): OmittedExpressionSyntax };
VariableDeclarationSyntax: { new(data: number, varKeyword: ISyntaxToken, variableDeclarators: VariableDeclaratorSyntax[]): VariableDeclarationSyntax };
VariableDeclarationSyntax: { new(data: number, varKeyword: ISyntaxToken, variableDeclarators: ISeparatedSyntaxList<VariableDeclaratorSyntax>): VariableDeclarationSyntax };
VariableDeclaratorSyntax: { new(data: number, propertyName: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax): VariableDeclaratorSyntax };
ArgumentListSyntax: { new(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, arguments: IExpressionSyntax[], closeParenToken: ISyntaxToken): ArgumentListSyntax };
ParameterListSyntax: { new(data: number, openParenToken: ISyntaxToken, parameters: ParameterSyntax[], closeParenToken: ISyntaxToken): ParameterListSyntax };
TypeArgumentListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeArguments: ITypeSyntax[], greaterThanToken: ISyntaxToken): TypeArgumentListSyntax };
TypeParameterListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeParameters: TypeParameterSyntax[], greaterThanToken: ISyntaxToken): TypeParameterListSyntax };
HeritageClauseSyntax: { new(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: INameSyntax[]): HeritageClauseSyntax };
ArgumentListSyntax: { new(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, arguments: ISeparatedSyntaxList<IExpressionSyntax>, closeParenToken: ISyntaxToken): ArgumentListSyntax };
ParameterListSyntax: { new(data: number, openParenToken: ISyntaxToken, parameters: ISeparatedSyntaxList<ParameterSyntax>, closeParenToken: ISyntaxToken): ParameterListSyntax };
TypeArgumentListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeArguments: ISeparatedSyntaxList<ITypeSyntax>, greaterThanToken: ISyntaxToken): TypeArgumentListSyntax };
TypeParameterListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeParameters: ISeparatedSyntaxList<TypeParameterSyntax>, greaterThanToken: ISyntaxToken): TypeParameterListSyntax };
HeritageClauseSyntax: { new(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: ISeparatedSyntaxList<INameSyntax>): HeritageClauseSyntax };
EqualsValueClauseSyntax: { new(data: number, equalsToken: ISyntaxToken, value: IExpressionSyntax): EqualsValueClauseSyntax };
CaseSwitchClauseSyntax: { new(data: number, caseKeyword: ISyntaxToken, expression: IExpressionSyntax, colonToken: ISyntaxToken, statements: IStatementSyntax[]): CaseSwitchClauseSyntax };
DefaultSwitchClauseSyntax: { new(data: number, defaultKeyword: ISyntaxToken, colonToken: ISyntaxToken, statements: IStatementSyntax[]): DefaultSwitchClauseSyntax };

16
src/services/syntax/syntaxTree.ts
View File

@ -169,10 +169,10 @@ module TypeScript {
private checkParameterListOrder(node: ParameterListSyntax): boolean {
var seenOptionalParameter = false;
var parameterCount = node.parameters.length;
var parameterCount = node.parameters.nonSeparatorCount();
for (var i = 0; i < parameterCount; i++) {
var parameter = node.parameters[i];
var parameter = node.parameters.nonSeparatorAt(i);
if (parameter.dotDotDotToken) {
if (i !== (parameterCount - 1)) {
@ -210,8 +210,8 @@ module TypeScript {
}
private checkParameterListAcessibilityModifiers(node: ParameterListSyntax): boolean {
for (var i = 0, n = node.parameters.length; i < n; i++) {
var parameter = node.parameters[i];
for (var i = 0, n = node.parameters.nonSeparatorCount(); i < n; i++) {
var parameter = node.parameters.nonSeparatorAt(i);
if (this.checkParameterAccessibilityModifiers(node, parameter)) {
return true;
@ -344,7 +344,7 @@ module TypeScript {
return true;
}
var parameter = node.parameters[0];
var parameter = node.parameters.nonSeparatorAt(0);
if (parameter.dotDotDotToken) {
this.pushDiagnostic(parameter, DiagnosticCode.Index_signatures_cannot_have_rest_parameters);
@ -407,7 +407,7 @@ module TypeScript {
return true;
}
if (heritageClause.typeNames.length > 1) {
if (heritageClause.typeNames.nonSeparatorCount() > 1) {
this.pushDiagnostic(heritageClause, DiagnosticCode.Classes_can_only_extend_a_single_class);
return true;
}
@ -654,12 +654,12 @@ module TypeScript {
private checkSetAccessorParameter(node: SetAccessorSyntax): boolean {
var parameters = node.callSignature.parameterList.parameters;
if (parameters.childCount() !== 1) {
if (parameters.nonSeparatorCount() !== 1) {
this.pushDiagnostic(node.propertyName, DiagnosticCode.set_accessor_must_have_exactly_one_parameter);
return true;
}
var parameter = parameters[0];
var parameter = parameters.nonSeparatorAt(0);
if (parameter.questionToken) {
this.pushDiagnostic(parameter, DiagnosticCode.set_accessor_parameter_cannot_be_optional);

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

@ -28,10 +28,6 @@ module TypeScript {
module TypeScript.Syntax {
class EmptyTriviaList implements ISyntaxTriviaList {
public kind() {
return SyntaxKind.TriviaList;
}
public isShared(): boolean {
return true;
}
@ -91,10 +87,6 @@ module TypeScript.Syntax {
this.item.parent = this;
}
public kind() {
return SyntaxKind.TriviaList;
}
public isShared(): boolean {
return false;
}
@ -155,10 +147,6 @@ module TypeScript.Syntax {
});
}
public kind() {
return SyntaxKind.TriviaList;
}
public isShared(): boolean {
return false;
}

34
src/services/syntax/syntaxWalker.generated.ts
View File

@ -27,16 +27,6 @@ module TypeScript {
}
}
public visitSeparatedList(list: ISyntaxNodeOrToken[]): void {
for (var i = 0, n = list.separatedListLength; i < n; i++) {
if (i % 2 === 0) {
list[i >> 1].accept(this);
}
else {
this.visitToken(list.separators[i >> 1]);
}
}
}
public visitSourceUnit(node: SourceUnitSyntax): void {
this.visitList(node.moduleElements);
@ -51,7 +41,7 @@ module TypeScript {
public visitObjectType(node: ObjectTypeSyntax): void {
this.visitToken(node.openBraceToken);
this.visitSeparatedList(node.typeMembers);
this.visitList(node.typeMembers);
this.visitToken(node.closeBraceToken);
}
@ -88,7 +78,7 @@ module TypeScript {
public visitTupleType(node: TupleTypeSyntax): void {
this.visitToken(node.openBracketToken);
this.visitSeparatedList(node.types);
this.visitList(node.types);
this.visitToken(node.closeBracketToken);
}
@ -148,7 +138,7 @@ module TypeScript {
this.visitToken(node.enumKeyword);
this.visitToken(node.identifier);
this.visitToken(node.openBraceToken);
this.visitSeparatedList(node.enumElements);
this.visitList(node.enumElements);
this.visitToken(node.closeBraceToken);
}
@ -231,7 +221,7 @@ module TypeScript {
public visitIndexSignature(node: IndexSignatureSyntax): void {
this.visitToken(node.openBracketToken);
this.visitSeparatedList(node.parameters);
this.visitList(node.parameters);
this.visitToken(node.closeBracketToken);
this.visitOptionalNode(node.typeAnnotation);
}
@ -426,13 +416,13 @@ module TypeScript {
public visitArrayLiteralExpression(node: ArrayLiteralExpressionSyntax): void {
this.visitToken(node.openBracketToken);
this.visitSeparatedList(node.expressions);
this.visitList(node.expressions);
this.visitToken(node.closeBracketToken);
}
public visitObjectLiteralExpression(node: ObjectLiteralExpressionSyntax): void {
this.visitToken(node.openBraceToken);
this.visitSeparatedList(node.propertyAssignments);
this.visitList(node.propertyAssignments);
this.visitToken(node.closeBraceToken);
}
@ -488,7 +478,7 @@ module TypeScript {
public visitVariableDeclaration(node: VariableDeclarationSyntax): void {
this.visitToken(node.varKeyword);
this.visitSeparatedList(node.variableDeclarators);
this.visitList(node.variableDeclarators);
}
public visitVariableDeclarator(node: VariableDeclaratorSyntax): void {
@ -500,31 +490,31 @@ module TypeScript {
public visitArgumentList(node: ArgumentListSyntax): void {
this.visitOptionalNode(node.typeArgumentList);
this.visitToken(node.openParenToken);
this.visitSeparatedList(node.arguments);
this.visitList(node.arguments);
this.visitToken(node.closeParenToken);
}
public visitParameterList(node: ParameterListSyntax): void {
this.visitToken(node.openParenToken);
this.visitSeparatedList(node.parameters);
this.visitList(node.parameters);
this.visitToken(node.closeParenToken);
}
public visitTypeArgumentList(node: TypeArgumentListSyntax): void {
this.visitToken(node.lessThanToken);
this.visitSeparatedList(node.typeArguments);
this.visitList(node.typeArguments);
this.visitToken(node.greaterThanToken);
}
public visitTypeParameterList(node: TypeParameterListSyntax): void {
this.visitToken(node.lessThanToken);
this.visitSeparatedList(node.typeParameters);
this.visitList(node.typeParameters);
this.visitToken(node.greaterThanToken);
}
public visitHeritageClause(node: HeritageClauseSyntax): void {
this.visitToken(node.extendsOrImplementsKeyword);
this.visitSeparatedList(node.typeNames);
this.visitList(node.typeNames);
}
public visitEqualsValueClause(node: EqualsValueClauseSyntax): void {

28
src/services/syntax/testUtilities.ts
View File

@ -126,31 +126,6 @@ module TypeScript {
return true;
}
function separatedListStructuralEquals<T extends TypeScript.ISyntaxNodeOrToken>(list1: T[], list2: T[], checkParents: boolean, text1: ISimpleText, text2: ISimpleText): boolean {
Debug.assert(TypeScript.isShared(list1) || list1.parent);
Debug.assert(TypeScript.isShared(list2) || list2.parent);
if (list1.childCount() !== list2.childCount()) {
return false;
}
for (var i = 0, n = list1.childCount(); i < n; i++) {
var element1 = list1.childAt(i);
var element2 = list2.childAt(i);
if (checkParents) {
assertParent(list1, element1);
assertParent(list2, element2);
}
if (!nodeOrTokenStructuralEquals(element1, element2, checkParents, text1, text2)) {
return false;
}
}
return true;
}
export function elementStructuralEquals(element1: TypeScript.ISyntaxElement, element2: TypeScript.ISyntaxElement, checkParents: boolean, text1: ISimpleText, text2: ISimpleText) {
if (element1 === element2) {
return true;
@ -192,9 +167,6 @@ module TypeScript {
else if (TypeScript.isList(element1)) {
return listStructuralEquals(<TypeScript.ISyntaxNodeOrToken[]>element1, <TypeScript.ISyntaxNodeOrToken[]>element2, checkParents, text1, text2);
}
else if (TypeScript.isSeparatedList(element1)) {
return separatedListStructuralEquals(<TypeScript.ISyntaxNodeOrToken[]>element1, <TypeScript.ISyntaxNodeOrToken[]>element2, checkParents, text1, text2);
}
throw TypeScript.Errors.invalidOperation();
}