fix: Fix union inline joining not generating enums

packages/nitrogen/src/syntax/createType.ts

@@ -339,9 +339,8 @@ export function createType(
       // - of string literals (then it's an enum)
       // - of type `T | undefined` (then it's just optional `T`)
       // - of different types (then it's a variant `A | B | C`)
-      const unionConstituents = getUnionConstituents(type, typeNode)
-      const nonNullTypes = unionConstituents
-        .map((c) => c.type)
+      const nonNullTypes = type
+        .getUnionTypes()
         .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid())
       const isEnumUnion = nonNullTypes.every((t) => t.isStringLiteral())
       if (isEnumUnion) {
@@ -358,6 +357,7 @@ export function createType(
         return new EnumType(typename, type)
       } else {
         // It consists of different types - that means it's a variant!
+        const unionConstituents = getUnionConstituents(type, typeNode)
         let variants = unionConstituents
           // Filter out any undefineds/voids, as those are already treated as `isOptional`.
           .filter(({ type: t }) => !t.isUndefined() && !t.isVoid())

packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt

@@ -34,6 +34,7 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
   override var optionalArray: Array<String>? = null
   override var optionalEnum: Powertrain? = null
   override var optionalOldEnum: OldEnum? = null
+  override var optionalEnumPlusOne: TruckPowertrain? = null
   override var optionalCallback: ((value: Double) -> Unit)? = null
 
   override val hasBoolean = false

packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp

@@ -143,6 +143,14 @@ void HybridTestObjectCpp::setOptionalOldEnum(std::optional<OldEnum> optionalOldE
   _optionalOldEnum = optionalOldEnum;
 }
 
+std::optional<TruckPowertrain> HybridTestObjectCpp::getOptionalEnumPlusOne() {
+  return _optionalEnumPlusOne;
+}
+
+void HybridTestObjectCpp::setOptionalEnumPlusOne(std::optional<TruckPowertrain> optionalEnumPlusOne) {
+  _optionalEnumPlusOne = optionalEnumPlusOne;
+}
+
 std::optional<std::function<void(double)>> HybridTestObjectCpp::getOptionalCallback() {
   return _optionalCallback;
 }

packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp

@@ -38,6 +38,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   std::optional<std::shared_ptr<HybridTestObjectCppSpec>> _optionalHybrid;
   std::optional<Powertrain> _optionalEnum;
   std::optional<OldEnum> _optionalOldEnum;
+  std::optional<TruckPowertrain> _optionalEnumPlusOne;
   std::optional<std::function<void(double)>> _optionalCallback;
   bool _hasBooleanWritable;
   bool _isBooleanWritable;
@@ -89,6 +90,8 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   void setOptionalEnum(std::optional<Powertrain> optionalEnum) override;
   std::optional<OldEnum> getOptionalOldEnum() override;
   void setOptionalOldEnum(std::optional<OldEnum> optionalOldEnum) override;
+  std::optional<TruckPowertrain> getOptionalEnumPlusOne() override;
+  void setOptionalEnumPlusOne(std::optional<TruckPowertrain> optionalEnumPlusOne) override;
   std::optional<std::function<void(double)>> getOptionalCallback() override;
   void setOptionalCallback(const std::optional<std::function<void(double)>>& callback) override;
   bool getHasBoolean() override;

packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift

@@ -37,6 +37,8 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
 
   var optionalOldEnum: OldEnum? = nil
 
+  var optionalEnumPlusOne: TruckPowertrain? = nil
+
   var optionalCallback: ((Double) -> Void)? = nil
 
   let hasBoolean = false

packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp

@@ -13,6 +13,8 @@ namespace margelo::nitro::test { class HybridTestObjectSwiftKotlinSpec; }
 namespace margelo::nitro::test { enum class Powertrain; }
 // Forward declaration of `OldEnum` to properly resolve imports.
 namespace margelo::nitro::test { enum class OldEnum; }
+// Forward declaration of `TruckPowertrain` to properly resolve imports.
+namespace margelo::nitro::test { enum class TruckPowertrain; }
 // Forward declaration of `Person` to properly resolve imports.
 namespace margelo::nitro::test { struct Person; }
 // Forward declaration of `PartialPerson` to properly resolve imports.
@@ -60,6 +62,8 @@ namespace margelo::nitro::test { class HybridTestViewSpec; }
 #include "JPowertrain.hpp"
 #include "OldEnum.hpp"
 #include "JOldEnum.hpp"
+#include "TruckPowertrain.hpp"
+#include "JTruckPowertrain.hpp"
 #include <functional>
 #include "JFunc_void_double.hpp"
 #include <NitroModules/JNICallable.hpp>
@@ -302,6 +306,15 @@ namespace margelo::nitro::test {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JOldEnum> /* optionalOldEnum */)>("setOptionalOldEnum");
     method(_javaPart, optionalOldEnum.has_value() ? JOldEnum::fromCpp(optionalOldEnum.value()) : nullptr);
   }
+  std::optional<TruckPowertrain> JHybridTestObjectSwiftKotlinSpec::getOptionalEnumPlusOne() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JTruckPowertrain>()>("getOptionalEnumPlusOne");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridTestObjectSwiftKotlinSpec::setOptionalEnumPlusOne(std::optional<TruckPowertrain> optionalEnumPlusOne) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JTruckPowertrain> /* optionalEnumPlusOne */)>("setOptionalEnumPlusOne");
+    method(_javaPart, optionalEnumPlusOne.has_value() ? JTruckPowertrain::fromCpp(optionalEnumPlusOne.value()) : nullptr);
+  }
   std::optional<std::function<void(double /* value */)>> JHybridTestObjectSwiftKotlinSpec::getOptionalCallback() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_double::javaobject>()>("getOptionalCallback_cxx");
     auto __result = method(_javaPart);

packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp

@@ -77,6 +77,8 @@ namespace margelo::nitro::test {
     void setOptionalEnum(std::optional<Powertrain> optionalEnum) override;
     std::optional<OldEnum> getOptionalOldEnum() override;
     void setOptionalOldEnum(std::optional<OldEnum> optionalOldEnum) override;
+    std::optional<TruckPowertrain> getOptionalEnumPlusOne() override;
+    void setOptionalEnumPlusOne(std::optional<TruckPowertrain> optionalEnumPlusOne) override;
     std::optional<std::function<void(double /* value */)>> getOptionalCallback() override;
     void setOptionalCallback(const std::optional<std::function<void(double /* value */)>>& optionalCallback) override;
     bool getHasBoolean() override;

packages/react-native-nitro-test/nitrogen/generated/android/c++/JTruckPowertrain.hpp

@@ -0,0 +1,64 @@
+///
+/// JTruckPowertrain.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "TruckPowertrain.hpp"
+
+namespace margelo::nitro::test {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "TruckPowertrain" and the Kotlin enum "TruckPowertrain".
+   */
+  struct JTruckPowertrain final: public jni::JavaClass<JTruckPowertrain> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/TruckPowertrain;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum TruckPowertrain.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    TruckPowertrain toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<TruckPowertrain>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JTruckPowertrain> fromCpp(TruckPowertrain value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case TruckPowertrain::ELECTRIC:
+          static const auto fieldELECTRIC = clazz->getStaticField<JTruckPowertrain>("ELECTRIC");
+          return clazz->getStaticFieldValue(fieldELECTRIC);
+        case TruckPowertrain::GAS:
+          static const auto fieldGAS = clazz->getStaticField<JTruckPowertrain>("GAS");
+          return clazz->getStaticFieldValue(fieldGAS);
+        case TruckPowertrain::HYBRID:
+          static const auto fieldHYBRID = clazz->getStaticField<JTruckPowertrain>("HYBRID");
+          return clazz->getStaticFieldValue(fieldHYBRID);
+        case TruckPowertrain::DIESEL:
+          static const auto fieldDIESEL = clazz->getStaticField<JTruckPowertrain>("DIESEL");
+          return clazz->getStaticFieldValue(fieldDIESEL);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::test

packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt

@@ -120,6 +120,12 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
   @set:Keep
   abstract var optionalOldEnum: OldEnum?
 
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var optionalEnumPlusOne: TruckPowertrain?
+
   abstract var optionalCallback: ((value: Double) -> Unit)?
 
   private var optionalCallback_cxx: Func_void_double?

packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/TruckPowertrain.kt

@@ -0,0 +1,25 @@
+///
+/// TruckPowertrain.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "TruckPowertrain".
+ */
+@DoNotStrip
+@Keep
+enum class TruckPowertrain(@DoNotStrip @Keep val value: Int) {
+  ELECTRIC(0),
+  GAS(1),
+  HYBRID(2),
+  DIESEL(3);
+
+  companion object
+}

packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp

@@ -44,6 +44,8 @@ namespace margelo::nitro::test { struct PartialPerson; }
 namespace margelo::nitro::test { struct Person; }
 // Forward declaration of `Powertrain` to properly resolve imports.
 namespace margelo::nitro::test { enum class Powertrain; }
+// Forward declaration of `TruckPowertrain` to properly resolve imports.
+namespace margelo::nitro::test { enum class TruckPowertrain; }
 // Forward declaration of `WeirdNumbersEnum` to properly resolve imports.
 namespace margelo::nitro::test { enum class WeirdNumbersEnum; }
 // Forward declaration of `WrappedJsStruct` to properly resolve imports.
@@ -82,6 +84,7 @@ namespace NitroTest { class HybridTestViewSpec_cxx; }
 #include "PartialPerson.hpp"
 #include "Person.hpp"
 #include "Powertrain.hpp"
+#include "TruckPowertrain.hpp"
 #include "WeirdNumbersEnum.hpp"
 #include "WrappedJsStruct.hpp"
 #include <NitroModules/AnyMap.hpp>
@@ -514,6 +517,21 @@ namespace margelo::nitro::test::bridge::swift {
     return optional.value();
   }
 
+  // pragma MARK: std::optional<TruckPowertrain>
+  /**
+   * Specialized version of `std::optional<TruckPowertrain>`.
+   */
+  using std__optional_TruckPowertrain_ = std::optional<TruckPowertrain>;
+  inline std::optional<TruckPowertrain> create_std__optional_TruckPowertrain_(const TruckPowertrain& value) noexcept {
+    return std::optional<TruckPowertrain>(value);
+  }
+  inline bool has_value_std__optional_TruckPowertrain_(const std::optional<TruckPowertrain>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TruckPowertrain get_std__optional_TruckPowertrain_(const std::optional<TruckPowertrain>& optional) noexcept {
+    return optional.value();
+  }
+
   // pragma MARK: std::function<void(double /* value */)>
   /**
    * Specialized version of `std::function<void(double)>`.

packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp

@@ -48,6 +48,8 @@ namespace margelo::nitro::test { struct Person; }
 namespace margelo::nitro::test { enum class Powertrain; }
 // Forward declaration of `SecondMapWrapper` to properly resolve imports.
 namespace margelo::nitro::test { struct SecondMapWrapper; }
+// Forward declaration of `TruckPowertrain` to properly resolve imports.
+namespace margelo::nitro::test { enum class TruckPowertrain; }
 // Forward declaration of `WeirdNumbersEnum` to properly resolve imports.
 namespace margelo::nitro::test { enum class WeirdNumbersEnum; }
 // Forward declaration of `WrappedJsStruct` to properly resolve imports.
@@ -73,6 +75,7 @@ namespace margelo::nitro::test { struct WrappedJsStruct; }
 #include "Person.hpp"
 #include "Powertrain.hpp"
 #include "SecondMapWrapper.hpp"
+#include "TruckPowertrain.hpp"
 #include "WeirdNumbersEnum.hpp"
 #include "WrappedJsStruct.hpp"
 #include <NitroModules/AnyMap.hpp>

packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp

@@ -18,6 +18,8 @@ namespace margelo::nitro::test { class HybridTestObjectSwiftKotlinSpec; }
 namespace margelo::nitro::test { enum class Powertrain; }
 // Forward declaration of `OldEnum` to properly resolve imports.
 namespace margelo::nitro::test { enum class OldEnum; }
+// Forward declaration of `TruckPowertrain` to properly resolve imports.
+namespace margelo::nitro::test { enum class TruckPowertrain; }
 // Forward declaration of `Person` to properly resolve imports.
 namespace margelo::nitro::test { struct Person; }
 // Forward declaration of `PartialPerson` to properly resolve imports.
@@ -62,6 +64,7 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; }
 #include <vector>
 #include "Powertrain.hpp"
 #include "OldEnum.hpp"
+#include "TruckPowertrain.hpp"
 #include <functional>
 #include <NitroModules/Promise.hpp>
 #include "Person.hpp"
@@ -224,6 +227,13 @@ namespace margelo::nitro::test {
     inline void setOptionalOldEnum(std::optional<OldEnum> optionalOldEnum) noexcept override {
       _swiftPart.setOptionalOldEnum(optionalOldEnum);
     }
+    inline std::optional<TruckPowertrain> getOptionalEnumPlusOne() noexcept override {
+      auto __result = _swiftPart.getOptionalEnumPlusOne();
+      return __result;
+    }
+    inline void setOptionalEnumPlusOne(std::optional<TruckPowertrain> optionalEnumPlusOne) noexcept override {
+      _swiftPart.setOptionalEnumPlusOne(optionalEnumPlusOne);
+    }
     inline std::optional<std::function<void(double /* value */)>> getOptionalCallback() noexcept override {
       auto __result = _swiftPart.getOptionalCallback();
       return __result;

packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift

@@ -25,6 +25,7 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: HybridObject {
   var optionalArray: [String]? { get set }
   var optionalEnum: Powertrain? { get set }
   var optionalOldEnum: OldEnum? { get set }
+  var optionalEnumPlusOne: TruckPowertrain? { get set }
   var optionalCallback: ((_ value: Double) -> Void)? { get set }
   var hasBoolean: Bool { get }
   var isBoolean: Bool { get }

packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift

@@ -282,7 +282,7 @@
     get {
       return { () -> bridge.std__variant_nitro__NullType__std__string_ in
         switch self.__implementation.stringOrNull {
           case .first(let __value):
             return bridge.create_std__variant_nitro__NullType__std__string_(margelo.nitro.NullType.null)
           case .second(let __value):
             return bridge.create_std__variant_nitro__NullType__std__string_(std.string(__value))
@@ -295,7 +295,7 @@
         let __variant = newValue
         switch __variant.index() {
           case 0:
             let __actual = __variant.get_0()
             return .first(NullType.null)
           case 1:
             let __actual = __variant.get_1()
@@ -371,6 +371,23 @@
     }
   }
 
+  public final var optionalEnumPlusOne: bridge.std__optional_TruckPowertrain_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_TruckPowertrain_ in
+        if let __unwrappedValue = self.__implementation.optionalEnumPlusOne {
+          return bridge.create_std__optional_TruckPowertrain_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.optionalEnumPlusOne = newValue.value
+    }
+  }
+
   public final var optionalCallback: bridge.std__optional_std__function_void_double____value______ {
     @inline(__always)
     get {
@@ -594,7 +611,7 @@
   @inline(__always)
   public final func bounceNull(value: margelo.nitro.NullType) -> bridge.Result_nitro__NullType_ {
     do {
       let __result = try self.__implementation.bounceNull(value: NullType.null)
       let __resultCpp = margelo.nitro.NullType.null
       return bridge.create_Result_nitro__NullType_(__resultCpp)
     } catch (let __error) {

packages/react-native-nitro-test/nitrogen/generated/ios/swift/TruckPowertrain.swift

@@ -0,0 +1,48 @@
+///
+/// TruckPowertrain.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `TruckPowertrain`, backed by a C++ enum.
+ */
+public typealias TruckPowertrain = margelo.nitro.test.TruckPowertrain
+
+public extension TruckPowertrain {
+  /**
+   * Get a TruckPowertrain for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "electric":
+        self = .electric
+      case "gas":
+        self = .gas
+      case "hybrid":
+        self = .hybrid
+      case "diesel":
+        self = .diesel
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this TruckPowertrain represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .electric:
+        return "electric"
+      case .gas:
+        return "gas"
+      case .hybrid:
+        return "hybrid"
+      case .diesel:
+        return "diesel"
+    }
+  }
+}

packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp

@@ -43,6 +43,8 @@ namespace margelo::nitro::test {
       prototype.registerHybridSetter("optionalEnum", &HybridTestObjectCppSpec::setOptionalEnum);
       prototype.registerHybridGetter("optionalOldEnum", &HybridTestObjectCppSpec::getOptionalOldEnum);
       prototype.registerHybridSetter("optionalOldEnum", &HybridTestObjectCppSpec::setOptionalOldEnum);
+      prototype.registerHybridGetter("optionalEnumPlusOne", &HybridTestObjectCppSpec::getOptionalEnumPlusOne);
+      prototype.registerHybridSetter("optionalEnumPlusOne", &HybridTestObjectCppSpec::setOptionalEnumPlusOne);
       prototype.registerHybridGetter("optionalCallback", &HybridTestObjectCppSpec::getOptionalCallback);
       prototype.registerHybridSetter("optionalCallback", &HybridTestObjectCppSpec::setOptionalCallback);
       prototype.registerHybridGetter("hasBoolean", &HybridTestObjectCppSpec::getHasBoolean);