nitrogen 0.31.10 → 0.32.0

package/lib/autolinking/ios/createPodspecRubyExtension.js

@@ -52,7 +52,7 @@ def add_nitrogen_files(spec)
   spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
     # Use C++ 20
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-    # Enables C++ <-> Swift interop (by default it's only C)
+    # Enables C++ <-> Swift interop (by default it's only ObjC)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",

package/lib/index.js

@@ -67,7 +67,7 @@ await yargs(hideBin(process.argv))
     .usage(`Usage: ${chalk.bold('$0 [options]')}\n` +
     `$0 is a code-generater for Nitro Modules (${chalk.underline('https://github.com/mrousavy/nitro')})\n` +
     `It converts all TypeScript specs found in ${chalk.underline('**/*.nitro.ts')} to C++, Swift or Kotlin specs.\n` +
-    `Each library/module must have a ${chalk.underline('nitro.json')} configuration file in it's root directory.\n` +
+    `Each library/module must have a ${chalk.underline('nitro.json')} configuration file in its root directory.\n` +
     `$Nitrogen Version: ${chalk.bold(NITROGEN_VERSION)}`)
     .help()
     .strict()

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

@@ -21,16 +21,28 @@ export function createCppStruct(typename, properties) {
         includeNameInfo: false,
     };
     const cppFromJsiParams = properties
-        .map((p) => `JSIConverter<${p.getCode('c++', codeOptions)}>::fromJSI(runtime, obj.getProperty(runtime, "${p.name}"))`)
+        .map((p) => `JSIConverter<${p.getCode('c++', codeOptions)}>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "${p.name}")))`)
         .join(',\n');
     // Get C++ code for converting each member to a jsi::Value
     const cppToJsiCalls = properties
-        .map((p) => `obj.setProperty(runtime, "${p.name}", JSIConverter<${p.getCode('c++', codeOptions)}>::toJSI(runtime, arg.${p.escapedName}));`)
+        .map((p) => `obj.setProperty(runtime, PropNameIDCache::get(runtime, "${p.name}"), JSIConverter<${p.getCode('c++', codeOptions)}>::toJSI(runtime, arg.${p.escapedName}));`)
         .join('\n');
     // Get C++ code for verifying if jsi::Value can be converted to type
     const cppCanConvertCalls = properties
-        .map((p) => `if (!JSIConverter<${p.getCode('c++', codeOptions)}>::canConvert(runtime, obj.getProperty(runtime, "${p.name}"))) return false;`)
+        .map((p) => `if (!JSIConverter<${p.getCode('c++', codeOptions)}>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "${p.name}")))) return false;`)
         .join('\n');
+    // Only equatable types have an operator== overload
+    let equatableFunc;
+    const isEquatable = properties.every((p) => p.isEquatable);
+    if (isEquatable) {
+        equatableFunc = `friend bool operator==(const ${typename}& lhs, const ${typename}& rhs) = default;`;
+    }
+    else {
+        const nonEquatableTypes = properties
+            .filter((p) => !p.isEquatable)
+            .map((p) => p.name);
+        equatableFunc = `// ${typename} is not equatable because these properties are not equatable: ${nonEquatableTypes.join(', ')}`;
+    }
     // Get C++ includes for each extra-file we need to include
     const includedTypes = properties.flatMap((r) => r.getRequiredImports('c++'));
     const cppForwardDeclarations = includedTypes
@@ -49,6 +61,7 @@ ${createFileMetadataString(`${typename}.hpp`)}
 ${includeNitroHeader('JSIConverter.hpp')}
 ${includeNitroHeader('NitroDefines.hpp')}
 ${includeNitroHeader('JSIHelpers.hpp')}
+${includeNitroHeader('PropNameIDCache.hpp')}
 
 ${cppForwardDeclarations.join('\n')}
 
