ast-types 0.7.5 → 0.8.2

package/.travis.yml

@@ -1,6 +1,14 @@
 language: node_js
 node_js:
+  - "0.12"
   - "0.11"
   - "0.10"
   - "0.8"
   - "0.6"
+  
+before_install:
+  npm install -g npm@'>=1.4.3'
+
+matrix:
+  allow_failures:
+    - node_js: "0.6"

package/def/babel.js

@@ -0,0 +1,101 @@
+require("./es7");
+
+var types = require("../lib/types");
+var defaults = require("../lib/shared").defaults;
+var def = types.Type.def;
+var or = types.Type.or;
+
+def("Noop")
+  .bases("Node")
+  .build();
+
+def("DoExpression")
+  .bases("Expression")
+  .build("body")
+  .field("body", [def("Statement")]);
+
+def("Super")
+  .bases("Expression")
+  .build();
+
+def("BindExpression")
+  .bases("Expression")
+  .build("object", "callee")
+  .field("object", or(def("Expression"), null))
+  .field("callee", def("Expression"));
+
+def("Decorator")
+  .bases("Node")
+  .build("expression")
+  .field("expression", def("Expression"));
+
+def("Property")
+  .field("decorators",
+         or([def("Decorator")], null),
+         defaults["null"]);
+
+def("MethodDefinition")
+  .field("decorators",
+         or([def("Decorator")], null),
+         defaults["null"]);
+
+def("MetaProperty")
+  .bases("Expression")
+  .build("meta", "property")
+  .field("meta", def("Identifier"))
+  .field("property", def("Identifier"));
+
+def("ParenthesizedExpression")
+  .bases("Expression")
+  .build("expression")
+  .field("expression", def("Expression"));
+
+def("ModuleSpecifier")
+  .bases("Specifier")
+  .field("local", def("Identifier"));
+
+def("ImportSpecifier")
+  .bases("ModuleSpecifier")
+  .build("imported", "local")
+  .field("imported", def("Identifier"));
+
+def("ImportDefaultSpecifier")
+  .bases("ModuleSpecifier")
+  .build("local");
+
+def("ImportNamespaceSpecifier")
+  .bases("ModuleSpecifier")
+  .build("local");
+
+def("ExportDefaultDeclaration")
+  .bases("Declaration")
+  .build("declaration")
+  .field("declaration", or(def("Declaration"), def("Expression")));
+
+def("ExportNamedDeclaration")
+  .bases("Declaration")
+  .build("declaration", "specifiers", "source")
+  .field("declaration", or(def("Declaration"), null))
+  .field("specifiers", [def("ExportSpecifier")], defaults.emptyArray)
+  .field("source", or(def("Literal"), null), defaults["null"]);
+
+def("ExportSpecifier")
+  .bases("ModuleSpecifier")
+  .build("local", "exported")
+  .field("exported", def("Identifier"));
+
+def("ExportNamespaceSpecifier")
+  .bases("Specifier")
+  .build("exported")
+  .field("exported", def("Identifier"));
+
+def("ExportDefaultSpecifier")
+  .bases("Specifier")
+  .build("exported")
+  .field("exported", def("Identifier"));
+
+def("ExportAllDeclaration")
+  .bases("Declaration")
+  .build("exported", "source")
+  .field("exported", or(def("Identifier"), null))
+  .field("source", def("Literal"));

package/def/core.js

@@ -2,11 +2,6 @@ var types = require("../lib/types");
 var Type = types.Type;
 var def = Type.def;
 var or = Type.or;
-var builtin = types.builtInTypes;
-var isString = builtin.string;
-var isNumber = builtin.number;
-var isBoolean = builtin.boolean;
-var isRegExp = builtin.RegExp;
 var shared = require("../lib/shared");
 var defaults = shared.defaults;
 var geq = shared.geq;
@@ -21,7 +16,7 @@ def("Printable")
 
 def("Node")
     .bases("Printable")
