@react-native-windows/codegen 0.0.0-canary.7 → 0.0.0-canary.71

package/src/generators/AliasGen.ts

@@ -0,0 +1,149 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleObjectTypeAnnotation,
+  NamedShape,
+  Nullable,
+} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap, getAliasCppName} from './AliasManaging';
+import {CppCodegenOptions, translateField} from './ObjectTypes';
+
+function translateObjectMembersDefinition(
+  type: NativeModuleObjectTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  prefix: string,
+  options: CppCodegenOptions,
+) {
+  return type.properties
+    .map((prop: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>) => {
+      let propType = prop.typeAnnotation;
+      if (prop.optional && propType.type !== 'NullableTypeAnnotation') {
+        propType = {type: 'NullableTypeAnnotation', typeAnnotation: propType};
+      }
+      return `${prefix}${translateField(
+        propType,
+        aliases,
+        `${baseAliasName}_${prop.name}`,
+        options,
+      )} ${prop.name};`;
+    })
+    .join('\n');
+}
+
+function translateObjectMembersReflection(
+  type: NativeModuleObjectTypeAnnotation,
+  aliasCppName: string,
+  prefix: string,
+) {
+  return type.properties
+    .map((prop: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>) => {
+      return `${prefix}{L"${prop.name}", &${aliasCppName}::${prop.name}},`;
+    })
+    .join('\n');
+}
+
+export function createAliasMap(nativeModuleAliases: {
+  [name: string]: NativeModuleObjectTypeAnnotation;
+}): AliasMap {
+  const aliases: AliasMap = {types: {}, jobs: Object.keys(nativeModuleAliases)};
+  for (const aliasName of aliases.jobs) {
+    aliases.types[aliasName] = nativeModuleAliases[aliasName];
+  }
+  return aliases;
+}
+
+interface AliasCode {
+  definition: string;
+  reflection: string;
+}
+
+interface AliasCodeMap {
+  [name: string]: AliasCode;
+}
+
+function generateSingleAlias(
+  aliases: AliasMap,
+  aliasName: string,
+  aliasCode: AliasCodeMap,
+  options: CppCodegenOptions,
+): void {
+  const aliasCppName = getAliasCppName(aliasName);
+  const aliasType = <NativeModuleObjectTypeAnnotation>aliases.types[aliasName];
+  const definition = `
+struct ${aliasCppName} {
+${translateObjectMembersDefinition(
+  aliasType,
+  aliases,
+  aliasName,
+  '    ',
+  options,
+)}
+};
+`;
+  const reflection = `
+inline winrt::Microsoft::ReactNative::FieldMap GetStructInfo(${aliasCppName}*) noexcept {
+    winrt::Microsoft::ReactNative::FieldMap fieldMap {
+${translateObjectMembersReflection(aliasType, aliasCppName, '        ')}
+    };
+    return fieldMap;
+}
+`;
+  aliasCode[aliasName] = {definition, reflection};
+}
+
+function generateNestedAliasesInCorrectOrder(
+  aliases: AliasMap,
+  aliasCode: AliasCodeMap,
+  aliasOrder: string[],
+  options: CppCodegenOptions,
+): void {
+  // retrieve and clean all ungenerated aliases
+  const jobs = aliases.jobs;
+  aliases.jobs = [];
+
+  // generate each one in its found order
+  for (const aliasName of jobs) {
+    // generate a new struct and all fields will be examined
+    // new anonymous objects could be found
+    // they will be stored in aliases.jobs
+    generateSingleAlias(aliases, aliasName, aliasCode, options);
+    // nested C++ structs must be put before the current C++ struct
+    // as they will be used in the current C++ struct
+    // the order will be perfectly and easily ensured by doing this recursively
+    generateNestedAliasesInCorrectOrder(
+      aliases,
+      aliasCode,
+      aliasOrder,
+      options,
+    );
+    // all referenced C++ structs are generated
+    // put the current one following them
+    aliasOrder.push(aliasName);
+  }
+}
+
+export function generateAliases(
+  aliases: AliasMap,
+  options: CppCodegenOptions,
+): [string, string] {
+  const aliasCode: AliasCodeMap = {};
+  const aliasOrder: string[] = [];
+  generateNestedAliasesInCorrectOrder(aliases, aliasCode, aliasOrder, options);
+
+  // aliasOrder now has the correct order of C++ struct code
+  let customTypes = '';
+  let customReflection = '';
+  for (const aliasName of aliasOrder) {
+    customTypes = `${customTypes}${aliasCode[aliasName].definition}`;
+    customReflection = `${customReflection}${aliasCode[aliasName].reflection}`;
+  }
+  return [customTypes, customReflection];
+}

