ast-types 0.10.2 → 0.11.3

package/def/babel-core.js

@@ -187,7 +187,8 @@ module.exports = function (fork) {
     def("Property"),
     def("ObjectMethod"),
     def("ObjectProperty"),
-    def("SpreadProperty")
+    def("SpreadProperty"),
+    def("SpreadElement")
   );
 
   // Split Property -> ObjectProperty and ObjectMethod
@@ -207,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"]);
@@ -216,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/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/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

@@ -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.2",
+  "version": "0.11.3",
   "homepage": "http://github.com/benjamn/ast-types",
   "repository": {
     "type": "git",
@@ -27,15 +27,17 @@
   "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",
+    "flow-parser": "^0.66.0",
+    "glob": "^7.1.2",
     "mocha": "^5.0.0",
     "reify": "^0.14.1"
   },