@react-native-windows/codegen 0.65.0 → 0.67.0-preview.1

package/src/generators/GenerateNM2.ts

@@ -6,14 +6,11 @@
 
 'use strict';
 
-import {
-  SchemaType,
-  MethodTypeShape,
-  // FunctionTypeAnnotation,
-  FunctionTypeAnnotationParam,
-  FunctionTypeAnnotationParamTypeAnnotation,
-  FunctionTypeAnnotationReturn,
-} from 'react-native-tscodegen';
+import {SchemaType} from 'react-native-tscodegen';
+import {AliasMap, setPreferredModuleName} from './AliasManaging';
+import {createAliasMap, generateAliases} from './AliasGen';
+import {generateValidateConstants} from './ValidateConstants';
+import {generateValidateMethods} from './ValidateMethods';
 
 type FilesOutput = Map<string, string>;
 
@@ -31,280 +28,21 @@ const moduleTemplate = `
 #include <tuple>
 
 namespace ::_NAMESPACE_:: {
-
+::_MODULE_ALIASED_STRUCTS_::
 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_MEMBERS_CHECKS_::
 
-::_MODULE_PROPERTIES_SPEC_ERRORS_::
+::_MODULE_MEMBERS_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}`;
-  });
-}
-
-function isMethodSync(prop: MethodTypeShape) {
-  return (
-    prop.typeAnnotation.returnTypeAnnotation.type !== 'VoidTypeAnnotation' &&
-    prop.typeAnnotation.returnTypeAnnotation.type !==
-      'GenericPromiseTypeAnnotation'
-  );
-}
-
-function isPromise(prop: MethodTypeShape) {
-  return (
-    prop.typeAnnotation.returnTypeAnnotation.type ===
-    'GenericPromiseTypeAnnotation'
-  );
-}
-
-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');
-  }
-
-  // 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 */ }}`;
-
-  const staticsig = `REACT_${isMethodSync(prop) ? 'SYNC_' : ''}METHOD(${
-    prop.name
-  }) static ${translateImplReturnType(
-    prop.typeAnnotation.returnTypeAnnotation,
-  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }}`;
-
-  return [sig, staticsig];
-}
-
-function translatePossibleMethodSignatures(prop: MethodTypeShape): string {
-  return getPossibleMethodSignatures(prop)
-    .map(sig => `"    ${sig}\\n"`)
-    .join('\n          ');
-}
-
-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;
-
-      const traversedArgs = translateSpecArgs(params);
-
-      const translatedReturnParam = translateSpecReturnType(
-        prop.typeAnnotation.returnTypeAnnotation,
-      );
-
-      if (isPromise(prop)) {
-        // Sadly, currently, the schema doesn't currently provide us information on the type of the promise.
-        traversedArgs.push('Promise<React::JSValue>');
-      }
-
-      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');
-}
-
 export function createNM2Generator({namespace}: {namespace: string}) {
   return (
     _libraryName: string,
@@ -313,30 +51,60 @@ 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);
+    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.aliases);
+
+        // prepare methods
+        const methods = generateValidateMethods(nativeModule, aliases);
+        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) {
+          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 traversedAliasedStructs = generateAliases(aliases);
 
         files.set(
-          `Native${name}Spec.g.h`,
+          `Native${preferredModuleName}Spec.g.h`,
           moduleTemplate
-            .replace(/::_MODULE_PROPERTIES_TUPLE_::/g, traversedPropertyTuples)
-            .replace(
-              /::_MODULE_PROPERTIES_SPEC_ERRORS_::/g,
-              traversedProperties,
-            )
-            .replace(/::_MODULE_NAME_::/g, name)
+            .replace(/::_MODULE_ALIASED_STRUCTS_::/g, traversedAliasedStructs)
+            .replace(/::_MODULE_MEMBERS_TUPLES_::/g, tuples.substr(1))
+            .replace(/::_MODULE_MEMBERS_CHECKS_::/g, checks.substr(1))
+            .replace(/::_MODULE_MEMBERS_ERRORS_::/g, errors)
+            .replace(/::_MODULE_NAME_::/g, preferredModuleName)
             .replace(/::_NAMESPACE_::/g, namespace),
         );
-      });
+      }
     }
 
     return files;