package/src/generators/AliasManaging.ts

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {NativeModuleObjectTypeAnnotation} from '@react-native/codegen/lib/CodegenSchema';
+
+let preferredModuleName: string = '';
+
+export function setPreferredModuleName(moduleName: string): void {
+  preferredModuleName = moduleName;
+}
+
+export function getAliasCppName(typeName: string): string {
+  return `${preferredModuleName}Spec_${typeName}`;
+}
+
+export interface AliasMap {
+  types: {[name: string]: NativeModuleObjectTypeAnnotation | undefined};
+  jobs: string[];
+}
+
+const ExtendedObjectKey = '$RNW-TURBOMODULE-ALIAS';
+interface ExtendedObject extends NativeModuleObjectTypeAnnotation {
+  '$RNW-TURBOMODULE-ALIAS'?: string;
+}
+
+function recordAnonymousAlias(
+  aliases: AliasMap,
+  baseAliasName: string,
+  extended: ExtendedObject,
+): string {
+  extended[ExtendedObjectKey] = baseAliasName;
+  aliases.types[baseAliasName] = extended;
+  aliases.jobs.push(baseAliasName);
+  return baseAliasName;
+}
+
+export function getAnonymousAliasCppName(
+  aliases: AliasMap,
+  baseAliasName: string,
+  objectType: NativeModuleObjectTypeAnnotation,
+): string {
+  // someone found an anonymous object literal type
+  // if the ExtendedObjectKey flag has been set
+  // then it is a known one
+  // this happens because method signatures are generate twice in spec and error messages
+  const extended = <ExtendedObject>objectType;
+  const key = extended[ExtendedObjectKey];
+  if (key !== undefined) {
+    return getAliasCppName(key);
+  }
+
+  // if the ExtendedObjectKey flag has not been set
+  // it means it is a unknown one
+  // associate the name with this object literal type and return
+  if (aliases.types[baseAliasName] === undefined) {
+    return getAliasCppName(
+      recordAnonymousAlias(aliases, baseAliasName, extended),
+    );
+  }
+
+  // sometimes names could be anonymous
+  let index = 2;
+  while (aliases.types[`${baseAliasName}${index}`] !== undefined) {
+    index++;
+  }
+
+  return getAliasCppName(
+    recordAnonymousAlias(aliases, `${baseAliasName}${index}`, extended),
+  );
+}

package/src/generators/GenerateNM2.ts

@@ -6,306 +6,89 @@
 
 'use strict';
 
-import {
-  SchemaType,
-  MethodTypeShape,
-  // FunctionTypeAnnotation,
-  FunctionTypeAnnotationParam,
-  FunctionTypeAnnotationParamTypeAnnotation,
-  FunctionTypeAnnotationReturn,
-} from 'react-native-tscodegen';
+import type {SchemaType} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap, setPreferredModuleName} from './AliasManaging';
+import {createAliasMap, generateAliases} from './AliasGen';
+import {generateValidateConstants} from './ValidateConstants';
+import {generateValidateMethods} from './ValidateMethods';
+import type {CppStringTypes} from './ObjectTypes';
+
+export type {CppStringTypes} from './ObjectTypes';
 
 type FilesOutput = Map<string, string>;
 
-const moduleTemplate = `
-/*
+const headerTemplate = `/*
  * This file is auto-generated from a NativeModule spec file in js.
  *
  * This is a C++ Spec class that should be used with MakeTurboModuleProvider to register native modules
  * in a way that also verifies at compile time that the native module matches the interface required
  * by the TurboModule JS spec.
  */
