From 5e7aaa6c27f1216305878cdb2f27910ab997f4e2 Mon Sep 17 00:00:00 2001
From: Lyupa Anastasia <lyupa.anastasia@huawei.com>
Date: Mon, 30 Jun 2025 18:19:20 +0300
Subject: [PATCH] Implement union type

Issue: https://gitee.com/openharmony/arkcompiler_runtime_core/issues/ICIYJL

Revert "Revert Union Type"
This reverts commit 032615c5baa080fd5165fb07473288d487a0997b.

UnionType checkcast/isinstance codegen; null type
FE support implementing union class in runtime
- Patch checkcast/isinstance codegen for Union types;
- Emit unions with null as {...|null} instead of simple 'object'
- Emit null type as std.core.Null

Signed-off-by: Anna Antipina <antipina.anna1@huawei.com>
Signed-off-by: Lyupa Anastasia <lyupa.anastasia@huawei.com>

Change-Id: I5b659865f3cbe9bb3dc411423bb8eb9c989ec8c1
---
 ets2panda/checker/ETSchecker.cpp              |  10 +
 ets2panda/checker/ETSchecker.h                |   8 +
 ets2panda/checker/ets/function.cpp            |  22 +-
 ets2panda/checker/ets/typeCheckingHelpers.cpp |   3 +-
 ets2panda/checker/ets/typeCreation.cpp        |   8 +-
 ets2panda/checker/types/ets/etsUnionType.cpp  | 139 ++++++----
 ets2panda/checker/types/ets/etsUnionType.h    |  36 ++-
 ets2panda/compiler/core/ETSGen.cpp            | 104 ++++++--
 ets2panda/compiler/core/ETSGen.h              |   9 +-
 ets2panda/compiler/core/ETSemitter.cpp        |   9 +-
 ets2panda/compiler/scripts/signatures.yaml    |   4 +-
 ets2panda/evaluate/debugInfoStorage.cpp       |   2 +-
 ets2panda/test/unit/CMakeLists.txt            |   4 +
 .../test/unit/any_ins_test/any_ins_test.cpp   |   2 +-
 ets2panda/test/unit/union_emit_test.cpp       | 238 ++++++++++++++++++
 15 files changed, 511 insertions(+), 87 deletions(-)
 create mode 100644 ets2panda/test/unit/union_emit_test.cpp

diff --git a/ets2panda/checker/ETSchecker.cpp b/ets2panda/checker/ETSchecker.cpp
index abf418beae8..5f08f3c6183 100644
--- a/ets2panda/checker/ETSchecker.cpp
+++ b/ets2panda/checker/ETSchecker.cpp
@@ -713,6 +713,16 @@ const GlobalArraySignatureMap &ETSChecker::GlobalArrayTypes() const
     return globalArraySignatures_;
 }
 
+const ArenaSet<util::StringView> &ETSChecker::UnionAssemblerTypes() const
+{
+    return unionAssemblerTypes_;
+}
+
+ArenaSet<util::StringView> &ETSChecker::UnionAssemblerTypes()
+{
+    return unionAssemblerTypes_;
+}
+
 Type *ETSChecker::GlobalTypeError() const
 {
     return GetGlobalTypesHolder()->GlobalTypeError();
diff --git a/ets2panda/checker/ETSchecker.h b/ets2panda/checker/ETSchecker.h
index 62c5776c6b2..cccc9283e55 100644
--- a/ets2panda/checker/ETSchecker.h
+++ b/ets2panda/checker/ETSchecker.h
@@ -93,6 +93,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()),
@@ -174,6 +175,9 @@ public:
     GlobalArraySignatureMap &GlobalArrayTypes();
     const GlobalArraySignatureMap &GlobalArrayTypes() const;
 
