ast-types 0.11.1 → 0.11.5

package/def/es-proposals.js

@@ -0,0 +1,33 @@
+module.exports = function (fork) {
+  fork.use(require('./core'));
+
+  var types = fork.use(require("../lib/types"));
+  var Type = types.Type;
+  var def = types.Type.def;
+  var or = Type.or;
+
+  var shared = fork.use(require("../lib/shared"));
+  var defaults = shared.defaults;
+
+
+  // https://github.com/tc39/proposal-optional-chaining
+  // `a?.b` as per https://github.com/estree/estree/issues/146
+  def("OptionalMemberExpression")
+    .bases("MemberExpression")
+    .build("object", "property", "computed", "optional")
+    .field("optional", Boolean, defaults["true"])
+
+  // a?.b()
+  def("OptionalCallExpression")
+    .bases("CallExpression")
+    .build("callee", "arguments", "optional")
+    .field("optional", Boolean, defaults["true"])
+
+
+  // https://github.com/tc39/proposal-nullish-coalescing
+  // `a ?? b` as per https://github.com/babel/babylon/pull/761/files
+  var LogicalOperator = or("||", "&&", "??");
+
+  def("LogicalExpression")
+    .field("operator", LogicalOperator)
+};

package/def/flow.js

@@ -6,31 +6,35 @@ module.exports = function (fork) {
   var or = types.Type.or;
   var defaults = fork.use(require("../lib/shared")).defaults;
 
-  // Type Annotations
-  def("Type").bases("Node");
+  // Base types
+
+  def("Flow").bases("Node");
+  def("FlowType").bases("Flow");
+
+  // Type annotations
 
   def("AnyTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("EmptyTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("MixedTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("VoidTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("NumberTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("NumberLiteralTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("value", "raw")
     .field("value", Number)
     .field("raw", String);
@@ -38,27 +42,27 @@ module.exports = function (fork) {
   // Babylon 6 differs in AST from Flow
   // same as NumberLiteralTypeAnnotation
   def("NumericLiteralTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("value", "raw")
     .field("value", Number)
     .field("raw", String);
 
   def("StringTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("StringLiteralTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("value", "raw")
     .field("value", String)
     .field("raw", String);
 
   def("BooleanTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("BooleanLiteralTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("value", "raw")
     .field("value", Boolean)
     .field("raw", String);
@@ -66,38 +70,38 @@ module.exports = function (fork) {
   def("TypeAnnotation")
     .bases("Node")
     .build("typeAnnotation")
-    .field("typeAnnotation", def("Type"));
+    .field("typeAnnotation", def("FlowType"));
 
   def("NullableTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("typeAnnotation")
-    .field("typeAnnotation", def("Type"));
+    .field("typeAnnotation", def("FlowType"));
 
   def("NullLiteralTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("NullTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("ThisTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("ExistsTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("ExistentialTypeParam")
-    .bases("Type")
+    .bases("FlowType")
     .build();
 
   def("FunctionTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("params", "returnType", "rest", "typeParameters")
     .field("params", [def("FunctionTypeParam")])
-    .field("returnType", def("Type"))
+    .field("returnType", def("FlowType"))
     .field("rest", or(def("FunctionTypeParam"), null))
     .field("typeParameters", or(def("TypeParameterDeclaration"), null));
 
@@ -105,16 +109,16 @@ module.exports = function (fork) {
     .bases("Node")
     .build("name", "typeAnnotation", "optional")
     .field("name", def("Identifier"))
-    .field("typeAnnotation", def("Type"))
+    .field("typeAnnotation", def("FlowType"))
     .field("optional", Boolean);
 
   def("ArrayTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("elementType")
-    .field("elementType", def("Type"));
+    .field("elementType", def("FlowType"));
 
   def("ObjectTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("properties", "indexers", "callProperties")
     .field("properties", [
       or(def("ObjectTypeProperty"),
@@ -142,7 +146,7 @@ module.exports = function (fork) {
     .bases("Node")
     .build("key", "value", "optional")
     .field("key", or(def("Literal"), def("Identifier")))
-    .field("value", def("Type"))
+    .field("value", def("FlowType"))
     .field("optional", Boolean)
     .field("variance", LegacyVariance, defaults["null"]);
 
@@ -150,8 +154,8 @@ module.exports = function (fork) {
     .bases("Node")
     .build("id", "key", "value")
     .field("id", def("Identifier"))
-    .field("key", def("Type"))
-    .field("value", def("Type"))
+    .field("key", def("FlowType"))
+    .field("value", def("FlowType"))
     .field("variance", LegacyVariance, defaults["null"]);
 
   def("ObjectTypeCallProperty")
@@ -169,13 +173,13 @@ module.exports = function (fork) {
     .field("id", def("Identifier"));
 
   def("GenericTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("id", "typeParameters")
     .field("id", or(def("Identifier"), def("QualifiedTypeIdentifier")))
     .field("typeParameters", or(def("TypeParameterInstantiation"), null));
 
   def("MemberTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("object", "property")
     .field("object", def("Identifier"))
     .field("property",
@@ -183,24 +187,24 @@ module.exports = function (fork) {
               def("GenericTypeAnnotation")));
 
   def("UnionTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("types")
-    .field("types", [def("Type")]);
+    .field("types", [def("FlowType")]);
 
   def("IntersectionTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("types")
-    .field("types", [def("Type")]);
+    .field("types", [def("FlowType")]);
 
   def("TypeofTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("argument")
-    .field("argument", def("Type"));
+    .field("argument", def("FlowType"));
 
   def("ObjectTypeSpreadProperty")
     .bases("Node")
     .build("argument")
-    .field("argument", def("Type"));
+    .field("argument", def("FlowType"));
 
   def("Identifier")
     .field("typeAnnotation", or(def("TypeAnnotation"), null), defaults["null"]);
@@ -216,10 +220,10 @@ module.exports = function (fork) {
   def("TypeParameterInstantiation")
     .bases("Node")
     .build("params")
-    .field("params", [def("Type")]);
+    .field("params", [def("FlowType")]);
 
   def("TypeParameter")
-    .bases("Type")
+    .bases("FlowType")
     .build("name", "variance", "bound")
     .field("name", String)
     .field("variance", LegacyVariance, defaults["null"])
@@ -295,15 +299,15 @@ module.exports = function (fork) {
     .build("id", "typeParameters", "right")
     .field("id", def("Identifier"))
     .field("typeParameters", or(def("TypeParameterDeclaration"), null))
-    .field("right", def("Type"));
+    .field("right", def("FlowType"));
 
   def("OpaqueType")
     .bases("Declaration")
     .build("id", "typeParameters", "impltype", "supertype")
     .field("id", def("Identifier"))
     .field("typeParameters", or(def("TypeParameterDeclaration"), null))
-    .field("implType", def("Type"))
-    .field("superType", def("Type"));
+    .field("implType", def("FlowType"))
+    .field("superType", def("FlowType"));
 
   def("DeclareTypeAlias")
     .bases("TypeAlias")
@@ -320,9 +324,9 @@ module.exports = function (fork) {
     .field("typeAnnotation", def("TypeAnnotation"));
 
   def("TupleTypeAnnotation")
-    .bases("Type")
+    .bases("FlowType")
     .build("types")
-    .field("types", [def("Type")]);
+    .field("types", [def("FlowType")]);
 
   def("DeclareVariable")
     .bases("Statement")
@@ -347,7 +351,7 @@ module.exports = function (fork) {
   def("DeclareModuleExports")
     .bases("Statement")
     .build("typeAnnotation")
-    .field("typeAnnotation", def("Type"));
+    .field("typeAnnotation", def("TypeAnnotation"));
 
   def("DeclareExportDeclaration")
     .bases("Declaration")
@@ -357,7 +361,7 @@ module.exports = function (fork) {
       def("DeclareVariable"),
       def("DeclareFunction"),
       def("DeclareClass"),
-      def("Type"), // Implies default.
+      def("FlowType"), // Implies default.
       null
     ))
     .field("specifiers", [or(
@@ -376,4 +380,15 @@ module.exports = function (fork) {
       def("Literal"),
       null
     ), defaults["null"]);
+
+  def("FlowPredicate").bases("Flow");
+
+  def("InferredPredicate")
+    .bases("FlowPredicate")
+    .build();
+
+  def("DeclaredPredicate")
+    .bases("FlowPredicate")
+    .build("value")
+    .field("value", def("Expression"));
 };

package/def/typescript.js

@@ -31,6 +31,7 @@ module.exports = function (fork) {
 
   def("TSTypeReference")
     .bases("TSType")
+    .build("typeName", "typeParameters")
     .field("typeName", IdOrQualifiedName)
     .field("typeParameters",
            or(def("TSTypeParameterInstantiation"), null),
@@ -110,6 +111,19 @@ module.exports = function (fork) {
       .field("types", [def("TSType")]);
   });
 
+  def("TSConditionalType")
+    .bases("TSType")
+    .build("checkType", "extendsType", "trueType", "falseType")
+    .field("checkType", def("TSType"))
+    .field("extendsType", def("TSType"))
+    .field("trueType", def("TSType"))
+    .field("falseType", def("TSType"));
+
+  def("TSInferType")
+    .bases("TSType")
+    .build("typeParameter")
+    .field("typeParameter", def("TSTypeParameter"));
+
   def("TSParenthesizedType")
     .bases("TSType")
     .build("typeAnnotation")

package/lib/types.js

@@ -533,77 +533,115 @@ module.exports = function () {
         // Override Dp.buildable for this Def instance.
         Object.defineProperty(self, "buildable", {value: true});
 
-        Object.defineProperty(builders, getBuilderName(self.typeName), {
-            enumerable: true,
+        function addParam(built, param, arg, isArgAvailable) {
+            if (hasOwn.call(built, param))
+                return;
 
-            value: function () {
-                var args = arguments;
-                var argc = args.length;
-                var built = Object.create(nodePrototype);
+            var all = self.allFields;
+            if (!hasOwn.call(all, param)) {
+                throw new Error("" + param);
+            }
 
-                if (!self.finalized) {
-                    throw new Error(
-                      "attempting to instantiate unfinalized type " +
-                      self.typeName
-                    );
-                }
+            var field = all[param];
+            var type = field.type;
+            var value;
+
+            if (isArgAvailable) {
+                value = arg;
+            } else if (field.defaultFn) {
+                // Expose the partially-built object to the default
+                // function as its `this` object.
+                value = field.defaultFn.call(built);
+            } else {
+                var message = "no value or default function given for field " +
+                  JSON.stringify(param) + " of " + self.typeName + "(" +
+                  self.buildParams.map(function (name) {
+                      return all[name];
+                  }).join(", ") + ")";
+                throw new Error(message);
+            }
+
+            if (!type.check(value)) {
+                throw new Error(
+                  shallowStringify(value) +
+                  " does not match field " + field +
+                  " of type " + self.typeName
+                );
+            }
 
-                function add(param, i) {
-                    if (hasOwn.call(built, param))
-                        return;
-
-                    var all = self.allFields;
-                    if (!hasOwn.call(all, param)) {
-                        throw new Error("" + param);
-                    }
-
-                    var field = all[param];
-                    var type = field.type;
-                    var value;
-
-                    if (isNumber.check(i) && i < argc) {
-                        value = args[i];
-                    } else if (field.defaultFn) {
-                        // Expose the partially-built object to the default
-                        // function as its `this` object.
-                        value = field.defaultFn.call(built);
-                    } else {
-                        var message = "no value or default function given for field " +
-                          JSON.stringify(param) + " of " + self.typeName + "(" +
-                          self.buildParams.map(function (name) {
-                              return all[name];
-                          }).join(", ") + ")";
-                        throw new Error(message);
-                    }
-
-                    if (!type.check(value)) {
-                        throw new Error(
-                          shallowStringify(value) +
-                          " does not match field " + field +
-                          " of type " + self.typeName
-                        );
-                    }
-
-                    // TODO Could attach getters and setters here to enforce
-                    // dynamic type safety.
-                    built[param] = value;
+            built[param] = value;
+        }
+
+        // Calling the builder function will construct an instance of the Def,
+        // with positional arguments mapped to the fields original passed to .build.
+        // If not enough arguments are provided, the default value for the remaining fields
+        // will be used.
+        function builder() {
+            var args = arguments;
+            var argc = args.length;
+            
+            if (!self.finalized) {
+                throw new Error(
+                    "attempting to instantiate unfinalized type " +
+                    self.typeName
+                );
+            }
+
+            var built = Object.create(nodePrototype);
+
+            self.buildParams.forEach(function (param, i) {
+                if (i < argc) {
+                    addParam(built, param, args[i], true)
+                } else {
+                    addParam(built, param, null, false);
                 }
+            });
 
-                self.buildParams.forEach(function (param, i) {
-                    add(param, i);
-                });
+            Object.keys(self.allFields).forEach(function (param) {
+                // Use the default value.
+                addParam(built, param, null, false);
+            });
 
-                Object.keys(self.allFields).forEach(function (param) {
-                    add(param); // Use the default value.
-                });
+            // Make sure that the "type" field was filled automatically.
+            if (built.type !== self.typeName) {
+                throw new Error("");
+            }
 
-                // Make sure that the "type" field was filled automatically.
-                if (built.type !== self.typeName) {
-                    throw new Error("");
+            return built;
+        }
+
+        // Calling .from on the builder function will construct an instance of the Def,
+        // using field values from the passed object. For fields missing from the passed object,
+        // their default value will be used.
+        builder.from = function (obj) {
+            if (!self.finalized) {
+                throw new Error(
+                    "attempting to instantiate unfinalized type " +
+                    self.typeName
+                );
+            }
+            
+            var built = Object.create(nodePrototype);
+
+            Object.keys(self.allFields).forEach(function (param) {
+                if (hasOwn.call(obj, param)) {
+                    addParam(built, param, obj[param], true);
+                } else {
+                    addParam(built, param, null, false);
                 }
+            });
 
-                return built;
+            // Make sure that the "type" field was filled automatically.
+            if (built.type !== self.typeName) {
+                throw new Error("");
             }
+
+            return built;
+        }
+
+        Object.defineProperty(builders, getBuilderName(self.typeName), {
+            enumerable: true,
+            value: builder
         });
 
         return self; // For chaining.

package/main.js

@@ -13,5 +13,6 @@ module.exports = require('./fork')([
   require("./def/flow"),
   require("./def/esprima"),
   require("./def/babel"),
-  require("./def/typescript")
+  require("./def/typescript"),
+  require("./def/es-proposals")
 ]);

package/package.json

@@ -18,7 +18,7 @@
     "transformation",
     "syntax"
   ],
-  "version": "0.11.1",
+  "version": "0.11.5",
   "homepage": "http://github.com/benjamn/ast-types",
   "repository": {
     "type": "git",
@@ -36,12 +36,12 @@
     "espree": "^3.1.7",
     "esprima": "~4.0.0",
     "esprima-fb": "~14001.1.0-dev-harmony-fb",
-    "flow-parser": "^0.66.0",
+    "flow-parser": "^0.73.0",
     "glob": "^7.1.2",
     "mocha": "^5.0.0",
-    "reify": "^0.14.1"
+    "reify": "^0.16.1"
   },
   "engines": {
-    "node": ">= 0.8"
+    "node": ">=4"
   }
 }