-#pragma once
-
-#include "NativeModules.h"
-#include <tuple>
-
-namespace ::_NAMESPACE_:: {
+#pragma once`;
 
+const specTemplate = `::_MODULE_CUSTPM_TYPES_REFLECTION_::
 struct ::_MODULE_NAME_::Spec : winrt::Microsoft::ReactNative::TurboModuleSpec {
-  static constexpr auto methods = std::tuple{
-::_MODULE_PROPERTIES_TUPLE_::
-  };
+::_MODULE_MEMBERS_TUPLES_::
 
   template <class TModule>
   static constexpr void ValidateModule() noexcept {
-    constexpr auto methodCheckResults = CheckMethods<TModule, ::_MODULE_NAME_::Spec>();
-
-::_MODULE_PROPERTIES_SPEC_ERRORS_::
-  }
-};
-
-} // namespace ::_NAMESPACE_::
-`;
-
-function translateSpecFunctionParam(
-  param: FunctionTypeAnnotationParam,
-): string {
-  switch (param.typeAnnotation.type) {
-    case 'StringTypeAnnotation':
-      return 'std::string';
-    case 'NumberTypeAnnotation':
-    case 'FloatTypeAnnotation':
-      return 'double';
-    case 'Int32TypeAnnotation':
-      return 'int';
-    case 'BooleanTypeAnnotation':
-      return 'bool';
-    case 'FunctionTypeAnnotation': {
-      // Ideally we'd get more information about the expected parameters of the callback
-      // But the current schema doesn't seem to provide the necessary information.
-      return 'Callback<React::JSValue>';
-    }
-    case 'ArrayTypeAnnotation':
-      // Ideally we'd get more information about the expected type of the array
-      // But the current schema doesn't seem to provide the necessary information.
-      return 'React::JSValueArray';
-    case 'GenericObjectTypeAnnotation':
-      return 'React::JSValueObject';
-    case 'ObjectTypeAnnotation':
-      // TODO we have more information here, and could create a more specific type
-      return 'React::JSValueObject';
-    case 'ReservedFunctionValueTypeAnnotation':
-      // (#6597)
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (param.typeAnnotation.name !== 'RootTag')
-        throw new Error(
-          `Unknown reserved function: ${param.typeAnnotation.name} in translateSpecFunctionParam`,
-        );
-      return 'double';
-    default:
-      throw new Error(
-        `Unhandled type in translateSpecFunctionParam: ${param.typeAnnotation.type}`,
-      );
-  }
-}
-
-function translateFunctionParam(param: FunctionTypeAnnotationParam): string {
-  switch (param.typeAnnotation.type) {
-    case 'StringTypeAnnotation':
-      return 'std::string';
-    case 'NumberTypeAnnotation':
-    case 'FloatTypeAnnotation':
-      return 'double';
-    case 'Int32TypeAnnotation':
-      return 'int';
-    case 'BooleanTypeAnnotation':
-      return 'bool';
-    case 'FunctionTypeAnnotation': {
-      // Ideally we'd get more information about the expected parameters of the callback
-      // But the current schema doesn't seem to provide the necessary information.
-      return 'std::function<void(React::JSValue const &)> const &';
-    }
-    case 'ArrayTypeAnnotation':
-      // Ideally we'd get more information about the expected type of the array
-      // But the current schema doesn't seem to provide the necessary information.
-      return 'React::JSValueArray &&';
-    case 'GenericObjectTypeAnnotation':
-      return 'React::JSValueObject &&';
-    case 'ObjectTypeAnnotation':
-      // TODO we have more information here, and could create a more specific type
-      return 'React::JSValueObject &&';
-    case 'ReservedFunctionValueTypeAnnotation':
-      // (#6597)
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (param.typeAnnotation.name !== 'RootTag')
-        throw new Error(
-          `Unknown reserved function: ${param.typeAnnotation.name} in translateFunctionParam`,
-        );
-      return 'double';
-    default:
-      throw new Error(
-        `Unhandled type in translateFunctionParam: ${param.typeAnnotation.type} in translateFunctionParam`,
-      );
-  }
-}
-
-function translateSpecReturnType(
-  type:
-    | FunctionTypeAnnotationParamTypeAnnotation
-    | FunctionTypeAnnotationReturn,
-) {
-  switch (type.type) {
-    case 'VoidTypeAnnotation':
-      return 'void';
-    case 'StringTypeAnnotation':
-      return 'std::string';
-    case 'NumberTypeAnnotation':
-    case 'FloatTypeAnnotation':
-      return 'double';
-    case 'Int32TypeAnnotation':
-      return 'int';
-    case 'BooleanTypeAnnotation':
-      return 'bool';
-    case 'GenericPromiseTypeAnnotation':
-      return 'void';
-    case 'ArrayTypeAnnotation':
-      // Ideally we'd get more information about the expected type of the array
-      // But the current schema doesn't seem to provide the necessary information.
-      return 'React::JSValueArray';
-    case 'GenericObjectTypeAnnotation':
-      return 'React::JSValueObject';
-    case 'ReservedFunctionValueTypeAnnotation':
-      // (#6597)
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (type.name !== 'RootTag')
-        throw new Error(
-          `Unknown reserved function: ${type.name} in translateSpecReturnType`,
-        );
-      return 'double';
-    default:
-      throw new Error(
-        `Unhandled type in translateSpecReturnType: ${type.type}`,
-      );
-  }
-}
-
-function translateImplReturnType(
-  type:
-    | FunctionTypeAnnotationParamTypeAnnotation
-    | FunctionTypeAnnotationReturn,
-) {
-  switch (type.type) {
-    case 'VoidTypeAnnotation':
-      return 'void';
-    case 'StringTypeAnnotation':
-      return 'std::string';
-    case 'NumberTypeAnnotation':
-    case 'FloatTypeAnnotation':
-      return 'double';
-    case 'Int32TypeAnnotation':
-      return 'int';
-    case 'BooleanTypeAnnotation':
-      return 'bool';
-    case 'GenericPromiseTypeAnnotation':
-      return 'void';
-    case 'ArrayTypeAnnotation':
-      // Ideally we'd get more information about the expected type of the array
-      // But the current schema doesn't seem to provide the necessary information.
-      return 'React::JSValueArray';
-    case 'GenericObjectTypeAnnotation':
-      return 'React::JSValueObject';
-    case 'ReservedFunctionValueTypeAnnotation':
-      // (#6597)
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (type.name !== 'RootTag')
-        throw new Error(
-          `Unknown reserved function: ${type.name} in translateSpecReturnType`,
-        );
-      return 'double';
-    default:
-      throw new Error(
-        `Unhandled type in translateImplReturnType: ${type.type}`,
-      );
-  }
-}
-
-function translateSpecArgs(params: ReadonlyArray<FunctionTypeAnnotationParam>) {
-  return params.map(param => {
-    const translatedParam = translateSpecFunctionParam(param);
-    return `${translatedParam}`;
-  });
-}
-
-function translateArgs(params: ReadonlyArray<FunctionTypeAnnotationParam>) {
-  return params.map(param => {
-    const translatedParam = translateFunctionParam(param);
-    return `${translatedParam} ${param.name}`;
-  });
-}
+::_MODULE_MEMBERS_CHECKS_::
 
-function isMethodSync(prop: MethodTypeShape) {
-  return (
-    prop.typeAnnotation.returnTypeAnnotation.type !== 'VoidTypeAnnotation' &&
-    prop.typeAnnotation.returnTypeAnnotation.type !==
-      'GenericPromiseTypeAnnotation'
-  );
-}
+::_MODULE_MEMBERS_ERRORS_::
+  }`;
 
-function isPromise(prop: MethodTypeShape) {
-  return (
-    prop.typeAnnotation.returnTypeAnnotation.type ===
-    'GenericPromiseTypeAnnotation'
-  );
-}
+const typeOnlyTemplate = `
+${headerTemplate}
 
