Codegen: Generate ObjC structs for type aliases

Summary: **Motivation:** Match the old codegen's behavior when generating structs for type alias derived objects. **Problem description:** Take, for example, the following spec: ``` export type MyTypeAlias = { /* ... */ } export interface Spec extends TurboModule { // ... +myMethod: (paramName: MyTypeAlias) => void; // ... } ``` The codegen needs to generate a struct to expose the properties of the type alias object. The codegen was producing the following output: ``` - (void)myMethod:(JS::MyModule::SpecMyMethodParamName &)paramName; ``` ...which does not match the output from the original codegen: ``` - (void)myMethod:(JS::MyModule::MyTypeAlias &)paramName; ``` The original codegen generates a struct using the type alias name, while the new codegen was generating a struct that uses a combination of the property and parameter names. Now that type alias names are exposed in the schema, the new codegen can match the original codegen's behavior. **De-duplication of structs:** Prior to these changes, type aliases were expanded into regular object types. This meant that any spec that used a type alias more than once would lead to redundant structs getting created. With these changes, we only generate the one struct per type alias, matching the old codegen. **Expansion of type aliases:** A new type was introduced in D22200700 (facebook@e261f02), TypeAliasTypeAnnotation: ``` export type TypeAliasTypeAnnotation = $ReadOnly<{| type: 'TypeAliasTypeAnnotation', name: string, |}>; ``` This type may now appear in several locations where a `{| type: 'ObjectTypeAnnotation', properties: [] |}` otherwise would have been used. A `getTypeAliasTypeAnnotation` function is introduced which, given an alias name and an array of aliases provided by the module, will produce the actual object type annotation for the given property parameter. Changelog: [Internal] Reviewed By: RSNara Differential Revision: D22244323 fbshipit-source-id: 125fbf0d6d887bd05a99bf8b81b30bdda4f1682b

Author: hramos

packages/react-native-codegen/src/generators/modules/GenerateModuleCpp.js

@@ -11,7 +11,7 @@
 'use strict';
 
 import type {SchemaType} from '../../CodegenSchema';
-
+const {getTypeAliasTypeAnnotation} = require('./ObjCppUtils/Utils');
 type FilesOutput = Map<string, string>;
 
 const propertyHeaderTemplate =
@@ -62,20 +62,25 @@ namespace react {
 } // namespace facebook
 `;
 
-function traverseArg(arg, index): string {
+function traverseArg(arg, index, aliases): string {
  function wrap(suffix) {
  return `args[${index}]${suffix}`;
  }
  const {typeAnnotation} = arg;
- switch (typeAnnotation.type) {
+
+ const realTypeAnnotation =
+ typeAnnotation.type === 'TypeAliasTypeAnnotation'
+ ? getTypeAliasTypeAnnotation(typeAnnotation.name, aliases)
+ : typeAnnotation;
+ switch (realTypeAnnotation.type) {
  case 'ReservedFunctionValueTypeAnnotation':
- switch (typeAnnotation.name) {
+ switch (realTypeAnnotation.name) {
  case 'RootTag':
  return wrap('.getNumber()');
  default:
- (typeAnnotation.name: empty);
+ (realTypeAnnotation.name: empty);
  throw new Error(
- `Unknown prop type for "${arg.name}", found: "${typeAnnotation.name}"`,
+ `Unknown prop type for "${arg.name}, found: ${realTypeAnnotation.name}"`,
  );
  }
  case 'StringTypeAnnotation':
@@ -91,27 +96,26 @@ function traverseArg(arg, index): string {
  case 'FunctionTypeAnnotation':
  return `std::move(${wrap('.getObject(rt).getFunction(rt)')})`;
  case 'GenericObjectTypeAnnotation':
- case 'TypeAliasTypeAnnotation': // TODO: Handle aliases
  case 'ObjectTypeAnnotation':
  return wrap('.getObject(rt)');
  case 'AnyTypeAnnotation':
  throw new Error(`Any type is not allowed in params for "${arg.name}"`);
  default:
  // TODO (T65847278): Figure out why this does not work.
- // (typeAnnotation.type: empty);
+ // (type: empty);
  throw new Error(
- `Unknown prop type for "${arg.name}", found: "${typeAnnotation.type}"`,
+ `Unknown prop type for "${arg.name}, found: ${realTypeAnnotation.type}"`,
  );
  }
 }
 
-function traverseProperty(property): string {
+function traverseProperty(property, aliases): string {
  const propertyTemplate =
  property.typeAnnotation.returnTypeAnnotation.type === 'VoidTypeAnnotation'
  ? voidPropertyTemplate
  : nonvoidPropertyTemplate;
  const traversedArgs = property.typeAnnotation.params
- .map(traverseArg)
+ .map((p, i) => traverseArg(p, i, aliases))
  .join(', ');
  return propertyTemplate
  .replace(/::_PROPERTY_NAME_::/g, property.name)
@@ -138,9 +142,9 @@ module.exports = {
 
  const modules = Object.keys(nativeModules)
  .map(name => {
- const {properties} = nativeModules[name];
+ const {aliases, properties} = nativeModules[name];
  const traversedProperties = properties
- .map(property => traverseProperty(property))
+ .map(property => traverseProperty(property, aliases))
  .join('\n');
  return moduleTemplate
  .replace(/::_MODULE_PROPERTIES_::/g, traversedProperties)

packages/react-native-codegen/src/generators/modules/GenerateModuleH.js

@@ -14,8 +14,12 @@ import type {
  SchemaType,
  FunctionTypeAnnotationParamTypeAnnotation,
  FunctionTypeAnnotationReturn,
+ TypeAliasTypeAnnotation,
+ ObjectTypeAliasTypeShape,
 } from '../../CodegenSchema';
 
+const {getTypeAliasTypeAnnotation} = require('./ObjCppUtils/Utils');
+
 type FilesOutput = Map<string, string>;
 
 const moduleTemplate = `
