nitrogen 0.29.8 → 0.30.1

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

@@ -0,0 +1,23 @@
+import { type NitroConfig } from '../../config/NitroConfig.js';
+import type { Language } from '../../getPlatformSpecs.js';
+import type { HybridObjectSpec } from '../HybridObjectSpec.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+interface GetHybridObjectCodeOptions extends GetCodeOptions {
+    mode?: 'strong' | 'weak';
+}
+export declare class HybridObjectType implements Type {
+    readonly hybridObjectName: string;
+    readonly implementationLanguage: Language;
+    readonly baseTypes: HybridObjectType[];
+    readonly sourceConfig: NitroConfig;
+    constructor(hybridObjectName: string, implementationLanguage: Language, baseTypes: HybridObjectType[], sourceConfig: NitroConfig);
+    constructor(spec: HybridObjectSpec);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, options?: GetHybridObjectCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    private getExternalCxxImportName;
+    getRequiredImports(language: Language): SourceImport[];
+}
+export {};

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

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

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

@@ -0,0 +1,14 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js';
+export declare class NamedWrappingType<T extends Type> implements NamedType {
+    readonly type: T;
+    readonly name: string;
+    constructor(name: string, type: T);
+    get escapedName(): string;
+    get kind(): TypeKind;
+    get canBePassedByReference(): boolean;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import { FunctionType } from './FunctionType.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+export declare class PromiseType implements Type {
+    readonly resultingType: Type;
+    readonly errorType: Type;
+    constructor(resultingType: Type);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    get resolverFunction(): FunctionType;
+    get rejecterFunction(): FunctionType;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type FileWithReferencedTypes, type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js';
+export declare class StructType implements Type {
+    readonly structName: string;
+    readonly properties: NamedType[];
+    readonly declarationFile: FileWithReferencedTypes;
+    constructor(structName: string, properties: NamedType[]);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, { fullyQualified }?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

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

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

@@ -0,0 +1,55 @@
+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 interface GetCodeOptions {
+    /**
+     * Specifies whether the name (e.g. a C++ class name)
+     * should use the fully qualified namespace name prefix.
+     */
+    fullyQualified?: boolean;
+}
+/**
+ * Represents a TypeScript Type that can be represented in a native language (C++, Swift, Kotlin)
+ */
+export interface Type {
+    /**
+     * Get whether this type can be passed by reference in C++ (`const T&` vs `T`)
+     */
+    readonly canBePassedByReference: boolean;
+    /**
+     * Get the kind of the type.
+     */
+    readonly kind: TypeKind;
+    /**
+     * Get the native code required to represent this type for the given language (C++, Swift, Kotlin).
+     *
+     * E.g. for a `number` type, this would return `'double'` in C++.
+     *
+     * The `options` parameter can specify custom options. Subclasses may have more options.
+     */
+    getCode(language: Language, options?: GetCodeOptions): string;
+    /**
+     * Get all required extra files that need to be **created** for this type to properly work.
+     *
+     * E.g. for `type Gender = 'male' | 'female'`, the enum `Gender` needs to be created first (as a separate file).
+     */
+    getExtraFiles(): SourceFile[];
+    /**
+     * Get all required extra imports that need to be **imported** for this type to properly work.
+     */
+    getRequiredImports(language: Language): SourceImport[];
+}
+export interface NamedType extends Type {
+    /**
+     * Get the name of the value if it is a member or parameter.
+     *
+     * E.g. for a class member `double _something`, this returns `'_something'`.
+     */
+    readonly name: string;
+    /**
+     * Get the name of the value escaped as a valid C++ variable name.
+     *
+     * E.g. for a class member `double some-value`, this returns `'some_value'`.
+     */
+    readonly escapedName: string;
+}

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

@@ -0,0 +1,19 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+export declare const VariantLabels: readonly ["first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eigth", "ninth", "tenth"];
+type VariantLabel = (typeof VariantLabels)[number];
+export declare class VariantType implements Type {
+    readonly variants: Type[];
+    readonly aliasName?: string;
+    constructor(variants: Type[], aliasName?: string);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    get jsType(): string;
+    get cases(): [VariantLabel, Type][];
+    getAliasName(language: Language, options?: GetCodeOptions): string;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}
+export {};

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

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

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

@@ -0,0 +1,2 @@
+import type { Type } from './Type.js';
+export declare function getTypeAs<T>(type: Type, classReference: new (...args: any[]) => T): T;

package/lib/utils.d.ts

@@ -0,0 +1,22 @@
+import type { SourceFile } from './syntax/SourceFile.js';
+import type { SwiftCxxHelper } from './syntax/swift/SwiftCxxTypeHelper.js';
+import type { Type } from 'ts-morph';
+import { NitroConfig } from './config/NitroConfig.js';
+export declare const NITROGEN_VERSION: string;
+export declare function capitalizeName(name: string): string;
+export declare function createIndentation(spacesCount: number): string;
+export declare function indent(string: string, spacesCount: number): string;
+export declare function indent(string: string, indentation: string): string;
+export declare function errorToString(error: unknown): string;
+export declare function escapeComments(string: string): string;
+export declare function toUnixPath(p: string): string;
+export declare function unsafeFastJoin(...segments: string[]): string;
+/**
+ * Deduplicates all files via their full path.
+ * If content differs, you are f*cked.
+ */
+export declare function deduplicateFiles(files: SourceFile[]): SourceFile[];
+export declare function filterDuplicateHelperBridges(bridge: SwiftCxxHelper, i: number, array: SwiftCxxHelper[]): boolean;
+export declare function toLowerCamelCase(string: string): string;
+export declare function getBaseTypes(type: Type): Type[];
+export declare function getHybridObjectNitroModuleConfig(type: Type): NitroConfig | undefined;

package/lib/views/CppHybridViewComponent.d.ts

@@ -0,0 +1,14 @@
+import type { SourceFile } from '../syntax/SourceFile.js';
+import type { HybridObjectSpec } from '../syntax/HybridObjectSpec.js';
+interface ViewComponentNames {
+    propsClassName: `${string}Props`;
+    stateClassName: `${string}State`;
+    nameVariable: `${string}ComponentName`;
+    shadowNodeClassName: `${string}ShadowNode`;
+    descriptorClassName: `${string}ComponentDescriptor`;
+    component: `${string}Component`;
+    manager: `${string}Manager`;
+}
+export declare function getViewComponentNames(spec: HybridObjectSpec): ViewComponentNames;
+export declare function createViewComponentShadowNodeFiles(spec: HybridObjectSpec): SourceFile[];
+export {};

package/lib/views/createHostComponentJs.d.ts

@@ -0,0 +1,3 @@
+import type { HybridObjectSpec } from '../syntax/HybridObjectSpec.js';
+import type { SourceFile } from '../syntax/SourceFile.js';
+export declare function createHostComponentJs(spec: HybridObjectSpec): SourceFile[];

package/lib/views/kotlin/KotlinHybridViewManager.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+import type { HybridObjectSpec } from '../../syntax/HybridObjectSpec.js';
+export declare function createKotlinHybridViewManager(spec: HybridObjectSpec): SourceFile[];

package/lib/views/swift/SwiftHybridViewManager.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+import type { HybridObjectSpec } from '../../syntax/HybridObjectSpec.js';
+export declare function createSwiftHybridViewManager(spec: HybridObjectSpec): SourceFile[];

package/lib/writeFile.d.ts

@@ -0,0 +1,5 @@
+import type { SourceFile } from './syntax/SourceFile.js';
+/**
+ * Writes the given file to disk and returns it's actual path.
+ */
+export declare function writeFile(basePath: string, file: SourceFile): Promise<string>;

package/package.json

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

package/src/init.ts

@@ -70,7 +70,7 @@ async function isGitInstalled(): Promise<boolean> {
   try {
     execSync('git --version')
     return true
-  } catch (error) {
+  } catch {
     return false
   }
 }

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

@@ -69,6 +69,7 @@ ${createFileMetadataString(`${typename}.hpp`)}
 
 ${includeNitroHeader('JSIConverter.hpp')}
 ${includeNitroHeader('NitroDefines.hpp')}
+${includeNitroHeader('JSIHelpers.hpp')}
 
 ${cppForwardDeclarations.join('\n')}
 
@@ -111,6 +112,9 @@ namespace margelo::nitro {
         return false;
       }
       jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
       ${indent(cppCanConvertCalls, '      ')}
       return true;
     }

package/src/syntax/kotlin/KotlinCxxBridgedType.ts

@@ -41,10 +41,6 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
       case 'function':
         // Function needs to be converted from JFunc_... to Lambda
         return true
-      case 'struct':
-        // Structs don't need special handling - they have direct mappings
-        // Returning false prevents secondary constructor generation that causes duplicates
-        return false
       case 'optional':
         // Optionals need special handling if the wrapped type needs special handling
         const optional = getTypeAs(this.type, OptionalType)
@@ -53,16 +49,6 @@ export class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
       default:
         break
     }
