diff --git a/ets2panda/checker/ETSchecker.cpp b/ets2panda/checker/ETSchecker.cpp
index ce5dd58750cf2af73e27ba167dafc524205d481a..fa504c4e41dae37fdd9b966a8361ea5d0f9b0d4a 100644
--- a/ets2panda/checker/ETSchecker.cpp
+++ b/ets2panda/checker/ETSchecker.cpp
@@ -696,6 +696,11 @@ const GlobalArraySignatureMap &ETSChecker::GlobalArrayTypes() const
     return globalArraySignatures_;
 }
 
+const ArenaSet<ETSUnionType *> &ETSChecker::UnionAssemblerTypes() const
+{
+    return unionAssemblerTypes_;
+}
+
 Type *ETSChecker::GlobalTypeError() const
 {
     return GetGlobalTypesHolder()->GlobalTypeError();
diff --git a/ets2panda/checker/ETSchecker.h b/ets2panda/checker/ETSchecker.h
index 7de58a472eae05ef500ffe336b287abbca60f4b6..383840caa39dee4193c1b870a84eb0bb258244c7 100644
--- a/ets2panda/checker/ETSchecker.h
+++ b/ets2panda/checker/ETSchecker.h
@@ -92,6 +92,7 @@ public:
           invokeToArrowSignatures_(Allocator()->Adapter()),
           arrowToFuncInterfaces_(Allocator()->Adapter()),
           globalArraySignatures_(Allocator()->Adapter()),
+          unionAssemblerTypes_(Allocator()->Adapter()),
           dynamicIntrinsics_ {DynamicCallIntrinsicsMap {Allocator()->Adapter()},
                               DynamicCallIntrinsicsMap {Allocator()->Adapter()}},
           dynamicClasses_ {DynamicClassIntrinsicsMap(Allocator()->Adapter()),
@@ -171,6 +172,8 @@ public:
     GlobalArraySignatureMap &GlobalArrayTypes();
     const GlobalArraySignatureMap &GlobalArrayTypes() const;
 
+    const ArenaSet<ETSUnionType *> &UnionAssemblerTypes() const;
+
     Type *GlobalTypeError() const;
     [[nodiscard]] Type *InvalidateType(ir::Typed<ir::AstNode> *node);
     [[nodiscard]] Type *TypeError(ir::Typed<ir::AstNode> *node, const diagnostic::DiagnosticKind &diagKind,
@@ -900,6 +903,7 @@ public:
         pendingConstraintCheckRecords_.clear();
         constraintCheckScopesCount_ = 0;
         globalArraySignatures_.clear();
+        unionAssemblerTypes_.clear();
         GetCachedComputedAbstracts()->clear();
         for (auto &dynamicCallIntrinsicsMap : dynamicIntrinsics_) {
             dynamicCallIntrinsicsMap.clear();
@@ -1058,6 +1062,7 @@ private:
     FunctionInterfaceMap arrowToFuncInterfaces_;
     size_t constraintCheckScopesCount_ {0};
     GlobalArraySignatureMap globalArraySignatures_;
+    ArenaSet<ETSUnionType *> unionAssemblerTypes_;
     ComputedAbstracts *cachedComputedAbstracts_ {nullptr};
     // NOTE(aleksisch): Extract dynamic from checker to separate class
     std::array<DynamicCallIntrinsicsMap, 2U> dynamicIntrinsics_;
diff --git a/ets2panda/checker/ets/typeCheckingHelpers.cpp b/ets2panda/checker/ets/typeCheckingHelpers.cpp
index dbb75b798a849302374059a73d7fa529b303e345..eace7633ab5af3d8b557d3b29f09aa9c763560e7 100644
--- a/ets2panda/checker/ets/typeCheckingHelpers.cpp
+++ b/ets2panda/checker/ets/typeCheckingHelpers.cpp
@@ -649,8 +649,7 @@ Type *ETSChecker::ResolveUnionUncheckedType(ArenaVector<checker::Type *> &&appar
     }
     auto *unionType = CreateETSUnionType(std::move(apparentTypes));
     if (unionType->IsETSUnionType()) {
-        checker::Type *typeLUB = unionType->AsETSUnionType()->GetAssemblerLUB();
-        return typeLUB;
+        return unionType->AsETSUnionType();
     }
     // Is case of single apparent type, just return itself
     return unionType;
diff --git a/ets2panda/checker/ets/typeCreation.cpp b/ets2panda/checker/ets/typeCreation.cpp
index 1c8c6c9a98910a1e00c65c7f932c68aaca91f26f..c4ef7ae5d8f3dd69e699f49c9b5aa2c091cfe2f6 100644
--- a/ets2panda/checker/ets/typeCreation.cpp
+++ b/ets2panda/checker/ets/typeCreation.cpp
@@ -137,8 +137,9 @@ Type *ETSChecker::CreateETSUnionType(Span<Type *const> constituentTypes)
     if (newConstituentTypes.size() == 1) {
         return newConstituentTypes[0];
     }
-
-    return ProgramAllocator()->New<ETSUnionType>(this, std::move(newConstituentTypes));
+    auto *un = ProgramAllocator()->New<ETSUnionType>(this, std::move(newConstituentTypes));
+    unionAssemblerTypes_.insert(un);
+    return un;
 }
 
 ETSTypeAliasType *ETSChecker::CreateETSTypeAliasType(util::StringView name, const ir::AstNode *declNode,
diff --git a/ets2panda/checker/types/ets/etsUnionType.cpp b/ets2panda/checker/types/ets/etsUnionType.cpp
index cb112121c82df4692d0fcbafdbee36da4bc05c13..b701f412e4d510b03e98cb98dffb31c46fcf9850 100644
--- a/ets2panda/checker/types/ets/etsUnionType.cpp
+++ b/ets2panda/checker/types/ets/etsUnionType.cpp
@@ -34,74 +34,119 @@ void ETSUnionType::ToString(std::stringstream &ss, bool precise) const
 
 void ETSUnionType::ToAssemblerType(std::stringstream &ss) const
 {
-    assemblerLub_->ToAssemblerTypeWithRank(ss);
+    ss << GetAssemblerType();
 }
 
 void ETSUnionType::ToDebugInfoType(std::stringstream &ss) const
 {
-    assemblerLub_->ToDebugInfoType(ss);
-}
-
-ETSUnionType::ETSUnionType(ETSChecker *checker, ArenaVector<Type *> &&constituentTypes)
-    : Type(TypeFlag::ETS_UNION), constituentTypes_(std::move(constituentTypes))
-{
-    ES2PANDA_ASSERT(constituentTypes_.size() > 1);
-    assemblerLub_ = ComputeAssemblerLUB(checker, this);
+    if (assemblerConstituentTypes_.size() == 1) {
+        assemblerConstituentTypes_[0]->ToDebugInfoType(ss);
+        return;
+    }
+    ss << "{U";
+    for (size_t idx = 0; idx < assemblerConstituentTypes_.size(); idx++) {
+        assemblerConstituentTypes_[idx]->ToDebugInfoType(ss);
+        if (idx != assemblerConstituentTypes_.size() - 1) {
+            ss << ",";
+        }
+    }
+    ss << "}";
 }
 
-bool ETSUnionType::EachTypeRelatedToSomeType(TypeRelation *relation, ETSUnionType *source, ETSUnionType *target)
+static std::string GetAssemblerTypeString(Type *type)
 {
-    return std::all_of(source->constituentTypes_.begin(), source->constituentTypes_.end(),
-                       [relation, target](auto *s) { return TypeRelatedToSomeType(relation, s, target); });
+    std::stringstream ss;
+    type->ToAssemblerTypeWithRank(ss);
+    return ss.str();
 }
 
-bool ETSUnionType::TypeRelatedToSomeType(TypeRelation *relation, Type *source, ETSUnionType *target)
+void ETSUnionType::InitAssemblerTypeCache(ETSChecker *checker)
 {
-    return std::any_of(target->constituentTypes_.begin(), target->constituentTypes_.end(),
-                       [relation, source](auto *t) { return relation->IsIdenticalTo(source, t); });
+    ES2PANDA_ASSERT(!assemblerConstituentTypes_.empty());
+    std::stringstream ss;
+    if (assemblerConstituentTypes_.size() == 1) {
+        assemblerConstituentTypes_[0]->ToAssemblerTypeWithRank(ss);
+    } else {
+        ss << "{U";
+        for (size_t idx = 0; idx < assemblerConstituentTypes_.size(); idx++) {
+            assemblerConstituentTypes_[idx]->ToAssemblerTypeWithRank(ss);
+            if (idx != assemblerConstituentTypes_.size() - 1) {
+                ss << ",";
+            }
+        }
+        ss << "}";
+    }
+    assemblerTypeCache_ = util::UString(ss.str(), checker->ProgramAllocator()).View();
 }
 
-// This function computes effective runtime representation of union type
-Type *ETSUnionType::ComputeAssemblerLUB(ETSChecker *checker, ETSUnionType *un)
+void ETSUnionType::CanonicalizedAssemblerType(ETSChecker *checker)
 {
-    auto *const apparent = checker->GetApparentType(un);
+    auto *const apparent = checker->GetApparentType(this);
     if (!apparent->IsETSUnionType()) {
-        return apparent;
+        assemblerConstituentTypes_.push_back(apparent);
+        return;
     }
-    if (apparent != un) {
-        return apparent->AsETSUnionType()->assemblerLub_;
+    if (apparent != this) {
+        const auto &types = apparent->AsETSUnionType()->GetAssemblerTypes();
+        assemblerConstituentTypes_.insert(assemblerConstituentTypes_.begin(), types.begin(), types.end());
+        return;
     }
-    un = apparent->AsETSUnionType();
-
-    Type *lub = nullptr;
-    for (auto *t : un->ConstituentTypes()) {
-        if (t->IsTypeError()) {
-            return checker->GlobalTypeError();
-        }
-        // NOTE(vpukhov): #19701 void refactoring
-        ES2PANDA_ASSERT(t->IsETSReferenceType() || t->IsETSVoidType());
-        t = t->IsETSVoidType() ? checker->GlobalETSUndefinedType() : t;
 
-        if (lub == nullptr || lub->IsETSUndefinedType()) {
-            lub = t;
+    ES2PANDA_ASSERT(constituentTypes_.size() > 1);
+    for (auto *type : constituentTypes_) {
+        ES2PANDA_ASSERT(!type->IsETSUnionType());
+        if (type->IsETSUndefinedType() || type->IsETSVoidType()) {
             continue;
         }
-        if (lub == t || t->IsETSUndefinedType()) {
-            continue;
+        if (type->IsETSNullType()) {
+            assemblerConstituentTypes_.clear();
+            assemblerConstituentTypes_.push_back(checker->GlobalETSObjectType());
+            return;
         }
-        if (t->IsETSNullType()) {
-            return checker->GetGlobalTypesHolder()->GlobalETSObjectType();
+        if (type->IsTypeError()) {
+            assemblerConstituentTypes_.clear();
+            assemblerConstituentTypes_.push_back(checker->GlobalTypeError());
+            return;
         }
-        if (t->IsETSObjectType() && lub->IsETSObjectType()) {
-            lub = checker->GetClosestCommonAncestor(lub->AsETSObjectType(), t->AsETSObjectType());
-        } else if (t->IsETSArrayType() && lub->IsETSArrayType()) {
-            // NOTE: can compute "common(lub, t)[]"
-            return checker->GetGlobalTypesHolder()->GlobalETSObjectType();
-        } else {
-            return checker->GetGlobalTypesHolder()->GlobalETSObjectType();
+        auto found =
+            std::find_if(assemblerConstituentTypes_.begin(), assemblerConstituentTypes_.end(),
+                         [&type](Type *t) { return GetAssemblerTypeString(type) == GetAssemblerTypeString(t); });
+        if (found == assemblerConstituentTypes_.end()) {
+            assemblerConstituentTypes_.push_back(type);
         }
     }
-    return checker->GetNonConstantType(lub);
+    if (assemblerConstituentTypes_.empty()) {
+        assemblerConstituentTypes_.push_back(checker->GlobalETSObjectType());
+        return;
+    }
+    if (assemblerConstituentTypes_.size() == 1) {
+        return;
+    }
+
+    std::sort(assemblerConstituentTypes_.begin(), assemblerConstituentTypes_.end(),
+              [](Type *a, Type *b) { return GetAssemblerTypeString(a) < GetAssemblerTypeString(b); });
+}
+
+ETSUnionType::ETSUnionType(ETSChecker *checker, ArenaVector<Type *> &&constituentTypes)
+    : Type(TypeFlag::ETS_UNION),
+      constituentTypes_(std::move(constituentTypes)),
+      assemblerConstituentTypes_(checker->ProgramAllocator()->Adapter())
+{
+    ES2PANDA_ASSERT(constituentTypes_.size() > 1);
+    CanonicalizedAssemblerType(checker);
+    InitAssemblerTypeCache(checker);
+}
+
+bool ETSUnionType::EachTypeRelatedToSomeType(TypeRelation *relation, ETSUnionType *source, ETSUnionType *target)
+{
+    return std::all_of(source->constituentTypes_.begin(), source->constituentTypes_.end(),
+                       [relation, target](auto *s) { return TypeRelatedToSomeType(relation, s, target); });
+}
+
+bool ETSUnionType::TypeRelatedToSomeType(TypeRelation *relation, Type *source, ETSUnionType *target)
+{
+    return std::any_of(target->constituentTypes_.begin(), target->constituentTypes_.end(),
+                       [relation, source](auto *t) { return relation->IsIdenticalTo(source, t); });
 }
 
 void ETSUnionType::Identical(TypeRelation *relation, Type *other)
diff --git a/ets2panda/checker/types/ets/etsUnionType.h b/ets2panda/checker/types/ets/etsUnionType.h
index 54c15370d85c9d453a8183ea0844b4a576856743..dc1fed610fde415d2965eecf4b17893b9bbd96c2 100644
--- a/ets2panda/checker/types/ets/etsUnionType.h
+++ b/ets2panda/checker/types/ets/etsUnionType.h
@@ -54,10 +54,14 @@ public:
 
     [[nodiscard]] ArenaVector<Type *> GetNonConstantTypes(ETSChecker *checker) const noexcept;
 
-    // Do not use it anywhere except codegen
-    Type *GetAssemblerLUB() const noexcept
+    const util::StringView &GetAssemblerType() const
     {
-        return assemblerLub_;
+        return assemblerTypeCache_;
+    }
+
+    const ArenaVector<Type *> &GetAssemblerTypes() const
+    {
+        return assemblerConstituentTypes_;
     }
 
     template <class UnaryPredicate>
@@ -105,10 +109,12 @@ private:
         checker::ETSChecker *checker, checker::ETSObjectType *sourceType,
         std::map<std::uint32_t, checker::ETSObjectType *> &numericTypes) const noexcept;
 
-    static Type *ComputeAssemblerLUB(ETSChecker *checker, ETSUnionType *un);
+    void CanonicalizedAssemblerType(ETSChecker *checker);
+    void InitAssemblerTypeCache(ETSChecker *checker);
 
     ArenaVector<Type *> const constituentTypes_;
-    Type *assemblerLub_ {nullptr};
+    ArenaVector<Type *> assemblerConstituentTypes_;
+    util::StringView assemblerTypeCache_;
 };
 }  // namespace ark::es2panda::checker
 
diff --git a/ets2panda/compiler/core/ETSGen.cpp b/ets2panda/compiler/core/ETSGen.cpp
index 149c12d4d57963671b7f818166bbcc4ac098b78d..9d5095d8d34b0d0000143f6113d2672b88b32e72 100644
--- a/ets2panda/compiler/core/ETSGen.cpp
+++ b/ets2panda/compiler/core/ETSGen.cpp
@@ -556,7 +556,8 @@ void ETSGen::TestIsInstanceConstituent(const ir::AstNode *const node, std::tuple
             break;
         case checker::TypeFlag::ETS_ARRAY:
         case checker::TypeFlag::ETS_TUPLE:
-        case checker::TypeFlag::FUNCTION: {
+        case checker::TypeFlag::FUNCTION:
+        case checker::TypeFlag::ETS_UNION: {
             EmitIsInstance(node, ToAssemblerType(target));
             BranchIfTrue(node, ifTrue);
             break;
@@ -587,11 +588,7 @@ void ETSGen::BranchIfIsInstance(const ir::AstNode *const node, const VReg srcReg
         TestIsInstanceConstituent(n, std::tie(ifTrue, ifFalse), t, acceptNull);
     };
 
-    if (target->IsETSUnionType()) {
-        for (auto *ct : target->AsETSUnionType()->ConstituentTypes()) {
-            checkType(node, ct);
-        }
-    } else if (!target->IsETSNeverType()) {
+    if (!target->IsETSNeverType()) {
         checkType(node, target);
     }
 
@@ -686,6 +683,29 @@ void ETSGen::CheckedReferenceNarrowingObject(const ir::AstNode *node, const chec
     }
 }
 
+// optimized specialization for union
+void ETSGen::CheckedReferenceNarrowingUnion(const ir::AstNode *node, const checker::Type *target)
+{
+    ES2PANDA_ASSERT(target->IsETSUnionType());
+    const RegScope rs(this);
+    const auto srcReg = AllocReg();
+    StoreAccumulator(node, srcReg);
+
+    auto isUndefined = AllocLabel();
+
+    if (target->PossiblyETSUndefined()) {
+        BranchIfUndefined(node, isUndefined);
+        LoadAccumulator(node, srcReg);
+        EmitCheckCast(node, ToAssemblerType(target));
+        SetLabel(node, isUndefined);
+        SetAccumulatorType(target);
+    } else {
+        EmitNullcheck(node);
+        EmitCheckCast(node, ToAssemblerType(target));
+        SetAccumulatorType(target);
+    }
+}
+
 // Implemented on top of the runtime type system, do not relax checks, do not introduce new types
 void ETSGen::CheckedReferenceNarrowing(const ir::AstNode *node, const checker::Type *target)
 {
@@ -702,6 +722,10 @@ void ETSGen::CheckedReferenceNarrowing(const ir::AstNode *node, const checker::T
         SetAccumulatorType(target);
         return;
     }
+    if (target->IsETSUnionType()) {
+        CheckedReferenceNarrowingUnion(node, target);
+        return;
+    }
     if (target->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT | checker::TypeFlag::ETS_TUPLE) &&
         !target->IsConstantType()) {
         CheckedReferenceNarrowingObject(node, target);
diff --git a/ets2panda/compiler/core/ETSGen.h b/ets2panda/compiler/core/ETSGen.h
index 6712e10b91f0bc63dc89d21b7b79f458c137d21b..10b30e0f73f893d1eee96e55f7b1e0c6f4188497 100644
--- a/ets2panda/compiler/core/ETSGen.h
+++ b/ets2panda/compiler/core/ETSGen.h
@@ -449,6 +449,7 @@ private:
     void TestIsInstanceConstituent(const ir::AstNode *node, std::tuple<Label *, Label *> label,
                                    checker::Type const *target, bool acceptNull);
     void CheckedReferenceNarrowingObject(const ir::AstNode *node, const checker::Type *target);
+    void CheckedReferenceNarrowingUnion(const ir::AstNode *node, const checker::Type *target);
 
     template <bool IS_SRTICT = false>
     void HandleDefinitelyNullishEquality(const ir::AstNode *node, VReg lhs, VReg rhs, Label *ifFalse);
diff --git a/ets2panda/compiler/core/ETSemitter.cpp b/ets2panda/compiler/core/ETSemitter.cpp
index 8895c5009a1ea46a4267f0a063bb9d92303479d4..50c9693ec90ebd945831d01935250525eec6a0c8 100644
--- a/ets2panda/compiler/core/ETSemitter.cpp
+++ b/ets2panda/compiler/core/ETSemitter.cpp
@@ -104,7 +104,9 @@ static pandasm::Type PandasmTypeWithRank(checker::Type const *type, uint32_t ran
         return PandasmTypeWithRank(type->AsETSPartialTypeParameter()->GetUnderlying());
     }
     if (type->IsETSUnionType()) {
-        return PandasmTypeWithRank(type->AsETSUnionType()->GetAssemblerLUB());
+        if (type->AsETSUnionType()->GetAssemblerTypes().size() == 1) {
+            return pandasm::Type::FromName(type->AsETSUnionType()->GetAssemblerType().Mutf8());
+        }
     }
 
     std::stringstream ss;
@@ -306,6 +308,13 @@ void ETSEmitter::GenAnnotation()
     for (auto [arrType, signature] : checker->GlobalArrayTypes()) {
         GenGlobalArrayRecord(arrType, signature);
     }
+    for (auto unionType : checker->UnionAssemblerTypes()) {
+        if (unionType->GetAssemblerTypes().size() > 1) {
+            auto unionRecord = pandasm::Record(unionType->GetAssemblerType().Mutf8(), Program()->lang);
+            unionRecord.metadata->SetAttribute(Signatures::EXTERNAL);
+            Program()->recordTable.emplace(unionRecord.name, std::move(unionRecord));
+        }
+    }
     if (Context()->config->options->WasSetWithExportTable()) {
         auto result = StoreExportNodes(Context()->parserProgram->DeclGenExportNodes(), Program());
         Program()->exportStrMap = std::move(result);
diff --git a/ets2panda/evaluate/debugInfoStorage.cpp b/ets2panda/evaluate/debugInfoStorage.cpp
index 1aa286225d616c9afb852a66bd59efa962c082b0..20163df7651cfe096002170d3259eedeb67bb862 100644
--- a/ets2panda/evaluate/debugInfoStorage.cpp
+++ b/ets2panda/evaluate/debugInfoStorage.cpp
@@ -30,7 +30,7 @@ std::string GetFullRecordName(const panda_file::File &pf, const panda_file::File
     std::string name = utf::Mutf8AsCString(pf.GetStringData(classId).data);
 
     auto type = pandasm::Type::FromDescriptor(name);
-    type = pandasm::Type(type.GetComponentName(), type.GetRank());
+    type = pandasm::Type(type.GetNameWithoutRank(), type.GetRank());
 
     return type.GetPandasmName();
 }
diff --git a/ets2panda/test/unit/CMakeLists.txt b/ets2panda/test/unit/CMakeLists.txt
index 07663a9a29d1e6c30a20f130b26d8cab1ce87f37..509f7de8a4c1d33aa501606a86a5d9f47f0b90b4 100644
--- a/ets2panda/test/unit/CMakeLists.txt
+++ b/ets2panda/test/unit/CMakeLists.txt
@@ -41,6 +41,10 @@ ets2panda_add_gtest(es2panda_globalETSObjectType_tests
     CPP_SOURCES globalETSObjectType_test.cpp
 )
 
+ets2panda_add_gtest(es2panda_union_emit_standard_test
+    CPP_SOURCES union_emit_test.cpp
+)
+
 if (PANDA_TARGET_LINUX AND PANDA_TARGET_64)
     ets2panda_add_gtest(sizeof_node_tests
         CPP_SOURCES sizeof_node_test.cpp
diff --git a/ets2panda/test/unit/union_emit_test.cpp b/ets2panda/test/unit/union_emit_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..07f8ca2de5e5c7a60c4b40d985408a77fab0056c
--- /dev/null
+++ b/ets2panda/test/unit/union_emit_test.cpp
@@ -0,0 +1,200 @@
+/**
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "test/utils/asm_test.h"
+
+namespace ark::es2panda::compiler::test {
+
+class UnionAsmTest : public ::test::utils::AsmTest {
+public:
+    UnionAsmTest() = default;
+
+    ~UnionAsmTest() override = default;
+
+    void CheckUnionType(std::string_view recordName)
+    {
+        pandasm::Record *rec = GetRecord(recordName, program_);
+        ASSERT_TRUE(rec != nullptr) << "Type '" << recordName << "' not found";
+    }
+
+    void CheckInsInFunction(std::string_view functionName, std::string_view insString, bool result = true)
+    {
+        pandasm::Function *fn = GetFunction(functionName, program_->functionStaticTable);
+        ASSERT_TRUE(fn != nullptr) << "Function '" << functionName << "' not found";
+        std::vector<ark::pandasm::Ins> ins = fn->ins;
+        bool found = false;
+        for (auto &i : ins) {
+            if (i.ToString("", true) == insString) {
+                found = true;
+            }
+        }
+        ASSERT_TRUE(found == result) << "Instruction '" << insString << "' not found in function " << functionName;
+    }
+
+private:
+    NO_COPY_SEMANTIC(UnionAsmTest);
+    NO_MOVE_SEMANTIC(UnionAsmTest);
+};
+
+TEST_F(UnionAsmTest, union_test)
+{
+    SetCurrentProgram(R"(
+        class A {}
+        class B {}
+        class C {}
+        class D {}
+        function test1(v:A|B) {}
+        function test2(v:A|B|C) {}
+        function test3(v:A|B|FixedArray<C>) {}
+        function test4(v:B|C|D|int) {}
+    )");
+
+    CheckUnionType("{Udummy.A,dummy.B}");
+    CheckUnionType("{Udummy.A,dummy.B,dummy.C[]}");
+    CheckUnionType("{Udummy.A,dummy.B,dummy.C}");
+    CheckUnionType("{Udummy.B,dummy.C,dummy.D,std.core.Int}");
+}
+
+TEST_F(UnionAsmTest, union_test_extends)
+{
+    SetCurrentProgram(R"(
+        class A {}
+        class B {}
+        class C extends B {}
+        class D extends B {}
+        function test1(v:A|B) {}
+        function test2(v:A|B|C) {}
+        function test3(v:A|B|FixedArray<C>) {}
+        function test4(v:B|C|D|int) {}
+    )");
+
+    CheckUnionType("{Udummy.A,dummy.B}");
+    CheckUnionType("{Udummy.A,dummy.B,dummy.C[]}");
+    CheckUnionType("{Udummy.B,std.core.Int}");
+}
+
+TEST_F(UnionAsmTest, union_test_2)
+{
+    SetCurrentProgram(R"(
+        class A {}
+        class B {}
+        class C {}
+        class D {}
+        function test1(v:C|C|B|C|B) {}
+        function test2(v:D|C|B|A) {}
+        function test3(v:A|A|A|B) {}
+        function test4(v:A|double) {}
+        function test5(v:double|double|long) {}
+        function test6(v:double|int|long) {}
+        function test7(v:B|C|B|A) {}
+        function test8(v:A|D|D|D) {}
+    )");
+
+    CheckUnionType("{Udummy.A,dummy.B,dummy.C,dummy.D}");
+    CheckUnionType("{Udummy.A,dummy.B,dummy.C}");
+    CheckUnionType("{Udummy.A,dummy.B}");
+    CheckUnionType("{Udummy.A,dummy.D}");
+    CheckUnionType("{Udummy.A,std.core.Double}");
+    CheckUnionType("{Udummy.B,dummy.C}");
+}
+
+TEST_F(UnionAsmTest, union_test_arrays)
+{
+    SetCurrentProgram(R"(
+        class A {}
+        class B {}
+        class C {}
+        class D {}
+        function test1(v:B|C|FixedArray<A|D|double>) {}
+        function test1(v:FixedArray<A|D|double>|FixedArray<A|D|int>|FixedArray<A|D|long>) {}
+        function test1(v:B|C|FixedArray<A|B>) {}
+        function test1(v:B|FixedArray<A|D>|FixedArray<D|B>|FixedArray<C|B>|FixedArray<C|D>) {}
+        function test1(v:FixedArray<A|D>|FixedArray<D|B>|FixedArray<C|B>|FixedArray<C|D>) {}
+        function test1(v:FixedArray<A|D>|FixedArray<D|B>) {}
+        function test1(v:FixedArray<D|C>|FixedArray<C|B>) {}
+        function test1(v:FixedArray<D|C>|C|B) {}
+        function test1(v:FixedArray<int|double>|long|double) {}
+        function test1(v:FixedArray<FixedArray<int>|FixedArray<double>>|FixedArray<long>|FixedArray<double>) {}
+    )");
+
+    CheckUnionType("{Udummy.A,dummy.B}");
+    CheckUnionType("{Udummy.A,dummy.B}[]");
+    CheckUnionType("{Udummy.A,dummy.D,std.core.Double}");
+    CheckUnionType("{Udummy.A,dummy.D,std.core.Double}[]");
+    CheckUnionType("{Udummy.A,dummy.D,std.core.Int}");
+    CheckUnionType("{Udummy.A,dummy.D,std.core.Int}[]");
+    CheckUnionType("{Udummy.A,dummy.D,std.core.Long}");
+    CheckUnionType("{Udummy.A,dummy.D,std.core.Long}[]");
+    CheckUnionType("{Udummy.A,dummy.D}");
+    CheckUnionType("{Udummy.A,dummy.D}[]");
+    CheckUnionType("{Udummy.B,dummy.C,{Udummy.A,dummy.B}[]}");
+    CheckUnionType("{Udummy.B,dummy.C,{Udummy.A,dummy.D,std.core.Double}[]}");
+    CheckUnionType("{Udummy.B,dummy.C,{Udummy.C,dummy.D}[]}");
+    CheckUnionType("{Udummy.B,dummy.C}");
+    CheckUnionType("{Udummy.B,dummy.C}[]");
+    CheckUnionType("{Udummy.B,dummy.D}");
+    CheckUnionType("{Udummy.B,dummy.D}[]");
+    CheckUnionType("{Udummy.B,{Udummy.A,dummy.D}[],{Udummy.B,dummy.C}[],{Udummy.B,dummy.D}[],{Udummy.C,dummy.D}[]}");
+    CheckUnionType("{Udummy.C,dummy.D}");
+    CheckUnionType("{Udummy.C,dummy.D}[]");
+    CheckUnionType(
+        "{U{Udummy.A,dummy.D,std.core.Double}[],{Udummy.A,dummy.D,std.core.Int}[],{Udummy.A,dummy.D,std.core.Long}[]}");
+    CheckUnionType("{U{Udummy.A,dummy.D}[],{Udummy.B,dummy.C}[],{Udummy.B,dummy.D}[],{Udummy.C,dummy.D}[]}");
+    CheckUnionType("{U{Udummy.A,dummy.D}[],{Udummy.B,dummy.D}[]}");
+    CheckUnionType("{U{Udummy.B,dummy.C}[],{Udummy.C,dummy.D}[]}");
+}
+
+TEST_F(UnionAsmTest, union_test_isinstanceof)
+{
+    SetCurrentProgram(R"(
+        function test1(v: string): void { v instanceof string | number }
+    )");
+
+    CheckInsInFunction("dummy.ETSGLOBAL.test1:std.core.String;void;", "isinstance {Ustd.core.Double,std.core.String}",
+                       true);
+}
+
+TEST_F(UnionAsmTest, union_test_generic_checkcast)
+{
+    SetCurrentProgram(R"(
+        class X<T> {
+            constructor(v: T) { this.p = v}
+            p: T
+        }
+        function test1(x: X<string|number>) { return x.p }
+        function test2(x: X<string|number|undefined>) { return x.p }
+    )");
+
+    CheckInsInFunction("dummy.ETSGLOBAL.test1:dummy.X;{Ustd.core.Double,std.core.String};", "ets.nullcheck", true);
+    CheckInsInFunction("dummy.ETSGLOBAL.test1:dummy.X;{Ustd.core.Double,std.core.String};",
+                       "checkcast {Ustd.core.Double,std.core.String}", true);
+    CheckInsInFunction("dummy.ETSGLOBAL.test2:dummy.X;{Ustd.core.Double,std.core.String};", "ets.nullcheck", false);
+    CheckInsInFunction("dummy.ETSGLOBAL.test2:dummy.X;{Ustd.core.Double,std.core.String};",
+                       "checkcast {Ustd.core.Double,std.core.String}", true);
+}
+
+TEST_F(UnionAsmTest, union_test_as)
+{
+    SetCurrentProgram(R"(
+        function test1(v: string): void { v as string | number }
+    )");
+
+    CheckInsInFunction("dummy.ETSGLOBAL.test1:std.core.String;void;", "ets.nullcheck", true);
+    CheckInsInFunction("dummy.ETSGLOBAL.test1:std.core.String;void;", "checkcast {Ustd.core.Double,std.core.String}",
+                       true);
+}
+
+}  // namespace ark::es2panda::compiler::test