-    .field("type", isString)
+    .field("type", String)
     .field("comments", or(
         [def("Comment")],
         null
@@ -31,13 +26,18 @@ def("SourceLocation")
     .build("start", "end", "source")
     .field("start", def("Position"))
     .field("end", def("Position"))
-    .field("source", or(isString, null), defaults["null"]);
+    .field("source", or(String, null), defaults["null"]);
 
 def("Position")
     .build("line", "column")
     .field("line", geq(1))
     .field("column", geq(0));
 
+def("File")
+    .bases("Node")
+    .build("program")
+    .field("program", def("Program"));
+
 def("Program")
     .bases("Node")
     .build("body")
@@ -101,7 +101,7 @@ def("SwitchStatement")
     .build("discriminant", "cases", "lexical")
     .field("discriminant", def("Expression"))
     .field("cases", [def("SwitchCase")])
-    .field("lexical", isBoolean, defaults["false"]);
+    .field("lexical", Boolean, defaults["false"]);
 
 def("ReturnStatement")
     .bases("Statement")
@@ -158,13 +158,12 @@ def("ForStatement")
 
 def("ForInStatement")
     .bases("Statement")
-    .build("left", "right", "body", "each")
+    .build("left", "right", "body")
     .field("left", or(
         def("VariableDeclaration"),
         def("Expression")))
     .field("right", def("Expression"))
-    .field("body", def("Statement"))
-    .field("each", isBoolean);
+    .field("body", def("Statement"));
 
 def("DebuggerStatement").bases("Statement").build();
 
@@ -183,10 +182,7 @@ def("VariableDeclaration")
     .bases("Declaration")
     .build("kind", "declarations")
     .field("kind", or("var", "let", "const"))
-    .field("declarations", [or(
-        def("VariableDeclarator"),
-        def("Identifier") // TODO Esprima deviation.
-    )]);
+    .field("declarations", [def("VariableDeclarator")]);
 
 def("VariableDeclarator")
     .bases("Node")
@@ -215,8 +211,7 @@ def("Property")
     .build("kind", "key", "value")
     .field("kind", or("init", "get", "set"))
     .field("key", or(def("Literal"), def("Identifier")))
-    // esprima allows Pattern
-    .field("value", or(def("Expression"), def("Pattern")));
+    .field("value", def("Expression"));
 
 def("SequenceExpression")
     .bases("Expression")
@@ -232,9 +227,9 @@ def("UnaryExpression")
     .build("operator", "argument", "prefix")
     .field("operator", UnaryOperator)
     .field("argument", def("Expression"))
-    // TODO Esprima doesn't bother with this field, presumably because
-    // it's always true for unary operators.
-    .field("prefix", isBoolean, defaults["true"]);
+    // Esprima doesn't bother with this field, presumably because it's
+    // always true for unary operators.
+    .field("prefix", Boolean, defaults["true"]);
 
 var BinaryOperator = or(
     "==", "!=", "===", "!==",
@@ -271,7 +266,7 @@ def("UpdateExpression")
     .build("operator", "argument", "prefix")
     .field("operator", UpdateOperator)
     .field("argument", def("Expression"))
-    .field("prefix", isBoolean);
+    .field("prefix", Boolean);
 
 var LogicalOperator = or("||", "&&");
 
@@ -310,28 +305,10 @@ def("MemberExpression")
     .build("object", "property", "computed")
     .field("object", def("Expression"))
     .field("property", or(def("Identifier"), def("Expression")))
-    .field("computed", isBoolean, defaults["false"]);
+    .field("computed", Boolean, defaults["false"]);
 
 def("Pattern").bases("Node");
 
-def("ObjectPattern")
-    .bases("Pattern")
-    .build("properties")
-    // TODO File a bug to get PropertyPattern added to the interfaces API.
-    // esprima uses Property
-    .field("properties", [or(def("PropertyPattern"), def("Property"))]);
-
-def("PropertyPattern")
-    .bases("Pattern")
-    .build("key", "pattern")
-    .field("key", or(def("Literal"), def("Identifier")))
-    .field("pattern", def("Pattern"));
-
-def("ArrayPattern")
-    .bases("Pattern")
-    .build("elements")
-    .field("elements", [or(def("Pattern"), null)]);
-
 def("SwitchCase")
     .bases("Node")
     .build("test", "consequent")
@@ -342,48 +319,44 @@ def("Identifier")
     // But aren't Expressions and Patterns already Nodes? TODO Report this.
     .bases("Node", "Expression", "Pattern")
     .build("name")
-    .field("name", isString);
+    .field("name", String);
 
 def("Literal")
     // But aren't Expressions already Nodes? TODO Report this.
     .bases("Node", "Expression")
     .build("value")
-    .field("value", or(
-        isString,
-        isBoolean,
-        null, // isNull would also work here.
-        isNumber,
-        isRegExp
-    ))
+    .field("value", or(String, Boolean, null, Number, RegExp))
     .field("regex", or({
-        pattern: isString,
-        flags: isString
+        pattern: String,
+        flags: String
     }, null), function() {
-        if (!isRegExp.check(this.value))
-            return null;
-
-        var flags = "";
-        if (this.value.ignoreCase) flags += "i";
-        if (this.value.multiline) flags += "m";
-        if (this.value.global) flags += "g";
-
-        return {
-            pattern: this.value.source,
-            flags: flags
-        };
+        if (this.value instanceof RegExp) {
+            var flags = "";
+
+            if (this.value.ignoreCase) flags += "i";
+            if (this.value.multiline) flags += "m";
+            if (this.value.global) flags += "g";
+
+            return {
+                pattern: this.value.source,
+                flags: flags
+            };
+        }
+
+        return null;
     });
 
 // Abstract (non-buildable) comment supertype. Not a Node.
 def("Comment")
     .bases("Printable")
-    .field("value", isString)
+    .field("value", String)
     // A .leading comment comes before the node, whereas a .trailing
     // comment comes after it. These two fields should not both be true,
     // but they might both be false when the comment falls inside a node
     // and the node has no children for the comment to lead or trail,
     // e.g. { /*dangling*/ }.
-    .field("leading", isBoolean, defaults["true"])
-    .field("trailing", isBoolean, defaults["false"]);
+    .field("leading", Boolean, defaults["true"])
+    .field("trailing", Boolean, defaults["false"]);
 
 // Block comment. The .type really should be BlockComment rather than
 // Block, but that's what we're stuck with for now.

package/def/e4x.js

@@ -2,9 +2,6 @@ require("./core");
 var types = require("../lib/types");
 var def = types.Type.def;
 var or = types.Type.or;
-var builtin = types.builtInTypes;
-var isString = builtin.string;
-var isBoolean = builtin.boolean;
 
 // Note that none of these types are buildable because the Mozilla Parser
 // API doesn't specify any builder functions, and nobody uses E4X anymore.
@@ -19,12 +16,12 @@ def("XMLQualifiedIdentifier")
     .bases("Expression")
     .field("left", or(def("Identifier"), def("XMLAnyName")))
     .field("right", or(def("Identifier"), def("Expression")))
-    .field("computed", isBoolean);
+    .field("computed", Boolean);
 
 def("XMLFunctionQualifiedIdentifier")
     .bases("Expression")
     .field("right", or(def("Identifier"), def("Expression")))
-    .field("computed", isBoolean);
+    .field("computed", Boolean);
 
 def("XMLAttributeSelector")
     .bases("Expression")
@@ -51,7 +48,7 @@ def("XMLEscape")
 
 def("XMLText")
     .bases("XML")
-    .field("text", isString);
+    .field("text", String);
 
 def("XMLStartTag")
     .bases("XML")
@@ -67,21 +64,21 @@ def("XMLPointTag")
 
 def("XMLName")
     .bases("XML")
-    .field("contents", or(isString, [def("XML")]));
+    .field("contents", or(String, [def("XML")]));
 
 def("XMLAttribute")
     .bases("XML")
-    .field("value", isString);
+    .field("value", String);
 
 def("XMLCdata")
     .bases("XML")
-    .field("contents", isString);
+    .field("contents", String);
 
 def("XMLComment")
     .bases("XML")
-    .field("contents", isString);
+    .field("contents", String);
 
 def("XMLProcessingInstruction")
     .bases("XML")
-    .field("target", isString)
-    .field("contents", or(isString, null));
+    .field("target", String)
+    .field("contents", or(String, null));

package/def/es6.js

@@ -2,27 +2,34 @@ require("./core");
 var types = require("../lib/types");
 var def = types.Type.def;
 var or = types.Type.or;
-var builtin = types.builtInTypes;
-var isBoolean = builtin.boolean;
-var isObject = builtin.object;
-var isString = builtin.string;
 var defaults = require("../lib/shared").defaults;
 
 def("Function")
-    .field("generator", isBoolean, defaults["false"])
-    .field("expression", isBoolean, defaults["false"])
+    .field("generator", Boolean, defaults["false"])
+    .field("expression", Boolean, defaults["false"])
     .field("defaults", [or(def("Expression"), null)], defaults.emptyArray)
-    // TODO This could be represented as a SpreadElementPattern in .params.
+    // TODO This could be represented as a RestElement in .params.
     .field("rest", or(def("Identifier"), null), defaults["null"]);
 
+// The ESTree way of representing a ...rest parameter.
+def("RestElement")
+    .bases("Pattern")
+    .build("argument")
+    .field("argument", def("Pattern"));
+
+def("SpreadElementPattern")
+    .bases("Pattern")
+    .build("argument")
+    .field("argument", def("Pattern"));
+
 def("FunctionDeclaration")
     .build("id", "params", "body", "generator", "expression");
 
 def("FunctionExpression")
     .build("id", "params", "body", "generator", "expression");
 
-// TODO The Parser API calls this ArrowExpression, but Esprima uses
-// ArrowFunctionExpression.
+// The Parser API calls this ArrowExpression, but Esprima and all other
+// actual parsers use ArrowFunctionExpression.
 def("ArrowFunctionExpression")
     .bases("Function", "Expression")
     .build("params", "body", "expression")
@@ -39,7 +46,7 @@ def("YieldExpression")
     .bases("Expression")
     .build("argument", "delegate")
     .field("argument", or(def("Expression"), null))
-    .field("delegate", isBoolean, defaults["false"]);
+    .field("delegate", Boolean, defaults["false"]);
 
 def("GeneratorExpression")
     .bases("Expression")
@@ -60,27 +67,40 @@ def("ComprehensionBlock")
     .build("left", "right", "each")
     .field("left", def("Pattern"))
     .field("right", def("Expression"))
-    .field("each", isBoolean);
+    .field("each", Boolean);
 
 def("Property")
-    // Esprima extensions not mentioned in the Mozilla Parser API:
     .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
-    .field("method", isBoolean, defaults["false"])
-    .field("shorthand", isBoolean, defaults["false"])
-    .field("computed", isBoolean, defaults["false"]);
+    .field("value", or(def("Expression"), def("Pattern")))
+    .field("method", Boolean, defaults["false"])
+    .field("shorthand", Boolean, defaults["false"])
+    .field("computed", Boolean, defaults["false"]);
 
 def("PropertyPattern")
+    .bases("Pattern")
+    .build("key", "pattern")
     .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
-    .field("computed", isBoolean, defaults["false"]);
+    .field("pattern", def("Pattern"))
+    .field("computed", Boolean, defaults["false"]);
+
+def("ObjectPattern")
+    .bases("Pattern")
+    .build("properties")
+    .field("properties", [or(def("PropertyPattern"), def("Property"))]);
+
+def("ArrayPattern")
+    .bases("Pattern")
+    .build("elements")
+    .field("elements", [or(def("Pattern"), null)]);
 
 def("MethodDefinition")
     .bases("Declaration")
     .build("kind", "key", "value", "static")
-    .field("kind", or("init", "get", "set", ""))
+    .field("kind", or("constructor", "method", "get", "set"))
     .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
     .field("value", def("Function"))
-    .field("computed", isBoolean, defaults["false"])
-    .field("static", isBoolean, defaults["false"]);
+    .field("computed", Boolean, defaults["false"])
+    .field("static", Boolean, defaults["false"]);
 
 def("SpreadElement")
     .bases("Node")
@@ -96,18 +116,17 @@ def("NewExpression")
 def("CallExpression")
     .field("arguments", [or(def("Expression"), def("SpreadElement"))]);
 
-def("SpreadElementPattern")
+// Note: this node type is *not* an AssignmentExpression with a Pattern on
+// the left-hand side! The existing AssignmentExpression type already
+// supports destructuring assignments. AssignmentPattern nodes may appear
+// wherever a Pattern is allowed, and the right-hand side represents a
+// default value to be destructured against the left-hand side, if no
+// value is otherwise provided. For example: default parameter values.
+def("AssignmentPattern")
     .bases("Pattern")
-    .build("argument")
-    .field("argument", def("Pattern"));
-
-def("ArrayPattern")
-    .field("elements", [or(
-        def("Pattern"),
-        null,
-        // used by esprima
-        def("SpreadElement")
-    )]);
+    .build("left", "right")
+    .field("left", def("Pattern"))
+    .field("right", def("Expression"));
 
 var ClassBodyElement = or(
     def("MethodDefinition"),
@@ -120,7 +139,7 @@ def("ClassProperty")
   .bases("Declaration")
   .build("key")
   .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
-  .field("computed", isBoolean, defaults["false"]);
+  .field("computed", Boolean, defaults["false"]);
 
 def("ClassPropertyDefinition") // static property
     .bases("Declaration")
@@ -157,68 +176,10 @@ def("ClassImplements")
 // Specifier and NamedSpecifier are abstract non-standard types that I
 // introduced for definitional convenience.
 def("Specifier").bases("Node");
-def("NamedSpecifier")
-    .bases("Specifier")
-    // Note: this abstract type is intentionally not buildable.
-    .field("id", def("Identifier"))
-    .field("name", or(def("Identifier"), null), defaults["null"]);
-
-// Like NamedSpecifier, except type:"ExportSpecifier" and buildable.
-// export {<id [as name]>} [from ...];
-def("ExportSpecifier")
-    .bases("NamedSpecifier")
-    .build("id", "name");
-
-// export <*> from ...;
-def("ExportBatchSpecifier")
-    .bases("Specifier")
-    .build();
-
-// Like NamedSpecifier, except type:"ImportSpecifier" and buildable.
-// import {<id [as name]>} from ...;
-def("ImportSpecifier")
-    .bases("NamedSpecifier")
-    .build("id", "name");
-
-// import <* as id> from ...;
-def("ImportNamespaceSpecifier")
-    .bases("Specifier")
-    .build("id")
-    .field("id", def("Identifier"));
-
-// import <id> from ...;
-def("ImportDefaultSpecifier")
-    .bases("Specifier")
-    .build("id")
-    .field("id", def("Identifier"));
-
-def("ExportDeclaration")
-    .bases("Declaration")
-    .build("default", "declaration", "specifiers", "source")
-    .field("default", isBoolean)
-    .field("declaration", or(
-        def("Declaration"),
-        def("Expression"), // Implies default.
-        null
-    ))
-    .field("specifiers", [or(
-        def("ExportSpecifier"),
-        def("ExportBatchSpecifier")
-    )], defaults.emptyArray)
-    .field("source", or(def("Literal"), null), defaults["null"]);
-
-def("ImportDeclaration")
-    .bases("Declaration")
-    .build("specifiers", "source")
-    .field("specifiers", [or(
-        def("ImportSpecifier"),
-        def("ImportNamespaceSpecifier"),
-        def("ImportDefaultSpecifier")
-    )], defaults.emptyArray)
-    .field("source", def("Literal"));
 
 def("TaggedTemplateExpression")
     .bases("Expression")
+    .build("tag", "quasi")
     .field("tag", def("Expression"))
     .field("quasi", def("TemplateLiteral"));
 
@@ -231,5 +192,5 @@ def("TemplateLiteral")
 def("TemplateElement")
     .bases("Node")
     .build("value", "tail")
-    .field("value", {"cooked": isString, "raw": isString})
-    .field("tail", isBoolean);
+    .field("value", {"cooked": String, "raw": String})
+    .field("tail", Boolean);

package/def/es7.js

@@ -1,13 +1,13 @@
-require("./core");
+require("./es6");
+
 var types = require("../lib/types");
 var def = types.Type.def;
 var or = types.Type.or;
 var builtin = types.builtInTypes;
-var isBoolean = builtin.boolean;
 var defaults = require("../lib/shared").defaults;
 
 def("Function")
-    .field("async", isBoolean, defaults["false"]);
+    .field("async", Boolean, defaults["false"]);
 
 def("SpreadProperty")
     .bases("Node")
@@ -24,15 +24,13 @@ def("SpreadPropertyPattern")
 
 def("ObjectPattern")
     .field("properties", [or(
-        def("PropertyPattern"),
-        def("SpreadPropertyPattern"),
-        // used by esprima
         def("Property"),
-        def("SpreadProperty")
+        def("PropertyPattern"),
+        def("SpreadPropertyPattern")
     )]);
 
 def("AwaitExpression")
     .bases("Expression")
     .build("argument", "all")
     .field("argument", or(def("Expression"), null))
-    .field("all", isBoolean, defaults["false"]);
+    .field("all", Boolean, defaults["false"]);

package/def/esprima.js

@@ -0,0 +1,96 @@
+require("./es7");
+
+var types = require("../lib/types");
+var defaults = require("../lib/shared").defaults;
+var def = types.Type.def;
+var or = types.Type.or;
+
+def("VariableDeclaration")
+    .field("declarations", [or(
+        def("VariableDeclarator"),
+        def("Identifier") // Esprima deviation.
+    )]);
+
+def("Property")
+    .field("value", or(
+        def("Expression"),
+        def("Pattern") // Esprima deviation.
+    ));
+
+def("ArrayPattern")
+    .field("elements", [or(
+        def("Pattern"),
+        def("SpreadElement"),
+        null
+    )]);
+
+def("ObjectPattern")
+    .field("properties", [or(
+        def("Property"),
+        def("PropertyPattern"),
+        def("SpreadPropertyPattern"),
+        def("SpreadProperty") // Used by Esprima.
+    )]);
+
+def("NamedSpecifier")
+    .bases("Specifier")
+    // Note: this abstract type is intentionally not buildable.
+    .field("id", def("Identifier"))
+    .field("name", or(def("Identifier"), null), defaults["null"]);
+
+// Like NamedSpecifier, except type:"ExportSpecifier" and buildable.
+// export {<id [as name]>} [from ...];
+def("ExportSpecifier")
+    .bases("NamedSpecifier")
+    .build("id", "name");
+
+// export <*> from ...;
+def("ExportBatchSpecifier")
+    .bases("Specifier")
+    .build();
+
+// Like NamedSpecifier, except type:"ImportSpecifier" and buildable.
+// import {<id [as name]>} from ...;
+def("ImportSpecifier")
+    .bases("NamedSpecifier")
+    .build("id", "name");
+
+// import <* as id> from ...;
+def("ImportNamespaceSpecifier")
+    .bases("Specifier")
+    .build("id")
+    .field("id", def("Identifier"));
+
+// import <id> from ...;
+def("ImportDefaultSpecifier")
+    .bases("Specifier")
+    .build("id")
+    .field("id", def("Identifier"));
+
+def("ExportDeclaration")
+    .bases("Declaration")
+    .build("default", "declaration", "specifiers", "source")
+    .field("default", Boolean)
+    .field("declaration", or(
+        def("Declaration"),
+        def("Expression"), // Implies default.
+        null
+    ))
+    .field("specifiers", [or(
+        def("ExportSpecifier"),
+        def("ExportBatchSpecifier")
+    )], defaults.emptyArray)
+    .field("source", or(
+        def("Literal"),
+        null
+    ), defaults["null"]);
+
+def("ImportDeclaration")
+    .bases("Declaration")
+    .build("specifiers", "source")
+    .field("specifiers", [or(
+        def("ImportSpecifier"),
+        def("ImportNamespaceSpecifier"),
+        def("ImportDefaultSpecifier")
+    )], defaults.emptyArray)
+    .field("source", def("Literal"));

package/def/fb-harmony.js

@@ -1,10 +1,8 @@
-require("./core");
+require("./es7");
+
 var types = require("../lib/types");
 var def = types.Type.def;
 var or = types.Type.or;
-var builtin = types.builtInTypes;
-var isString = builtin.string;
-var isBoolean = builtin.boolean;
 var defaults = require("../lib/shared").defaults;
 
 def("JSXAttribute")
@@ -20,7 +18,7 @@ def("JSXAttribute")
 def("JSXIdentifier")
     .bases("Identifier")
     .build("name")
-    .field("name", isString);
+    .field("name", String);
 
 def("JSXNamespacedName")
     .bases("Node")
@@ -33,7 +31,7 @@ def("JSXMemberExpression")
     .build("object", "property")
     .field("object", or(def("JSXIdentifier"), def("JSXMemberExpression")))
     .field("property", def("JSXIdentifier"))
-    .field("computed", isBoolean, defaults.false);
+    .field("computed", Boolean, defaults.false);
 
 var JSXElementName = or(
     def("JSXIdentifier"),
@@ -75,7 +73,7 @@ def("JSXElement")
         // guaranteed to be available.
         return this.openingElement.name;
     })
-    .field("selfClosing", isBoolean, function() {
+    .field("selfClosing", Boolean, function() {
         return this.openingElement.selfClosing;
     })
     .field("attributes", JSXAttributes, function() {
@@ -87,7 +85,7 @@ def("JSXOpeningElement")
     .build("name", "attributes", "selfClosing")
     .field("name", JSXElementName)
     .field("attributes", JSXAttributes, defaults.emptyArray)
-    .field("selfClosing", isBoolean, defaults["false"]);
+    .field("selfClosing", Boolean, defaults["false"]);
 
 def("JSXClosingElement")
     .bases("Node") // TODO Same concern.
@@ -97,34 +95,54 @@ def("JSXClosingElement")
 def("JSXText")
     .bases("Literal")
     .build("value")
-    .field("value", isString);
+    .field("value", String);
 
 def("JSXEmptyExpression").bases("Expression").build();
 
 // Type Annotations
-def("Type")
-  .bases("Node");
+def("Type").bases("Node");
 
 def("AnyTypeAnnotation")
-  .bases("Type");
+  .bases("Type")
+  .build();
+
+def("MixedTypeAnnotation")
+  .bases("Type")
+  .build();
 
 def("VoidTypeAnnotation")
-  .bases("Type");
+  .bases("Type")
+  .build();
 
 def("NumberTypeAnnotation")
-  .bases("Type");
+  .bases("Type")
+  .build();
+
+def("NumberLiteralTypeAnnotation")
+  .bases("Type")
+  .build("value", "raw")
+  .field("value", Number)
+  .field("raw", String);
 
 def("StringTypeAnnotation")
-  .bases("Type");
+  .bases("Type")
+  .build();
 
 def("StringLiteralTypeAnnotation")
   .bases("Type")
   .build("value", "raw")
-  .field("value", isString)
-  .field("raw", isString);
+  .field("value", String)
+  .field("raw", String);
 
 def("BooleanTypeAnnotation")
-  .bases("Type");
+  .bases("Type")
+  .build();
+
+def("BooleanLiteralTypeAnnotation")
+  .bases("Type")
+  .build("value", "raw")
+  .field("value", Boolean)
+  .field("raw", String);
 
 def("TypeAnnotation")
   .bases("Node")
@@ -149,7 +167,7 @@ def("FunctionTypeParam")
   .build("name", "typeAnnotation", "optional")
   .field("name", def("Identifier"))
   .field("typeAnnotation", def("Type"))
-  .field("optional", isBoolean);
+  .field("optional", Boolean);
 
 def("ArrayTypeAnnotation")
   .bases("Type")
@@ -161,14 +179,16 @@ def("ObjectTypeAnnotation")
   .build("properties")
   .field("properties", [def("ObjectTypeProperty")])
   .field("indexers", [def("ObjectTypeIndexer")], defaults.emptyArray)
-  .field("callProperties", [def("ObjectTypeCallProperty")], defaults.emptyArray);
+  .field("callProperties",
+         [def("ObjectTypeCallProperty")],
+         defaults.emptyArray);
 
 def("ObjectTypeProperty")
   .bases("Node")
   .build("key", "value", "optional")
   .field("key", or(def("Literal"), def("Identifier")))
   .field("value", def("Type"))
-  .field("optional", isBoolean);
+  .field("optional", Boolean);
 
 def("ObjectTypeIndexer")
   .bases("Node")
@@ -181,12 +201,14 @@ def("ObjectTypeCallProperty")
   .bases("Node")
   .build("value")
   .field("value", def("FunctionTypeAnnotation"))
-  .field("static", isBoolean, false);
+  .field("static", Boolean, false);
 
 def("QualifiedTypeIdentifier")
   .bases("Node")
   .build("qualification", "id")
-  .field("qualification", or(def("Identifier"), def("QualifiedTypeIdentifier")))
+  .field("qualification",
+         or(def("Identifier"),
+            def("QualifiedTypeIdentifier")))
   .field("id", def("Identifier"));
 
 def("GenericTypeAnnotation")
@@ -199,7 +221,9 @@ def("MemberTypeAnnotation")
   .bases("Type")
   .build("object", "property")
   .field("object", def("Identifier"))
-  .field("property", or(def("MemberTypeAnnotation"), def("GenericTypeAnnotation")));
+  .field("property",
+         or(def("MemberTypeAnnotation"),
+            def("GenericTypeAnnotation")));
 
 def("UnionTypeAnnotation")
   .bases("Type")
@@ -230,22 +254,30 @@ def("TypeParameterInstantiation")
   .field("params", [def("Type")]);
 
 def("Function")
-  .field("returnType", or(def("TypeAnnotation"), null), defaults["null"])
-  .field("typeParameters", or(def("TypeParameterDeclaration"), null), defaults["null"]);
+  .field("returnType",
+         or(def("TypeAnnotation"), null),
+         defaults["null"])
+  .field("typeParameters",
+         or(def("TypeParameterDeclaration"), null),
+         defaults["null"]);
 
 def("ClassProperty")
   .build("key", "typeAnnotation")
   .field("typeAnnotation", def("TypeAnnotation"))
-  .field("static", isBoolean, false);
+  .field("static", Boolean, false);
 
 def("ClassImplements")
-  .field("typeParameters", or(def("TypeParameterInstantiation"), null), defaults["null"]);
+  .field("typeParameters",
+         or(def("TypeParameterInstantiation"), null),
+         defaults["null"]);
 
 def("InterfaceDeclaration")
   .bases("Statement")
   .build("id", "body", "extends")
   .field("id", def("Identifier"))
-  .field("typeParameters", or(def("TypeParameterDeclaration"), null), defaults["null"])
+  .field("typeParameters",
+         or(def("TypeParameterDeclaration"), null),
+         defaults["null"])
   .field("body", def("ObjectTypeAnnotation"))
   .field("extends", [def("InterfaceExtends")]);
 

package/def/mozilla.js

@@ -2,12 +2,18 @@ require("./core");
 var types = require("../lib/types");
 var def = types.Type.def;
 var or = types.Type.or;
-var geq = require("../lib/shared").geq;
+var shared = require("../lib/shared");
+var geq = shared.geq;
+var defaults = shared.defaults;
 
 def("Function")
     // SpiderMonkey allows expression closures: function(x) x+1
     .field("body", or(def("BlockStatement"), def("Expression")));
 
+def("ForInStatement")
+    .build("left", "right", "body", "each")
+    .field("each", Boolean, defaults["false"]);
+
 def("ForOfStatement")
     .bases("Statement")
     .build("left", "right", "body")

package/lib/types.js

@@ -80,27 +80,33 @@ Tp.toString = function() {
     return name + " type";
 };
 
+var builtInCtorFns = [];
+var builtInCtorTypes = [];
 var builtInTypes = {};
 exports.builtInTypes = builtInTypes;
 
 function defBuiltInType(example, name) {
     var objStr = objToStr.call(example);
 
-    Object.defineProperty(builtInTypes, name, {
-        enumerable: true,
-        value: new Type(function(value) {
-            return objToStr.call(value) === objStr;
-        }, name)
-    });
+    var type = new Type(function(value) {
+        return objToStr.call(value) === objStr;
+    }, name);
 
-    return builtInTypes[name];
+    builtInTypes[name] = type;
+
+    if (example && typeof example.constructor === "function") {
+        builtInCtorFns.push(example.constructor);
+        builtInCtorTypes.push(type);
+    }
+
+    return type;
 }
 
 // These types check the underlying [[Class]] attribute of the given
 // value, rather than using the problematic typeof operator. Note however
 // that no subtyping is considered; so, for instance, isObject.check
 // returns false for [], /./, new Date, and null.
-var isString = defBuiltInType("", "string");
+var isString = defBuiltInType("truthy", "string");
 var isFunction = defBuiltInType(function(){}, "function");
 var isArray = defBuiltInType([], "array");
 var isObject = defBuiltInType({}, "object");
@@ -132,10 +138,17 @@ function toType(from, name) {
     if (isObject.check(from))
         return Type.fromObject(from);
 
-    // If isFunction.check(from), assume that from is a binary predicate
-    // function we can use to define the type.
-    if (isFunction.check(from))
+    if (isFunction.check(from)) {
+        var bicfIndex = builtInCtorFns.indexOf(from);
+        if (bicfIndex >= 0) {
+            return builtInCtorTypes[bicfIndex];
+        }
+
+        // If isFunction.check(from), and from is not a built-in
+        // constructor, assume from is a binary predicate function we can
+        // use to define the type.
         return new Type(from, name);
+    }
 
     // As a last resort, toType returns a type that matches any value that
     // is === from. This is primarily useful for literal values like
@@ -324,7 +337,7 @@ exports.computeSupertypeLookupTable = function(candidates) {
     for (var i = 0; i < typeNameCount; ++i) {
         var typeName = typeNames[i];
         var d = defCache[typeName];
-        assert.strictEqual(d.finalized, true);
+        assert.strictEqual(d.finalized, true, typeName);
         for (var j = 0; j < d.supertypeList.length; ++j) {
             var superTypeName = d.supertypeList[j];
             if (hasOwn.call(candidates, superTypeName)) {
@@ -339,7 +352,7 @@ exports.computeSupertypeLookupTable = function(candidates) {
 
 Dp.checkAllFields = function(value, deep) {
     var allFields = this.allFields;
-    assert.strictEqual(this.finalized, true);
+    assert.strictEqual(this.finalized, true, this.typeName);
 
     function checkFieldByName(name) {
         var field = allFields[name];
@@ -403,11 +416,15 @@ Dp.check = function(value, deep) {
 };
 
 Dp.bases = function() {
+    var args = slice.call(arguments);
     var bases = this.baseNames;
 
-    assert.strictEqual(this.finalized, false);
+    if (this.finalized) {
+        assert.deepEqual(args, bases);
+        return this;
+    }
 
-    each.call(arguments, function(baseName) {
+    args.forEach(function(baseName) {
         isString.assert(baseName);
 
         // This indexOf lookup may be O(n), but the typical number of base
@@ -450,6 +467,8 @@ exports.defineMethod = function(name, func) {
     return old;
 };
 
+var isArrayOfString = isString.arrayOf();
+
 // Calling the .build method of a Def simultaneously marks the type as
 // buildable (by defining builders[getBuilderName(typeName)]) and
 // specifies the order of arguments that should be passed to the builder
@@ -457,18 +476,18 @@ exports.defineMethod = function(name, func) {
 Dp.build = function(/* param1, param2, ... */) {
     var self = this;
 
+    var newBuildParams = slice.call(arguments);
+    isArrayOfString.assert(newBuildParams);
+
     // Calling Def.prototype.build multiple times has the effect of merely
     // redefining this property.
     Object.defineProperty(self, "buildParams", {
-        value: slice.call(arguments),
+        value: newBuildParams,
         writable: false,
         enumerable: false,
         configurable: true
     });
 
-    assert.strictEqual(self.finalized, false);
-    isString.arrayOf().assert(self.buildParams);
-
     if (self.buildable) {
         // If this Def is already buildable, update self.buildParams and
         // continue using the old builder function.
@@ -478,7 +497,7 @@ Dp.build = function(/* param1, param2, ... */) {
     // Every buildable type will have its "type" field filled in
     // automatically. This includes types that are not subtypes of Node,
     // like SourceLocation, but that seems harmless (TODO?).
-    self.field("type", self.typeName, function() { return self.typeName });
+    self.field("type", String, function() { return self.typeName });
 
     // Override Dp.buildable for this Def instance.
     Object.defineProperty(self, "buildable", { value: true });
@@ -570,13 +589,25 @@ function getBuilderName(typeName) {
         }
     });
 }
+exports.getBuilderName = getBuilderName;
+
+function getStatementBuilderName(typeName) {
+    typeName = getBuilderName(typeName);
+    return typeName.replace(/(Expression)?$/, "Statement");
+}
+exports.getStatementBuilderName = getStatementBuilderName;
 
 // The reason fields are specified using .field(...) instead of an object
 // literal syntax is somewhat subtle: the object literal syntax would
 // support only one key and one value, but with .field(...) we can pass
 // any number of arguments to specify the field.
 Dp.field = function(name, type, defaultFn, hidden) {
-    assert.strictEqual(this.finalized, false);
+    if (this.finalized) {
+        console.error("Ignoring attempt to redefine field " +
+                      JSON.stringify(name) + " of finalized type " +
+                      JSON.stringify(this.typeName));
+        return this;
+    }
     this.ownFields[name] = new Field(name, type, defaultFn, hidden);
     return this; // For chaining.
 };
@@ -643,44 +674,77 @@ exports.someField = function(object, callback, context) {
 Object.defineProperty(Dp, "finalized", { value: false });
 
 Dp.finalize = function() {
+    var self = this;
+
     // It's not an error to finalize a type more than once, but only the
     // first call to .finalize does anything.
-    if (!this.finalized) {
-        var allFields = this.allFields;
-        var allSupertypes = this.allSupertypes;
+    if (!self.finalized) {
+        var allFields = self.allFields;
+        var allSupertypes = self.allSupertypes;
 
-        this.baseNames.forEach(function(name) {
+        self.baseNames.forEach(function(name) {
             var def = defCache[name];
-            def.finalize();
-            extend(allFields, def.allFields);
-            extend(allSupertypes, def.allSupertypes);
+            if (def instanceof Def) {
+                def.finalize();
+                extend(allFields, def.allFields);
+                extend(allSupertypes, def.allSupertypes);
+            } else {
+                var message = "unknown supertype name " +
+                    JSON.stringify(name) +
+                    " for subtype " +
+                    JSON.stringify(self.typeName);
+                assert.ok(false, message);
+            }
         });
 
         // TODO Warn if fields are overridden with incompatible types.
-        extend(allFields, this.ownFields);
-        allSupertypes[this.typeName] = this;
+        extend(allFields, self.ownFields);
+        allSupertypes[self.typeName] = self;
 
-        this.fieldNames.length = 0;
+        self.fieldNames.length = 0;
         for (var fieldName in allFields) {
             if (hasOwn.call(allFields, fieldName) &&
                 !allFields[fieldName].hidden) {
-                this.fieldNames.push(fieldName);
+                self.fieldNames.push(fieldName);
             }
         }
 
         // Types are exported only once they have been finalized.
-        Object.defineProperty(namedTypes, this.typeName, {
+        Object.defineProperty(namedTypes, self.typeName, {
             enumerable: true,
-            value: this.type
+            value: self.type
         });
 
-        Object.defineProperty(this, "finalized", { value: true });
+        Object.defineProperty(self, "finalized", { value: true });
 
         // A linearization of the inheritance hierarchy.
-        populateSupertypeList(this.typeName, this.supertypeList);
+        populateSupertypeList(self.typeName, self.supertypeList);
+
+        if (self.buildable && self.supertypeList.lastIndexOf("Expression") >= 0) {
+            wrapExpressionBuilderWithStatement(self.typeName);
+        }
     }
 };
 
+// Adds an additional builder for Expression subtypes
+// that wraps the built Expression in an ExpressionStatements.
+function wrapExpressionBuilderWithStatement(typeName) {
+    var wrapperName = getStatementBuilderName(typeName);
+
+    // skip if the builder already exists
+    if (builders[wrapperName]) return;
+
+    // the builder function to wrap with builders.ExpressionStatement
+    var wrapped = builders[getBuilderName(typeName)];
+
+    // skip if there is nothing to wrap
+    if (!wrapped) return;
+
+    builders[wrapperName] = function() {
+        return builders.expressionStatement(wrapped.apply(builders, arguments));
+    };
+}
+
 function populateSupertypeList(typeName, list) {
     list.length = 0;
     list.push(typeName);

package/main.js

@@ -11,6 +11,8 @@ require("./def/es7");
 require("./def/mozilla");
 require("./def/e4x");
 require("./def/fb-harmony");
+require("./def/esprima");
+require("./def/babel");
 
 types.finalize();
 

package/package.json

@@ -18,7 +18,7 @@
     "transformation",
     "syntax"
   ],
-  "version": "0.7.5",
+  "version": "0.8.2",
   "homepage": "http://github.com/benjamn/ast-types",
   "repository": {
     "type": "git",
@@ -27,16 +27,16 @@
   "license": "MIT",
   "main": "main.js",
   "scripts": {
-    "test": "mocha --reporter spec test/run.js"
-  },
-  "dependencies": {
+    "test": "mocha --reporter spec --full-trace test/run.js"
   },
+  "dependencies": {},
   "devDependencies": {
+    "babel-core": "^5.6.15",
     "esprima": "~1.2.2",
     "esprima-fb": "~14001.1.0-dev-harmony-fb",
-    "mocha": "~1.20.1"
+    "mocha": "~2.2.5"
   },
   "engines": {
-    "node": ">= 0.6"
+    "node": ">= 0.8"
   }
 }