diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md index 01b5025d20..f3fcff1ea1 100644 --- a/CONTRIBUTORS.md +++ b/CONTRIBUTORS.md @@ -63,6 +63,7 @@ All definitions files include a header with the author and editors, so at some p * [emissary](https://github.com/atom/emissary) (by [vvakame](https://github.com/vvakame)) * [EpicEditor](http://epiceditor.com/) (by [Boris Yankov](https://github.com/borisyankov)) * [ES6-Promises](https://github.com/jakearchibald/ES6-Promises) (by [François de Campredon](https://github.com/fdecampredon/)) +* [Esprima](http://esprima.org/) (by [Teppei Sato](https://github.com/teppeis)) * [expect.js](https://github.com/LearnBoost/expect.js) (by [Teppei Sato](https://github.com/teppeis)) * [expectations](https://github.com/spmason/expectations) (by [vvakame](https://github.com/vvakame)) * [Express](http://expressjs.com/) (by [Boris Yankov](https://github.com/borisyankov)) diff --git a/esprima/esprima-tests.ts b/esprima/esprima-tests.ts new file mode 100644 index 0000000000..9451e077d2 --- /dev/null +++ b/esprima/esprima-tests.ts @@ -0,0 +1,163 @@ +/// + +import esprima = require('esprima'); +import Syntax = esprima.Syntax; + +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 property: Syntax.Property; +var identifier: Syntax.Identifier; +var literal: Syntax.Literal; +var switchCase: Syntax.SwitchCase; +var catchClause: Syntax.CatchClause; +var variableDeclaratorOrExpression: Syntax.VariableDeclaratorOrExpression; +var literalOrIdentifier: Syntax.LiteralOrIdentifier; +var blockStatementOrExpression: Syntax.BlockStatementOrExpression; +var identifierOrExpression: Syntax.IdentifierOrExpression; +var any: any; +var string: string; +var boolean: boolean; +var number: number; + +// esprima +string = esprima.version; +program = esprima.parse('code'); +program = esprima.parse('code', {range: true}); +token = esprima.tokenize('code')[0]; +token = esprima.tokenize('code', {range: true})[0]; + +// Token +string = token.type; +string = token.value; + +// Program +string = program.type; +statement = program.body[0]; +comment = program.comments[0] + +// Location +number = program.loc.start.line; +number = program.loc.start.column; +number = program.loc.end.line; +number = program.loc.end.column; +number = program.range[0]; + +// Comment +string = comment.value; + +// Statement +// BlockStatement +string = statement.type; +statement = statement.body[0]; +comment = statement.leadingComments[0] +comment = statement.trailingComments[0] + +// ExpressionStatement +expression = statement.expression; + +// IfStatement +expression = statement.test; +statement = statement.consequent; +statement = statement.alternate; + +// LabeledStatement +identifier = statement.label; +statement = statement.body; + +// WithStatement +expression = statement.object; + +// SwitchStatement +expression = statement.discriminant; +switchCase = statement.cases[0]; +boolean = statement.lexical; + +// ReturnStatement +expression = statement.argument; + +// TryStatement +blockStatement = statement.block; +catchClause = statement.handler; +catchClause = statement.guardedHandlers[0]; +blockStatement = statement.finalizer; + +// ForStatement +variableDeclaratorOrExpression = statement.init; +expression = statement.update; + +// ForInStatement +variableDeclaratorOrExpression = statement.left; +expression = statement.right; +boolean = statement.each; + +// Expression +// ArrayExpression +string = expression.type; +expression = expression.elements[0]; + +// ObjectExpression +property = expression.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; + +// SequenceExpression +expression = expression.expressions[0] + +// UnaryExpression +string = expression.operator; +boolean = expression.prefix; + +// BinaryExpression +expression = expression.left; +expression = expression.right; + +// ConditionalExpression +expression = expression.test; +expression = expression.alternate; +expression = expression.consequent; + +// ConditionalExpression +expression = expression.callee; +expression = expression.arguments[0]; + +// MemberExpression +expression = expression.object; +identifierOrExpression = expression.property; +boolean = expression.computed; + +// Clauses +// SwitchCase +string = switchCase.type; +expression = switchCase.test; +statement = switchCase.consequent[0]; + +// CatchClause +string = catchClause.type; +identifier = catchClause.param; +expression = catchClause.guard; +blockStatement = catchClause.body; + +// Misc +// Identifier +string = identifier.type; +string = identifier.name; + +// Literal +string = literal.type; +any = literal.value; diff --git a/esprima/esprima.d.ts b/esprima/esprima.d.ts new file mode 100644 index 0000000000..1e603ee255 --- /dev/null +++ b/esprima/esprima.d.ts @@ -0,0 +1,276 @@ +// Type definitions for Esprima v1.2.0 +// Project: http://esprima.org +// Definitions by: teppeis +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module esprima { + var version: string; + function parse(code: string, options?: Options): Syntax.Program; + function tokenize(code: string, options?: Options): Array; + + interface Token { + type: string + value: string + } + + interface Options { + loc?: boolean + range?: boolean + raw?: boolean + tokens?: boolean + comment?: boolean + attachComment?: boolean + tolerant?: boolean + source?: boolean + } + + module Syntax { + // Node + interface Node { + type: string + loc?: LineLocation + range?: number[] + leadingComments?: Comment[] + trailingComments?: Comment[] + } + interface LineLocation { + start: Position + end: Position + } + interface Position { + line: number + column: number + } + + // Comment + interface Comment extends Node { + value: string + } + + // Program + interface Program extends Node { + body: SomeStatement[] + comments?: Comment[] + } + + // Function + interface Function extends Node { + id: Identifier // | null + params: Identifier[] + defaults: SomeExpression[] + rest: Identifier // | null + body: BlockStatementOrExpression + generator: boolean + expression: boolean + } + interface BlockStatementOrExpression extends Array, BlockStatement, SomeExpression { + body: BlockStatementOrExpression + } + + // Statement + interface Statement extends Node { + } + interface EmptyStatement extends Statement { + } + interface BlockStatement extends Statement { + body: SomeStatement[] + } + interface ExpressionStatement extends Statement { + expression: SomeExpression + } + interface IfStatement extends Statement { + test: SomeExpression + consequent: SomeStatement + alternate: SomeStatement + } + interface LabeledStatement extends Statement { + label: Identifier + body: SomeStatement + } + interface BreakStatement extends Statement { + label: Identifier // | null + } + interface ContinueStatement extends Statement { + label: Identifier // | null + } + interface WithStatement extends Statement { + object: SomeExpression + body: SomeStatement + } + interface SwitchStatement extends Statement { + discriminant: SomeExpression + cases: SwitchCase[] + lexical: boolean + } + interface ReturnStatement extends Statement { + argument: SomeExpression // | null + } + interface ThrowStatement extends Statement { + argument: SomeExpression + } + interface TryStatement extends Statement { + block: BlockStatement + handler: CatchClause // | null + guardedHandlers: CatchClause[] + finalizer: BlockStatement // | null + } + interface WhileStatement extends Statement { + test: SomeExpression + body: SomeStatement + } + interface DoWhileStatement extends Statement { + body: SomeStatement + test: SomeExpression + } + interface ForStatement extends Statement { + init: VariableDeclaratorOrExpression // | null + test: SomeExpression // | null + update: SomeExpression // | null + body: SomeStatement + } + interface ForInStatement extends Statement { + left: VariableDeclaratorOrExpression + right: SomeExpression + body: SomeStatement + each: boolean + } + interface VariableDeclaratorOrExpression extends VariableDeclarator, SomeExpression { + } + 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 { + } + + // Declration + interface Declration extends Statement { + } + interface FunctionDeclration extends Declration { + id: Identifier + params: Identifier[] // Pattern + defaults: SomeExpression[] + rest: Identifier + body: BlockStatementOrExpression + generator: boolean + expression: boolean + } + interface VariableDeclaration extends Declration { + declarations: VariableDeclarator[] + kind: string // "var" | "let" | "const" + } + interface VariableDeclarator extends Node { + id: Identifier // Pattern + init: SomeExpression + } + + // 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 ThisExpression extends Expression { + } + interface ArrayExpression extends Expression { + elements: SomeExpression[] // [ Expression | null ] + } + interface ObjectExpression extends Expression { + properties: Property[] + } + interface Property extends Node { + key: LiteralOrIdentifier // Literal | Identifier + value: SomeExpression + kind: string // "init" | "get" | "set" + } + interface LiteralOrIdentifier extends Literal, Identifier { + } + interface FunctionExpression extends Function, Expression { + } + interface ArrowFunctionExpression extends Function, Expression { + } + interface SequenceExpression extends Expression { + expressions: SomeExpression[] + } + interface UnaryExpression extends Expression { + operator: string // UnaryOperator + prefix: boolean + argument: SomeExpression + } + interface BinaryExpression extends Expression { + operator: string // BinaryOperator + left: SomeExpression + right: SomeExpression + } + interface AssignmentExpression extends Expression { + operator: string // AssignmentOperator + left: SomeExpression + right: SomeExpression + } + interface UpdateExpression extends Expression { + operator: string // UpdateOperator + argument: SomeExpression + prefix: boolean + } + interface LogicalExpression extends Expression { + operator: string // LogicalOperator + left: SomeExpression + right: SomeExpression + } + interface ConditionalExpression extends Expression { + test: SomeExpression + alternate: SomeExpression + consequent: SomeExpression + } + interface NewExpression extends Expression { + callee: SomeExpression + arguments: SomeExpression[] + } + interface CallExpression extends Expression { + callee: SomeExpression + arguments: SomeExpression[] + } + interface MemberExpression extends Expression { + object: SomeExpression + property: IdentifierOrExpression // Identifier | Expression + computed: boolean + } + interface IdentifierOrExpression extends Identifier, SomeExpression { + } + + // Pattern + // interface Pattern extends Node { + // } + + // Clauses + interface SwitchCase extends Node { + test: SomeExpression + consequent: SomeStatement[] + } + interface CatchClause extends Node { + param: Identifier // Pattern + guard: SomeExpression + body: BlockStatement + } + + // Misc + interface Identifier extends Node, Expression { // | Pattern + name: string + } + interface Literal extends Node, Expression { + value: any // string | boolean | null | number | RegExp + } + } +} + +declare module "esprima" { + export = esprima +}