nitrogen 0.31.1 → 0.31.3

package/lib/config/nitrogenVersion.d.ts

@@ -0,0 +1 @@
+export declare const NITROGEN_VERSION: string;

package/lib/config/nitrogenVersion.js

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

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/index.js

@@ -8,7 +8,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';
 // Maximum of 100 col width
 const cliWidth = Math.min(process.stdout.columns * 0.9, 100);
@@ -71,6 +71,7 @@ await yargs(hideBin(process.argv))
     `$Nitrogen Version: ${chalk.bold(NITROGEN_VERSION)}`)
     .help()
     .strict()
+    .version(NITROGEN_VERSION)
     .wrap(cliWidth).argv;
 async function runNitrogenCommand(baseDirectory, outputDirectory) {
     // 1. Prepare output folders

package/lib/nitrogen.js

@@ -3,7 +3,7 @@ import { extendsHybridObject, isHybridView, getHybridObjectPlatforms, getHybridV
 import { generatePlatformFiles } from './createPlatformSpec.js';
 import path from 'path';
 import { prettifyDirectory } from './prettifyDirectory.js';
-import { capitalizeName, deduplicateFiles, errorToString, indent, NITROGEN_VERSION, } from './utils.js';
+import { capitalizeName, deduplicateFiles, errorToString, indent, } from './utils.js';
 import { writeFile } from './writeFile.js';
 import chalk from 'chalk';
 import { groupByPlatform } from './syntax/SourceFile.js';
@@ -12,6 +12,7 @@ import { NitroConfig } from './config/NitroConfig.js';
 import { createIOSAutolinking } from './autolinking/createIOSAutolinking.js';
 import { createAndroidAutolinking } from './autolinking/createAndroidAutolinking.js';
 import { createGitAttributes } from './createGitAttributes.js';
+import { NITROGEN_VERSION } from './config/nitrogenVersion.js';
 export async function runNitrogen({ baseDirectory, outputDirectory, }) {
     let targetSpecs = 0;
     let generatedSpecs = 0;
@@ -61,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/SwiftCxxBridgedType.js

@@ -22,7 +22,6 @@ import { VoidType } from '../types/VoidType.js';
 import { NamedWrappingType } from '../types/NamedWrappingType.js';
 import { ErrorType } from '../types/ErrorType.js';
 import { createSwiftFunctionBridge } from './SwiftFunction.js';
-import { isPrimitivelyCopyable } from './isPrimitivelyCopyable.js';
 // TODO: Remove enum bridge once Swift fixes bidirectional enums crashing the `-Swift.h` header.
 export class SwiftCxxBridgedType {
     type;
@@ -449,21 +448,8 @@ export class SwiftCxxBridgedType {
                 const wrapping = new SwiftCxxBridgedType(array.itemType, true);
                 switch (language) {
                     case 'swift':
-                        if (isPrimitivelyCopyable(array.itemType)) {
-                            // We can primitively copy the data, raw:
-                            const bridge = this.getBridgeOrThrow();
-                            const getDataFunc = `bridge.get_data_${bridge.specializationName}`;
-                            return `
-{ () -> ${array.getCode('swift')} in
-  let __data = ${getDataFunc}(${cppParameterName})
-  let __size = ${cppParameterName}.size()
-  return Array(UnsafeBufferPointer(start: __data, count: __size))
-}()`.trim();
-                        }
-                        else {
-                            // We have to iterate the element one by one to create a resulting Array (mapped)
-                            return `${cppParameterName}.map({ __item in ${wrapping.parseFromCppToSwift('__item', 'swift')} })`.trim();
-                        }
+                        // We have to iterate the element one by one to create a resulting Array (mapped)
+                        return `${cppParameterName}.map({ __item in ${wrapping.parseFromCppToSwift('__item', 'swift')} })`.trim();
                     default:
                         return cppParameterName;
                 }
@@ -713,18 +699,9 @@ case ${i}:
                 const wrapping = new SwiftCxxBridgedType(array.itemType, true);
                 switch (language) {
                     case 'swift':
-                        if (isPrimitivelyCopyable(array.itemType)) {
-                            // memory can be copied primitively
-                            const copyFunc = `bridge.${bridge.funcName}`;
-                            return `
-${swiftParameterName}.withUnsafeBufferPointer { __pointer -> bridge.${bridge.specializationName} in
-  return ${copyFunc}(__pointer.baseAddress!, ${swiftParameterName}.count)
-}`.trim();
-                        }
-                        else {
-                            // array has to be iterated and converted one-by-one
-                            const makeFunc = `bridge.${bridge.funcName}`;
-                            return `
+                        // array has to be iterated and converted one-by-one
+                        const makeFunc = `bridge.${bridge.funcName}`;
+                        return `
 { () -> bridge.${bridge.specializationName} in
   var __vector = ${makeFunc}(${swiftParameterName}.count)
   for __item in ${swiftParameterName} {
@@ -732,7 +709,6 @@ ${swiftParameterName}.withUnsafeBufferPointer { __pointer -> bridge.${bridge.spe
   }
   return __vector
 }()`.trim();
-                        }
                     default:
                         return swiftParameterName;
                 }