mirror of
https://github.com/wassname/DefinitelyTyped.git
synced 2026-09-11 11:50:54 +08:00
Add ESTree AST and Acorn definitions.
Adds type defs for [ESTree AST specification](https://github.com/estree/estree) and updates Esprima and Acorn definitions since they follow same spec.
This commit is contained in:
Ingvar Stepanyan
+3
-184
@@ -1,27 +1,12 @@
|
||||
/// <reference path="../estree/estree.d.ts" />
|
||||
/// <reference path="esprima.d.ts" />
|
||||
|
||||
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.Statement;
|
||||
var expression: Syntax.Expression;
|
||||
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 comment: esprima.Comment;
|
||||
var program: ESTree.Program;
|
||||
var string: string;
|
||||
var boolean: boolean;
|
||||
var number: number;
|
||||
|
||||
// esprima
|
||||
string = esprima.version;
|
||||
@@ -34,171 +19,5 @@ token = esprima.tokenize('code', {range: true})[0];
|
||||
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
|
||||
var blockStatement: Syntax.BlockStatement;
|
||||
string = blockStatement.type;
|
||||
statement = blockStatement.body[0];
|
||||
comment = blockStatement.leadingComments[0];
|
||||
comment = blockStatement.trailingComments[0];
|
||||
|
||||
// ExpressionStatement
|
||||
var expressionStatement: Syntax.ExpressionStatement;
|
||||
expression = expressionStatement.expression;
|
||||
|
||||
// IfStatement
|
||||
var ifStatement: Syntax.IfStatement;
|
||||
expression = ifStatement.test;
|
||||
statement = ifStatement.consequent;
|
||||
statement = ifStatement.alternate;
|
||||
|
||||
// LabeledStatement
|
||||
var labeledStatement: Syntax.LabeledStatement;
|
||||
identifier = labeledStatement.label;
|
||||
statement = labeledStatement.body;
|
||||
|
||||
// WithStatement
|
||||
var withStatement: Syntax.WithStatement;
|
||||
expression = withStatement.object;
|
||||
|
||||
// SwitchStatement
|
||||
var switchStatement: Syntax.SwitchStatement;
|
||||
expression = switchStatement.discriminant;
|
||||
switchCase = switchStatement.cases[0];
|
||||
boolean = switchStatement.lexical;
|
||||
|
||||
// ReturnStatement
|
||||
var returnStatement: Syntax.ReturnStatement;
|
||||
expression = returnStatement.argument;
|
||||
|
||||
// TryStatement
|
||||
var tryStatement: Syntax.TryStatement;
|
||||
blockStatement = tryStatement.block;
|
||||
catchClause = tryStatement.handler;
|
||||
catchClause = tryStatement.guardedHandlers[0];
|
||||
blockStatement = tryStatement.finalizer;
|
||||
|
||||
// ForStatement
|
||||
var forStatement: Syntax.ForStatement;
|
||||
variableDeclaratorOrExpression = forStatement.init;
|
||||
expression = forStatement.update;
|
||||
|
||||
// ForInStatement
|
||||
var forInStatement: Syntax.ForInStatement;
|
||||
variableDeclaratorOrExpression = forInStatement.left;
|
||||
expression = forInStatement.right;
|
||||
boolean = forInStatement.each;
|
||||
|
||||
// Expression
|
||||
// ArrayExpression
|
||||
var arrayExpression: Syntax.ArrayExpression;
|
||||
string = arrayExpression.type;
|
||||
expression = arrayExpression.elements[0];
|
||||
|
||||
// ObjectExpression
|
||||
var objectExpression: Syntax.ObjectExpression;
|
||||
property = objectExpression.properties[0];
|
||||
string = property.type;
|
||||
literalOrIdentifier = property.key;
|
||||
expression = property.value;
|
||||
string = property.kind;
|
||||
|
||||
// FunctionExpression
|
||||
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
|
||||
var sequenceExpression: Syntax.SequenceExpression;
|
||||
expression = sequenceExpression.expressions[0]
|
||||
|
||||
// UnaryExpression
|
||||
var unaryExpression: Syntax.UnaryExpression;
|
||||
string = unaryExpression.operator;
|
||||
boolean = unaryExpression.prefix;
|
||||
|
||||
// BinaryExpression
|
||||
var binaryExpression: Syntax.BinaryExpression;
|
||||
expression = binaryExpression.left;
|
||||
expression = binaryExpression.right;
|
||||
|
||||
// ConditionalExpression
|
||||
var conditionalExpression: Syntax.ConditionalExpression;
|
||||
expression = conditionalExpression.test;
|
||||
expression = conditionalExpression.alternate;
|
||||
expression = conditionalExpression.consequent;
|
||||
|
||||
// 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
|
||||
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
|
||||
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;
|
||||
|
||||
Vendored
+11
-243
@@ -1,18 +1,24 @@
|
||||
// Type definitions for Esprima v1.2.0
|
||||
// Type definitions for Esprima v2.1.0
|
||||
// Project: http://esprima.org
|
||||
// Definitions by: teppeis <https://github.com/teppeis/>
|
||||
// Definitions by: teppeis <https://github.com/teppeis>, RReverser <https://github.com/RReverser>
|
||||
// Definitions: https://github.com/borisyankov/DefinitelyTyped
|
||||
|
||||
/// <reference path="../estree/estree.d.ts" />
|
||||
|
||||
declare module esprima {
|
||||
var version: string;
|
||||
function parse(code: string, options?: Options): Syntax.Program;
|
||||
function tokenize(code: string, options?: Options): Array<Token>;
|
||||
var version: string
|
||||
function parse(code: string, options?: Options): ESTree.Program
|
||||
function tokenize(code: string, options?: Options): Array<Token>
|
||||
|
||||
interface Token {
|
||||
type: string
|
||||
value: string
|
||||
}
|
||||
|
||||
interface Comment extends ESTree.Node {
|
||||
value: string
|
||||
}
|
||||
|
||||
interface Options {
|
||||
loc?: boolean
|
||||
range?: boolean
|
||||
@@ -23,244 +29,6 @@ declare module esprima {
|
||||
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: Statement[]
|
||||
comments?: Comment[]
|
||||
}
|
||||
|
||||
// Function
|
||||
interface Function extends Node {
|
||||
id: Identifier // | null
|
||||
params: Identifier[]
|
||||
defaults: Expression[]
|
||||
rest: Identifier // | null
|
||||
body: BlockStatementOrExpression
|
||||
generator: boolean
|
||||
expression: boolean
|
||||
}
|
||||
interface BlockStatementOrExpression extends BlockStatement, Expression {
|
||||
}
|
||||
|
||||
// Statement
|
||||
interface Statement extends Node {
|
||||
}
|
||||
interface EmptyStatement extends Statement {
|
||||
}
|
||||
interface BlockStatement extends Statement {
|
||||
body: Statement[]
|
||||
}
|
||||
interface ExpressionStatement extends Statement {
|
||||
expression: Expression
|
||||
}
|
||||
interface IfStatement extends Statement {
|
||||
test: Expression
|
||||
consequent: Statement
|
||||
alternate: Statement
|
||||
}
|
||||
interface LabeledStatement extends Statement {
|
||||
label: Identifier
|
||||
body: Statement
|
||||
}
|
||||
interface BreakStatement extends Statement {
|
||||
label: Identifier // | null
|
||||
}
|
||||
interface ContinueStatement extends Statement {
|
||||
label: Identifier // | null
|
||||
}
|
||||
interface WithStatement extends Statement {
|
||||
object: Expression
|
||||
body: Statement
|
||||
}
|
||||
interface SwitchStatement extends Statement {
|
||||
discriminant: Expression
|
||||
cases: SwitchCase[]
|
||||
lexical: boolean
|
||||
}
|
||||
interface ReturnStatement extends Statement {
|
||||
argument: Expression // | null
|
||||
}
|
||||
interface ThrowStatement extends Statement {
|
||||
argument: Expression
|
||||
}
|
||||
interface TryStatement extends Statement {
|
||||
block: BlockStatement
|
||||
handler: CatchClause // | null
|
||||
guardedHandlers: CatchClause[]
|
||||
finalizer: BlockStatement // | null
|
||||
}
|
||||
interface WhileStatement extends Statement {
|
||||
test: Expression
|
||||
body: Statement
|
||||
}
|
||||
interface DoWhileStatement extends Statement {
|
||||
body: Statement
|
||||
test: Expression
|
||||
}
|
||||
interface ForStatement extends Statement {
|
||||
init: VariableDeclaratorOrExpression // | null
|
||||
test: Expression // | null
|
||||
update: Expression // | null
|
||||
body: Statement
|
||||
}
|
||||
interface ForInStatement extends Statement {
|
||||
left: VariableDeclaratorOrExpression
|
||||
right: Expression
|
||||
body: Statement
|
||||
each: boolean
|
||||
}
|
||||
interface VariableDeclaratorOrExpression extends VariableDeclarator, Expression {
|
||||
}
|
||||
interface DebuggerStatement extends Statement {
|
||||
}
|
||||
interface StatementOrList extends Array<Statement>, Statement {
|
||||
}
|
||||
|
||||
// Declaration
|
||||
interface Declaration extends Statement {
|
||||
}
|
||||
interface FunctionDeclaration extends Declaration {
|
||||
id: Identifier
|
||||
params: Identifier[] // Pattern
|
||||
defaults: Expression[]
|
||||
rest: Identifier
|
||||
body: BlockStatementOrExpression
|
||||
generator: boolean
|
||||
expression: boolean
|
||||
}
|
||||
interface VariableDeclaration extends Declaration {
|
||||
declarations: VariableDeclarator[]
|
||||
kind: string // "var" | "let" | "const"
|
||||
}
|
||||
interface VariableDeclarator extends Node {
|
||||
id: Identifier // Pattern
|
||||
init: Expression
|
||||
}
|
||||
|
||||
// Expression
|
||||
interface Expression extends Node { // | Pattern
|
||||
}
|
||||
//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: Expression[] // [ Expression | null ]
|
||||
}
|
||||
interface ObjectExpression extends Expression {
|
||||
properties: Property[]
|
||||
}
|
||||
interface Property extends Node {
|
||||
key: LiteralOrIdentifier // Literal | Identifier
|
||||
value: Expression
|
||||
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: Expression[]
|
||||
}
|
||||
interface UnaryExpression extends Expression {
|
||||
operator: string // UnaryOperator
|
||||
prefix: boolean
|
||||
argument: Expression
|
||||
}
|
||||
interface BinaryExpression extends Expression {
|
||||
operator: string // BinaryOperator
|
||||
left: Expression
|
||||
right: Expression
|
||||
}
|
||||
interface AssignmentExpression extends Expression {
|
||||
operator: string // AssignmentOperator
|
||||
left: Expression
|
||||
right: Expression
|
||||
}
|
||||
interface UpdateExpression extends Expression {
|
||||
operator: string // UpdateOperator
|
||||
argument: Expression
|
||||
prefix: boolean
|
||||
}
|
||||
interface LogicalExpression extends Expression {
|
||||
operator: string // LogicalOperator
|
||||
left: Expression
|
||||
right: Expression
|
||||
}
|
||||
interface ConditionalExpression extends Expression {
|
||||
test: Expression
|
||||
alternate: Expression
|
||||
consequent: Expression
|
||||
}
|
||||
interface NewExpression extends Expression {
|
||||
callee: Expression
|
||||
arguments: Expression[]
|
||||
}
|
||||
interface CallExpression extends Expression {
|
||||
callee: Expression
|
||||
arguments: Expression[]
|
||||
}
|
||||
interface MemberExpression extends Expression {
|
||||
object: Expression
|
||||
property: IdentifierOrExpression // Identifier | Expression
|
||||
computed: boolean
|
||||
}
|
||||
interface IdentifierOrExpression extends Identifier, Expression {
|
||||
}
|
||||
|
||||
// Pattern
|
||||
// interface Pattern extends Node {
|
||||
// }
|
||||
|
||||
// Clauses
|
||||
interface SwitchCase extends Node {
|
||||
test: Expression
|
||||
consequent: Statement[]
|
||||
}
|
||||
interface CatchClause extends Node {
|
||||
param: Identifier // Pattern
|
||||
guard: Expression
|
||||
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" {
|
||||
|
||||
Reference in New Issue
Block a user