}, null);
var AST_Node = DEFNODE("Node", "start end", {
+ $documentation: "Base class of all AST nodes",
_walk: function(visitor) {
return visitor._visit(this);
},
}, null);
var AST_Debugger = DEFNODE("Debugger", null, {
+ $documentation: "Represents a debugger statement"
});
var AST_Directive = DEFNODE("Directive", "value", {
+ $documentation: "Represents a directive, like \"use strict\";"
});
/* -----[ loops ]----- */
var AST_LabeledStatement = DEFNODE("LabeledStatement", "label statement", {
+ $documentation: "Statement with a label",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.label._walk(visitor);
});
var AST_Statement = DEFNODE("Statement", "body", {
+ $documentation: "Base class of all statements",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.body._walk(visitor);
});
var AST_SimpleStatement = DEFNODE("SimpleStatement", null, {
+ $documentation: "A statement consisting of an expression, i.e. a = 1 + 2."
}, AST_Statement);
var AST_BlockStatement = DEFNODE("BlockStatement", null, {
+ $documentation: "A block statement.",
_walk: function(visitor) {
return visitor._visit(this, function(){
var a = this.body, i = 0, n = a.length;
}, AST_Statement);
var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
+ $documentation: "The empty statement (empty block or simply a semicolon).",
_walk: function(visitor) {
return visitor._visit(this);
}
}, AST_Statement);
var AST_DWLoop = DEFNODE("DWLoop", "condition", {
+ $documentation: "Base class for do/while statements.",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.condition._walk(visitor);
}, AST_Statement);
var AST_Do = DEFNODE("Do", null, {
+ $documentation: "A `do` statement"
}, AST_DWLoop);
var AST_While = DEFNODE("While", null, {
+ $documentation: "A `while` statement"
}, AST_DWLoop);
var AST_For = DEFNODE("For", "init condition step", {
+ $documentation: "A `for` statement",
_walk: function(visitor) {
return visitor._visit(this, function(){
if (this.init) this.init._walk(visitor);
}, AST_Statement);
var AST_ForIn = DEFNODE("ForIn", "init name object", {
+ $documentation: "A `for ... in` statement",
_walk: function(visitor) {
return visitor._visit(this, function(){
if (this.init) this.init._walk(visitor);
}, AST_Statement);
var AST_With = DEFNODE("With", "expression", {
+ $documentation: "A `with` statement",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.expression._walk(visitor);
/* -----[ scope and functions ]----- */
var AST_Scope = DEFNODE("Scope", null, {
+ $documentation: "Base class for all statements introducing a lexical scope",
initialize: function() {
this.labels = {};
this.variables = {};
}, AST_BlockStatement);
var AST_Toplevel = DEFNODE("Toplevel", null, {
+ $documentation: "The toplevel scope"
}, AST_Scope);
var AST_Lambda = DEFNODE("Lambda", "name argnames", {
+ $documentation: "Base class for functions",
initialize: function() {
AST_Scope.prototype.initialize.call(this);
this.uses_arguments = false;
}, AST_Scope);
var AST_Function = DEFNODE("Function", null, {
+ $documentation: "A function expression"
}, AST_Lambda);
var AST_Defun = DEFNODE("Defun", null, {
+ $documentation: "A function definition"
}, AST_Lambda);
/* -----[ JUMPS ]----- */
var AST_Jump = DEFNODE("Jump", null, {
+ $documentation: "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)"
});
var AST_Exit = DEFNODE("Exit", "value", {
+ $documentation: "Base class for “exits” (`return` and `throw`)",
_walk: function(visitor) {
return visitor._visit(this, this.value && function(){
this.value._walk(visitor);
}, AST_Jump);
var AST_Return = DEFNODE("Return", null, {
+ $documentation: "A `return` statement"
}, AST_Exit);
var AST_Throw = DEFNODE("Throw", null, {
+ $documentation: "A `throw` statement"
}, AST_Exit);
var AST_LoopControl = DEFNODE("LoopControl", "label", {
+ $documentation: "Base class for loop control statements (`break` and `continue`)",
_walk: function(visitor) {
return visitor._visit(this, this.label && function(){
this.label._walk(visitor);
}, AST_Jump);
var AST_Break = DEFNODE("Break", null, {
+ $documentation: "A `break` statement"
}, AST_LoopControl);
var AST_Continue = DEFNODE("Continue", null, {
+ $documentation: "A `continue` statement"
}, AST_LoopControl);
/* -----[ IF ]----- */
var AST_If = DEFNODE("If", "condition consequent alternative", {
+ $documentation: "A `if` statement",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.condition._walk(visitor);
/* -----[ SWITCH ]----- */
var AST_Switch = DEFNODE("Switch", "expression", {
+ $documentation: "A `switch` statement",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.expression._walk(visitor);
}, AST_Statement);
var AST_SwitchBlock = DEFNODE("SwitchBlock", null, {
+ $documentation: "The switch block is somewhat special, hence a special node for it"
}, AST_BlockStatement);
var AST_SwitchBranch = DEFNODE("SwitchBranch", null, {
+ $documentation: "Base class for `switch` branches"
}, AST_BlockStatement);
var AST_Default = DEFNODE("Default", null, {
+ $documentation: "A `default` switch branch",
_walk: function(visitor) {
return visitor._visit(this, function(){
AST_BlockStatement.prototype._walk.call(this, visitor);
}, AST_SwitchBranch);
var AST_Case = DEFNODE("Case", "expression", {
+ $documentation: "A `case` switch branch",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.expression._walk(visitor);
/* -----[ EXCEPTIONS ]----- */
var AST_Try = DEFNODE("Try", "btry bcatch bfinally", {
+ $documentation: "A `try` statement",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.btry._walk(visitor);
// we ever want to fix this then AST_Catch should inherit from
// AST_Scope.
var AST_Catch = DEFNODE("Catch", "argname", {
+ $documentation: "A `catch` node; only makes sense as part of a `try` statement",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.argname._walk(visitor);
}, AST_BlockStatement);
var AST_Finally = DEFNODE("Finally", null, {
+ $documentation: "A `finally` node; only makes sense as part of a `try` statement"
}, AST_BlockStatement);
/* -----[ VAR/CONST ]----- */
var AST_Definitions = DEFNODE("Definitions", "definitions", {
+ $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.definitions.forEach(function(def){
});
var AST_Var = DEFNODE("Var", null, {
+ $documentation: "A `var` statement"
}, AST_Definitions);
var AST_Const = DEFNODE("Const", null, {
+ $documentation: "A `const` statement"
}, AST_Definitions);
var AST_VarDef = DEFNODE("VarDef", "name value", {
+ $documentation: "A variable declaration; only appears in a AST_Definitions node",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.name._walk(visitor);
/* -----[ OTHER ]----- */
var AST_Call = DEFNODE("Call", "expression args", {
+ $documentation: "A function call expression",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.expression._walk(visitor);
});
var AST_New = DEFNODE("New", null, {
+ $documentation: "An object instantiation. Derives from a function call since it has exactly the same properties."
}, AST_Call);
var AST_Seq = DEFNODE("Seq", "first second", {
+ $documentation: "A sequence expression (two comma-separated expressions)",
_walk: function(visitor) {
return visitor._visit(this, function(){
this.first._walk(visitor);