@@ -59,13 +72,16 @@ namespace ${cxxNamespace} {
   /**
    * A struct which can be represented as a JavaScript object (${typename}).
    */
-  struct ${typename} {
+  struct ${typename} final {
   public:
     ${indent(cppStructProps, '    ')}
 
   public:
     ${typename}() = default;
     explicit ${typename}(${cppConstructorParams}): ${cppInitializerParams} {}
+
+  public:
+    ${indent(equatableFunc, '    ')}
   };
 
 } // namespace ${cxxNamespace}

package/lib/syntax/createType.js

@@ -302,7 +302,7 @@ export function createType(language, type, isOptional) {
         }
         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 to make a type optional, add \`?\` to its 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.`);
         }

package/lib/syntax/getHybridObjectName.d.ts

@@ -11,7 +11,7 @@ export interface HybridObjectName {
     HybridT: string;
     /**
      * The name of the C++ class, Kotlin interface or Swift protocol that represents the
-     * specification (all of it's virtual properties and methods) of the Hybrid Object.
+     * specification (all of its virtual properties and methods) of the Hybrid Object.
      * @example "HybridImageSpec"
      */
     HybridTSpec: string;

package/lib/syntax/kotlin/KotlinCxxBridgedType.js

@@ -100,11 +100,6 @@ export class KotlinCxxBridgedType {
                         name: 'NitroModules/JArrayBuffer.hpp',
                         space: 'system',
                     });
