nitrogen 0.33.7 → 0.33.8

package/lib/syntax/createType.js

@@ -2,7 +2,7 @@ import { ts, Type as TSMorphType } from 'ts-morph';
 import { BooleanType } from './types/BooleanType.js';
 import { NumberType } from './types/NumberType.js';
 import { StringType } from './types/StringType.js';
-import { BigIntType } from './types/BigIntType.js';
+import { Int64Type } from './types/Int64Type.js';
 import { VoidType } from './types/VoidType.js';
 import { ArrayType } from './types/ArrayType.js';
 import { FunctionType } from './types/FunctionType.js';
@@ -25,10 +25,11 @@ import { getBaseTypes, getHybridObjectNitroModuleConfig } from '../utils.js';
 import { DateType } from './types/DateType.js';
 import { NitroConfig } from '../config/NitroConfig.js';
 import { CustomType } from './types/CustomType.js';
-import { isSyncFunction, isArrayBuffer, isCustomType, isDate, isError, isMap, isPromise, isRecord, } from './isCoreType.js';
+import { isSyncFunction, isArrayBuffer, isCustomType, isDate, isError, isMap, isPromise, isRecord, isInt64, isUInt64, } from './isCoreType.js';
 import { getCustomTypeConfig } from './getCustomTypeConfig.js';
 import { compareLooselyness } from './helpers.js';
 import { NullType } from './types/NullType.js';
