diff --git a/esprima/esprima-tests.ts b/esprima/esprima-tests.ts index 9451e077d..d2635a404 100644 --- a/esprima/esprima-tests.ts +++ b/esprima/esprima-tests.ts @@ -7,9 +7,8 @@ var token: esprima.Token; var options: esprima.Options; var comment: Syntax.Comment; var program: Syntax.Program; -var statement: Syntax.SomeStatement; -var blockStatement: Syntax.BlockStatement; -var expression: Syntax.SomeExpression; +var statement: Syntax.Statement; +var expression: Syntax.Expression; var property: Syntax.Property; var identifier: Syntax.Identifier; var literal: Syntax.Literal; @@ -52,94 +51,136 @@ string = comment.value; // Statement // BlockStatement -string = statement.type; -statement = statement.body[0]; -comment = statement.leadingComments[0] -comment = statement.trailingComments[0] +var blockStatement: Syntax.BlockStatement; +string = blockStatement.type; +statement = blockStatement.body[0]; +comment = blockStatement.leadingComments[0]; +comment = blockStatement.trailingComments[0]; // ExpressionStatement -expression = statement.expression; +var expressionStatement: Syntax.ExpressionStatement; +expression = expressionStatement.expression; // IfStatement -expression = statement.test; -statement = statement.consequent; -statement = statement.alternate; +var ifStatement: Syntax.IfStatement; +expression = ifStatement.test; +statement = ifStatement.consequent; +statement = ifStatement.alternate; // LabeledStatement -identifier = statement.label; -statement = statement.body; +var labeledStatement: Syntax.LabeledStatement; +identifier = labeledStatement.label; +statement = labeledStatement.body; // WithStatement -expression = statement.object; +var withStatement: Syntax.WithStatement; +expression = withStatement.object; // SwitchStatement -expression = statement.discriminant; -switchCase = statement.cases[0]; -boolean = statement.lexical; +var switchStatement: Syntax.SwitchStatement; +expression = switchStatement.discriminant; +switchCase = switchStatement.cases[0]; +boolean = switchStatement.lexical; // ReturnStatement -expression = statement.argument; +var returnStatement: Syntax.ReturnStatement; +expression = returnStatement.argument; // TryStatement -blockStatement = statement.block; -catchClause = statement.handler; -catchClause = statement.guardedHandlers[0]; -blockStatement = statement.finalizer; +var tryStatement: Syntax.TryStatement; +blockStatement = tryStatement.block; +catchClause = tryStatement.handler; +catchClause = tryStatement.guardedHandlers[0]; +blockStatement = tryStatement.finalizer; // ForStatement -variableDeclaratorOrExpression = statement.init; -expression = statement.update; +var forStatement: Syntax.ForStatement; +variableDeclaratorOrExpression = forStatement.init; +expression = forStatement.update; // ForInStatement -variableDeclaratorOrExpression = statement.left; -expression = statement.right; -boolean = statement.each; +var forInStatement: Syntax.ForInStatement; +variableDeclaratorOrExpression = forInStatement.left; +expression = forInStatement.right; +boolean = forInStatement.each; // Expression // ArrayExpression -string = expression.type; -expression = expression.elements[0]; +var arrayExpression: Syntax.ArrayExpression; +string = arrayExpression.type; +expression = arrayExpression.elements[0]; // ObjectExpression -property = expression.properties[0]; +var objectExpression: Syntax.ObjectExpression; +property = objectExpression.properties[0]; string = property.type; literalOrIdentifier = property.key; expression = property.value; string = property.kind; // FunctionExpression -identifier = expression.id; -identifier = expression.params[0]; -expression = expression.defaults[0]; -identifier = expression.rest; -blockStatementOrExpression = expression.body; -boolean = expression.generator; -boolean = expression.expression; +var functionExpression: Syntax.FunctionExpression; +identifier = functionExpression.id; +identifier = functionExpression.params[0]; +expression = functionExpression.defaults[0]; +identifier = functionExpression.rest; +blockStatementOrExpression = functionExpression.body; +boolean = functionExpression.generator; +boolean = functionExpression.expression; // SequenceExpression -expression = expression.expressions[0] +var sequenceExpression: Syntax.SequenceExpression; +expression = sequenceExpression.expressions[0] // UnaryExpression -string = expression.operator; -boolean = expression.prefix; +var unaryExpression: Syntax.UnaryExpression; +string = unaryExpression.operator; +boolean = unaryExpression.prefix; // BinaryExpression -expression = expression.left; -expression = expression.right; +var binaryExpression: Syntax.BinaryExpression; +expression = binaryExpression.left; +expression = binaryExpression.right; // ConditionalExpression -expression = expression.test; -expression = expression.alternate; -expression = expression.consequent; +var conditionalExpression: Syntax.ConditionalExpression; +expression = conditionalExpression.test; +expression = conditionalExpression.alternate; +expression = conditionalExpression.consequent; -// ConditionalExpression -expression = expression.callee; -expression = expression.arguments[0]; +// NewExpression +var newExpression: Syntax.NewExpression; +expression = newExpression.callee; +expression = newExpression.arguments[0]; + +// CallExpression +var callExpression: Syntax.CallExpression; +expression = callExpression.callee; +expression = callExpression.arguments[0]; // MemberExpression -expression = expression.object; -identifierOrExpression = expression.property; -boolean = expression.computed; +var memberExpression: Syntax.MemberExpression; +expression = memberExpression.object; +identifierOrExpression = memberExpression.property; +boolean = memberExpression.computed; + +// Declarations +var functionDeclaration: Syntax.FunctionDeclaration; +identifier = functionDeclaration.id; +var params:Syntax.Identifier[] = functionDeclaration.params; +var defaults:Syntax.Expression[] = functionDeclaration.defaults; +identifier = functionDeclaration.rest; +var body:Syntax.BlockStatementOrExpression = functionDeclaration.body; +boolean = functionDeclaration.generator; +boolean = functionDeclaration.expression; + +var variableDeclaration: Syntax.VariableDeclaration; +var declarations:Syntax.VariableDeclarator[] = variableDeclaration.declarations; +string = variableDeclaration.kind; // "var" | "let" | "const" + +var variableDeclarator: Syntax.VariableDeclarator; +identifier = variableDeclarator.id; // Pattern +expression = variableDeclarator.init; // Clauses // SwitchCase diff --git a/esprima/esprima.d.ts b/esprima/esprima.d.ts index 1e603ee25..d62bb09bb 100644 --- a/esprima/esprima.d.ts +++ b/esprima/esprima.d.ts @@ -49,7 +49,7 @@ declare module esprima { // Program interface Program extends Node { - body: SomeStatement[] + body: Statement[] comments?: Comment[] } @@ -57,14 +57,13 @@ declare module esprima { interface Function extends Node { id: Identifier // | null params: Identifier[] - defaults: SomeExpression[] + defaults: Expression[] rest: Identifier // | null body: BlockStatementOrExpression generator: boolean expression: boolean } - interface BlockStatementOrExpression extends Array, BlockStatement, SomeExpression { - body: BlockStatementOrExpression + interface BlockStatementOrExpression extends BlockStatement, Expression { } // Statement @@ -73,19 +72,19 @@ declare module esprima { interface EmptyStatement extends Statement { } interface BlockStatement extends Statement { - body: SomeStatement[] + body: Statement[] } interface ExpressionStatement extends Statement { - expression: SomeExpression + expression: Expression } interface IfStatement extends Statement { - test: SomeExpression - consequent: SomeStatement - alternate: SomeStatement + test: Expression + consequent: Statement + alternate: Statement } interface LabeledStatement extends Statement { label: Identifier - body: SomeStatement + body: Statement } interface BreakStatement extends Statement { label: Identifier // | null @@ -94,19 +93,19 @@ declare module esprima { label: Identifier // | null } interface WithStatement extends Statement { - object: SomeExpression - body: SomeStatement + object: Expression + body: Statement } interface SwitchStatement extends Statement { - discriminant: SomeExpression + discriminant: Expression cases: SwitchCase[] lexical: boolean } interface ReturnStatement extends Statement { - argument: SomeExpression // | null + argument: Expression // | null } interface ThrowStatement extends Statement { - argument: SomeExpression + argument: Expression } interface TryStatement extends Statement { block: BlockStatement @@ -115,80 +114,73 @@ declare module esprima { finalizer: BlockStatement // | null } interface WhileStatement extends Statement { - test: SomeExpression - body: SomeStatement + test: Expression + body: Statement } interface DoWhileStatement extends Statement { - body: SomeStatement - test: SomeExpression + body: Statement + test: Expression } interface ForStatement extends Statement { init: VariableDeclaratorOrExpression // | null - test: SomeExpression // | null - update: SomeExpression // | null - body: SomeStatement + test: Expression // | null + update: Expression // | null + body: Statement } interface ForInStatement extends Statement { left: VariableDeclaratorOrExpression - right: SomeExpression - body: SomeStatement + right: Expression + body: Statement each: boolean } - interface VariableDeclaratorOrExpression extends VariableDeclarator, SomeExpression { + interface VariableDeclaratorOrExpression extends VariableDeclarator, Expression { } interface DebuggerStatement extends Statement { } - interface SomeStatement extends - EmptyStatement, ExpressionStatement, BlockStatement, IfStatement, - LabeledStatement, BreakStatement, ContinueStatement, WithStatement, - SwitchStatement, ReturnStatement, ThrowStatement, TryStatement, - WhileStatement, DoWhileStatement, ForStatement, ForInStatement, DebuggerStatement { - body: SomeStatementOrList - } - interface SomeStatementOrList extends Array, SomeStatement { + interface StatementOrList extends Array, Statement { } - // Declration - interface Declration extends Statement { + // Declaration + interface Declaration extends Statement { } - interface FunctionDeclration extends Declration { + interface FunctionDeclaration extends Declaration { id: Identifier params: Identifier[] // Pattern - defaults: SomeExpression[] + defaults: Expression[] rest: Identifier body: BlockStatementOrExpression generator: boolean expression: boolean } - interface VariableDeclaration extends Declration { + interface VariableDeclaration extends Declaration { declarations: VariableDeclarator[] kind: string // "var" | "let" | "const" } interface VariableDeclarator extends Node { id: Identifier // Pattern - init: SomeExpression + init: Expression } // Expression interface Expression extends Node { // | Pattern } - interface SomeExpression extends - ThisExpression, ArrayExpression, ObjectExpression, FunctionExpression, - ArrowFunctionExpression, SequenceExpression, UnaryExpression, BinaryExpression, - AssignmentExpression, UpdateExpression, LogicalExpression, ConditionalExpression, - NewExpression, CallExpression, MemberExpression { - } + //interface Expression extends + // ThisExpression, ArrayExpression, ObjectExpression, FunctionExpression, + // ArrowFunctionExpression, SequenceExpression, UnaryExpression, BinaryExpression, + // AssignmentExpression, UpdateExpression, LogicalExpression, ConditionalExpression, + // NewExpression, CallExpression, MemberExpression { + //} interface ThisExpression extends Expression { } interface ArrayExpression extends Expression { - elements: SomeExpression[] // [ Expression | null ] + elements: Expression[] // [ Expression | null ] } interface ObjectExpression extends Expression { properties: Property[] } interface Property extends Node { key: LiteralOrIdentifier // Literal | Identifier - value: SomeExpression + value: Expression kind: string // "init" | "get" | "set" } interface LiteralOrIdentifier extends Literal, Identifier { @@ -198,66 +190,66 @@ declare module esprima { interface ArrowFunctionExpression extends Function, Expression { } interface SequenceExpression extends Expression { - expressions: SomeExpression[] + expressions: Expression[] } interface UnaryExpression extends Expression { operator: string // UnaryOperator prefix: boolean - argument: SomeExpression + argument: Expression } interface BinaryExpression extends Expression { operator: string // BinaryOperator - left: SomeExpression - right: SomeExpression + left: Expression + right: Expression } interface AssignmentExpression extends Expression { operator: string // AssignmentOperator - left: SomeExpression - right: SomeExpression + left: Expression + right: Expression } interface UpdateExpression extends Expression { operator: string // UpdateOperator - argument: SomeExpression + argument: Expression prefix: boolean } interface LogicalExpression extends Expression { operator: string // LogicalOperator - left: SomeExpression - right: SomeExpression + left: Expression + right: Expression } interface ConditionalExpression extends Expression { - test: SomeExpression - alternate: SomeExpression - consequent: SomeExpression + test: Expression + alternate: Expression + consequent: Expression } interface NewExpression extends Expression { - callee: SomeExpression - arguments: SomeExpression[] + callee: Expression + arguments: Expression[] } interface CallExpression extends Expression { - callee: SomeExpression - arguments: SomeExpression[] + callee: Expression + arguments: Expression[] } interface MemberExpression extends Expression { - object: SomeExpression + object: Expression property: IdentifierOrExpression // Identifier | Expression computed: boolean } - interface IdentifierOrExpression extends Identifier, SomeExpression { + interface IdentifierOrExpression extends Identifier, Expression { } // Pattern - // interface Pattern extends Node { - // } + // interface Pattern extends Node { + // } // Clauses interface SwitchCase extends Node { - test: SomeExpression - consequent: SomeStatement[] + test: Expression + consequent: Statement[] } interface CatchClause extends Node { param: Identifier // Pattern - guard: SomeExpression + guard: Expression body: BlockStatement }