From 4b803d7571496ee75ec306359ec35192b82e5e3e Mon Sep 17 00:00:00 2001
From: Lyupa Anastasia <lyupa.anastasia@huawei.com>
Date: Tue, 17 Jun 2025 16:57:37 +0300
Subject: [PATCH] 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

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

Tests:
ninja all tests

Change-Id: I98eb1ff29b9602a0724c6b16f87394b9bac8bbb7
Signed-off-by: Anna Antipina <antipina.anna1@huawei.com>
Signed-off-by: Lyupa Anastasia <lyupa.anastasia@huawei.com>
---
 ets2panda/checker/ETSchecker.cpp              |   7 +-
 ets2panda/checker/ETSchecker.h                |   7 +-
 ets2panda/checker/ets/function.cpp            |  22 +++-
 ets2panda/checker/ets/typeCheckingHelpers.cpp |   3 +-
 ets2panda/checker/ets/typeCreation.cpp        |   5 +-
 ets2panda/checker/types/ets/etsUnionType.cpp  |  62 ++---------
 ets2panda/checker/types/ets/etsUnionType.h    |  28 +++--
 ets2panda/compiler/core/ETSGen.cpp            | 104 ++++++++++++++----
 ets2panda/compiler/core/ETSGen.h              |   9 +-
 ets2panda/compiler/core/ETSemitter.cpp        |   8 +-
 ets2panda/compiler/scripts/signatures.yaml    |   4 +-
 ets2panda/test/unit/union_emit_test.cpp       |  96 +++++++++++++++-
 12 files changed, 253 insertions(+), 102 deletions(-)

diff --git a/ets2panda/checker/ETSchecker.cpp b/ets2panda/checker/ETSchecker.cpp
index 8b45002d11..deab42bd05 100644
--- a/ets2panda/checker/ETSchecker.cpp
+++ b/ets2panda/checker/ETSchecker.cpp
@@ -706,7 +706,12 @@ const GlobalArraySignatureMap &ETSChecker::GlobalArrayTypes() const
     return globalArraySignatures_;
 }
 
-const ArenaSet<ETSUnionType *> &ETSChecker::UnionAssemblerTypes() const
+const ArenaSet<util::StringView> &ETSChecker::UnionAssemblerTypes() const
+{
+    return unionAssemblerTypes_;
+}
+
+ArenaSet<util::StringView> &ETSChecker::UnionAssemblerTypes()
 {
     return unionAssemblerTypes_;
 }
diff --git a/ets2panda/checker/ETSchecker.h b/ets2panda/checker/ETSchecker.h
index 4da77afe91..1bf89d60fc 100644
--- a/ets2panda/checker/ETSchecker.h
+++ b/ets2panda/checker/ETSchecker.h
@@ -174,7 +174,8 @@ public:
     GlobalArraySignatureMap &GlobalArrayTypes();
     const GlobalArraySignatureMap &GlobalArrayTypes() const;
 
-    const ArenaSet<ETSUnionType *> &UnionAssemblerTypes() const;
+    const ArenaSet<util::StringView> &UnionAssemblerTypes() const;
+    ArenaSet<util::StringView> &UnionAssemblerTypes();
 
     Type *GlobalTypeError() const;
     [[nodiscard]] Type *InvalidateType(ir::Typed<ir::AstNode> *node);
@@ -488,6 +489,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);
@@ -1067,7 +1070,7 @@ private:
     FunctionInterfaceMap arrowToFuncInterfaces_;
     size_t constraintCheckScopesCount_ {0};
     GlobalArraySignatureMap globalArraySignatures_;
