nitrogen 0.2.24 → 0.29.5

package/src/syntax/kotlin/KotlinStruct.ts

@@ -0,0 +1,198 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { capitalizeName, indent } from '../../utils.js'
+import { includeHeader } from '../c++/includeNitroHeader.js'
+import { getReferencedTypes } from '../getReferencedTypes.js'
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js'
+import type { SourceFile } from '../SourceFile.js'
+import type { StructType } from '../types/StructType.js'
+import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
+
+export function createKotlinStruct(structType: StructType): SourceFile[] {
+  const packageName = NitroConfig.current.getAndroidPackage('java/kotlin')
+  const values = structType.properties.map((p) => {
+    const bridged = new KotlinCxxBridgedType(p)
+    return `
+@DoNotStrip
+@Keep
+val ${p.escapedName}: ${bridged.getTypeCode('kotlin', false)}
+`.trim()
+  })
+  let secondaryConstructor: string
+  const needsSpecialHandling = structType.properties.some(
+    (p) => new KotlinCxxBridgedType(p).needsSpecialHandling
+  )
+  if (needsSpecialHandling) {
+    // If we need special handling for any of our properties, we need to add a convenience initializer.
+    const params = structType.properties.map(
+      (p) => `${p.escapedName}: ${p.getCode('kotlin')}`
+    )
+    const paramsForward = structType.properties.map((p) => {
+      const bridged = new KotlinCxxBridgedType(p)
+      if (bridged.needsSpecialHandling) {
+        // We need special parsing for this type
+        return bridged.parseFromKotlinToCpp(p.escapedName, 'kotlin', false)
+      } else {
+        return p.escapedName
+      }
+    })
+    secondaryConstructor = `
+/**
+ * Initialize a new instance of \`${structType.structName}\` from Kotlin.
+ */
+constructor(${indent(params.join(', '), 12)})
+     : this(${indent(paramsForward.join(', '), 12)})
+    `.trim()
+  } else {
+    secondaryConstructor = `/* main constructor */`
+  }
+
+  const extraImports = structType.properties
+    .flatMap((t) => t.getRequiredImports('kotlin'))
+    .map((i) => `import ${i.name}`)
+
+  const code = `
+${createFileMetadataString(`${structType.structName}.kt`)}
+
+package ${packageName}
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.*
+${extraImports.join('\n')}
+
+/**
+ * Represents the JavaScript object/struct "${structType.structName}".
+ */
+@DoNotStrip
+@Keep
+data class ${structType.structName}
+  @DoNotStrip
+  @Keep
+  constructor(
+    ${indent(values.join(',\n'), '    ')}
+  ) {
+  ${indent(secondaryConstructor, '  ')}
+}
+  `.trim()
+
+  const cxxNamespace = NitroConfig.current.getCxxNamespace('c++')
+  const jniClassDescriptor = NitroConfig.current.getAndroidPackage(
+    'c++/jni',
+    structType.structName
+  )
+  const jniStructInitializerBody = createJNIStructInitializer(structType)
+  const cppStructInitializerBody = createCppStructInitializer(
+    'value',
+    structType
+  )
+  const imports = structType.properties
+    .flatMap((p) => getReferencedTypes(p))
+    .map((t) => new KotlinCxxBridgedType(t))
+    .flatMap((t) => t.getRequiredImports('c++'))
+  const includes = imports
+    .map((i) => includeHeader(i))
+    .filter(isNotDuplicate)
+    .sort()
+
+  const fbjniCode = `
+${createFileMetadataString(`J${structType.structName}.hpp`)}
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "${structType.declarationFile.name}"
+
+${includes.join('\n')}
+
+namespace ${cxxNamespace} {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "${structType.structName}" and the the Kotlin data class "${structType.structName}".
+   */
+  struct J${structType.structName} final: public jni::JavaClass<J${structType.structName}> {
+  public:
+    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ${structType.structName} by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ${structType.structName} toCpp() const {
+      ${indent(jniStructInitializerBody, '      ')}
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<J${structType.structName}::javaobject> fromCpp(const ${structType.structName}& value) {
+      ${indent(cppStructInitializerBody, '      ')}
+    }
+  };
+
+} // namespace ${cxxNamespace}
+  `.trim()
+
+  const files: SourceFile[] = []
+  files.push({
+    content: code,
+    language: 'kotlin',
+    name: `${structType.structName}.kt`,
+    subdirectory: NitroConfig.current.getAndroidPackageDirectory(),
+    platform: 'android',
+  })
+  files.push({
+    content: fbjniCode,
+    language: 'c++',
+    name: `J${structType.structName}.hpp`,
+    subdirectory: [],
+    platform: 'android',
+  })
+  return files
+}
+
+function createJNIStructInitializer(structType: StructType): string {
+  const lines: string[] = ['static const auto clazz = javaClassStatic();']
+  for (const prop of structType.properties) {
+    const fieldName = `field${capitalizeName(prop.escapedName)}`
+    const jniType = new KotlinCxxBridgedType(prop)
+    const signatureType = jniType.getTypeCode('c++')
+    const valueType = jniType.asJniReferenceType('local')
+    lines.push(
+      `static const auto ${fieldName} = clazz->getField<${signatureType}>("${prop.escapedName}");`
+    )
+    lines.push(
+      `${valueType} ${prop.escapedName} = this->getFieldValue(${fieldName});`
+    )
+  }
+
+  const propsForward = structType.properties.map((p) => {
+    const bridged = new KotlinCxxBridgedType(p)
+    return bridged.parse(p.escapedName, 'kotlin', 'c++', 'c++')
+  })
+  lines.push(`return ${structType.structName}(`)
+  lines.push(`  ${indent(propsForward.join(',\n'), '  ')}`)
+  lines.push(`);`)
+  return lines.join('\n')
+}
+
+function createCppStructInitializer(
+  cppValueName: string,
+  structType: StructType
+): string {
+  const lines: string[] = []
+  lines.push(`return newInstance(`)
+  const names = structType.properties.map((p) => {
+    const name = `${cppValueName}.${p.escapedName}`
+    const bridge = new KotlinCxxBridgedType(p)
+    return bridge.parse(name, 'c++', 'kotlin', 'c++')
+  })
+  lines.push(`  ${indent(names.join(',\n'), '  ')}`)
+  lines.push(');')
+  return lines.join('\n')
+}

