ast-types 0.10.1 → 0.11.2

package/.travis.yml

@@ -1,5 +1,6 @@
 language: node_js
 node_js:
+  - "9"
   - "8"
   - "7"
   - "6"

package/def/babel-core.js

@@ -7,7 +7,7 @@ module.exports = function (fork) {
   var or = types.Type.or;
 
   def("Noop")
-    .bases("Node")
+    .bases("Statement")
     .build();
 
   def("DoExpression")
@@ -136,7 +136,17 @@ module.exports = function (fork) {
   def("NumericLiteral")
     .bases("Literal")
     .build("value")
-    .field("value", Number);
+    .field("value", Number)
+    .field("raw", or(String, null), defaults["null"])
+    .field("extra", {
+      rawValue: Number,
+      raw: String
+    }, function getDefault() {
+      return {
+        rawValue: this.value,
+        raw: this.value + ""
+      }
+    });
 
   def("BigIntLiteral")
     .bases("Literal")
@@ -177,7 +187,8 @@ module.exports = function (fork) {
     def("Property"),
     def("ObjectMethod"),
     def("ObjectProperty"),
-    def("SpreadProperty")
+    def("SpreadProperty"),
+    def("SpreadElement")
   );
 
   // Split Property -> ObjectProperty and ObjectMethod
@@ -197,6 +208,9 @@ module.exports = function (fork) {
     .field("computed", Boolean, defaults["false"])
     .field("generator", Boolean, defaults["false"])
     .field("async", Boolean, defaults["false"])
+    .field("accessibility", // TypeScript
+           or(def("Literal"), null),
+           defaults["null"])
     .field("decorators",
            or([def("Decorator")], null),
            defaults["null"]);
@@ -206,6 +220,9 @@ module.exports = function (fork) {
     .build("key", "value")
     .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
     .field("value", or(def("Expression"), def("Pattern")))
+    .field("accessibility", // TypeScript
+           or(def("Literal"), null),
+           defaults["null"])
     .field("computed", Boolean, defaults["false"]);
 
   var ClassBodyElement = or(

package/def/core.js

@@ -131,7 +131,8 @@ module.exports = function (fork) {
     def("CatchClause")
         .bases("Node")
         .build("param", "guard", "body")
-        .field("param", def("Pattern"))
+        // https://github.com/tc39/proposal-optional-catch-binding
+        .field("param", or(def("Pattern"), null), defaults["null"])
         .field("guard", or(def("Expression"), null), defaults["null"])
         .field("body", def("BlockStatement"));
 
@@ -237,7 +238,7 @@ module.exports = function (fork) {
         "==", "!=", "===", "!==",
         "<", "<=", ">", ">=",
         "<<", ">>", ">>>",
-        "+", "-", "*", "/", "%",
+        "+", "-", "*", "/", "%", "**",
         "&", // TODO Missing from the Parser API.
         "|", "^", "in",
         "instanceof", "..");
@@ -329,7 +330,8 @@ module.exports = function (fork) {
         // But aren't Expressions and Patterns already Nodes? TODO Report this.
         .bases("Node", "Expression", "Pattern")
         .build("name")
-        .field("name", String);
+        .field("name", String)
+        .field("optional", Boolean, defaults["false"]);
 
     def("Literal")
         // But aren't Expressions already Nodes? TODO Report this.
@@ -367,4 +369,4 @@ module.exports = function (fork) {
         // e.g. { /*dangling*/ }.
         .field("leading", Boolean, defaults["true"])
         .field("trailing", Boolean, defaults["false"]);
-};
+};

package/def/es6.js

@@ -16,7 +16,9 @@ module.exports = function (fork) {
   def("RestElement")
     .bases("Pattern")
     .build("argument")
-    .field("argument", def("Pattern"));
+    .field("argument", def("Pattern"))
+    .field("typeAnnotation", // for Babylon. Flow parser puts it on the identifier
+      or(def("TypeAnnotation"), def("TSTypeAnnotation"), null), defaults["null"]);
 
   def("SpreadElementPattern")
     .bases("Pattern")
@@ -107,7 +109,7 @@ module.exports = function (fork) {
     .bases("Declaration")
     .build("kind", "key", "value", "static")
     .field("kind", or("constructor", "method", "get", "set"))
-    .field("key", or(def("Literal"), def("Identifier"), def("Expression")))
+    .field("key", def("Expression"))
     .field("value", def("Function"))
     .field("computed", Boolean, defaults["false"])
     .field("static", Boolean, defaults["false"]);
@@ -179,13 +181,6 @@ module.exports = function (fork) {
     .build("id", "body", "superClass")
     .field("id", or(def("Identifier"), null), defaults["null"])
     .field("body", def("ClassBody"))
-    .field("superClass", or(def("Expression"), null), defaults["null"])
-    .field("implements", [def("ClassImplements")], defaults.emptyArray);
-
-  def("ClassImplements")
-    .bases("Node")
-    .build("id")
-    .field("id", def("Identifier"))
     .field("superClass", or(def("Expression"), null), defaults["null"]);
 
   // Specifier and ModuleSpecifier are abstract non-standard types
@@ -208,6 +203,38 @@ module.exports = function (fork) {
     .field("id", or(def("Identifier"), null), defaults["null"])
     .field("name", or(def("Identifier"), null), defaults["null"]);
 
+  // Like ModuleSpecifier, except type:"ImportSpecifier" and buildable.
+  // import {<id [as name]>} from ...;
+  def("ImportSpecifier")
+    .bases("ModuleSpecifier")
+    .build("id", "name");
+
+  // import <* as id> from ...;
+  def("ImportNamespaceSpecifier")
+    .bases("ModuleSpecifier")
+    .build("id");
+
+  // import <id> from ...;
+  def("ImportDefaultSpecifier")
+    .bases("ModuleSpecifier")
+    .build("id");
+
+  def("ImportDeclaration")
+    .bases("Declaration")
+    .build("specifiers", "source", "importKind")
+    .field("specifiers", [or(
+      def("ImportSpecifier"),
+      def("ImportNamespaceSpecifier"),
+      def("ImportDefaultSpecifier")
+    )], defaults.emptyArray)
+    .field("source", def("Literal"))
+    .field("importKind", or(
+      "value",
+      "type"
+    ), function() {
+      return "value";
+    });
+
   def("TaggedTemplateExpression")
     .bases("Expression")
     .build("tag", "quasi")

package/def/es7.js

@@ -1,38 +1,42 @@
 module.exports = function (fork) {
-    fork.use(require('./es6'));
+  fork.use(require('./es6'));
 
-    var types = fork.use(require("../lib/types"));
-    var def = types.Type.def;
-    var or = types.Type.or;
-    var builtin = types.builtInTypes;
-    var defaults = fork.use(require("../lib/shared")).defaults;
+  var types = fork.use(require("../lib/types"));
+  var def = types.Type.def;
+  var or = types.Type.or;
+  var builtin = types.builtInTypes;
+  var defaults = fork.use(require("../lib/shared")).defaults;
 
-    def("Function")
-      .field("async", Boolean, defaults["false"]);
+  def("Function")
+    .field("async", Boolean, defaults["false"]);
 
-    def("SpreadProperty")
-      .bases("Node")
-      .build("argument")
-      .field("argument", def("Expression"));
+  def("SpreadProperty")
+    .bases("Node")
+    .build("argument")
+    .field("argument", def("Expression"));
 
-    def("ObjectExpression")
-      .field("properties", [or(def("Property"), def("SpreadProperty"))]);
+  def("ObjectExpression")
+    .field("properties", [or(
+      def("Property"),
+      def("SpreadProperty"),
+      def("SpreadElement")
+    )]);
 
-    def("SpreadPropertyPattern")
-      .bases("Pattern")
-      .build("argument")
-      .field("argument", def("Pattern"));
+  def("SpreadPropertyPattern")
+    .bases("Pattern")
+    .build("argument")
+    .field("argument", def("Pattern"));
 
-    def("ObjectPattern")
-      .field("properties", [or(
-        def("Property"),
-        def("PropertyPattern"),
-        def("SpreadPropertyPattern")
-      )]);
+  def("ObjectPattern")
+    .field("properties", [or(
+      def("Property"),
+      def("PropertyPattern"),
+      def("SpreadPropertyPattern")
+    )]);
 
-    def("AwaitExpression")
-      .bases("Expression")
-      .build("argument", "all")
-      .field("argument", or(def("Expression"), null))
-      .field("all", Boolean, defaults["false"]);
-};
+  def("AwaitExpression")
+    .bases("Expression")
+    .build("argument", "all")
+    .field("argument", or(def("Expression"), null))
+    .field("all", Boolean, defaults["false"]);
+};

package/def/esprima.js

@@ -1,104 +1,72 @@
 module.exports = function (fork) {
-    fork.use(require("./es7"));
+  fork.use(require("./es7"));
 
-    var types = fork.use(require("../lib/types"));
-    var defaults = fork.use(require("../lib/shared")).defaults;
-    var def = types.Type.def;
-    var or = types.Type.or;
+  var types = fork.use(require("../lib/types"));
+  var defaults = fork.use(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("VariableDeclaration")
+    .field("declarations", [or(
+      def("VariableDeclarator"),
+      def("Identifier") // Esprima deviation.
+    )]);
 
-    def("Property")
-      .field("value", or(
-        def("Expression"),
-        def("Pattern") // Esprima deviation.
-      ));
+  def("Property")
+    .field("value", or(
+      def("Expression"),
+      def("Pattern") // Esprima deviation.
+    ));
 
-    def("ArrayPattern")
-      .field("elements", [or(
-        def("Pattern"),
-        def("SpreadElement"),
-        null
-      )]);
+  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("ObjectPattern")
+    .field("properties", [or(
+      def("Property"),
+      def("PropertyPattern"),
+      def("SpreadPropertyPattern"),
+      def("SpreadProperty") // Used by Esprima.
+    )]);
 
-// Like ModuleSpecifier, except type:"ExportSpecifier" and buildable.
-// export {<id [as name]>} [from ...];
-    def("ExportSpecifier")
-      .bases("ModuleSpecifier")
-      .build("id", "name");
+  // Like ModuleSpecifier, except type:"ExportSpecifier" and buildable.
+  // export {<id [as name]>} [from ...];
+  def("ExportSpecifier")
+    .bases("ModuleSpecifier")
+    .build("id", "name");
 
-// export <*> from ...;
-    def("ExportBatchSpecifier")
-      .bases("Specifier")
-      .build();
+  // export <*> from ...;
+  def("ExportBatchSpecifier")
+    .bases("Specifier")
+    .build();
 
-// Like ModuleSpecifier, except type:"ImportSpecifier" and buildable.
-// import {<id [as name]>} from ...;
-    def("ImportSpecifier")
-      .bases("ModuleSpecifier")
-      .build("id", "name");
+  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"]);
 
-// import <* as id> from ...;
-    def("ImportNamespaceSpecifier")
-      .bases("ModuleSpecifier")
-      .build("id");
+  def("Block")
+    .bases("Comment")
+    .build("value", /*optional:*/ "leading", "trailing");
 
-// import <id> from ...;
-    def("ImportDefaultSpecifier")
-      .bases("ModuleSpecifier")
-      .build("id");
-
-    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", "importKind")
-      .field("specifiers", [or(
-        def("ImportSpecifier"),
-        def("ImportNamespaceSpecifier"),
-        def("ImportDefaultSpecifier")
-      )], defaults.emptyArray)
-      .field("source", def("Literal"))
-      .field("importKind", or(
-        "value",
-        "type"
-      ), function() {
-        return "value";
-      });
-
-    def("Block")
-      .bases("Comment")
-      .build("value", /*optional:*/ "leading", "trailing");
-
-    def("Line")
-      .bases("Comment")
-      .build("value", /*optional:*/ "leading", "trailing");
-};
+  def("Line")
+    .bases("Comment")
+    .build("value", /*optional:*/ "leading", "trailing");
+};

package/def/flow.js

@@ -242,11 +242,34 @@ module.exports = function (fork) {
     .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")
+    .field("id", def("Identifier"))
+    .field("superClass", or(def("Expression"), null), defaults["null"])
     .field("typeParameters",
            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")

package/def/jsx.js

@@ -63,6 +63,7 @@ module.exports = function (fork) {
     .field("children", [or(
       def("JSXElement"),
       def("JSXExpressionContainer"),
+      def("JSXFragment"),
       def("JSXText"),
       def("Literal") // TODO Esprima should return JSXText instead.
     )], defaults.emptyArray)
@@ -93,6 +94,27 @@ module.exports = function (fork) {
     .build("name")
     .field("name", JSXElementName);
 
+  def("JSXFragment")
+    .bases("Expression")
+    .build("openingElement", "closingElement", "children")
+    .field("openingElement", def("JSXOpeningFragment"))
+    .field("closingElement", def("JSXClosingFragment"))
+    .field("children", [or(
+      def("JSXElement"),
+      def("JSXExpressionContainer"),
+      def("JSXFragment"),
+      def("JSXText"),
+      def("Literal") // TODO Esprima should return JSXText instead.
+    )], defaults.emptyArray)
+
+  def("JSXOpeningFragment")
+    .bases("Node") // TODO Same concern.
+    .build();
+
+  def("JSXClosingFragment")
+    .bases("Node") // TODO Same concern.
+    .build();
+
   def("JSXText")
     .bases("Literal")
     .build("value")

package/def/typescript.js

@@ -0,0 +1,445 @@
+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"));
+
+  var types = fork.use(require("../lib/types"));
+  var n = types.namedTypes;
+  var def = types.Type.def;
+  var or = types.Type.or;
+  var defaults = fork.use(require("../lib/shared")).defaults;
+  var StringLiteral = new types.Type(function (value, deep) {
+    if (n.StringLiteral &&
+        n.StringLiteral.check(value, deep)) {
+      return true
+    }
+    if (n.Literal &&
+        n.Literal.check(value, deep) &&
+        typeof value.value === "string") {
+      return true;
+    }
+    return false;
+  }, "StringLiteral");
+
+  def("TSType")
+    .bases("Node");
+
+  var IdOrQualifiedName = or(
+    def("Identifier"),
+    def("TSQualifiedName")
+  );
+
+  def("TSTypeReference")
+    .bases("TSType")
+    .field("typeName", IdOrQualifiedName)
+    .field("typeParameters",
+           or(def("TSTypeParameterInstantiation"), null),
+           defaults["null"]);
+
+  // An abstract (non-buildable) base type that provide a commonly-needed
+  // optional .typeParameters field.
+  def("TSHasOptionalTypeParameters")
+    .field("typeParameters",
+           or(def("TSTypeParameterDeclaration"), null),
+           defaults["null"]);
+
+  // An abstract (non-buildable) base type that provide a commonly-needed
+  // optional .typeAnnotation field.
+  def("TSHasOptionalTypeAnnotation")
+    .field("typeAnnotation",
+           or(def("TSTypeAnnotation"), null),
+           defaults["null"]);
+
+  def("TSQualifiedName")
+    .bases("Node")
+    .build("left", "right")
+    .field("left", IdOrQualifiedName)
+    .field("right", IdOrQualifiedName);
+
+  def("TSAsExpression")
+    .bases("Expression")
+    .build("expression")
+    .field("expression", def("Expression"))
+    .field("typeAnnotation", def("TSType"))
+    .field("extra",
+           or({ parenthesized: Boolean }, null),
+           defaults["null"]);
+
+  def("TSNonNullExpression")
+    .bases("Expression")
+    .build("expression")
+    .field("expression", def("Expression"));
+
+  [ // Define all the simple keyword types.
+    "TSAnyKeyword",
+    "TSBooleanKeyword",
+    "TSNeverKeyword",
+    "TSNullKeyword",
+    "TSNumberKeyword",
+    "TSObjectKeyword",
+    "TSStringKeyword",
+    "TSSymbolKeyword",
+    "TSUndefinedKeyword",
+    "TSVoidKeyword",
+    "TSThisType",
+  ].forEach(keywordType => {
+    def(keywordType)
+      .bases("TSType")
+      .build();
+  });
+
+  def("TSArrayType")
+    .bases("TSType")
+    .build("elementType")
+    .field("elementType", def("TSType"))
+
+  def("TSLiteralType")
+    .bases("TSType")
+    .build("literal")
+    .field("literal",
+           or(def("NumericLiteral"),
+              def("StringLiteral"),
+              def("BooleanLiteral")));
+
+  ["TSUnionType",
+   "TSIntersectionType",
+  ].forEach(typeName => {
+    def(typeName)
+      .bases("TSType")
+      .build("types")
+      .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("TSType"));
+
+  def("TSParenthesizedType")
+    .bases("TSType")
+    .build("typeAnnotation")
+    .field("typeAnnotation", def("TSType"));
+
+  var ParametersType = [or(
+    def("Identifier"),
+    def("RestElement")
+  )];
+
+  ["TSFunctionType",
+   "TSConstructorType",
+  ].forEach(typeName => {
+    def(typeName)
+      .bases("TSType",
+             "TSHasOptionalTypeParameters",
+             "TSHasOptionalTypeAnnotation")
+      .build("parameters")
+      .field("parameters", ParametersType);
+  });
+
+  def("TSDeclareFunction")
+    .bases("Declaration", "TSHasOptionalTypeParameters")
+    .build("id", "params", "returnType")
+    .field("declare", Boolean, defaults["false"])
+    .field("async", Boolean, defaults["false"])
+    .field("generator", Boolean, defaults["false"])
+    .field("id", or(def("Identifier"), null), defaults["null"])
+    .field("params", [def("Pattern")])
+    // tSFunctionTypeAnnotationCommon
+    .field("returnType",
+           or(def("TSTypeAnnotation"),
+              def("Noop"), // Still used?
+              null),
+           defaults["null"]);
+
+  def("TSDeclareMethod")
+    .bases("Declaration", "TSHasOptionalTypeParameters")
+    .build("key", "params", "returnType")
+    .field("async", Boolean, defaults["false"])
+    .field("generator", Boolean, defaults["false"])
+    .field("params", [def("Pattern")])
+    // classMethodOrPropertyCommon
+    .field("abstract", Boolean, defaults["false"])
+    .field("accessibility",
+           or("public", "private", "protected", void 0),
+           defaults["undefined"])
+    .field("static", Boolean, defaults["false"])
+    .field("computed", Boolean, defaults["false"])
+    .field("optional", Boolean, defaults["false"])
+    .field("key", or(
+      def("Identifier"),
+      def("StringLiteral"),
+      def("NumericLiteral"),
+      // Only allowed if .computed is true.
+      def("Expression")
+    ))
+    // classMethodOrDeclareMethodCommon
+    .field("kind",
+           or("get", "set", "method", "constructor"),
+           function getDefault() { return "method"; })
+    .field("access", // Not "accessibility"?
+           or("public", "private", "protected", void 0),
+           defaults["undefined"])
+    .field("decorators",
+           or([def("Decorator")], null),
+           defaults["null"])
+    // tSFunctionTypeAnnotationCommon
+    .field("returnType",
+           or(def("TSTypeAnnotation"),
+              def("Noop"), // Still used?
+              null),
+           defaults["null"]);
+
+  def("TSMappedType")
+    .bases("TSType")
+    .build("typeParameter", "typeAnnotation")
+    .field("readonly", Boolean, defaults["false"])
+    .field("typeParameter", def("TSTypeParameter"))
+    .field("optional", Boolean, defaults["false"])
+    .field("typeAnnotation",
+           or(def("TSType"), null),
+           defaults["null"]);
+
+  def("TSTupleType")
+    .bases("TSType")
+    .build("elementTypes")
+    .field("elementTypes", [def("TSType")]);
+
+  def("TSIndexedAccessType")
+    .bases("TSType")
+    .build("objectType", "indexType")
+    .field("objectType", def("TSType"))
+    .field("indexType", def("TSType"))
+
+  def("TSTypeOperator")
+    .bases("TSType")
+    .build("operator")
+    .field("operator", String)
+    .field("typeAnnotation", def("TSType"));
+
+  def("TSTypeAnnotation")
+    .bases("Node")
+    .build("typeAnnotation")
+    .field("typeAnnotation",
+           or(def("TSType"),
+              def("TSTypeAnnotation")));
+
+  def("TSIndexSignature")
+    .bases("Declaration", "TSHasOptionalTypeAnnotation")
+    .build("parameters")
+    .field("parameters", [def("Identifier")]) // Length === 1
+    .field("readonly", Boolean, defaults["false"]);
+
+  def("TSPropertySignature")
+    .bases("Declaration", "TSHasOptionalTypeAnnotation")
+    .build("key")
+    .field("key", def("Expression"))
+    .field("computed", Boolean, defaults["false"])
+    .field("readonly", Boolean, defaults["false"])
+    .field("optional", Boolean, defaults["false"])
+    .field("initializer",
+           or(def("Expression"), null),
+           defaults["null"]);
+
+  def("TSMethodSignature")
+    .bases("Declaration",
+           "TSHasOptionalTypeParameters",
+           "TSHasOptionalTypeAnnotation")
+    .build("key")
+    .field("key", def("Expression"))
+    .field("computed", Boolean, defaults["false"])
+    .field("optional", Boolean, defaults["false"])
+    .field("parameters", ParametersType);
+
+  def("TSTypePredicate")
+    .bases("TSTypeAnnotation")
+    .build("parameterName", "typeAnnotation")
+    .field("parameterName",
+           or(def("Identifier"),
+              def("TSThisType")))
+    .field("typeAnnotation", def("TSTypeAnnotation"));
+
+  ["TSCallSignatureDeclaration",
+   "TSConstructSignatureDeclaration",
+  ].forEach(typeName => {
+    def(typeName)
+      .bases("Declaration",
+             "TSHasOptionalTypeParameters",
+             "TSHasOptionalTypeAnnotation")
+      .build("parameters")
+      .field("parameters", ParametersType);
+  });
+
+  def("TSEnumMember")
+    .bases("Node")
+    .build("id", "initializer")
+    .field("id", or(def("Identifier"), StringLiteral))
+    .field("initializer",
+           or(def("Expression"), null),
+           defaults["null"]);
+
+  def("TSTypeQuery")
+    .bases("TSType")
+    .build("exprName")
+    .field("exprName", def("Identifier"));
+
+  // Inferred from Babylon's tsParseTypeMember method.
+  var TSTypeMember = or(
+    def("TSCallSignatureDeclaration"),
+    def("TSConstructSignatureDeclaration"),
+    def("TSIndexSignature"),
+    def("TSMethodSignature"),
+    def("TSPropertySignature")
+  );
+
+  def("TSTypeLiteral")
+    .bases("TSType")
+    .build("members")
+    .field("members", [TSTypeMember]);
+
+  def("TSTypeParameter")
+    .bases("Identifier")
+    .field("name", String)
+    .field("constraint", or(def("TSType"), null), defaults["null"])
+    .field("default", or(def("TSType"), null), defaults["null"]);
+
+  def("TSTypeAssertion")
+    .bases("Expression")
+    .build("typeAnnotation", "expression")
+    .field("typeAnnotation", def("TSType"))
+    .field("expression", def("Expression"))
+    .field("extra",
+           or({ parenthesized: Boolean }, null),
+           defaults["null"]);
+
+  def("TSTypeParameterDeclaration")
+    .bases("Declaration")
+    .build("params")
+    .field("params", [def("TSTypeParameter")]);
+
+  def("TSTypeParameterInstantiation")
+    .bases("Node")
+    .build("params")
+    .field("params", [def("TSType")]);
+
+  def("TSEnumDeclaration")
+    .bases("Declaration")
+    .build("id", "members")
+    .field("id", def("Identifier"))
+    .field("const", Boolean, defaults["false"])
+    .field("declare", Boolean, defaults["false"])
+    .field("members", [def("TSEnumMember")])
+    .field("initializer",
+           or(def("Expression"), null),
+           defaults["null"]);
+
+  def("TSTypeAliasDeclaration")
+    .bases("Declaration", "TSHasOptionalTypeParameters")
+    .build("id")
+    .field("id", def("Identifier"))
+    .field("declare", Boolean, defaults["false"])
+    .field("typeAnnotation", def("TSType"));
+
+  def("TSModuleBlock")
+    .bases("Node")
+    .build("body")
+    .field("body", [def("Statement")]);
+
+  def("TSModuleDeclaration")
+    .bases("Declaration")
+    .build("id", "body")
+    .field("id", or(StringLiteral, IdOrQualifiedName))
+    .field("declare", Boolean, defaults["false"])
+    .field("global", Boolean, defaults["false"])
+    .field("body",
+           or(def("TSModuleBlock"),
+              def("TSModuleDeclaration"),
+              null),
+           defaults["null"]);
+
+  def("TSImportEqualsDeclaration")
+    .bases("Declaration")
+    .build("id", "moduleReference")
+    .field("id", def("Identifier"))
+    .field("isExport", Boolean, defaults["false"])
+    .field("moduleReference",
+           or(IdOrQualifiedName,
+              def("TSExternalModuleReference")));
+
+  def("TSExternalModuleReference")
+    .bases("Declaration")
+    .build("expression")
+    .field("expression", StringLiteral);
+
+  def("TSExportAssignment")
+    .bases("Statement")
+    .build("expression")
+    .field("expression", def("Expression"));
+
+  def("TSNamespaceExportDeclaration")
+    .bases("Declaration")
+    .build("id")
+    .field("id", def("Identifier"));
+
+  def("TSInterfaceBody")
+    .bases("Node")
+    .build("body")
+    .field("body", [TSTypeMember]);
+
+  def("TSExpressionWithTypeArguments")
+    .bases("TSType")
+    .build("expression", "typeParameters")
+    .field("expression", IdOrQualifiedName)
+    .field("typeParameters",
+           or(def("TSTypeParameterInstantiation"), null),
+           defaults["null"]);
+
+  def("TSInterfaceDeclaration")
+    .bases("Declaration", "TSHasOptionalTypeParameters")
+    .build("id", "body")
+    .field("id", IdOrQualifiedName)
+    .field("declare", Boolean, defaults["false"])
+    .field("extends",
+           or([def("TSExpressionWithTypeArguments")], null),
+           defaults["null"])
+    .field("body", def("TSInterfaceBody"));
+
+  ["ClassDeclaration",
+   "ClassExpression",
+  ].forEach(typeName => {
+    def(typeName)
+      .field("implements",
+             [def("TSExpressionWithTypeArguments")],
+             defaults.emptyArray);
+  });
+
+  def("TSParameterProperty")
+    .bases("Pattern")
+    .build("parameter")
+    .field("accessibility",
+           or("public", "private", "protected", void 0),
+           defaults["undefined"])
+    .field("readonly", Boolean, defaults["false"])
+    .field("parameter", or(def("Identifier"),
+                           def("AssignmentPattern")));
+
+  // Defined already in es6 and babel-core.
+  def("ClassBody")
+    .field("body", [or(
+      def("MethodDefinition"),
+      def("VariableDeclarator"),
+      def("ClassPropertyDefinition"),
+      def("ClassProperty"),
+      def("ClassMethod"),
+      // Just need to add these types:
+      def("TSDeclareMethod"),
+      TSTypeMember
+    )]);
+};

package/lib/scope.js

@@ -274,6 +274,10 @@ module.exports = function (fork) {
                 bindings[pattern.name] = [patternPath];
             }
 
+        } else if (namedTypes.AssignmentPattern &&
+          namedTypes.AssignmentPattern.check(pattern)) {
+          addPattern(patternPath.get('left'), bindings);
+
         } else if (namedTypes.ObjectPattern &&
           namedTypes.ObjectPattern.check(pattern)) {
             patternPath.get('properties').each(function(propertyPath) {

package/main.js

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

package/package.json

@@ -18,7 +18,7 @@
     "transformation",
     "syntax"
   ],
-  "version": "0.10.1",
+  "version": "0.11.2",
   "homepage": "http://github.com/benjamn/ast-types",
   "repository": {
     "type": "git",
@@ -27,17 +27,19 @@
   "license": "MIT",
   "main": "main.js",
   "scripts": {
-    "test": "mocha --reporter spec --full-trace test/run.js"
+    "test": "test/run.sh"
   },
   "dependencies": {},
   "devDependencies": {
     "babel-types": "^6.26.0",
-    "babylon": "^7.0.0-beta.31",
+    "babylon": "^7.0.0-beta.40",
     "espree": "^3.1.7",
     "esprima": "~4.0.0",
     "esprima-fb": "~14001.1.0-dev-harmony-fb",
-    "mocha": "^4.0.1",
-    "reify": "^0.12.0"
+    "flow-parser": "^0.66.0",
+    "glob": "^7.1.2",
+    "mocha": "^5.0.0",
+    "reify": "^0.14.1"
   },
   "engines": {
     "node": ">= 0.8"