-    ArenaSet<ETSUnionType *> unionAssemblerTypes_;
+    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 3e78b0fc52..d787746b95 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 77d3cf08eb..822b6d2d75 100644
--- a/ets2panda/checker/ets/typeCheckingHelpers.cpp
+++ b/ets2panda/checker/ets/typeCheckingHelpers.cpp
@@ -681,8 +681,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 f45e2ac987..be742f86d2 100644
--- a/ets2panda/checker/ets/typeCreation.cpp
+++ b/ets2panda/checker/ets/typeCreation.cpp
@@ -163,7 +163,10 @@ Type *ETSChecker::CreateETSUnionType(Span<Type *const> constituentTypes)
         return newConstituentTypes[0];
     }
     auto *un = ProgramAllocator()->New<ETSUnionType>(this, std::move(newConstituentTypes));
-    unionAssemblerTypes_.insert(un);
+    auto ut = un->GetAssemblerType().Mutf8();
+    if (std::count_if(ut.begin(), ut.end(), [](char c) { return c == ','; }) > 0) {
+        unionAssemblerTypes_.insert(un->GetAssemblerType());
+    }
     return un;
 }
 
diff --git a/ets2panda/checker/types/ets/etsUnionType.cpp b/ets2panda/checker/types/ets/etsUnionType.cpp
index 36a06ed594..10f4f3b134 100644
--- a/ets2panda/checker/types/ets/etsUnionType.cpp
+++ b/ets2panda/checker/types/ets/etsUnionType.cpp
@@ -44,6 +44,7 @@ void ETSUnionType::ToDebugInfoType(std::stringstream &ss) const
         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) {
@@ -69,10 +70,14 @@ void ETSUnionType::InitAssemblerTypeCache(ETSChecker *checker)
     } else {
         ss << "{U";
         for (size_t idx = 0; idx < assemblerConstituentTypes_.size(); idx++) {
-            assemblerConstituentTypes_[idx]->ToAssemblerTypeWithRank(ss);
-            if (idx != assemblerConstituentTypes_.size() - 1) {
+            if (idx != 0) {
                 ss << ",";
             }
+            if (assemblerConstituentTypes_[idx]->IsETSNullType()) {
+                ss << compiler::Signatures::NULL_ASSEMBLY_TYPE;
+                continue;
+            }
+            assemblerConstituentTypes_[idx]->ToAssemblerTypeWithRank(ss);
         }
         ss << "}";
     }
@@ -93,15 +98,16 @@ void ETSUnionType::CanonicalizedAssemblerType(ETSChecker *checker)
     }
 
     ES2PANDA_ASSERT(constituentTypes_.size() > 1);