-function getPossibleMethodSignatures(prop: MethodTypeShape): string[] {
-  const args = translateArgs(prop.typeAnnotation.params);
-  if (isPromise(prop)) {
-    // Sadly, currently, the schema doesn't currently provide us information on the type of the promise.
-    args.push('React::ReactPromise<React::JSValue> &&result');
-  }
+#include <string>
+#include <optional>
+#include <functional>
+#include <vector>
 
-  // TODO be much more exhastive on the possible method signatures that can be used..
-  const sig = `REACT_${isMethodSync(prop) ? 'SYNC_' : ''}METHOD(${
-    prop.name
-  }) ${translateImplReturnType(prop.typeAnnotation.returnTypeAnnotation)} ${
-    prop.name
-  }(${args.join(', ')}) noexcept { /* implementation */ }}`;
+namespace ::_NAMESPACE_:: {
+::_MODULE_CUSTPM_TYPES_::
+} // namespace ::_NAMESPACE_::
+`;
 
-  const staticsig = `REACT_${isMethodSync(prop) ? 'SYNC_' : ''}METHOD(${
-    prop.name
-  }) static ${translateImplReturnType(
-    prop.typeAnnotation.returnTypeAnnotation,
-  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }}`;
+const moduleOnlyTemplate = `
+${headerTemplate}
 
-  return [sig, staticsig];
-}
+::_TYPE_DEFINITION_INCLUDE_::
+#include <NativeModules.h>
+#include <tuple>
 