-                    imports.push({
-                        language: 'c++',
-                        name: 'NitroModules/JUnit.hpp',
-                        space: 'system',
-                    });
                     break;
                 case 'promise':
                     imports.push({
@@ -112,6 +107,15 @@ export class KotlinCxxBridgedType {
                         name: 'NitroModules/JPromise.hpp',
                         space: 'system',
                     });
+                    const promiseType = getTypeAs(this.type, PromiseType);
+                    if (promiseType.resultingType.kind === 'void') {
+                        // Promise<void> uses JUnit
+                        imports.push({
+                            language: 'c++',
+                            name: 'NitroModules/JUnit.hpp',
+                            space: 'system',
+                        });
+                    }
                     break;
                 case 'date':
                     imports.push({
@@ -274,8 +278,8 @@ export class KotlinCxxBridgedType {
                 switch (language) {
                     case 'c++':
                         const recordType = getTypeAs(this.type, RecordType);
-                        const keyType = new KotlinCxxBridgedType(recordType.keyType).getTypeCode(language);
-                        const valueType = new KotlinCxxBridgedType(recordType.valueType).getTypeCode(language);
+                        const keyType = new KotlinCxxBridgedType(recordType.keyType).getTypeCode(language, true);
+                        const valueType = new KotlinCxxBridgedType(recordType.valueType).getTypeCode(language, true);
                         return `jni::JMap<${keyType}, ${valueType}>`;
                     default:
                         return this.type.getCode(language);
@@ -552,10 +556,12 @@ export class KotlinCxxBridgedType {
                         const record = getTypeAs(this.type, RecordType);
                         const key = new KotlinCxxBridgedType(record.keyType);
                         const value = new KotlinCxxBridgedType(record.valueType);
-                        const parseKey = key.parseFromCppToKotlin('__entry.first', 'c++');
-                        const parseValue = value.parseFromCppToKotlin('__entry.second', 'c++');
-                        const javaMapType = `jni::JMap<${key.getTypeCode('c++')}, ${value.getTypeCode('c++')}>`;
-                        const javaHashMapType = `jni::JHashMap<${key.getTypeCode('c++')}, ${value.getTypeCode('c++')}>`;
+                        const parseKey = key.parseFromCppToKotlin('__entry.first', 'c++', true);
+                        const parseValue = value.parseFromCppToKotlin('__entry.second', 'c++', true);
+                        const keyType = key.getTypeCode('c++', true);
+                        const valueType = value.getTypeCode('c++', true);
+                        const javaMapType = `jni::JMap<${keyType}, ${valueType}>`;
+                        const javaHashMapType = `jni::JHashMap<${keyType}, ${valueType}>`;
                         return `
 [&]() -> jni::local_ref<${javaMapType}> {
   auto __map = ${javaHashMapType}::create(${parameterName}.size());
@@ -817,8 +823,8 @@ export class KotlinCxxBridgedType {
                         const record = getTypeAs(this.type, RecordType);
                         const key = new KotlinCxxBridgedType(record.keyType);
                         const value = new KotlinCxxBridgedType(record.valueType);
-                        const parseKey = key.parseFromKotlinToCpp('__entry.first', 'c++');
-                        const parseValue = value.parseFromKotlinToCpp('__entry.second', 'c++');
+                        const parseKey = key.parseFromKotlinToCpp('__entry.first', 'c++', true);
+                        const parseValue = value.parseFromKotlinToCpp('__entry.second', 'c++', true);
                         const cxxType = this.type.getCode('c++');
                         return `
 [&]() {

package/lib/syntax/kotlin/KotlinEnum.js

@@ -20,6 +20,8 @@ import com.facebook.proguard.annotations.DoNotStrip
 @Keep
 enum class ${enumType.enumName}(@DoNotStrip @Keep val value: Int) {
   ${indent(members.join(',\n'), '  ')};
+
+  companion object
 }
   `.trim();
     const cxxNamespace = NitroConfig.current.getCxxNamespace('c++');
@@ -88,21 +90,16 @@ namespace ${cxxNamespace} {
 }
 function getCppToJniConverterCode(cppValueName, enumType) {
     const jniEnumName = `J${enumType.enumName}`;
-    const fields = enumType.enumMembers.map((m) => {
-        const fieldName = `field${capitalizeName(m.name)}`;
-        return `static const auto ${fieldName} = clazz->getStaticField<${jniEnumName}>("${m.name}");`;
-    });
     const cases = enumType.enumMembers.map((m) => {
         const fieldName = `field${capitalizeName(m.name)}`;
         return `
 case ${enumType.enumName}::${m.name}:
+  static const auto ${fieldName} = clazz->getStaticField<${jniEnumName}>("${m.name}");
   return clazz->getStaticFieldValue(${fieldName});
 `.trim();
     });
     return `
 static const auto clazz = javaClassStatic();
-${fields.join('\n')}
-
 switch (${cppValueName}) {
   ${indent(cases.join('\n'), '  ')}
   default:

package/lib/syntax/kotlin/KotlinStruct.js

@@ -51,7 +51,7 @@ data class ${structType.structName}(
 ) {
   ${indent(secondaryConstructor, '  ')}
 
-  private companion object {
+  companion object {
     /**
      * Constructor called from C++
      */

package/lib/syntax/kotlin/KotlinVariant.js

@@ -134,7 +134,7 @@ if (isInstanceOf(${namespace}::${innerName}::javaClassStatic())) {
         const innerName = capitalizeName(label);
         const descriptor = NitroConfig.current.getAndroidPackage('c++/jni', `${kotlinName}$${innerName}`);
         return `
-class ${innerName}: public jni::JavaClass<${innerName}, J${kotlinName}> {
+class ${innerName} final: public jni::JavaClass<${innerName}, J${kotlinName}> {
 public:
   static auto constexpr kJavaDescriptor = "L${descriptor};";
 

package/lib/syntax/swift/SwiftCxxTypeHelper.js

@@ -462,7 +462,7 @@ inline ${t.getCode('c++')} get_${i}() const noexcept {
  * std::variant cannot be used in Swift because of a Swift bug.
  * Not even specializing it works. So we create a wrapper struct.
  */
-struct ${name} {
+struct ${name} final {
   ${actualType} variant;
   ${name}(${actualType} variant): variant(variant) { }
   operator ${actualType}() const noexcept {

package/lib/syntax/swift/SwiftStruct.js

@@ -13,15 +13,9 @@ export function createSwiftStructBridge(struct) {
         const bridge = new SwiftCxxBridgedType(p, true);
         const cppName = `self.__${p.escapedName}`;
         return `
+@inline(__always)
 var ${p.escapedName}: ${p.getCode('swift')} {
-  @inline(__always)
-  get {
-    return ${indent(bridge.parseFromCppToSwift(cppName, 'swift'), '    ')}
-  }
-  @inline(__always)
-  set {
-    ${cppName} = ${indent(bridge.parseFromSwiftToCpp('newValue', 'swift'), '    ')}
-  }
+  return ${indent(bridge.parseFromCppToSwift(cppName, 'swift'), '  ')}
 }
     `.trim();
     })

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

@@ -5,6 +5,7 @@ export declare class AnyHybridObjectType implements Type {
     constructor();
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/AnyHybridObjectType.js

@@ -8,6 +8,9 @@ export class AnyHybridObjectType {
     get kind() {
         return 'hybrid-object-base';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

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

@@ -4,6 +4,7 @@ import type { Type, TypeKind } from './Type.js';
 export declare class ArrayBufferType implements Type {
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/ArrayBufferType.js

@@ -6,6 +6,9 @@ export class ArrayBufferType {
     get kind() {
         return 'array-buffer';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

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

@@ -6,6 +6,7 @@ export declare class ArrayType implements Type {
     constructor(itemType: Type);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language, options?: GetCodeOptions): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/ArrayType.js

@@ -11,6 +11,9 @@ export class ArrayType {
     get kind() {
         return 'array';
     }
+    get isEquatable() {
+        return this.itemType.isEquatable;
+    }
     getCode(language, options) {
         const itemCode = this.itemType.getCode(language, options);
         switch (language) {

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

@@ -4,6 +4,7 @@ import type { Type, TypeKind } from './Type.js';
 export declare class BigIntType implements Type {
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(): SourceImport[];

package/lib/syntax/types/BigIntType.js

@@ -6,6 +6,9 @@ export class BigIntType {
     get kind() {
         return 'bigint';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

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

@@ -4,6 +4,7 @@ import type { Type, TypeKind } from './Type.js';
 export declare class BooleanType implements Type {
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(): SourceImport[];

package/lib/syntax/types/BooleanType.js

@@ -6,6 +6,9 @@ export class BooleanType {
     get kind() {
         return 'boolean';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

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

@@ -8,6 +8,7 @@ export declare class CustomType implements Type {
     constructor(typeName: string, typeConfig: CustomTypeConfig);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/CustomType.js

@@ -11,6 +11,9 @@ export class CustomType {
     get kind() {
         return 'custom-type';
     }
+    get isEquatable() {
+        return false;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

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

@@ -4,6 +4,7 @@ import type { Type, TypeKind } from './Type.js';
 export declare class DateType implements Type {
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/DateType.js

@@ -6,6 +6,9 @@ export class DateType {
     get kind() {
         return 'date';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

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

@@ -17,6 +17,7 @@ export declare class EnumType implements Type {
     constructor(enumName: string, union: TSMorphType<ts.UnionType>);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language, { fullyQualified }?: GetCodeOptions): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/EnumType.js

@@ -65,6 +65,9 @@ export class EnumType {
     get kind() {
         return 'enum';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language, { fullyQualified } = {}) {
         switch (language) {
             case 'c++':

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

@@ -5,6 +5,7 @@ export declare class ErrorType implements Type {
     constructor();
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/ErrorType.js

@@ -2,12 +2,15 @@ import {} from '../SourceFile.js';
 export class ErrorType {
     constructor() { }
     get canBePassedByReference() {
-        // It's a exception<..>, pass by reference.
+        // It's an exception<..>, pass by reference.
         return true;
     }
     get kind() {
         return 'error';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

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

@@ -12,6 +12,7 @@ export declare class FunctionType implements Type {
     get jsName(): string;
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     /**
      * For a function, get the forward recreation of it:
      * If variable is called `func`, this would return:

package/lib/syntax/types/FunctionType.js

@@ -40,6 +40,9 @@ export class FunctionType {
     get kind() {
         return 'function';
     }
+    get isEquatable() {
+        return false;
+    }
     /**
      * For a function, get the forward recreation of it:
      * If variable is called `func`, this would return:

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

@@ -15,6 +15,7 @@ export declare class HybridObjectType implements Type {
     constructor(spec: HybridObjectSpec);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language, options?: GetHybridObjectCodeOptions): string;
     getExtraFiles(): SourceFile[];
     private getExternalCxxImportName;

package/lib/syntax/types/HybridObjectType.js

@@ -32,6 +32,9 @@ export class HybridObjectType {
     get kind() {
         return 'hybrid-object';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language, options = {}) {
         const name = getHybridObjectName(this.hybridObjectName);
         const mode = options.mode ?? 'strong';

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

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

package/lib/syntax/types/MapType.js

@@ -6,6 +6,9 @@ export class MapType {
     get kind() {
         return 'map';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

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

@@ -7,6 +7,7 @@ export declare class NamedWrappingType<T extends Type> implements NamedType {
     constructor(name: string, type: T);
     get escapedName(): string;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     get canBePassedByReference(): boolean;
     getCode(language: Language, options?: GetCodeOptions): string;
     getExtraFiles(): SourceFile[];

package/lib/syntax/types/NamedWrappingType.js

@@ -12,6 +12,9 @@ export class NamedWrappingType {
     get kind() {
         return this.type.kind;
     }
+    get isEquatable() {
+        return this.type.isEquatable;
+    }
     get canBePassedByReference() {
         return this.type.canBePassedByReference;
     }

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

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

package/lib/syntax/types/NullType.js

@@ -6,6 +6,9 @@ export class NullType {
     get kind() {
         return 'null';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

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

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

package/lib/syntax/types/NumberType.js

@@ -6,6 +6,9 @@ export class NumberType {
     get kind() {
         return 'number';
     }
+    get isEquatable() {
+        return true;
+    }
     getCode(language) {
         switch (language) {
             case 'c++':

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

@@ -6,6 +6,7 @@ export declare class OptionalType implements Type {
     constructor(wrappingType: Type);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     get needsBraces(): boolean;
     getCode(language: Language, options?: GetCodeOptions): string;
     getExtraFiles(): SourceFile[];

package/lib/syntax/types/OptionalType.js

@@ -11,6 +11,9 @@ export class OptionalType {
     get kind() {
         return 'optional';
     }
+    get isEquatable() {
+        return this.wrappingType.isEquatable;
+    }
     get needsBraces() {
         switch (this.wrappingType.kind) {
             case 'function':

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

@@ -8,6 +8,7 @@ export declare class PromiseType implements Type {
     constructor(resultingType: Type);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     get resolverFunction(): FunctionType;
     get rejecterFunction(): FunctionType;
     getCode(language: Language, options?: GetCodeOptions): string;

package/lib/syntax/types/PromiseType.js

@@ -17,6 +17,9 @@ export class PromiseType {
     get kind() {
         return 'promise';
     }
+    get isEquatable() {
+        return false;
+    }
     get resolverFunction() {
         if (this.resultingType.kind === 'void') {
             return new FunctionType(new VoidType(), []);

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

@@ -7,6 +7,7 @@ export declare class RecordType implements Type {
     constructor(keyType: Type, valueType: Type);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language, options?: GetCodeOptions): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/RecordType.js

@@ -13,6 +13,9 @@ export class RecordType {
     get kind() {
         return 'record';
     }
+    get isEquatable() {
+        return this.keyType.isEquatable && this.valueType.isEquatable;
+    }
     getCode(language, options) {
         const keyCode = this.keyType.getCode(language, options);
         const valueCode = this.valueType.getCode(language, options);

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

@@ -7,6 +7,7 @@ export declare class ResultWrappingType implements Type {
     constructor(result: Type);
     get canBePassedByReference(): boolean;
     get kind(): TypeKind;
+    get isEquatable(): boolean;
     getCode(language: Language, options?: GetCodeOptions): string;
     getExtraFiles(): SourceFile[];
     getRequiredImports(language: Language): SourceImport[];

package/lib/syntax/types/ResultWrappingType.js

@@ -13,6 +13,9 @@ export class ResultWrappingType {
     get kind() {
         return 'result-wrapper';
     }
+    get isEquatable() {
+        return this.result.isEquatable && this.error.isEquatable;
+    }
     getCode(language, options) {
         const type = this.result.getCode(language, options);
         switch (language) {