Choose parser based on file extension

Summary:
This adds the main entry point for the TypeScript parser as well as adds the logic to use the new parser if the spec file's extension is `.ts`

`js/react-native-github/packages/react-native-codegen/src/parsers/typescript/index.js` is mostly a direct copy from the flow parser.

Changelog:
[General][Add] - Choose Flow or WIP TypeScript Codegen parser based on spec's file extension

Reviewed By: RSNara

Differential Revision: D33081296

fbshipit-source-id: 267823685e6723e3c1f19752bbbe692e895c075b

Author: charlesbdudley

packages/react-native-codegen/src/cli/combine/combine-js-to-schema-cli.js

@@ -35,7 +35,7 @@ const allFiles = [];
 fileList.forEach(file => {
   if (fs.lstatSync(file).isDirectory()) {
     const dirFiles = glob
-      .sync(`${file}/**/*.js`, {
+      .sync(`${file}/**/*.{js,ts,tsx}`, {
         nodir: true,
       })
       .filter(filterJSFile);

packages/react-native-codegen/src/cli/combine/combine-js-to-schema.js

@@ -12,18 +12,26 @@
 import type {SchemaType} from '../../CodegenSchema.js';
 
 const FlowParser = require('../../parsers/flow');
+const TypeScriptParser = require('../../parsers/typescript');
 const fs = require('fs');
+const path = require('path');
 
 function combineSchemas(files: Array<string>): SchemaType {
   return files.reduce(
     (merged, filename) => {
       const contents = fs.readFileSync(filename, 'utf8');
+
       if (
         contents &&
         (/export\s+default\s+\(?codegenNativeComponent</.test(contents) ||
           /extends TurboModule/.test(contents))
       ) {
-        const schema = FlowParser.parseFile(filename);
+        const isTypeScript =
+          path.extname(filename) === '.ts' || path.extname(filename) === '.tsx';
+
+        const schema = isTypeScript
+          ? TypeScriptParser.parseFile(filename)
+          : FlowParser.parseFile(filename);
 
         if (schema && schema.modules) {
           merged.modules = {...merged.modules, ...schema.modules};

packages/react-native-codegen/src/cli/parser/parser.js

@@ -10,13 +10,24 @@
 
 'use strict';
 
+const path = require('path');
 const FlowParser = require('../../parsers/flow');
+const TypeScriptParser = require('../../parsers/typescript');
 
 function parseFiles(files: Array<string>) {
   files.forEach(filename => {
+    const isTypeScript =
+      path.extname(filename) === '.ts' || path.extname(filename) === '.tsx';
+
     console.log(
       filename,
-      JSON.stringify(FlowParser.parseFile(filename), null, 2),
+      JSON.stringify(
+        isTypeScript
+          ? TypeScriptParser.parseFile(filename)
+          : FlowParser.parseFile(filename),
+        null,
+        2,
+      ),
     );
   });
 }

packages/react-native-codegen/src/parsers/typescript/index.js

@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import type {SchemaType} from '../../CodegenSchema.js';
+const babelParser = require('@babel/parser');
+const fs = require('fs');
+const path = require('path');
+const {buildComponentSchema} = require('./components');
+const {wrapComponentSchema} = require('./components/schema');
+const {buildModuleSchema} = require('./modules');
+const {wrapModuleSchema} = require('./modules/schema');
+
+const {
+  createParserErrorCapturer,
+  visit,
+  isModuleRegistryCall,
+} = require('./utils');
+const invariant = require('invariant');
+
+function getConfigType(
+  // TODO(T108222691): Use flow-types for @babel/parser
+  ast: $FlowFixMe,
+): 'module' | 'component' | 'none' {
+  let isComponent = false;
+  let isModule = false;
+
+  visit(ast, {
+    CallExpression(node) {
+      if (
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'codegenNativeComponent'
+      ) {
+        isComponent = true;
+      }
+
+      if (isModuleRegistryCall(node)) {
+        isModule = true;
+      }
+    },
+
+    TSInterfaceDeclaration(node) {
+      if (
+        Array.isArray(node.extends) &&
+        node.extends.some(
+          extension => extension.expression.name === 'TurboModule',
+        )
+      ) {
+        isModule = true;
+      }
+    },
+  });
+
+  if (isModule && isComponent) {
+    throw new Error(
+      'Found type extending "TurboModule" and exported "codegenNativeComponent" declaration in one file. Split them into separated files.',
+    );
+  }
+
+  if (isModule) {
+    return 'module';
+  } else if (isComponent) {
+    return 'component';
+  } else {
+    return 'none';
+  }
+}
+
+function buildSchema(contents: string, filename: ?string): SchemaType {
+  // Early return for non-Spec JavaScript files
+  if (
+    !contents.includes('codegenNativeComponent') &&
+    !contents.includes('TurboModule')
+  ) {
+    return {modules: {}};
+  }
+
+  const ast = babelParser.parse(contents, {
+    sourceType: 'module',
+    plugins: ['typescript'],
+  }).program;
+
+  const configType = getConfigType(ast);
+
+  switch (configType) {
+    case 'component': {
+      return wrapComponentSchema(buildComponentSchema(ast));
+    }
+    case 'module': {
+      if (filename === undefined || filename === null) {
+        throw new Error('Filepath expected while parasing a module');
+      }
+      const hasteModuleName = path.basename(filename).replace(/\.tsx?$/, '');
+
+      const [parsingErrors, tryParse] = createParserErrorCapturer();
+
+      const schema = tryParse(() =>
+        buildModuleSchema(hasteModuleName, ast, tryParse),
+      );
+
+      if (parsingErrors.length > 0) {
+        /**
+         * TODO(T77968131): We have two options:
+         *  - Throw the first error, but indicate there are more then one errors.
+         *  - Display all errors, nicely formatted.
+         *
+         * For the time being, we're just throw the first error.
+         **/
+
+        throw parsingErrors[0];
+      }
+
+      invariant(
+        schema != null,
+        'When there are no parsing errors, the schema should not be null',
+      );
+
+      return wrapModuleSchema(schema, hasteModuleName);
+    }
+    default:
+      return {modules: {}};
+  }
+}
+
+function parseFile(filename: string): SchemaType {
+  const contents = fs.readFileSync(filename, 'utf8');
+
+  return buildSchema(contents, filename);
+}
+
+function parseModuleFixture(filename: string): SchemaType {
+  const contents = fs.readFileSync(filename, 'utf8');
+
+  return buildSchema(contents, 'path/NativeSampleTurboModule.ts');
+}
+
+function parseString(contents: string, filename: ?string): SchemaType {
+  return buildSchema(contents, filename);
+}
+
+module.exports = {
+  parseFile,
+  parseModuleFixture,
+  parseString,
+};