+    const ArenaSet<util::StringView> &UnionAssemblerTypes() const;
+    ArenaSet<util::StringView> &UnionAssemblerTypes();
+
     Type *GlobalTypeError() const;
     [[nodiscard]] Type *InvalidateType(ir::Typed<ir::AstNode> *node);
     [[nodiscard]] Type *TypeError(ir::Typed<ir::AstNode> *node, const diagnostic::DiagnosticKind &diagKind,
@@ -513,6 +517,8 @@ public:
     void SearchAmongMostSpecificTypes(Type *&mostSpecificType, Signature *&prevSig,
                                       std::tuple<const lexer::SourcePosition &, size_t, Signature *> info,
                                       bool lookForClassType);
+    void CheckAmbiguousCall(Type *&mostSpecificType, Type *sigType, Signature *prevSig, Signature *sig,
+                            const lexer::SourcePosition &pos);
     void CollectSuitableSignaturesForTypeInference(size_t paramIdx, ArenaVector<Signature *> &signatures,
                                                    ArenaMultiMap<size_t, Signature *> &bestSignaturesForParameter,
                                                    const ArenaVector<ir::Expression *> &arguments);
@@ -940,6 +946,7 @@ public:
         pendingConstraintCheckRecords_.clear();
         constraintCheckScopesCount_ = 0;
         globalArraySignatures_.clear();
+        unionAssemblerTypes_.clear();
         GetCachedComputedAbstracts()->clear();
         for (auto &dynamicCallIntrinsicsMap : dynamicIntrinsics_) {
             dynamicCallIntrinsicsMap.clear();
@@ -1099,6 +1106,7 @@ private:
     FunctionInterfaceMap arrowToFuncInterfaces_;
     size_t constraintCheckScopesCount_ {0};
     GlobalArraySignatureMap globalArraySignatures_;
+    ArenaSet<util::StringView> unionAssemblerTypes_;
     ComputedAbstracts *cachedComputedAbstracts_ {nullptr};
     // NOTE(aleksisch): Extract dynamic from checker to separate class
     std::array<DynamicCallIntrinsicsMap, 2U> dynamicIntrinsics_;
diff --git a/ets2panda/checker/ets/function.cpp b/ets2panda/checker/ets/function.cpp
index c31ff616071..a7aa48c0e24 100644
--- a/ets2panda/checker/ets/function.cpp
+++ b/ets2panda/checker/ets/function.cpp
@@ -1009,6 +1009,21 @@ static void InitMostSpecificType(TypeRelation *relation, const ArenaVector<Signa
     }
 }
 
+void ETSChecker::CheckAmbiguousCall(Type *&mostSpecificType, Type *sigType, Signature *prevSig, Signature *sig,
+                                    const lexer::SourcePosition &pos)
+{
+    if (((sigType->IsETSObjectType() && mostSpecificType->IsETSObjectType()) ||
+         (sigType->IsETSUnionType() && mostSpecificType->IsETSUnionType() &&
+          ((sigType->AsETSUnionType()->ContainsNull() && mostSpecificType->AsETSUnionType()->ContainsNull()) ||
+           (sigType->AsETSUnionType()->ContainsUndefined() &&
+            mostSpecificType->AsETSUnionType()->ContainsUndefined())))) &&
+        !Relation()->IsAssignableTo(mostSpecificType, sigType) &&
+        !Relation()->IsLegalBoxedPrimitiveConversion(sigType, mostSpecificType)) {
+        auto funcName = sig->Function()->Id()->Name();
+        LogError(diagnostic::AMBIGUOUS_CALL, {funcName, funcName, funcName, prevSig, funcName, sig}, pos);
+    }
+}
+
 void ETSChecker::SearchAmongMostSpecificTypes(Type *&mostSpecificType, Signature *&prevSig,
                                               std::tuple<const lexer::SourcePosition &, size_t, Signature *> info,
                                               bool lookForClassType)
@@ -1056,11 +1071,8 @@ void ETSChecker::SearchAmongMostSpecificTypes(Type *&mostSpecificType, Signature
         if (Relation()->IsAssignableTo(sigType, mostSpecificType)) {
             mostSpecificType = sigType;
             prevSig = sig;
-        } else if (sigType->IsETSObjectType() && mostSpecificType->IsETSObjectType() &&
-                   !Relation()->IsAssignableTo(mostSpecificType, sigType) &&
-                   !Relation()->IsLegalBoxedPrimitiveConversion(sigType, mostSpecificType)) {
-            auto funcName = sig->Function()->Id()->Name();
-            LogError(diagnostic::AMBIGUOUS_CALL, {funcName, funcName, funcName, prevSig, funcName, sig}, pos);
+        } else {
+            CheckAmbiguousCall(mostSpecificType, sigType, prevSig, sig, pos);
         }
     }
 }