@@ -51,17 +55,23 @@ namespace react {
 function translatePrimitiveJSTypeToCpp(
  typeAnnotation:
  | FunctionTypeAnnotationParamTypeAnnotation
- | FunctionTypeAnnotationReturn,
+ | FunctionTypeAnnotationReturn
+ | TypeAliasTypeAnnotation,
  createErrorMessage: (typeName: string) => string,
+ aliases: $ReadOnly<{[aliasName: string]: ObjectTypeAliasTypeShape, ...}>,
 ) {
- switch (typeAnnotation.type) {
+ const realTypeAnnotation =
+ typeAnnotation.type === 'TypeAliasTypeAnnotation'
+ ? getTypeAliasTypeAnnotation(typeAnnotation.name, aliases)
+ : typeAnnotation;
+ switch (realTypeAnnotation.type) {
  case 'ReservedFunctionValueTypeAnnotation':
- switch (typeAnnotation.name) {
+ switch (realTypeAnnotation.name) {
  case 'RootTag':
  return 'double';
  default:
- (typeAnnotation.name: empty);
- throw new Error(createErrorMessage(typeAnnotation.name));
+ (realTypeAnnotation.name: empty);
+ throw new Error(createErrorMessage(realTypeAnnotation.name));
  }
  case 'VoidTypeAnnotation':
  return 'void';
@@ -74,7 +84,6 @@ function translatePrimitiveJSTypeToCpp(
  return 'int';
  case 'BooleanTypeAnnotation':
  return 'bool';
- // case 'TypeAliasTypeAnnotation': // TODO: Handle aliases
  case 'GenericObjectTypeAnnotation':
  case 'ObjectTypeAnnotation':
  return 'jsi::Object';
@@ -86,8 +95,8 @@ function translatePrimitiveJSTypeToCpp(
  return 'jsi::Value';
  default:
  // TODO (T65847278): Figure out why this does not work.
- // (typeAnnotation.type: empty);
- throw new Error(createErrorMessage(typeAnnotation.type));
+ // (type: empty);
+ throw new Error(createErrorMessage(realTypeAnnotation.type));
  }
 }
 
@@ -114,7 +123,7 @@ module.exports = {
 
  const modules = Object.keys(nativeModules)
  .map(name => {
- const {properties} = nativeModules[name];
+ const {aliases, properties} = nativeModules[name];
  const traversedProperties = properties
  .map(prop => {
  const traversedArgs = prop.typeAnnotation.params
@@ -123,6 +132,7 @@ module.exports = {
  param.typeAnnotation,
  typeName =>
  `Unsupported type for param "${param.name}" in ${prop.name}. Found: ${typeName}`,
+ aliases,
  );
  const isObject = translatedParam.startsWith('jsi::');
  return (
@@ -140,6 +150,7 @@ module.exports = {
  prop.typeAnnotation.returnTypeAnnotation,
  typeName =>
  `Unsupported return type for ${prop.name}. Found: ${typeName}`,
+ aliases,
  ),
  )
  .replace(