nitrogen 0.31.5 → 0.31.6

package/lib/createPlatformSpec.js

@@ -79,12 +79,14 @@ function getHybridObjectSpec(type, language) {
         }
         if (Node.isPropertySignature(declaration)) {
             const t = declaration.getType();
-            const propType = createType(language, t, prop.isOptional() || t.isNullable());
+            const isOptional = prop.isOptional() || t.getUnionTypes().some((u) => u.isUndefined());
+            const propType = createType(language, t, isOptional);
             properties.push(new Property(prop.getName(), propType, declaration.isReadonly()));
         }
         else if (Node.isMethodSignature(declaration)) {
             const returnType = declaration.getReturnType();
-            const methodReturnType = createType(language, returnType, returnType.isNullable());
+            const isOptional = returnType.getUnionTypes().some((t) => t.isUndefined());
+            const methodReturnType = createType(language, returnType, isOptional);
             const methodParameters = declaration
                 .getParameters()
                 .map((p) => new Parameter(p, language));

package/lib/syntax/createType.js

@@ -1,5 +1,4 @@
 import { ts, Type as TSMorphType } from 'ts-morph';
-import { NullType } from './types/NullType.js';
 import { BooleanType } from './types/BooleanType.js';
 import { NumberType } from './types/NumberType.js';
 import { StringType } from './types/StringType.js';
@@ -29,6 +28,7 @@ import { CustomType } from './types/CustomType.js';
 import { isSyncFunction, isArrayBuffer, isCustomType, isDate, isError, isMap, isPromise, isRecord, } from './isCoreType.js';
 import { getCustomTypeConfig } from './getCustomTypeConfig.js';
 import { compareLooselyness } from './helpers.js';
+import { NullType } from './types/NullType.js';
 function getHybridObjectName(type) {
     const symbol = isHybridView(type) ? type.getAliasSymbol() : type.getSymbol();
     if (symbol == null) {
@@ -122,7 +122,7 @@ export function createType(language, type, isOptional) {
             const wrapping = createType(language, type, false);
             return new OptionalType(wrapping);
         }
-        if (type.isNull() || type.isUndefined()) {
+        if (type.isNull()) {
             return new NullType();
         }
         else if (type.isBoolean() || type.isBooleanLiteral()) {
@@ -166,7 +166,10 @@ export function createType(language, type, isOptional) {
             // It's a function!
             const callSignature = getFunctionCallSignature(type);
             const funcReturnType = callSignature.getReturnType();
-            const returnType = createType(language, funcReturnType, funcReturnType.isNullable());
+            const isReturnOptional = funcReturnType
+                .getUnionTypes()
+                .some((t) => t.isUndefined());
+            const returnType = createType(language, funcReturnType, isReturnOptional);
             const parameters = callSignature.getParameters().map((p) => {
                 const declaration = p.getValueDeclarationOrThrow();
                 const parameterType = p.getTypeAtLocation(declaration);
@@ -179,7 +182,10 @@ export function createType(language, type, isOptional) {
         else if (isPromise(type)) {
             // It's a Promise!
             const [promiseResolvingType] = getArguments(type, 'Promise', 1);
-            const resolvingType = createType(language, promiseResolvingType, promiseResolvingType.isNullable());
+            const isResolvingOptional = promiseResolvingType
+                .getUnionTypes()
+                .some((t) => t.isUndefined());
+            const resolvingType = createType(language, promiseResolvingType, isResolvingOptional);
             return new PromiseType(resolvingType);
         }
         else if (isRecord(type)) {
@@ -240,8 +246,8 @@ export function createType(language, type, isOptional) {
                 // It consists of different types - that means it's a variant!
                 let variants = type
                     .getUnionTypes()
-                    // Filter out any nulls or undefineds, as those are already treated as `isOptional`.
-                    .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid())
+                    // Filter out any undefineds/voids, as those are already treated as `isOptional`.
+                    .filter((t) => !t.isUndefined() && !t.isVoid())
                     .map((t) => createType(language, t, false))
                     .toSorted(compareLooselyness);
                 variants = removeDuplicates(variants);
@@ -294,6 +300,12 @@ export function createType(language, type, isOptional) {
         else if (type.isStringLiteral()) {
             throw new Error(`String literal ${type.getText()} cannot be represented in C++ because it is ambiguous between a string and a discriminating union enum.`);
         }
+        else if (type.isUndefined()) {
+            throw new Error(`The TypeScript type "undefined" cannot be represented in Nitro.\n` +
+                `- If you want to make a type optional, add \`?\` to it's name, or make it an union with \`undefined\`.\n` +
+                `- If you want a method that returns nothing, use \`void\` instead.\n` +
+                `- If you want to represent an explicit absence of a value, use \`null\` instead.`);
+        }
         else if (type.isAny()) {
             throw new Error(`The TypeScript type "${type.getText()}" resolved to any - any is not supported in Nitro.`);
         }

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

@@ -13,6 +13,7 @@ export declare class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'
     asJniReferenceType(referenceType?: 'alias' | 'local' | 'global'): string;
     getTypeCode(language: 'kotlin' | 'c++', isBoxed?: boolean): string;
     parse(parameterName: string, from: 'c++' | 'kotlin', to: 'kotlin' | 'c++', inLanguage: 'kotlin' | 'c++'): string;
+    dereferenceToJObject(parameterName: string): string;
     parseFromCppToKotlin(parameterName: string, language: 'kotlin' | 'c++', isBoxed?: boolean): string;
     parseFromKotlinToCpp(parameterName: string, language: 'kotlin' | 'c++', isBoxed?: boolean): string;
     private getFullJHybridObjectName;

package/lib/syntax/kotlin/KotlinCxxBridgedType.js

@@ -22,7 +22,7 @@ export class KotlinCxxBridgedType {
         this.type = type;
     }
     get hasType() {
-        return this.type.kind !== 'void' && this.type.kind !== 'null';
+        return this.type.kind !== 'void';
     }
     get canBePassedByReference() {
         return this.type.canBePassedByReference;
@@ -37,6 +37,16 @@ export class KotlinCxxBridgedType {
                 const optional = getTypeAs(this.type, OptionalType);
                 return new KotlinCxxBridgedType(optional.wrappingType)
                     .needsSpecialHandling;
+            case 'array':
+                // Arrays need special handling if their item type needs special handling
+                const array = getTypeAs(this.type, ArrayType);
+                return new KotlinCxxBridgedType(array.itemType).needsSpecialHandling;
+            case 'record':
+                // Records need special handling if their key or value type needs special handling
+                const record = getTypeAs(this.type, RecordType);
+                const keyType = new KotlinCxxBridgedType(record.keyType);
+                const valueType = new KotlinCxxBridgedType(record.valueType);
+                return keyType.needsSpecialHandling || valueType.needsSpecialHandling;
             default:
                 break;
         }
@@ -72,6 +82,13 @@ export class KotlinCxxBridgedType {
                         space: 'user',
                     });
                     break;
+                case 'null':
+                    imports.push({
+                        language: 'c++',
+                        name: `NitroModules/JNull.hpp`,
+                        space: 'system',
+                    });
+                    break;
                 case 'array-buffer':
                     imports.push({
                         language: 'c++',
@@ -295,6 +312,13 @@ export class KotlinCxxBridgedType {
                         return this.type.getCode(language);
                 }
             }
+            case 'null':
+                switch (language) {
+                    case 'c++':
+                        return `JNull`;
+                    default:
+                        return this.type.getCode(language);
+                }
             case 'array-buffer':
                 switch (language) {
                     case 'c++':
@@ -379,6 +403,21 @@ export class KotlinCxxBridgedType {
             throw new Error(`Cannot parse "${parameterName}" from ${from} to ${to}!`);
         }
     }
+    dereferenceToJObject(parameterName) {
+        switch (this.type.kind) {
+            // any jni::HybridClass needs to be dereferenced to jobject with .get()
+            case 'array-buffer':
+            case 'function':
+            case 'hybrid-object':
+            case 'hybrid-object-base':
+            case 'map':
+            case 'promise':
+                return `${parameterName}.get()`;
+            // anything else can be dereferenced to jobject with *
+            default:
+                return `*${parameterName}`;
+        }
+    }
     parseFromCppToKotlin(parameterName, language, isBoxed = false) {
         switch (this.type.kind) {
             case 'number':
@@ -423,6 +462,14 @@ export class KotlinCxxBridgedType {
                         return parameterName;
                 }
             }
+            case 'null': {
+                switch (language) {
+                    case 'c++':
+                        return `JNull::null()`;
+                    default:
+                        return parameterName;
+                }
+            }
             case 'date': {
                 switch (language) {
                     case 'c++':
@@ -546,7 +593,8 @@ export class KotlinCxxBridgedType {
   jni::local_ref<${arrayType}> __array = ${arrayType}::newArray(__size);
   for (size_t __i = 0; __i < __size; __i++) {
     const auto& __element = ${parameterName}[__i];
-    __array->setElement(__i, *${indent(bridge.parseFromCppToKotlin('__element', 'c++'), '    ')});
+    auto __elementJni = ${indent(bridge.parseFromCppToKotlin('__element', 'c++'), '    ')};
+    __array->setElement(__i, ${bridge.dereferenceToJObject('__elementJni')});
   }
   return __array;
 }()
@@ -556,7 +604,9 @@ export class KotlinCxxBridgedType {
                     }
                     case 'kotlin':
                         if (bridge.needsSpecialHandling) {
-                            return `${parameterName}.map { ${bridge.parseFromCppToKotlin('it', language, isBoxed)} }`;
+                            const variableName = `${parameterName}[i]`;
+                            const parseCode = bridge.parseFromCppToKotlin(variableName, 'kotlin', isBoxed);
+                            return `Array(${parameterName}.size) { i -> ${parseCode} }`;
                         }
                         else {
                             return parameterName;
@@ -678,6 +728,14 @@ export class KotlinCxxBridgedType {
                         return parameterName;
                 }
             }
+            case 'null': {
+                switch (language) {
+                    case 'c++':
+                        return `nitro::null`;
+                    default:
+                        return parameterName;
+                }
+            }
             case 'hybrid-object': {
                 switch (language) {
                     case 'c++':
@@ -775,10 +833,10 @@ export class KotlinCxxBridgedType {
                 }
             }
             case 'array': {
+                const array = getTypeAs(this.type, ArrayType);
+                const bridge = new KotlinCxxBridgedType(array.itemType);
                 switch (language) {
-                    case 'c++':
-                        const array = getTypeAs(this.type, ArrayType);
-                        const bridge = new KotlinCxxBridgedType(array.itemType);
+                    case 'c++': {
                         const itemType = array.itemType.getCode('c++');
                         switch (array.itemType.kind) {
                             case 'number':
@@ -811,6 +869,16 @@ export class KotlinCxxBridgedType {
             `.trim();
                             }
                         }
+                    }
+                    case 'kotlin':
+                        if (bridge.needsSpecialHandling) {
+                            const variableName = `${parameterName}[i]`;
+                            const parseCode = bridge.parseFromKotlinToCpp(variableName, 'kotlin', isBoxed);
+                            return `Array(${parameterName}.size) { i -> ${parseCode} }`;
+                        }
+                        else {
+                            return parameterName;
+                        }
                     default:
                         return parameterName;
                 }

package/lib/syntax/swift/SwiftCxxBridgedType.js

@@ -31,7 +31,7 @@ export class SwiftCxxBridgedType {
         this.isBridgingToDirectCppTarget = isBridgingToDirectCppTarget;
     }
     get hasType() {
-        return this.type.kind !== 'void' && this.type.kind !== 'null';
+        return this.type.kind !== 'void';
     }
     get canBePassedByReference() {
         return this.type.canBePassedByReference;
@@ -53,6 +53,9 @@ export class SwiftCxxBridgedType {
             case 'optional':
                 // swift::Optional<T> <> std::optional<T>
                 return true;
+            case 'null':
+                // NullType <> nitro::null
+                return true;
             case 'string':
                 // swift::String <> std::string
                 return true;
@@ -220,6 +223,13 @@ export class SwiftCxxBridgedType {
                         return this.type.getCode(language);
                 }
             }
+            case 'null':
+                switch (language) {
+                    case 'swift':
+                        return 'margelo.nitro.NullType';
+                    default:
+                        return this.type.getCode(language);
+                }
             case 'array-buffer':
                 if (this.isBridgingToDirectCppTarget) {
                     return this.type.getCode(language);
@@ -393,6 +403,13 @@ export class SwiftCxxBridgedType {
                         return cppParameterName;
                 }
             }
+            case 'null':
+                switch (language) {
+                    case 'swift':
+                        return `NullType.null`;
+                    default:
+                        return cppParameterName;
+                }
             case 'optional': {
                 const optional = getTypeAs(this.type, OptionalType);
                 const wrapping = new SwiftCxxBridgedType(optional.wrappingType, true);
@@ -606,6 +623,13 @@ case ${i}:
                         return swiftParameterName;
                 }
             }
+            case 'null':
+                switch (language) {
+                    case 'swift':
+                        return `margelo.nitro.NullType.null`;
+                    default:
+                        return swiftParameterName;
+                }
             case 'optional': {
                 const optional = getTypeAs(this.type, OptionalType);
                 const wrapping = new SwiftCxxBridgedType(optional.wrappingType, true);

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

@@ -6,5 +6,5 @@ export declare class NullType implements Type {
     get kind(): TypeKind;
     getCode(language: Language): string;
     getExtraFiles(): SourceFile[];
-    getRequiredImports(): SourceImport[];
+    getRequiredImports(language: Language): SourceImport[];
 }

package/lib/syntax/types/NullType.js

@@ -9,7 +9,11 @@ export class NullType {
     getCode(language) {
         switch (language) {
             case 'c++':
-                return 'std::nullptr_t';
+                return 'nitro::NullType';
+            case 'swift':
+                return 'NullType';
+            case 'kotlin':
+                return 'NullType';
             default:
                 throw new Error(`Language ${language} is not yet supported for NullType!`);
         }
@@ -17,7 +21,31 @@ export class NullType {
     getExtraFiles() {
         return [];
     }
-    getRequiredImports() {
-        return [];
+    getRequiredImports(language) {
+        const imports = [];
+        switch (language) {
+            case 'c++':
+                imports.push({
+                    language: language,
+                    name: 'NitroModules/Null.hpp',
+                    space: 'system',
+                });
+                break;
+            case 'swift':
+                imports.push({
+                    language: language,
+                    name: 'NitroModules',
+                    space: 'system',
+                });
+                break;
+            case 'kotlin':
+                imports.push({
+                    language: language,
+                    name: 'com.margelo.nitro.core.NullType',
+                    space: 'system',
+                });
+                break;
+        }
+        return imports;
     }
 }

package/package.json

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

package/src/createPlatformSpec.ts

@@ -111,21 +111,16 @@ function getHybridObjectSpec(type: Type, language: Language): HybridObjectSpec {
 
     if (Node.isPropertySignature(declaration)) {
       const t = declaration.getType()
-      const propType = createType(
-        language,
-        t,
-        prop.isOptional() || t.isNullable()
-      )
+      const isOptional =
+        prop.isOptional() || t.getUnionTypes().some((u) => u.isUndefined())
+      const propType = createType(language, t, isOptional)
       properties.push(
         new Property(prop.getName(), propType, declaration.isReadonly())
       )
     } else if (Node.isMethodSignature(declaration)) {
       const returnType = declaration.getReturnType()
-      const methodReturnType = createType(
-        language,
-        returnType,
-        returnType.isNullable()
-      )
+      const isOptional = returnType.getUnionTypes().some((t) => t.isUndefined())
+      const methodReturnType = createType(language, returnType, isOptional)
       const methodParameters = declaration
         .getParameters()
         .map((p) => new Parameter(p, language))

package/src/syntax/createType.ts

@@ -1,6 +1,5 @@
 import { ts, Type as TSMorphType, type Signature } from 'ts-morph'
 import type { Type } from './types/Type.js'
-import { NullType } from './types/NullType.js'
 import { BooleanType } from './types/BooleanType.js'
 import { NumberType } from './types/NumberType.js'
 import { StringType } from './types/StringType.js'
@@ -44,6 +43,7 @@ import {
 } from './isCoreType.js'
 import { getCustomTypeConfig } from './getCustomTypeConfig.js'
 import { compareLooselyness } from './helpers.js'
+import { NullType } from './types/NullType.js'
 
 function getHybridObjectName(type: TSMorphType): string {
   const symbol = isHybridView(type) ? type.getAliasSymbol() : type.getSymbol()
@@ -184,7 +184,7 @@ export function createType(
       return new OptionalType(wrapping)
     }
 
-    if (type.isNull() || type.isUndefined()) {
+    if (type.isNull()) {
       return new NullType()
     } else if (type.isBoolean() || type.isBooleanLiteral()) {
       return new BooleanType()
@@ -222,11 +222,10 @@ export function createType(
       // It's a function!
       const callSignature = getFunctionCallSignature(type)
       const funcReturnType = callSignature.getReturnType()
-      const returnType = createType(
-        language,
-        funcReturnType,
-        funcReturnType.isNullable()
-      )
+      const isReturnOptional = funcReturnType
+        .getUnionTypes()
+        .some((t) => t.isUndefined())
+      const returnType = createType(language, funcReturnType, isReturnOptional)
       const parameters = callSignature.getParameters().map((p) => {
         const declaration = p.getValueDeclarationOrThrow()
         const parameterType = p.getTypeAtLocation(declaration)
@@ -238,10 +237,13 @@ export function createType(
     } else if (isPromise(type)) {
       // It's a Promise!
       const [promiseResolvingType] = getArguments(type, 'Promise', 1)
+      const isResolvingOptional = promiseResolvingType
+        .getUnionTypes()
+        .some((t) => t.isUndefined())
       const resolvingType = createType(
         language,
         promiseResolvingType,
-        promiseResolvingType.isNullable()
+        isResolvingOptional
       )
       return new PromiseType(resolvingType)
     } else if (isRecord(type)) {
@@ -300,8 +302,8 @@ export function createType(
         // It consists of different types - that means it's a variant!
         let variants = type
           .getUnionTypes()
-          // Filter out any nulls or undefineds, as those are already treated as `isOptional`.
-          .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid())
+          // Filter out any undefineds/voids, as those are already treated as `isOptional`.
+          .filter((t) => !t.isUndefined() && !t.isVoid())
           .map((t) => createType(language, t, false))
           .toSorted(compareLooselyness)
         variants = removeDuplicates(variants)
@@ -354,6 +356,13 @@ export function createType(
       throw new Error(
         `String literal ${type.getText()} cannot be represented in C++ because it is ambiguous between a string and a discriminating union enum.`
       )
+    } else if (type.isUndefined()) {
+      throw new Error(
+        `The TypeScript type "undefined" cannot be represented in Nitro.\n` +
+          `- If you want to make a type optional, add \`?\` to it's name, or make it an union with \`undefined\`.\n` +
+          `- If you want a method that returns nothing, use \`void\` instead.\n` +
+          `- If you want to represent an explicit absence of a value, use \`null\` instead.`
+      )
     } else if (type.isAny()) {
       throw new Error(
         `The TypeScript type "${type.getText()}" resolved to any - any is not supported in Nitro.`

package/src/syntax/kotlin/KotlinCxxBridgedType.ts

@@ -29,7 +29,7 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
   }
 
   get hasType(): boolean {
-    return this.type.kind !== 'void' && this.type.kind !== 'null'
+    return this.type.kind !== 'void'
   }
 
   get canBePassedByReference(): boolean {
@@ -46,6 +46,16 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
         const optional = getTypeAs(this.type, OptionalType)
         return new KotlinCxxBridgedType(optional.wrappingType)
           .needsSpecialHandling
+      case 'array':
+        // Arrays need special handling if their item type needs special handling
+        const array = getTypeAs(this.type, ArrayType)
+        return new KotlinCxxBridgedType(array.itemType).needsSpecialHandling
+      case 'record':
+        // Records need special handling if their key or value type needs special handling
+        const record = getTypeAs(this.type, RecordType)
+        const keyType = new KotlinCxxBridgedType(record.keyType)
+        const valueType = new KotlinCxxBridgedType(record.valueType)
+        return keyType.needsSpecialHandling || valueType.needsSpecialHandling
       default:
         break
     }
@@ -83,6 +93,13 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             space: 'user',
           })
           break
+        case 'null':
+          imports.push({
+            language: 'c++',
+            name: `NitroModules/JNull.hpp`,
+            space: 'system',
+          })
+          break
         case 'array-buffer':
           imports.push({
             language: 'c++',
@@ -316,6 +333,13 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             return this.type.getCode(language)
         }
       }
+      case 'null':
+        switch (language) {
+          case 'c++':
+            return `JNull`
+          default:
+            return this.type.getCode(language)
+        }
       case 'array-buffer':
         switch (language) {
           case 'c++':
@@ -407,6 +431,22 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
     }
   }
 
+  dereferenceToJObject(parameterName: string): string {
+    switch (this.type.kind) {
+      // any jni::HybridClass needs to be dereferenced to jobject with .get()
+      case 'array-buffer':
+      case 'function':
+      case 'hybrid-object':
+      case 'hybrid-object-base':
+      case 'map':
+      case 'promise':
+        return `${parameterName}.get()`
+      // anything else can be dereferenced to jobject with *
+      default:
+        return `*${parameterName}`
+    }
+  }
+
   parseFromCppToKotlin(
     parameterName: string,
     language: 'kotlin' | 'c++',
@@ -454,6 +494,14 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             return parameterName
         }
       }
+      case 'null': {
+        switch (language) {
+          case 'c++':
+            return `JNull::null()`
+          default:
+            return parameterName
+        }
+      }
       case 'date': {
         switch (language) {
           case 'c++':
@@ -579,7 +627,8 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
   jni::local_ref<${arrayType}> __array = ${arrayType}::newArray(__size);
   for (size_t __i = 0; __i < __size; __i++) {
     const auto& __element = ${parameterName}[__i];
-    __array->setElement(__i, *${indent(bridge.parseFromCppToKotlin('__element', 'c++'), '    ')});
+    auto __elementJni = ${indent(bridge.parseFromCppToKotlin('__element', 'c++'), '    ')};
+    __array->setElement(__i, ${bridge.dereferenceToJObject('__elementJni')});
   }
   return __array;
 }()
@@ -589,7 +638,13 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
           }
           case 'kotlin':
             if (bridge.needsSpecialHandling) {
-              return `${parameterName}.map { ${bridge.parseFromCppToKotlin('it', language, isBoxed)} }`
+              const variableName = `${parameterName}[i]`
+              const parseCode = bridge.parseFromCppToKotlin(
+                variableName,
+                'kotlin',
+                isBoxed
+              )
+              return `Array(${parameterName}.size) { i -> ${parseCode} }`
             } else {
               return parameterName
             }
@@ -713,6 +768,14 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             return parameterName
         }
       }
+      case 'null': {
+        switch (language) {
+          case 'c++':
+            return `nitro::null`
+          default:
+            return parameterName
+        }
+      }
       case 'hybrid-object': {
         switch (language) {
           case 'c++':
@@ -820,10 +883,10 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
         }
       }
       case 'array': {
+        const array = getTypeAs(this.type, ArrayType)
+        const bridge = new KotlinCxxBridgedType(array.itemType)
         switch (language) {
-          case 'c++':
-            const array = getTypeAs(this.type, ArrayType)
-            const bridge = new KotlinCxxBridgedType(array.itemType)
+          case 'c++': {
             const itemType = array.itemType.getCode('c++')
             switch (array.itemType.kind) {
               case 'number':
@@ -856,6 +919,19 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             `.trim()
               }
             }
+          }
+          case 'kotlin':
+            if (bridge.needsSpecialHandling) {
+              const variableName = `${parameterName}[i]`
+              const parseCode = bridge.parseFromKotlinToCpp(
+                variableName,
+                'kotlin',
+                isBoxed
+              )
+              return `Array(${parameterName}.size) { i -> ${parseCode} }`
+            } else {
+              return parameterName
+            }
           default:
             return parameterName
         }

package/src/syntax/swift/SwiftCxxBridgedType.ts

@@ -45,7 +45,7 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
   }
 
   get hasType(): boolean {
-    return this.type.kind !== 'void' && this.type.kind !== 'null'
+    return this.type.kind !== 'void'
   }
 
   get canBePassedByReference(): boolean {
@@ -69,6 +69,9 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
       case 'optional':
         // swift::Optional<T> <> std::optional<T>
         return true
+      case 'null':
+        // NullType <> nitro::null
+        return true
       case 'string':
         // swift::String <> std::string
         return true
@@ -253,6 +256,13 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
             return this.type.getCode(language)
         }
       }
+      case 'null':
+        switch (language) {
+          case 'swift':
+            return 'margelo.nitro.NullType'
+          default:
+            return this.type.getCode(language)
+        }
       case 'array-buffer':
         if (this.isBridgingToDirectCppTarget) {
           return this.type.getCode(language)
@@ -433,6 +443,13 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
             return cppParameterName
         }
       }
+      case 'null':
+        switch (language) {
+          case 'swift':
+            return `NullType.null`
+          default:
+            return cppParameterName
+        }
       case 'optional': {
         const optional = getTypeAs(this.type, OptionalType)
         const wrapping = new SwiftCxxBridgedType(optional.wrappingType, true)
@@ -656,6 +673,13 @@ case ${i}:
             return swiftParameterName
         }
       }
+      case 'null':
+        switch (language) {
+          case 'swift':
+            return `margelo.nitro.NullType.null`
+          default:
+            return swiftParameterName
+        }
       case 'optional': {
         const optional = getTypeAs(this.type, OptionalType)
         const wrapping = new SwiftCxxBridgedType(optional.wrappingType, true)

package/src/syntax/types/NullType.ts

@@ -14,7 +14,11 @@ export class NullType implements Type {
   getCode(language: Language): string {
     switch (language) {
       case 'c++':
-        return 'std::nullptr_t'
+        return 'nitro::NullType'
+      case 'swift':
+        return 'NullType'
+      case 'kotlin':
+        return 'NullType'
       default:
         throw new Error(
           `Language ${language} is not yet supported for NullType!`
@@ -24,7 +28,31 @@ export class NullType implements Type {
   getExtraFiles(): SourceFile[] {
     return []
   }
-  getRequiredImports(): SourceImport[] {
-    return []
+  getRequiredImports(language: Language): SourceImport[] {
+    const imports: SourceImport[] = []
+    switch (language) {
+      case 'c++':
+        imports.push({
+          language: language,
+          name: 'NitroModules/Null.hpp',
+          space: 'system',
+        })
+        break
+      case 'swift':
+        imports.push({
+          language: language,
+          name: 'NitroModules',
+          space: 'system',
+        })
+        break
+      case 'kotlin':
+        imports.push({
+          language: language,
+          name: 'com.margelo.nitro.core.NullType',
+          space: 'system',
+        })
+        break
+    }
+    return imports
   }
 }