-    // check if any types this type references (e.g. underlying optional, array element, ...)
-    // needs special handling. if yes, we need it as well
-    const referencedTypes = getReferencedTypes(this.type)
-      .filter((t) => t !== this.type)
-      .map((t) => new KotlinCxxBridgedType(t))
-    for (const type of referencedTypes) {
-      if (type.needsSpecialHandling) {
-        return true
-      }
-    }
     // no special handling needed
     return false
   }

package/src/syntax/kotlin/KotlinHybridObject.ts

@@ -95,7 +95,7 @@ abstract class ${name.HybridTSpec}: ${kotlinBase}() {
   private external fun initHybrid(): HybridData
 
   companion object {
-    private const val TAG = "${name.HybridTSpec}"
+    protected const val TAG = "${name.HybridTSpec}"
   }
 }
   `.trim()

package/src/syntax/kotlin/KotlinStruct.ts

@@ -9,42 +9,28 @@ import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
 
 export function createKotlinStruct(structType: StructType): SourceFile[] {
   const packageName = NitroConfig.current.getAndroidPackage('java/kotlin')
-  const values = structType.properties.map((p) => {
-    const bridged = new KotlinCxxBridgedType(p)
-    return `
+  const parameters = structType.properties
+    .map((p) =>
+      `
 @DoNotStrip
 @Keep
-val ${p.escapedName}: ${bridged.getTypeCode('kotlin', false)}
+val ${p.escapedName}: ${p.getCode('kotlin')}
 `.trim()
-  })
-  let secondaryConstructor: string
-  const needsSpecialHandling = structType.properties.some(
-    (p) => new KotlinCxxBridgedType(p).needsSpecialHandling
-  )
-  if (needsSpecialHandling) {
-    // If we need special handling for any of our properties, we need to add a convenience initializer.
-    const params = structType.properties.map(
-      (p) => `${p.escapedName}: ${p.getCode('kotlin')}`
     )
-    const paramsForward = structType.properties.map((p) => {
+    .join(',\n')
+
+  const cxxCreateFunctionParameters = structType.properties
+    .map((p) => {
       const bridged = new KotlinCxxBridgedType(p)
-      if (bridged.needsSpecialHandling) {
-        // We need special parsing for this type
-        return bridged.parseFromKotlinToCpp(p.escapedName, 'kotlin', false)
-      } else {
-        return p.escapedName
-      }
+      return `${p.escapedName}: ${bridged.getTypeCode('kotlin', false)}`
     })
-    secondaryConstructor = `
-/**
- * Initialize a new instance of \`${structType.structName}\` from Kotlin.
- */
-constructor(${indent(params.join(', '), 12)})
-     : this(${indent(paramsForward.join(', '), 12)})
-    `.trim()
-  } else {
-    secondaryConstructor = `/* main constructor */`
-  }
+    .join(', ')
+  const cxxCreateFunctionForward = structType.properties
+    .map((p) => {
+      const bridged = new KotlinCxxBridgedType(p)
+      return bridged.parseFromCppToKotlin(p.escapedName, 'kotlin', false)
+    })
+    .join(', ')
 
   const extraImports = structType.properties
     .flatMap((t) => t.getRequiredImports('kotlin'))
@@ -65,13 +51,21 @@ ${extraImports.join('\n')}
  */
 @DoNotStrip
 @Keep
-data class ${structType.structName}
-  @DoNotStrip
-  @Keep
-  constructor(
-    ${indent(values.join(',\n'), '    ')}
-  ) {
-  ${indent(secondaryConstructor, '  ')}
+data class ${structType.structName}(
+  ${indent(parameters, '  ')}
+) {
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(${cxxCreateFunctionParameters}): ${structType.structName} {
+      return ${structType.structName}(${cxxCreateFunctionForward})
+    }
+  }
 }
   `.trim()
 
@@ -185,14 +179,27 @@ function createCppStructInitializer(
   cppValueName: string,
   structType: StructType
 ): string {
-  const lines: string[] = []
-  lines.push(`return newInstance(`)
-  const names = structType.properties.map((p) => {
-    const name = `${cppValueName}.${p.escapedName}`
-    const bridge = new KotlinCxxBridgedType(p)
-    return bridge.parse(name, 'c++', 'kotlin', 'c++')
-  })
-  lines.push(`  ${indent(names.join(',\n'), '  ')}`)
-  lines.push(');')
-  return lines.join('\n')
+  const jniTypes = structType.properties
+    .map((p) => {
+      const bridge = new KotlinCxxBridgedType(p)
+      return bridge.asJniReferenceType('alias')
+    })
+    .join(', ')
+  const params = structType.properties
+    .map((p) => {
+      const name = `${cppValueName}.${p.escapedName}`
+      const bridge = new KotlinCxxBridgedType(p)
+      return bridge.parse(name, 'c++', 'kotlin', 'c++')
+    })
+    .join(',\n')
+
+  return `
+using JSignature = J${structType.structName}(${jniTypes});
+static const auto clazz = javaClassStatic();
+static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+return create(
+  clazz,
+  ${indent(params, '  ')}
+);
+  `.trim()
 }

package/src/syntax/kotlin/KotlinVariant.ts

@@ -7,19 +7,21 @@ import {
   toReferenceType,
 } from '../helpers.js'
 import type { SourceFile } from '../SourceFile.js'
+import { OptionalType } from '../types/OptionalType.js'
 import { type VariantType } from '../types/VariantType.js'
 import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js'
 
 export function createKotlinVariant(variant: VariantType): SourceFile[] {
-  const jsName = variant.variants.map((v) => v.getCode('kotlin')).join('|')
+  const jsName = variant.variants.map((v) => v.getCode('kotlin')).join(' | ')
   const kotlinName = variant.getAliasName('kotlin')
   const namespace = `J${kotlinName}_impl`
 
   const innerClasses = variant.cases.map(([label, v]) => {
     const innerName = capitalizeName(label)
+    const bridge = new KotlinCxxBridgedType(v)
     return `
 @DoNotStrip
-data class ${innerName}(@DoNotStrip val value: ${v.getCode('kotlin')}): ${kotlinName}()
+data class ${innerName}(@DoNotStrip val value: ${bridge.getTypeCode('kotlin')}): ${kotlinName}()
       `.trim()
   })
 
@@ -35,14 +37,36 @@ val is${innerName}: Boolean
   get() = this is ${innerName}
     `.trim()
   })
+  const asFunctions = variant.cases.map(([label, v]) => {
+    const innerName = capitalizeName(label)
+    const bridge = new KotlinCxxBridgedType(v)
+    const optional = new OptionalType(v)
+    return `
+fun as${innerName}OrNull(): ${optional.getCode('kotlin')} {
+  val value = (this as? ${innerName})?.value ?: return null
+  return ${bridge.parseFromCppToKotlin('value', 'kotlin')}
+}
+    `.trim()
+  })
+  const matchParameters = variant.cases.map(([label, v]) => {
+    return `${label}: (${v.getCode('kotlin')}) -> R`
+  })
+  const matchCases = variant.cases.map(([label, v]) => {
+    const innerName = capitalizeName(label)
+    const bridge = new KotlinCxxBridgedType(v)
+    return `
+is ${innerName} -> ${label}(${bridge.parseFromCppToKotlin('value', 'kotlin')})
+    `.trim()
+  })
 
   const createFunctions = variant.cases.map(([label, v]) => {
+    const bridge = new KotlinCxxBridgedType(v)
     const innerName = capitalizeName(label)
     return `
 @JvmStatic
 @DoNotStrip
-fun create(value: ${v.getCode('kotlin')}): ${kotlinName} = ${innerName}(value)
-    `.trim()
+fun create(value: ${bridge.getTypeCode('kotlin')}): ${kotlinName} = ${innerName}(${bridge.parseFromCppToKotlin('value', 'kotlin')})
+`.trim()
   })
 
   const extraImports = variant.variants
@@ -65,12 +89,21 @@ ${extraImports.join('\n')}
 sealed class ${kotlinName} {
   ${indent(innerClasses.join('\n'), '  ')}
 
+  @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR)
   inline fun <reified T> getAs(): T? = when (this) {
     ${indent(getterCases.join('\n'), '    ')}
   }
 
   ${indent(isFunctions.join('\n'), '  ')}
 
+  ${indent(asFunctions.join('\n'), '  ')}
+
+  inline fun <R> match(${matchParameters.join(', ')}): R {
+    return when (this) {
+      ${indent(matchCases.join('\n'), '      ')}
+    }
+  }
+
   companion object {
     ${indent(createFunctions.join('\n'), '    ')}
   }