diff --git a/ets2panda/checker/ets/typeCheckingHelpers.cpp b/ets2panda/checker/ets/typeCheckingHelpers.cpp
index f2a5fd239c3..96773da5281 100644
--- a/ets2panda/checker/ets/typeCheckingHelpers.cpp
+++ b/ets2panda/checker/ets/typeCheckingHelpers.cpp
@@ -705,8 +705,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 725024a0bb1..c99b6e1ccd4 100644
--- a/ets2panda/checker/ets/typeCreation.cpp
+++ b/ets2panda/checker/ets/typeCreation.cpp
@@ -162,8 +162,12 @@ 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));
+    auto ut = un->GetAssemblerType().Mutf8();
+    if (std::count_if(ut.begin(), ut.end(), [](char c) { return c == ','; }) > 0) {
+        unionAssemblerTypes_.insert(un->GetAssemblerType());
+    }
+    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 34f539ad856..cd3902673a1 100644
--- a/ets2panda/checker/types/ets/etsUnionType.cpp
+++ b/ets2panda/checker/types/ets/etsUnionType.cpp
@@ -34,74 +34,125 @@ 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";
+    // NOLINTNEXTLINE(modernize-loop-convert)
+    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++) {
+            if (idx != 0) {
+                ss << ",";
+            }
+            if (assemblerConstituentTypes_[idx]->IsETSNullType()) {
+                ss << compiler::Signatures::NULL_ASSEMBLY_TYPE;
+                continue;
+            }
+            assemblerConstituentTypes_[idx]->ToAssemblerTypeWithRank(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);
+    bool hasNull = false;
+    for (auto *type : constituentTypes_) {
+        ES2PANDA_ASSERT(!type->IsETSUnionType());
+        if (type->IsETSUndefinedType() || type->IsETSVoidType()) {
             continue;
         }
-        if (lub == t || t->IsETSUndefinedType()) {
+        if (type->IsETSNullType() && !hasNull) {
+            hasNull = true;
+            assemblerConstituentTypes_.push_back(type);
             continue;
         }
-        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 54c15370d85..3a4006b71c7 100644
--- a/ets2panda/checker/types/ets/etsUnionType.h
+++ b/ets2panda/checker/types/ets/etsUnionType.h
@@ -54,10 +54,34 @@ 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_;
+    }
+
+    bool ContainsNull() const
+    {
+        for (auto *type : ConstituentTypes()) {
+            if (type->IsETSNullType()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool ContainsUndefined() const
+    {
+        for (auto *type : ConstituentTypes()) {
+            if (type->IsETSUndefinedType()) {
+                return true;
+            }
+        }
+        return false;
     }
 
     template <class UnaryPredicate>
@@ -105,10 +129,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 4e62393a954..f60ed50362c 100644
--- a/ets2panda/compiler/core/ETSGen.cpp
+++ b/ets2panda/compiler/core/ETSGen.cpp
@@ -586,14 +586,23 @@ void ETSGen::ReturnAcc(const ir::AstNode *node)
 
 static bool IsNullUnsafeObjectType(checker::Type const *type)
 {
+    if (type->IsETSUnionType()) {
+        for (auto *t : type->AsETSUnionType()->GetAssemblerTypes()) {
+            if (IsNullUnsafeObjectType(t)) {
+                return true;
+            }
+        }
+        return false;
+    }
     return type->IsETSObjectType() && type->AsETSObjectType()->IsGlobalETSObjectType();
 }
 
 // Implemented on top of the runtime type system, do not relax checks, do not introduce new types
-void ETSGen::TestIsInstanceConstituent(const ir::AstNode *const node, std::tuple<Label *, Label *> label,
-                                       checker::Type const *target, bool acceptNull)
+void ETSGen::TestIsInstanceType(const ir::AstNode *const node, std::tuple<Label *, Label *> label,
+                                checker::Type const *target, const VReg srcReg, bool acceptNull)
 {
     auto [ifTrue, ifFalse] = label;
+    LoadAccumulator(node, srcReg);
 
     switch (checker::ETSChecker::ETSType(target)) {
         case checker::TypeFlag::ETS_UNDEFINED:
@@ -621,6 +630,15 @@ void ETSGen::TestIsInstanceConstituent(const ir::AstNode *const node, std::tuple
             BranchIfTrue(node, ifTrue);
             break;
         }
+        case checker::TypeFlag::ETS_UNION: {
+            if (!target->PossiblyETSNull() && IsNullUnsafeObjectType(target)) {
+                BranchIfNull(node, ifFalse);
+            }
+            LoadAccumulator(node, srcReg);
+            InternalIsInstance(node, target);
+            BranchIfTrue(node, ifTrue);
+            break;
+        }
         default:
             ES2PANDA_UNREACHABLE();  // other types must not appear here
     }
@@ -633,26 +651,19 @@ void ETSGen::BranchIfIsInstance(const ir::AstNode *const node, const VReg srcReg
 {
     ES2PANDA_ASSERT(target == Checker()->GetApparentType(target));
     auto ifFalse = AllocLabel();
-
     if (!target->PossiblyETSUndefined()) {
         LoadAccumulator(node, srcReg);
         BranchIfUndefined(node, ifFalse);
+    } else if (target->IsETSUnionType()) {
+        LoadAccumulator(node, srcReg);
+        BranchIfUndefined(node, ifTrue);
     }
 
-    auto const checkType = [this, srcReg, ifTrue, ifFalse, acceptNull = target->PossiblyETSNull()](
-                               const ir::AstNode *const n, checker::Type const *t) {
-        LoadAccumulator(n, srcReg);
+    if (!target->IsETSNeverType()) {
         // #21835: type-alias in ApparentType
-        t = t->IsETSTypeAliasType() ? t->AsETSTypeAliasType()->GetTargetType() : t;
-        TestIsInstanceConstituent(n, std::tie(ifTrue, ifFalse), t, acceptNull);
-    };
-
-    if (target->IsETSUnionType()) {
-        for (auto *ct : target->AsETSUnionType()->ConstituentTypes()) {
-            checkType(node, ct);
-        }
-    } else if (!target->IsETSNeverType()) {
-        checkType(node, target);
+        TestIsInstanceType(node, std::tie(ifTrue, ifFalse),
+                           target->IsETSTypeAliasType() ? target->AsETSTypeAliasType()->GetTargetType() : target,
+                           srcReg, target->PossiblyETSNull());
     }
 
     SetLabel(node, ifFalse);
@@ -690,8 +701,8 @@ void ETSGen::IsInstance(const ir::AstNode *const node, const VReg srcReg, const
 // isinstance can only be used for Object and [] types, ensure source is not null!
 void ETSGen::InternalIsInstance(const ir::AstNode *node, const es2panda::checker::Type *target)
 {
-    ES2PANDA_ASSERT(target->IsETSObjectType() || target->IsETSArrayType());
-    if (!IsNullUnsafeObjectType(target)) {
+    ES2PANDA_ASSERT(target->IsETSObjectType() || target->IsETSArrayType() || target->IsETSUnionType());
+    if (!IsNullUnsafeObjectType(target) || (target->IsETSUnionType() && !IsNullUnsafeObjectType(target))) {
         EmitIsInstance(node, ToAssemblerType(target));
         SetAccumulatorType(Checker()->GlobalETSBooleanType());
     } else {
@@ -702,8 +713,9 @@ void ETSGen::InternalIsInstance(const ir::AstNode *node, const es2panda::checker
 // checkcast can only be used for Object and [] types, ensure source is not nullish!
 void ETSGen::InternalCheckCast(const ir::AstNode *node, const es2panda::checker::Type *target)
 {
-    ES2PANDA_ASSERT(target->IsETSObjectType() || target->IsETSArrayType() || target->IsETSTupleType());
-    if (!IsNullUnsafeObjectType(target)) {
+    ES2PANDA_ASSERT(target->IsETSObjectType() || target->IsETSArrayType() || target->IsETSTupleType() ||
+                    target->IsETSUnionType());
+    if (!IsNullUnsafeObjectType(target) || (target->IsETSUnionType() && !IsNullUnsafeObjectType(target))) {
         EmitCheckCast(node, ToAssemblerType(target));
     }
     SetAccumulatorType(target);
@@ -755,6 +767,43 @@ void ETSGen::CheckedReferenceNarrowingObject(const ir::AstNode *node, const chec
     }
 }
 
+// optimized specialization for union
+void ETSGen::CheckedReferenceNarrowingUnion(const ir::AstNode *node, const checker::ETSUnionType *target)
+{
+    ES2PANDA_ASSERT(target->IsETSUnionType());
+
+    const RegScope rs(this);
+    const auto srcReg = AllocReg();
+    auto error = AllocLabel();
+    auto end = AllocLabel();
+
+    StoreAccumulator(node, srcReg);
+    bool isNull = false;
+    bool isUndef = false;
+
+    if (!target->PossiblyETSUndefined()) {
+        isUndef = true;
+        BranchIfUndefined(node, error);
+    }
+    if (!target->PossiblyETSNull() && IsNullUnsafeObjectType(target)) {
+        isNull = true;
+        BranchIfNull(node, error);
+    }
+    if (!isNull && !isUndef) {
+        InternalCheckCast(node, target);
+    } else {
+        LoadAccumulator(node, srcReg);
+        InternalCheckCast(node, target);
+        JumpTo(node, end);
+
+        SetLabel(node, error);
+        EmitFailedTypeCastException(node, srcReg, target, isUndef);
+
+        SetLabel(node, end);
+        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)
 {
@@ -776,6 +825,10 @@ void ETSGen::CheckedReferenceNarrowing(const ir::AstNode *node, const checker::T
         CheckedReferenceNarrowingObject(node, target);
         return;
     }
+    if (target->IsETSUnionType()) {
+        CheckedReferenceNarrowingUnion(node, target->AsETSUnionType());
+        return;
+    }
 
     const RegScope rs(this);
     const auto srcReg = AllocReg();
@@ -808,13 +861,20 @@ void ETSGen::GuardUncheckedType(const ir::AstNode *node, const checker::Type *un
     SetAccumulatorType(target);
 }
 
-void ETSGen::EmitFailedTypeCastException(const ir::AstNode *node, const VReg src, checker::Type const *target)
+void ETSGen::EmitFailedTypeCastException(const ir::AstNode *node, const VReg src, checker::Type const *target,
+                                         bool isUndef)
 {
     const RegScope rs(this);
     const auto errorReg = AllocReg();
 
+    if (isUndef) {
+        Sa().Emit<Movi>(node, errorReg, 1.0);
+    } else {
+        Sa().Emit<Movi>(node, errorReg, 0.0);
+    }
+    SetVRegType(errorReg, Checker()->GlobalETSBooleanType());
     LoadAccumulatorString(node, util::UString(target->ToString(), Allocator()).View());
-    Ra().Emit<CallAccShort, 1>(node, Signatures::BUILTIN_RUNTIME_FAILED_TYPE_CAST_EXCEPTION, src, 1);
+    Ra().Emit<CallAcc, 2U>(node, Signatures::BUILTIN_RUNTIME_FAILED_TYPE_CAST_EXCEPTION, src, errorReg, dummyReg_, 1);
     StoreAccumulator(node, errorReg);
     EmitThrow(node, errorReg);
     SetAccumulatorType(nullptr);
diff --git a/ets2panda/compiler/core/ETSGen.h b/ets2panda/compiler/core/ETSGen.h
index 6707dcca73a..e0f6ae7e81a 100644
--- a/ets2panda/compiler/core/ETSGen.h
+++ b/ets2panda/compiler/core/ETSGen.h
@@ -94,8 +94,10 @@ public:
     void ReturnAcc(const ir::AstNode *node);
 
     void BranchIfIsInstance(const ir::AstNode *node, VReg srcReg, const checker::Type *target, Label *ifTrue);
+    void BranchIfIsInstanceUnion(const ir::AstNode *node, VReg srcReg, const checker::Type *target, Label *ifTrue);
     void IsInstance(const ir::AstNode *node, VReg srcReg, checker::Type const *target);
-    void EmitFailedTypeCastException(const ir::AstNode *node, VReg src, checker::Type const *target);
+    void EmitFailedTypeCastException(const ir::AstNode *node, const VReg src, checker::Type const *target,
+                                     bool isUndef = false);
 
     void EmitNullcheck([[maybe_unused]] const ir::AstNode *node)
     {
@@ -482,9 +484,10 @@ private:
     void UnaryTilde(const ir::AstNode *node);
 
     util::StringView ToAssemblerType(const es2panda::checker::Type *type) const;
-    void TestIsInstanceConstituent(const ir::AstNode *node, std::tuple<Label *, Label *> label,
-                                   checker::Type const *target, bool acceptNull);
+    void TestIsInstanceType(const ir::AstNode *const node, std::tuple<Label *, Label *> label,
+                            checker::Type const *target, const VReg srcReg, bool acceptNull);
     void CheckedReferenceNarrowingObject(const ir::AstNode *node, const checker::Type *target);
+    void CheckedReferenceNarrowingUnion(const ir::AstNode *node, const checker::ETSUnionType *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 baf96ce455f..c6ccf6f04c0 100644
--- a/ets2panda/compiler/core/ETSemitter.cpp
+++ b/ets2panda/compiler/core/ETSemitter.cpp
@@ -109,7 +109,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;
@@ -298,6 +300,11 @@ void ETSEmitter::GenAnnotation()
     for (auto [arrType, signature] : checker->GlobalArrayTypes()) {
         GenGlobalArrayRecord(arrType, signature);
     }
+    for (auto unionType : checker->UnionAssemblerTypes()) {
+        auto unionRecord = pandasm::Record(unionType.Mutf8(), Program()->lang);
+        unionRecord.metadata->SetAttribute(Signatures::EXTERNAL);
+        Program()->recordTable.emplace(unionRecord.name, std::move(unionRecord));
+    }
 }
 
 static bool IsFromSelfHeadFile(const std::string &name, const parser::Program *curProg, const parser::Program *extProg)
diff --git a/ets2panda/compiler/scripts/signatures.yaml b/ets2panda/compiler/scripts/signatures.yaml
index d44d0d0c169..15dfcdbfe96 100644
--- a/ets2panda/compiler/scripts/signatures.yaml
+++ b/ets2panda/compiler/scripts/signatures.yaml
@@ -152,6 +152,8 @@ defines:
     ref: UNDEFINED
   - name: 'null'
     ref: NULL_LITERAL
+  - name: 'std.core.Null'
+    ref: NULL_ASSEMBLY_TYPE
   - name: 'Readonly'
     ref: READONLY_TYPE_NAME
   - name: 'Partial'
@@ -788,7 +790,7 @@ signatures:
 
   - callee: BUILTIN_RUNTIME
     method_name: failedTypeCastException
-    params: [BUILTIN_OBJECT, BUILTIN_STRING]
+    params: [BUILTIN_OBJECT, BUILTIN_STRING, PRIMITIVE_BOOLEAN]
     return_type: BUILTIN_CLASS_CAST_ERROR
     ref: BUILTIN_RUNTIME_FAILED_TYPE_CAST_EXCEPTION
 
diff --git a/ets2panda/evaluate/debugInfoStorage.cpp b/ets2panda/evaluate/debugInfoStorage.cpp
index 1aa286225d6..20163df7651 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 78467d14499..0d4c20f3e59 100644
--- a/ets2panda/test/unit/CMakeLists.txt
+++ b/ets2panda/test/unit/CMakeLists.txt
@@ -43,6 +43,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/any_ins_test/any_ins_test.cpp b/ets2panda/test/unit/any_ins_test/any_ins_test.cpp
index e6bda882e22..357470258db 100644
--- a/ets2panda/test/unit/any_ins_test/any_ins_test.cpp
+++ b/ets2panda/test/unit/any_ins_test/any_ins_test.cpp
@@ -270,7 +270,7 @@ TEST_F(AnyInsTest, any_ins_test_05)
     ASSERT_NE(program, nullptr);
 
     const std::vector<pandasm::Opcode> expectedOps = {pandasm::Opcode::ANY_ISINSTANCE, pandasm::Opcode::ISINSTANCE};
-    AssertFunctionInstructions(program.get(), "dummy.ETSGLOBAL.foo:std.core.Object;void;", expectedOps);
+    AssertFunctionInstructions(program.get(), "dummy.ETSGLOBAL.foo:{Udummy.X,dummy.Y};void;", expectedOps);
 }
 
 // CC-OFFNXT(huge_depth) solid logic
diff --git a/ets2panda/test/unit/union_emit_test.cpp b/ets2panda/test/unit/union_emit_test.cpp
new file mode 100644
index 00000000000..5e73a42a413
--- /dev/null
+++ b/ets2panda/test/unit/union_emit_test.cpp
@@ -0,0 +1,238 @@
+/**
+ * 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, bool found = true)
+    {
+        pandasm::Record *rec = GetRecord(recordName, program_);
+        if (found) {
+            ASSERT_TRUE(rec != nullptr) << "Type '" << recordName << "' not found";
+        } else {
+            ASSERT_TRUE(rec == nullptr) << "Type '" << recordName << "' 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 (const auto &i : ins) {
+            std::string iStr = i.ToString("", true);
+            if (iStr.find(insString) != std::string::npos) {
+                found = true;
+            }
+        }
+        ASSERT_TRUE(found == result) << "Instruction '" << insString << "' in function '" << functionName
+                                     << "' not met expectations";
+    }
+
+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_null)
+{
+    SetCurrentProgram(R"(
+        class A {}
+        class B {}
+        class C {}
+        class D {}
+        function test1(v:D|C|B|null|A) {}
+    )");
+
+    CheckUnionType("{Udummy.A,dummy.B,dummy.C,dummy.D,std.core.Null}");
+}
+
+TEST_F(UnionAsmTest, union_test_undefined)
+{
+    SetCurrentProgram(R"(
+        class A {}
+        class B {}
+        class C {}
+        class D {}
+        function test1(v:D|C|B|undefined|A) {}
+        function test2(v:undefined|A) {}
+        function test3(v:undefined|A|null) {}
+    )");
+
+    CheckUnionType("{Udummy.A,dummy.B,dummy.C,dummy.D}");
+    CheckUnionType("{Udummy.A,undefined}", false);
+    CheckUnionType("{Udummy.A,std.core.Null}");
+}
+
+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};",
+                       "checkcast {Ustd.core.Double,std.core.String}", true);
+    CheckInsInFunction("dummy.ETSGLOBAL.test1:dummy.X;{Ustd.core.Double,std.core.String};",
+                       "std.core.Runtime.failedTypeCastException", true);
+    CheckInsInFunction("dummy.ETSGLOBAL.test2: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};",
+                       "std.core.Runtime.failedTypeCastException", false);
+}
+
+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;", "checkcast {Ustd.core.Double,std.core.String}",
+                       true);
+    CheckInsInFunction("dummy.ETSGLOBAL.test1:std.core.String;void;", "std.core.Runtime.failedTypeCastException", true);
+}
+
+}  // namespace ark::es2panda::compiler::test
-- 
Gitee