+    bool hasNull = false;
     for (auto *type : constituentTypes_) {
         ES2PANDA_ASSERT(!type->IsETSUnionType());
         if (type->IsETSUndefinedType() || type->IsETSVoidType()) {
             continue;
         }
-        if (type->IsETSNullType()) {
-            assemblerConstituentTypes_.clear();
-            assemblerConstituentTypes_.push_back(checker->GlobalETSObjectType());
-            return;
+        if (type->IsETSNullType() && !hasNull) {
+            hasNull = true;
+            assemblerConstituentTypes_.push_back(type);
+            continue;
         }
         if (type->IsTypeError()) {
             assemblerConstituentTypes_.clear();
@@ -133,7 +139,6 @@ ETSUnionType::ETSUnionType(ETSChecker *checker, ArenaVector<Type *> &&constituen
       assemblerConstituentTypes_(checker->ProgramAllocator()->Adapter())
 {
     ES2PANDA_ASSERT(constituentTypes_.size() > 1);
-    assemblerLub_ = ComputeAssemblerLUB(checker, this);
     CanonicalizedAssemblerType(checker);
     InitAssemblerTypeCache(checker);
 }
@@ -150,49 +155,6 @@ bool ETSUnionType::TypeRelatedToSomeType(TypeRelation *relation, Type *source, E
                        [relation, source](auto *t) { return relation->IsIdenticalTo(source, t); });
 }
 
-// This function computes effective runtime representation of union type
-Type *ETSUnionType::ComputeAssemblerLUB(ETSChecker *checker, ETSUnionType *un)
-{
-    auto *const apparent = checker->GetApparentType(un);
-    if (!apparent->IsETSUnionType()) {
-        return apparent;
-    }
-    if (apparent != un) {
-        return apparent->AsETSUnionType()->assemblerLub_;
-    }
-    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;
-            continue;
-        }
-        if (lub == t || t->IsETSUndefinedType()) {
-            continue;
-        }
-        if (t->IsETSNullType()) {
-            return checker->GetGlobalTypesHolder()->GlobalETSObjectType();
-        }
-        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();
-        }
-    }
-    return checker->GetNonConstantType(lub);
-}
-
 void ETSUnionType::Identical(TypeRelation *relation, Type *other)
 {
     if (other->IsETSUnionType()) {
diff --git a/ets2panda/checker/types/ets/etsUnionType.h b/ets2panda/checker/types/ets/etsUnionType.h
index be1d6c3b29..3a4006b71c 100644
--- a/ets2panda/checker/types/ets/etsUnionType.h
+++ b/ets2panda/checker/types/ets/etsUnionType.h
@@ -54,12 +54,6 @@ public:
 
     [[nodiscard]] ArenaVector<Type *> GetNonConstantTypes(ETSChecker *checker) const noexcept;
 
-    // Do not use it anywhere except codegen
-    Type *GetAssemblerLUB() const noexcept
-    {
-        return assemblerLub_;
-    }
-
     const util::StringView &GetAssemblerType() const
     {
         return assemblerTypeCache_;
@@ -70,6 +64,26 @@ public:
         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>
     [[nodiscard]] bool AllOfConstituentTypes(UnaryPredicate p) const noexcept
     {
@@ -115,14 +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_;
     ArenaVector<Type *> assemblerConstituentTypes_;
     util::StringView assemblerTypeCache_;
-    Type *assemblerLub_ {nullptr};
 };
 }  // namespace ark::es2panda::checker
 
diff --git a/ets2panda/compiler/core/ETSGen.cpp b/ets2panda/compiler/core/ETSGen.cpp
index 4e62393a95..f60ed50362 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 084e2edfa2..a94f57e526 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)
     {
@@ -477,9 +479,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 376ae87f82..4e2d1069a8 100644
--- a/ets2panda/compiler/core/ETSemitter.cpp
+++ b/ets2panda/compiler/core/ETSemitter.cpp
@@ -296,11 +296,9 @@ void ETSEmitter::GenAnnotation()
         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));
-        }
+        auto unionRecord = pandasm::Record(unionType.Mutf8(), Program()->lang);
+        unionRecord.metadata->SetAttribute(Signatures::EXTERNAL);
+        Program()->recordTable.emplace(unionRecord.name, std::move(unionRecord));
     }
 }
 
diff --git a/ets2panda/compiler/scripts/signatures.yaml b/ets2panda/compiler/scripts/signatures.yaml
index 5366d99f38..a163b3a0b4 100644
--- a/ets2panda/compiler/scripts/signatures.yaml
+++ b/ets2panda/compiler/scripts/signatures.yaml
@@ -147,6 +147,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'
@@ -777,7 +779,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/test/unit/union_emit_test.cpp b/ets2panda/test/unit/union_emit_test.cpp
index d63214db56..5e73a42a41 100644
--- a/ets2panda/test/unit/union_emit_test.cpp
+++ b/ets2panda/test/unit/union_emit_test.cpp
@@ -24,10 +24,30 @@ public:
 
     ~UnionAsmTest() override = default;
 
-    void CheckUnionType(std::string_view recordName)
+    void CheckUnionType(std::string_view recordName, bool found = true)
     {
         pandasm::Record *rec = GetRecord(recordName, program_);
-        ASSERT_TRUE(rec != nullptr) << "Type '" << recordName << "' not found";
+        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:
@@ -143,4 +163,76 @@ TEST_F(UnionAsmTest, union_test_arrays)
     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