package/src/syntax/kotlin/KotlinVariant.ts

@@ -0,0 +1,212 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { capitalizeName, indent } from '../../utils.js'
+import { includeHeader } from '../c++/includeNitroHeader.js'
+import {
+  createFileMetadataString,
+  isNotDuplicate,
+  toReferenceType,
+} from '../helpers.js'
+import type { SourceFile } from '../SourceFile.js'
+import { type VariantType } from '../types/VariantType.js'
+import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
+
+export function createKotlinVariant(variant: VariantType): SourceFile[] {
+  const jsName = variant.variants.map((v) => v.getCode('kotlin')).join('|')
+  const kotlinName = variant.getAliasName('kotlin')
+  const namespace = `J${kotlinName}_impl`
+
+  const innerClasses = variant.cases.map(([label, v]) => {
+    const innerName = capitalizeName(label)
+    return `
+@DoNotStrip
+data class ${innerName}(@DoNotStrip val value: ${v.getCode('kotlin')}): ${kotlinName}()
+      `.trim()
+  })
+
+  const packageName = NitroConfig.current.getAndroidPackage('java/kotlin')
+  const getterCases = variant.cases.map(([label]) => {
+    const innerName = capitalizeName(label)
+    return `is ${innerName} -> value as? T`
+  })
+  const isFunctions = variant.cases.map(([label]) => {
+    const innerName = capitalizeName(label)
+    return `
+val is${innerName}: Boolean
+  get() = this is ${innerName}
+    `.trim()
+  })
+
+  const createFunctions = variant.cases.map(([label, v]) => {
+    const innerName = capitalizeName(label)
+    return `
+@JvmStatic
+@DoNotStrip
+fun create(value: ${v.getCode('kotlin')}): ${kotlinName} = ${innerName}(value)
+    `.trim()
+  })
+
+  const extraImports = variant.variants
+    .flatMap((t) => t.getRequiredImports('kotlin'))
+    .map((i) => `import ${i.name}`)
+
+  const code = `
+${createFileMetadataString(`${kotlinName}.kt`)}
+
+package ${packageName}
+
+import com.facebook.proguard.annotations.DoNotStrip
+${extraImports.join('\n')}
+
+/**
+ * Represents the TypeScript variant "${jsName}".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class ${kotlinName} {
+  ${indent(innerClasses.join('\n'), '  ')}
+
+  inline fun <reified T> getAs(): T? = when (this) {
+    ${indent(getterCases.join('\n'), '    ')}
+  }
+
+  ${indent(isFunctions.join('\n'), '  ')}
+
+  companion object {
+    ${indent(createFunctions.join('\n'), '    ')}
+  }
+}
+  `.trim()
+
+  const cxxNamespace = NitroConfig.current.getCxxNamespace('c++')
+  const jniClassDescriptor = NitroConfig.current.getAndroidPackage(
+    'c++/jni',
+    kotlinName
+  )
+  const cppCreateFuncs = variant.variants.map((v, i) => {
+    const bridge = new KotlinCxxBridgedType(v)
+    return `
+static jni::local_ref<J${kotlinName}> create_${i}(${bridge.asJniReferenceType('alias')} value) {
+  static const auto method = javaClassStatic()->getStaticMethod<J${kotlinName}(${bridge.asJniReferenceType('alias')})>("create");
+  return method(javaClassStatic(), value);
+}
+    `.trim()
+  })
+  const variantCases = variant.variants.map((v, i) => {
+    const bridge = new KotlinCxxBridgedType(v)
+    return `case ${i}: return create_${i}(${bridge.parseFromCppToKotlin(`std::get<${i}>(variant)`, 'c++')});`
+  })
+  const cppGetIfs = variant.cases.map(([label, v]) => {
+    const innerName = capitalizeName(label)
+    const bridge = new KotlinCxxBridgedType(v)
+    return `
+if (isInstanceOf(${namespace}::${innerName}::javaClassStatic())) {
+  // It's a \`${v.getCode('c++')}\`
+  auto jniValue = static_cast<const ${namespace}::${innerName}*>(this)->getValue();
+  return ${bridge.parseFromKotlinToCpp('jniValue', 'c++')};
+}
+  `.trim()
+  })
+  const cppInnerClasses = variant.cases.map(([label, v]) => {
+    const bridge = new KotlinCxxBridgedType(v)
+    const innerName = capitalizeName(label)
+    const descriptor = NitroConfig.current.getAndroidPackage(
+      'c++/jni',
+      `${kotlinName}$${innerName}`
+    )
+    return `
+class ${innerName}: public jni::JavaClass<${innerName}, J${kotlinName}> {
+public:
+  static auto constexpr kJavaDescriptor = "L${descriptor};";
+
+  [[nodiscard]] ${bridge.asJniReferenceType('local')} getValue() const {
+    static const auto field = javaClassStatic()->getField<${bridge.getTypeCode('c++')}>("value");
+    return getFieldValue(field);
+  }
+};
+    `.trim()
+  })
+
+  const includes = new KotlinCxxBridgedType(variant)
+    .getRequiredImports('c++')
+    .filter((i) => i.name !== `J${kotlinName}.hpp`)
+    .map((i) => includeHeader(i, true))
+    .filter(isNotDuplicate)
+
+  const fbjniHeaderCode = `
+${createFileMetadataString(`J${kotlinName}.hpp`)}
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <variant>
+
+${includes.join('\n')}
+
+namespace ${cxxNamespace} {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "${kotlinName}".
+   */
+  class J${kotlinName}: public jni::JavaClass<J${kotlinName}> {
+  public:
+    static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
+
+    ${indent(cppCreateFuncs.join('\n'), '    ')}
+
+    static jni::local_ref<J${kotlinName}> fromCpp(${toReferenceType(variant.getCode('c++'))} variant) {
+      switch (variant.index()) {
+        ${indent(variantCases.join('\n'), '        ')}
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] ${variant.getCode('c++')} toCpp() const;
+  };
+
+  namespace ${namespace} {
+    ${indent(cppInnerClasses.join('\n\n'), '    ')}
+  } // namespace ${namespace}
+} // namespace ${cxxNamespace}
+  `.trim()
+  const fbjniImplementationCode = `
+${createFileMetadataString(`J${kotlinName}.cpp`)}
+
+#include "J${kotlinName}.hpp"
+
+namespace ${cxxNamespace} {
+  /**
+   * Converts J${kotlinName} to ${variant.getCode('c++')}
+   */
+  ${variant.getCode('c++')} J${kotlinName}::toCpp() const {
+    ${indent(cppGetIfs.join(' else '), '    ')}
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace ${cxxNamespace}
+  `.trim()
+
+  const files: SourceFile[] = []
+  files.push({
+    content: code,
+    language: 'kotlin',
+    name: `${kotlinName}.kt`,
+    subdirectory: NitroConfig.current.getAndroidPackageDirectory(),
+    platform: 'android',
+  })
+  files.push({
+    content: fbjniHeaderCode,
+    language: 'c++',
+    name: `J${kotlinName}.hpp`,
+    subdirectory: [],
+    platform: 'android',
+  })
+  files.push({
+    content: fbjniImplementationCode,
+    language: 'c++',
+    name: `J${kotlinName}.cpp`,
+    subdirectory: [],
+    platform: 'android',
+  })
+  return files
+}