+import { UInt64Type } from './types/UInt64Type.js';
 function getHybridObjectName(type) {
     const symbol = isHybridView(type) ? type.getAliasSymbol() : type.getSymbol();
     if (symbol == null) {
@@ -145,8 +146,11 @@ export function createType(language, type, isOptional) {
         else if (type.isString()) {
             return new StringType();
         }
-        else if (type.isBigInt() || type.isBigIntLiteral()) {
-            return new BigIntType();
+        else if (isInt64(type)) {
+            return new Int64Type();
+        }
+        else if (isUInt64(type)) {
+            return new UInt64Type();
         }
         else if (type.isVoid()) {
             return new VoidType();
@@ -309,6 +313,12 @@ export function createType(language, type, isOptional) {
         else if (type.isAny()) {
             throw new Error(`The TypeScript type "${type.getText()}" resolved to any - any is not supported in Nitro.`);
         }
+        else if (type.isBigInt()) {
+            throw new Error(`Using a bigint without specifying signedness is deprecated! Use \`Int64\` or \`UInt64\` instead.`);
+        }
+        else if (type.isLiteral()) {
+            throw new Error(`The literal "${type.getLiteralValue()}" cannot be used as a type!`);
+        }
         else {
             if (type.getSymbol() == null) {
                 // There is no declaration for it!

package/lib/syntax/helpers.js

@@ -55,7 +55,8 @@ function getTypeLooselyness(type) {
         case 'array-buffer':
             // We have `.isArrayBuffer()`
             return 0;
-        case 'bigint':
+        case 'int64':
+        case 'uint64':
             // We have `.isBigInt()`
             return 0;
         case 'boolean':

package/lib/syntax/isCoreType.d.ts

@@ -7,3 +7,5 @@ export declare function isMap(type: TSMorphType): boolean;
 export declare function isError(type: TSMorphType): boolean;
 export declare function isCustomType(type: TSMorphType): boolean;
 export declare function isSyncFunction(type: TSMorphType): boolean;
+export declare function isInt64(type: TSMorphType): boolean;
+export declare function isUInt64(type: TSMorphType): boolean;

package/lib/syntax/isCoreType.js

@@ -45,3 +45,23 @@ export function isSyncFunction(type) {
     const syncTag = type.getProperty('__syncTag');
     return syncTag != null;
 }
+export function isInt64(type) {
+    // Int64 is an intersection: `bigint & {...}`
+    const isBigInt = type.getIntersectionTypes().some((i) => i.isBigInt());
+    if (!isBigInt) {
+        // not a bigint
+        return false;
+    }
+    const signedTag = type.getProperty('__signedTag');
+    return signedTag != null;
+}
+export function isUInt64(type) {
+    // UInt64 is an intersection: `bigint & {...}`
+    const isBigInt = type.getIntersectionTypes().some((i) => i.isBigInt());
+    if (!isBigInt) {
+        // not a bigint
+        return false;
+    }
+    const unsignedTag = type.getProperty('__unsignedTag');
+    return unsignedTag != null;
+}

package/lib/syntax/kotlin/KotlinBoxedPrimitive.js

@@ -9,7 +9,10 @@ export function getKotlinBoxedPrimitiveType(type) {
             return 'jni::JDouble';
         case 'boolean':
             return 'jni::JBoolean';
-        case 'bigint':
+        case 'int64':
+            return 'jni::JLong';
+        case 'uint64':
+            // this sucks, but ULong is actually Long in JNI. We have to reinterpret it.
             return 'jni::JLong';
         default:
             throw new Error(`Type ${type.kind} is not a primitive!`);

package/lib/syntax/kotlin/KotlinCxxBridgedType.js

@@ -47,6 +47,9 @@ export class KotlinCxxBridgedType {
                 const keyType = new KotlinCxxBridgedType(record.keyType);
                 const valueType = new KotlinCxxBridgedType(record.valueType);
                 return keyType.needsSpecialHandling || valueType.needsSpecialHandling;
+            case 'uint64':
+                // ULong == Long, we need to cast
+                return true;
             default:
                 break;
         }
@@ -216,9 +219,12 @@ export class KotlinCxxBridgedType {
             case 'void':
             case 'number':
             case 'boolean':
-            case 'bigint':
+            case 'int64':
                 // primitives are not references
                 return this.getTypeCode('c++');
+            case 'uint64':
+                // ULong is unfortunately not representable in JNI. It's long + cast
+                return 'jlong';
             default:
                 return `jni::${referenceType}_ref<${this.getTypeCode('c++')}>`;
         }
@@ -226,8 +232,8 @@ export class KotlinCxxBridgedType {
     getTypeCode(language, isBoxed = false) {
         switch (this.type.kind) {
             case 'number':
-            case 'bigint':
             case 'boolean':
+            case 'int64':
                 if (isBoxed) {
                     return getKotlinBoxedPrimitiveType(this.type);
                 }
@@ -238,6 +244,21 @@ export class KotlinCxxBridgedType {
                     }
                     return this.type.getCode(language);
                 }
+            case 'uint64':
+                // ULong is unfortunately not representable in JNI. It's long + cast
+                switch (language) {
+                    case 'c++':
+                        if (isBoxed) {
+                            return 'jni::JLong';
+                        }
+                        else {
+                            return 'jlong';
+                        }
+                    case 'kotlin':
+                        return 'Long';
+                    default:
+                        return this.type.getCode(language);
+                }
             case 'array':
                 const array = getTypeAs(this.type, ArrayType);
                 const bridgedItem = new KotlinCxxBridgedType(array.itemType);
@@ -248,7 +269,10 @@ export class KotlinCxxBridgedType {
                                 return 'jni::JArrayDouble';
                             case 'boolean':
                                 return 'jni::JArrayBoolean';
-                            case 'bigint':
+                            case 'int64':
+                                return 'jni::JArrayLong';
+                            case 'uint64':
+                                // ULong is Long, we have to reinterpret cast it
                                 return 'jni::JArrayLong';
                             default:
                                 return `jni::JArrayClass<${bridgedItem.getTypeCode(language)}>`;
@@ -259,7 +283,10 @@ export class KotlinCxxBridgedType {
                                 return 'DoubleArray';
                             case 'boolean':
                                 return 'BooleanArray';
-                            case 'bigint':
+                            case 'int64':
+                                return 'LongArray';
+                            case 'uint64':
+                                // ULong is Long, we have to reinterpret cast it
                                 return 'LongArray';
                             default:
                                 return `Array<${bridgedItem.getTypeCode(language)}>`;
@@ -377,7 +404,8 @@ export class KotlinCxxBridgedType {
                             // primitives need to be boxed to make them nullable
                             case 'number':
                             case 'boolean':
-                            case 'bigint':
+                            case 'int64':
+                            case 'uint64':
                                 const boxed = getKotlinBoxedPrimitiveType(optional.wrappingType);
                                 return boxed;
                             default:
@@ -431,7 +459,8 @@ export class KotlinCxxBridgedType {
         switch (this.type.kind) {
             case 'number':
             case 'boolean':
-            case 'bigint':
+            case 'int64':
+            case 'uint64':
                 switch (language) {
                     case 'c++':
                         if (isBoxed) {
@@ -442,6 +471,14 @@ export class KotlinCxxBridgedType {
                         else {
                             return parameterName;
                         }
+                    case 'kotlin':
+                        switch (this.type.kind) {
+                            case 'uint64':
+                                // Long -> ULong
+                                return `${parameterName}.toULong()`;
+                            default:
+                                return parameterName;
+                        }
                     default:
                         return parameterName;
                 }
@@ -584,7 +621,8 @@ export class KotlinCxxBridgedType {
                         switch (array.itemType.kind) {
                             case 'number':
                             case 'boolean':
-                            case 'bigint': {
+                            case 'int64':
+                            case 'uint64': {
                                 // primitive arrays can be constructed more efficiently with region/batch access.
                                 // no need to iterate through the entire array.
                                 return `
@@ -685,9 +723,10 @@ export class KotlinCxxBridgedType {
     }
     parseFromKotlinToCpp(parameterName, language, isBoxed = false) {
         switch (this.type.kind) {
-            case 'number':
             case 'boolean':
-            case 'bigint':
+            case 'number':
+            case 'int64':
+            case 'uint64':
                 switch (language) {
                     case 'c++':
                         let code;
@@ -699,11 +738,27 @@ export class KotlinCxxBridgedType {
                             // it's just the primitive type directly
                             code = parameterName;
                         }
-                        if (this.type.kind === 'boolean') {
-                            // jboolean =/= bool (it's a char in Java)
-                            code = `static_cast<bool>(${code})`;
+                        switch (this.type.kind) {
+                            case 'boolean':
+                                // jboolean =/= bool (it's a char in Java)
+                                code = `static_cast<bool>(${code})`;
+                                break;
+                            case 'uint64':
+                                // jlong =/= uint64 (it's signed in Java)
+                                code = `static_cast<uint64_t>(${code})`;
+                                break;
+                            default:
+                                break;
                         }
                         return code;
+                    case 'kotlin':
+                        switch (this.type.kind) {
+                            case 'uint64':
+                                // ULong -> Long
+                                return `${parameterName}.toLong()`;
+                            default:
+                                return parameterName;
+                        }
                     default:
                         return parameterName;
                 }
@@ -849,7 +904,8 @@ export class KotlinCxxBridgedType {
                         switch (array.itemType.kind) {
                             case 'number':
                             case 'boolean':
-                            case 'bigint': {
+                            case 'int64':
+                            case 'uint64': {
                                 // primitive arrays can use region/batch access,
                                 // which we can use to construct the vector directly instead of looping through it.
                                 return `

package/lib/syntax/swift/SwiftVariant.js

@@ -4,7 +4,8 @@ import { getTypeAs } from '../types/getTypeAs.js';
 import { OptionalType } from '../types/OptionalType.js';
 function isPrimitive(type) {
     switch (type.kind) {
-        case 'bigint':
+        case 'int64':
+        case 'uint64':
         case 'boolean':
         case 'number':
         case 'string':

package/lib/syntax/types/ArrayType.js

@@ -27,7 +27,10 @@ export class ArrayType {
                         return 'DoubleArray';
                     case 'boolean':
                         return 'BooleanArray';
-                    case 'bigint':
+                    case 'int64':
+                        return 'LongArray';
+                    case 'uint64':
+                        // ULong is just interpret as LongArray in Java.
                         return 'LongArray';
                     default:
                         return `Array<${itemCode}>`;

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

@@ -2,6 +2,8 @@ import type { Language } from '../../getPlatformSpecs.js';
 import type { SourceFile, SourceImport } from '../SourceFile.js';
 import type { Type, TypeKind } from './Type.js';
 export declare class BigIntType implements Type {
+    private signed;
+    constructor(signed: boolean);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
     get isEquatable(): boolean;

package/lib/syntax/types/BigIntType.js

@@ -1,4 +1,8 @@
 export class BigIntType {
+    signed;
+    constructor(signed) {
+        this.signed = signed;
+    }
     get canBePassedByReference() {
         // It's a primitive.
         return false;
@@ -10,15 +14,29 @@ export class BigIntType {
         return true;
     }
     getCode(language) {
-        switch (language) {
-            case 'c++':
-                return 'int64_t';
-            case 'swift':
-                return 'Int64';
-            case 'kotlin':
-                return 'Long';
-            default:
-                throw new Error(`Language ${language} is not yet supported for BigIntType!`);
+        if (this.signed) {
+            switch (language) {
+                case 'c++':
+                    return 'int64_t';
+                case 'swift':
+                    return 'Int64';
+                case 'kotlin':
+                    return 'Long';
+                default:
+                    throw new Error(`Language ${language} is not yet supported for BigIntType!`);
+            }
+        }
+        else {
+            switch (language) {
+                case 'c++':
+                    return 'uint64_t';
+                case 'swift':
+                    return 'UInt64';
+                case 'kotlin':
+                    return 'ULong';
+                default:
+                    throw new Error(`Language ${language} is not yet supported for BigIntType!`);
+            }
         }
     }
     getExtraFiles() {

package/lib/syntax/types/Int64Type.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 Int64Type implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    get isEquatable(): boolean;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(): SourceImport[];
+}

package/lib/syntax/types/Int64Type.js

@@ -0,0 +1,30 @@
+export class Int64Type {
+    get canBePassedByReference() {
+        // It's a primitive.
+        return false;
+    }
+    get kind() {
+        return 'int64';
+    }
+    get isEquatable() {
+        return true;
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return 'int64_t';
+            case 'swift':
+                return 'Int64';
+            case 'kotlin':
+                return 'Long';
+            default:
+                throw new Error(`Language ${language} is not yet supported for Int64Type!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports() {
+        return [];
+    }
+}

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

@@ -1,6 +1,6 @@
 import type { Language } from '../../getPlatformSpecs.js';
 import type { SourceFile, SourceImport } from '../SourceFile.js';
-export type TypeKind = 'array-buffer' | 'array' | 'bigint' | 'boolean' | 'custom-type' | 'enum' | 'error' | 'function' | 'hybrid-object' | 'hybrid-object-base' | 'map' | 'null' | 'number' | 'optional' | 'promise' | 'record' | 'string' | 'struct' | 'tuple' | 'variant' | 'result-wrapper' | 'date' | 'void';
+export type TypeKind = 'array-buffer' | 'array' | 'int64' | 'uint64' | 'boolean' | 'custom-type' | 'enum' | 'error' | 'function' | 'hybrid-object' | 'hybrid-object-base' | 'map' | 'null' | 'number' | 'optional' | 'promise' | 'record' | 'string' | 'struct' | 'tuple' | 'variant' | 'result-wrapper' | 'date' | 'void';
 export interface GetCodeOptions {
     /**
      * Specifies whether the name (e.g. a C++ class name)

package/lib/syntax/types/UInt64Type.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 UInt64Type implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    get isEquatable(): boolean;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(): SourceImport[];
+}

package/lib/syntax/types/UInt64Type.js

@@ -0,0 +1,30 @@
+export class UInt64Type {
+    get canBePassedByReference() {
+        // It's a primitive.
+        return false;
+    }
+    get kind() {
+        return 'uint64';
+    }
+    get isEquatable() {
+        return true;
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return 'uint64_t';
+            case 'swift':
+                return 'UInt64';
+            case 'kotlin':
+                return 'ULong';
+            default:
+                throw new Error(`Language ${language} is not yet supported for UInt64Type!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports() {
+        return [];
+    }
+}

package/package.json

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

package/src/syntax/createType.ts

@@ -3,7 +3,7 @@ import type { Type } from './types/Type.js'
 import { BooleanType } from './types/BooleanType.js'
 import { NumberType } from './types/NumberType.js'
 import { StringType } from './types/StringType.js'
-import { BigIntType } from './types/BigIntType.js'
+import { Int64Type } from './types/Int64Type.js'
 import { VoidType } from './types/VoidType.js'
 import { ArrayType } from './types/ArrayType.js'
 import { FunctionType } from './types/FunctionType.js'
@@ -40,10 +40,13 @@ import {
   isMap,
   isPromise,
   isRecord,
+  isInt64,
+  isUInt64,
 } from './isCoreType.js'
 import { getCustomTypeConfig } from './getCustomTypeConfig.js'
 import { compareLooselyness } from './helpers.js'
 import { NullType } from './types/NullType.js'
+import { UInt64Type } from './types/UInt64Type.js'
 
 function getHybridObjectName(type: TSMorphType): string {
   const symbol = isHybridView(type) ? type.getAliasSymbol() : type.getSymbol()
@@ -205,8 +208,10 @@ export function createType(
       return new NumberType()
     } else if (type.isString()) {
       return new StringType()
-    } else if (type.isBigInt() || type.isBigIntLiteral()) {
-      return new BigIntType()
+    } else if (isInt64(type)) {
+      return new Int64Type()
+    } else if (isUInt64(type)) {
+      return new UInt64Type()
     } else if (type.isVoid()) {
       return new VoidType()
     } else if (type.isArray()) {
@@ -367,6 +372,14 @@ export function createType(
       throw new Error(
         `The TypeScript type "${type.getText()}" resolved to any - any is not supported in Nitro.`
       )
+    } else if (type.isBigInt()) {
+      throw new Error(
+        `Using a bigint without specifying signedness is deprecated! Use \`Int64\` or \`UInt64\` instead.`
+      )
+    } else if (type.isLiteral()) {
+      throw new Error(
+        `The literal "${type.getLiteralValue()}" cannot be used as a type!`
+      )
     } else {
       if (type.getSymbol() == null) {
         // There is no declaration for it!

package/src/syntax/helpers.ts

@@ -69,7 +69,8 @@ function getTypeLooselyness(type: Type): number {
     case 'array-buffer':
       // We have `.isArrayBuffer()`
       return 0
-    case 'bigint':
+    case 'int64':
+    case 'uint64':
       // We have `.isBigInt()`
       return 0
     case 'boolean':

package/src/syntax/isCoreType.ts

@@ -58,3 +58,24 @@ export function isSyncFunction(type: TSMorphType): boolean {
   const syncTag = type.getProperty('__syncTag')
   return syncTag != null
 }
+
+export function isInt64(type: TSMorphType): boolean {
+  // Int64 is an intersection: `bigint & {...}`
+  const isBigInt = type.getIntersectionTypes().some((i) => i.isBigInt())
+  if (!isBigInt) {
+    // not a bigint
+    return false
+  }
+  const signedTag = type.getProperty('__signedTag')
+  return signedTag != null
+}
+export function isUInt64(type: TSMorphType): boolean {
+  // UInt64 is an intersection: `bigint & {...}`
+  const isBigInt = type.getIntersectionTypes().some((i) => i.isBigInt())
+  if (!isBigInt) {
+    // not a bigint
+    return false
+  }
+  const unsignedTag = type.getProperty('__unsignedTag')
+  return unsignedTag != null
+}

package/src/syntax/kotlin/KotlinBoxedPrimitive.ts

@@ -11,7 +11,10 @@ export function getKotlinBoxedPrimitiveType(type: Type): string {
       return 'jni::JDouble'
     case 'boolean':
       return 'jni::JBoolean'
-    case 'bigint':
+    case 'int64':
+      return 'jni::JLong'
+    case 'uint64':
+      // this sucks, but ULong is actually Long in JNI. We have to reinterpret it.
       return 'jni::JLong'
     default:
       throw new Error(`Type ${type.kind} is not a primitive!`)

package/src/syntax/kotlin/KotlinCxxBridgedType.ts

@@ -56,6 +56,9 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
         const keyType = new KotlinCxxBridgedType(record.keyType)
         const valueType = new KotlinCxxBridgedType(record.valueType)
         return keyType.needsSpecialHandling || valueType.needsSpecialHandling
+      case 'uint64':
+        // ULong == Long, we need to cast
+        return true
       default:
         break
     }
@@ -233,9 +236,12 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
       case 'void':
       case 'number':
       case 'boolean':
-      case 'bigint':
+      case 'int64':
         // primitives are not references
         return this.getTypeCode('c++')
+      case 'uint64':
+        // ULong is unfortunately not representable in JNI. It's long + cast
+        return 'jlong'
       default:
         return `jni::${referenceType}_ref<${this.getTypeCode('c++')}>`
     }
@@ -244,8 +250,8 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
   getTypeCode(language: 'kotlin' | 'c++', isBoxed = false): string {
     switch (this.type.kind) {
       case 'number':
-      case 'bigint':
       case 'boolean':
+      case 'int64':
         if (isBoxed) {
           return getKotlinBoxedPrimitiveType(this.type)
         } else {
@@ -255,6 +261,20 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
           }
           return this.type.getCode(language)
         }
+      case 'uint64':
+        // ULong is unfortunately not representable in JNI. It's long + cast
+        switch (language) {
+          case 'c++':
+            if (isBoxed) {
+              return 'jni::JLong'
+            } else {
+              return 'jlong'
+            }
+          case 'kotlin':
+            return 'Long'
+          default:
+            return this.type.getCode(language)
+        }
       case 'array':
         const array = getTypeAs(this.type, ArrayType)
         const bridgedItem = new KotlinCxxBridgedType(array.itemType)
@@ -265,7 +285,10 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
                 return 'jni::JArrayDouble'
               case 'boolean':
                 return 'jni::JArrayBoolean'
-              case 'bigint':
+              case 'int64':
+                return 'jni::JArrayLong'
+              case 'uint64':
+                // ULong is Long, we have to reinterpret cast it
                 return 'jni::JArrayLong'
               default:
                 return `jni::JArrayClass<${bridgedItem.getTypeCode(language)}>`
@@ -276,7 +299,10 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
                 return 'DoubleArray'
               case 'boolean':
                 return 'BooleanArray'
-              case 'bigint':
+              case 'int64':
+                return 'LongArray'
+              case 'uint64':
+                // ULong is Long, we have to reinterpret cast it
                 return 'LongArray'
               default:
                 return `Array<${bridgedItem.getTypeCode(language)}>`
@@ -400,7 +426,8 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
               // primitives need to be boxed to make them nullable
               case 'number':
               case 'boolean':
-              case 'bigint':
+              case 'int64':
+              case 'uint64':
                 const boxed = getKotlinBoxedPrimitiveType(optional.wrappingType)
                 return boxed
               default:
@@ -464,7 +491,8 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
     switch (this.type.kind) {
       case 'number':
       case 'boolean':
-      case 'bigint':
+      case 'int64':
+      case 'uint64':
         switch (language) {
           case 'c++':
             if (isBoxed) {
@@ -474,6 +502,14 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             } else {
               return parameterName
             }
+          case 'kotlin':
+            switch (this.type.kind) {
+              case 'uint64':
+                // Long -> ULong
+                return `${parameterName}.toULong()`
+              default:
+                return parameterName
+            }
           default:
             return parameterName
         }
@@ -623,7 +659,8 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             switch (array.itemType.kind) {
               case 'number':
               case 'boolean':
-              case 'bigint': {
+              case 'int64':
+              case 'uint64': {
                 // primitive arrays can be constructed more efficiently with region/batch access.
                 // no need to iterate through the entire array.
                 return `
@@ -731,9 +768,10 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
     isBoxed = false
   ): string {
     switch (this.type.kind) {
-      case 'number':
       case 'boolean':
-      case 'bigint':
+      case 'number':
+      case 'int64':
+      case 'uint64':
         switch (language) {
           case 'c++':
             let code: string
@@ -744,11 +782,27 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
               // it's just the primitive type directly
               code = parameterName
             }
-            if (this.type.kind === 'boolean') {
-              // jboolean =/= bool (it's a char in Java)
-              code = `static_cast<bool>(${code})`
+            switch (this.type.kind) {
+              case 'boolean':
+                // jboolean =/= bool (it's a char in Java)
+                code = `static_cast<bool>(${code})`
+                break
+              case 'uint64':
+                // jlong =/= uint64 (it's signed in Java)
+                code = `static_cast<uint64_t>(${code})`
+                break
+              default:
+                break
             }
             return code
+          case 'kotlin':
+            switch (this.type.kind) {
+              case 'uint64':
+                // ULong -> Long
+                return `${parameterName}.toLong()`
+              default:
+                return parameterName
+            }
           default:
             return parameterName
         }
@@ -907,7 +961,8 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
             switch (array.itemType.kind) {
               case 'number':
               case 'boolean':
-              case 'bigint': {
+              case 'int64':
+              case 'uint64': {
                 // primitive arrays can use region/batch access,
                 // which we can use to construct the vector directly instead of looping through it.
                 return `

package/src/syntax/swift/SwiftVariant.ts

@@ -8,7 +8,8 @@ import type { VariantType } from '../types/VariantType.js'
 
 function isPrimitive(type: Type): boolean {
   switch (type.kind) {
-    case 'bigint':
+    case 'int64':
+    case 'uint64':
     case 'boolean':
     case 'number':
     case 'string':

package/src/syntax/types/ArrayType.ts

@@ -35,7 +35,10 @@ export class ArrayType implements Type {
             return 'DoubleArray'
           case 'boolean':
             return 'BooleanArray'
-          case 'bigint':
+          case 'int64':
+            return 'LongArray'
+          case 'uint64':
+            // ULong is just interpret as LongArray in Java.
             return 'LongArray'
           default:
             return `Array<${itemCode}>`

package/src/syntax/types/{BigIntType.ts → Int64Type.ts}

@@ -2,14 +2,14 @@ import type { Language } from '../../getPlatformSpecs.js'
 import type { SourceFile, SourceImport } from '../SourceFile.js'
 import type { Type, TypeKind } from './Type.js'
 
-export class BigIntType implements Type {
+export class Int64Type implements Type {
   get canBePassedByReference(): boolean {
     // It's a primitive.
     return false
   }
 
   get kind(): TypeKind {
-    return 'bigint'
+    return 'int64'
   }
   get isEquatable(): boolean {
     return true
@@ -25,7 +25,7 @@ export class BigIntType implements Type {
         return 'Long'
       default:
         throw new Error(
-          `Language ${language} is not yet supported for BigIntType!`
+          `Language ${language} is not yet supported for Int64Type!`
         )
     }
   }

package/src/syntax/types/Type.ts

@@ -4,7 +4,8 @@ import type { SourceFile, SourceImport } from '../SourceFile.js'
 export type TypeKind =
   | 'array-buffer'
   | 'array'
-  | 'bigint'
+  | 'int64'
+  | 'uint64'
   | 'boolean'
   | 'custom-type'
   | 'enum'

package/src/syntax/types/UInt64Type.ts

@@ -0,0 +1,38 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import type { SourceFile, SourceImport } from '../SourceFile.js'
+import type { Type, TypeKind } from './Type.js'
+
+export class UInt64Type implements Type {
+  get canBePassedByReference(): boolean {
+    // It's a primitive.
+    return false
+  }
+
+  get kind(): TypeKind {
+    return 'uint64'
+  }
+  get isEquatable(): boolean {
+    return true
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return 'uint64_t'
+      case 'swift':
+        return 'UInt64'
+      case 'kotlin':
+        return 'ULong'
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for UInt64Type!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return []
+  }
+  getRequiredImports(): SourceImport[] {
+    return []
+  }
+}