nitrogen 0.31.1 → 0.31.3

package/lib/syntax/swift/SwiftCxxTypeHelper.js

@@ -17,7 +17,6 @@ import { VoidType } from '../types/VoidType.js';
 import { NamedWrappingType } from '../types/NamedWrappingType.js';
 import { ErrorType } from '../types/ErrorType.js';
 import { ResultWrappingType } from '../types/ResultWrappingType.js';
-import { isPrimitivelyCopyable } from './isPrimitivelyCopyable.js';
 export function createSwiftCxxHelpers(type) {
     switch (type.kind) {
         case 'hybrid-object':
@@ -227,27 +226,8 @@ function createCxxVectorSwiftHelper(type) {
     const actualType = type.getCode('c++');
     const bridgedType = new SwiftCxxBridgedType(type);
     const name = escapeCppName(actualType);
-    let code;
-    let funcName;
-    if (isPrimitivelyCopyable(type.itemType)) {
-        const itemType = type.itemType.getCode('c++');
-        funcName = `copy_${name}`;
-        code = `
-/**
- * Specialized version of \`${escapeComments(actualType)}\`.
- */
-using ${name} = ${actualType};
-inline ${actualType} copy_${name}(const ${itemType}* CONTIGUOUS_MEMORY NON_NULL data, size_t size) noexcept {
-  return margelo::nitro::FastVectorCopy<${itemType}>(data, size);
-}
-inline const ${itemType}* CONTIGUOUS_MEMORY NON_NULL get_data_${name}(const ${actualType}& vector) noexcept {
-  return vector.data();
-}
-`.trim();
-    }
-    else {
-        funcName = `create_${name}`;
-        code = `
+    const funcName = `create_${name}`;
+    const code = `
 /**
  * Specialized version of \`${escapeComments(actualType)}\`.
  */
@@ -257,7 +237,6 @@ inline ${actualType} create_${name}(size_t size) noexcept {
   vector.reserve(size);
   return vector;
 }`.trim();
-    }
     return {
         cxxType: actualType,
         funcName: funcName,
@@ -270,11 +249,6 @@ inline ${actualType} create_${name}(size_t size) noexcept {
                     space: 'system',
                     language: 'c++',
                 },
-                {
-                    name: 'NitroModules/FastVectorCopy.hpp',
-                    space: 'system',
-                    language: 'c++',
-                },
                 ...bridgedType.getRequiredImports('c++'),
             ],
         },

package/lib/syntax/swift/SwiftHybridObject.js

@@ -8,7 +8,7 @@ export function createSwiftHybridObject(spec) {
     const name = getHybridObjectName(spec.name);
     const protocolName = name.HybridTSpec;
     const properties = spec.properties.map((p) => p.getCode('swift')).join('\n');
-    const methods = spec.methods.map((p) => p.getCode('swift')).join('\n');
+    const methods = spec.methods.map((m) => m.getCode('swift')).join('\n');
     const extraImports = [
         ...spec.properties.flatMap((p) => p.getRequiredImports('swift')),
         ...spec.methods.flatMap((m) => m.getRequiredImports('swift')),
@@ -69,6 +69,13 @@ public protocol ${protocolName}_protocol: ${protocolBaseClasses.join(', ')} {
   ${indent(methods, '  ')}
 }
 
+public extension ${protocolName}_protocol {
+  /// Default implementation of \`\`HybridObject.toString\`\`
+  func toString() -> String {
+    return "[HybridObject ${name.T}]"
+  }
+}
+
 /// See \`\`${protocolName}\`\`
 open class ${protocolName}_base${classBaseClasses.length > 0 ? `: ${classBaseClasses.join(',')}` : ''} {
   ${indent(baseMembers.join('\n'), '  ')}

package/lib/syntax/swift/SwiftHybridObjectBridge.js

@@ -148,7 +148,7 @@ ${hasBase ? `open class ${name.HybridTSpecCxx} : ${baseClasses.join(', ')}` : `o
    */
   public func getCxxPart() -> bridge.${bridge.specializationName} {
     let cachedCxxPart = self.__cxxPart.lock()
-    if cachedCxxPart.__convertToBool() {
+    if Bool(fromCxx: cachedCxxPart) {
       return cachedCxxPart
     } else {
       let newCxxPart = bridge.${bridge.funcName}(self.toUnsafe())
@@ -177,6 +177,14 @@ ${hasBase ? `open class ${name.HybridTSpecCxx} : ${baseClasses.join(', ')}` : `o
     self.__implementation.dispose()
   }
 
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public ${hasBase ? 'override func' : 'func'} toString() -> String {
+    return self.__implementation.toString()
+  }
+
   // Properties
   ${indent(propertiesBridge.join('\n\n'), '  ')}
 
@@ -330,6 +338,9 @@ namespace ${cxxNamespace} {
     void dispose() noexcept override {
       _swiftPart.dispose();
     }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
 
   public:
     // Properties

package/lib/syntax/types/AnyHybridObjectType.d.ts

@@ -0,0 +1,11 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type, TypeKind } from './Type.js';
+export declare class AnyHybridObjectType implements Type {
+    constructor();
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/types/AnyHybridObjectType.js

@@ -0,0 +1,40 @@
+import { getForwardDeclaration } from '../c++/getForwardDeclaration.js';
+export class AnyHybridObjectType {
+    constructor() { }
+    get canBePassedByReference() {
+        // It's a shared_ptr<..>, no copy.
+        return true;
+    }
+    get kind() {
+        return 'hybrid-object-base';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return `std::shared_ptr<HybridObject>`;
+            default:
+                throw new Error(`\`AnyHybridObject\` cannot be used directly in ${language} yet. Use a specific derived class of \`HybridObject\` instead!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports(language) {
+        const imports = [];
+        switch (language) {
+            case 'c++':
+                imports.push({
+                    language: 'c++',
+                    name: 'memory',
+                    space: 'system',
+                }, {
+                    name: `NitroModules/HybridObject.hpp`,
+                    forwardDeclaration: getForwardDeclaration('class', 'HybridObject', 'margelo::nitro'),
+                    language: 'c++',
+                    space: 'system',
+                });
+                break;
+        }
+        return imports;
+    }
+}

package/lib/utils.d.ts

@@ -2,7 +2,6 @@ import type { SourceFile } from './syntax/SourceFile.js';
 import type { SwiftCxxHelper } from './syntax/swift/SwiftCxxTypeHelper.js';
 import type { Type } from 'ts-morph';
 import { NitroConfig } from './config/NitroConfig.js';
-export declare const NITROGEN_VERSION: string;
 export declare function capitalizeName(name: string): string;
 export declare function createIndentation(spacesCount: number): string;
 export declare function indent(string: string, spacesCount: number): string;

package/lib/utils.js

@@ -3,7 +3,6 @@ import fs from 'fs';
 import { isNotDuplicate } from './syntax/helpers.js';
 import { readUserConfig } from './config/getConfig.js';
 import { NitroConfig } from './config/NitroConfig.js';
-export const NITROGEN_VERSION = process.env.npm_package_version ?? '?.?.?';
 export function capitalizeName(name) {
     if (name.length === 0)
         return name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitrogen",
-  "version": "0.31.1",
+  "version": "0.31.3",
   "description": "The code-generator for react-native-nitro-modules.",
   "main": "lib/index",
   "types": "lib/index.d.ts",
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "chalk": "^5.3.0",
-    "react-native-nitro-modules": "^0.31.1",
+    "react-native-nitro-modules": "^0.31.3",
     "ts-morph": "^27.0.0",
     "yargs": "^18.0.0",
     "zod": "^4.0.5"

package/src/config/nitrogenVersion.ts

@@ -0,0 +1,3 @@
+import packageJson from 'nitrogen/package.json' with { type: 'json' }
+
+export const NITROGEN_VERSION = packageJson.version

package/src/createPlatformSpec.ts

@@ -19,6 +19,7 @@ import { createType } from './syntax/createType.js'
 import { Parameter } from './syntax/Parameter.js'
 import { getBaseTypes, getHybridObjectNitroModuleConfig } from './utils.js'
 import { NitroConfig } from './config/NitroConfig.js'
+import { isMemberOverridingFromBase } from './syntax/isMemberOverridingFromBase.js'
 
 export function generatePlatformFiles(
   interfaceType: Type,
@@ -151,6 +152,21 @@ function getHybridObjectSpec(type: Type, language: Language): HybridObjectSpec {
     isHybridView: isHybridView(type),
     config: config,
   }
+
+  for (const member of [...properties, ...methods]) {
+    const isOverridingBaseMember = isMemberOverridingFromBase(
+      member.name,
+      spec,
+      language
+    )
+    if (isOverridingBaseMember) {
+      throw new Error(
+        `\`${name}.${member.name}\` is overriding a member of one of it's base classes. ` +
+          `This is unsupported, override on the native side instead!`
+      )
+    }
+  }
+
   return spec
 }
 

package/src/getPlatformSpecs.ts

@@ -54,30 +54,27 @@ function getPlatformSpec(typeName: string, platformSpecs: Type): PlatformSpec {
     // Property name (ios, android)
     const platform = property.getName()
     if (!isValidPlatform(platform)) {
-      console.warn(
-        `    ⚠️   ${typeName} does not properly extend HybridObject<T> - "${platform}" is not a valid Platform! ` +
+      throw new Error(
+        `${typeName} does not properly extend HybridObject<T> - "${platform}" is not a valid Platform! ` +
           `Valid platforms are: [${allPlatforms.join(', ')}]`
       )
-      continue
     }
 
     // Value (swift, kotlin, c++)
     const language = getLiteralValue(property)
     if (!isValidLanguage(language)) {
-      console.warn(
-        `    ⚠️   ${typeName}: Language ${language} is not a valid language for ${platform}! ` +
+      throw new Error(
+        `${typeName}: Language ${language} is not a valid language for ${platform}! ` +
           `Valid languages are: [${platformLanguages[platform].join(', ')}]`
       )
-      continue
     }
 
     // Double-check that language works on this platform (android: kotlin/c++, ios: swift/c++)
     if (!isValidLanguageForPlatform(language, platform)) {
-      console.warn(
-        `    ⚠️   ${typeName}: Language ${language} is not a valid language for ${platform}! ` +
+      throw new Error(
+        `${typeName}: Language ${language} is not a valid language for ${platform}! ` +
           `Valid languages are: [${platformLanguages[platform].join(', ')}]`
       )
-      continue
     }
 
     // @ts-expect-error because TypeScript isn't smart enough yet to correctly cast after the `isValidLanguageForPlatform` check.
@@ -115,6 +112,10 @@ export function isDirectlyHybridObject(type: Type): boolean {
   return isDirectlyType(type, 'HybridObject')
 }
 
+export function isDirectlyAnyHybridObject(type: Type): boolean {
+  return isDirectlyType(type, 'AnyHybridObject')
+}
+
 export function extendsHybridObject(type: Type, recursive: boolean): boolean {
   return extendsType(type, 'HybridObject', recursive)
 }
@@ -154,7 +155,7 @@ export function isAnyHybridSubclass(type: Type): boolean {
  */
 export function getHybridObjectPlatforms(
   declaration: InterfaceDeclaration | TypeAliasDeclaration
-): PlatformSpec | undefined {
+): PlatformSpec {
   const base = getBaseTypes(declaration.getType()).find((t) =>
     isDirectlyHybridObject(t)
   )
@@ -167,9 +168,15 @@ export function getHybridObjectPlatforms(
 
   const genericArguments = base.getTypeArguments()
   const platformSpecsArgument = genericArguments[0]
-  if (platformSpecsArgument == null) {
-    // it uses `HybridObject` without generic arguments. This defaults to C++
-    return { android: 'c++', ios: 'c++' }
+  if (
+    platformSpecsArgument == null ||
+    platformSpecsArgument.getProperties().length === 0
+  ) {
+    // it uses `HybridObject` without generic arguments. We throw as we don't know what to generate.
+    throw new Error(
+      `HybridObject ${declaration.getName()} does not declare any platforms in the \`HybridObject\` type argument! ` +
+        `Pass at least one platform (and language) to \`interface ${declaration.getName()} extends HybridObject<{ ... }>\``
+    )
   }
 
   return getPlatformSpec(declaration.getName(), platformSpecsArgument)
@@ -177,7 +184,7 @@ export function getHybridObjectPlatforms(
 
 export function getHybridViewPlatforms(
   view: InterfaceDeclaration | TypeAliasDeclaration
-): PlatformSpec | undefined {
+): PlatformSpec {
   if (Node.isTypeAliasDeclaration(view)) {
     const hybridViewTypeNode = view.getTypeNode()
 
@@ -186,7 +193,9 @@ export function getHybridViewPlatforms(
       hybridViewTypeNode.getTypeName().getText() === 'HybridView'
 
     if (!isHybridViewType) {
-      return
+      throw new Error(
+        `${view.getName()} looks like a HybridView, but doesn't seem to alias HybridView<...>!`
+      )
     }
 
     const genericArguments = hybridViewTypeNode.getTypeArguments()

package/src/index.ts

@@ -9,7 +9,7 @@ import { runNitrogen } from './nitrogen.js'
 import { promises as fs } from 'fs'
 import { isValidLogLevel, setLogLevel } from './Logger.js'
 import { initNewNitroModule } from './init.js'
-import { NITROGEN_VERSION } from './utils.js'
+import { NITROGEN_VERSION } from './config/nitrogenVersion.js'
 
 const commandName = 'nitrogen'
 
@@ -90,6 +90,7 @@ await yargs(hideBin(process.argv))
   )
   .help()
   .strict()
+  .version(NITROGEN_VERSION)
   .wrap(cliWidth).argv
 
 async function runNitrogenCommand(

package/src/nitrogen.ts

@@ -14,7 +14,6 @@ import {
   deduplicateFiles,
   errorToString,
   indent,
-  NITROGEN_VERSION,
 } from './utils.js'
 import { writeFile } from './writeFile.js'
 import chalk from 'chalk'
@@ -26,6 +25,7 @@ import { createAndroidAutolinking } from './autolinking/createAndroidAutolinking
 import type { Autolinking } from './autolinking/Autolinking.js'
 import { createGitAttributes } from './createGitAttributes.js'
 import type { PlatformSpec } from 'react-native-nitro-modules'
+import { NITROGEN_VERSION } from './config/nitrogenVersion.js'
 
 interface NitrogenOptions {
   baseDirectory: string
@@ -108,31 +108,20 @@ export async function runNitrogen({
         let platformSpec: PlatformSpec
         if (isHybridView(declaration.getType())) {
           // Hybrid View Props
-          const targetPlatforms = getHybridViewPlatforms(declaration)
-          if (targetPlatforms == null) {
-            // It does not extend HybridView, continue..
-            continue
-          }
-          platformSpec = targetPlatforms
+          platformSpec = getHybridViewPlatforms(declaration)
         } else if (extendsHybridObject(declaration.getType(), true)) {
           // Hybrid View
-          const targetPlatforms = getHybridObjectPlatforms(declaration)
-          if (targetPlatforms == null) {
-            // It does not extend HybridObject, continue..
-            continue
-          }
-          platformSpec = targetPlatforms
+          platformSpec = getHybridObjectPlatforms(declaration)
         } else {
           continue
         }
 
         const platforms = Object.keys(platformSpec) as Platform[]
-
         if (platforms.length === 0) {
-          Logger.warn(
-            `⚠️   ${typeName} does not declare any platforms in HybridObject<T> - nothing can be generated.`
+          throw new Error(
+            `${typeName} does not declare any platforms in HybridObject<T> - nothing can be generated. ` +
+              `For example, to generate a C++ HybridObject, use \`interface ${typeName} extends HybridObject<{ ios: 'c++', android: 'c++' }> { ... }\``
           )
-          continue
         }
 
         targetSpecs++

package/src/syntax/Method.ts

@@ -50,6 +50,12 @@ export class Method implements CodeNode {
         `Method names are not allowed to start with two underscores (__)! (In ${this.jsSignature})`
       )
     }
+    if (this.name === 'dispose') {
+      // .dispose() does some special JSI magic that we loose if the user overrides it in his spec.
+      throw new Error(
+        `dispose() must not be overridden from TypeScript! You can override dispose() natively.`
+      )
+    }
   }
 
   get jsSignature(): string {

package/src/syntax/c++/CppHybridObject.ts

@@ -29,6 +29,11 @@ export function createCppHybridObject(spec: HybridObjectSpec): SourceFile[] {
   const cxxNamespace = spec.config.getCxxNamespace('c++')
   const name = getHybridObjectName(spec.name)
 
+  const properties = spec.properties.map((p) =>
+    p.getCode('c++', { virtual: true })
+  )
+  const methods = spec.methods.map((m) => m.getCode('c++', { virtual: true }))
+
   const bases = ['public virtual HybridObject']
   for (const base of spec.baseTypes) {
     const baseName = getHybridObjectName(base.name).HybridTSpec
@@ -77,11 +82,11 @@ namespace ${cxxNamespace} {
 
     public:
       // Properties
-      ${indent(spec.properties.map((p) => p.getCode('c++', { virtual: true })).join('\n'), '      ')}
+      ${indent(properties.join('\n'), '      ')}
 
     public:
       // Methods
-      ${indent(spec.methods.map((m) => m.getCode('c++', { virtual: true })).join('\n'), '      ')}
+      ${indent(methods.join('\n'), '      ')}
 
     protected:
       // Hybrid Setup

package/src/syntax/createType.ts

@@ -22,11 +22,11 @@ import { MapType } from './types/MapType.js'
 import { TupleType } from './types/TupleType.js'
 import {
   isAnyHybridSubclass,
-  isDirectlyHybridObject,
+  isDirectlyAnyHybridObject,
   isHybridView,
   type Language,
 } from '../getPlatformSpecs.js'
-import { HybridObjectBaseType } from './types/HybridObjectBaseType.js'
+import { AnyHybridObjectType } from './types/AnyHybridObjectType.js'
 import { ErrorType } from './types/ErrorType.js'
 import { getBaseTypes, getHybridObjectNitroModuleConfig } from '../utils.js'
 import { DateType } from './types/DateType.js'
@@ -314,6 +314,9 @@ export function createType(
         const name = type.getAliasSymbol()?.getName()
         return new VariantType(variants, name)
       }
+    } else if (isDirectlyAnyHybridObject(type)) {
+      // It is a HybridObject directly/literally. Base type
+      return new AnyHybridObjectType()
     } else if (isAnyHybridSubclass(type)) {
       // It is another HybridObject being referenced!
       const typename = getHybridObjectName(type)
@@ -324,9 +327,6 @@ export function createType(
       const sourceConfig =
         getHybridObjectNitroModuleConfig(type) ?? NitroConfig.current
       return new HybridObjectType(typename, language, baseHybrids, sourceConfig)
-    } else if (isDirectlyHybridObject(type)) {
-      // It is a HybridObject directly/literally. Base type
-      return new HybridObjectBaseType()
     } else if (type.isInterface()) {
       // It is an `interface T { ... }`, which is a `struct`
       const typename = type.getSymbolOrThrow().getName()

package/src/syntax/isMemberOverridingFromBase.ts

@@ -0,0 +1,79 @@
+import type { HybridObject } from 'react-native-nitro-modules'
+import type { Language } from '../getPlatformSpecs.js'
+import type { HybridObjectSpec } from './HybridObjectSpec.js'
+
+function getMemberNamesOfBaseType(language: Language): string[] {
+  switch (language) {
+    case 'c++':
+      // C++ classes don't have any base type.
+      return []
+    case 'swift':
+      // Swift classes conform to `AnyObject`, but that doesn't have any properties
+      return []
+    case 'kotlin':
+      // Kotlin/JVM classes always extends `Any`, which has 3 methods
+      return ['toString', 'equals', 'hashCode']
+  }
+}
+function getMemberNamesOfHybridObject(): string[] {
+  type MemberName = keyof HybridObject<{}>
+  type HasToContainAllKeys = { [P in MemberName]: boolean }
+  const allKeys: HasToContainAllKeys = {
+    __type: true,
+    dispose: true,
+    equals: true,
+    name: true,
+    toString: true,
+  }
+  return Object.keys(allKeys)
+}
+
+function flatBaseTypes(type: HybridObjectSpec): HybridObjectSpec[] {
+  return type.baseTypes.flatMap((b) => [b, ...flatBaseTypes(b)])
+}
+
+/**
+ * Returns true when the given {@linkcode memberName} is overriding a
+ * property or method from any base class inside the given
+ * {@linkcode hybridObject}'s prototype chain (all the way up).
+ *
+ * For example, `"toString"` would return `true` since it overrides from base HybridObject.
+ * On Kotlin, `"hashCode"` would return `true` since it overrides from base `kotlin.Any`.
+ */
+export function isMemberOverridingFromBase(
+  memberName: string,
+  hybridObject: HybridObjectSpec,
+  language: Language
+): boolean {
+  // 1. Check if the HybridObject inherits from other HybridObjects,
+  //    if yes, check if those have properties of that given name.
+  const allBases = flatBaseTypes(hybridObject)
+  const anyBaseOverrides = allBases.some((h) => {
+    if (h.properties.some((p) => p.name === memberName)) {
+      return true
+    }
+    if (h.methods.some((m) => m.name === memberName)) {
+      return true
+    }
+    return false
+  })
+  if (anyBaseOverrides) {
+    // A HybridObject base type has the same property name - we need to override it.
+    return true
+  }
+
+  // 2. Check if the base `HybridObject` type contains a property of the given name
+  const baseHybridObjectProps = getMemberNamesOfHybridObject()
+  if (baseHybridObjectProps.includes(memberName)) {
+    return true
+  }
+
+  // 3. Check if the base type in our language contains a property of the given name
+  const baseTypeProps = getMemberNamesOfBaseType(language)
+  if (baseTypeProps.includes(memberName)) {
+    return true
+  }
+
+  // 4. Apparently no base type has a property of that name - we are safe!
+  return false
+}

package/src/syntax/kotlin/FbjniHybridObject.ts

@@ -113,6 +113,7 @@ ${spaces}          public virtual ${name.HybridTSpec} {
   public:
     size_t getExternalMemorySize() noexcept override;
     void dispose() noexcept override;
+    std::string toString() override;
 
   public:
     inline const jni::global_ref<${name.JHybridTSpec}::javaobject>& getJavaPart() const noexcept {
@@ -198,6 +199,12 @@ namespace ${cxxNamespace} {
     method(_javaPart);
   }
 
+  std::string ${name.JHybridTSpec}::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
   // Properties
   ${indent(propertiesImpl, '  ')}
 

package/src/syntax/kotlin/KotlinHybridObject.ts

@@ -94,6 +94,11 @@ abstract class ${name.HybridTSpec}: ${kotlinBase}() {
     super.updateNative(hybridData)
   }
 
+  // Default implementation of \`HybridObject.toString()\`
+  override fun toString(): String {
+    return "[HybridObject ${name.T}]"
+  }
+
   // Properties
   ${indent(properties, '  ')}
 
@@ -199,7 +204,9 @@ set(value) {
       `.trim()
       )
     }
-    const code = property.getCode('kotlin', { virtual: true })
+    const code = property.getCode('kotlin', {
+      virtual: true,
+    })
     return `
 ${code}
 
@@ -207,7 +214,10 @@ private ${keyword} ${property.name}_cxx: ${bridged.getTypeCode('kotlin')}
   ${indent(lines.join('\n'), '  ')}
     `.trim()
   } else {
-    const code = property.getCode('kotlin', { doNotStrip: true, virtual: true })
+    const code = property.getCode('kotlin', {
+      doNotStrip: true,
+      virtual: true,
+    })
     return code
   }
 }