Generate TypeScript typings, and improve generated Flow typings (#7101)

* generate typescript types

* improve type generator output

* move generator scripts to scripts/generators

* use new stringifier for generating flow types too

* export summary types

* add support for oneOfNodeOrValueTypes to improve type generation

* export typescript types from top level, and remove module declaration

* generate typescript/flow types and copy typescript types to babel-types/lib as part of make build

* copy flow types to babel-types/lib as part of make build (fix #6839)

* improve typing: Identifier->name should be a string, not any

* avoid destructuring, to support node 4

* update doc generator to share more code, regenerate babel-types readme, pipe all generator output to stdout

* regenerate babel-types readme as part of make build

* improve typing: ClassProperty->key should be Identifier | StringLiteral | NumericLiteral | Expression, not any

* improve typing: optional node properties are nullable, not undefinedable

* improve docs: FlowClassImplements should be ClassImplements

* make ts usage more friendly: when using babel-types api, make optional params | undefined, and when reading nodes keep optional params | null

* rm lib/types.d.ts and lib/types.js in favor of packages/babel-types/lib

* add missing variance node type, address review comments

* add tests for flow variance

* Comment should be a disjoint union of tagged types

* update .flowconfig

scripts/generators/utils.js

@@ -0,0 +1,51 @@
+exports.stringifyValidator = function stringifyValidator(
+  validator,
+  nodePrefix
+) {
+  if (validator === undefined) {
+    return "any";
+  }
+
+  if (validator.each) {
+    return `Array<${stringifyValidator(validator.each, nodePrefix)}>`;
+  }
+
+  if (validator.chainOf) {
+    return stringifyValidator(validator.chainOf[1], nodePrefix);
+  }
+
+  if (validator.oneOf) {
+    return validator.oneOf.map(JSON.stringify).join(" | ");
+  }
+
+  if (validator.oneOfNodeTypes) {
+    return validator.oneOfNodeTypes.map(_ => nodePrefix + _).join(" | ");
+  }
+
+  if (validator.oneOfNodeOrValueTypes) {
+    return validator.oneOfNodeOrValueTypes
+      .map(_ => {
+        return isValueType(_) ? _ : nodePrefix + _;
+      })
+      .join(" | ");
+  }
+
+  if (validator.type) {
+    return validator.type;
+  }
+
+  return ["any"];
+};
+
+exports.toFunctionName = function toFunctionName(typeName) {
+  const _ = typeName.replace(/^TS/, "ts").replace(/^JSX/, "jsx");
+  return _.slice(0, 1).toLowerCase() + _.slice(1);
+};
+
+/**
+ * Heuristic to decide whether or not the given type is a value type (eg. "null")
+ * or a Node type (eg. "Expression").
+ */
+function isValueType(type) {
+  return type.charAt(0).toLowerCase() === type.charAt(0);
+}