ast-types 0.3.34 → 0.3.38

package/def/core.js

@@ -16,7 +16,7 @@ def("Node")
     .field("loc", or(
         def("SourceLocation"),
         null
-    ), defaults["null"]);
+    ), defaults["null"], true);
 
 def("SourceLocation")
     .build("start", "end", "source")

package/def/es6.js

@@ -80,7 +80,8 @@ def("ModuleDeclaration")
 def("Property")
     // Esprima extensions not mentioned in the Mozilla Parser API:
     .field("method", isBoolean, defaults["false"])
-    .field("shorthand", isBoolean, defaults["false"]);
+    .field("shorthand", isBoolean, defaults["false"])
+    .field("computed", isBoolean, defaults["false"]);
 
 def("MethodDefinition")
     .bases("Declaration")

package/def/es7.js

@@ -32,4 +32,4 @@ def("AwaitExpression")
     .bases("Expression")
     .build("argument", "all")
     .field("argument", or(def("Expression"), null))
-    .field("all", isBoolean, false);
+    .field("all", isBoolean, defaults["false"]);

package/lib/node-path.js

@@ -129,7 +129,7 @@ NPp.needsParens = function(assumeExpressionContext) {
     if (!n.Expression.check(node))
         return false;
 
-    if (n.UnaryExpression.check(node))
+    if (isUnaryLike(node))
         return n.MemberExpression.check(parent)
             && this.name === "object"
             && parent.object === node;
@@ -141,7 +141,7 @@ NPp.needsParens = function(assumeExpressionContext) {
             return true;
         }
 
-        if (n.UnaryExpression.check(parent))
+        if (isUnaryLike(parent))
             return true;
 
         if (n.MemberExpression.check(parent) &&
@@ -192,7 +192,7 @@ NPp.needsParens = function(assumeExpressionContext) {
             || n.MemberExpression.check(parent)
             || n.NewExpression.check(parent)
             || n.ConditionalExpression.check(parent)
-            || n.UnaryExpression.check(parent)
+            || isUnaryLike(parent)
             || n.YieldExpression.check(parent);
 
     if (n.NewExpression.check(parent) &&
@@ -211,7 +211,7 @@ NPp.needsParens = function(assumeExpressionContext) {
 
     if (n.AssignmentExpression.check(node) ||
         n.ConditionalExpression.check(node)) {
-        if (n.UnaryExpression.check(parent))
+        if (isUnaryLike(parent))
             return true;
 
         if (isBinary(parent))
@@ -249,6 +249,14 @@ function isBinary(node) {
         || n.LogicalExpression.check(node);
 }
 
+function isUnaryLike(node) {
+    return n.UnaryExpression.check(node)
+        // I considered making SpreadElement and SpreadProperty subtypes
+        // of UnaryExpression, but they're not really Expression nodes.
+        || (n.SpreadElement && n.SpreadElement.check(node))
+        || (n.SpreadProperty && n.SpreadProperty.check(node));
+}
+
 var PRECEDENCE = {};
 [["||"],
  ["&&"],

package/lib/types.js

@@ -44,7 +44,7 @@ var Tp = Type.prototype;
 
 // Throughout this file we use Object.defineProperty to prevent
 // redefinition of exported properties.
-Object.defineProperty(exports, "Type", { value: Type });
+exports.Type = Type;
 
 // Like .check, except that failure triggers an AssertionError.
 Tp.assert = function(value, deep) {
@@ -81,10 +81,7 @@ Tp.toString = function() {
 };
 
 var builtInTypes = {};
-Object.defineProperty(exports, "builtInTypes", {
-    enumerable: true,
-    value: builtInTypes
-});
+exports.builtInTypes = builtInTypes;
 
 function defBuiltInType(example, name) {
     var objStr = objToStr.call(example);
@@ -268,7 +265,9 @@ function Def(typeName) {
 
         // These two are populated during finalization.
         allSupertypes: { value: {} }, // Includes own typeName.
+        supertypeList: { value: [] }, // Linear inheritance hierarchy.
         allFields: { value: {} }, // Includes inherited fields.
+        fieldNames: { value: [] }, // Non-hidden keys of allFields.
 
         type: {
             value: new Type(function(value, deep) {
@@ -279,14 +278,18 @@ function Def(typeName) {
 }
 
 Def.fromValue = function(value) {
-    if (isObject.check(value) &&
-        hasOwn.call(value, "type") &&
-        hasOwn.call(defCache, value.type))
-    {
-        var vDef = defCache[value.type];
-        assert.strictEqual(vDef.finalized, true);
-        return vDef;
+    if (value && typeof value === "object") {
+        var type = value.type;
+        if (typeof type === "string" &&
+            hasOwn.call(defCache, type)) {
+            var d = defCache[type];
+            if (d.finalized) {
+                return d;
+            }
+        }
     }
+
+    return null;
 };
 
 var Dp = Def.prototype;
@@ -301,6 +304,29 @@ Dp.isSupertypeOf = function(that) {
     }
 };
 
+// Returns an object mapping from every known type in the defCache to the
+// most specific supertype whose name is an own property of the candidates
+// object.
+exports.computeSupertypeLookupTable = function(candidates) {
+    var table = {};
+
+    for (var typeName in defCache) {
+        if (hasOwn.call(defCache, typeName)) {
+            var d = defCache[typeName];
+            assert.strictEqual(d.finalized, true);
+            for (var i = 0; i < d.supertypeList.length; ++i) {
+                var superTypeName = d.supertypeList[i];
+                if (hasOwn.call(candidates, superTypeName)) {
+                    table[typeName] = superTypeName;
+                    break;
+                }
+            }
+        }
+    }
+
+    return table;
+};
+
 Dp.checkAllFields = function(value, deep) {
     var allFields = this.allFields;
     assert.strictEqual(this.finalized, true);
@@ -387,36 +413,32 @@ Dp.bases = function() {
 Object.defineProperty(Dp, "buildable", { value: false });
 
 var builders = {};
-Object.defineProperty(exports, "builders", {
-    value: builders
-});
+exports.builders = builders;
 
 // This object is used as prototype for any node created by a builder.
 var nodePrototype = {};
 
 // Call this function to define a new method to be shared by all AST
 // nodes. The replaced method (if any) is returned for easy wrapping.
-Object.defineProperty(exports, "defineMethod", {
-    value: function(name, func) {
-        var old = nodePrototype[name];
+exports.defineMethod = function(name, func) {
+    var old = nodePrototype[name];
 
-        // Pass undefined as func to delete nodePrototype[name].
-        if (isUndefined.check(func)) {
-            delete nodePrototype[name];
+    // Pass undefined as func to delete nodePrototype[name].
+    if (isUndefined.check(func)) {
+        delete nodePrototype[name];
 
-        } else {
-            isFunction.assert(func);
-
-            Object.defineProperty(nodePrototype, name, {
-                enumerable: true, // For discoverability.
-                configurable: true, // For delete proto[name].
-                value: func
-            });
-        }
+    } else {
+        isFunction.assert(func);
 
-        return old;
+        Object.defineProperty(nodePrototype, name, {
+            enumerable: true, // For discoverability.
+            configurable: true, // For delete proto[name].
+            value: func
+        });
     }
-});
+
+    return old;
+};
 
 // Calling the .build method of a Def simultaneously marks the type as
 // buildable (by defining builders[getBuilderName(typeName)]) and
@@ -547,86 +569,59 @@ Dp.field = function(name, type, defaultFn, hidden) {
 };
 
 var namedTypes = {};
-Object.defineProperty(exports, "namedTypes", {
-    value: namedTypes
-});
+exports.namedTypes = namedTypes;
+
+// Like Object.keys, but aware of what fields each AST type should have.
+function getFieldNames(object) {
+    var d = Def.fromValue(object);
+    if (d) {
+        return d.fieldNames.slice(0);
+    }
+
+    assert.strictEqual(
+        "type" in object, false,
+        "did not recognize object of type " +
+            JSON.stringify(object.type)
+    );
+
+    return Object.keys(object);
+}
+exports.getFieldNames = getFieldNames;
 
 // Get the value of an object property, taking object.type and default
 // functions into account.
-Object.defineProperty(exports, "getFieldValue", {
-    value: function(object, fieldName) {
-        var d = Def.fromValue(object);
-        if (d) {
-            var field = d.allFields[fieldName];
-            if (field) {
-                return field.getValue(object);
-            }
+function getFieldValue(object, fieldName) {
+    var d = Def.fromValue(object);
+    if (d) {
+        var field = d.allFields[fieldName];
+        if (field) {
+            return field.getValue(object);
         }
-
-        return object[fieldName];
     }
-});
+
+    return object[fieldName];
+}
+exports.getFieldValue = getFieldValue;
 
 // Iterate over all defined fields of an object, including those missing
 // or undefined, passing each field name and effective value (as returned
 // by getFieldValue) to the callback. If the object has no corresponding
 // Def, the callback will never be called.
-Object.defineProperty(exports, "eachField", {
-    value: function(object, callback, context) {
-        var d = Def.fromValue(object);
-        if (d) {
-            var all = d.allFields;
-            Object.keys(all).forEach(function(name) {
-                var field = all[name];
-                if (!field.hidden) {
-                    callback.call(this, name, field.getValue(object));
-                }
-            }, context);
-        } else {
-            assert.strictEqual(
-                "type" in object, false,
-                "did not recognize object of type " + JSON.stringify(object.type)
-            );
-
-            // If we could not infer a Def type for this object, just
-            // iterate over its keys in the normal way.
-            Object.keys(object).forEach(function(name) {
-                callback.call(this, name, object[name]);
-            }, context);
-        }
-    }
-});
+exports.eachField = function(object, callback, context) {
+    getFieldNames(object).forEach(function(name) {
+        callback.call(this, name, getFieldValue(object, name));
+    }, context);
+};
 
 // Similar to eachField, except that iteration stops as soon as the
 // callback returns a truthy value. Like Array.prototype.some, the final
 // result is either true or false to indicates whether the callback
 // returned true for any element or not.
-Object.defineProperty(exports, "someField", {
-    value: function(object, callback, context) {
-        var d = Def.fromValue(object);
-        if (d) {
-            var all = d.allFields;
-            return Object.keys(all).some(function(name) {
-                var field = all[name];
-                if (!field.hidden) {
-                    var value = field.getValue(object);
-                    return callback.call(this, name, value);
-                }
-            }, context);
-        }
-
-        assert.strictEqual(
-            "type" in object, false,
-            "did not recognize object of type " + JSON.stringify(object.type)
-        );
-
-        // If we could not infer a Def type for this object, just iterate
-        // over its keys in the normal way.
-        return Object.keys(object).some(function(name) {
-            return callback.call(this, name, object[name]);
-        }, context);
-    }
-});
+exports.someField = function(object, callback, context) {
+    return getFieldNames(object).some(function(name) {
+        return callback.call(this, name, getFieldValue(object, name));
+    }, context);
+};
 
 // This property will be overridden as true by individual Def instances
 // when they are finalized.
@@ -650,6 +645,14 @@ Dp.finalize = function() {
         extend(allFields, this.ownFields);
         allSupertypes[this.typeName] = this;
 
+        this.fieldNames.length = 0;
+        for (var fieldName in allFields) {
+            if (hasOwn.call(allFields, fieldName) &&
+                !allFields[fieldName].hidden) {
+                this.fieldNames.push(fieldName);
+            }
+        }
+
         // Types are exported only once they have been finalized.
         Object.defineProperty(namedTypes, this.typeName, {
             enumerable: true,
@@ -657,9 +660,46 @@ Dp.finalize = function() {
         });
 
         Object.defineProperty(this, "finalized", { value: true });
+
+        // A linearization of the inheritance hierarchy.
+        populateSupertypeList(this.typeName, this.supertypeList);
     }
 };
 
+function populateSupertypeList(typeName, list) {
+    list.length = 0;
+    list.push(typeName);
+
+    var lastSeen = {};
+
+    for (var pos = 0; pos < list.length; ++pos) {
+        typeName = list[pos];
+        var d = defCache[typeName];
+        assert.strictEqual(d.finalized, true);
+
+        // If we saw typeName earlier in the breadth-first traversal,
+        // delete the last-seen occurrence.
+        if (hasOwn.call(lastSeen, typeName)) {
+            delete list[lastSeen[typeName]];
+        }
+
+        // Record the new index of the last-seen occurrence of typeName.
+        lastSeen[typeName] = pos;
+
+        // Enqueue the base names of this type.
+        list.push.apply(list, d.baseNames);
+    }
+
+    // Compaction loop to remove array holes.
+    for (var to = 0, from = to, len = list.length; from < len; ++from) {
+        if (hasOwn.call(list, from)) {
+            list[to++] = list[from];
+        }
+    }
+
+    list.length = to;
+}
+
 function extend(into, from) {
     Object.keys(from).forEach(function(name) {
         into[name] = from[name];
@@ -668,14 +708,8 @@ function extend(into, from) {
     return into;
 };
 
-Object.defineProperty(exports, "finalize", {
-    // This function should be called at the end of any complete file of
-    // type definitions. It declares that everything defined so far is
-    // complete and needs no further modification, and defines all
-    // finalized types as properties of exports.namedTypes.
-    value: function() {
-        Object.keys(defCache).forEach(function(name) {
-            defCache[name].finalize();
-        });
-    }
-});
+exports.finalize = function() {
+    Object.keys(defCache).forEach(function(name) {
+        defCache[name].finalize();
+    });
+};

package/main.js

@@ -19,9 +19,11 @@ exports.builtInTypes = types.builtInTypes;
 exports.namedTypes = types.namedTypes;
 exports.builders = types.builders;
 exports.defineMethod = types.defineMethod;
+exports.getFieldNames = types.getFieldNames;
 exports.getFieldValue = types.getFieldValue;
 exports.eachField = types.eachField;
 exports.someField = types.someField;
 exports.traverse = require("./lib/traverse");
 exports.finalize = types.finalize;
 exports.NodePath = require("./lib/node-path");
+exports.computeSupertypeLookupTable = types.computeSupertypeLookupTable;

package/package.json

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

package/test/run.js

@@ -47,6 +47,32 @@ describe("isSupertypeOf", function() {
     });
 });
 
+describe("computeSupertypeLookupTable", function() {
+    it("should resolve the most precise supertypes", function() {
+        var table = types.computeSupertypeLookupTable({
+            Function: true,
+            Declaration: true,
+            ArrowFunctionExpression: true,
+            Expression: true,
+            Identifier: true
+        });
+
+        function check(subtype, expectedSupertype) {
+            assert.strictEqual(table[subtype], expectedSupertype);
+        }
+
+        check("FunctionExpression", "Function");
+        check("FunctionDeclaration", "Function");
+        check("VariableDeclaration", "Declaration");
+        check("Identifier", "Identifier");
+        check("ArrowFunctionExpression", "ArrowFunctionExpression");
+        check("ForInStatement");
+        check("Node");
+        check("ThisExpression", "Expression");
+        check("Property");
+    });
+});
+
 describe("shallow and deep checks", function() {
     var index = b.identifier("foo");
     var decl = b.variableDeclaration("var", [
@@ -248,9 +274,7 @@ describe("types.eachField", function() {
     }
 
     it("should give correct keys for supertypes", function() {
-        check({ type: "Expression" }, [
-            "type", "loc"
-        ]);
+        check({ type: "Expression" }, ["type"]);
     });
 
     it("should work for non-buildable types", function() {
@@ -266,12 +290,12 @@ describe("types.eachField", function() {
     it("should respect hidden fields", function() {
         check({ type: "TryStatement" }, [
             // Note that the "handlers" field is now hidden from eachField.
-            "type", "block", "handler", "guardedHandlers", "finalizer", "loc"
+            "type", "block", "handler", "guardedHandlers", "finalizer"
         ]);
     });
 
     check({ type: "CatchClause" }, [
-        "type", "param", "guard", "body", "loc"
+        "type", "param", "guard", "body"
     ]);
 
     it("should complain about invalid types", function() {