-function translatePossibleMethodSignatures(prop: MethodTypeShape): string {
-  return getPossibleMethodSignatures(prop)
-    .map(sig => `"    ${sig}\\n"`)
-    .join('\n          ');
-}
+namespace ::_NAMESPACE_:: {
+${specTemplate}
+};
 
-function renderProperties(
-  properties: ReadonlyArray<MethodTypeShape>,
-  tuple: boolean,
-): string {
-  // We skip the constants for now, since we dont have Spec file validation of them.
-  return properties
-    .filter(prop => prop.name !== 'getConstants')
-    .map((prop, index) => {
-      const params = prop.typeAnnotation.params;
+} // namespace ::_NAMESPACE_::
+`;
 
-      const traversedArgs = translateSpecArgs(params);
+const allInOneTemplate = `
+${headerTemplate}
 
-      const translatedReturnParam = translateSpecReturnType(
-        prop.typeAnnotation.returnTypeAnnotation,
-      );
+#include <NativeModules.h>
+#include <tuple>
 
-      if (isPromise(prop)) {
-        // Sadly, currently, the schema doesn't currently provide us information on the type of the promise.
-        traversedArgs.push('Promise<React::JSValue>');
-      }
+namespace ::_NAMESPACE_:: {
+::_MODULE_CUSTPM_TYPES_::
+${specTemplate}
+};
 
-      if (tuple) {
-        return `      ${
-          isMethodSync(prop) ? 'Sync' : ''
-        }Method<${translatedReturnParam}(${traversedArgs.join(
-          ', ',
-        )}) noexcept>{${index}, L"${prop.name}"},`;
-      } else {
-        return `    REACT_SHOW_METHOD_SPEC_ERRORS(
-          ${index},
-          "${prop.name}",
-          ${translatePossibleMethodSignatures(prop)});`;
-      }
-    })
-    .join('\n');
-}
+} // namespace ::_NAMESPACE_::
+`;
 
-export function createNM2Generator({namespace}: {namespace: string}) {
+export function createNM2Generator({
+  methodOnly,
+  namespace,
+  cppStringType,
+  separateDataTypes,
+}: {
+  methodOnly: boolean;
+  namespace: string;
+  cppStringType: CppStringTypes;
+  separateDataTypes: boolean;
+}) {
   return (
     _libraryName: string,
     schema: SchemaType,
@@ -313,30 +96,90 @@ export function createNM2Generator({namespace}: {namespace: string}) {
   ): FilesOutput => {
     const files = new Map<string, string>();
 
-    const nativeModules = Object.keys(schema.modules)
-      .map(moduleName => schema.modules[moduleName].nativeModules)
-      .filter(Boolean)
-      .reduce((acc, components) => Object.assign(acc, components), {});
-
-    if (nativeModules) {
-      Object.keys(nativeModules).forEach(name => {
-        console.log(`Generating Native${name}Spec.g.h`);
-        const {properties} = nativeModules[name];
-        const traversedProperties = renderProperties(properties, false);
-        const traversedPropertyTuples = renderProperties(properties, true);
-
-        files.set(
-          `Native${name}Spec.g.h`,
-          moduleTemplate
-            .replace(/::_MODULE_PROPERTIES_TUPLE_::/g, traversedPropertyTuples)
+    for (const moduleName of Object.keys(schema.modules)) {
+      const nativeModule = schema.modules[moduleName];
+      // from 0.65 facebook's react-native-codegen
+      // the module name has the Native prefix comparing to 0.63
+      // when reading files we provided
+      const preferredModuleName = moduleName.startsWith('Native')
+        ? moduleName.substr(6)
+        : moduleName;
+      setPreferredModuleName(preferredModuleName);
+
+      if (nativeModule.type === 'NativeModule') {
+        console.log(`Generating Native${preferredModuleName}Spec.g.h`);
+
+        // copy all explicit to a map
+        const aliases: AliasMap = createAliasMap(nativeModule.aliasMap);
+
+        // prepare methods
+        const methods = generateValidateMethods(nativeModule, aliases, {
+          cppStringType,
+        });
+        let tuples = `
+  static constexpr auto methods = std::tuple{
+${methods[0]}
+  };`;
+        let checks = `
+    constexpr auto methodCheckResults = CheckMethods<TModule, ::_MODULE_NAME_::Spec>();`;
+        let errors = methods[1];
+
+        // prepare constants
+        const constants = generateValidateConstants(nativeModule, aliases);
+        if (constants !== undefined && !methodOnly) {
+          tuples = `
+  static constexpr auto constants = std::tuple{
+${constants[0]}
+  };${tuples}`;
+          checks = `
+    constexpr auto constantCheckResults = CheckConstants<TModule, ::_MODULE_NAME_::Spec>();${checks}`;
+          errors = `${constants[1]}
+
+${errors}`;
+        }
+
+        // generate code for structs
+        const [customTypes, customReflection] = generateAliases(aliases, {
+          cppStringType,
+        });
+
+        const customTypesExist = customTypes !== '';
+
+        const replaceContent = function (template: string): string {
+          return template
+            .replace(/::_MODULE_CUSTPM_TYPES_::/g, customTypes)
+            .replace(/::_MODULE_CUSTPM_TYPES_REFLECTION_::/g, customReflection)
+            .replace(/::_MODULE_MEMBERS_TUPLES_::/g, tuples.substring(1))
+            .replace(/::_MODULE_MEMBERS_CHECKS_::/g, checks.substring(1))
+            .replace(/::_MODULE_MEMBERS_ERRORS_::/g, errors)
+            .replace(/::_MODULE_NAME_::/g, preferredModuleName)
             .replace(
-              /::_MODULE_PROPERTIES_SPEC_ERRORS_::/g,
-              traversedProperties,
+              /::_TYPE_DEFINITION_INCLUDE_::/g,
+              customTypesExist
+                ? `// #include "Native${preferredModuleName}DataTypes.g.h" before this file to use the generated type definition`
+                : '',
             )
-            .replace(/::_MODULE_NAME_::/g, name)
-            .replace(/::_NAMESPACE_::/g, namespace),
-        );
-      });
+            .replace(/::_NAMESPACE_::/g, namespace);
+        };
+
+        if (separateDataTypes) {
+          if (customTypesExist) {
+            files.set(
+              `Native${preferredModuleName}DataTypes.g.h`,
+              replaceContent(typeOnlyTemplate),
+            );
+          }
+          files.set(
+            `Native${preferredModuleName}Spec.g.h`,
+            replaceContent(moduleOnlyTemplate),
+          );
+        } else {
+          files.set(
+            `Native${preferredModuleName}Spec.g.h`,
+            replaceContent(allInOneTemplate),
+          );
+        }
+      }
     }
 
     return files;