nitrogen 0.31.2 → 0.31.3

package/lib/createPlatformSpec.js

@@ -9,6 +9,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, language) {
     const spec = getHybridObjectSpec(interfaceType, language);
     // TODO: We currently just call this so the HybridObject itself is a "known type".
@@ -105,6 +106,13 @@ function getHybridObjectSpec(type, language) {
         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;
 }
 function generateCppFiles(spec) {

package/lib/getPlatformSpecs.d.ts

@@ -3,6 +3,7 @@ import type { InterfaceDeclaration, Type, TypeAliasDeclaration } from 'ts-morph'
 export type Platform = keyof Required<PlatformSpec>;
 export type Language = Required<PlatformSpec>[keyof PlatformSpec];
 export declare function isDirectlyHybridObject(type: Type): boolean;
+export declare function isDirectlyAnyHybridObject(type: Type): boolean;
 export declare function extendsHybridObject(type: Type, recursive: boolean): boolean;
 export declare function isHybridViewProps(type: Type): boolean;
 export declare function isHybridViewMethods(type: Type): boolean;
@@ -13,5 +14,5 @@ export declare function isAnyHybridSubclass(type: Type): boolean;
  * this method returns the platforms it exists on.
  * If it doesn't extend `HybridObject`, this returns `undefined`.
  */
-export declare function getHybridObjectPlatforms(declaration: InterfaceDeclaration | TypeAliasDeclaration): PlatformSpec | undefined;
-export declare function getHybridViewPlatforms(view: InterfaceDeclaration | TypeAliasDeclaration): PlatformSpec | undefined;
+export declare function getHybridObjectPlatforms(declaration: InterfaceDeclaration | TypeAliasDeclaration): PlatformSpec;
+export declare function getHybridViewPlatforms(view: InterfaceDeclaration | TypeAliasDeclaration): PlatformSpec;

package/lib/getPlatformSpecs.js

@@ -39,22 +39,19 @@ function getPlatformSpec(typeName, platformSpecs) {
         // 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.
         result[platform] = language;
@@ -86,6 +83,9 @@ function extendsType(type, name, recursive) {
 export function isDirectlyHybridObject(type) {
     return isDirectlyType(type, 'HybridObject');
 }
+export function isDirectlyAnyHybridObject(type) {
+    return isDirectlyType(type, 'AnyHybridObject');
+}
 export function extendsHybridObject(type, recursive) {
     return extendsType(type, 'HybridObject', recursive);
 }
@@ -128,9 +128,11 @@ export function getHybridObjectPlatforms(declaration) {
     }
     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);
 }
@@ -140,7 +142,7 @@ export function getHybridViewPlatforms(view) {
         const isHybridViewType = Node.isTypeReference(hybridViewTypeNode) &&
             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();
         const platformSpecArg = genericArguments[2];

package/lib/nitrogen.js

@@ -62,29 +62,19 @@ export async function runNitrogen({ baseDirectory, outputDirectory, }) {
                 let 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);
                 if (platforms.length === 0) {
-                    Logger.warn(`⚠️   ${typeName} does not declare any platforms in HybridObject<T> - nothing can be generated.`);
-                    continue;
+                    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++' }> { ... }\``);
                 }
                 targetSpecs++;
                 Logger.info(`    ⚙️   Generating specs for HybridObject "${chalk.bold(typeName)}"...`);

package/lib/syntax/Method.js

@@ -12,6 +12,10 @@ export class Method {
         if (this.name.startsWith('__')) {
             throw new Error(`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() {
         const returnType = this.returnType.kind;

package/lib/syntax/c++/CppHybridObject.js

@@ -23,6 +23,8 @@ export function createCppHybridObject(spec) {
         .filter(isNotDuplicate);
     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;
@@ -70,11 +72,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/lib/syntax/createType.js

@@ -19,8 +19,8 @@ import { getInterfaceProperties } from './getInterfaceProperties.js';
 import { VariantType } from './types/VariantType.js';
 import { MapType } from './types/MapType.js';
 import { TupleType } from './types/TupleType.js';
-import { isAnyHybridSubclass, isDirectlyHybridObject, isHybridView, } from '../getPlatformSpecs.js';
-import { HybridObjectBaseType } from './types/HybridObjectBaseType.js';
+import { isAnyHybridSubclass, isDirectlyAnyHybridObject, isHybridView, } from '../getPlatformSpecs.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';
@@ -253,6 +253,10 @@ export function createType(language, type, isOptional) {
                 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);
@@ -263,10 +267,6 @@ export function createType(language, type, isOptional) {
             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/lib/syntax/isMemberOverridingFromBase.d.ts

@@ -0,0 +1,11 @@
+import type { Language } from '../getPlatformSpecs.js';
+import type { HybridObjectSpec } from './HybridObjectSpec.js';
+/**
+ * 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 declare function isMemberOverridingFromBase(memberName: string, hybridObject: HybridObjectSpec, language: Language): boolean;

package/lib/syntax/isMemberOverridingFromBase.js

@@ -0,0 +1,64 @@
+function getMemberNamesOfBaseType(language) {
+    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() {
+    const allKeys = {
+        __type: true,
+        dispose: true,
+        equals: true,
+        name: true,
+        toString: true,
+    };
+    return Object.keys(allKeys);
+}
+function flatBaseTypes(type) {
+    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, hybridObject, language) {
+    // 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/lib/syntax/isOverridingFromBase.d.ts

@@ -0,0 +1,11 @@
+import type { Language } from '../getPlatformSpecs.js';
+import type { HybridObjectSpec } from './HybridObjectSpec.js';
+/**
+ * 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 declare function isMemberOverridingFromBase(memberName: string, hybridObject: HybridObjectSpec, language: Language): boolean;

package/lib/syntax/isOverridingFromBase.js

@@ -0,0 +1,64 @@
+function getMemberNamesOfBaseType(language) {
+    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() {
+    const allKeys = {
+        __type: true,
+        dispose: true,
+        equals: true,
+        name: true,
+        toString: true,
+    };
+    return Object.keys(allKeys);
+}
+function flatBaseTypes(type) {
+    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, hybridObject, language) {
+    // 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/lib/syntax/kotlin/FbjniHybridObject.js

@@ -94,6 +94,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 {
@@ -176,6 +177,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/lib/syntax/kotlin/KotlinHybridObject.js

@@ -83,6 +83,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, '  ')}
 
@@ -173,7 +178,9 @@ set(value) {
 }
       `.trim());
         }
-        const code = property.getCode('kotlin', { virtual: true });
+        const code = property.getCode('kotlin', {
+            virtual: true,
+        });
         return `
 ${code}
 
@@ -182,7 +189,10 @@ private ${keyword} ${property.name}_cxx: ${bridged.getTypeCode('kotlin')}
     `.trim();
     }
     else {
-        const code = property.getCode('kotlin', { doNotStrip: true, virtual: true });
+        const code = property.getCode('kotlin', {
+            doNotStrip: true,
+            virtual: true,
+        });
         return code;
     }
 }

package/lib/syntax/kotlin/KotlinStruct.js

@@ -6,29 +6,41 @@ import { createFileMetadataString, isNotDuplicate } from '../helpers.js';
 import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js';
 export function createKotlinStruct(structType) {
     const packageName = NitroConfig.current.getAndroidPackage('java/kotlin');
-    const parameters = structType.properties
-        .map((p) => `
+    const bridgedProperties = structType.properties.map((p) => ({
+        name: p.escapedName,
+        type: new KotlinCxxBridgedType(p),
+    }));
+    //   const parameters = structType.properties
+    //     .map((p) =>
+    //       `
+    // @DoNotStrip
+    // @Keep
+    // val ${p.escapedName}: ${p.getCode('kotlin')}
+    // `.trim()
+    //     )
+    //     .join(',\n')
+    const properties = bridgedProperties
+        .map(({ name, type }) => {
+        return `
 @DoNotStrip
 @Keep
-val ${p.escapedName}: ${p.getCode('kotlin')}
-`.trim())
+val ${name}: ${type.getTypeCode('kotlin', false)}
+`.trim();
+    })
         .join(',\n');
-    const cxxCreateFunctionParameters = structType.properties
-        .map((p) => {
-        const bridged = new KotlinCxxBridgedType(p);
-        return `${p.escapedName}: ${bridged.getTypeCode('kotlin', false)}`;
+    const cxxCreateFunctionParameters = bridgedProperties
+        .map(({ name, type }) => {
+        return `${name}: ${type.getTypeCode('kotlin', false)}`;
     })
         .join(', ');
-    const cxxCreateFunctionForward = structType.properties
-        .map((p) => {
-        const bridged = new KotlinCxxBridgedType(p);
-        return bridged.parseFromCppToKotlin(p.escapedName, 'kotlin', false);
-    })
+    const cxxCreateFunctionForward = bridgedProperties
+        .map((p) => p.name)
         .join(', ');
     const extraImports = structType.properties
         .flatMap((t) => t.getRequiredImports('kotlin'))
         .map((i) => `import ${i.name}`)
         .filter(isNotDuplicate);
+    const secondaryConstructor = createKotlinConstructor(structType);
     const code = `
 ${createFileMetadataString(`${structType.structName}.kt`)}
 
@@ -44,8 +56,10 @@ ${extraImports.join('\n')}
 @DoNotStrip
 @Keep
 data class ${structType.structName}(
-  ${indent(parameters, '  ')}
+  ${indent(properties, '  ')}
 ) {
+  ${indent(secondaryConstructor, '  ')}
+
   private companion object {
     /**
      * Constructor called from C++
@@ -132,6 +146,27 @@ namespace ${cxxNamespace} {
     });
     return files;
 }
+function createKotlinConstructor(structType) {
+    const bridgedProperties = structType.properties.map((p) => ({
+        name: p.escapedName,
+        type: new KotlinCxxBridgedType(p),
+    }));
+    const needsSpecialHandling = bridgedProperties.some(({ type }) => type.needsSpecialHandling);
+    if (needsSpecialHandling) {
+        const kotlinParams = structType.properties.map((p) => `${p.escapedName}: ${p.getCode('kotlin')}`);
+        const paramsForward = bridgedProperties.map(({ name, type }) => type.parseFromKotlinToCpp(name, 'kotlin'));
+        return `
+/**
+ * Create a new instance of ${structType.structName} from Kotlin
+ */
+constructor(${kotlinParams.join(', ')}):
+       this(${paramsForward.join(', ')})
+      `.trim();
+    }
+    else {
+        return `/* primary constructor */`;
+    }
+}
 function createJNIStructInitializer(structType) {
     const lines = ['static const auto clazz = javaClassStatic();'];
     for (const prop of structType.properties) {

package/lib/syntax/kotlin/isBaseObjectMethodName.d.ts

@@ -0,0 +1,7 @@
+import type { Method } from '../Method.js';
+/**
+ * Returns `true` if the given {@linkcode method} is a
+ * method that exists in the base `Object` type in Java.
+ * If this is true, it needs an `override` modifier.
+ */
+export declare function isBaseObjectMethodName(method: Method): boolean;

package/lib/syntax/kotlin/isBaseObjectMethodName.js

@@ -0,0 +1,9 @@
+const kotlinAnyMethodNames = ['equals', 'hashCode', 'toString'];
+/**
+ * Returns `true` if the given {@linkcode method} is a
+ * method that exists in the base `Object` type in Java.
+ * If this is true, it needs an `override` modifier.
+ */
+export function isBaseObjectMethodName(method) {
+    return kotlinAnyMethodNames.includes(method.name);
+}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitrogen",
-  "version": "0.31.2",
+  "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.2",
+    "react-native-nitro-modules": "^0.31.3",
     "ts-morph": "^27.0.0",
     "yargs": "^18.0.0",
     "zod": "^4.0.5"

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/nitrogen.ts

@@ -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
   }
 }

package/src/syntax/kotlin/KotlinStruct.ts

@@ -7,29 +7,44 @@ import type { SourceFile } from '../SourceFile.js'
 import type { StructType } from '../types/StructType.js'
 import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
 
+interface BridgedProperty {
+  name: string
+  type: KotlinCxxBridgedType
+}
+
 export function createKotlinStruct(structType: StructType): SourceFile[] {
   const packageName = NitroConfig.current.getAndroidPackage('java/kotlin')
-  const parameters = structType.properties
-    .map((p) =>
-      `
+
+  const bridgedProperties = structType.properties.map<BridgedProperty>((p) => ({
+    name: p.escapedName,
+    type: new KotlinCxxBridgedType(p),
+  }))
+  //   const parameters = structType.properties
+  //     .map((p) =>
+  //       `
+  // @DoNotStrip
+  // @Keep
+  // val ${p.escapedName}: ${p.getCode('kotlin')}
+  // `.trim()
+  //     )
+  //     .join(',\n')
+  const properties = bridgedProperties
+    .map(({ name, type }) => {
+      return `
 @DoNotStrip
 @Keep
-val ${p.escapedName}: ${p.getCode('kotlin')}
+val ${name}: ${type.getTypeCode('kotlin', false)}
 `.trim()
-    )
+    })
     .join(',\n')
 
-  const cxxCreateFunctionParameters = structType.properties
-    .map((p) => {
-      const bridged = new KotlinCxxBridgedType(p)
-      return `${p.escapedName}: ${bridged.getTypeCode('kotlin', false)}`
+  const cxxCreateFunctionParameters = bridgedProperties
+    .map(({ name, type }) => {
+      return `${name}: ${type.getTypeCode('kotlin', false)}`
     })
     .join(', ')
-  const cxxCreateFunctionForward = structType.properties
-    .map((p) => {
-      const bridged = new KotlinCxxBridgedType(p)
-      return bridged.parseFromCppToKotlin(p.escapedName, 'kotlin', false)
-    })
+  const cxxCreateFunctionForward = bridgedProperties
+    .map((p) => p.name)
     .join(', ')
 
   const extraImports = structType.properties
@@ -37,6 +52,8 @@ val ${p.escapedName}: ${p.getCode('kotlin')}
     .map((i) => `import ${i.name}`)
     .filter(isNotDuplicate)
 
+  const secondaryConstructor = createKotlinConstructor(structType)
+
   const code = `
 ${createFileMetadataString(`${structType.structName}.kt`)}
 
@@ -52,8 +69,10 @@ ${extraImports.join('\n')}
 @DoNotStrip
 @Keep
 data class ${structType.structName}(
-  ${indent(parameters, '  ')}
+  ${indent(properties, '  ')}
 ) {
+  ${indent(secondaryConstructor, '  ')}
+
   private companion object {
     /**
      * Constructor called from C++
@@ -150,6 +169,33 @@ namespace ${cxxNamespace} {
   return files
 }
 
+function createKotlinConstructor(structType: StructType): string {
+  const bridgedProperties = structType.properties.map<BridgedProperty>((p) => ({
+    name: p.escapedName,
+    type: new KotlinCxxBridgedType(p),
+  }))
+  const needsSpecialHandling = bridgedProperties.some(
+    ({ type }) => type.needsSpecialHandling
+  )
+  if (needsSpecialHandling) {
+    const kotlinParams = structType.properties.map(
+      (p) => `${p.escapedName}: ${p.getCode('kotlin')}`
+    )
+    const paramsForward = bridgedProperties.map(({ name, type }) =>
+      type.parseFromKotlinToCpp(name, 'kotlin')
+    )
+    return `
+/**
+ * Create a new instance of ${structType.structName} from Kotlin
+ */
+constructor(${kotlinParams.join(', ')}):
+       this(${paramsForward.join(', ')})
+      `.trim()
+  } else {
+    return `/* primary constructor */`
+  }
+}
+
 function createJNIStructInitializer(structType: StructType): string {
   const lines: string[] = ['static const auto clazz = javaClassStatic();']
   for (const prop of structType.properties) {

package/src/syntax/swift/SwiftHybridObject.ts

@@ -11,7 +11,7 @@ export function createSwiftHybridObject(spec: HybridObjectSpec): SourceFile[] {
   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')),
@@ -83,6 +83,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/src/syntax/swift/SwiftHybridObjectBridge.ts

@@ -191,7 +191,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())
@@ -220,6 +220,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'), '  ')}
 
@@ -390,6 +398,9 @@ namespace ${cxxNamespace} {
     void dispose() noexcept override {
       _swiftPart.dispose();
     }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
 
   public:
     // Properties

package/src/syntax/types/{HybridObjectBaseType.ts → AnyHybridObjectType.ts}

@@ -3,7 +3,7 @@ import { getForwardDeclaration } from '../c++/getForwardDeclaration.js'
 import type { SourceFile, SourceImport } from '../SourceFile.js'
 import type { Type, TypeKind } from './Type.js'
 
-export class HybridObjectBaseType implements Type {
+export class AnyHybridObjectType implements Type {
   constructor() {}
 
   get canBePassedByReference(): boolean {
@@ -21,7 +21,7 @@ export class HybridObjectBaseType implements Type {
         return `std::shared_ptr<HybridObject>`
       default:
         throw new Error(
-          `The base type \`HybridObject\` cannot be used directly in ${language} yet. Use a specific derived class of \`HybridObject\` instead!`
+          `\`AnyHybridObject\` cannot be used directly in ${language} yet. Use a specific derived class of \`HybridObject\` instead!`
         )
     }
   }
@@ -50,13 +50,6 @@ export class HybridObjectBaseType implements Type {
           }
         )
         break
-      case 'kotlin':
-        imports.push({
-          name: 'com.margelo.nitro.core.HybridObject',
-          space: 'system',
-          language: 'kotlin',
-        })
-        break
     }
     return imports
   }