@react-native-windows/codegen 0.0.0-canary.12 → 0.0.0-canary.120

package/src/generators/ObjectTypes.ts

@@ -6,31 +6,71 @@
 
 'use strict';
 
-import {
+import type {
+  NativeModuleEnumDeclaration,
   NativeModuleBaseTypeAnnotation,
-  NativeModuleObjectTypeAnnotation,
-  NamedShape,
+  NativeModuleUnionTypeAnnotation,
+  NativeModuleStringTypeAnnotation,
+  NativeModuleFunctionTypeAnnotation,
+  NativeModuleStringLiteralTypeAnnotation,
+  StringLiteralUnionTypeAnnotation,
+  UnsafeAnyTypeAnnotation,
   Nullable,
-} from 'react-native-tscodegen';
+} from '@react-native/codegen/lib/CodegenSchema';
+import {
+  AliasMap,
+  getAliasCppName,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
 
-let preferredModuleName: string = '';
+export type CppStringTypes = 'std::string' | 'std::wstring';
 
-export function setPreferredModuleName(moduleName: string): void {
-  preferredModuleName = moduleName;
+export interface CppCodegenOptions {
+  cppStringType: CppStringTypes;
 }
 
-export function getAliasCppName(typeName: string): string {
-  return `${preferredModuleName}Spec_${typeName}`;
+function translateUnionReturnType(
+  type: NativeModuleEnumDeclaration | NativeModuleUnionTypeAnnotation,
+  options: CppCodegenOptions,
+): string {
+  const memberType = type.memberType;
+  switch (type.memberType) {
+    case 'StringTypeAnnotation':
+      return options.cppStringType;
+    case 'NumberTypeAnnotation':
+      return 'double';
+    case 'ObjectTypeAnnotation':
+      return '::React::JSValue';
+    default:
+      throw new Error(
+        `Unknown enum/union member type in translateReturnType: ${memberType}`,
+      );
+  }
 }
 
-function translateField(
-  type: Nullable<NativeModuleBaseTypeAnnotation>,
+// eslint-disable-next-line complexity
+export function translateFieldOrReturnType(
+  type:
+    | Nullable<
+        | NativeModuleBaseTypeAnnotation
+        | NativeModuleStringTypeAnnotation
+        | NativeModuleFunctionTypeAnnotation
+        | NativeModuleStringLiteralTypeAnnotation
+        | StringLiteralUnionTypeAnnotation
+      >
+    | UnsafeAnyTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  callerName: 'translateField' | 'translateReturnType',
+  options: CppCodegenOptions,
 ): string {
   // avoid: Property 'type' does not exist on type 'never'
   const returnType = type.type;
   switch (type.type) {
     case 'StringTypeAnnotation':
-      return 'std::string';
+    case 'StringLiteralTypeAnnotation':
+    case 'StringLiteralUnionTypeAnnotation':
+      return options.cppStringType;
     case 'NumberTypeAnnotation':
     case 'FloatTypeAnnotation':
     case 'DoubleTypeAnnotation':
@@ -40,46 +80,64 @@ function translateField(
     case 'BooleanTypeAnnotation':
       return 'bool';
     case 'ArrayTypeAnnotation':
-      // TODO: type.elementType
-      return 'React::JSValueArray';
+      if (type.elementType.type !== 'AnyTypeAnnotation') {
+        return `std::vector<${translateFieldOrReturnType(
+          type.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+          callerName,
+          options,
+        )}>`;
+      } else {
+        return `::React::JSValueArray`;
+      }
     case 'GenericObjectTypeAnnotation':
-      return 'React::JSValue';
+      return '::React::JSValue';
     case 'ObjectTypeAnnotation':
-      // TODO: we have more information here, and could create a more specific type
-      return 'React::JSValueObject';
+      return getAnonymousAliasCppName(aliases, baseAliasName, type);
     case 'ReservedTypeAnnotation': {
       // avoid: Property 'name' does not exist on type 'never'
       const name = type.name;
       // (#6597)
       // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (name !== 'RootTag')
-        throw new Error(
-          `Unknown reserved function: ${name} in translateReturnType`,
-        );
+        throw new Error(`Unknown reserved function: ${name} in ${callerName}`);
       return 'double';
     }
     case 'TypeAliasTypeAnnotation':
       return getAliasCppName(type.name);
     case 'NullableTypeAnnotation':
-      return `std::optional<${translateField(type.typeAnnotation)}>`;
+      return `std::optional<${translateFieldOrReturnType(
+        type.typeAnnotation,
+        aliases,
+        baseAliasName,
+        callerName,
+        options,
+      )}>`;
+    case 'FunctionTypeAnnotation':
+    case 'MixedTypeAnnotation':
+      return '';
+    case 'EnumDeclaration':
+    case 'UnionTypeAnnotation':
+      return translateUnionReturnType(type, options);
+    case 'AnyTypeAnnotation':
+      return '::React::JSValue?';
     default:
-      throw new Error(`Unhandled type in translateReturnType: ${returnType}`);
+      throw new Error(`Unhandled type in ${callerName}: ${returnType}`);
   }
 }
 
-export function translateObjectBody(
-  type: NativeModuleObjectTypeAnnotation,
-  prefix: string,
-) {
-  return type.properties
-    .map((prop: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>) => {
-      let propType = prop.typeAnnotation;
-      if (prop.optional && propType.type !== 'NullableTypeAnnotation') {
-        propType = {type: 'NullableTypeAnnotation', typeAnnotation: propType};
-      }
-      const first = `${prefix}REACT_FIELD(${prop.name})`;
-      const second = `${prefix}${translateField(propType)} ${prop.name};`;
-      return `${first}\n${second}`;
-    })
-    .join('\n');
+export function translateField(
+  type: Nullable<NativeModuleBaseTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  return translateFieldOrReturnType(
+    type,
+    aliases,
+    baseAliasName,
+    'translateField',
+    options,
+  );
 }

package/src/generators/ParamTypes.ts

@@ -6,12 +6,25 @@
 
 'use strict';
 
-import {
+import type {
   NamedShape,
+  NativeModuleArrayTypeAnnotation,
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleEventEmitterBaseTypeAnnotation,
+  NativeModuleEventEmitterTypeAnnotation,
+  NativeModuleEnumDeclaration,
+  NativeModuleFunctionTypeAnnotation,
   NativeModuleParamTypeAnnotation,
+  NativeModuleUnionTypeAnnotation,
+  UnsafeAnyTypeAnnotation,
   Nullable,
-} from 'react-native-tscodegen';
-import {getAliasCppName} from './ObjectTypes';
+} from '@react-native/codegen/lib/CodegenSchema';
+import {
+  AliasMap,
+  getAliasCppName,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
+import type {CppCodegenOptions} from './ObjectTypes';
 
 type NativeModuleParamShape = NamedShape<
   Nullable<NativeModuleParamTypeAnnotation>
@@ -30,15 +43,156 @@ function decorateType(type: string, target: ParamTarget): string {
   }
 }
 
+function translateUnionReturnType(
+  type: NativeModuleEnumDeclaration | NativeModuleUnionTypeAnnotation,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  const memberType = type.memberType;
+  switch (type.memberType) {
+    case 'StringTypeAnnotation':
+      return options.cppStringType;
+    case 'NumberTypeAnnotation':
+      return 'double';
+    case 'ObjectTypeAnnotation':
+      return decorateType('::React::JSValue', target);
+    default:
+      throw new Error(
+        `Unknown enum/union member type in translateReturnType: ${memberType}`,
+      );
+  }
+}
+
+function translateFunction(
+  param: NativeModuleFunctionTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  // TODO: type.returnTypeAnnotation
+  switch (target) {
+    case 'spec':
+      return `Callback<${param.params
+        .map((p: NativeModuleParamShape) =>
+          translateSpecFunctionParam(
+            p,
+            aliases,
+            `${baseAliasName}_${p.name}`,
+            options,
+          ),
+        )
+        .join(', ')}>`;
+    case 'template':
+      return `std::function<void(${param.params
+        .map((p: NativeModuleParamShape) =>
+          translateCallbackParam(
+            p,
+            aliases,
+            `${baseAliasName}_${p.name}`,
+            options,
+          ),
+        )
+        .join(', ')})>`;
+    default:
+      return `std::function<void(${param.params
+        .map((p: NativeModuleParamShape) =>
+          translateCallbackParam(
+            p,
+            aliases,
+            `${baseAliasName}_${p.name}`,
+            options,
+          ),
+        )
+        .join(', ')})> const &`;
+  }
+}
+
+function translateArray(
+  param: NativeModuleArrayTypeAnnotation<
+    Nullable<NativeModuleBaseTypeAnnotation>
+  >,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  if (param.elementType.type !== 'AnyTypeAnnotation') {
+    switch (target) {
+      case 'spec':
+      case 'template':
+        return `std::vector<${translateNullableParamType(
+          param.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+          'template',
+          'template',
+          options,
+        )}>`;
+      default:
+        return `std::vector<${translateNullableParamType(
+          param.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+          'template',
+          'template',
+          options,
+        )}> const &`;
+    }
+  } else {
+    return decorateType('::React::JSValueArray', target);
+  }
+}
+
+// Hopefully eventually NativeModuleEventEmitterTypeAnnotation will align better with NativeModuleParamTypeAnnotation
+// and this method can be merged / replaced with translateArray
+function translateEventEmitterArray(
+  param: {
+    readonly type: 'ArrayTypeAnnotation';
+    readonly elementType:
+      | NativeModuleEventEmitterBaseTypeAnnotation
+      | {type: string};
+  },
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  switch (target) {
+    case 'spec':
+    case 'template':
+      return `std::vector<${translateEventEmitterParam(
+        param.elementType as NativeModuleEventEmitterBaseTypeAnnotation,
+        aliases,
+        `${baseAliasName}_element`,
+        'template',
+        options,
+      )}>`;
+    default:
+      return `std::vector<${translateEventEmitterParam(
+        param.elementType as NativeModuleEventEmitterBaseTypeAnnotation,
+        aliases,
+        `${baseAliasName}_element`,
+        'template',
+        options,
+      )}> const &`;
+  }
+}
+
 function translateParam(
-  param: NativeModuleParamTypeAnnotation,
+  param: NativeModuleParamTypeAnnotation | UnsafeAnyTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
   target: ParamTarget,
+  options: CppCodegenOptions,
 ): string {
   // avoid: Property 'type' does not exist on type 'never'
   const paramType = param.type;
   switch (param.type) {
     case 'StringTypeAnnotation':
-      return 'std::string';
+    case 'StringLiteralTypeAnnotation':
+    case 'StringLiteralUnionTypeAnnotation':
+      return options.cppStringType;
     case 'NumberTypeAnnotation':
     case 'FloatTypeAnnotation':
     case 'DoubleTypeAnnotation':
@@ -47,31 +201,17 @@ function translateParam(
       return 'int';
     case 'BooleanTypeAnnotation':
       return 'bool';
-    case 'FunctionTypeAnnotation': {
-      // TODO: type.returnTypeAnnotation
-      switch (target) {
-        case 'spec':
-          return `Callback<${param.params
-            .map(translateSpecFunctionParam)
-            .join(', ')}>`;
-        case 'template':
-          return `std::function<void(${param.params
-            .map(translateCallbackParam)
-            .join(', ')})>`;
-        default:
-          return `std::function<void(${param.params
-            .map(translateCallbackParam)
-            .join(', ')})> const &`;
-      }
-    }
+    case 'FunctionTypeAnnotation':
+      return translateFunction(param, aliases, baseAliasName, target, options);
     case 'ArrayTypeAnnotation':
-      // TODO: type.elementType
-      return decorateType('React::JSValueArray', target);
+      return translateArray(param, aliases, baseAliasName, target, options);
     case 'GenericObjectTypeAnnotation':
-      return decorateType('React::JSValue', target);
+      return decorateType('::React::JSValue', target);
     case 'ObjectTypeAnnotation':
-      // TODO: we have more information here, and could create a more specific type
-      return decorateType('React::JSValueObject', target);
+      return decorateType(
+        getAnonymousAliasCppName(aliases, baseAliasName, param),
+        target,
+      );
     case 'ReservedTypeAnnotation': {
       // avoid: Property 'name' does not exist on type 'never'
       const name = param.name;
@@ -83,68 +223,175 @@ function translateParam(
     }
     case 'TypeAliasTypeAnnotation':
       return decorateType(getAliasCppName(param.name), target);
+    case 'MixedTypeAnnotation':
+      return '';
+    case 'EnumDeclaration':
+    case 'UnionTypeAnnotation':
+      return translateUnionReturnType(param, target, options);
+    case 'AnyTypeAnnotation':
+      return decorateType('::React::JSValue', target);
     default:
       throw new Error(`Unhandled type in translateParam: ${paramType}`);
   }
 }
 
-function translateSpecFunctionParam(param: NativeModuleParamShape): string {
-  switch (param.typeAnnotation.type) {
-    case 'NullableTypeAnnotation':
-      // TODO: should be
-      // return `std::optional<${translateParam(
-      //   param.typeAnnotation.typeAnnotation,
-      //   'spec',
-      // )}>`;
-      return translateParam(param.typeAnnotation.typeAnnotation, 'spec');
+// Hopefully eventually NativeModuleEventEmitterTypeAnnotation will align better with NativeModuleParamTypeAnnotation
+// and this method can be merged / replaced with translateParam
+function translateEventEmitterParam(
+  param: NativeModuleEventEmitterTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  // avoid: Property 'type' does not exist on type 'never'
+  const paramType = param.type;
+  switch (param.type) {
+    case 'StringTypeAnnotation':
+      return options.cppStringType;
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'ArrayTypeAnnotation':
+      return translateEventEmitterArray(
+        param,
+        aliases,
+        baseAliasName,
+        target,
+        options,
+      );
+    case 'TypeAliasTypeAnnotation':
+      return decorateType(getAliasCppName(param.name), target);
+    case 'VoidTypeAnnotation':
+      return 'void';
     default:
-      return translateParam(param.typeAnnotation, 'spec');
+      throw new Error(`Unhandled type in translateParam: ${paramType}`);
   }
 }
 
-function translateCallbackParam(param: NativeModuleParamShape): string {
-  switch (param.typeAnnotation.type) {
+function translateNullableParamType(
+  paramType:
+    | Nullable<NativeModuleParamTypeAnnotation>
+    | UnsafeAnyTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  nullableTarget: ParamTarget,
+  target: ParamTarget,
+  options: CppCodegenOptions,
+): string {
+  switch (paramType.type) {
     case 'NullableTypeAnnotation':
-      // TODO: should be
-      // return `std::optional<${translateParam(
-      //   param.typeAnnotation.typeAnnotation,
-      //   'template',
-      // )}>`;
-      return translateParam(
-        param.typeAnnotation.typeAnnotation,
-        'callback-arg',
-      );
+      return `std::optional<${translateParam(
+        paramType.typeAnnotation,
+        aliases,
+        baseAliasName,
+        nullableTarget,
+        options,
+      )}>`;
     default:
-      return translateParam(param.typeAnnotation, 'callback-arg');
+      return translateParam(paramType, aliases, baseAliasName, target, options);
   }
 }
 
-function translateFunctionParam(param: NativeModuleParamShape): string {
-  switch (param.typeAnnotation.type) {
-    case 'NullableTypeAnnotation':
-      // TODO: should be
-      // return `std::optional<${translateParam(
-      //   param.typeAnnotation.typeAnnotation,
-      //   'template',
-      // )}>`;
-      return translateParam(param.typeAnnotation.typeAnnotation, 'method-arg');
-    default:
-      return translateParam(param.typeAnnotation, 'method-arg');
-  }
+function translateSpecFunctionParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'spec',
+    'spec',
+    options,
+  );
+}
+
+function translateCallbackParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'template',
+    'callback-arg',
+    options,
+  );
+}
+
+function translateFunctionParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'template',
+    'method-arg',
+    options,
+  );
 }
 
 export function translateSpecArgs(
   params: ReadonlyArray<NativeModuleParamShape>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
 ) {
   return params.map(param => {
-    const translatedParam = translateSpecFunctionParam(param);
+    const translatedParam = translateSpecFunctionParam(
+      param,
+      aliases,
+      `${baseAliasName}_${param.name}`,
+      options,
+    );
     return `${translatedParam}`;
   });
 }
 
-export function translateArgs(params: ReadonlyArray<NativeModuleParamShape>) {
+export function translateEventEmitterArgs(
+  params: NativeModuleEventEmitterTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+) {
+  const translatedParam = translateEventEmitterParam(
+    params,
+    aliases,
+    baseAliasName,
+    'spec',
+    options,
+  );
+  return `${translatedParam}`;
+}
+
+export function translateArgs(
+  params: ReadonlyArray<NativeModuleParamShape>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+) {
   return params.map(param => {
-    const translatedParam = translateFunctionParam(param);
+    const translatedParam = translateFunctionParam(
+      param,
+      aliases,
+      `${baseAliasName}_${param.name}`,
+      options,
+    );
     return `${translatedParam} ${param.name}`;
   });
 }