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

Merge pull request #1008 from Microsoft/lessSyntaxKinds

Browse Source 
Move away from separate syntax kinds for binary and unary expressions.
This commit is contained in:
CyrusNajmabadi 2014-10-30 15:35:32 -07:00
commit c2efdd3f90
13 changed files with 84 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
src/services/compiler/astHelpers.ts
View File

@ -16,46 +16,8 @@
///<reference path='references.ts' />
module TypeScript.ASTHelpers {
var sentinelEmptyArray: any[] = [];
//export function scriptIsElided(sourceUnit: SourceUnitSyntax): boolean {
// return isDTSFile(sourceUnit.syntaxTree.fileName()) || moduleMembersAreElided(sourceUnit.moduleElements);
//}
//export function moduleIsElided(declaration: ModuleDeclarationSyntax): boolean {
// return hasModifier(declaration.modifiers, PullElementFlags.Ambient) || moduleMembersAreElided(declaration.moduleElements);
//}
//function moduleMembersAreElided(members: IModuleElementSyntax[]): boolean {
// for (var i = 0, n = members.length; i < n; i++) {
// var member = members[i];
// // We should emit *this* module if it contains any non-interface types.
// // Caveat: if we have contain a module, then we should be emitted *if we want to
// // emit that inner module as well.
// if (member.kind() === SyntaxKind.ModuleDeclaration) {
// if (!moduleIsElided(<ModuleDeclarationSyntax>member)) {
// return false;
// }
// }
// else if (member.kind() !== SyntaxKind.InterfaceDeclaration) {
// return false;
// }
// }
// return true;
//}
//export function enumIsElided(declaration: EnumDeclarationSyntax): boolean {
// if (hasModifier(declaration.modifiers, PullElementFlags.Ambient)) {
// return true;
// }
// return false;
//}
export function isValidAstNode(ast: ISyntaxElement): boolean {
return ast && !isShared(ast) && start(ast) !== -1 && end(ast) !== -1;
}
@ -70,28 +32,6 @@ module TypeScript.ASTHelpers {
return true;
}
export function getExtendsHeritageClause(clauses: HeritageClauseSyntax[]): HeritageClauseSyntax {
return getHeritageClause(clauses, SyntaxKind.ExtendsHeritageClause);
}
export function getImplementsHeritageClause(clauses: HeritageClauseSyntax[]): HeritageClauseSyntax {
return getHeritageClause(clauses, SyntaxKind.ImplementsHeritageClause);
}
function getHeritageClause(clauses: HeritageClauseSyntax[], kind: SyntaxKind): HeritageClauseSyntax {
if (clauses) {
for (var i = 0, n = clauses.length; i < n; i++) {
var child = clauses[i];
if (child.typeNames.length > 0 && child.kind() === kind) {
return child;
}
}
}
return null;
}
export function isCallExpression(ast: ISyntaxElement): boolean {
return (ast && ast.kind() === SyntaxKind.InvocationExpression) ||
(ast && ast.kind() === SyntaxKind.ObjectCreationExpression);
@ -578,28 +518,6 @@ module TypeScript.ASTHelpers {
return variableStatement ? variableStatement.modifiers : Syntax.emptyList<ISyntaxToken>();
}
export function isIntegerLiteralAST(expression: ISyntaxElement): boolean {
if (expression) {
switch (expression.kind()) {
case SyntaxKind.PlusExpression:
case SyntaxKind.NegateExpression:
// Note: if there is a + or - sign, we can only allow a normal integer following
// (and not a hex integer). i.e. -0xA is a legal expression, but it is not a
// *literal*.
expression = (<PrefixUnaryExpressionSyntax>expression).operand;
return expression.kind() === SyntaxKind.NumericLiteral && IntegerUtilities.isInteger((<ISyntaxToken>expression).text());
case SyntaxKind.NumericLiteral:
// If it doesn't have a + or -, then either an integer literal or a hex literal
// is acceptable.
var text = (<ISyntaxToken>expression).text();
return IntegerUtilities.isInteger(text) || IntegerUtilities.isHexInteger(text);
}
}
return false;
}
export function getEnclosingModuleDeclaration(ast: ISyntaxElement): ModuleDeclarationSyntax {
while (ast) {
if (ast.kind() === SyntaxKind.ModuleDeclaration) {

36
src/services/formatting/rules.ts
View File

@ -448,42 +448,8 @@ module TypeScript.Services.Formatting {
switch (context.contextNode.kind()) {
// binary expressions
case SyntaxKind.AssignmentExpression:
case SyntaxKind.AddAssignmentExpression:
case SyntaxKind.SubtractAssignmentExpression:
case SyntaxKind.MultiplyAssignmentExpression:
case SyntaxKind.DivideAssignmentExpression:
case SyntaxKind.ModuloAssignmentExpression:
case SyntaxKind.AndAssignmentExpression:
case SyntaxKind.ExclusiveOrAssignmentExpression:
case SyntaxKind.OrAssignmentExpression:
case SyntaxKind.LeftShiftAssignmentExpression:
case SyntaxKind.SignedRightShiftAssignmentExpression:
case SyntaxKind.UnsignedRightShiftAssignmentExpression:
case SyntaxKind.BinaryExpression:
case SyntaxKind.ConditionalExpression:
case SyntaxKind.LogicalOrExpression:
case SyntaxKind.LogicalAndExpression:
case SyntaxKind.BitwiseOrExpression:
case SyntaxKind.BitwiseExclusiveOrExpression:
case SyntaxKind.BitwiseAndExpression:
case SyntaxKind.EqualsWithTypeConversionExpression:
case SyntaxKind.NotEqualsWithTypeConversionExpression:
case SyntaxKind.EqualsExpression:
case SyntaxKind.NotEqualsExpression:
case SyntaxKind.LessThanExpression:
case SyntaxKind.GreaterThanExpression:
case SyntaxKind.LessThanOrEqualExpression:
case SyntaxKind.GreaterThanOrEqualExpression:
case SyntaxKind.InstanceOfExpression:
case SyntaxKind.InExpression:
case SyntaxKind.LeftShiftExpression:
case SyntaxKind.SignedRightShiftExpression:
case SyntaxKind.UnsignedRightShiftExpression:
case SyntaxKind.MultiplyExpression:
case SyntaxKind.DivideExpression:
case SyntaxKind.ModuloExpression:
case SyntaxKind.AddExpression:
case SyntaxKind.SubtractExpression:
return true;
// equal in import a = module('a');

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

@ -552,7 +552,7 @@ module TypeScript.PrettyPrinter {
public visitBinaryExpression(node: BinaryExpressionSyntax): void {
visitNodeOrToken(this, node.left);
if (node.kind() !== SyntaxKind.CommaExpression) {
if (node.operatorToken.kind() !== SyntaxKind.CommaToken) {
this.ensureSpace();
}

18
src/services/syntax/syntax.ts
View File

@ -185,13 +185,17 @@ module TypeScript.Syntax {
export function isIntegerLiteral(expression: IExpressionSyntax): boolean {
if (expression) {
switch (expression.kind()) {
case SyntaxKind.PlusExpression:
case SyntaxKind.NegateExpression:
// Note: if there is a + or - sign, we can only allow a normal integer following
// (and not a hex integer). i.e. -0xA is a legal expression, but it is not a
// *literal*.
expression = (<PrefixUnaryExpressionSyntax>expression).operand;
return isToken(expression) && IntegerUtilities.isInteger((<ISyntaxToken>expression).text());
case SyntaxKind.PrefixUnaryExpression:
var prefixExpr = <PrefixUnaryExpressionSyntax>expression;
if (prefixExpr.operatorToken.kind() == SyntaxKind.PlusToken || prefixExpr.operatorToken.kind() === SyntaxKind.MinusToken) {
// Note: if there is a + or - sign, we can only allow a normal integer following
// (and not a hex integer). i.e. -0xA is a legal expression, but it is not a
// *literal*.
expression = prefixExpr.operand;
return isToken(expression) && IntegerUtilities.isInteger((<ISyntaxToken>expression).text());
}
return false;
case SyntaxKind.NumericLiteral:
// If it doesn't have a + or -, then either an integer literal or a hex literal

154
src/services/syntax/syntaxFacts.ts
View File

@ -146,114 +146,60 @@ module TypeScript.SyntaxFacts {
}
export function isPrefixUnaryExpressionOperatorToken(tokenKind: SyntaxKind): boolean {
return getPrefixUnaryExpressionFromOperatorToken(tokenKind) !== SyntaxKind.None;
switch (tokenKind) {
case SyntaxKind.PlusToken:
case SyntaxKind.MinusToken:
case SyntaxKind.TildeToken:
case SyntaxKind.ExclamationToken:
case SyntaxKind.PlusPlusToken:
case SyntaxKind.MinusMinusToken:
return true;
default:
return false;
}
}
export function isBinaryExpressionOperatorToken(tokenKind: SyntaxKind): boolean {
return getBinaryExpressionFromOperatorToken(tokenKind) !== SyntaxKind.None;
}
export function getPrefixUnaryExpressionFromOperatorToken(tokenKind: SyntaxKind): SyntaxKind {
switch (tokenKind) {
case SyntaxKind.PlusToken: return SyntaxKind.PlusExpression;
case SyntaxKind.MinusToken: return SyntaxKind.NegateExpression;
case SyntaxKind.TildeToken: return SyntaxKind.BitwiseNotExpression;
case SyntaxKind.ExclamationToken: return SyntaxKind.LogicalNotExpression;
case SyntaxKind.PlusPlusToken: return SyntaxKind.PreIncrementExpression;
case SyntaxKind.MinusMinusToken: return SyntaxKind.PreDecrementExpression;
default: return SyntaxKind.None;
}
}
export function getPostfixUnaryExpressionFromOperatorToken(tokenKind: SyntaxKind): SyntaxKind {
switch (tokenKind) {
case SyntaxKind.PlusPlusToken: return SyntaxKind.PostIncrementExpression;
case SyntaxKind.MinusMinusToken: return SyntaxKind.PostDecrementExpression;
default: return SyntaxKind.None;
}
}
export function getBinaryExpressionFromOperatorToken(tokenKind: SyntaxKind): SyntaxKind {
switch (tokenKind) {
case SyntaxKind.AsteriskToken: return SyntaxKind.MultiplyExpression;
case SyntaxKind.SlashToken: return SyntaxKind.DivideExpression;
case SyntaxKind.PercentToken: return SyntaxKind.ModuloExpression;
case SyntaxKind.PlusToken: return SyntaxKind.AddExpression;
case SyntaxKind.MinusToken: return SyntaxKind.SubtractExpression;
case SyntaxKind.LessThanLessThanToken: return SyntaxKind.LeftShiftExpression;
case SyntaxKind.GreaterThanGreaterThanToken: return SyntaxKind.SignedRightShiftExpression;
case SyntaxKind.GreaterThanGreaterThanGreaterThanToken: return SyntaxKind.UnsignedRightShiftExpression;
case SyntaxKind.LessThanToken: return SyntaxKind.LessThanExpression;
case SyntaxKind.GreaterThanToken: return SyntaxKind.GreaterThanExpression;
case SyntaxKind.LessThanEqualsToken: return SyntaxKind.LessThanOrEqualExpression;
case SyntaxKind.GreaterThanEqualsToken: return SyntaxKind.GreaterThanOrEqualExpression;
case SyntaxKind.InstanceOfKeyword: return SyntaxKind.InstanceOfExpression;
case SyntaxKind.InKeyword: return SyntaxKind.InExpression;
case SyntaxKind.EqualsEqualsToken: return SyntaxKind.EqualsWithTypeConversionExpression;
case SyntaxKind.ExclamationEqualsToken: return SyntaxKind.NotEqualsWithTypeConversionExpression;
case SyntaxKind.EqualsEqualsEqualsToken: return SyntaxKind.EqualsExpression;
case SyntaxKind.ExclamationEqualsEqualsToken: return SyntaxKind.NotEqualsExpression;
case SyntaxKind.AmpersandToken: return SyntaxKind.BitwiseAndExpression;
case SyntaxKind.CaretToken: return SyntaxKind.BitwiseExclusiveOrExpression;
case SyntaxKind.BarToken: return SyntaxKind.BitwiseOrExpression;
case SyntaxKind.AmpersandAmpersandToken: return SyntaxKind.LogicalAndExpression;
case SyntaxKind.BarBarToken: return SyntaxKind.LogicalOrExpression;
case SyntaxKind.BarEqualsToken: return SyntaxKind.OrAssignmentExpression;
case SyntaxKind.AmpersandEqualsToken: return SyntaxKind.AndAssignmentExpression;
case SyntaxKind.CaretEqualsToken: return SyntaxKind.ExclusiveOrAssignmentExpression;
case SyntaxKind.LessThanLessThanEqualsToken: return SyntaxKind.LeftShiftAssignmentExpression;
case SyntaxKind.GreaterThanGreaterThanEqualsToken: return SyntaxKind.SignedRightShiftAssignmentExpression;
case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: return SyntaxKind.UnsignedRightShiftAssignmentExpression;
case SyntaxKind.PlusEqualsToken: return SyntaxKind.AddAssignmentExpression;
case SyntaxKind.MinusEqualsToken: return SyntaxKind.SubtractAssignmentExpression;
case SyntaxKind.AsteriskEqualsToken: return SyntaxKind.MultiplyAssignmentExpression;
case SyntaxKind.SlashEqualsToken: return SyntaxKind.DivideAssignmentExpression;
case SyntaxKind.PercentEqualsToken: return SyntaxKind.ModuloAssignmentExpression;
case SyntaxKind.EqualsToken: return SyntaxKind.AssignmentExpression;
case SyntaxKind.CommaToken: return SyntaxKind.CommaExpression;
default: return SyntaxKind.None;
}
}
export function getOperatorTokenFromBinaryExpression(tokenKind: SyntaxKind): SyntaxKind {
switch (tokenKind) {
case SyntaxKind.MultiplyExpression: return SyntaxKind.AsteriskToken;
case SyntaxKind.DivideExpression: return SyntaxKind.SlashToken;
case SyntaxKind.ModuloExpression: return SyntaxKind.PercentToken;
case SyntaxKind.AddExpression: return SyntaxKind.PlusToken;
case SyntaxKind.SubtractExpression: return SyntaxKind.MinusToken;
case SyntaxKind.LeftShiftExpression: return SyntaxKind.LessThanLessThanToken;
case SyntaxKind.SignedRightShiftExpression: return SyntaxKind.GreaterThanGreaterThanToken;
case SyntaxKind.UnsignedRightShiftExpression: return SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
case SyntaxKind.LessThanExpression: return SyntaxKind.LessThanToken;
case SyntaxKind.GreaterThanExpression: return SyntaxKind.GreaterThanToken;
case SyntaxKind.LessThanOrEqualExpression: return SyntaxKind.LessThanEqualsToken;
case SyntaxKind.GreaterThanOrEqualExpression: return SyntaxKind.GreaterThanEqualsToken;
case SyntaxKind.InstanceOfExpression: return SyntaxKind.InstanceOfKeyword;
case SyntaxKind.InExpression: return SyntaxKind.InKeyword;
case SyntaxKind.EqualsWithTypeConversionExpression: return SyntaxKind.EqualsEqualsToken;
case SyntaxKind.NotEqualsWithTypeConversionExpression: return SyntaxKind.ExclamationEqualsToken;
case SyntaxKind.EqualsExpression: return SyntaxKind.EqualsEqualsEqualsToken;
case SyntaxKind.NotEqualsExpression: return SyntaxKind.ExclamationEqualsEqualsToken;
case SyntaxKind.BitwiseAndExpression: return SyntaxKind.AmpersandToken;
case SyntaxKind.BitwiseExclusiveOrExpression: return SyntaxKind.CaretToken;
case SyntaxKind.BitwiseOrExpression: return SyntaxKind.BarToken;
case SyntaxKind.LogicalAndExpression: return SyntaxKind.AmpersandAmpersandToken;
case SyntaxKind.LogicalOrExpression: return SyntaxKind.BarBarToken;
case SyntaxKind.OrAssignmentExpression: return SyntaxKind.BarEqualsToken;
case SyntaxKind.AndAssignmentExpression: return SyntaxKind.AmpersandEqualsToken;
case SyntaxKind.ExclusiveOrAssignmentExpression: return SyntaxKind.CaretEqualsToken;
case SyntaxKind.LeftShiftAssignmentExpression: return SyntaxKind.LessThanLessThanEqualsToken;
case SyntaxKind.SignedRightShiftAssignmentExpression: return SyntaxKind.GreaterThanGreaterThanEqualsToken;
case SyntaxKind.UnsignedRightShiftAssignmentExpression: return SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken;
case SyntaxKind.AddAssignmentExpression: return SyntaxKind.PlusEqualsToken;
case SyntaxKind.SubtractAssignmentExpression: return SyntaxKind.MinusEqualsToken;
case SyntaxKind.MultiplyAssignmentExpression: return SyntaxKind.AsteriskEqualsToken;
case SyntaxKind.DivideAssignmentExpression: return SyntaxKind.SlashEqualsToken;
case SyntaxKind.ModuloAssignmentExpression: return SyntaxKind.PercentEqualsToken;
case SyntaxKind.AssignmentExpression: return SyntaxKind.EqualsToken;
case SyntaxKind.CommaExpression: return SyntaxKind.CommaToken;
default: return SyntaxKind.None;
case SyntaxKind.AsteriskToken:
case SyntaxKind.SlashToken:
case SyntaxKind.PercentToken:
case SyntaxKind.PlusToken:
case SyntaxKind.MinusToken:
case SyntaxKind.LessThanLessThanToken:
case SyntaxKind.GreaterThanGreaterThanToken:
case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
case SyntaxKind.LessThanToken:
case SyntaxKind.GreaterThanToken:
case SyntaxKind.LessThanEqualsToken:
case SyntaxKind.GreaterThanEqualsToken:
case SyntaxKind.InstanceOfKeyword:
case SyntaxKind.InKeyword:
case SyntaxKind.EqualsEqualsToken:
case SyntaxKind.ExclamationEqualsToken:
case SyntaxKind.EqualsEqualsEqualsToken:
case SyntaxKind.ExclamationEqualsEqualsToken:
case SyntaxKind.AmpersandToken:
case SyntaxKind.CaretToken:
case SyntaxKind.BarToken:
case SyntaxKind.AmpersandAmpersandToken:
case SyntaxKind.BarBarToken:
case SyntaxKind.BarEqualsToken:
case SyntaxKind.AmpersandEqualsToken:
case SyntaxKind.CaretEqualsToken:
case SyntaxKind.LessThanLessThanEqualsToken:
case SyntaxKind.GreaterThanGreaterThanEqualsToken:
case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
case SyntaxKind.PlusEqualsToken:
case SyntaxKind.MinusEqualsToken:
case SyntaxKind.AsteriskEqualsToken:
case SyntaxKind.SlashEqualsToken:
case SyntaxKind.PercentEqualsToken:
case SyntaxKind.EqualsToken:
case SyntaxKind.CommaToken:
return true;
default:
return false;
}
}

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

@ -136,10 +136,9 @@ var definitions:ITypeDefinition[] = [
name: 'HeritageClauseSyntax',
baseType: 'ISyntaxNode',
children: [
<any>{ name: 'extendsOrImplementsKeyword', isToken: true, tokenKinds: ['ExtendsKeyword', 'ImplementsKeyword'] },
<any>{ name: 'extendsOrImplementsKeyword', isToken: true },
<any>{ name: 'typeNames', isSeparatedList: true, requiresAtLeastOneItem: true, elementType: 'INameSyntax' }
],
syntaxKinds: ["ExtendsHeritageClause", "ImplementsHeritageClause"],
isTypeScriptSpecific: true
},
<any>{
@ -210,10 +209,9 @@ var definitions:ITypeDefinition[] = [
baseType: 'ISyntaxNode',
interfaces: ['IUnaryExpressionSyntax'],
children: [
<any>{ name: 'operatorToken', isToken: true, tokenKinds: ['PlusPlusToken', 'MinusMinusToken', 'PlusToken', 'MinusToken', 'TildeToken', 'ExclamationToken'] },
<any>{ name: 'operatorToken', isToken: true },
<any>{ name: 'operand', type: 'IUnaryExpressionSyntax' }
],
syntaxKinds: ["PreIncrementExpression", "PreDecrementExpression", "PlusExpression", "NegateExpression", "BitwiseNotExpression", "LogicalNotExpression"],
},
<any>{
name: 'ArrayLiteralExpressionSyntax',
@ -435,9 +433,8 @@ var definitions:ITypeDefinition[] = [
interfaces: ['IPostfixExpressionSyntax'],
children: [
<any>{ name: 'operand', type: 'ILeftHandSideExpressionSyntax' },
<any>{ name: 'operatorToken', isToken: true, tokenKinds:['PlusPlusToken', 'MinusMinusToken'] }
<any>{ name: 'operatorToken', isToken: true }
],
syntaxKinds: ["PostIncrementExpression", "PostDecrementExpression"],
},
<any>{
name: 'ElementAccessExpressionSyntax',
@ -475,27 +472,9 @@ var definitions:ITypeDefinition[] = [
interfaces: ['IExpressionSyntax'],
children: [
<any>{ name: 'left', type: 'IExpressionSyntax' },
<any>{ name: 'operatorToken', isToken: true,
tokenKinds:['AsteriskToken', 'SlashToken', 'PercentToken', 'PlusToken', 'MinusToken', 'LessThanLessThanToken',
'GreaterThanGreaterThanToken', 'GreaterThanGreaterThanGreaterThanToken', 'LessThanToken',
'GreaterThanToken', 'LessThanEqualsToken', 'GreaterThanEqualsToken', 'InstanceOfKeyword',
'InKeyword', 'EqualsEqualsToken', 'ExclamationEqualsToken', 'EqualsEqualsEqualsToken',
'ExclamationEqualsEqualsToken', 'AmpersandToken', 'CaretToken', 'BarToken', 'AmpersandAmpersandToken',
'BarBarToken', 'BarEqualsToken', 'AmpersandEqualsToken', 'CaretEqualsToken', 'LessThanLessThanEqualsToken',
'GreaterThanGreaterThanEqualsToken', 'GreaterThanGreaterThanGreaterThanEqualsToken', 'PlusEqualsToken',
'MinusEqualsToken', 'AsteriskEqualsToken', 'SlashEqualsToken', 'PercentEqualsToken', 'EqualsToken',
'CommaToken'] },
<any>{ name: 'operatorToken', isToken: true },
<any>{ name: 'right', type: 'IExpressionSyntax' }
],
syntaxKinds: ["MultiplyExpression", "DivideExpression", "ModuloExpression", "AddExpression", "SubtractExpression", "LeftShiftExpression",
"SignedRightShiftExpression", "UnsignedRightShiftExpression", "LessThanExpression",
"GreaterThanExpression", "LessThanOrEqualExpression", "GreaterThanOrEqualExpression", "InstanceOfExpression",
"InExpression", "EqualsWithTypeConversionExpression", "NotEqualsWithTypeConversionExpression", "EqualsExpression",
"NotEqualsExpression", "BitwiseAndExpression", "BitwiseExclusiveOrExpression", "BitwiseOrExpression", "LogicalAndExpression",
"LogicalOrExpression", "OrAssignmentExpression", "AndAssignmentExpression", "ExclusiveOrAssignmentExpression", "LeftShiftAssignmentExpression",
"SignedRightShiftAssignmentExpression", "UnsignedRightShiftAssignmentExpression", "AddAssignmentExpression",
"SubtractAssignmentExpression", "MultiplyAssignmentExpression", "DivideAssignmentExpression", "ModuloAssignmentExpression", "AssignmentExpression",
"CommaExpression"]
},
<any>{
name: 'ConditionalExpressionSyntax',
@ -1994,20 +1973,6 @@ function generateNode(definition: ITypeDefinition, abstract: boolean): string {
}
result += " }\r\n";
if (definition.name === "BinaryExpressionSyntax") {
result += " public kind(): SyntaxKind { return SyntaxFacts.getBinaryExpressionFromOperatorToken(this.operatorToken.kind()); }\r\n";
}
else if (definition.name === "PrefixUnaryExpressionSyntax") {
result += " public kind(): SyntaxKind { return SyntaxFacts.getPrefixUnaryExpressionFromOperatorToken(this.operatorToken.kind()); }\r\n";
}
else if (definition.name === "PostfixUnaryExpressionSyntax") {
result += " public kind(): SyntaxKind { return SyntaxFacts.getPostfixUnaryExpressionFromOperatorToken(this.operatorToken.kind()); }\r\n";
}
else if (definition.name === "HeritageClauseSyntax") {
result += " public kind(): SyntaxKind { return this.extendsOrImplementsKeyword.kind() === SyntaxKind.ExtendsKeyword ? SyntaxKind.ExtendsHeritageClause : SyntaxKind.ImplementsHeritageClause; }\r\n";
}
result += " }";
return result;
}

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

@ -209,54 +209,13 @@ module TypeScript {
WithStatement,
// Expressions
PlusExpression,
NegateExpression,
BitwiseNotExpression,
LogicalNotExpression,
PreIncrementExpression,
PreDecrementExpression,
PrefixUnaryExpression,
DeleteExpression,
TypeOfExpression,
VoidExpression,
CommaExpression,
AssignmentExpression,
AddAssignmentExpression,
SubtractAssignmentExpression,
MultiplyAssignmentExpression,
DivideAssignmentExpression,
ModuloAssignmentExpression,
AndAssignmentExpression,
ExclusiveOrAssignmentExpression,
OrAssignmentExpression,
LeftShiftAssignmentExpression,
SignedRightShiftAssignmentExpression,
UnsignedRightShiftAssignmentExpression,
ConditionalExpression,
LogicalOrExpression,
LogicalAndExpression,
BitwiseOrExpression,
BitwiseExclusiveOrExpression,
BitwiseAndExpression,
EqualsWithTypeConversionExpression,
NotEqualsWithTypeConversionExpression,
EqualsExpression,
NotEqualsExpression,
LessThanExpression,
GreaterThanExpression,
LessThanOrEqualExpression,
GreaterThanOrEqualExpression,
InstanceOfExpression,
InExpression,
LeftShiftExpression,
SignedRightShiftExpression,
UnsignedRightShiftExpression,
MultiplyExpression,
DivideExpression,
ModuloExpression,
AddExpression,
SubtractExpression,
PostIncrementExpression,
PostDecrementExpression,
BinaryExpression,
PostfixUnaryExpression,
MemberAccessExpression,
InvocationExpression,
ArrayLiteralExpression,
@ -281,8 +240,7 @@ module TypeScript {
TypeParameterList,
// Clauses
ExtendsHeritageClause,
ImplementsHeritageClause,
HeritageClause,
EqualsValueClause,
CaseSwitchClause,
DefaultSwitchClause,

6
src/services/syntax/syntaxNodes.abstract.generated.ts
View File

File diff suppressed because one or more lines are too long

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

File diff suppressed because one or more lines are too long

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

File diff suppressed because one or more lines are too long

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

@ -1494,9 +1494,9 @@ module TypeScript {
}
private isPreIncrementOrDecrementExpression(node: PrefixUnaryExpressionSyntax) {
switch (node.kind()) {
case SyntaxKind.PreDecrementExpression:
case SyntaxKind.PreIncrementExpression:
switch (node.operatorToken.kind()) {
case SyntaxKind.MinusMinusToken:
case SyntaxKind.PlusPlusToken:
return true;
}

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

@ -72,54 +72,13 @@ module TypeScript {
case SyntaxKind.TrueKeyword:
case SyntaxKind.SuperKeyword:
case SyntaxKind.PlusExpression:
case SyntaxKind.NegateExpression:
case SyntaxKind.BitwiseNotExpression:
case SyntaxKind.LogicalNotExpression:
case SyntaxKind.PreIncrementExpression:
case SyntaxKind.PreDecrementExpression:
case SyntaxKind.PrefixUnaryExpression:
case SyntaxKind.PostfixUnaryExpression:
case SyntaxKind.BinaryExpression:
case SyntaxKind.DeleteExpression:
case SyntaxKind.TypeOfExpression:
case SyntaxKind.VoidExpression:
case SyntaxKind.CommaExpression:
case SyntaxKind.AssignmentExpression:
case SyntaxKind.AddAssignmentExpression:
case SyntaxKind.SubtractAssignmentExpression:
case SyntaxKind.MultiplyAssignmentExpression:
case SyntaxKind.DivideAssignmentExpression:
case SyntaxKind.ModuloAssignmentExpression:
case SyntaxKind.AndAssignmentExpression:
case SyntaxKind.ExclusiveOrAssignmentExpression:
case SyntaxKind.OrAssignmentExpression:
case SyntaxKind.LeftShiftAssignmentExpression:
case SyntaxKind.SignedRightShiftAssignmentExpression:
case SyntaxKind.UnsignedRightShiftAssignmentExpression:
case SyntaxKind.ConditionalExpression:
case SyntaxKind.LogicalOrExpression:
case SyntaxKind.LogicalAndExpression:
case SyntaxKind.BitwiseOrExpression:
case SyntaxKind.BitwiseExclusiveOrExpression:
case SyntaxKind.BitwiseAndExpression:
case SyntaxKind.EqualsWithTypeConversionExpression:
case SyntaxKind.NotEqualsWithTypeConversionExpression:
case SyntaxKind.EqualsExpression:
case SyntaxKind.NotEqualsExpression:
case SyntaxKind.LessThanExpression:
case SyntaxKind.GreaterThanExpression:
case SyntaxKind.LessThanOrEqualExpression:
case SyntaxKind.GreaterThanOrEqualExpression:
case SyntaxKind.InstanceOfExpression:
case SyntaxKind.InExpression:
case SyntaxKind.LeftShiftExpression:
case SyntaxKind.SignedRightShiftExpression:
case SyntaxKind.UnsignedRightShiftExpression:
case SyntaxKind.MultiplyExpression:
case SyntaxKind.DivideExpression:
case SyntaxKind.ModuloExpression:
case SyntaxKind.AddExpression:
case SyntaxKind.SubtractExpression:
case SyntaxKind.PostIncrementExpression:
case SyntaxKind.PostDecrementExpression:
case SyntaxKind.MemberAccessExpression:
case SyntaxKind.InvocationExpression:
case SyntaxKind.ArrayLiteralExpression:

12
src/services/syntax/syntaxVisitor.generated.ts
View File

@ -52,16 +52,13 @@ module TypeScript {
case SyntaxKind.DoStatement: return visitor.visitDoStatement(<DoStatementSyntax>element);
case SyntaxKind.DebuggerStatement: return visitor.visitDebuggerStatement(<DebuggerStatementSyntax>element);
case SyntaxKind.WithStatement: return visitor.visitWithStatement(<WithStatementSyntax>element);
case SyntaxKind.PreIncrementExpression: case SyntaxKind.PreDecrementExpression: case SyntaxKind.PlusExpression: case SyntaxKind.NegateExpression: case SyntaxKind.BitwiseNotExpression: case SyntaxKind.LogicalNotExpression:
return visitor.visitPrefixUnaryExpression(<PrefixUnaryExpressionSyntax>element);
case SyntaxKind.PrefixUnaryExpression: return visitor.visitPrefixUnaryExpression(<PrefixUnaryExpressionSyntax>element);
case SyntaxKind.DeleteExpression: return visitor.visitDeleteExpression(<DeleteExpressionSyntax>element);
case SyntaxKind.TypeOfExpression: return visitor.visitTypeOfExpression(<TypeOfExpressionSyntax>element);
case SyntaxKind.VoidExpression: return visitor.visitVoidExpression(<VoidExpressionSyntax>element);
case SyntaxKind.ConditionalExpression: return visitor.visitConditionalExpression(<ConditionalExpressionSyntax>element);
case SyntaxKind.MultiplyExpression: case SyntaxKind.DivideExpression: case SyntaxKind.ModuloExpression: case SyntaxKind.AddExpression: case SyntaxKind.SubtractExpression: case SyntaxKind.LeftShiftExpression: case SyntaxKind.SignedRightShiftExpression: case SyntaxKind.UnsignedRightShiftExpression: case SyntaxKind.LessThanExpression: case SyntaxKind.GreaterThanExpression: case SyntaxKind.LessThanOrEqualExpression: case SyntaxKind.GreaterThanOrEqualExpression: case SyntaxKind.InstanceOfExpression: case SyntaxKind.InExpression: case SyntaxKind.EqualsWithTypeConversionExpression: case SyntaxKind.NotEqualsWithTypeConversionExpression: case SyntaxKind.EqualsExpression: case SyntaxKind.NotEqualsExpression: case SyntaxKind.BitwiseAndExpression: case SyntaxKind.BitwiseExclusiveOrExpression: case SyntaxKind.BitwiseOrExpression: case SyntaxKind.LogicalAndExpression: case SyntaxKind.LogicalOrExpression: case SyntaxKind.OrAssignmentExpression: case SyntaxKind.AndAssignmentExpression: case SyntaxKind.ExclusiveOrAssignmentExpression: case SyntaxKind.LeftShiftAssignmentExpression: case SyntaxKind.SignedRightShiftAssignmentExpression: case SyntaxKind.UnsignedRightShiftAssignmentExpression: case SyntaxKind.AddAssignmentExpression: case SyntaxKind.SubtractAssignmentExpression: case SyntaxKind.MultiplyAssignmentExpression: case SyntaxKind.DivideAssignmentExpression: case SyntaxKind.ModuloAssignmentExpression: case SyntaxKind.AssignmentExpression: case SyntaxKind.CommaExpression:
return visitor.visitBinaryExpression(<BinaryExpressionSyntax>element);
case SyntaxKind.PostIncrementExpression: case SyntaxKind.PostDecrementExpression:
return visitor.visitPostfixUnaryExpression(<PostfixUnaryExpressionSyntax>element);
case SyntaxKind.BinaryExpression: return visitor.visitBinaryExpression(<BinaryExpressionSyntax>element);
case SyntaxKind.PostfixUnaryExpression: return visitor.visitPostfixUnaryExpression(<PostfixUnaryExpressionSyntax>element);
case SyntaxKind.MemberAccessExpression: return visitor.visitMemberAccessExpression(<MemberAccessExpressionSyntax>element);
case SyntaxKind.InvocationExpression: return visitor.visitInvocationExpression(<InvocationExpressionSyntax>element);
case SyntaxKind.ArrayLiteralExpression: return visitor.visitArrayLiteralExpression(<ArrayLiteralExpressionSyntax>element);
@ -80,8 +77,7 @@ module TypeScript {
case SyntaxKind.ParameterList: return visitor.visitParameterList(<ParameterListSyntax>element);
case SyntaxKind.TypeArgumentList: return visitor.visitTypeArgumentList(<TypeArgumentListSyntax>element);
case SyntaxKind.TypeParameterList: return visitor.visitTypeParameterList(<TypeParameterListSyntax>element);
case SyntaxKind.ExtendsHeritageClause: case SyntaxKind.ImplementsHeritageClause:
return visitor.visitHeritageClause(<HeritageClauseSyntax>element);
case SyntaxKind.HeritageClause: return visitor.visitHeritageClause(<HeritageClauseSyntax>element);
case SyntaxKind.EqualsValueClause: return visitor.visitEqualsValueClause(<EqualsValueClauseSyntax>element);
case SyntaxKind.CaseSwitchClause: return visitor.visitCaseSwitchClause(<CaseSwitchClauseSyntax>element);
case SyntaxKind.DefaultSwitchClause: return visitor.visitDefaultSwitchClause(<DefaultSwitchClauseSyntax>element);