package/src/generators/ObjectTypes.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import {NativeModuleBaseTypeAnnotation, Nullable} from 'react-native-tscodegen';
+import {
+  AliasMap,
+  getAliasCppName,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
+
+export function translateField(
+  type: Nullable<NativeModuleBaseTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+): string {
+  // avoid: Property 'type' does not exist on type 'never'
+  const returnType = type.type;
+  switch (type.type) {
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'ArrayTypeAnnotation':
+      if (type.elementType) {
+        return `std::vector<${translateField(
+          type.elementType,
+          aliases,
+          `${baseAliasName}_element`,
+        )}>`;
+      } else {
+        return `React::JSValueArray`;
+      }
+    case 'GenericObjectTypeAnnotation':
+      return 'React::JSValue';
+    case 'ObjectTypeAnnotation':
+      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`,
+        );
+      return 'double';
+    }
+    case 'TypeAliasTypeAnnotation':
+      return getAliasCppName(type.name);
+    case 'NullableTypeAnnotation':
+      return `std::optional<${translateField(
+        type.typeAnnotation,
+        aliases,
+        baseAliasName,
+      )}>`;
+    default:
+      throw new Error(`Unhandled type in translateReturnType: ${returnType}`);
+  }
+}

package/src/generators/ParamTypes.ts

@@ -0,0 +1,220 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import {
+  NamedShape,
+  NativeModuleParamTypeAnnotation,
+  Nullable,
+} from 'react-native-tscodegen';
+import {
+  AliasMap,
+  getAliasCppName,
+  getAnonymousAliasCppName,
+} from './AliasManaging';
+
+type NativeModuleParamShape = NamedShape<
+  Nullable<NativeModuleParamTypeAnnotation>
+>;
+
+type ParamTarget = 'spec' | 'template' | 'callback-arg' | 'method-arg';
+
+function decorateType(type: string, target: ParamTarget): string {
+  switch (target) {
+    case 'method-arg':
+      return `${type} &&`;
+    case 'callback-arg':
+      return `${type} const &`;
+    default:
+      return type;
+  }
+}
+
+function translateParam(
+  param: NativeModuleParamTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  target: ParamTarget,
+): string {
+  // avoid: Property 'type' does not exist on type 'never'
+  const paramType = param.type;
+  switch (param.type) {
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+    case 'DoubleTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'FunctionTypeAnnotation': {
+      // TODO: type.returnTypeAnnotation
+      switch (target) {
+        case 'spec':
+          return `Callback<${param.params
+            .map((p: NativeModuleParamShape) =>
+              translateSpecFunctionParam(
+                p,
+                aliases,
+                `${baseAliasName}_${p.name}`,
+              ),
+            )
+            .join(', ')}>`;
+        case 'template':
+          return `std::function<void(${param.params
+            .map((p: NativeModuleParamShape) =>
+              translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`),
+            )
+            .join(', ')})>`;
+        default:
+          return `std::function<void(${param.params
+            .map((p: NativeModuleParamShape) =>
+              translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`),
+            )
+            .join(', ')})> const &`;
+      }
+    }
+    case 'ArrayTypeAnnotation':
+      if (param.elementType) {
+        switch (target) {
+          case 'spec':
+          case 'template':
+            return `std::vector<${translateNullableParamType(
+              param.elementType,
+              aliases,
+              `${baseAliasName}_element`,
+              'template',
+              'template',
+            )}>`;
+          default:
+            return `std::vector<${translateNullableParamType(
+              param.elementType,
+              aliases,
+              `${baseAliasName}_element`,
+              'template',
+              'template',
+            )}> const &`;
+        }
+      } else {
+        return decorateType('React::JSValueArray', target);
+      }
+    case 'GenericObjectTypeAnnotation':
+      return decorateType('React::JSValue', target);
+    case 'ObjectTypeAnnotation':
+      return decorateType(
+        getAnonymousAliasCppName(aliases, baseAliasName, param),
+        target,
+      );
+    case 'ReservedTypeAnnotation': {
+      // avoid: Property 'name' does not exist on type 'never'
+      const name = param.name;
+      // (#6597)
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (name !== 'RootTag')
+        throw new Error(`Unknown reserved function: ${name} in translateParam`);
+      return 'double';
+    }
+    case 'TypeAliasTypeAnnotation':
+      return decorateType(getAliasCppName(param.name), target);
+    default:
+      throw new Error(`Unhandled type in translateParam: ${paramType}`);
+  }
+}
+
+function translateNullableParamType(
+  paramType: Nullable<NativeModuleParamTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  nullableTarget: ParamTarget,
+  target: ParamTarget,
+): string {
+  switch (paramType.type) {
+    case 'NullableTypeAnnotation':
+      return `std::optional<${translateParam(
+        paramType.typeAnnotation,
+        aliases,
+        baseAliasName,
+        nullableTarget,
+      )}>`;
+    default:
+      return translateParam(paramType, aliases, baseAliasName, target);
+  }
+}
+
+function translateSpecFunctionParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'spec',
+    'spec',
+  );
+}
+
+function translateCallbackParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'template',
+    'callback-arg',
+  );
+}
+
+function translateFunctionParam(
+  param: NativeModuleParamShape,
+  aliases: AliasMap,
+  baseAliasName: string,
+): string {
+  return translateNullableParamType(
+    param.typeAnnotation,
+    aliases,
+    baseAliasName,
+    'template',
+    'method-arg',
+  );
+}
+
+export function translateSpecArgs(
+  params: ReadonlyArray<NativeModuleParamShape>,
+  aliases: AliasMap,
+  baseAliasName: string,
+) {
+  return params.map(param => {
+    const translatedParam = translateSpecFunctionParam(
+      param,
+      aliases,
+      `${baseAliasName}_${param.name}`,
+    );
+    return `${translatedParam}`;
+  });
+}
+
+export function translateArgs(
+  params: ReadonlyArray<NativeModuleParamShape>,
+  aliases: AliasMap,
+  baseAliasName: string,
+) {
+  return params.map(param => {
+    const translatedParam = translateFunctionParam(
+      param,
+      aliases,
+      `${baseAliasName}_${param.name}`,
+    );
+    return `${translatedParam} ${param.name}`;
+  });
+}