ast-types 0.7.4 → 0.7.8

package/.travis.yml

@@ -4,3 +4,7 @@ node_js:
   - "0.10"
   - "0.8"
   - "0.6"
+
+matrix:
+  allow_failures:
+    - node_js: "0.6"

package/def/core.js

@@ -354,7 +354,24 @@ def("Literal")
         null, // isNull would also work here.
         isNumber,
         isRegExp
-    ));
+    ))
+    .field("regex", or({
+        pattern: isString,
+        flags: isString
+    }, 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
+        };
+    });
 
 // Abstract (non-buildable) comment supertype. Not a Node.
 def("Comment")

package/def/es6.js

@@ -62,6 +62,11 @@ def("ComprehensionBlock")
     .field("right", def("Expression"))
     .field("each", isBoolean);
 
+def("ModuleSpecifier")
+    .bases("Literal")
+    .build("value")
+    .field("value", isString);
+
 def("Property")
     // Esprima extensions not mentioned in the Mozilla Parser API:
     .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
@@ -205,7 +210,11 @@ def("ExportDeclaration")
         def("ExportSpecifier"),
         def("ExportBatchSpecifier")
     )], defaults.emptyArray)
-    .field("source", or(def("Literal"), null), defaults["null"]);
+    .field("source", or(
+        def("Literal"),
+        def("ModuleSpecifier"),
+        null
+    ), defaults["null"]);
 
 def("ImportDeclaration")
     .bases("Declaration")
@@ -215,7 +224,10 @@ def("ImportDeclaration")
         def("ImportNamespaceSpecifier"),
         def("ImportDefaultSpecifier")
     )], defaults.emptyArray)
-    .field("source", def("Literal"));
+    .field("source", or(
+        def("Literal"),
+        def("ModuleSpecifier")
+    ));
 
 def("TaggedTemplateExpression")
     .bases("Expression")

package/def/fb-harmony.js

@@ -4,6 +4,7 @@ var def = types.Type.def;
 var or = types.Type.or;
 var builtin = types.builtInTypes;
 var isString = builtin.string;
+var isNumber = builtin.number;
 var isBoolean = builtin.boolean;
 var defaults = require("../lib/shared").defaults;
 
@@ -114,6 +115,12 @@ def("VoidTypeAnnotation")
 def("NumberTypeAnnotation")
   .bases("Type");
 
+def("NumberLiteralTypeAnnotation")
+  .bases("Type")
+  .build("value", "raw")
+  .field("value", isNumber)
+  .field("raw", isString);
+
 def("StringTypeAnnotation")
   .bases("Type");
 
@@ -126,6 +133,12 @@ def("StringLiteralTypeAnnotation")
 def("BooleanTypeAnnotation")
   .bases("Type");
 
+def("BooleanLiteralTypeAnnotation")
+  .bases("Type")
+  .build("value", "raw")
+  .field("value", isBoolean)
+  .field("raw", isString);
+
 def("TypeAnnotation")
   .bases("Node")
   .build("typeAnnotation")

package/lib/types.js

@@ -478,7 +478,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", isString, function() { return self.typeName });
 
     // Override Dp.buildable for this Def instance.
     Object.defineProperty(self, "buildable", { value: true });
@@ -570,6 +570,13 @@ 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
@@ -678,9 +685,32 @@ Dp.finalize = function() {
 
         // A linearization of the inheritance hierarchy.
         populateSupertypeList(this.typeName, this.supertypeList);
+
+        if (this.buildable && this.supertypeList.lastIndexOf("Expression") >= 0) {
+            wrapExpressionBuilderWithStatement(this.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/package.json

@@ -18,7 +18,7 @@
     "transformation",
     "syntax"
   ],
-  "version": "0.7.4",
+  "version": "0.7.8",
   "homepage": "http://github.com/benjamn/ast-types",
   "repository": {
     "type": "git",