ast-types 0.11.3 → 0.11.7

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/es6.js

@@ -88,6 +88,9 @@ module.exports = function (fork) {
     .field("shorthand", Boolean, defaults["false"])
     .field("computed", Boolean, defaults["false"]);
 
+  def("ObjectProperty")
+    .field("shorthand", Boolean, defaults["false"]);
+
   def("PropertyPattern")
     .bases("Pattern")
     .build("key", "pattern")

package/def/flow.js

@@ -1,36 +1,41 @@
 module.exports = function (fork) {
   fork.use(require("./es7"));
+  fork.use(require("./type-annotations"));
 
   var types = fork.use(require("../lib/types"));
   var def = types.Type.def;
   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 +43,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 +71,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 +110,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 +147,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 +155,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 +174,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,30 +188,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"));
-
-  def("Identifier")
-    .field("typeAnnotation", or(def("TypeAnnotation"), null), defaults["null"]);
-
-  def("ObjectPattern")
-    .field("typeAnnotation", or(def("TypeAnnotation"), null), defaults["null"]);
+    .field("argument", def("FlowType"));
 
   def("TypeParameterDeclaration")
     .bases("Node")
@@ -216,10 +215,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"])
@@ -227,33 +226,9 @@ module.exports = function (fork) {
            or(def("TypeAnnotation"), null),
            defaults["null"]);
 
-  def("Function")
-    .field("returnType",
-           or(def("TypeAnnotation"), null),
-           defaults["null"])
-    .field("typeParameters",
-           or(def("TypeParameterDeclaration"), null),
-           defaults["null"]);
-
   def("ClassProperty")
-    .build("key", "value", "typeAnnotation", "static")
-    .field("value", or(def("Expression"), null))
-    .field("typeAnnotation", or(def("TypeAnnotation"), null))
-    .field("static", Boolean, defaults["false"])
     .field("variance", LegacyVariance, defaults["null"]);
 
-  ["ClassDeclaration",
-   "ClassExpression",
-  ].forEach(typeName => {
-    def(typeName)
-      .field("typeParameters",
-             or(def("TypeParameterDeclaration"), null),
-             defaults["null"])
-      .field("superTypeParameters",
-             or([def("GenericTypeAnnotation")], null),
-             defaults["null"]);
-  });
-
   def("ClassImplements")
     .bases("Node")
     .build("id")
@@ -263,13 +238,6 @@ module.exports = function (fork) {
            or(def("TypeParameterInstantiation"), null),
            defaults["null"]);
 
-  ["ClassDeclaration",
-   "ClassExpression",
-  ].forEach(typeName => {
-    def(typeName)
-      .field("implements", [def("ClassImplements")], defaults.emptyArray);
-  });
-
   def("InterfaceDeclaration")
     .bases("Declaration")
     .build("id", "body", "extends")
@@ -295,15 +263,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 +288,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 +315,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 +325,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 +344,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/type-annotations.js

@@ -0,0 +1,61 @@
+/**
+ * Type annotation defs shared between Flow and TypeScript.
+ * These defs could not be defined in ./flow.js or ./typescript.js directly
+ * because they use the same name.
+ */
+module.exports = function (fork) {
+  var types = fork.use(require("../lib/types"));
+  var def = types.Type.def;
+  var or = types.Type.or;
+  var defaults = fork.use(require("../lib/shared")).defaults;
+
+  var TypeAnnotation = or(
+    def("TypeAnnotation"),
+    def("TSTypeAnnotation"),
+    null
+  );
+
+  var TypeParamDecl = or(
+    def("TypeParameterDeclaration"),
+    def("TSTypeParameterDeclaration"),
+    null
+  );
+
+  def("Identifier")
+    .field("typeAnnotation", TypeAnnotation, defaults["null"]);
+
+  def("ObjectPattern")
+    .field("typeAnnotation", TypeAnnotation, defaults["null"]);
+
+  def("Function")
+    .field("returnType", TypeAnnotation, defaults["null"])
+    .field("typeParameters", TypeParamDecl, defaults["null"]);
+
+  def("ClassProperty")
+    .build("key", "value", "typeAnnotation", "static")
+    .field("value", or(def("Expression"), null))
+    .field("static", Boolean, defaults["false"])
+    .field("typeAnnotation", TypeAnnotation, defaults["null"]);
+
+  ["ClassDeclaration",
+    "ClassExpression",
+  ].forEach(typeName => {
+    def(typeName)
+      .field("typeParameters", TypeParamDecl, defaults["null"])
+      .field("superTypeParameters",
+             or(def("TypeParameterInstantiation"),
+                def("TSTypeParameterInstantiation"),
+                null),
+             defaults["null"]);
+  });
+
+  ["ClassDeclaration",
+   "ClassExpression",
+  ].forEach(typeName => {
+    def(typeName)
+      .field("implements",
+             or([def("ClassImplements")],
+                [def("TSExpressionWithTypeArguments")]),
+             defaults.emptyArray);
+  });
+};

package/def/typescript.js

@@ -2,6 +2,7 @@ module.exports = function (fork) {
   // Since TypeScript is parsed by Babylon, include the core Babylon types
   // but omit the Flow-related types.
   fork.use(require("./babel-core"));
+  fork.use(require("./type-annotations"));
 
   var types = fork.use(require("../lib/types"));
   var n = types.namedTypes;
@@ -31,6 +32,7 @@ module.exports = function (fork) {
 
   def("TSTypeReference")
     .bases("TSType")
+    .build("typeName", "typeParameters")
     .field("typeName", IdOrQualifiedName)
     .field("typeParameters",
            or(def("TSTypeParameterInstantiation"), null),
@@ -80,6 +82,7 @@ module.exports = function (fork) {
     "TSStringKeyword",
     "TSSymbolKeyword",
     "TSUndefinedKeyword",
+    "TSUnknownKeyword",
     "TSVoidKeyword",
     "TSThisType",
   ].forEach(keywordType => {
@@ -121,7 +124,7 @@ module.exports = function (fork) {
   def("TSInferType")
     .bases("TSType")
     .build("typeParameter")
-    .field("typeParameter", def("TSType"));
+    .field("typeParameter", def("TSTypeParameter"));
 
   def("TSParenthesizedType")
     .bases("TSType")
@@ -200,9 +203,9 @@ module.exports = function (fork) {
   def("TSMappedType")
     .bases("TSType")
     .build("typeParameter", "typeAnnotation")
-    .field("readonly", Boolean, defaults["false"])
+    .field("readonly", or(Boolean, "+", "-"), defaults["false"])
     .field("typeParameter", def("TSTypeParameter"))
-    .field("optional", Boolean, defaults["false"])
+    .field("optional", or(Boolean, "+", "-"), defaults["false"])
     .field("typeAnnotation",
            or(def("TSType"), null),
            defaults["null"]);
@@ -212,6 +215,16 @@ module.exports = function (fork) {
     .build("elementTypes")
     .field("elementTypes", [def("TSType")]);
 
+  def("TSRestType")
+    .bases("TSType")
+    .build("typeAnnotation")
+    .field("typeAnnotation", def("TSType"));
+
+  def("TSOptionalType")
+    .bases("TSType")
+    .build("typeAnnotation")
+    .field("typeAnnotation", def("TSType"));
+
   def("TSIndexedAccessType")
     .bases("TSType")
     .build("objectType", "indexType")
@@ -288,7 +301,7 @@ module.exports = function (fork) {
   def("TSTypeQuery")
     .bases("TSType")
     .build("exprName")
-    .field("exprName", def("Identifier"));
+    .field("exprName", IdOrQualifiedName);
 
   // Inferred from Babylon's tsParseTypeMember method.
   var TSTypeMember = or(
@@ -306,6 +319,7 @@ module.exports = function (fork) {
 
   def("TSTypeParameter")
     .bases("Identifier")
+    .build("name", "constraint", "default")
     .field("name", String)
     .field("constraint", or(def("TSType"), null), defaults["null"])
     .field("default", or(def("TSType"), null), defaults["null"]);
@@ -411,15 +425,6 @@ module.exports = function (fork) {
            defaults["null"])
     .field("body", def("TSInterfaceBody"));
 
-  ["ClassDeclaration",
-   "ClassExpression",
-  ].forEach(typeName => {
-    def(typeName)
-      .field("implements",
-             [def("TSExpressionWithTypeArguments")],
-             defaults.emptyArray);
-  });
-
   def("TSParameterProperty")
     .bases("Pattern")
     .build("parameter")

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

@@ -1,6 +1,7 @@
 {
   "author": "Ben Newman <bn@cs.stanford.edu>",
   "name": "ast-types",
+  "version": "0.11.7",
   "description": "Esprima-compatible implementation of the Mozilla JS Parser API",
   "keywords": [
     "ast",
@@ -18,7 +19,6 @@
     "transformation",
     "syntax"
   ],
-  "version": "0.11.3",
   "homepage": "http://github.com/benjamn/ast-types",
   "repository": {
     "type": "git",
@@ -33,15 +33,15 @@
   "devDependencies": {
     "babel-types": "^6.26.0",
     "babylon": "^7.0.0-beta.40",
-    "espree": "^3.1.7",
+    "espree": "^4.0.0",
     "esprima": "~4.0.0",
     "esprima-fb": "~14001.1.0-dev-harmony-fb",
-    "flow-parser": "^0.66.0",
+    "flow-parser": "^0.83.0",
     "glob": "^7.1.2",
     "mocha": "^5.0.0",
-    "reify": "^0.14.1"
+    "reify": "^0.18.0"
   },
   "engines": {
-    "node": ">= 0.8"
+    "node": ">=4"
   }
 }