diff --git a/ets2panda/BUILD.gn b/ets2panda/BUILD.gn
index 6a29659a5f81d0b0b688016ff33f10360aa8f0b9..25c5c32238ac5a76cead8552951c46f4ff19debd 100644
--- a/ets2panda/BUILD.gn
+++ b/ets2panda/BUILD.gn
@@ -65,6 +65,7 @@ libes2panda_sources = [
   "checker/types/ets/doubleType.cpp",
   "checker/types/ets/etsArrayType.cpp",
   "checker/types/ets/etsAsyncFuncReturnType.cpp",
+  "checker/types/ets/etsBigIntType.cpp",
   "checker/types/ets/etsBooleanType.cpp",
   "checker/types/ets/etsDynamicType.cpp",
   "checker/types/ets/etsEnumType.cpp",
diff --git a/ets2panda/CMakeLists.txt b/ets2panda/CMakeLists.txt
index 463ac9740cc65699399329dc2787691508ead700..67dfc925c7a3fe25f5f1aef861d1dd890eb5395f 100644
--- a/ets2panda/CMakeLists.txt
+++ b/ets2panda/CMakeLists.txt
@@ -372,6 +372,7 @@ set(ES2PANDA_LIB_SRC
   checker/types/ets/etsFunctionType.cpp
   checker/types/ets/etsObjectType.cpp
   checker/types/ets/etsStringType.cpp
+  checker/types/ets/etsBigIntType.cpp
   checker/types/ets/etsTypeParameter.cpp
   checker/types/ets/etsUnionType.cpp
   checker/types/ets/etsVoidType.cpp
diff --git a/ets2panda/checker/ETSchecker.cpp b/ets2panda/checker/ETSchecker.cpp
index 4144da1ef35b883dced383245d7f619cea334c73..a93801fe87fe0cc444a2ebe841a003c51a39fdb6 100644
--- a/ets2panda/checker/ETSchecker.cpp
+++ b/ets2panda/checker/ETSchecker.cpp
@@ -221,6 +221,11 @@ Type *ETSChecker::GlobalETSStringLiteralType() const
     return GetGlobalTypesHolder()->GlobalETSStringLiteralType();
 }
 
+Type *ETSChecker::GlobalETSBigIntLiteralType() const
+{
+    return GetGlobalTypesHolder()->GlobalETSBigIntBuiltinType();
+}
+
 Type *ETSChecker::GlobalWildcardType() const
 {
     return GetGlobalTypesHolder()->GlobalWildcardType();
@@ -236,6 +241,11 @@ ETSObjectType *ETSChecker::GlobalBuiltinETSStringType() const
     return AsETSObjectType(&GlobalTypesHolder::GlobalETSStringBuiltinType);
 }
 
+ETSObjectType *ETSChecker::GlobalBuiltinETSBigIntType() const
+{
+    return AsETSObjectType(&GlobalTypesHolder::GlobalETSBigIntBuiltinType);
+}
+
 ETSObjectType *ETSChecker::GlobalBuiltinTypeType() const
 {
     return AsETSObjectType(&GlobalTypesHolder::GlobalTypeBuiltinType);
diff --git a/ets2panda/checker/ETSchecker.h b/ets2panda/checker/ETSchecker.h
index 87fc469310256e6f5cdb6c2ae77fe7c722b4cd85..808d3cfa84d2241c836bc8dd3e315304e3012f84 100644
--- a/ets2panda/checker/ETSchecker.h
+++ b/ets2panda/checker/ETSchecker.h
@@ -22,6 +22,7 @@
 #include "varbinder/enumMemberResult.h"
 #include "ir/ts/tsTypeParameter.h"
 #include "ir/ts/tsTypeParameterInstantiation.h"
+#include "lexer/token/tokenType.h"
 #include "util/enumbitops.h"
 #include "util/ustring.h"
 #include "checker/resolveResult.h"
@@ -98,10 +99,12 @@ public:
     Type *GlobalETSNullType() const;
     Type *GlobalETSUndefinedType() const;
     Type *GlobalETSStringLiteralType() const;
+    Type *GlobalETSBigIntLiteralType() const;
     Type *GlobalWildcardType() const;
 
     ETSObjectType *GlobalETSObjectType() const;
     ETSObjectType *GlobalBuiltinETSStringType() const;
+    ETSObjectType *GlobalBuiltinETSBigIntType() const;
     ETSObjectType *GlobalBuiltinTypeType() const;
     ETSObjectType *GlobalBuiltinExceptionType() const;
     ETSObjectType *GlobalBuiltinErrorType() const;
@@ -124,6 +127,10 @@ public:
     Type *CheckTypeCached(ir::Expression *expr) override;
     void ResolveStructuredTypeMembers([[maybe_unused]] Type *type) override {}
     Type *GetTypeOfVariable([[maybe_unused]] varbinder::Variable *var) override;
+    bool IsETSChecker() override
+    {
+        return true;
+    }
 
     // Object
     ETSObjectType *BuildClassProperties(ir::ClassDefinition *class_def);
@@ -177,6 +184,7 @@ public:
     LongType *CreateLongType(int64_t value);
     ShortType *CreateShortType(int16_t value);
     CharType *CreateCharType(char16_t value);
+    ETSBigIntType *CreateETSBigIntLiteralType(util::StringView value);
     ETSStringType *CreateETSStringLiteralType(util::StringView value);
     ETSArrayType *CreateETSArrayType(Type *element_type);
     Type *CreateETSUnionType(ArenaVector<Type *> &&constituent_types);
@@ -203,6 +211,7 @@ public:
     // Arithmetic
     Type *NegateNumericType(Type *type, ir::Expression *node);
     Type *BitwiseNegateIntegralType(Type *type, ir::Expression *node);
+    bool CheckBinaryOperatorForBigInt(Type *left, Type *right, lexer::TokenType operation);
     std::tuple<Type *, Type *> CheckBinaryOperator(ir::Expression *left, ir::Expression *right, ir::Expression *expr,
                                                    lexer::TokenType operation_type, lexer::SourcePosition pos,
                                                    bool force_promotion = false);
@@ -285,11 +294,9 @@ public:
                                 const ArenaVector<ir::Expression *> &arguments,
                                 const std::vector<bool> &arg_type_inference_required);
     Signature *ChooseMostSpecificSignature(ArenaVector<Signature *> &signatures,
-                                           const ArenaVector<ir::Expression *> &arguments,
                                            const std::vector<bool> &arg_type_inference_required,
                                            const lexer::SourcePosition &pos, size_t arguments_size = ULONG_MAX);
     Signature *ChooseMostSpecificProxySignature(ArenaVector<Signature *> &signatures,
-                                                const ArenaVector<ir::Expression *> &arguments,
                                                 const std::vector<bool> &arg_type_inference_required,
                                                 const lexer::SourcePosition &pos, size_t arguments_size);
     Signature *ResolveCallExpression(ArenaVector<Signature *> &signatures,
@@ -402,6 +409,8 @@ public:
     bool IsNullLikeOrVoidExpression(const ir::Expression *expr) const;
     bool IsConstantExpression(ir::Expression *expr, Type *type);
     void ValidateUnaryOperatorOperand(varbinder::Variable *variable);
+    bool TestUnionType(Type *type, TypeFlag test);
+    bool CheckPossibilityPromotion(Type *left, Type *right, TypeFlag test);
     std::tuple<Type *, bool> ApplyBinaryOperatorPromotion(Type *left, Type *right, TypeFlag test,
                                                           bool do_promotion = true);
     checker::Type *ApplyConditionalOperatorPromotion(checker::ETSChecker *checker, checker::Type *unboxed_l,
@@ -587,9 +596,16 @@ private:
     }
 
     ArenaVector<Type *> CreateTypeForTypeParameters(ir::TSTypeParameterDeclaration *type_params);
+
     Type *CreateTypeParameterType(ir::TSTypeParameter *param);
+
+    using Type2TypeMap = std::unordered_map<std::string_view, std::string_view>;
+    void CheckTypeParameterConstraint(ir::TSTypeParameter *param, Type2TypeMap &extends);
+
     void SetUpTypeParameterConstraint(ir::TSTypeParameter *param);
     ETSObjectType *SetUpParameterType(ir::TSTypeParameter *param);
+    ETSObjectType *UpdateGlobalType(ETSObjectType *obj_type, util::StringView name);
+    ETSObjectType *UpdateBoxedGlobalType(ETSObjectType *obj_type, util::StringView name);
     ETSObjectType *CreateETSObjectTypeCheckBuiltins(util::StringView name, ir::AstNode *decl_node,
                                                     ETSObjectFlags flags);
     void CheckProgram(parser::Program *program, bool run_analysis = false);
diff --git a/ets2panda/checker/checker.h b/ets2panda/checker/checker.h
index 9927c78589745ccaa56b973dd6495904e8a761e0..5113779226950fb67d74d8552e565aea4acd33b1 100644
--- a/ets2panda/checker/checker.h
+++ b/ets2panda/checker/checker.h
@@ -139,6 +139,11 @@ public:
         return type_stack_;
     }
 
+    virtual bool IsETSChecker()
+    {
+        return false;
+    }
+
     ETSChecker *AsETSChecker()
     {
         return reinterpret_cast<ETSChecker *>(this);
diff --git a/ets2panda/checker/ets/arithmetic.cpp b/ets2panda/checker/ets/arithmetic.cpp
index c78ac64ba9fe7e3ef3070a9a058a2e7686fb89d1..dd25c293ef61169e436d3af5ed03fbba8cc9ac63 100644
--- a/ets2panda/checker/ets/arithmetic.cpp
+++ b/ets2panda/checker/ets/arithmetic.cpp
@@ -126,6 +126,44 @@ Type *ETSChecker::HandleRelationOperationOnTypes(Type *left, Type *right, lexer:
     return PerformRelationOperationOnTypes<IntType>(left, right, operation_type);
 }
 
+bool ETSChecker::CheckBinaryOperatorForBigInt(Type *left, Type *right, lexer::TokenType operation)
+{
+    if ((left == nullptr) || (right == nullptr)) {
+        return false;
+    }
+
+    if (!left->IsETSObjectType() || !left->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::BUILTIN_BIGINT)) {
+        return false;
+    }
+
+    if (!right->IsETSObjectType() || !right->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::BUILTIN_BIGINT)) {
+        return false;
+    }
+
+    bool both_const = false;
+    if (left->HasTypeFlag(TypeFlag::CONSTANT) && right->HasTypeFlag(TypeFlag::CONSTANT)) {
+        both_const = true;
+    }
+
+    switch (operation) {
+        case lexer::TokenType::PUNCTUATOR_EQUAL:
+        case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL:
+        case lexer::TokenType::KEYW_INSTANCEOF:
+            // This is handled in the main CheckBinaryOperator function
+            return false;
+        default:
+            break;
+    }
+
+    if (!both_const) {
+        // Nothing else to be done here, return
+        return true;
+    }
+
+    // NOTE(kkonsw): if both objects are const we can perform operations during compilation
+    return true;
+}
+
 checker::Type *ETSChecker::CheckBinaryOperatorMulDivMod(ir::Expression *left, ir::Expression *right,
                                                         lexer::TokenType operation_type, lexer::SourcePosition pos,
                                                         bool is_equal_op, checker::Type *const left_type,
@@ -139,6 +177,10 @@ checker::Type *ETSChecker::CheckBinaryOperatorMulDivMod(ir::Expression *left, ir
     FlagExpressionWithUnboxing(left_type, unboxed_l, left);
     FlagExpressionWithUnboxing(right_type, unboxed_r, right);
 
+    if (left_type->IsETSUnionType() || right_type->IsETSUnionType()) {
+        ThrowTypeError("Bad operand type, unions are not allowed in binary expressions except equality.", pos);
+    }
+
     if (promotedType == nullptr && !bothConst) {
         ThrowTypeError("Bad operand type, the types of the operands must be numeric type.", pos);
     }
@@ -156,7 +198,16 @@ checker::Type *ETSChecker::CheckBinaryOperatorPlus(ir::Expression *left, ir::Exp
                                                    bool is_equal_op, checker::Type *const left_type,
                                                    checker::Type *const right_type, Type *unboxed_l, Type *unboxed_r)
 {
+    if (left_type->IsETSUnionType() || right_type->IsETSUnionType()) {
+        ThrowTypeError("Bad operand type, unions are not allowed in binary expressions except equality.", pos);
+    }
+
     if (left_type->IsETSStringType() || right_type->IsETSStringType()) {
+        if (operation_type == lexer::TokenType::PUNCTUATOR_MINUS ||
+            operation_type == lexer::TokenType::PUNCTUATOR_MINUS_EQUAL) {
+            ThrowTypeError("Bad operand type, the types of the operands must be numeric type.", pos);
+        }
+
         return HandleStringConcatenation(left_type, right_type);
     }
 
@@ -182,6 +233,10 @@ checker::Type *ETSChecker::CheckBinaryOperatorShift(ir::Expression *left, ir::Ex
                                                     bool is_equal_op, checker::Type *const left_type,
                                                     checker::Type *const right_type, Type *unboxed_l, Type *unboxed_r)
 {
+    if (left_type->IsETSUnionType() || right_type->IsETSUnionType()) {
+        ThrowTypeError("Bad operand type, unions are not allowed in binary expressions except equality.", pos);
+    }
+
     auto promoted_left_type = ApplyUnaryOperatorPromotion(unboxed_l, false, !is_equal_op);
     auto promoted_right_type = ApplyUnaryOperatorPromotion(unboxed_r, false, !is_equal_op);
 
@@ -225,6 +280,10 @@ checker::Type *ETSChecker::CheckBinaryOperatorBitwise(ir::Expression *left, ir::
                                                       bool is_equal_op, checker::Type *const left_type,
                                                       checker::Type *const right_type, Type *unboxed_l, Type *unboxed_r)
 {
+    if (left_type->IsETSUnionType() || right_type->IsETSUnionType()) {
+        ThrowTypeError("Bad operand type, unions are not allowed in binary expressions except equality.", pos);
+    }
+
     if (unboxed_l != nullptr && unboxed_l->HasTypeFlag(checker::TypeFlag::ETS_BOOLEAN) && unboxed_r != nullptr &&
         unboxed_r->HasTypeFlag(checker::TypeFlag::ETS_BOOLEAN)) {
         FlagExpressionWithUnboxing(left_type, unboxed_l, left);
@@ -253,6 +312,10 @@ checker::Type *ETSChecker::CheckBinaryOperatorLogical(ir::Expression *left, ir::
                                                       lexer::SourcePosition pos, checker::Type *const left_type,
                                                       checker::Type *const right_type, Type *unboxed_l, Type *unboxed_r)
 {
+    if (left_type->IsETSUnionType() || right_type->IsETSUnionType()) {
+        ThrowTypeError("Bad operand type, unions are not allowed in binary expressions except equality.", pos);
+    }
+
     if (unboxed_l == nullptr || !unboxed_l->IsConditionalExprType() || unboxed_r == nullptr ||
         !unboxed_r->IsConditionalExprType()) {
         ThrowTypeError("Bad operand type, the types of the operands must be of possible condition type.", pos);
@@ -278,8 +341,8 @@ std::tuple<Type *, Type *> ETSChecker::CheckBinaryOperatorStrictEqual(ir::Expres
                                                                       checker::Type *const right_type)
 {
     checker::Type *ts_type {};
-    if (!(left_type->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) ||
-        !(right_type->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT))) {
+    if (!(left_type->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT) || left_type->IsETSUnionType()) ||
+        !(right_type->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT) || right_type->IsETSUnionType())) {
         ThrowTypeError("Both operands have to be reference types", pos);
     }
 
@@ -374,6 +437,12 @@ std::tuple<Type *, Type *> ETSChecker::CheckBinaryOperatorLessGreater(
     ir::Expression *left, ir::Expression *right, lexer::TokenType operation_type, lexer::SourcePosition pos,
     bool is_equal_op, checker::Type *const left_type, checker::Type *const right_type, Type *unboxed_l, Type *unboxed_r)
 {
+    if ((left_type->IsETSUnionType() || right_type->IsETSUnionType()) &&
+        operation_type != lexer::TokenType::PUNCTUATOR_EQUAL &&
+        operation_type != lexer::TokenType::PUNCTUATOR_NOT_EQUAL) {
+        ThrowTypeError("Bad operand type, unions are not allowed in binary expressions except equality.", pos);
+    }
+
     checker::Type *ts_type {};
     auto [promotedType, bothConst] =
         ApplyBinaryOperatorPromotion(unboxed_l, unboxed_r, TypeFlag::ETS_NUMERIC, !is_equal_op);
@@ -454,83 +523,82 @@ Type *ETSChecker::CheckBinaryOperatorNullishCoalescing(ir::Expression *right, le
     return FindLeastUpperBound(non_nullish_left_type, right_type);
 }
 
-// NOLINTNEXTLINE(readability-function-size)
-std::tuple<Type *, Type *> ETSChecker::CheckBinaryOperator(ir::Expression *left, ir::Expression *right,
-                                                           ir::Expression *expr, lexer::TokenType operation_type,
-                                                           lexer::SourcePosition pos, bool force_promotion)
+using CheckBinaryFunction = std::function<checker::Type *(
+    ETSChecker *, ir::Expression *left, ir::Expression *right, lexer::TokenType operation_type,
+    lexer::SourcePosition pos, bool is_equal_op, checker::Type *const left_type, checker::Type *const right_type,
+    Type *unboxed_l, Type *unboxed_r)>;
+
+std::map<lexer::TokenType, CheckBinaryFunction> check_map = {
+    {lexer::TokenType::PUNCTUATOR_MULTIPLY, &ETSChecker::CheckBinaryOperatorMulDivMod},
+    {lexer::TokenType::PUNCTUATOR_MULTIPLY_EQUAL, &ETSChecker::CheckBinaryOperatorMulDivMod},
+    {lexer::TokenType::PUNCTUATOR_DIVIDE, &ETSChecker::CheckBinaryOperatorMulDivMod},
+    {lexer::TokenType::PUNCTUATOR_DIVIDE_EQUAL, &ETSChecker::CheckBinaryOperatorMulDivMod},
+    {lexer::TokenType::PUNCTUATOR_MOD, &ETSChecker::CheckBinaryOperatorMulDivMod},
+    {lexer::TokenType::PUNCTUATOR_MOD_EQUAL, &ETSChecker::CheckBinaryOperatorMulDivMod},
+
+    {lexer::TokenType::PUNCTUATOR_MINUS, &ETSChecker::CheckBinaryOperatorPlus},
+    {lexer::TokenType::PUNCTUATOR_MINUS_EQUAL, &ETSChecker::CheckBinaryOperatorPlus},
+    {lexer::TokenType::PUNCTUATOR_PLUS, &ETSChecker::CheckBinaryOperatorPlus},
+    {lexer::TokenType::PUNCTUATOR_PLUS_EQUAL, &ETSChecker::CheckBinaryOperatorPlus},
+
+    {lexer::TokenType::PUNCTUATOR_LEFT_SHIFT, &ETSChecker::CheckBinaryOperatorShift},
+    {lexer::TokenType::PUNCTUATOR_LEFT_SHIFT_EQUAL, &ETSChecker::CheckBinaryOperatorShift},
+    {lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT, &ETSChecker::CheckBinaryOperatorShift},
+    {lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT_EQUAL, &ETSChecker::CheckBinaryOperatorShift},
+    {lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT, &ETSChecker::CheckBinaryOperatorShift},
+    {lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL, &ETSChecker::CheckBinaryOperatorShift},
+
+    {lexer::TokenType::PUNCTUATOR_BITWISE_OR, &ETSChecker::CheckBinaryOperatorBitwise},
+    {lexer::TokenType::PUNCTUATOR_BITWISE_OR_EQUAL, &ETSChecker::CheckBinaryOperatorBitwise},
+    {lexer::TokenType::PUNCTUATOR_BITWISE_AND, &ETSChecker::CheckBinaryOperatorBitwise},
+    {lexer::TokenType::PUNCTUATOR_BITWISE_AND_EQUAL, &ETSChecker::CheckBinaryOperatorBitwise},
+    {lexer::TokenType::PUNCTUATOR_BITWISE_XOR, &ETSChecker::CheckBinaryOperatorBitwise},
+    {lexer::TokenType::PUNCTUATOR_BITWISE_XOR_EQUAL, &ETSChecker::CheckBinaryOperatorBitwise},
+};
+
+struct BinaryOperatorParams {
+    ir::Expression *left;
+    ir::Expression *right;
+    ir::Expression *expr;
+    lexer::TokenType operation_type;
+    lexer::SourcePosition pos;
+    bool is_equal_op;
+};
+
+struct TypeParams {
+    checker::Type *left_type;
+    checker::Type *right_type;
+    Type *unboxed_l;
+    Type *unboxed_r;
+};
+
+static std::tuple<Type *, Type *> CheckBinaryOperatorHelper(ETSChecker *checker,
+                                                            const BinaryOperatorParams &binary_params,
+                                                            const TypeParams &type_params)
 {
-    checker::Type *const left_type = left->Check(this);
-    checker::Type *const right_type = right->Check(this);
-    const bool is_logical_extended_operator = (operation_type == lexer::TokenType::PUNCTUATOR_LOGICAL_AND) ||
-                                              (operation_type == lexer::TokenType::PUNCTUATOR_LOGICAL_OR);
-    Type *unboxed_l = is_logical_extended_operator ? ETSBuiltinTypeAsConditionalType(left_type)
-                                                   : ETSBuiltinTypeAsPrimitiveType(left_type);
-    Type *unboxed_r = is_logical_extended_operator ? ETSBuiltinTypeAsConditionalType(right_type)
-                                                   : ETSBuiltinTypeAsPrimitiveType(right_type);
-
+    ir::Expression *left = binary_params.left;
+    ir::Expression *right = binary_params.right;
+    lexer::SourcePosition pos = binary_params.pos;
+    checker::Type *const left_type = type_params.left_type;
+    checker::Type *const right_type = type_params.right_type;
+    Type *unboxed_l = type_params.unboxed_l;
+    Type *unboxed_r = type_params.unboxed_r;
     checker::Type *ts_type {};
-    bool is_equal_op = (operation_type > lexer::TokenType::PUNCTUATOR_SUBSTITUTION &&
-                        operation_type < lexer::TokenType::PUNCTUATOR_ARROW) &&
-                       !force_promotion;
-
-    switch (operation_type) {
-        case lexer::TokenType::PUNCTUATOR_MULTIPLY:
-        case lexer::TokenType::PUNCTUATOR_MULTIPLY_EQUAL:
-        case lexer::TokenType::PUNCTUATOR_DIVIDE:
-        case lexer::TokenType::PUNCTUATOR_DIVIDE_EQUAL:
-        case lexer::TokenType::PUNCTUATOR_MOD:
-        case lexer::TokenType::PUNCTUATOR_MOD_EQUAL: {
-            ts_type = CheckBinaryOperatorMulDivMod(left, right, operation_type, pos, is_equal_op, left_type, right_type,
-                                                   unboxed_l, unboxed_r);
-            break;
-        }
-        case lexer::TokenType::PUNCTUATOR_MINUS:
-        case lexer::TokenType::PUNCTUATOR_MINUS_EQUAL: {
-            if (left_type->IsETSStringType() || right_type->IsETSStringType()) {
-                ThrowTypeError("Bad operand type, the types of the operands must be numeric type.", pos);
-            }
-
-            [[fallthrough]];
-        }
-        case lexer::TokenType::PUNCTUATOR_PLUS:
-        case lexer::TokenType::PUNCTUATOR_PLUS_EQUAL: {
-            ts_type = CheckBinaryOperatorPlus(left, right, operation_type, pos, is_equal_op, left_type, right_type,
-                                              unboxed_l, unboxed_r);
-            break;
-        }
-        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT:
-        case lexer::TokenType::PUNCTUATOR_LEFT_SHIFT_EQUAL:
-        case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT:
-        case lexer::TokenType::PUNCTUATOR_RIGHT_SHIFT_EQUAL:
-        case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT:
-        case lexer::TokenType::PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL: {
-            ts_type = CheckBinaryOperatorShift(left, right, operation_type, pos, is_equal_op, left_type, right_type,
-                                               unboxed_l, unboxed_r);
-            break;
-        }
-        case lexer::TokenType::PUNCTUATOR_BITWISE_OR:
-        case lexer::TokenType::PUNCTUATOR_BITWISE_OR_EQUAL:
-        case lexer::TokenType::PUNCTUATOR_BITWISE_AND:
-        case lexer::TokenType::PUNCTUATOR_BITWISE_AND_EQUAL:
-        case lexer::TokenType::PUNCTUATOR_BITWISE_XOR_EQUAL:
-        case lexer::TokenType::PUNCTUATOR_BITWISE_XOR: {
-            ts_type = CheckBinaryOperatorBitwise(left, right, operation_type, pos, is_equal_op, left_type, right_type,
-                                                 unboxed_l, unboxed_r);
-            break;
-        }
+    switch (binary_params.operation_type) {
         case lexer::TokenType::PUNCTUATOR_LOGICAL_AND:
         case lexer::TokenType::PUNCTUATOR_LOGICAL_OR: {
-            ts_type = CheckBinaryOperatorLogical(left, right, expr, pos, left_type, right_type, unboxed_l, unboxed_r);
+            ts_type = checker->CheckBinaryOperatorLogical(left, right, binary_params.expr, pos, left_type, right_type,
+                                                          unboxed_l, unboxed_r);
             break;
         }
         case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL:
         case lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL: {
-            return CheckBinaryOperatorStrictEqual(left, pos, left_type, right_type);
+            return checker->CheckBinaryOperatorStrictEqual(left, pos, left_type, right_type);
         }
         case lexer::TokenType::PUNCTUATOR_EQUAL:
         case lexer::TokenType::PUNCTUATOR_NOT_EQUAL: {
-            std::tuple<Type *, Type *> res =
-                CheckBinaryOperatorEqual(left, right, operation_type, pos, left_type, right_type, unboxed_l, unboxed_r);
+            std::tuple<Type *, Type *> res = checker->CheckBinaryOperatorEqual(
+                left, right, binary_params.operation_type, pos, left_type, right_type, unboxed_l, unboxed_r);
             if (!(std::get<0>(res) == nullptr && std::get<1>(res) == nullptr)) {
                 return res;
             }
@@ -540,18 +608,18 @@ std::tuple<Type *, Type *> ETSChecker::CheckBinaryOperator(ir::Expression *left,
         case lexer::TokenType::PUNCTUATOR_LESS_THAN_EQUAL:
         case lexer::TokenType::PUNCTUATOR_GREATER_THAN:
         case lexer::TokenType::PUNCTUATOR_GREATER_THAN_EQUAL: {
-            return CheckBinaryOperatorLessGreater(left, right, operation_type, pos, is_equal_op, left_type, right_type,
-                                                  unboxed_l, unboxed_r);
+            return checker->CheckBinaryOperatorLessGreater(left, right, binary_params.operation_type, pos,
+                                                           binary_params.is_equal_op, left_type, right_type, unboxed_l,
+                                                           unboxed_r);
         }
         case lexer::TokenType::KEYW_INSTANCEOF: {
-            return CheckBinaryOperatorInstanceOf(pos, left_type, right_type);
+            return checker->CheckBinaryOperatorInstanceOf(pos, left_type, right_type);
         }
         case lexer::TokenType::PUNCTUATOR_NULLISH_COALESCING: {
-            ts_type = CheckBinaryOperatorNullishCoalescing(right, pos, left_type, right_type);
+            ts_type = checker->CheckBinaryOperatorNullishCoalescing(right, pos, left_type, right_type);
             break;
         }
         default: {
-            // NOTE
             UNREACHABLE();
             break;
         }
@@ -560,6 +628,38 @@ std::tuple<Type *, Type *> ETSChecker::CheckBinaryOperator(ir::Expression *left,
     return {ts_type, ts_type};
 }
 
+std::tuple<Type *, Type *> ETSChecker::CheckBinaryOperator(ir::Expression *left, ir::Expression *right,
+                                                           ir::Expression *expr, lexer::TokenType op,
+                                                           lexer::SourcePosition pos, bool force_promotion)
+{
+    checker::Type *const left_type = left->Check(this);
+    checker::Type *const right_type = right->Check(this);
+    const bool is_logical_extended_operator =
+        (op == lexer::TokenType::PUNCTUATOR_LOGICAL_AND) || (op == lexer::TokenType::PUNCTUATOR_LOGICAL_OR);
+    Type *unboxed_l = is_logical_extended_operator ? ETSBuiltinTypeAsConditionalType(left_type)
+                                                   : ETSBuiltinTypeAsPrimitiveType(left_type);
+    Type *unboxed_r = is_logical_extended_operator ? ETSBuiltinTypeAsConditionalType(right_type)
+                                                   : ETSBuiltinTypeAsPrimitiveType(right_type);
+
+    checker::Type *ts_type {};
+    bool is_equal_op =
+        (op > lexer::TokenType::PUNCTUATOR_SUBSTITUTION && op < lexer::TokenType::PUNCTUATOR_ARROW) && !force_promotion;
+
+    if (CheckBinaryOperatorForBigInt(left_type, right_type, op)) {
+        return {left_type, right_type};
+    };
+
+    if (check_map.find(op) != check_map.end()) {
+        auto check = check_map[op];
+        ts_type = check(this, left, right, op, pos, is_equal_op, left_type, right_type, unboxed_l, unboxed_r);
+        return {ts_type, ts_type};
+    }
+
+    BinaryOperatorParams binary_params {left, right, expr, op, pos, is_equal_op};
+    TypeParams type_params {left_type, right_type, unboxed_l, unboxed_r};
+    return CheckBinaryOperatorHelper(this, binary_params, type_params);
+}
+
 Type *ETSChecker::HandleArithmeticOperationOnTypes(Type *left, Type *right, lexer::TokenType operation_type)
 {
     ASSERT(left->HasTypeFlag(TypeFlag::CONSTANT | TypeFlag::ETS_NUMERIC) &&
diff --git a/ets2panda/checker/ets/function.cpp b/ets2panda/checker/ets/function.cpp
index ed412dc6469d9ffd2ccddfa5f77ddb0856695366..9ca1872b485b17a40426b5e670580fafaa0d6a8d 100644
--- a/ets2panda/checker/ets/function.cpp
+++ b/ets2panda/checker/ets/function.cpp
@@ -290,10 +290,12 @@ bool ETSChecker::ValidateProxySignature(Signature *const signature,
         return false;
     }
 
-    const auto num_non_default_params =
-        signature->Params().size() - signature->Function()->Body()->AsBlockStatement()->Statements().size();
+    auto const *const proxy_param = signature->Function()->Params().back()->AsETSParameterExpression();
+    if (!proxy_param->Ident()->Name().Is(ir::PROXY_PARAMETER_NAME)) {
+        return false;
+    }
 
-    if (arguments.size() < num_non_default_params) {
+    if (arguments.size() < proxy_param->GetRequiredParams()) {
         return false;
     }
 
@@ -355,7 +357,7 @@ Signature *ETSChecker::ValidateSignatures(ArenaVector<Signature *> &signatures,
 
     if (!compatible_signatures.empty()) {
         Signature *most_specific_signature =
-            ChooseMostSpecificSignature(compatible_signatures, arguments, arg_type_inference_required, pos);
+            ChooseMostSpecificSignature(compatible_signatures, arg_type_inference_required, pos);
 
         if (most_specific_signature == nullptr) {
             ThrowTypeError({"Reference to ", compatible_signatures.front()->Function()->Id()->Name(), " is ambiguous"},
@@ -366,17 +368,25 @@ Signature *ETSChecker::ValidateSignatures(ArenaVector<Signature *> &signatures,
             return nullptr;
         }
 
+        // Just to avoid extra nesting level
+        auto const check_ambiguous = [this, most_specific_signature,
+                                      &pos](Signature const *const proxy_signature) -> void {
+            auto const *const proxy_param = proxy_signature->Function()->Params().back()->AsETSParameterExpression();
+            if (!proxy_param->Ident()->Name().Is(ir::PROXY_PARAMETER_NAME)) {
+                ThrowTypeError({"Proxy parameter '", proxy_param->Ident()->Name(), "' has invalid name."}, pos);
+            }
+
+            if (most_specific_signature->Params().size() == proxy_param->GetRequiredParams()) {
+                ThrowTypeError({"Reference to ", most_specific_signature->Function()->Id()->Name(), " is ambiguous"},
+                               pos);
+            }
+        };
+
         if (!proxy_signatures.empty()) {
-            auto *const proxy_signature = ChooseMostSpecificProxySignature(
-                proxy_signatures, arguments, arg_type_inference_required, pos, arguments.size());
+            auto *const proxy_signature =
+                ChooseMostSpecificProxySignature(proxy_signatures, arg_type_inference_required, pos, arguments.size());
             if (proxy_signature != nullptr) {
-                const size_t num_non_default_params =
-                    proxy_signature->Params().size() -
-                    proxy_signature->Function()->Body()->AsBlockStatement()->Statements().size();
-                if (most_specific_signature->Params().size() == num_non_default_params) {
-                    ThrowTypeError(
-                        {"Reference to ", most_specific_signature->Function()->Id()->Name(), " is ambiguous"}, pos);
-                }
+                check_ambiguous(proxy_signature);
             }
         }
 
@@ -384,8 +394,8 @@ Signature *ETSChecker::ValidateSignatures(ArenaVector<Signature *> &signatures,
     }
 
     if (!proxy_signatures.empty()) {
-        auto *const proxy_signature = ChooseMostSpecificProxySignature(
-            proxy_signatures, arguments, arg_type_inference_required, pos, arguments.size());
+        auto *const proxy_signature =
+            ChooseMostSpecificProxySignature(proxy_signatures, arg_type_inference_required, pos, arguments.size());
         if (proxy_signature != nullptr) {
             return proxy_signature;
         }
@@ -399,7 +409,6 @@ Signature *ETSChecker::ValidateSignatures(ArenaVector<Signature *> &signatures,
 }
 
 Signature *ETSChecker::ChooseMostSpecificSignature(ArenaVector<Signature *> &signatures,
-                                                   const ArenaVector<ir::Expression *> &arguments,
                                                    const std::vector<bool> &arg_type_inference_required,
                                                    const lexer::SourcePosition &pos, size_t arguments_size)
 {
@@ -422,8 +431,8 @@ Signature *ETSChecker::ChooseMostSpecificSignature(ArenaVector<Signature *> &sig
     // Collect which signatures are most specific for each parameter.
     ArenaMultiMap<size_t /* parameter index */, Signature *> best_signatures_for_parameter(Allocator()->Adapter());
 
-    checker::SavedTypeRelationFlagsContext saved_type_relation_flag_ctx(Relation(),
-                                                                        TypeRelationFlag::ONLY_CHECK_WIDENING);
+    const checker::SavedTypeRelationFlagsContext saved_type_relation_flag_ctx(Relation(),
+                                                                              TypeRelationFlag::ONLY_CHECK_WIDENING);
 
     for (size_t i = 0; i < param_count; ++i) {
         if (arg_type_inference_required[i]) {
@@ -434,51 +443,56 @@ Signature *ETSChecker::ChooseMostSpecificSignature(ArenaVector<Signature *> &sig
         }
         // 1st step: check which is the most specific parameter type for i. parameter.
         Type *most_specific_type = signatures.front()->Params().at(i)->TsType();
+        Signature *prev_sig = signatures.front();
 
-        for (auto it = ++signatures.begin(); it != signatures.end(); ++it) {
-            Signature *sig = *it;
-            // Each signature must have the same amount of parameters.
-            if (arguments_size == ULONG_MAX) {
-                ASSERT(sig->Params().size() == param_count);
-            }
-
-            Type *sig_type = sig->Params().at(i)->TsType();
-
-            if (Relation()->IsIdenticalTo(sig_type, most_specific_type)) {
-                continue;
+        auto init_most_specific_type = [&most_specific_type, &prev_sig, i](Signature *sig) {
+            if (Type *sig_type = sig->Params().at(i)->TsType();
+                sig_type->IsETSObjectType() && !sig_type->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::INTERFACE)) {
+                most_specific_type = sig_type;
+                prev_sig = sig;
+                return true;
             }
+            return false;
+        };
 
+        auto evaluate_result = [this, &most_specific_type, &prev_sig, pos](Signature *sig, Type *sig_type) {
             if (Relation()->IsAssignableTo(sig_type, most_specific_type)) {
                 most_specific_type = sig_type;
+                prev_sig = sig;
+            } else if (sig_type->IsETSObjectType() && most_specific_type->IsETSObjectType() &&
+                       !Relation()->IsAssignableTo(most_specific_type, sig_type)) {
+                auto func_name = sig->Function()->Id()->Name();
+                ThrowTypeError({"Call to `", func_name, "` is ambiguous as `2` versions of `", func_name,
+                                "` are available: `", func_name, prev_sig, "` and `", func_name, sig, "`"},
+                               pos);
             }
-        }
+        };
 
-        // 2nd step: collect which signatures fit to the i. most specific parameter type.
-        Type *prev_sig_type = nullptr;
-        Signature *prev_sig = nullptr;
-        Type *arg_type = arguments.at(i)->TsType();
-        for (auto *sig : signatures) {
+        auto search_among_types = [this, &most_specific_type, arguments_size, param_count, i,
+                                   &evaluate_result](Signature *sig, const bool look_for_class_type) {
+            if (look_for_class_type && arguments_size == ULONG_MAX) {
+                [[maybe_unused]] const bool equal_param_size = sig->Params().size() == param_count;
+                ASSERT(equal_param_size);
+            }
             Type *sig_type = sig->Params().at(i)->TsType();
-            if (arg_type->IsETSObjectType()) {
-                auto it = std::find(arg_type->AsETSObjectType()->Interfaces().begin(),
-                                    arg_type->AsETSObjectType()->Interfaces().end(), sig_type);
-                bool found_coincidence = it != arg_type->AsETSObjectType()->Interfaces().end() ||
-                                         arg_type->AsETSObjectType()->SuperType() == sig_type;
-                if (found_coincidence && prev_sig_type != nullptr) {  // Ambiguous call
-                    bool is_assignable =
-                        IsTypeAssignableTo(prev_sig_type, sig_type) || IsTypeAssignableTo(sig_type, prev_sig_type);
-                    if (!is_assignable) {
-                        auto func_name = sig->Function()->Id()->Name();
-                        ThrowTypeError({"Call to `", func_name, "` is ambiguous as `2` versions of `", func_name,
-                                        "` are available: `", func_name, prev_sig, "` and `", func_name, sig, "`"},
-                                       pos);
-                    }
-                } else if (found_coincidence && !arg_type->IsETSStringType()) {
-                    prev_sig = sig;
-                    prev_sig_type = sig_type;
+            const bool is_class_type =
+                sig_type->IsETSObjectType() && !sig_type->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::INTERFACE);
+            if (is_class_type == look_for_class_type) {
+                if (Relation()->IsIdenticalTo(sig_type, most_specific_type)) {
+                    return;
                 }
+                evaluate_result(sig, sig_type);
             }
+        };
+
+        std::any_of(signatures.begin(), signatures.end(), init_most_specific_type);
+        std::for_each(signatures.begin(), signatures.end(),
+                      [&search_among_types](Signature *sig) mutable { search_among_types(sig, true); });
+        std::for_each(signatures.begin(), signatures.end(),
+                      [&search_among_types](Signature *sig) mutable { search_among_types(sig, false); });
 
+        for (auto *sig : signatures) {
+            Type *sig_type = sig->Params().at(i)->TsType();
             if (Relation()->IsIdenticalTo(sig_type, most_specific_type)) {
                 best_signatures_for_parameter.insert({i, sig});
             }
@@ -524,7 +538,6 @@ Signature *ETSChecker::ChooseMostSpecificSignature(ArenaVector<Signature *> &sig
 }
 
 Signature *ETSChecker::ChooseMostSpecificProxySignature(ArenaVector<Signature *> &signatures,
-                                                        const ArenaVector<ir::Expression *> &arguments,
                                                         const std::vector<bool> &arg_type_inference_required,
                                                         const lexer::SourcePosition &pos, size_t arguments_size)
 {
@@ -533,7 +546,7 @@ Signature *ETSChecker::ChooseMostSpecificProxySignature(ArenaVector<Signature *>
     }
 
     const auto most_specific_signature =
-        ChooseMostSpecificSignature(signatures, arguments, arg_type_inference_required, pos, arguments_size);
+        ChooseMostSpecificSignature(signatures, arg_type_inference_required, pos, arguments_size);
 
     if (most_specific_signature == nullptr) {
         const auto str = signatures.front()->Function()->Id()->Name().Mutf8().substr(
diff --git a/ets2panda/checker/ets/helpers.cpp b/ets2panda/checker/ets/helpers.cpp
index 73311393661a09964e961fe4673159a8a0ac6b8a..29ee49f655d5632fc39be47e6184e94c20e5e26a 100644
--- a/ets2panda/checker/ets/helpers.cpp
+++ b/ets2panda/checker/ets/helpers.cpp
@@ -75,6 +75,10 @@ void ETSChecker::CheckTruthinessOfType(ir::Expression *expr)
     checker::Type *type = expr->Check(this);
     auto *unboxed_type = ETSBuiltinTypeAsConditionalType(type);
 
+    if (unboxed_type == GlobalBuiltinVoidType() || unboxed_type->IsETSVoidType()) {
+        ThrowTypeError("An expression of type 'void' cannot be tested for truthiness", expr->Start());
+    }
+
     if (unboxed_type != nullptr && !unboxed_type->IsConditionalExprType()) {
         ThrowTypeError("Condition must be of possible condition type", expr->Start());
     }
@@ -439,7 +443,7 @@ void ETSChecker::ValidateResolvedIdentifier(ir::Identifier *const ident, varbind
 
             if (!resolved_type->IsETSObjectType() && !resolved_type->IsETSArrayType() &&
                 !resolved_type->IsETSEnumType() && !resolved_type->IsETSStringEnumType() &&
-                !resolved_type->IsETSUnionType()) {
+                !resolved_type->IsETSUnionType() && !resolved_type->HasTypeFlag(TypeFlag::ETS_PRIMITIVE)) {
                 throw_error();
             }
 
@@ -750,8 +754,13 @@ Type *ETSChecker::HandleBooleanLogicalOperatorsExtended(Type *left_type, Type *r
         IsNullLikeOrVoidExpression(expr->Right()) ? std::make_tuple(true, false) : right_type->ResolveConditionExpr();
 
     if (!resolve_left) {
-        // return the UNION type when it is implemented
-        return IsTypeIdenticalTo(left_type, right_type) ? left_type : GlobalETSBooleanType();
+        if (IsTypeIdenticalTo(left_type, right_type)) {
+            return left_type;
+        }
+        ArenaVector<checker::Type *> types(Allocator()->Adapter());
+        types.push_back(left_type);
+        types.push_back(right_type);
+        return CreateETSUnionType(std::move(types));
     }
 
     switch (expr->OperatorType()) {
@@ -1057,8 +1066,11 @@ void ETSChecker::SetPropertiesForModuleObject(checker::ETSObjectType *module_obj
 {
     auto *ets_binder = static_cast<varbinder::ETSBinder *>(VarBinder());
 
-    auto res = ets_binder->GetGlobalRecordTable()->Program()->ExternalSources().find(import_path);
-
+    auto ext_records = ets_binder->GetGlobalRecordTable()->Program()->ExternalSources();
+    auto res = [ets_binder, ext_records, import_path]() {
+        auto r = ext_records.find(import_path);
+        return r != ext_records.end() ? r : ext_records.find(ets_binder->GetResolvedImportPath(import_path));
+    }();
     for (auto [_, var] : res->second.front()->GlobalClassScope()->StaticFieldScope()->Bindings()) {
         (void)_;
         if (var->AsLocalVariable()->Declaration()->Node()->IsExported()) {
@@ -1341,7 +1353,7 @@ bool ETSChecker::IsTypeBuiltinType(Type *type)
 bool ETSChecker::IsReferenceType(const Type *type)
 {
     return type->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT) || type->IsETSNullLike() ||
-           type->IsETSStringType();
+           type->IsETSStringType() || type->IsETSBigIntType();
 }
 
 const ir::AstNode *ETSChecker::FindJumpTarget(ir::AstNodeType node_type, const ir::AstNode *node,
@@ -1446,18 +1458,6 @@ Type *ETSChecker::ETSBuiltinTypeAsConditionalType(Type *object_type)
         return nullptr;
     }
 
-    if (object_type->IsETSObjectType()) {
-        if (!object_type->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::UNBOXABLE_TYPE)) {
-            return object_type;
-        }
-        auto saved_result = Relation()->IsTrue();
-        Relation()->Result(false);
-
-        UnboxingConverter converter = UnboxingConverter(AsETSChecker(), Relation(), object_type, object_type);
-        Relation()->Result(saved_result);
-        return converter.Result();
-    }
-
     return object_type;
 }
 
@@ -1786,7 +1786,7 @@ void ETSChecker::CheckUnboxedTypesAssignable(TypeRelation *relation, Type *sourc
 void ETSChecker::CheckBoxedSourceTypeAssignable(TypeRelation *relation, Type *source, Type *target)
 {
     checker::SavedTypeRelationFlagsContext saved_type_relation_flag_ctx(
-        relation, TypeRelationFlag::ONLY_CHECK_WIDENING |
+        relation, (relation->ApplyWidening() ? TypeRelationFlag::WIDENING : TypeRelationFlag::NONE) |
                       (relation->ApplyNarrowing() ? TypeRelationFlag::NARROWING : TypeRelationFlag::NONE));
     auto *boxed_source_type = relation->GetChecker()->AsETSChecker()->PrimitiveTypeAsETSBuiltinType(source);
     if (boxed_source_type == nullptr) {
@@ -1804,7 +1804,7 @@ void ETSChecker::CheckBoxedSourceTypeAssignable(TypeRelation *relation, Type *so
         if (unboxed_target_type == nullptr) {
             return;
         }
-        NarrowingConverter(this, relation, unboxed_target_type, source);
+        NarrowingWideningConverter(this, relation, unboxed_target_type, source);
         if (relation->IsTrue()) {
             AddBoxingFlagToPrimitiveType(relation, target);
         }
@@ -2040,7 +2040,7 @@ Type *ETSChecker::GetTypeFromTypeAnnotation(ir::TypeNode *const type_annotation)
         return type;
     }
 
-    if (!type->HasTypeFlag(TypeFlag::ETS_ARRAY_OR_OBJECT)) {
+    if (!type->HasTypeFlag(TypeFlag::ETS_ARRAY_OR_OBJECT) && !type->HasTypeFlag(TypeFlag::ETS_UNION)) {
         ThrowTypeError("Non reference types cannot be nullish.", type_annotation->Start());
     }
 
diff --git a/ets2panda/checker/ets/object.cpp b/ets2panda/checker/ets/object.cpp
index 3de0b51247e8420256b92e76e1292216d3413a91..5baa4a4ab09f0ba56cadfd5c52a180f2c65b2cee 100644
--- a/ets2panda/checker/ets/object.cpp
+++ b/ets2panda/checker/ets/object.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2023 - 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
@@ -175,9 +175,20 @@ ArenaVector<Type *> ETSChecker::CreateTypeForTypeParameters(ir::TSTypeParameterD
     ArenaVector<Type *> result {Allocator()->Adapter()};
     checker::ScopeContext scope_ctx(this, type_params->Scope());
 
-    for (auto *const param : type_params->Params()) {
-        result.push_back(CreateTypeParameterType(param));
+    // Note: we have to run pure check loop first to avoid endless loop because of possible circular dependencies
+    Type2TypeMap extends {};
+    for (auto *const type_param : type_params->Params()) {
+        if (auto *const constraint = type_param->Constraint();
+            constraint != nullptr && constraint->IsETSTypeReference() &&
+            constraint->AsETSTypeReference()->Part()->Name()->IsIdentifier()) {
+            CheckTypeParameterConstraint(type_param, extends);
+        }
+    }
+
+    for (auto *const type_param : type_params->Params()) {
+        result.emplace_back(CreateTypeParameterType(type_param));
     }
+
     // The type parameter might be used in the constraint, like 'K extend Comparable<K>',
     // so we need to create their type first, then set up the constraint
     for (auto *const param : type_params->Params()) {
@@ -187,6 +198,35 @@ ArenaVector<Type *> ETSChecker::CreateTypeForTypeParameters(ir::TSTypeParameterD
     return result;
 }
 
+void ETSChecker::CheckTypeParameterConstraint(ir::TSTypeParameter *param, Type2TypeMap &extends)
+{
+    const auto type_param_name = param->Name()->Name().Utf8();
+    const auto constraint_name =
+        param->Constraint()->AsETSTypeReference()->Part()->Name()->AsIdentifier()->Name().Utf8();
+
+    if (type_param_name == constraint_name) {
+        ThrowTypeError({"Type parameter '", type_param_name, "' cannot extend/implement itself."},
+                       param->Constraint()->Start());
+    }
+
+    auto it = extends.find(type_param_name);
+    if (it != extends.cend()) {
+        ThrowTypeError({"Type parameter '", type_param_name, "' is duplicated in the list."},
+                       param->Constraint()->Start());
+    }
+
+    it = extends.find(constraint_name);
+    while (it != extends.cend()) {
+        if (it->second == type_param_name) {
+            ThrowTypeError({"Type parameter '", type_param_name, "' has circular constraint dependency."},
+                           param->Constraint()->Start());
+        }
+        it = extends.find(it->second);
+    }
+
+    extends.emplace(type_param_name, constraint_name);
+}
+
 Type *ETSChecker::CreateTypeParameterType(ir::TSTypeParameter *const param)
 {
     auto const instantiate_supertype = [this](TypeFlag nullish_flags) {
@@ -217,19 +257,10 @@ void ETSChecker::SetUpTypeParameterConstraint(ir::TSTypeParameter *const param)
         param_type = param->Name()->Variable()->TsType()->AsETSObjectType();
     }
     if (param->Constraint() != nullptr) {
-        if (param->Constraint()->IsETSTypeReference() &&
-            param->Constraint()->AsETSTypeReference()->Part()->Name()->IsIdentifier() &&
-            param->Name()->Name() ==
-                param->Constraint()->AsETSTypeReference()->Part()->Name()->AsIdentifier()->Name()) {
-            ThrowTypeError({"Type variable '", param->Name()->Name(), "' cannot depend on itself"},
-                           param->Constraint()->Start());
-        }
-
         if (param->Constraint()->IsETSTypeReference()) {
             const auto constraint_name =
                 param->Constraint()->AsETSTypeReference()->Part()->Name()->AsIdentifier()->Name();
             const auto *const type_param_scope = param->Parent()->AsTSTypeParameterDeclaration()->Scope();
-
             if (auto *const found_param =
                     type_param_scope->FindLocal(constraint_name, varbinder::ResolveBindingOptions::BINDINGS);
                 found_param != nullptr) {
diff --git a/ets2panda/checker/ets/typeCreation.cpp b/ets2panda/checker/ets/typeCreation.cpp
index 03be8f6bda655f04b4c21ddc1fdb27d9c413541e..4730f3581005d0bb1cb2177f99a92a3223991059 100644
--- a/ets2panda/checker/ets/typeCreation.cpp
+++ b/ets2panda/checker/ets/typeCreation.cpp
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#include <functional>
 #include "generated/signatures.h"
 #include "checker/ETSchecker.h"
 #include "checker/types/ets/etsDynamicFunctionType.h"
@@ -27,6 +28,7 @@
 #include "ir/ts/tsInterfaceDeclaration.h"
 #include "parser/program/program.h"
 #include "util/helpers.h"
+#include "checker/types/ts/bigintType.h"
 
 namespace panda::es2panda::checker {
 ByteType *ETSChecker::CreateByteType(int8_t value)
@@ -95,6 +97,11 @@ CharType *ETSChecker::CreateCharType(char16_t value)
     return Allocator()->New<CharType>(value);
 }
 
+ETSBigIntType *ETSChecker::CreateETSBigIntLiteralType(util::StringView value)
+{
+    return Allocator()->New<ETSBigIntType>(Allocator(), GlobalBuiltinETSBigIntType(), value);
+}
+
 ETSStringType *ETSChecker::CreateETSStringLiteralType(util::StringView value)
 {
     return Allocator()->New<ETSStringType>(Allocator(), GlobalBuiltinETSStringType(), value);
@@ -143,6 +150,7 @@ Type *ETSChecker::CreateETSUnionType(ArenaVector<Type *> &&constituent_types)
     }
 
     auto *new_union_type = Allocator()->New<ETSUnionType>(std::move(new_constituent_types));
+    new_union_type->SetLeastUpperBoundType(this);
 
     return ETSUnionType::HandleUnionType(new_union_type);
 }
@@ -209,9 +217,99 @@ ETSExtensionFuncHelperType *ETSChecker::CreateETSExtensionFuncHelperType(ETSFunc
     return Allocator()->New<ETSExtensionFuncHelperType>(class_method_type, extension_function_type);
 }
 
+std::map<util::StringView, GlobalTypeId> name_to_type_id = {
+    {compiler::Signatures::BUILTIN_BIGINT_CLASS, GlobalTypeId::ETS_BIG_INT_BUILTIN},
+    {compiler::Signatures::BUILTIN_STRING_CLASS, GlobalTypeId::ETS_STRING_BUILTIN},
+    {compiler::Signatures::BUILTIN_OBJECT_CLASS, GlobalTypeId::ETS_OBJECT_BUILTIN},
+    {compiler::Signatures::BUILTIN_EXCEPTION_CLASS, GlobalTypeId::ETS_EXCEPTION_BUILTIN},
+    {compiler::Signatures::BUILTIN_ERROR_CLASS, GlobalTypeId::ETS_ERROR_BUILTIN},
+    {compiler::Signatures::BUILTIN_TYPE_CLASS, GlobalTypeId::ETS_TYPE_BUILTIN},
+    {compiler::Signatures::BUILTIN_PROMISE_CLASS, GlobalTypeId::ETS_PROMISE_BUILTIN},
+    {compiler::Signatures::BUILTIN_BOX_CLASS, GlobalTypeId::ETS_BOX_BUILTIN},
+    {compiler::Signatures::BUILTIN_BOOLEAN_BOX_CLASS, GlobalTypeId::ETS_BOOLEAN_BOX_BUILTIN},
+    {compiler::Signatures::BUILTIN_BYTE_BOX_CLASS, GlobalTypeId::ETS_BYTE_BOX_BUILTIN},
+    {compiler::Signatures::BUILTIN_CHAR_BOX_CLASS, GlobalTypeId::ETS_CHAR_BOX_BUILTIN},
+    {compiler::Signatures::BUILTIN_SHORT_BOX_CLASS, GlobalTypeId::ETS_SHORT_BOX_BUILTIN},
+    {compiler::Signatures::BUILTIN_INT_BOX_CLASS, GlobalTypeId::ETS_INT_BOX_BUILTIN},
+    {compiler::Signatures::BUILTIN_LONG_BOX_CLASS, GlobalTypeId::ETS_LONG_BOX_BUILTIN},
+    {compiler::Signatures::BUILTIN_FLOAT_BOX_CLASS, GlobalTypeId::ETS_FLOAT_BOX_BUILTIN},
+    {compiler::Signatures::BUILTIN_DOUBLE_BOX_CLASS, GlobalTypeId::ETS_DOUBLE_BOX_BUILTIN},
+    {compiler::Signatures::BUILTIN_VOID_CLASS, GlobalTypeId::ETS_VOID_BUILTIN},
+};
+
+std::map<util::StringView, std::function<ETSObjectType *(const ETSChecker *)>> name_to_global_type = {
+    {compiler::Signatures::BUILTIN_BIGINT_CLASS, &ETSChecker::GlobalBuiltinETSBigIntType},
+    {compiler::Signatures::BUILTIN_STRING_CLASS, &ETSChecker::GlobalBuiltinETSStringType},
+    {compiler::Signatures::BUILTIN_OBJECT_CLASS, &ETSChecker::GlobalETSObjectType},
+    {compiler::Signatures::BUILTIN_EXCEPTION_CLASS, &ETSChecker::GlobalBuiltinExceptionType},
+    {compiler::Signatures::BUILTIN_ERROR_CLASS, &ETSChecker::GlobalBuiltinErrorType},
+    {compiler::Signatures::BUILTIN_TYPE_CLASS, &ETSChecker::GlobalBuiltinTypeType},
+    {compiler::Signatures::BUILTIN_PROMISE_CLASS, &ETSChecker::GlobalBuiltinPromiseType},
+    {compiler::Signatures::BUILTIN_VOID_CLASS, &ETSChecker::GlobalBuiltinVoidType},
+};
+
+std::map<util::StringView, std::function<Type *(const ETSChecker *)>> name_to_global_box_type = {
+    {compiler::Signatures::BUILTIN_BOX_CLASS, &ETSChecker::GlobalETSObjectType},
+    {compiler::Signatures::BUILTIN_BOOLEAN_BOX_CLASS, &ETSChecker::GlobalETSBooleanType},
+    {compiler::Signatures::BUILTIN_BYTE_BOX_CLASS, &ETSChecker::GlobalByteType},
+    {compiler::Signatures::BUILTIN_CHAR_BOX_CLASS, &ETSChecker::GlobalCharType},
+    {compiler::Signatures::BUILTIN_SHORT_BOX_CLASS, &ETSChecker::GlobalShortType},
+    {compiler::Signatures::BUILTIN_INT_BOX_CLASS, &ETSChecker::GlobalIntType},
+    {compiler::Signatures::BUILTIN_LONG_BOX_CLASS, &ETSChecker::GlobalLongType},
+    {compiler::Signatures::BUILTIN_FLOAT_BOX_CLASS, &ETSChecker::GlobalFloatType},
+    {compiler::Signatures::BUILTIN_DOUBLE_BOX_CLASS, &ETSChecker::GlobalDoubleType},
+};
+
+ETSObjectType *ETSChecker::UpdateBoxedGlobalType(ETSObjectType *obj_type, util::StringView name)
+{
+    if (name_to_global_type.find(name) != name_to_global_type.end()) {
+        std::function<Type *(const ETSChecker *)> global_type = name_to_global_box_type[name];
+        if (GlobalBuiltinBoxType(global_type(this)) != nullptr) {
+            return GlobalBuiltinBoxType(global_type(this));
+        }
+
+        auto id = name_to_type_id.find(name);
+        if (id != name_to_type_id.end()) {
+            GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(id->second)] = obj_type;
+        }
+    }
+
+    return obj_type;
+}
+
+ETSObjectType *ETSChecker::UpdateGlobalType(ETSObjectType *obj_type, util::StringView name)
+{
+    if (name_to_global_type.find(name) != name_to_global_type.end()) {
+        std::function<ETSObjectType *(const ETSChecker *)> global_type = name_to_global_type[name];
+        if (global_type(this) != nullptr) {
+            return global_type(this);
+        }
+
+        auto id = name_to_type_id.find(name);
+        if (id != name_to_type_id.end()) {
+            GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(id->second)] = obj_type;
+        }
+    }
+
+    return obj_type;
+}
+
 ETSObjectType *ETSChecker::CreateETSObjectTypeCheckBuiltins(util::StringView name, ir::AstNode *decl_node,
                                                             ETSObjectFlags flags)
 {
+    if (name == compiler::Signatures::BUILTIN_BIGINT_CLASS) {
+        if (GlobalBuiltinETSBigIntType() != nullptr) {
+            return GlobalBuiltinETSBigIntType();
+        }
+
+        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_BIG_INT_BUILTIN)] =
+            CreateNewETSObjectType(name, decl_node, flags | ETSObjectFlags::BUILTIN_BIGINT);
+        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_BIG_INT)] =
+            Allocator()->New<ETSBigIntType>(Allocator(), GlobalBuiltinETSBigIntType());
+
+        return GlobalBuiltinETSBigIntType();
+    }
+
     if (name == compiler::Signatures::BUILTIN_STRING_CLASS) {
         if (GlobalBuiltinETSStringType() != nullptr) {
             return GlobalBuiltinETSStringType();
@@ -225,90 +323,11 @@ ETSObjectType *ETSChecker::CreateETSObjectTypeCheckBuiltins(util::StringView nam
     }
 
     auto *obj_type = CreateNewETSObjectType(name, decl_node, flags);
-
-    if (name == compiler::Signatures::BUILTIN_OBJECT_CLASS) {
-        if (GlobalETSObjectType() != nullptr) {
-            return GlobalETSObjectType();
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_OBJECT_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_EXCEPTION_CLASS) {
-        if (GlobalBuiltinExceptionType() != nullptr) {
-            return GlobalBuiltinExceptionType();
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_EXCEPTION_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_ERROR_CLASS) {
-        if (GlobalBuiltinErrorType() != nullptr) {
-            return GlobalBuiltinErrorType();
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_ERROR_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_TYPE_CLASS) {
-        if (GlobalBuiltinTypeType() != nullptr) {
-            return GlobalBuiltinTypeType();
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_TYPE_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_PROMISE_CLASS) {
-        if (GlobalBuiltinPromiseType() != nullptr) {
-            return GlobalBuiltinPromiseType();
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_PROMISE_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_BOX_CLASS) {
-        if (GlobalBuiltinBoxType(GlobalETSObjectType()) != nullptr) {
-            return GlobalBuiltinBoxType(GlobalETSObjectType());
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_BOX_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_BOOLEAN_BOX_CLASS) {
-        if (GlobalBuiltinBoxType(GlobalETSBooleanType()) != nullptr) {
-            return GlobalBuiltinBoxType(GlobalETSBooleanType());
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN_BOX_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_BYTE_BOX_CLASS) {
-        if (GlobalBuiltinBoxType(GlobalByteType()) != nullptr) {
-            return GlobalBuiltinBoxType(GlobalByteType());
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_BYTE_BOX_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_CHAR_BOX_CLASS) {
-        if (GlobalBuiltinBoxType(GlobalCharType()) != nullptr) {
-            return GlobalBuiltinBoxType(GlobalCharType());
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_CHAR_BOX_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_SHORT_BOX_CLASS) {
-        if (GlobalBuiltinBoxType(GlobalShortType()) != nullptr) {
-            return GlobalBuiltinBoxType(GlobalShortType());
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_SHORT_BOX_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_INT_BOX_CLASS) {
-        if (GlobalBuiltinBoxType(GlobalIntType()) != nullptr) {
-            return GlobalBuiltinBoxType(GlobalIntType());
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_INT_BOX_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_LONG_BOX_CLASS) {
-        if (GlobalBuiltinBoxType(GlobalLongType()) != nullptr) {
-            return GlobalBuiltinBoxType(GlobalLongType());
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_LONG_BOX_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_FLOAT_BOX_CLASS) {
-        if (GlobalBuiltinBoxType(GlobalFloatType()) != nullptr) {
-            return GlobalBuiltinBoxType(GlobalFloatType());
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_FLOAT_BOX_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_FLOAT_BOX_CLASS) {
-        if (GlobalBuiltinBoxType(GlobalFloatType()) != nullptr) {
-            return GlobalBuiltinBoxType(GlobalFloatType());
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_FLOAT_BOX_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_DOUBLE_BOX_CLASS) {
-        if (GlobalBuiltinBoxType(GlobalDoubleType()) != nullptr) {
-            return GlobalBuiltinBoxType(GlobalDoubleType());
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<size_t>(GlobalTypeId::ETS_DOUBLE_BOX_BUILTIN)] = obj_type;
-    } else if (name == compiler::Signatures::BUILTIN_VOID_CLASS) {
-        if (GlobalBuiltinVoidType() != nullptr) {
-            return GlobalBuiltinVoidType();
-        }
-        GetGlobalTypesHolder()->GlobalTypes()[static_cast<std::size_t>(GlobalTypeId::ETS_VOID_BUILTIN)] = obj_type;
+    if (name_to_global_box_type.find(name) != name_to_global_box_type.end()) {
+        return UpdateBoxedGlobalType(obj_type, name);
     }
 
-    return obj_type;
+    return UpdateGlobalType(obj_type, name);
 }
 
 ETSObjectType *ETSChecker::CreateETSObjectType(util::StringView name, ir::AstNode *decl_node, ETSObjectFlags flags)
diff --git a/ets2panda/checker/types/ets/etsBigIntType.cpp b/ets2panda/checker/types/ets/etsBigIntType.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..883554170c3d8e21af39888af15a8de0368b2ec9
--- /dev/null
+++ b/ets2panda/checker/types/ets/etsBigIntType.cpp
@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2021-2023 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 "etsBigIntType.h"
+
+namespace panda::es2panda::checker {
+void ETSBigIntType::Identical(TypeRelation *relation, Type *other)
+{
+    if (other->IsETSBigIntType()) {
+        relation->Result(true);
+        return;
+    }
+
+    relation->Result(false);
+}
+
+void ETSBigIntType::AssignmentTarget([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] Type *source)
+{
+    if (source->IsETSBigIntType()) {
+        relation->Result(true);
+        return;
+    }
+
+    relation->Result(false);
+}
+
+Type *ETSBigIntType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[maybe_unused]] TypeRelation *relation,
+                                 [[maybe_unused]] GlobalTypesHolder *global_types)
+{
+    return this;
+}
+}  // namespace panda::es2panda::checker
diff --git a/ets2panda/checker/types/ets/etsBigIntType.h b/ets2panda/checker/types/ets/etsBigIntType.h
new file mode 100644
index 0000000000000000000000000000000000000000..5703107e899a48b7dfb155d200817c21ece45956
--- /dev/null
+++ b/ets2panda/checker/types/ets/etsBigIntType.h
@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2021-2023 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.
+ */
+
+#ifndef ES2PANDA_COMPILER_CHECKER_TYPES_ETS_BIGINT_TYPE_H
+#define ES2PANDA_COMPILER_CHECKER_TYPES_ETS_BIGINT_TYPE_H
+
+#include "checker/types/ets/etsObjectType.h"
+
+namespace panda::es2panda::checker {
+class ETSBigIntType : public ETSObjectType {
+public:
+    explicit ETSBigIntType(ArenaAllocator *allocator, [[maybe_unused]] ETSObjectType *super)
+        : ETSObjectType(allocator,
+                        ETSObjectFlags::CLASS | ETSObjectFlags::BUILTIN_BIGINT | ETSObjectFlags::RESOLVED_SUPER)
+    {
+        SetSuperType(super);
+    }
+
+    explicit ETSBigIntType(ArenaAllocator *allocator, ETSObjectType *super, util::StringView value)
+        : ETSObjectType(allocator,
+                        ETSObjectFlags::CLASS | ETSObjectFlags::BUILTIN_BIGINT | ETSObjectFlags::RESOLVED_SUPER),
+          value_(value)
+    {
+        SetSuperType(super);
+        AddTypeFlag(TypeFlag::CONSTANT);
+        AddTypeFlag(TypeFlag::BIGINT_LITERAL);
+        variable_ = super->Variable();
+    }
+
+    void Identical(TypeRelation *relation, Type *other) override;
+    void AssignmentTarget(TypeRelation *relation, Type *source) override;
+    Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *global_types) override;
+
+    void ToString(std::stringstream &ss) const override
+    {
+        ss << lexer::TokenToString(lexer::TokenType::KEYW_BIGINT);
+    }
+
+    void ToAssemblerType([[maybe_unused]] std::stringstream &ss) const override
+    {
+        ss << compiler::Signatures::BUILTIN_BIGINT;
+    }
+
+    util::StringView GetValue() const
+    {
+        return value_;
+    }
+
+private:
+    util::StringView value_ {};
+};
+}  // namespace panda::es2panda::checker
+
+#endif
diff --git a/ets2panda/checker/types/ets/etsEnumType.h b/ets2panda/checker/types/ets/etsEnumType.h
index fb9cc0debb0d67eb05482c3e70aaa8cb8b3a9d14..094790cab810693b05b43465b02c8f352890d96a 100644
--- a/ets2panda/checker/types/ets/etsEnumType.h
+++ b/ets2panda/checker/types/ets/etsEnumType.h
@@ -138,6 +138,11 @@ public:
         from_int_method_ = method;
     }
 
+    std::tuple<bool, bool> ResolveConditionExpr() const override
+    {
+        return {true, !GetMembers().empty()};
+    }
+
 private:
     const ir::TSEnumDeclaration *decl_;
     const UType ordinal_;
diff --git a/ets2panda/checker/types/ets/etsObjectType.cpp b/ets2panda/checker/types/ets/etsObjectType.cpp
index 7d060c93c57c08edf186bd7416ed5a972c78443b..6c6435e7ecf83b47ad4a82337e9bd7616fd17431 100644
--- a/ets2panda/checker/types/ets/etsObjectType.cpp
+++ b/ets2panda/checker/types/ets/etsObjectType.cpp
@@ -762,7 +762,6 @@ Type *ETSObjectType::Instantiate(ArenaAllocator *const allocator, TypeRelation *
     for (auto *const type_argument : TypeArguments()) {
         copied_type->TypeArguments().emplace_back(type_argument->Instantiate(allocator, relation, global_types));
     }
-
     copied_type->SetBaseType(this);
     copied_type->properties_instantiated_ = false;
     copied_type->relation_ = relation;
diff --git a/ets2panda/checker/types/ets/etsObjectType.h b/ets2panda/checker/types/ets/etsObjectType.h
index a083979f86ffc07384e9df0e89b9a2a70409e337..9d7a08b1cbef20ebb044e0ea195b3312c5a244c9 100644
--- a/ets2panda/checker/types/ets/etsObjectType.h
+++ b/ets2panda/checker/types/ets/etsObjectType.h
@@ -49,6 +49,7 @@ enum class ETSObjectFlags : uint32_t {
     CHECKED_INVOKE_LEGITIMACY = 1U << 19U,
     UNDEFINED_TYPE = 1U << 20U,
 
+    BUILTIN_BIGINT = 1U << 22U,
     BUILTIN_STRING = 1U << 23U,
     BUILTIN_BOOLEAN = 1U << 24U,
     BUILTIN_BYTE = 1U << 25U,
@@ -61,7 +62,7 @@ enum class ETSObjectFlags : uint32_t {
 
     UNBOXABLE_TYPE = BUILTIN_BOOLEAN | BUILTIN_BYTE | BUILTIN_CHAR | BUILTIN_SHORT | BUILTIN_INT | BUILTIN_LONG |
                      BUILTIN_FLOAT | BUILTIN_DOUBLE,
-    BUILTIN_TYPE = BUILTIN_STRING | UNBOXABLE_TYPE,
+    BUILTIN_TYPE = BUILTIN_STRING | BUILTIN_BIGINT | UNBOXABLE_TYPE,
     VALID_SWITCH_TYPE =
         BUILTIN_BYTE | BUILTIN_CHAR | BUILTIN_SHORT | BUILTIN_INT | BUILTIN_LONG | BUILTIN_STRING | ENUM,
     GLOBAL_CLASS = CLASS | GLOBAL,
@@ -512,11 +513,7 @@ public:
 
     std::tuple<bool, bool> ResolveConditionExpr() const override
     {
-        if (IsNullish() || IsETSStringType()) {
-            return {false, false};
-        }
-
-        return {true, true};
+        return {false, false};
     }
 
 protected:
diff --git a/ets2panda/checker/types/ets/etsUnionType.cpp b/ets2panda/checker/types/ets/etsUnionType.cpp
index cca516221ff77316e6c1f90d04713203c8de2161..b3335689a18c33baa4b690a8167e8452716399ba 100644
--- a/ets2panda/checker/types/ets/etsUnionType.cpp
+++ b/ets2panda/checker/types/ets/etsUnionType.cpp
@@ -19,6 +19,7 @@
 #include "checker/ets/conversion.h"
 #include "checker/types/globalTypesHolder.h"
 #include "checker/ETSchecker.h"
+#include "ir/astNode.h"
 
 namespace panda::es2panda::checker {
 void ETSUnionType::ToString(std::stringstream &ss) const
@@ -26,11 +27,16 @@ void ETSUnionType::ToString(std::stringstream &ss) const
     for (auto it = constituent_types_.begin(); it != constituent_types_.end(); it++) {
         (*it)->ToString(ss);
         if (std::next(it) != constituent_types_.end()) {
-            ss << " | ";
+            ss << "|";
         }
     }
 }
 
+void ETSUnionType::ToAssemblerType(std::stringstream &ss) const
+{
+    ss << compiler::Signatures::BUILTIN_OBJECT;
+}
+
 bool ETSUnionType::EachTypeRelatedToSomeType(TypeRelation *relation, ETSUnionType *source, ETSUnionType *target)
 {
     return std::all_of(source->constituent_types_.begin(), source->constituent_types_.end(),
@@ -43,7 +49,7 @@ bool ETSUnionType::TypeRelatedToSomeType(TypeRelation *relation, Type *source, E
                        [relation, source](auto *t) { return relation->IsIdenticalTo(source, t); });
 }
 
-Type *ETSUnionType::GetLeastUpperBoundType(ETSChecker *checker)
+void ETSUnionType::SetLeastUpperBoundType(ETSChecker *checker)
 {
     ASSERT(constituent_types_.size() > 1);
     if (lub_type_ == nullptr) {
@@ -51,12 +57,11 @@ Type *ETSUnionType::GetLeastUpperBoundType(ETSChecker *checker)
         for (auto *t : constituent_types_) {
             if (!t->HasTypeFlag(TypeFlag::ETS_ARRAY_OR_OBJECT)) {
                 lub_type_ = checker->GetGlobalTypesHolder()->GlobalETSObjectType();
-                return lub_type_;
+                return;
             }
             lub_type_ = checker->FindLeastUpperBound(lub_type_, t);
         }
     }
-    return lub_type_;
 }
 
 void ETSUnionType::Identical(TypeRelation *relation, Type *other)
@@ -86,10 +91,21 @@ bool ETSUnionType::AssignmentSource(TypeRelation *relation, Type *target)
 
 void ETSUnionType::AssignmentTarget(TypeRelation *relation, Type *source)
 {
-    auto *const ref_source = source->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE)
-                                 ? relation->GetChecker()->AsETSChecker()->PrimitiveTypeAsETSBuiltinType(source)
-                                 : source;
-
+    auto *const checker = relation->GetChecker()->AsETSChecker();
+    auto *const ref_source =
+        source->HasTypeFlag(TypeFlag::ETS_PRIMITIVE) ? checker->PrimitiveTypeAsETSBuiltinType(source) : source;
+    auto exact_type = std::find_if(
+        constituent_types_.begin(), constituent_types_.end(), [checker, relation, source, ref_source](Type *ct) {
+            if (ct == ref_source && source->HasTypeFlag(TypeFlag::ETS_PRIMITIVE) && ct->IsETSObjectType() &&
+                ct->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::UNBOXABLE_TYPE)) {
+                relation->GetNode()->SetBoxingUnboxingFlags(checker->GetBoxingFlag(ct));
+                return relation->IsAssignableTo(ref_source, ct);
+            }
+            return false;
+        });
+    if (exact_type != constituent_types_.end()) {
+        return;
+    }
     for (auto *it : constituent_types_) {
         if (relation->IsAssignableTo(ref_source, it)) {
             if (ref_source != source) {
@@ -98,6 +114,18 @@ void ETSUnionType::AssignmentTarget(TypeRelation *relation, Type *source)
             }
             return;
         }
+        bool assign_primitive = it->IsETSObjectType() &&
+                                it->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::UNBOXABLE_TYPE) &&
+                                source->HasTypeFlag(TypeFlag::ETS_PRIMITIVE);
+        if (assign_primitive && relation->IsAssignableTo(source, checker->ETSBuiltinTypeAsPrimitiveType(it))) {
+            Type *unboxed_it = checker->ETSBuiltinTypeAsPrimitiveType(it);
+            if (unboxed_it != source) {
+                relation->GetNode()->SetBoxingUnboxingFlags(checker->GetBoxingFlag(it));
+                source->Cast(relation, unboxed_it);
+                ASSERT(relation->IsTrue());
+            }
+            return;
+        }
     }
 }
 
@@ -124,21 +152,32 @@ Type *ETSUnionType::Instantiate(ArenaAllocator *allocator, TypeRelation *relatio
         return copied_constituents[0];
     }
 
-    Type *new_union_type = allocator->New<ETSUnionType>(std::move(copied_constituents));
+    auto *new_union_type = allocator->New<ETSUnionType>(std::move(copied_constituents));
 
-    lub_type_ = global_types->GlobalETSObjectType();
-    return HandleUnionType(new_union_type->AsETSUnionType());
+    new_union_type->SetLeastUpperBoundType(relation->GetChecker()->AsETSChecker());
+    return HandleUnionType(new_union_type);
 }
 
 void ETSUnionType::Cast(TypeRelation *relation, Type *target)
 {
-    auto *const ref_target = target->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE)
-                                 ? relation->GetChecker()->AsETSChecker()->PrimitiveTypeAsETSBuiltinType(target)
-                                 : target;
-
+    auto *const checker = relation->GetChecker()->AsETSChecker();
+    auto *const ref_target =
+        target->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE) ? checker->PrimitiveTypeAsETSBuiltinType(target) : target;
+    auto exact_type = std::find_if(constituent_types_.begin(), constituent_types_.end(),
+                                   [this, checker, relation, ref_target](Type *src) {
+                                       if (src == ref_target && relation->IsCastableTo(src, ref_target)) {
+                                           GetLeastUpperBoundType(checker)->Cast(relation, ref_target);
+                                           ASSERT(relation->IsTrue());
+                                           return true;
+                                       }
+                                       return false;
+                                   });
+    if (exact_type != constituent_types_.end()) {
+        return;
+    }
     for (auto *source : constituent_types_) {
         if (relation->IsCastableTo(source, ref_target)) {
-            GetLeastUpperBoundType(relation->GetChecker()->AsETSChecker())->Cast(relation, ref_target);
+            GetLeastUpperBoundType(checker)->Cast(relation, ref_target);
             ASSERT(relation->IsTrue());
             if (ref_target != target) {
                 source->Cast(relation, target);
@@ -147,6 +186,13 @@ void ETSUnionType::Cast(TypeRelation *relation, Type *target)
             }
             return;
         }
+        bool cast_primitive = source->IsETSObjectType() &&
+                              source->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::UNBOXABLE_TYPE) &&
+                              target->HasTypeFlag(TypeFlag::ETS_PRIMITIVE);
+        if (cast_primitive && relation->IsCastableTo(checker->ETSBuiltinTypeAsPrimitiveType(source), target)) {
+            ASSERT(relation->IsTrue());
+            return;
+        }
     }
 
     conversion::Forbidden(relation);
@@ -241,9 +287,36 @@ Type *ETSUnionType::FindTypeIsCastableToSomeType(ir::Expression *node, TypeRelat
     return nullptr;
 }
 
-void ETSUnionType::ToAssemblerType(std::stringstream &ss) const
+Type *ETSUnionType::FindUnboxableType() const
 {
-    ss << compiler::Signatures::BUILTIN_OBJECT;
+    auto it = std::find_if(constituent_types_.begin(), constituent_types_.end(),
+                           [](Type *t) { return t->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::UNBOXABLE_TYPE); });
+    if (it != constituent_types_.end()) {
+        return *it;
+    }
+    return nullptr;
+}
+
+bool ETSUnionType::HasObjectType(ETSObjectFlags flag) const
+{
+    auto it = std::find_if(constituent_types_.begin(), constituent_types_.end(),
+                           [flag](Type *t) { return t->AsETSObjectType()->HasObjectFlag(flag); });
+    return it != constituent_types_.end();
+}
+
+Type *ETSUnionType::FindExactOrBoxedType(ETSChecker *checker, Type *const type) const
+{
+    auto it = std::find_if(constituent_types_.begin(), constituent_types_.end(), [checker, type](Type *ct) {
+        if (ct->IsETSObjectType() && ct->AsETSObjectType()->HasObjectFlag(ETSObjectFlags::UNBOXABLE_TYPE)) {
+            auto *const unboxed_ct = checker->ETSBuiltinTypeAsPrimitiveType(ct);
+            return unboxed_ct == type;
+        }
+        return ct == type;
+    });
+    if (it != constituent_types_.end()) {
+        return *it;
+    }
+    return nullptr;
 }
 
 }  // namespace panda::es2panda::checker
diff --git a/ets2panda/checker/types/ets/etsUnionType.h b/ets2panda/checker/types/ets/etsUnionType.h
index 728c05665b8f285a32825e73fbd3df81cc61080d..ce032fcef4712cb86bab8f42048c78a0057a698d 100644
--- a/ets2panda/checker/types/ets/etsUnionType.h
+++ b/ets2panda/checker/types/ets/etsUnionType.h
@@ -17,6 +17,7 @@
 #define ES2PANDA_COMPILER_CHECKER_TYPES_ETS_UNION_TYPE_H
 
 #include "checker/types/type.h"
+#include "checker/types/ets/etsObjectType.h"
 
 namespace panda::es2panda::checker {
 class GlobalTypesHolder;
@@ -60,6 +61,7 @@ public:
     }
 
     void ToString(std::stringstream &ss) const override;
+    void ToAssemblerType(std::stringstream &ss) const override;
     void Identical(TypeRelation *relation, Type *other) override;
     void AssignmentTarget(TypeRelation *relation, Type *source) override;
     bool AssignmentSource(TypeRelation *relation, Type *target) override;
@@ -68,10 +70,18 @@ public:
     void CastToThis(TypeRelation *relation, Type *source);
     Type *FindTypeIsCastableToThis(ir::Expression *node, TypeRelation *relation, Type *source) const;
     Type *FindTypeIsCastableToSomeType(ir::Expression *node, TypeRelation *relation, Type *target) const;
+    Type *FindUnboxableType() const;
 
-    void ToAssemblerType(std::stringstream &ss) const override;
+    void SetLeastUpperBoundType(ETSChecker *checker);
 
-    Type *GetLeastUpperBoundType(ETSChecker *checker);
+    Type *GetLeastUpperBoundType(ETSChecker *checker)
+    {
+        if (lub_type_ == nullptr) {
+            SetLeastUpperBoundType(checker);
+        }
+        ASSERT(lub_type_ != nullptr);
+        return lub_type_;
+    }
 
     Type *GetLeastUpperBoundType() const
     {
@@ -79,8 +89,22 @@ public:
         return lub_type_;
     }
 
+    bool HasObjectType(ETSObjectFlags flag) const;
+
+    Type *FindExactOrBoxedType(ETSChecker *checker, Type *type) const;
+
     static Type *HandleUnionType(ETSUnionType *union_type);
 
+    std::tuple<bool, bool> ResolveConditionExpr() const override
+    {
+        for (auto tp : ConstituentTypes()) {
+            if (!tp->IsConditionalExprType()) {
+                return {true, false};
+            }
+        }
+        return {true, true};
+    }
+
 private:
     static bool EachTypeRelatedToSomeType(TypeRelation *relation, ETSUnionType *source, ETSUnionType *target);
     static bool TypeRelatedToSomeType(TypeRelation *relation, Type *source, ETSUnionType *target);
diff --git a/ets2panda/checker/types/ets/types.h b/ets2panda/checker/types/ets/types.h
index 1f798ee532f0073398218b8c14b9eb951315b8fc..ceb2e87ade93af2b767661af558191fb1f727512 100644
--- a/ets2panda/checker/types/ets/types.h
+++ b/ets2panda/checker/types/ets/types.h
@@ -30,6 +30,7 @@
 #include "etsUnionType.h"
 #include "etsVoidType.h"
 #include "etsStringType.h"
+#include "etsBigIntType.h"
 #include "etsObjectType.h"
 #include "etsDynamicType.h"
 #include "etsArrayType.h"
diff --git a/ets2panda/checker/types/globalTypesHolder.cpp b/ets2panda/checker/types/globalTypesHolder.cpp
index 50e7839a5381e8ce88c47fff7ca579ffca7e1483..0f80331d02cf9a37dc7c6594a4a67d25b1228214 100644
--- a/ets2panda/checker/types/globalTypesHolder.cpp
+++ b/ets2panda/checker/types/globalTypesHolder.cpp
@@ -42,6 +42,7 @@
 #include "checker/types/ets/shortType.h"
 #include "checker/types/ets/etsBooleanType.h"
 #include "checker/types/ets/etsStringType.h"
+#include "checker/types/ets/etsBigIntType.h"
 #include "checker/types/ets/etsVoidType.h"
 #include "checker/types/ets/etsObjectType.h"
 #include "checker/types/ets/wildcardType.h"
@@ -126,6 +127,7 @@ GlobalTypesHolder::GlobalTypesHolder(ArenaAllocator *allocator) : builtin_name_m
     builtin_name_mappings_.emplace("ClassNotFoundException", GlobalTypeId::ETS_CLASS_NOT_FOUND_EXCEPTION_BUILTIN);
     builtin_name_mappings_.emplace("ClassCastException", GlobalTypeId::ETS_CLASS_CAST_EXCEPTION_BUILTIN);
     builtin_name_mappings_.emplace("String", GlobalTypeId::ETS_STRING_BUILTIN);
+    builtin_name_mappings_.emplace("BigInt", GlobalTypeId::ETS_BIG_INT_BUILTIN);
     builtin_name_mappings_.emplace("StringBuilder", GlobalTypeId::ETS_STRING_BUILDER_BUILTIN);
     builtin_name_mappings_.emplace("Type", GlobalTypeId::ETS_TYPE_BUILTIN);
     builtin_name_mappings_.emplace("Types", GlobalTypeId::ETS_TYPES_BUILTIN);
@@ -506,6 +508,16 @@ Type *GlobalTypesHolder::GlobalETSStringBuiltinType()
     return global_types_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING_BUILTIN));
 }
 
+Type *GlobalTypesHolder::GlobalETSBigIntBuiltinType()
+{
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::ETS_BIG_INT_BUILTIN));
+}
+
+Type *GlobalTypesHolder::GlobalETSBigIntLiteralType()
+{
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::ETS_BIG_INT));
+}
+
 Type *GlobalTypesHolder::GlobalStringBuilderBuiltinType()
 {
     return global_types_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING_BUILDER_BUILTIN));
diff --git a/ets2panda/checker/types/globalTypesHolder.h b/ets2panda/checker/types/globalTypesHolder.h
index e84ae6ad353511525e38813af7258bab5fe4e1af..242cb362976e96e94655fc3a718c253ba5d4fc4c 100644
--- a/ets2panda/checker/types/globalTypesHolder.h
+++ b/ets2panda/checker/types/globalTypesHolder.h
@@ -108,6 +108,8 @@ enum class GlobalTypeId {
     ETS_FLOAT_BOX_BUILTIN,
     ETS_DOUBLE_BOX_BUILTIN,
     ETS_NEVER_BUILTIN,
+    ETS_BIG_INT_BUILTIN,
+    ETS_BIG_INT,
 
     COUNT,
 };
@@ -183,6 +185,8 @@ public:
     Type *GlobalClassNotFoundExceptionBuiltinType();
     [[nodiscard]] Type *GlobalClassCastExceptionBuiltinType() const noexcept;
     Type *GlobalETSStringBuiltinType();
+    Type *GlobalETSBigIntBuiltinType();
+    Type *GlobalETSBigIntLiteralType();
     Type *GlobalStringBuilderBuiltinType();
     Type *GlobalTypeBuiltinType();
     Type *GlobalTypesBuiltinType();
diff --git a/ets2panda/checker/types/signature.cpp b/ets2panda/checker/types/signature.cpp
index ab2188c6c0b438324f968af76af314a0ccda0cf7..79019e37878c321e03a68e65af6fd9a2d6f3ce67 100644
--- a/ets2panda/checker/types/signature.cpp
+++ b/ets2panda/checker/types/signature.cpp
@@ -172,12 +172,44 @@ void Signature::ToString(std::stringstream &ss, const varbinder::Variable *varia
     return_type_->ToString(ss);
 }
 
+namespace {
+std::size_t GetToCheckParamCount(Signature *signature, bool is_ets)
+{
+    auto param_number = static_cast<ssize_t>(signature->Params().size());
+    if (!is_ets || signature->Function() == nullptr) {
+        return param_number;
+    }
+    for (auto i = param_number - 1; i >= 0; i--) {
+        if (!signature->Function()->Params()[i]->AsETSParameterExpression()->IsDefault()) {
+            return static_cast<std::size_t>(i + 1);
+        }
+    }
+    return 0;
+}
+}  // namespace
+
+bool Signature::IdenticalParameter(TypeRelation *relation, Type *type1, Type *type2)
+{
+    if (!CheckFunctionalInterfaces(relation, type1, type2)) {
+        relation->IsIdenticalTo(type1, type2);
+    }
+    return relation->IsTrue();
+}
+
 void Signature::Identical(TypeRelation *relation, Signature *other)
 {
-    if ((this->MinArgCount() != other->MinArgCount() || this->Params().size() != other->Params().size()) &&
+    bool is_ets = relation->GetChecker()->IsETSChecker();
+    auto const this_to_check_parameters_number = GetToCheckParamCount(this, is_ets);
+    auto const other_to_check_parameters_number = GetToCheckParamCount(other, is_ets);
+    if ((this_to_check_parameters_number != other_to_check_parameters_number ||
+         this->MinArgCount() != other->MinArgCount()) &&
         this->RestVar() == nullptr && other->RestVar() == nullptr) {
-        relation->Result(false);
-        return;
+        // skip check for ets cases only when all parameters are mandatory
+        if (!is_ets || (this_to_check_parameters_number == this->Params().size() &&
+                        other_to_check_parameters_number == other->Params().size())) {
+            relation->Result(false);
+            return;
+        }
     }
 
     if (relation->NoReturnTypeCheck()) {
@@ -187,51 +219,63 @@ void Signature::Identical(TypeRelation *relation, Signature *other)
     }
 
     if (relation->IsTrue()) {
-        // Lambda to check parameter types
-        auto const identical_parameters = [this, relation](checker::Type *const type1,
-                                                           checker::Type *const type2) -> bool {
-            if (!CheckFunctionalInterfaces(relation, type1, type2)) {
-                relation->IsIdenticalTo(type1, type2);
-            }
-            return relation->IsTrue();
-        };
-
-        auto const this_parameters_number = this->Params().size();
-        auto const other_parameters_number = other->Params().size();
-        auto const parameters_number = std::min(this_parameters_number, other_parameters_number);
+        /* In ETS, the functions "foo(a: int)" and "foo(a: int, b: int = 1)" should be considered as having an
+           equivalent signature. Hence, we only need to check if the mandatory parameters of the signature with
+           more mandatory parameters can match the parameters of the other signature (including the optional
+           parameter or rest parameters) here.
+
+           XXX_to_check_parameters_number is calculated beforehand by counting mandatory parameters.
+           Signature::params() stores all parameters (mandatory and optional), excluding the rest parameter.
+           Signature::restVar() stores the rest parameters of the function.
+
+           For example:
+           foo(a: int): params().size: 1, to_check_param_number: 1, restVar: nullptr
+           foo(a: int, b: int = 0): params().size: 2, to_check_param_number: 1, restVar: nullptr
+           foo(a: int, ...b: int[]): params().size: 1, to_check_param_number: 1, restVar: ...b: int[]
+
+           Note that optional parameters always come after mandatory parameters, and signatures containing both
+           optional and rest parameters are not allowed.
+
+           "to_check_parameters_number" is the number of parameters that need to be checked to ensure identical.
+           "parameters_number" is the number of parameters that can be checked in Signature::params().
+        */
+        auto const to_check_parameters_number =
+            std::max(this_to_check_parameters_number, other_to_check_parameters_number);
+        auto const parameters_number =
+            std::min({this->Params().size(), other->Params().size(), to_check_parameters_number});
 
         std::size_t i = 0U;
         for (; i < parameters_number; ++i) {
-            auto *const this_sig_param_type = this->Params()[i]->TsType();
-            auto *const other_sig_param_type = other->Params()[i]->TsType();
-            if (!identical_parameters(this_sig_param_type, other_sig_param_type)) {
+            if (!IdenticalParameter(relation, this->Params()[i]->TsType(), other->Params()[i]->TsType())) {
                 return;
             }
         }
 
-        // Lambda to check the rest parameters
-        auto const identical_rest_parameters =
-            [&i, &identical_parameters, relation](std::size_t const parameter_number,
-                                                  ArenaVector<varbinder::LocalVariable *> const &parameters,
-                                                  varbinder::LocalVariable const *const rest_parameter) -> void {
-            if (rest_parameter != nullptr) {
-                auto *const other_sig_param_type = rest_parameter->TsType()->AsETSArrayType()->ElementType();
-
-                for (; i < parameter_number; ++i) {
-                    auto *const this_sig_param_type = parameters[i]->TsType();
-                    if (!identical_parameters(this_sig_param_type, other_sig_param_type)) {
-                        break;
-                    }
-                }
-            } else {
-                relation->Result(false);
+        /* "i" could be one of the following three cases:
+            1. == to_check_parameters_number, we have finished the checking and can directly return.
+            2. == other->Params().size(), must be < this_to_check_parameters_number in this case since
+            xxx->Params().size() always >= xxx_to_check_parameters_number. We need to check the remaining
+            mandatory parameters of "this" against ths RestVar of "other".
+            3. == this->Params().size(), must be < other_to_check_parameters_number as described in 2, and
+            we need to check the remaining mandatory parameters of "other" against the RestVar of "this".
+        */
+        if (i == to_check_parameters_number) {
+            return;
+        }
+        bool is_other_mandatory_params_matched = i < this_to_check_parameters_number;
+        ArenaVector<varbinder::LocalVariable *> const &parameters =
+            is_other_mandatory_params_matched ? this->Params() : other->Params();
+        varbinder::LocalVariable const *rest_parameter =
+            is_other_mandatory_params_matched ? other->RestVar() : this->RestVar();
+        if (rest_parameter == nullptr) {
+            relation->Result(false);
+            return;
+        }
+        auto *const rest_parameter_type = rest_parameter->TsType()->AsETSArrayType()->ElementType();
+        for (; i < to_check_parameters_number; ++i) {
+            if (!IdenticalParameter(relation, parameters[i]->TsType(), rest_parameter_type)) {
+                return;
             }
-        };
-
-        if (i < this_parameters_number) {
-            identical_rest_parameters(this_parameters_number, this->Params(), other->RestVar());
-        } else if (i < other_parameters_number) {
-            identical_rest_parameters(other_parameters_number, other->Params(), this->RestVar());
         }
     }
 }
diff --git a/ets2panda/checker/types/signature.h b/ets2panda/checker/types/signature.h
index 2341dd57456f0972044b51d5a2a87dba7cce9f97..161325c6a0b653617a2f8f9545d160321de1d666 100644
--- a/ets2panda/checker/types/signature.h
+++ b/ets2panda/checker/types/signature.h
@@ -250,6 +250,7 @@ public:
     void AssignmentTarget(TypeRelation *relation, Signature *source);
 
 private:
+    bool IdenticalParameter(TypeRelation *relation, Type *type1, Type *type2);
     checker::SignatureInfo *signature_info_;
     Type *return_type_;
     ir::ScriptFunction *func_ {};
diff --git a/ets2panda/checker/types/type.cpp b/ets2panda/checker/types/type.cpp
index f50b36c8de7094009f41b97887e801cd6a1b6e1f..113cbf1e35b5536bd50ae696d5618aed2bc6e420 100644
--- a/ets2panda/checker/types/type.cpp
+++ b/ets2panda/checker/types/type.cpp
@@ -61,6 +61,11 @@ bool Type::IsETSStringType() const
     return IsETSObjectType() && AsETSObjectType()->HasObjectFlag(ETSObjectFlags::STRING);
 }
 
+bool Type::IsETSBigIntType() const
+{
+    return IsETSObjectType() && AsETSObjectType()->HasObjectFlag(ETSObjectFlags::BUILTIN_BIGINT);
+}
+
 bool Type::IsETSAsyncFuncReturnType() const
 {
     return IsETSObjectType() && AsETSObjectType()->HasObjectFlag(ETSObjectFlags::ASYNC_FUNC_RETURN_TYPE);
diff --git a/ets2panda/checker/types/type.h b/ets2panda/checker/types/type.h
index 83d97754ba41ffe9b830a5ca162594f77c9dc5f6..41afd132f8aefd73386fe1da848e03af866ffe85 100644
--- a/ets2panda/checker/types/type.h
+++ b/ets2panda/checker/types/type.h
@@ -42,6 +42,7 @@ class ETSDynamicFunctionType;
 TYPE_MAPPING(DECLARE_TYPENAMES)
 #undef DECLARE_TYPENAMES
 class ETSStringType;
+class ETSBigIntType;
 
 using Substitution = ArenaMap<Type *, Type *>;
 
@@ -83,6 +84,7 @@ public:
 #undef TYPE_AS_CASTS
 
     bool IsETSStringType() const;
+    bool IsETSBigIntType() const;
     bool IsETSNullType() const;
     bool IsETSUndefinedType() const;
     bool IsETSNullLike() const;
@@ -104,6 +106,12 @@ public:
         return reinterpret_cast<const ETSStringType *>(this);
     }
 
+    const ETSBigIntType *AsETSBigIntType() const
+    {
+        ASSERT(IsETSObjectType());
+        return reinterpret_cast<const ETSBigIntType *>(this);
+    }
+
     bool IsETSDynamicType() const
     {
         return IsETSObjectType() && HasTypeFlag(TypeFlag::ETS_DYNAMIC_FLAG);
diff --git a/ets2panda/checker/types/typeFlag.h b/ets2panda/checker/types/typeFlag.h
index 7a26628209dce4b89f47d4dae61efbe9f2ad3963..58c04f812f895b62dc8f44893f4577fea54021ad 100644
--- a/ets2panda/checker/types/typeFlag.h
+++ b/ets2panda/checker/types/typeFlag.h
@@ -128,8 +128,8 @@ enum class TypeFlag : uint64_t {
     VALID_ARITHMETIC_TYPE = ANY | NUMBER_LIKE | BIGINT_LIKE | ENUM,
     UNIT = LITERAL | UNIQUE_SYMBOL | NULLISH,
     GETTER_SETTER = GETTER | SETTER,
-    CONDITION_EXPRESSION_TYPE =
-        NULLISH | CONSTANT | ETS_OBJECT | BYTE | SHORT | INT | LONG | FLOAT | DOUBLE | ETS_BOOLEAN | ETS_ARRAY
+    CONDITION_EXPRESSION_TYPE = NULLISH | CONSTANT | ETS_OBJECT | BYTE | SHORT | INT | LONG | FLOAT | DOUBLE |
+                                ETS_BOOLEAN | ETS_ARRAY | ETS_ENUM | ETS_STRING_ENUM
 };
 
 DEFINE_BITOPS(TypeFlag)
diff --git a/ets2panda/cmake/coverage.cmake b/ets2panda/cmake/coverage.cmake
index 8464c0fed8fbdeca293eb8743038231b204035f7..794bf7a6e7c226cfde314cd6b60f41f524545d3b 100644
--- a/ets2panda/cmake/coverage.cmake
+++ b/ets2panda/cmake/coverage.cmake
@@ -17,9 +17,13 @@ include(${PANDA_ROOT}/cmake/toolchain/coverage/unit_tests_lcov.cmake)
 
 add_custom_target(es2panda_coverage DEPENDS etsstdlib es2panda verifier ark)
 
+if (NOT DEFINED ES2PANDA_PATH)
+    set(ES2PANDA_PATH ${PANDA_ROOT}/tools/es2panda)
+endif()
+
 add_custom_command(TARGET es2panda_coverage POST_BUILD
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    COMMAND bash ${PANDA_ROOT}/plugins/ecmascript/es2panda/scripts/es2panda_coverage.sh --binary-dir=${PANDA_BINARY_ROOT} --root-dir=${PANDA_ROOT}
+    COMMAND bash ${ES2PANDA_PATH}/scripts/es2panda_coverage.sh --binary-dir=${PANDA_BINARY_ROOT} --root-dir=${PANDA_ROOT}
 )
 
 if(ENABLE_ES2PANDA_COVERAGE)
diff --git a/ets2panda/compiler/base/condition.cpp b/ets2panda/compiler/base/condition.cpp
index 0331d9342c7c84029588065ec0bf8aeb442ec5be..d2abcf956930a75c6c9c30f7dae2f79f52208806 100644
--- a/ets2panda/compiler/base/condition.cpp
+++ b/ets2panda/compiler/base/condition.cpp
@@ -126,6 +126,67 @@ Condition::Result Condition::CheckConstantExpr(ETSGen *etsg, const ir::Expressio
     return Result::UNKNOWN;
 }
 
+void Condition::CompileLogicalOrExpr(ETSGen *etsg, const ir::BinaryExpression *bin_expr, Label *false_label)
+{
+    auto ttctx = TargetTypeContext(etsg, bin_expr->OperationType());
+    RegScope rs(etsg);
+    VReg lhs = etsg->AllocReg();
+    VReg rhs = etsg->AllocReg();
+    auto *return_left_label = etsg->AllocLabel();
+    auto *return_right_true_label = etsg->AllocLabel();
+    auto *return_right_false_label = etsg->AllocLabel();
+
+    bin_expr->Left()->Compile(etsg);
+    etsg->ApplyConversionAndStoreAccumulator(bin_expr->Left(), lhs, bin_expr->OperationType());
+    etsg->ResolveConditionalResultIfTrue(bin_expr->Left(), return_left_label);
+    etsg->BranchIfTrue(bin_expr, return_left_label);
+
+    bin_expr->Right()->Compile(etsg);
+    etsg->ApplyConversionAndStoreAccumulator(bin_expr->Right(), rhs, bin_expr->OperationType());
+    etsg->ResolveConditionalResultIfFalse(bin_expr->Right(), return_right_false_label);
+    etsg->BranchIfFalse(bin_expr, return_right_false_label);
+    etsg->LoadAccumulator(bin_expr, rhs);
+    etsg->Branch(bin_expr, return_right_true_label);
+
+    etsg->SetLabel(bin_expr, return_right_false_label);
+    etsg->LoadAccumulator(bin_expr, rhs);
+    etsg->Branch(bin_expr, false_label);
+    etsg->SetLabel(bin_expr, return_left_label);
+    etsg->LoadAccumulator(bin_expr, lhs);
+    etsg->SetLabel(bin_expr, return_right_true_label);
+}
+
+void Condition::CompileLogicalAndExpr(ETSGen *etsg, const ir::BinaryExpression *bin_expr, Label *false_label)
+{
+    auto ttctx = TargetTypeContext(etsg, bin_expr->OperationType());
+    RegScope rs(etsg);
+    VReg lhs = etsg->AllocReg();
+    VReg rhs = etsg->AllocReg();
+    auto *return_left_label = etsg->AllocLabel();
+    auto *return_right_true_label = etsg->AllocLabel();
+    auto *return_right_false_label = etsg->AllocLabel();
+
+    bin_expr->Left()->Compile(etsg);
+    etsg->ApplyConversionAndStoreAccumulator(bin_expr->Left(), lhs, bin_expr->OperationType());
+    etsg->ResolveConditionalResultIfFalse(bin_expr->Left(), return_left_label);
+    etsg->BranchIfFalse(bin_expr, return_left_label);
+
+    bin_expr->Right()->Compile(etsg);
+    etsg->ApplyConversionAndStoreAccumulator(bin_expr->Right(), rhs, bin_expr->OperationType());
+    etsg->ResolveConditionalResultIfFalse(bin_expr->Right(), return_right_false_label);
+    etsg->BranchIfFalse(bin_expr, return_right_false_label);
+    etsg->LoadAccumulator(bin_expr, rhs);
+    etsg->Branch(bin_expr, return_right_true_label);
+
+    etsg->SetLabel(bin_expr, return_left_label);
+    etsg->LoadAccumulator(bin_expr, lhs);
+    etsg->Branch(bin_expr, false_label);
+    etsg->SetLabel(bin_expr, return_right_false_label);
+    etsg->LoadAccumulator(bin_expr, rhs);
+    etsg->Branch(bin_expr, false_label);
+    etsg->SetLabel(bin_expr, return_right_true_label);
+}
+
 bool Condition::CompileBinaryExpr(ETSGen *etsg, const ir::BinaryExpression *bin_expr, Label *false_label)
 {
     switch (bin_expr->OperatorType()) {
@@ -149,30 +210,11 @@ bool Condition::CompileBinaryExpr(ETSGen *etsg, const ir::BinaryExpression *bin_
             return true;
         }
         case lexer::TokenType::PUNCTUATOR_LOGICAL_AND: {
-            bin_expr->Left()->Compile(etsg);
-            etsg->ApplyConversion(bin_expr->Left(), bin_expr->OperationType());
-            etsg->ResolveConditionalResultIfFalse(bin_expr->Left(), false_label);
-            etsg->BranchIfFalse(bin_expr, false_label);
-
-            bin_expr->Right()->Compile(etsg);
-            etsg->ApplyConversion(bin_expr->Right(), bin_expr->OperationType());
-            etsg->ResolveConditionalResultIfFalse(bin_expr->Right(), false_label);
-            etsg->BranchIfFalse(bin_expr, false_label);
+            CompileLogicalAndExpr(etsg, bin_expr, false_label);
             return true;
         }
         case lexer::TokenType::PUNCTUATOR_LOGICAL_OR: {
-            auto *end_label = etsg->AllocLabel();
-
-            bin_expr->Left()->Compile(etsg);
-            etsg->ApplyConversion(bin_expr->Left(), bin_expr->OperationType());
-            etsg->ResolveConditionalResultIfTrue(bin_expr->Left(), end_label);
-            etsg->BranchIfTrue(bin_expr, end_label);
-
-            bin_expr->Right()->Compile(etsg);
-            etsg->ApplyConversion(bin_expr->Right(), bin_expr->OperationType());
-            etsg->ResolveConditionalResultIfFalse(bin_expr->Right(), false_label);
-            etsg->BranchIfFalse(bin_expr, false_label);
-            etsg->SetLabel(bin_expr, end_label);
+            CompileLogicalOrExpr(etsg, bin_expr, false_label);
             return true;
         }
         default: {
diff --git a/ets2panda/compiler/base/condition.h b/ets2panda/compiler/base/condition.h
index 11ed9e8670ccb054d15c950f11338de275f11aa9..6380ba538ea054cc711217737c042649cfcc5ba7 100644
--- a/ets2panda/compiler/base/condition.h
+++ b/ets2panda/compiler/base/condition.h
@@ -40,6 +40,8 @@ public:
 private:
     static bool CompileBinaryExpr(PandaGen *pg, const ir::BinaryExpression *bin_expr, Label *false_label);
     static bool CompileBinaryExpr(ETSGen *etsg, const ir::BinaryExpression *bin_expr, Label *false_label);
+    static void CompileLogicalAndExpr(ETSGen *etsg, const ir::BinaryExpression *bin_expr, Label *false_label);
+    static void CompileLogicalOrExpr(ETSGen *etsg, const ir::BinaryExpression *bin_expr, Label *false_label);
 };
 }  // namespace panda::es2panda::compiler
 
diff --git a/ets2panda/compiler/core/ETSCompiler.cpp b/ets2panda/compiler/core/ETSCompiler.cpp
index 6ee70ad191040eb3ba06d358f357beeb3794599e..085c86abbd365dc741326cb1dd34271a32d95116 100644
--- a/ets2panda/compiler/core/ETSCompiler.cpp
+++ b/ets2panda/compiler/core/ETSCompiler.cpp
@@ -317,33 +317,33 @@ static void CompileLogical(compiler::ETSGen *etsg, const ir::BinaryExpression *e
     auto ttctx = compiler::TargetTypeContext(etsg, expr->OperationType());
     compiler::RegScope rs(etsg);
     auto lhs = etsg->AllocReg();
-    auto rhs = etsg->AllocReg();
+
     expr->Left()->Compile(etsg);
     etsg->ApplyConversionAndStoreAccumulator(expr->Left(), lhs, expr->OperationType());
 
     auto *end_label = etsg->AllocLabel();
 
-    auto left_false_label = etsg->AllocLabel();
+    auto return_left_label = etsg->AllocLabel();
     if (expr->OperatorType() == lexer::TokenType::PUNCTUATOR_LOGICAL_AND) {
-        etsg->ResolveConditionalResultIfFalse(expr->Left(), left_false_label);
-        etsg->BranchIfFalse(expr, left_false_label);
+        etsg->ResolveConditionalResultIfFalse(expr->Left(), return_left_label);
+        etsg->BranchIfFalse(expr, return_left_label);
 
         expr->Right()->Compile(etsg);
-        etsg->ApplyConversionAndStoreAccumulator(expr->Right(), rhs, expr->OperationType());
+        etsg->ApplyConversion(expr->Right(), expr->OperationType());
         etsg->Branch(expr, end_label);
 
-        etsg->SetLabel(expr, left_false_label);
+        etsg->SetLabel(expr, return_left_label);
         etsg->LoadAccumulator(expr, lhs);
     } else {
-        etsg->ResolveConditionalResultIfFalse(expr->Left(), left_false_label);
-        etsg->BranchIfFalse(expr, left_false_label);
+        etsg->ResolveConditionalResultIfTrue(expr->Left(), return_left_label);
+        etsg->BranchIfTrue(expr, return_left_label);
 
-        etsg->LoadAccumulator(expr, lhs);
+        expr->Right()->Compile(etsg);
+        etsg->ApplyConversion(expr->Right(), expr->OperationType());
         etsg->Branch(expr, end_label);
 
-        etsg->SetLabel(expr, left_false_label);
-        expr->Right()->Compile(etsg);
-        etsg->ApplyConversionAndStoreAccumulator(expr->Right(), rhs, expr->OperationType());
+        etsg->SetLabel(expr, return_left_label);
+        etsg->LoadAccumulator(expr, lhs);
     }
 
     etsg->SetLabel(expr, end_label);
@@ -353,6 +353,20 @@ static void CompileLogical(compiler::ETSGen *etsg, const ir::BinaryExpression *e
 void ETSCompiler::Compile(const ir::BinaryExpression *expr) const
 {
     ETSGen *etsg = GetETSGen();
+
+    if (expr->Left()->TsType()->IsETSBigIntType() && expr->Right()->TsType()->IsETSBigIntType()) {
+        switch (expr->OperatorType()) {
+            case lexer::TokenType::KEYW_INSTANCEOF:
+            case lexer::TokenType::PUNCTUATOR_EQUAL:
+            case lexer::TokenType::PUNCTUATOR_STRICT_EQUAL:
+                // Handled below
+                break;
+            default:
+                etsg->CallBigIntOperator(expr);
+                return;
+        }
+    }
+
     if (etsg->TryLoadConstantExpression(expr)) {
         return;
     }
@@ -524,7 +538,9 @@ void ETSCompiler::CompileDynamic(const ir::CallExpression *expr, compiler::VReg
 void ETSCompiler::EmitCall(const ir::CallExpression *expr, compiler::VReg &callee_reg, bool is_static) const
 {
     ETSGen *etsg = GetETSGen();
-
+    if (expr->Callee()->GetBoxingUnboxingFlags() != ir::BoxingUnboxingFlags::NONE) {
+        etsg->ApplyConversionAndStoreAccumulator(expr->Callee(), callee_reg, nullptr);
+    }
     if (is_static) {
         etsg->CallStatic(expr, expr->Signature(), expr->Arguments());
     } else if (expr->Signature()->HasSignatureFlag(checker::SignatureFlags::PRIVATE) || expr->IsETSConstructorCall() ||
diff --git a/ets2panda/compiler/core/ETSGen.cpp b/ets2panda/compiler/core/ETSGen.cpp
index 30b85196537359b852c43094dea5fbb21599e6f6..bc003c7facc8f5ad511c61a801a27c8db4284140 100644
--- a/ets2panda/compiler/core/ETSGen.cpp
+++ b/ets2panda/compiler/core/ETSGen.cpp
@@ -15,7 +15,6 @@
 
 #include "ETSGen.h"
 
-#include "checker/ets/boxingConverter.h"
 #include "ir/base/scriptFunction.h"
 #include "ir/base/classDefinition.h"
 #include "ir/statement.h"
@@ -40,6 +39,7 @@
 #include "checker/types/typeFlag.h"
 #include "checker/checker.h"
 #include "checker/ETSchecker.h"
+#include "checker/ets/boxingConverter.h"
 #include "checker/types/ets/etsObjectType.h"
 #include "checker/types/ets/types.h"
 #include "parser/program/program.h"
@@ -598,6 +598,11 @@ void ETSGen::LoadThis(const ir::AstNode *node)
     LoadAccumulator(node, GetThisReg());
 }
 
+void ETSGen::CreateBigIntObject(const ir::AstNode *node, VReg arg0)
+{
+    Ra().Emit<InitobjShort>(node, Signatures::BUILTIN_BIGINT_CTOR, arg0, dummy_reg_);
+}
+
 void ETSGen::CreateLambdaObjectFromIdentReference(const ir::AstNode *node, ir::ClassDefinition *lambda_obj)
 {
     auto *ctor = lambda_obj->TsType()->AsETSObjectType()->ConstructSignatures()[0];
@@ -811,6 +816,19 @@ void ETSGen::EmitIsInstance([[maybe_unused]] const ir::AstNode *const node, [[ma
 #endif  // PANDA_WITH_ETS
 }
 
+void ETSGen::LoadConstantObject(const ir::Expression *node, const checker::Type *type)
+{
+    if (type->AsETSObjectType()->HasObjectFlag(checker::ETSObjectFlags::BUILTIN_BIGINT)) {
+        LoadAccumulatorBigInt(node, type->AsETSObjectType()->AsETSBigIntType()->GetValue());
+        const VReg value = AllocReg();
+        StoreAccumulator(node, value);
+        CreateBigIntObject(node, value);
+    } else {
+        LoadAccumulatorString(node, type->AsETSObjectType()->AsETSStringType()->GetValue());
+        SetAccumulatorType(node->TsType());
+    }
+}
+
 bool ETSGen::TryLoadConstantExpression(const ir::Expression *node)
 {
     const auto *type = node->TsType();
@@ -855,8 +873,7 @@ bool ETSGen::TryLoadConstantExpression(const ir::Expression *node)
             break;
         }
         case checker::TypeFlag::ETS_OBJECT: {
-            LoadAccumulatorString(node, type->AsETSObjectType()->AsETSStringType()->GetValue());
-            SetAccumulatorType(node->TsType());
+            LoadConstantObject(node, type);
             break;
         }
         default: {
@@ -867,15 +884,35 @@ bool ETSGen::TryLoadConstantExpression(const ir::Expression *node)
     return true;
 }
 
-// NOTE: vpukhov. lower (union_value) as (primitive_type) to be two as-nodes
-static void ApplyUnboxingUnionPrimitive(ETSGen *etsg, const ir::AstNode *node)
+void ETSGen::ApplyConversionCast(const ir::AstNode *node, const checker::Type *target_type)
 {
-    if (node->IsExpression() && node->Parent()->IsTSAsExpression()) {
-        auto const *from_type = node->AsExpression()->TsType();
-        auto const *to_type = node->Parent()->AsTSAsExpression()->TsType();
-        if (from_type->IsETSUnionType() && to_type->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE)) {
-            etsg->EmitCheckedNarrowingReferenceConversion(
-                node, checker::BoxingConverter::ETSTypeFromSource(etsg->Checker(), to_type));
+    switch (checker::ETSChecker::TypeKind(target_type)) {
+        case checker::TypeFlag::DOUBLE: {
+            CastToDouble(node);
+            break;
+        }
+        case checker::TypeFlag::FLOAT: {
+            CastToFloat(node);
+            break;
+        }
+        case checker::TypeFlag::LONG: {
+            CastToLong(node);
+            break;
+        }
+        case checker::TypeFlag::ETS_ARRAY:
+            [[fallthrough]];
+        case checker::TypeFlag::ETS_OBJECT: {
+            if (GetAccumulatorType() != nullptr && GetAccumulatorType()->IsETSDynamicType()) {
+                CastDynamicToObject(node, target_type);
+            }
+            break;
+        }
+        case checker::TypeFlag::ETS_DYNAMIC_TYPE: {
+            CastToDynamic(node, target_type->AsETSDynamicType());
+            break;
+        }
+        default: {
+            break;
         }
     }
 }
@@ -897,7 +934,6 @@ void ETSGen::ApplyConversion(const ir::AstNode *node, const checker::Type *targe
         if (GetAccumulatorType()->IsNullishOrNullLike()) {  // NOTE: vpukhov. should be a CTE
             EmitNullishGuardian(node);
         }
-        ApplyUnboxingUnionPrimitive(this, node);
         EmitUnboxingConversion(node);
         const auto unboxing_flags = static_cast<ir::BoxingUnboxingFlags>(node->GetBoxingUnboxingFlags() &
                                                                          ir::BoxingUnboxingFlags::UNBOXING_FLAG);
@@ -909,35 +945,12 @@ void ETSGen::ApplyConversion(const ir::AstNode *node, const checker::Type *targe
         return;
     }
 
-    switch (checker::ETSChecker::TypeKind(target_type)) {
-        case checker::TypeFlag::DOUBLE: {
-            CastToDouble(node);
-            break;
-        }
-        case checker::TypeFlag::FLOAT: {
-            CastToFloat(node);
-            break;
-        }
-        case checker::TypeFlag::LONG: {
-            CastToLong(node);
-            break;
-        }
-        case checker::TypeFlag::ETS_ARRAY:
-            [[fallthrough]];
-        case checker::TypeFlag::ETS_OBJECT: {
-            if (GetAccumulatorType() != nullptr && GetAccumulatorType()->IsETSDynamicType()) {
-                CastDynamicToObject(node, target_type);
-            }
-            break;
-        }
-        case checker::TypeFlag::ETS_DYNAMIC_TYPE: {
-            CastToDynamic(node, target_type->AsETSDynamicType());
-            break;
-        }
-        default: {
-            break;
-        }
+    if (target_type->IsETSUnionType()) {
+        SetAccumulatorType(target_type->AsETSUnionType()->GetLeastUpperBoundType());
+        return;
     }
+
+    ApplyConversionCast(node, target_type);
 }
 
 void ETSGen::ApplyCast(const ir::AstNode *node, const checker::Type *target_type)
@@ -2100,7 +2113,10 @@ void ETSGen::BinaryEqualityRef(const ir::AstNode *node, bool test_equal, VReg lh
         StoreAccumulator(node, rhs);
 
         LoadAccumulator(node, lhs);
-        if (GetVRegType(lhs)->IsETSStringType()) {
+
+        if (GetVRegType(lhs)->IsETSBigIntType()) {
+            CallThisStatic1(node, lhs, Signatures::BUILTIN_BIGINT_EQUALS, rhs);
+        } else if (GetVRegType(lhs)->IsETSStringType()) {
             CallThisStatic1(node, lhs, Signatures::BUILTIN_STRING_EQUALS, rhs);
         } else {
             CallThisVirtual1(node, lhs, Signatures::BUILTIN_OBJECT_EQUALS, rhs);
@@ -2160,6 +2176,7 @@ void ETSGen::LogicalNot(const ir::AstNode *node)
     ASSERT(GetAccumulatorType()->IsConditionalExprType());
     ResolveConditionalResultIfFalse<true, false>(node);
     Sa().Emit<Xori>(node, 1);
+    SetAccumulatorType(Checker()->GlobalETSBooleanType());
 }
 
 void ETSGen::Unary(const ir::AstNode *node, lexer::TokenType op)
@@ -2192,6 +2209,13 @@ void ETSGen::Unary(const ir::AstNode *node, lexer::TokenType op)
 
 void ETSGen::UnaryMinus(const ir::AstNode *node)
 {
+    if (GetAccumulatorType()->IsETSBigIntType()) {
+        const VReg value = AllocReg();
+        StoreAccumulator(node, value);
+        CallThisStatic0(node, value, Signatures::BUILTIN_BIGINT_NEGATE);
+        return;
+    }
+
     switch (checker::ETSChecker::ETSType(GetAccumulatorType())) {
         case checker::TypeFlag::LONG: {
             Sa().Emit<NegWide>(node);
@@ -2356,6 +2380,22 @@ void ETSGen::BuildString(const ir::Expression *node)
     SetAccumulatorType(node->TsType());
 }
 
+void ETSGen::CallBigIntOperator(const ir::Expression *node)
+{
+    RegScope rs(this);
+
+    // Empty big int constructor
+    Ra().Emit<InitobjShort, 0>(node, Signatures::BUILTIN_BIGINT_CTOR_EMPTY, dummy_reg_, dummy_reg_);
+    SetAccumulatorType(Checker()->GlobalBuiltinETSBigIntType());
+    const VReg bigint = AllocReg();
+    StoreAccumulator(node, bigint);
+
+    // NOTE(kkonsw): add implementation for the operators
+    CallThisStatic0(node, bigint, Signatures::BUILTIN_BIGINT_OPERATOR);
+    SetAccumulatorType(Checker()->GlobalLongType());
+    StoreAccumulator(node, bigint);
+}
+
 void ETSGen::BuildTemplateString(const ir::TemplateLiteral *node)
 {
     RegScope rs(this);
@@ -2422,6 +2462,10 @@ void ETSGen::LoadArrayElement(const ir::AstNode *node, VReg object_reg)
 {
     auto *element_type = GetVRegType(object_reg)->AsETSArrayType()->ElementType();
 
+    if (element_type->IsETSUnionType()) {
+        element_type = element_type->AsETSUnionType()->GetLeastUpperBoundType();
+    }
+
     switch (checker::ETSChecker::ETSType(element_type)) {
         case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE: {
@@ -2472,6 +2516,9 @@ void ETSGen::LoadArrayElement(const ir::AstNode *node, VReg object_reg)
 
 void ETSGen::StoreArrayElement(const ir::AstNode *node, VReg object_reg, VReg index, const checker::Type *element_type)
 {
+    if (element_type->IsETSUnionType()) {
+        element_type = element_type->AsETSUnionType()->GetLeastUpperBoundType();
+    }
     switch (checker::ETSChecker::ETSType(element_type)) {
         case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE: {
diff --git a/ets2panda/compiler/core/ETSGen.h b/ets2panda/compiler/core/ETSGen.h
index 7ee98c5619fb31522e9ada5358b7e9b7f720d1c2..e16ca8a1054b27d8570912516c48e69aba45f9ba 100644
--- a/ets2panda/compiler/core/ETSGen.h
+++ b/ets2panda/compiler/core/ETSGen.h
@@ -102,10 +102,11 @@ public:
     bool TryLoadConstantExpression(const ir::Expression *node);
     void Condition(const ir::AstNode *node, lexer::TokenType op, VReg lhs, Label *if_false);
 
-    template <typename CondCompare, bool BEFORE_LOGICAL_NOT, bool USE_FALSE_LABEL>
-    void ResolveConditionalResultFloat(const ir::AstNode *node, [[maybe_unused]] Label *if_false, Label *end)
+    template <typename CondCompare, bool BEFORE_LOGICAL_NOT>
+    void ResolveConditionalResultFloat(const ir::AstNode *node, Label *real_end_label)
     {
-        auto type = node->IsExpression() ? node->AsExpression()->TsType() : GetAccumulatorType();
+        auto type = node->IsExpression() && !node->AsExpression()->IsUnaryExpression() ? node->AsExpression()->TsType()
+                                                                                       : GetAccumulatorType();
         VReg tmp_reg = AllocReg();
         StoreAccumulator(node, tmp_reg);
         if (type->IsFloatType()) {
@@ -113,17 +114,8 @@ public:
         } else {
             DoubleIsNaN(node);
         }
-
         Sa().Emit<Xori>(node, 1);
-        auto real_end_label = [](Label *end_label, Label *if_false_label, ETSGen *etsgn, bool use_false_label) {
-            if (use_false_label) {
-                return if_false_label;
-            }
-            if (end_label == nullptr) {
-                end_label = etsgn->AllocLabel();
-            }
-            return end_label;
-        }(end, if_false, this, USE_FALSE_LABEL);
+
         BranchIfFalse(node, real_end_label);
         LoadAccumulator(node, tmp_reg);
         VReg zero_reg = AllocReg();
@@ -138,39 +130,40 @@ public:
     }
 
     template <typename CondCompare, bool BEFORE_LOGICAL_NOT, bool USE_FALSE_LABEL>
-    void ResolveConditionalResultNumeric(const ir::AstNode *node, [[maybe_unused]] Label *if_false, Label *end)
+    void ResolveConditionalResultNumeric(const ir::AstNode *node, [[maybe_unused]] Label *if_false, Label **end)
     {
-        auto type = node->IsExpression() ? node->AsExpression()->TsType() : GetAccumulatorType();
-        switch (type->TypeFlags()) {
-            case checker::TypeFlag::LONG: {
-                CastToInt(node);
-                [[fallthrough]];
-            }
-            case checker::TypeFlag::BYTE:
-            case checker::TypeFlag::CHAR:
-            case checker::TypeFlag::SHORT:
-            case checker::TypeFlag::INT: {
-                if constexpr (BEFORE_LOGICAL_NOT) {
-                    Label *zero_primitive = AllocLabel();
-                    BranchIfFalse(node, zero_primitive);
-                    ToBinaryResult(node, zero_primitive);
-                }
-                break;
+        auto type = node->IsExpression() && !node->AsExpression()->IsUnaryExpression() ? node->AsExpression()->TsType()
+                                                                                       : GetAccumulatorType();
+
+        auto real_end_label = [end, if_false, this](bool use_false_label) {
+            if (use_false_label) {
+                return if_false;
             }
-            case checker::TypeFlag::DOUBLE:
-            case checker::TypeFlag::FLOAT: {
-                ResolveConditionalResultFloat<CondCompare, BEFORE_LOGICAL_NOT, USE_FALSE_LABEL>(node, if_false, end);
-                break;
+            if ((*end) == nullptr) {
+                (*end) = AllocLabel();
             }
-            default:
-                break;
+            return (*end);
+        }(USE_FALSE_LABEL);
+        if (type->IsDoubleType() || type->IsFloatType()) {
+            ResolveConditionalResultFloat<CondCompare, BEFORE_LOGICAL_NOT>(node, real_end_label);
+        }
+        if (type->IsLongType()) {
+            VReg zero_reg = AllocReg();
+            MoveImmediateToRegister(node, zero_reg, checker::TypeFlag::LONG, 0);
+            BinaryNumberComparison<CmpWide, CondCompare>(node, zero_reg, real_end_label);
+        }
+        if constexpr (BEFORE_LOGICAL_NOT) {
+            Label *zero_primitive = AllocLabel();
+            BranchIfFalse(node, zero_primitive);
+            ToBinaryResult(node, zero_primitive);
         }
     }
 
-    template <typename CondCompare, bool BEFORE_LOGICAL_NOT, bool USE_FALSE_LABEL>
-    void ResolveConditionalResultObject(const ir::AstNode *node, [[maybe_unused]] Label *if_false)
+    template <typename CondCompare, bool BEFORE_LOGICAL_NOT>
+    void ResolveConditionalResultObject(const ir::AstNode *node)
     {
-        auto type = node->IsExpression() ? node->AsExpression()->TsType() : GetAccumulatorType();
+        auto type = node->IsExpression() && !node->AsExpression()->IsUnaryExpression() ? node->AsExpression()->TsType()
+                                                                                       : GetAccumulatorType();
         if (type->IsETSStringType()) {
             LoadStringLength(node);
             if constexpr (BEFORE_LOGICAL_NOT) {
@@ -178,6 +171,27 @@ public:
                 BranchIfFalse(node, zero_lenth);
                 ToBinaryResult(node, zero_lenth);
             }
+        } else if (node->IsExpression() && node->AsExpression()->IsIdentifier() &&
+                   node->AsExpression()->AsIdentifier()->Variable()->HasFlag(varbinder::VariableFlags::VAR)) {
+            Label *is_string = AllocLabel();
+            Label *end = AllocLabel();
+            compiler::VReg obj_reg = AllocReg();
+            StoreAccumulator(node, obj_reg);
+
+            Sa().Emit<Isinstance>(node, Checker()->GlobalBuiltinETSStringType()->AsETSStringType()->AssemblerName());
+            BranchIfTrue(node, is_string);
+            Sa().Emit<Ldai>(node, 1);
+            Branch(node, end);
+            SetLabel(node, is_string);
+            LoadAccumulator(node, obj_reg);
+            CastToString(node);
+            LoadStringLength(node);
+            if constexpr (BEFORE_LOGICAL_NOT) {
+                Label *zero_lenth = AllocLabel();
+                BranchIfFalse(node, zero_lenth);
+                ToBinaryResult(node, zero_lenth);
+            }
+            SetLabel(node, end);
         } else {
             Sa().Emit<Ldai>(node, 1);
         }
@@ -200,11 +214,8 @@ public:
     template <typename CondCompare, bool BEFORE_LOGICAL_NOT, bool USE_FALSE_LABEL>
     void ResolveConditionalResult(const ir::AstNode *node, [[maybe_unused]] Label *if_false)
     {
-        auto type = node->IsExpression() ? node->AsExpression()->TsType() : GetAccumulatorType();
-        if (type->IsETSObjectType() &&
-            type->AsETSObjectType()->HasObjectFlag(panda::es2panda::checker::ETSObjectFlags::UNBOXABLE_TYPE)) {
-            type = GetAccumulatorType();
-        }
+        auto type = node->IsExpression() && !node->AsExpression()->IsUnaryExpression() ? node->AsExpression()->TsType()
+                                                                                       : GetAccumulatorType();
         if (type->IsETSBooleanType()) {
             return;
         }
@@ -228,9 +239,9 @@ public:
             StoreAccumulator(node, obj_reg);
             LoadArrayLength(node, obj_reg);
         } else if (type->IsETSObjectType()) {
-            ResolveConditionalResultObject<CondCompare, BEFORE_LOGICAL_NOT, USE_FALSE_LABEL>(node, if_false);
+            ResolveConditionalResultObject<CondCompare, BEFORE_LOGICAL_NOT>(node);
         } else {
-            ResolveConditionalResultNumeric<CondCompare, BEFORE_LOGICAL_NOT, USE_FALSE_LABEL>(node, if_false, end);
+            ResolveConditionalResultNumeric<CondCompare, BEFORE_LOGICAL_NOT, USE_FALSE_LABEL>(node, if_false, &end);
         }
         if (if_nullish != nullptr) {
             Branch(node, end);
@@ -248,10 +259,10 @@ public:
         ResolveConditionalResult<Jeqz, BEFORE_LOGICAL_NOT, FALSE_LABEL_EXISTED>(node, if_false);
     }
 
-    template <bool BEFORE_LOGICAL_NOT = false>
+    template <bool BEFORE_LOGICAL_NOT = false, bool FALSE_LABEL_EXISTED = true>
     void ResolveConditionalResultIfTrue(const ir::AstNode *node, Label *if_false = nullptr)
     {
-        ResolveConditionalResult<Jnez, BEFORE_LOGICAL_NOT, false>(node, if_false);
+        ResolveConditionalResult<Jnez, BEFORE_LOGICAL_NOT, FALSE_LABEL_EXISTED>(node, if_false);
     }
 
     void BranchIfFalse(const ir::AstNode *node, Label *if_false)
@@ -376,6 +387,12 @@ public:
         SetAccumulatorType(Checker()->GlobalETSStringLiteralType());
     }
 
+    void LoadAccumulatorBigInt(const ir::AstNode *node, util::StringView str)
+    {
+        Sa().Emit<LdaStr>(node, str);
+        SetAccumulatorType(Checker()->GlobalETSBigIntLiteralType());
+    }
+
     void LoadAccumulatorNull(const ir::AstNode *node, const checker::Type *type)
     {
         Sa().Emit<LdaNull>(node);
@@ -407,6 +424,7 @@ public:
             ApplyConversion(node, target_type_);
         }
     }
+    void ApplyConversionCast(const ir::AstNode *node, const checker::Type *target_type);
     void ApplyConversion(const ir::AstNode *node, const checker::Type *target_type);
     void ApplyCast(const ir::AstNode *node, const checker::Type *target_type);
     void EmitUnboxingConversion(const ir::AstNode *node);
@@ -534,6 +552,7 @@ public:
     void NewArray(const ir::AstNode *node, VReg arr, VReg dim, const checker::Type *arr_type);
     void NewObject(const ir::AstNode *node, VReg ctor, util::StringView name);
     void BuildString(const ir::Expression *node);
+    void CallBigIntOperator(const ir::Expression *node);
     void BuildTemplateString(const ir::TemplateLiteral *node);
     void InitObject(const ir::AstNode *node, checker::Signature *signature,
                     const ArenaVector<ir::Expression *> &arguments)
@@ -618,6 +637,7 @@ public:
     }
 #endif  // PANDA_WITH_ETS
 
+    void CreateBigIntObject(const ir::AstNode *node, VReg arg0);
     void CreateLambdaObjectFromIdentReference(const ir::AstNode *node, ir::ClassDefinition *lambda_obj);
     void CreateLambdaObjectFromMemberReference(const ir::AstNode *node, ir::Expression *obj,
                                                ir::ClassDefinition *lambda_obj);
@@ -642,6 +662,7 @@ private:
 
     void EmitIsInstanceNonNullish(const ir::AstNode *node, VReg obj_reg, checker::ETSObjectType const *cls_type);
 
+    void LoadConstantObject(const ir::Expression *node, const checker::Type *type);
     void StringBuilderAppend(const ir::AstNode *node, VReg builder);
     void AppendString(const ir::Expression *bin_expr, VReg builder);
     void StringBuilder(const ir::Expression *left, const ir::Expression *right, VReg builder);
diff --git a/ets2panda/compiler/core/compilerImpl.cpp b/ets2panda/compiler/core/compilerImpl.cpp
index 0d33af9dd5f188d697279484eade4585c5a1668e..858ca20a05ae825f2e0c312cf3951fca9a26db04 100644
--- a/ets2panda/compiler/core/compilerImpl.cpp
+++ b/ets2panda/compiler/core/compilerImpl.cpp
@@ -115,7 +115,10 @@ static pandasm::Program *CreateCompiler(const CompilationUnit &unit, const Phase
     context.SetParser(&parser);
 
     parser.ParseScript(unit.input, unit.options.compilation_mode == CompilationMode::GEN_STD_LIB);
-
+    if constexpr (std::is_same_v<Parser, parser::ETSParser> && std::is_same_v<VarBinder, varbinder::ETSBinder>) {
+        reinterpret_cast<varbinder::ETSBinder *>(varbinder)->FillResolvedImportPathes(parser.ResolvedParsedSourcesMap(),
+                                                                                      &allocator);
+    }
     for (auto *phase : get_phases()) {
         if (!phase->Apply(&context, &program)) {
             return nullptr;
diff --git a/ets2panda/compiler/lowering/ets/unionLowering.cpp b/ets2panda/compiler/lowering/ets/unionLowering.cpp
index f036bdab81d8125c6a4a86a88fdf445edff8c45f..fbe3ea2305c169b19fea88986399c4938a619a15 100644
--- a/ets2panda/compiler/lowering/ets/unionLowering.cpp
+++ b/ets2panda/compiler/lowering/ets/unionLowering.cpp
@@ -17,21 +17,21 @@
 #include "varbinder/variableFlags.h"
 #include "varbinder/ETSBinder.h"
 #include "checker/ETSchecker.h"
+#include "checker/ets/conversion.h"
+#include "checker/ets/boxingConverter.h"
 #include "compiler/core/compilerContext.h"
+#include "compiler/lowering/util.h"
 #include "ir/base/classDefinition.h"
 #include "ir/base/classProperty.h"
 #include "ir/astNode.h"
 #include "ir/expression.h"
 #include "ir/opaqueTypeNode.h"
-#include "ir/ets/etsParameterExpression.h"
-#include "ir/expressions/assignmentExpression.h"
 #include "ir/expressions/binaryExpression.h"
 #include "ir/expressions/identifier.h"
-#include "ir/expressions/functionExpression.h"
 #include "ir/expressions/memberExpression.h"
-#include "ir/expressions/sequenceExpression.h"
 #include "ir/statements/blockStatement.h"
 #include "ir/statements/classDeclaration.h"
+#include "ir/statements/variableDeclaration.h"
 #include "ir/ts/tsAsExpression.h"
 #include "type_helper.h"
 
@@ -115,46 +115,261 @@ void HandleUnionPropertyAccess(checker::ETSChecker *checker, varbinder::VarBinde
     ASSERT(expr->PropVar() != nullptr);
 }
 
-ir::Expression *HandleBinaryExpressionWithUnion(checker::ETSChecker *checker, ir::BinaryExpression *expr)
+ir::TSAsExpression *GenAsExpression(checker::ETSChecker *checker, checker::Type *const opaque_type,
+                                    ir::Expression *const node, ir::AstNode *const parent)
 {
-    auto *union_type = expr->OperationType()->AsETSUnionType();
-    ir::Expression *union_node;
-    ir::Expression *other_union_node = nullptr;
-    checker::Type *other_node_type;
-    if (expr->Left()->TsType()->IsETSUnionType()) {
-        union_node = expr->Left();
-        other_node_type = expr->Right()->TsType();
-        if (other_node_type->IsETSUnionType()) {
-            other_union_node = expr->Right();
+    auto *const type_node = checker->AllocNode<ir::OpaqueTypeNode>(opaque_type);
+    auto *const as_expression = checker->AllocNode<ir::TSAsExpression>(node, type_node, false);
+    as_expression->SetParent(parent);
+    node->SetParent(as_expression);
+    as_expression->Check(checker);
+    return as_expression;
+}
+
+/*
+ *  Function that generates conversion from (union) to (primitive) type as to `as` expressions:
+ *      (union) as (prim) => ((union) as (ref)) as (prim),
+ *      where (ref) is some unboxable type from union constituent types.
+ *  Finally, `(union) as (prim)` expression replaces union_node that came above.
+ */
+ir::TSAsExpression *UnionCastToPrimitive(checker::ETSChecker *checker, checker::ETSObjectType *unboxable_ref,
+                                         checker::Type *unboxed_prim, ir::Expression *union_node)
+{
+    auto *const union_as_ref_expression = GenAsExpression(checker, unboxable_ref, union_node, nullptr);
+    union_as_ref_expression->SetBoxingUnboxingFlags(checker->GetUnboxingFlag(unboxed_prim));
+    union_node->SetParent(union_as_ref_expression);
+
+    auto *const ref_as_prim_expression =
+        GenAsExpression(checker, unboxed_prim, union_as_ref_expression, union_node->Parent());
+    union_as_ref_expression->SetParent(ref_as_prim_expression);
+
+    return ref_as_prim_expression;
+}
+
+ir::TSAsExpression *HandleUnionCastToPrimitive(checker::ETSChecker *checker, ir::TSAsExpression *expr)
+{
+    auto *const union_type = expr->Expr()->TsType()->AsETSUnionType();
+    auto *source_type = union_type->FindExactOrBoxedType(checker, expr->TsType());
+    if (source_type == nullptr) {
+        source_type = union_type->AsETSUnionType()->FindTypeIsCastableToSomeType(expr->Expr(), checker->Relation(),
+                                                                                 expr->TsType());
+    }
+    if (source_type != nullptr && expr->Expr()->GetBoxingUnboxingFlags() != ir::BoxingUnboxingFlags::NONE) {
+        if (expr->TsType()->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE)) {
+            auto *const boxed_expr_type = checker::BoxingConverter::ETSTypeFromSource(checker, expr->TsType());
+            auto *const as_expr = GenAsExpression(checker, boxed_expr_type, expr->Expr(), expr);
+            as_expr->SetBoxingUnboxingFlags(expr->Expr()->GetBoxingUnboxingFlags());
+            expr->Expr()->SetBoxingUnboxingFlags(ir::BoxingUnboxingFlags::NONE);
+            expr->SetExpr(as_expr);
         }
-    } else {
-        union_node = expr->Right();
-        other_node_type = expr->Left()->TsType();
+        return expr;
     }
-    auto *source_type =
-        union_type->AsETSUnionType()->FindTypeIsCastableToSomeType(union_node, checker->Relation(), other_node_type);
-    if (source_type == nullptr) {
-        checker->ThrowTypeError("Bad operand type, some type of the union must be the same type as other expression.",
-                                expr->Start());
-    }
-    if ((union_node->GetBoxingUnboxingFlags() & ir::BoxingUnboxingFlags::BOXING_FLAG) != 0U &&
-        source_type->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
-        union_node->SetBoxingUnboxingFlags(ir::BoxingUnboxingFlags::NONE);
-    }
-    auto *union_type_node = checker->AllocNode<ir::OpaqueTypeNode>(source_type);
-    auto *as_expression = checker->AllocNode<ir::TSAsExpression>(union_node, union_type_node, false);
-    as_expression->SetParent(expr);
-    expr->SetOperationType(source_type);
-    if (other_union_node != nullptr) {
-        auto *other_union_type_node = checker->AllocNode<ir::OpaqueTypeNode>(other_node_type);
-        auto *other_as_expression =
-            checker->AllocNode<ir::TSAsExpression>(other_union_node, other_union_type_node, false);
-        other_as_expression->SetParent(expr);
+    auto *const unboxable_union_type = source_type != nullptr ? source_type : union_type->FindUnboxableType();
+    auto *const unboxed_union_type = checker->ETSBuiltinTypeAsPrimitiveType(unboxable_union_type);
+    expr->SetExpr(
+        UnionCastToPrimitive(checker, unboxable_union_type->AsETSObjectType(), unboxed_union_type, expr->Expr()));
+    return expr;
+}
+
+ir::BinaryExpression *GenInstanceofExpr(checker::ETSChecker *checker, ir::Expression *union_node,
+                                        checker::Type *constituent_type)
+{
+    auto *const lhs_expr = union_node->Clone(checker->Allocator())->AsExpression();
+    lhs_expr->Check(checker);
+    lhs_expr->SetBoxingUnboxingFlags(union_node->GetBoxingUnboxingFlags());
+    auto *rhs_type = constituent_type;
+    if (!constituent_type->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
+        checker->Relation()->SetNode(union_node);
+        rhs_type = checker::conversion::Boxing(checker->Relation(), constituent_type);
+        checker->Relation()->SetNode(nullptr);
     }
+    auto *const rhs_expr =
+        checker->Allocator()->New<ir::Identifier>(rhs_type->AsETSObjectType()->Name(), checker->Allocator());
+    auto *const instanceof_expr =
+        checker->Allocator()->New<ir::BinaryExpression>(lhs_expr, rhs_expr, lexer::TokenType::KEYW_INSTANCEOF);
+    lhs_expr->SetParent(instanceof_expr);
+    rhs_expr->SetParent(instanceof_expr);
+    auto rhs_var = NearestScope(union_node)->Find(rhs_expr->Name());
+    rhs_expr->SetVariable(rhs_var.variable);
+    rhs_expr->SetTsType(rhs_var.variable->TsType());
+    instanceof_expr->SetOperationType(checker->GlobalETSObjectType());
+    instanceof_expr->SetTsType(checker->GlobalETSBooleanType());
+    return instanceof_expr;
+}
+
+ir::VariableDeclaration *GenVariableDeclForBinaryExpr(checker::ETSChecker *checker, varbinder::Scope *scope,
+                                                      ir::BinaryExpression *expr)
+{
+    ASSERT(expr->OperatorType() == lexer::TokenType::PUNCTUATOR_EQUAL ||
+           expr->OperatorType() == lexer::TokenType::PUNCTUATOR_NOT_EQUAL);
+    auto *var_id = Gensym(checker->Allocator());
+    auto *var = scope->AddDecl<varbinder::LetDecl, varbinder::LocalVariable>(checker->Allocator(), var_id->Name(),
+                                                                             varbinder::VariableFlags::LOCAL);
+    var->SetTsType(checker->GlobalETSBooleanType());
+    var_id->SetVariable(var);
+    var_id->SetTsType(var->TsType());
+
+    auto declarator = checker->AllocNode<ir::VariableDeclarator>(var_id);
+    ArenaVector<ir::VariableDeclarator *> declarators(checker->Allocator()->Adapter());
+    declarators.push_back(declarator);
+
+    auto var_kind = ir::VariableDeclaration::VariableDeclarationKind::LET;
+    auto *binary_var_decl =
+        checker->AllocNode<ir::VariableDeclaration>(var_kind, checker->Allocator(), std::move(declarators), false);
+    binary_var_decl->SetRange({expr->Start(), expr->End()});
+    return binary_var_decl;
+}
+
+ir::ExpressionStatement *GenExpressionStmtWithAssignment(checker::ETSChecker *checker, ir::Identifier *var_decl_id,
+                                                         ir::Expression *expr)
+{
+    auto *assignment_for_binary =
+        checker->AllocNode<ir::AssignmentExpression>(var_decl_id, expr, lexer::TokenType::PUNCTUATOR_SUBSTITUTION);
+    assignment_for_binary->SetTsType(expr->TsType());
+    return checker->AllocNode<ir::ExpressionStatement>(assignment_for_binary);
+}
+
+ir::BlockStatement *GenBlockStmtForAssignmentBinary(checker::ETSChecker *checker, ir::Identifier *var_decl_id,
+                                                    ir::Expression *expr)
+{
+    auto local_ctx = varbinder::LexicalScope<varbinder::LocalScope>(checker->VarBinder());
+    ArenaVector<ir::Statement *> stmts(checker->Allocator()->Adapter());
+    auto *stmt = GenExpressionStmtWithAssignment(checker, var_decl_id, expr);
+    stmts.push_back(stmt);
+    auto *const local_block_stmt =
+        checker->AllocNode<ir::BlockStatement>(checker->Allocator(), local_ctx.GetScope(), std::move(stmts));
+    stmt->SetParent(local_block_stmt);
+    local_block_stmt->SetRange(stmt->Range());
+    local_ctx.GetScope()->BindNode(local_block_stmt);
+    return local_block_stmt;
+}
+
+ir::Expression *SetBoxFlagOrGenAsExpression(checker::ETSChecker *checker, checker::Type *constituent_type,
+                                            ir::Expression *other_node)
+{
+    if (constituent_type->AsETSObjectType()->HasObjectFlag(checker::ETSObjectFlags::UNBOXABLE_TYPE) &&
+        !other_node->IsETSUnionType() && other_node->TsType()->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE)) {
+        auto *unboxed_constituent_type = checker->ETSBuiltinTypeAsPrimitiveType(constituent_type);
+        if (unboxed_constituent_type != other_node->TsType()) {
+            auto *const prim_as_expression =
+                GenAsExpression(checker, unboxed_constituent_type, other_node, other_node->Parent());
+            prim_as_expression->SetBoxingUnboxingFlags(checker->GetBoxingFlag(constituent_type));
+            return prim_as_expression;
+        }
+        return other_node;
+    }
+    if (other_node->TsType()->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE)) {
+        other_node->SetBoxingUnboxingFlags(
+            checker->GetBoxingFlag(checker::BoxingConverter::ETSTypeFromSource(checker, other_node->TsType())));
+    }
+    return other_node;
+}
+
+ir::Expression *ProcessOperandsInBinaryExpr(checker::ETSChecker *checker, ir::BinaryExpression *expr,
+                                            checker::Type *constituent_type)
+{
+    ASSERT(expr->OperatorType() == lexer::TokenType::PUNCTUATOR_EQUAL ||
+           expr->OperatorType() == lexer::TokenType::PUNCTUATOR_NOT_EQUAL);
+    bool is_lhs_union;
+    ir::Expression *union_node =
+        (is_lhs_union = expr->Left()->TsType()->IsETSUnionType()) ? expr->Left() : expr->Right();
+    auto *const as_expression = GenAsExpression(checker, constituent_type, union_node, expr);
+    if (is_lhs_union) {
+        expr->SetLeft(as_expression);
+        expr->SetRight(SetBoxFlagOrGenAsExpression(checker, constituent_type, expr->Right()));
+    } else {
+        expr->SetRight(as_expression);
+        expr->SetLeft(SetBoxFlagOrGenAsExpression(checker, constituent_type, expr->Left()));
+    }
+    expr->SetOperationType(checker->GlobalETSObjectType());
     expr->SetTsType(checker->GlobalETSBooleanType());
     return expr;
 }
 
+ir::Statement *FindStatementFromNode(ir::Expression *expr)
+{
+    ir::AstNode *node = expr;
+    while (!node->IsStatement()) {
+        node = node->Parent();
+    }
+    ASSERT(node->IsStatement());
+    return node->AsStatement();
+}
+
+void InsertInstanceofTreeBeforeStmt(ir::Statement *stmt, ir::VariableDeclaration *binary_var_decl,
+                                    ir::Statement *instanceof_tree)
+{
+    if (stmt->IsVariableDeclarator()) {
+        ASSERT(stmt->Parent()->IsVariableDeclaration());
+        stmt = stmt->Parent()->AsVariableDeclaration();
+    }
+    ASSERT(stmt->Parent()->IsBlockStatement());
+    auto *block = stmt->Parent()->AsBlockStatement();
+    binary_var_decl->SetParent(block);
+    instanceof_tree->SetParent(block);
+    auto it_stmt = std::find(block->Statements().begin(), block->Statements().end(), stmt);
+    block->Statements().insert(it_stmt, {binary_var_decl, instanceof_tree});
+}
+
+ir::BlockStatement *ReplaceBinaryExprInStmt(checker::ETSChecker *checker, ir::Expression *union_node,
+                                            ir::BlockStatement *block, ir::BinaryExpression *expr)
+{
+    auto *stmt = FindStatementFromNode(expr);
+    ASSERT(stmt->IsVariableDeclarator() || block == stmt->Parent());  // statement with union
+    auto *const binary_var_decl = GenVariableDeclForBinaryExpr(checker, NearestScope(stmt), expr);
+    auto *const var_decl_id = binary_var_decl->Declarators().front()->Id();  // only one declarator was generated
+    ir::IfStatement *instanceof_tree = nullptr;
+    for (auto *u_type : union_node->TsType()->AsETSUnionType()->ConstituentTypes()) {
+        auto *const test = GenInstanceofExpr(checker, union_node, u_type);
+        auto *cloned_binary = expr->Clone(checker->Allocator(), expr->Parent())->AsBinaryExpression();
+        cloned_binary->Check(checker);
+        auto *const consequent = GenBlockStmtForAssignmentBinary(
+            checker, var_decl_id->AsIdentifier(), ProcessOperandsInBinaryExpr(checker, cloned_binary, u_type));
+        instanceof_tree = checker->Allocator()->New<ir::IfStatement>(test, consequent, instanceof_tree);
+        test->SetParent(instanceof_tree);
+        consequent->SetParent(instanceof_tree);
+        if (instanceof_tree->Alternate() != nullptr) {
+            instanceof_tree->Alternate()->SetParent(instanceof_tree);
+        }
+    }
+    ASSERT(instanceof_tree != nullptr);
+    // Replacing a binary expression with an identifier
+    // that was set in one of the branches of the `instanceof_tree` tree
+    stmt->TransformChildrenRecursively([var_decl_id](ir::AstNode *ast) -> ir::AstNode * {
+        if (ast->IsBinaryExpression() && ast->AsBinaryExpression()->OperationType() != nullptr &&
+            ast->AsBinaryExpression()->OperationType()->IsETSUnionType()) {
+            return var_decl_id;
+        }
+
+        return ast;
+    });
+    InsertInstanceofTreeBeforeStmt(stmt, binary_var_decl, instanceof_tree);
+    return block;
+}
+
+ir::BlockStatement *HandleBlockWithBinaryAndUnion(checker::ETSChecker *checker, ir::BlockStatement *block,
+                                                  ir::BinaryExpression *bin_expr)
+{
+    if (bin_expr->OperatorType() != lexer::TokenType::PUNCTUATOR_EQUAL &&
+        bin_expr->OperatorType() != lexer::TokenType::PUNCTUATOR_NOT_EQUAL) {
+        checker->ThrowTypeError("Bad operand type, unions are not allowed in binary expressions except equality.",
+                                bin_expr->Start());
+    }
+    ir::Expression *union_node = bin_expr->Left()->TsType()->IsETSUnionType() ? bin_expr->Left() : bin_expr->Right();
+    return ReplaceBinaryExprInStmt(checker, union_node, block, bin_expr);
+}
+
+ir::BlockStatement *HandleBlockWithBinaryAndUnions(checker::ETSChecker *checker, ir::BlockStatement *block,
+                                                   const ir::NodePredicate &handle_binary)
+{
+    ir::BlockStatement *modified_ast_block = block;
+    while (modified_ast_block->IsAnyChild(handle_binary)) {
+        modified_ast_block = HandleBlockWithBinaryAndUnion(
+            checker, modified_ast_block, modified_ast_block->FindChild(handle_binary)->AsBinaryExpression());
+    }
+    return modified_ast_block;
+}
+
 bool UnionLowering::Perform(CompilerContext *ctx, parser::Program *program)
 {
     for (auto &[_, ext_programs] : program->ExternalSources()) {
@@ -173,9 +388,19 @@ bool UnionLowering::Perform(CompilerContext *ctx, parser::Program *program)
             return ast;
         }
 
-        if (ast->IsBinaryExpression() && ast->AsBinaryExpression()->OperationType() != nullptr &&
-            ast->AsBinaryExpression()->OperationType()->IsETSUnionType()) {
-            return HandleBinaryExpressionWithUnion(checker, ast->AsBinaryExpression());
+        if (ast->IsTSAsExpression() && ast->AsTSAsExpression()->Expr()->TsType() != nullptr &&
+            ast->AsTSAsExpression()->Expr()->TsType()->IsETSUnionType() &&
+            ast->AsTSAsExpression()->TsType() != nullptr &&
+            ast->AsTSAsExpression()->TsType()->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE)) {
+            return HandleUnionCastToPrimitive(checker, ast->AsTSAsExpression());
+        }
+
+        auto handle_binary = [](const ir::AstNode *ast_node) {
+            return ast_node->IsBinaryExpression() && ast_node->AsBinaryExpression()->OperationType() != nullptr &&
+                   ast_node->AsBinaryExpression()->OperationType()->IsETSUnionType();
+        };
+        if (ast->IsBlockStatement() && ast->IsAnyChild(handle_binary)) {
+            return HandleBlockWithBinaryAndUnions(checker, ast->AsBlockStatement(), handle_binary);
         }
 
         return ast;
diff --git a/ets2panda/compiler/scripts/signatures.yaml b/ets2panda/compiler/scripts/signatures.yaml
index 0f2a2e8dc1a580211a2867ac346d91bd59545991..f71cdfd3698637f156dbbd2c16a2b8ee190ab135 100644
--- a/ets2panda/compiler/scripts/signatures.yaml
+++ b/ets2panda/compiler/scripts/signatures.yaml
@@ -251,6 +251,9 @@ builtins:
   - name: Error
     package: PKG_ESCOMPAT
     ref: BUILTIN_ERROR
+  - name: BigInt
+    package: PKG_ESCOMPAT
+    ref: BUILTIN_BIGINT
   - name: AssertionError
     package: PKG_ESCOMPAT
     ref: BUILTIN_ASSERTION_ERROR
@@ -331,6 +334,36 @@ signatures:
     return_type: PRIMITIVE_VOID
     ref: BUILTIN_ASSERTION_ERROR_CTOR
 
+  - callee: BUILTIN_BIGINT
+    method_name: $CTOR
+    params: [BUILTIN_STRING]
+    return_type: PRIMITIVE_VOID
+    ref: BUILTIN_BIGINT_CTOR
+
+  - callee: BUILTIN_BIGINT
+    method_name: $CTOR
+    params: []
+    return_type: PRIMITIVE_VOID
+    ref: BUILTIN_BIGINT_CTOR_EMPTY
+
+  - callee: BUILTIN_BIGINT
+    method_name: bigIntOperator
+    params: []
+    return_type: PRIMITIVE_LONG
+    ref: BUILTIN_BIGINT_OPERATOR
+
+  - callee: BUILTIN_BIGINT
+    method_name: equals
+    params: [BUILTIN_BIGINT]
+    return_type: PRIMITIVE_BOOLEAN
+    ref: BUILTIN_BIGINT_EQUALS
+
+  - callee: BUILTIN_BIGINT
+    method_name: negate
+    params: []
+    return_type: BUILTIN_BIGINT
+    ref: BUILTIN_BIGINT_NEGATE
+
   - callee: BUILTIN_THROWABLE
     method_name: $CTOR
     params: []
diff --git a/ets2panda/ir/astNode.cpp b/ets2panda/ir/astNode.cpp
index 4db50cff077bed7228d0102d09035f34df1efb3d..3aee5eb5479a8558ec216d99c8c8ad973ebac9b2 100644
--- a/ets2panda/ir/astNode.cpp
+++ b/ets2panda/ir/astNode.cpp
@@ -89,6 +89,27 @@ bool AstNode::IsAnyChild(const NodePredicate &cb) const
     return found;
 }
 
+void FindChildHelper(AstNode *&found, const NodePredicate &cb, AstNode *ast)
+{
+    if (found != nullptr) {
+        return;
+    }
+
+    if (cb(ast)) {
+        found = ast;
+        return;
+    }
+
+    ast->Iterate([&found, cb](AstNode *child) { FindChildHelper(found, cb, child); });
+}
+
+AstNode *AstNode::FindChild(const NodePredicate &cb) const
+{
+    AstNode *found = nullptr;
+    Iterate([&found, cb](AstNode *child) { FindChildHelper(found, cb, child); });
+    return found;
+}
+
 void AnnotatedAstNode::CloneTypeAnnotation(ArenaAllocator *const allocator)
 {
     if (auto *annotation = const_cast<TypeNode *>(TypeAnnotation()); annotation != nullptr) {
diff --git a/ets2panda/ir/astNode.h b/ets2panda/ir/astNode.h
index f164f1660c7d4bd4ae7438d7244faf93d3032686..db3ab5e36e752d6bd20626399ce1089271ad14af 100644
--- a/ets2panda/ir/astNode.h
+++ b/ets2panda/ir/astNode.h
@@ -460,6 +460,7 @@ public:
     void TransformChildrenRecursively(const NodeTransformer &cb);
     void IterateRecursively(const NodeTraverser &cb) const;
     bool IsAnyChild(const NodePredicate &cb) const;
+    AstNode *FindChild(const NodePredicate &cb) const;
 
     std::string DumpJSON() const;
 
diff --git a/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp b/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp
index e0a0ce1b2db3d3c27225f514e5e99143699d9d2f..f39597c1c670cd66b670a4125d64a644c651a9cc 100644
--- a/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp
+++ b/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp
@@ -164,6 +164,8 @@ checker::Type *ETSNewClassInstanceExpression::Check([[maybe_unused]] checker::ET
         auto *signature = checker->ResolveConstructExpression(callee_obj, arguments_, Start());
 
         checker->CheckObjectLiteralArguments(signature, arguments_);
+        checker->AddUndefinedParamsForDefaultParams(signature, arguments_, checker);
+
         checker->ValidateSignatureAccessibility(callee_obj, signature, Start());
 
         ASSERT(signature->Function() != nullptr);
diff --git a/ets2panda/ir/ets/etsParameterExpression.cpp b/ets2panda/ir/ets/etsParameterExpression.cpp
index 3d00268107796fc5b6a597b7f68a6067443080a1..0445df4d220a30566263e793144e4a19c495db29 100644
--- a/ets2panda/ir/ets/etsParameterExpression.cpp
+++ b/ets2panda/ir/ets/etsParameterExpression.cpp
@@ -171,12 +171,16 @@ ETSParameterExpression *ETSParameterExpression::Clone(ArenaAllocator *const allo
 
     if (auto *const clone = allocator->New<ETSParameterExpression>(ident_or_spread, initializer); clone != nullptr) {
         ident_or_spread->SetParent(clone);
+
         if (initializer != nullptr) {
             initializer->SetParent(clone);
         }
+
         if (parent != nullptr) {
             clone->SetParent(parent);
         }
+
+        clone->SetRequiredParams(extra_value_);
         return clone;
     }
 
diff --git a/ets2panda/ir/ets/etsParameterExpression.h b/ets2panda/ir/ets/etsParameterExpression.h
index 7786d77fc3080a6e8cbb0e956982ba3ae1423283..64af2b177868a115c2d00efe1a7b2781e18888eb 100644
--- a/ets2panda/ir/ets/etsParameterExpression.h
+++ b/ets2panda/ir/ets/etsParameterExpression.h
@@ -23,6 +23,10 @@ class ETSAnalyzer;
 }  // namespace panda::es2panda::checker
 
 namespace panda::es2panda::ir {
+// NOLINTBEGIN(modernize-avoid-c-arrays)
+inline constexpr char const PROXY_PARAMETER_NAME[] = "$proxy_mask$";
+// NOLINTEND(modernize-avoid-c-arrays)
+
 class ETSParameterExpression final : public Expression {
 public:
     ETSParameterExpression() = delete;
@@ -64,6 +68,16 @@ public:
         return spread_ != nullptr;
     }
 
+    [[nodiscard]] std::size_t GetRequiredParams() const noexcept
+    {
+        return extra_value_;
+    }
+
+    void SetRequiredParams(std::size_t const value) noexcept
+    {
+        extra_value_ = value;
+    }
+
     // NOLINTNEXTLINE(google-default-arguments)
     [[nodiscard]] ETSParameterExpression *Clone(ArenaAllocator *allocator, AstNode *parent = nullptr) override;
 
@@ -80,6 +94,7 @@ private:
     Expression *initializer_;
     SpreadElement *spread_ = nullptr;
     util::StringView saved_lexer_ = "";
+    std::size_t extra_value_ = 0U;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ets2panda/ir/expressions/binaryExpression.h b/ets2panda/ir/expressions/binaryExpression.h
index 98416dc89f6ebc5a57cda74ccdc29435ff180bf8..69bdfa92f80f1e02c5bbc025e2a116dd4ad525af 100644
--- a/ets2panda/ir/expressions/binaryExpression.h
+++ b/ets2panda/ir/expressions/binaryExpression.h
@@ -92,6 +92,12 @@ public:
         SetStart(left_->Start());
     }
 
+    void SetRight(Expression *expr) noexcept
+    {
+        right_ = expr;
+        SetEnd(right_->End());
+    }
+
     void SetResult(Expression *expr) noexcept
     {
         left_ = expr;
diff --git a/ets2panda/ir/expressions/literals/bigIntLiteral.cpp b/ets2panda/ir/expressions/literals/bigIntLiteral.cpp
index 5887c20cd73cb0fc8aebd1a34de9e631d1e5d146..23fac98eb3d54c28d1c14dd842b088d09e17a6a4 100644
--- a/ets2panda/ir/expressions/literals/bigIntLiteral.cpp
+++ b/ets2panda/ir/expressions/literals/bigIntLiteral.cpp
@@ -18,6 +18,8 @@
 #include "compiler/core/pandagen.h"
 #include "checker/TSchecker.h"
 #include "ir/astDump.h"
+#include "compiler/core/ETSGen.h"
+#include "checker/ETSchecker.h"
 
 namespace panda::es2panda::ir {
 void BigIntLiteral::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {}
@@ -33,6 +35,16 @@ void BigIntLiteral::Compile(compiler::PandaGen *pg) const
     pg->LoadAccumulatorBigInt(this, src_);
 }
 
+void BigIntLiteral::Compile(compiler::ETSGen *etsg) const
+{
+    compiler::TargetTypeContext ttctx = compiler::TargetTypeContext(etsg, TsType());
+    compiler::RegScope rs {etsg};
+    etsg->LoadAccumulatorBigInt(this, src_);
+    const compiler::VReg value = etsg->AllocReg();
+    etsg->StoreAccumulator(this, value);
+    etsg->CreateBigIntObject(this, value);
+}
+
 checker::Type *BigIntLiteral::Check(checker::TSChecker *checker)
 {
     auto search = checker->BigintLiteralMap().find(src_);
@@ -47,7 +59,8 @@ checker::Type *BigIntLiteral::Check(checker::TSChecker *checker)
 
 checker::Type *BigIntLiteral::Check([[maybe_unused]] checker::ETSChecker *checker)
 {
-    return nullptr;
+    SetTsType(checker->CreateETSBigIntLiteralType(src_));
+    return TsType();
 }
 
 // NOLINTNEXTLINE(google-default-arguments)
diff --git a/ets2panda/ir/expressions/literals/bigIntLiteral.h b/ets2panda/ir/expressions/literals/bigIntLiteral.h
index 32d4c40d30351f22165c52ebadbaa4c55e770d4e..3748403b5b1e8facd1ffef009acac91589975785 100644
--- a/ets2panda/ir/expressions/literals/bigIntLiteral.h
+++ b/ets2panda/ir/expressions/literals/bigIntLiteral.h
@@ -42,6 +42,7 @@ public:
     void Iterate(const NodeTraverser &cb) const override;
     void Dump(ir::AstDumper *dumper) const override;
     void Compile([[maybe_unused]] compiler::PandaGen *pg) const override;
+    void Compile(compiler::ETSGen *etsg) const override;
     checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override;
     checker::Type *Check([[maybe_unused]] checker::ETSChecker *checker) override;
 
diff --git a/ets2panda/ir/expressions/memberExpression.cpp b/ets2panda/ir/expressions/memberExpression.cpp
index eda32a4f54bc8b03bc90d84116794cfc99a46cad..082e0be6487e34ccf89435b79a3bd66bf7ed4b40 100644
--- a/ets2panda/ir/expressions/memberExpression.cpp
+++ b/ets2panda/ir/expressions/memberExpression.cpp
@@ -451,6 +451,15 @@ checker::Type *MemberExpression::Check(checker::ETSChecker *checker)
         return AdjustOptional(checker, CheckUnionMember(checker, base_type));
     }
 
+    if (base_type->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE)) {
+        checker->Relation()->SetNode(this);
+        SetObjectType(checker->PrimitiveTypeAsETSBuiltinType(base_type)->AsETSObjectType());
+        checker->AddBoxingUnboxingFlagToNode(this, obj_type_);
+        auto [res_type, res_var] = ResolveObjectMember(checker);
+        SetPropVar(res_var);
+        return AdjustOptional(checker, res_type);
+    }
+
     checker->ThrowTypeError({"Cannot access property of non-object or non-enum type"}, object_->Start());
 }
 
@@ -460,7 +469,15 @@ MemberExpression *MemberExpression::Clone(ArenaAllocator *const allocator, AstNo
     auto *const object = object_ != nullptr ? object_->Clone(allocator)->AsExpression() : nullptr;
     auto *const property = property_ != nullptr ? property_->Clone(allocator)->AsExpression() : nullptr;
 
-    if (auto *const clone = allocator->New<MemberExpression>(Tag {}, *this, object, property); clone != nullptr) {
+    if (auto *const clone =
+            allocator->New<MemberExpression>(object, property, kind_, computed_, MaybeOptionalExpression::IsOptional());
+        clone != nullptr) {
+        if (object != nullptr) {
+            object->SetParent(clone);
+        }
+        if (property != nullptr) {
+            property->SetParent(clone);
+        }
         if (parent != nullptr) {
             clone->SetParent(parent);
         }
diff --git a/ets2panda/ir/expressions/unaryExpression.cpp b/ets2panda/ir/expressions/unaryExpression.cpp
index a73cbef0771f745f05549cd07d211661f5374add..3a584e7b1578348aa58d1c2f1bbe622898b0a203 100644
--- a/ets2panda/ir/expressions/unaryExpression.cpp
+++ b/ets2panda/ir/expressions/unaryExpression.cpp
@@ -16,6 +16,7 @@
 #include "unaryExpression.h"
 
 #include "varbinder/variable.h"
+#include "checker/types/typeFlag.h"
 #include "compiler/core/pandagen.h"
 #include "compiler/core/ETSGen.h"
 #include "checker/TSchecker.h"
@@ -230,6 +231,24 @@ checker::Type *UnaryExpression::Check(checker::ETSChecker *checker)
     checker::Type *operand_type = checker->ApplyUnaryOperatorPromotion(arg_type, true, true, is_cond_expr);
     auto unboxed_operand_type = is_cond_expr ? checker->ETSBuiltinTypeAsConditionalType(arg_type)
                                              : checker->ETSBuiltinTypeAsPrimitiveType(arg_type);
+    if (arg_type != nullptr && arg_type->IsETSBigIntType() &&
+        arg_type->HasTypeFlag(checker::TypeFlag::BIGINT_LITERAL)) {
+        switch (operator_) {
+            case lexer::TokenType::PUNCTUATOR_MINUS: {
+                checker::Type *type = checker->CreateETSBigIntLiteralType(arg_type->AsETSBigIntType()->GetValue());
+
+                // We do not need this const anymore as we are negating the bigint object in runtime
+                type->RemoveTypeFlag(checker::TypeFlag::CONSTANT);
+                argument_->SetTsType(type);
+                SetTsType(type);
+                return TsType();
+            }
+            default:
+                // Handled below
+                // NOTE(kkonsw): handle other unary operators for bigint objects
+                break;
+        }
+    }
 
     switch (operator_) {
         case lexer::TokenType::PUNCTUATOR_MINUS:
@@ -283,7 +302,7 @@ checker::Type *UnaryExpression::Check(checker::ETSChecker *checker)
                 break;
             }
 
-            SetTsType(operand_type);
+            SetTsType(checker->GlobalETSBooleanType());
             break;
         }
         case lexer::TokenType::PUNCTUATOR_DOLLAR_DOLLAR: {
@@ -296,7 +315,7 @@ checker::Type *UnaryExpression::Check(checker::ETSChecker *checker)
         }
     }
 
-    if (arg_type->IsETSObjectType() && (unboxed_operand_type != nullptr) &&
+    if ((arg_type != nullptr) && arg_type->IsETSObjectType() && (unboxed_operand_type != nullptr) &&
         unboxed_operand_type->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE)) {
         argument_->AddBoxingUnboxingFlag(checker->GetUnboxingFlag(unboxed_operand_type));
     }
diff --git a/ets2panda/ir/statements/ifStatement.h b/ets2panda/ir/statements/ifStatement.h
index e124967507389f106356031ac29b6e8827a49598..57755853e4591303e6ed7855348c27a5d40cd579 100644
--- a/ets2panda/ir/statements/ifStatement.h
+++ b/ets2panda/ir/statements/ifStatement.h
@@ -47,6 +47,11 @@ public:
         return consequent_;
     }
 
+    Statement *Alternate()
+    {
+        return alternate_;
+    }
+
     const Statement *Alternate() const
     {
         return alternate_;
diff --git a/ets2panda/lexer/ETSLexer.h b/ets2panda/lexer/ETSLexer.h
index 1ad9801099336f62558f21e607ea0b0dc1975223..b1664791a98bf1dff8257fa6a6c6a81f00655c6a 100644
--- a/ets2panda/lexer/ETSLexer.h
+++ b/ets2panda/lexer/ETSLexer.h
@@ -17,6 +17,7 @@
 #define ES2PANDA_PARSER_CORE_ETS_LEXER_H
 
 #include "lexer/lexer.h"
+#include "token/letters.h"
 
 namespace panda::es2panda::lexer {
 class ETSLexer final : public Lexer {
@@ -40,12 +41,25 @@ public:
     void ScanNumberLeadingZero() override
     {
         const auto saved_lexer_position = Save();
+
+        bool allow_bigint = false;
+        if (Iterator().Peek() == LEX_CHAR_LOWERCASE_N) {
+            // 0n is the only allowed bigint literal with leading 0
+            allow_bigint = true;
+        }
+
         try {
             ScanNumberLeadingZeroImpl<uint32_t, uint32_t>();
         } catch (...) {
             Rewind(saved_lexer_position);
             ScanNumberLeadingZeroImpl<uint64_t, uint64_t>();
         }
+
+        if ((GetToken().flags_ & TokenFlags::NUMBER_BIGINT) != 0) {
+            if (!allow_bigint) {
+                ThrowError("Invalid BigInt number");
+            }
+        }
     }
 
     void CheckUtf16Compatible(char32_t cp) const;
diff --git a/ets2panda/parser/ETSparser.cpp b/ets2panda/parser/ETSparser.cpp
index 1100af3be59744c72fa13015407b4cf5ab5d647c..5d2da9eaafa61605feee038dbb1a7260cfcfc392 100644
--- a/ets2panda/parser/ETSparser.cpp
+++ b/ets2panda/parser/ETSparser.cpp
@@ -173,11 +173,21 @@ void ETSParser::ParseETSGlobalScript(lexer::SourcePosition start_loc, ArenaVecto
     // remove external sources from paths because already parsed them
     paths.erase(remove_if(begin(paths), end(paths),
                           [this](auto x) {
-                              return find(begin(parsed_sources_), end(parsed_sources_), x) != end(parsed_sources_);
+                              auto resolved = ResolveImportPath(x);
+                              auto path_iter =
+                                  std::find_if(resolved_parsed_sources_.begin(), resolved_parsed_sources_.end(),
+                                               [resolved](const auto &p) { return p.second == resolved; });
+                              auto found = path_iter != resolved_parsed_sources_.end();
+                              if (found) {
+                                  resolved_parsed_sources_.emplace(x, resolved);
+                              }
+                              return found;
                           }),
                 end(paths));
 
-    parsed_sources_.insert(parsed_sources_.end(), paths.begin(), paths.end());
+    for (const auto &path : paths) {
+        parsed_sources_.push_back(ResolveImportPath(path));
+    }
 
     ParseSources(paths, false);
     ParseTopLevelDeclaration(statements);
@@ -231,9 +241,12 @@ ArenaVector<ir::Statement *> ETSParser::PrepareExternalGlobalClass([[maybe_unuse
     if (!statements.empty()) {
         res = ext_sources.find(name);
     } else {
-        const util::UString source_file_path(
-            GetProgram()->SourceFilePath().Mutf8() + GetProgram()->GetPackageName().Mutf8(), Allocator());
-        GetProgram()->SetSource(GetProgram()->SourceCode(), GetProgram()->SourceFile(), source_file_path.View());
+        auto path = GetProgram()->SourceFilePath().Mutf8() + panda::os::file::File::GetPathDelim().at(0) +
+                    GetProgram()->GetPackageName().Mutf8();
+        auto resolved = ResolveImportPath(path);
+        resolved_parsed_sources_.emplace(path, resolved);
+        GetProgram()->SetSource(GetProgram()->SourceCode(), GetProgram()->SourceFile(),
+                                util::UString(resolved, Allocator()).View());
     }
 
     if (res == ext_sources.end()) {
@@ -344,14 +357,30 @@ ETSParser::ImportData ETSParser::GetImportData(const std::string &path)
     return {ToLanguage(Extension()), path, true};
 }
 
+std::string ETSParser::ResolveFullPathFromRelative(const std::string &path)
+{
+    char path_delimiter = panda::os::file::File::GetPathDelim().at(0);
+    auto resolved_fp = GetProgram()->ResolvedFilePath().Mutf8();
+    auto source_fp = GetProgram()->SourceFilePath().Mutf8();
+    if (resolved_fp.empty()) {
+        auto fp = source_fp + path_delimiter + path;
+        return util::Helpers::IsRealPath(fp) ? fp : path;
+    }
+    auto fp = resolved_fp + path_delimiter + path;
+    if (util::Helpers::IsRealPath(fp)) {
+        return fp;
+    }
+    if (path.find(source_fp) == 0) {
+        return resolved_fp + path_delimiter + path.substr(source_fp.size());
+    }
+    return path;
+}
+
 std::string ETSParser::ResolveImportPath(const std::string &path)
 {
     char path_delimiter = panda::os::file::File::GetPathDelim().at(0);
     if (util::Helpers::IsRelativePath(path)) {
-        if (GetProgram()->ResolvedFilePath().Mutf8().empty()) {
-            return GetProgram()->SourceFilePath().Mutf8() + path_delimiter + path;
-        }
-        return GetProgram()->ResolvedFilePath().Mutf8() + path_delimiter + path;
+        return util::Helpers::GetAbsPath(ResolveFullPathFromRelative(path));
     }
 
     std::string base_url;
@@ -395,11 +424,29 @@ std::string ETSParser::ResolveImportPath(const std::string &path)
     return base_url;
 }
 
+std::tuple<std::string, bool> ETSParser::GetSourceRegularPath(const std::string &path, const std::string &resolved_path)
+{
+    if (!panda::os::file::File::IsRegularFile(resolved_path)) {
+        std::string import_extension = ".ets";
+
+        if (!panda::os::file::File::IsRegularFile(resolved_path + import_extension)) {
+            import_extension = ".ts";
+
+            if (!panda::os::file::File::IsRegularFile(resolved_path + import_extension)) {
+                ThrowSyntaxError("Incorrect path: " + resolved_path);
+            }
+        }
+        return {path + import_extension, true};
+    }
+    return {path, false};
+}
+
 std::tuple<std::vector<std::string>, bool> ETSParser::CollectUserSources(const std::string &path)
 {
     std::vector<std::string> user_paths;
 
     const std::string resolved_path = ResolveImportPath(path);
+    resolved_parsed_sources_.emplace(path, resolved_path);
     const auto data = GetImportData(resolved_path);
 
     if (!data.has_decl) {
@@ -407,23 +454,11 @@ std::tuple<std::vector<std::string>, bool> ETSParser::CollectUserSources(const s
     }
 
     if (!panda::os::file::File::IsDirectory(resolved_path)) {
-        if (!panda::os::file::File::IsRegularFile(resolved_path)) {
-            std::string import_extension = ".ets";
-
-            if (!panda::os::file::File::IsRegularFile(resolved_path + import_extension)) {
-                import_extension = ".ts";
-
-                if (!panda::os::file::File::IsRegularFile(resolved_path + import_extension)) {
-                    ThrowSyntaxError("Incorrect path: " + resolved_path);
-                }
-            }
-
-            user_paths.emplace_back(path + import_extension);
-            return {user_paths, true};
-        }
-
-        user_paths.emplace_back(path);
-        return {user_paths, false};
+        std::string regular_path;
+        bool is_module = false;
+        std::tie(regular_path, is_module) = GetSourceRegularPath(path, resolved_path);
+        user_paths.emplace_back(regular_path);
+        return {user_paths, is_module};
     }
 
 #ifdef USE_UNIX_SYSCALL
@@ -479,6 +514,8 @@ void ETSParser::ParseSources(const std::vector<std::string> &paths, bool is_exte
     const std::size_t path_count = paths.size();
     for (std::size_t idx = 0; idx < path_count; idx++) {
         std::string resolved_path = ResolveImportPath(paths[idx]);
+        resolved_parsed_sources_.emplace(paths[idx], resolved_path);
+
         const auto data = GetImportData(resolved_path);
 
         if (!data.has_decl) {
@@ -2168,13 +2205,15 @@ void ETSParser::CreateClassFunctionDeclaration(ir::MethodDefinition *method)
     method->Function()->AddFlag(ir::ScriptFunctionFlags::OVERLOAD);
 }
 
-bool ETSParser::HasDefaultParam(const ir::ScriptFunction *const function)
+std::pair<bool, std::size_t> ETSParser::CheckDefaultParameters(const ir::ScriptFunction *const function) const
 {
     bool has_default_parameter = false;
     bool has_rest_parameter = false;
+    std::size_t required_parameters_number = 0U;
 
     for (auto *const it : function->Params()) {
         auto const *const param = it->AsETSParameterExpression();
+
         if (param->IsRestParameter()) {
             has_rest_parameter = true;
             continue;
@@ -2192,23 +2231,58 @@ bool ETSParser::HasDefaultParam(const ir::ScriptFunction *const function)
         if (has_default_parameter) {
             ThrowSyntaxError("Required parameter follows default parameter(s).", param->Start());
         }
-    }
 
-    if (!has_default_parameter) {
-        return false;
+        ++required_parameters_number;
     }
 
-    if (has_rest_parameter) {
+    if (has_default_parameter && has_rest_parameter) {
         ThrowSyntaxError("Both optional and rest parameters are not allowed in function's parameter list.",
                          function->Start());
     }
 
-    return true;
+    return std::make_pair(has_default_parameter, required_parameters_number);
+}
+
+ir::MethodDefinition *ETSParser::CreateProxyConstructorDefinition(ir::MethodDefinition const *const method)
+{
+    ASSERT(method->IsConstructor());
+
+    const auto *const function = method->Function();
+    std::string proxy_method = function->Id()->Name().Mutf8() + '(';
+
+    for (const auto *const it : function->Params()) {
+        auto const *const param = it->AsETSParameterExpression();
+        proxy_method += param->Ident()->Name().Mutf8() + ": " + GetNameForTypeNode(param->TypeAnnotation()) + ", ";
+    }
+
+    proxy_method += ir::PROXY_PARAMETER_NAME;
+    proxy_method += ": int) { this(";
+
+    auto const parameters_number = function->Params().size();
+    for (size_t i = 0U; i < parameters_number; ++i) {
+        if (auto const *const param = function->Params()[i]->AsETSParameterExpression(); param->IsDefault()) {
+            std::string proxy_if = "(((" + std::string {ir::PROXY_PARAMETER_NAME} + " >> " + std::to_string(i) +
+                                   ") & 0x1) == 0) ? " + param->Ident()->Name().Mutf8() + " : (" +
+                                   param->LexerSaved().Mutf8() + "), ";
+            proxy_method += proxy_if;
+        } else {
+            proxy_method += function->Params()[i]->AsETSParameterExpression()->Ident()->Name().Mutf8() + ", ";
+        }
+    }
+
+    proxy_method.pop_back();  // Note: at least one parameter always should present!
+    proxy_method.pop_back();
+    proxy_method += ") }";
+
+    return CreateConstructorDefinition(method->Modifiers(), proxy_method, DEFAULT_PROXY_FILE);
 }
 
-std::string ETSParser::CreateProxyMethodName(const ir::ScriptFunction *const function, ir::MethodDefinition *method,
-                                             ir::Identifier *ident_node, varbinder::ClassScope *const cls_scope)
+ir::MethodDefinition *ETSParser::CreateProxyMethodDefinition(ir::MethodDefinition const *const method,
+                                                             ir::Identifier const *const ident_node)
 {
+    ASSERT(!method->IsConstructor());
+
+    const auto *const function = method->Function();
     std::string proxy_method = function->Id()->Name().Mutf8() + "_proxy(";
 
     for (const auto *const it : function->Params()) {
@@ -2216,32 +2290,42 @@ std::string ETSParser::CreateProxyMethodName(const ir::ScriptFunction *const fun
         proxy_method += param->Ident()->Name().Mutf8() + ": " + GetNameForTypeNode(param->TypeAnnotation()) + ", ";
     }
 
-    const bool has_function_return_type = method->Function()->ReturnTypeAnnotation() != nullptr;
+    const bool has_function_return_type = function->ReturnTypeAnnotation() != nullptr;
     const std::string return_type =
-        has_function_return_type ? GetNameForTypeNode(method->Function()->ReturnTypeAnnotation()) : "";
+        has_function_return_type ? GetNameForTypeNode(function->ReturnTypeAnnotation()) : "";
 
-    proxy_method += has_function_return_type ? "proxy_int:int):" + return_type + "{" : "proxy_int:int) {";
+    proxy_method += ir::PROXY_PARAMETER_NAME;
+    proxy_method += ": int)";
+    if (has_function_return_type) {
+        proxy_method += ": " + return_type;
+    }
+    proxy_method += " { ";
 
     auto const parameters_number = function->Params().size();
-    for (size_t i = 0U; i < parameters_number; i++) {
+    for (size_t i = 0U; i < parameters_number; ++i) {
         if (auto const *const param = function->Params()[i]->AsETSParameterExpression(); param->IsDefault()) {
-            std::string proxy_if = "if (((proxy_int >> " + std::to_string(i) + ") & 0x1) == 1) { " +
-                                   param->Ident()->Name().Mutf8() + " = " + param->LexerSaved().Mutf8() + " }";
+            std::string proxy_if = "if (((" + std::string {ir::PROXY_PARAMETER_NAME} + " >> " + std::to_string(i) +
+                                   ") & 0x1) == 1) { " + param->Ident()->Name().Mutf8() + " = " +
+                                   param->LexerSaved().Mutf8() + " } ";
             proxy_method += proxy_if;
         }
     }
 
+    proxy_method += ' ';
     if (return_type != "void") {
-        if (cls_scope->Parent()->IsGlobalScope()) {
+        if (auto *const cls_scope = VarBinder()->GetScope()->AsClassScope(); cls_scope->Parent()->IsGlobalScope()) {
             proxy_method += "return ";
         } else if (method->IsStatic()) {
+            ASSERT(ident_node != nullptr);
             proxy_method += "return " + ident_node->Name().Mutf8() + ".";
         } else {
             proxy_method += "return this.";
         }
     }
 
-    proxy_method += function->Id()->Name().Mutf8() + "(";
+    proxy_method += function->Id()->Name().Mutf8();
+    proxy_method += '(';
+
     for (const auto *const it : function->Params()) {
         proxy_method += it->AsETSParameterExpression()->Ident()->Name().Mutf8() + ", ";
     }
@@ -2249,39 +2333,34 @@ std::string ETSParser::CreateProxyMethodName(const ir::ScriptFunction *const fun
     proxy_method.pop_back();
     proxy_method += ") }";
 
-    return proxy_method;
+    return CreateMethodDefinition(method->Modifiers(), proxy_method, DEFAULT_PROXY_FILE);
 }
 
 void ETSParser::AddProxyOverloadToMethodWithDefaultParams(ir::MethodDefinition *method, ir::Identifier *ident_node)
 {
-    if (method->IsConstructor()) {
-        return;  // NOTE(szd): Fix constructors not working with default params
-    }
+    if (auto const [has_default_parameters, required_parameters] = CheckDefaultParameters(method->Function());
+        has_default_parameters) {
+        if (ir::MethodDefinition *proxy_method_def = !method->IsConstructor()
+                                                         ? CreateProxyMethodDefinition(method, ident_node)
+                                                         : CreateProxyConstructorDefinition(method);
+            proxy_method_def != nullptr) {
+            auto *const proxy_param = proxy_method_def->Function()->Params().back()->AsETSParameterExpression();
+            proxy_param->SetRequiredParams(required_parameters);
 
-    const auto *const function = method->Function();
-
-    if (!HasDefaultParam(function)) {
-        return;
-    }
-
-    auto *const cls_scope = VarBinder()->GetScope()->AsClassScope();
-    varbinder::LocalScope *target_scope =
-        method->IsStatic() ? cls_scope->StaticMethodScope() : cls_scope->InstanceMethodScope();
-    auto *const found = target_scope->FindLocal(method->Id()->Name(), varbinder::ResolveBindingOptions::BINDINGS);
+            proxy_method_def->Function()->SetDefaultParamProxy();
+            proxy_method_def->Function()->AddFlag(ir::ScriptFunctionFlags::OVERLOAD);
 
-    std::string proxy_method = CreateProxyMethodName(function, method, ident_node, cls_scope);
+            auto *const var = method->Id()->Variable();
+            auto *const current_node = var->Declaration()->Node();
 
-    auto class_ctx =
-        varbinder::LexicalScope<varbinder::ClassScope>::Enter(VarBinder(), GetProgram()->GlobalClassScope());
-
-    auto *const proxy_method_def = CreateMethodDefinition(method->Modifiers(), proxy_method, "<default_methods>.ets");
-    proxy_method_def->Function()->SetDefaultParamProxy();
+            proxy_method_def->Id()->SetVariable(var);
+            proxy_method_def->SetParent(current_node);
 
-    auto *const current_node = found->Declaration()->Node();
-    current_node->AsMethodDefinition()->AddOverload(proxy_method_def);
-    proxy_method_def->Id()->SetVariable(found);
-    proxy_method_def->SetParent(current_node);
-    proxy_method_def->Function()->AddFlag(ir::ScriptFunctionFlags::OVERLOAD);
+            if (!method->IsConstructor()) {
+                current_node->AsMethodDefinition()->AddOverload(proxy_method_def);
+            }
+        }
+    }
 }
 
 std::string ETSParser::PrimitiveTypeToName(ir::PrimitiveType type)
@@ -2310,7 +2389,7 @@ std::string ETSParser::PrimitiveTypeToName(ir::PrimitiveType type)
     }
 }
 
-std::string ETSParser::GetNameForTypeNode(const ir::TypeNode *type_annotation)
+std::string ETSParser::GetNameForTypeNode(const ir::TypeNode *type_annotation) const
 {
     if ((type_annotation->IsNullAssignable() || type_annotation->IsUndefinedAssignable()) &&
         type_annotation->IsETSUnionType()) {
@@ -2862,6 +2941,7 @@ std::tuple<ir::ImportSource *, std::vector<std::string>> ETSParser::ParseFromCla
     bool is_module = false;
     auto import_path = Lexer()->GetToken().Ident();
     auto resolved_import_path = ResolveImportPath(import_path.Mutf8());
+    resolved_parsed_sources_.emplace(import_path.Mutf8(), resolved_import_path);
 
     ir::StringLiteral *resolved_source;
     if (*import_path.Bytes() == '/') {
@@ -4727,6 +4807,39 @@ ir::MethodDefinition *ETSParser::CreateMethodDefinition(ir::ModifierFlags modifi
     return method_definition;
 }
 
+ir::MethodDefinition *ETSParser::CreateConstructorDefinition(ir::ModifierFlags modifiers,
+                                                             std::string_view const source_code,
+                                                             std::string_view const file_name)
+{
+    util::UString source {source_code, Allocator()};
+    auto const isp = InnerSourceParser(this);
+    auto const lexer = InitLexer({file_name, source.View().Utf8()});
+
+    auto const start_loc = Lexer()->GetToken().Start();
+    Lexer()->NextToken();
+
+    if (IsClassMethodModifier(Lexer()->GetToken().Type())) {
+        modifiers |= ParseClassMethodModifiers(false);
+    }
+
+    if (Lexer()->GetToken().Type() != lexer::TokenType::KEYW_CONSTRUCTOR) {
+        ThrowSyntaxError({"Unexpected token. 'Constructor' keyword is expected."});
+    }
+
+    if ((modifiers & ir::ModifierFlags::ASYNC) != 0) {
+        ThrowSyntaxError({"Constructor should not be async."});
+    }
+
+    auto *member_name = AllocNode<ir::Identifier>(Lexer()->GetToken().Ident(), Allocator());
+    modifiers |= ir::ModifierFlags::CONSTRUCTOR;
+    Lexer()->NextToken();
+
+    auto *const method_definition = ParseClassMethodDefinition(member_name, modifiers);
+    method_definition->SetStart(start_loc);
+
+    return method_definition;
+}
+
 ir::Expression *ETSParser::CreateExpression(std::string_view const source_code, ExpressionParseFlags const flags,
                                             std::string_view const file_name)
 {
diff --git a/ets2panda/parser/ETSparser.h b/ets2panda/parser/ETSparser.h
index d1eb419aa82dbb2f77527a06167cf6a8af77ef07..a2716bef27d38c1b83dc2f5c688365bb8e56550c 100644
--- a/ets2panda/parser/ETSparser.h
+++ b/ets2panda/parser/ETSparser.h
@@ -41,7 +41,10 @@ inline constexpr char const DEFAULT_SOURCE_FILE[] = "<auxiliary_tmp>.ets";
 class ETSParser final : public TypedParser {
 public:
     ETSParser(Program *program, const CompilerOptions &options, ParserStatus status = ParserStatus::NO_OPTS)
-        : TypedParser(program, options, status), global_program_(GetProgram()), parsed_sources_({})
+        : TypedParser(program, options, status),
+          global_program_(GetProgram()),
+          parsed_sources_({}),
+          resolved_parsed_sources_({})
     {
     }
 
@@ -109,8 +112,10 @@ private:
     void ParseTopLevelDeclaration(ArenaVector<ir::Statement *> &statements);
     void CollectDefaultSources();
     std::string ResolveImportPath(const std::string &path);
+    std::string ResolveFullPathFromRelative(const std::string &path);
     ImportData GetImportData(const std::string &path);
     std::tuple<std::vector<std::string>, bool> CollectUserSources(const std::string &path);
+    std::tuple<std::string, bool> GetSourceRegularPath(const std::string &path, const std::string &resolved_path);
     void ParseSources(const std::vector<std::string> &paths, bool is_external = true);
     std::tuple<ir::ImportSource *, std::vector<std::string>> ParseFromClause(bool require_from);
     void ParseNamedImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
@@ -165,12 +170,13 @@ private:
     ir::TypeNode *ParseWildcardType(TypeAnnotationParsingOptions *options);
     ir::TypeNode *ParseFunctionType();
     void CreateClassFunctionDeclaration(ir::MethodDefinition *method);
-    bool HasDefaultParam(const ir::ScriptFunction *function);
-    std::string CreateProxyMethodName(const ir::ScriptFunction *function, ir::MethodDefinition *method,
-                                      ir::Identifier *ident_node, varbinder::ClassScope *cls_scope);
+    std::pair<bool, std::size_t> CheckDefaultParameters(const ir::ScriptFunction *function) const;
+    ir::MethodDefinition *CreateProxyMethodDefinition(ir::MethodDefinition const *method,
+                                                      ir::Identifier const *ident_node);
+    ir::MethodDefinition *CreateProxyConstructorDefinition(ir::MethodDefinition const *method);
     void AddProxyOverloadToMethodWithDefaultParams(ir::MethodDefinition *method, ir::Identifier *ident_node = nullptr);
     static std::string PrimitiveTypeToName(ir::PrimitiveType type);
-    std::string GetNameForTypeNode(const ir::TypeNode *type_annotation);
+    std::string GetNameForTypeNode(const ir::TypeNode *type_annotation) const;
     ir::TSInterfaceDeclaration *ParseInterfaceBody(ir::Identifier *name, bool is_static);
     bool IsArrowFunctionExpressionStart();
     ir::ArrowFunctionExpression *ParseArrowFunctionExpression();
@@ -302,10 +308,14 @@ private:
 
     void CheckDeclare();
 
-    //  Methods to create AST node(s) from the specified string (part of valid ETS-code!)
-    //  NOTE: the correct initial scope should be entered BEFORE calling any of these methods,
-    //  and correct parent and, probably, variable set to the node(s) after obtaining
-
+    // Methods to create AST node(s) from the specified string (part of valid ETS-code!)
+    // NOTE: the correct initial scope should be entered BEFORE calling any of these methods,
+    // and correct parent and, probably, variable set to the node(s) after obtaining
+    // NOLINTBEGIN(modernize-avoid-c-arrays)
+    inline static constexpr char const DEFAULT_SOURCE_FILE[] = "<auxiliary_tmp>.ets";
+    inline static constexpr char const DEFAULT_PROXY_FILE[] = "<default_method>.ets";
+    // NOLINTEND(modernize-avoid-c-arrays)
+    // NOLINTBEGIN(google-default-arguments)
     ir::Statement *CreateStatement(std::string_view source_code, std::string_view file_name = DEFAULT_SOURCE_FILE);
     ir::Statement *CreateFormattedStatement(std::string_view source_code, std::vector<ir::AstNode *> &inserting_nodes,
                                             std::string_view file_name = DEFAULT_SOURCE_FILE);
@@ -321,17 +331,25 @@ private:
 
     ir::MethodDefinition *CreateMethodDefinition(ir::ModifierFlags modifiers, std::string_view source_code,
                                                  std::string_view file_name = DEFAULT_SOURCE_FILE);
-
+    ir::MethodDefinition *CreateConstructorDefinition(ir::ModifierFlags modifiers, std::string_view source_code,
+                                                      std::string_view file_name = DEFAULT_SOURCE_FILE);
     ir::TypeNode *CreateTypeAnnotation(TypeAnnotationParsingOptions *options, std::string_view source_code,
                                        std::string_view file_name = DEFAULT_SOURCE_FILE);
 
     friend class ExternalSourceParser;
     friend class InnerSourceParser;
 
+public:
+    const std::unordered_map<std::string, std::string> &ResolvedParsedSourcesMap() const
+    {
+        return resolved_parsed_sources_;
+    }
+
 private:
     parser::Program *global_program_;
     std::vector<std::string> parsed_sources_;
     std::vector<ir::AstNode *> inserting_nodes_ {};
+    std::unordered_map<std::string, std::string> resolved_parsed_sources_;
 };
 
 class ExternalSourceParser {
diff --git a/ets2panda/scripts/es2panda_coverage.sh b/ets2panda/scripts/es2panda_coverage.sh
index 9af403a22b0ae730a15b89be8ff1a68916fcccb6..a299f1c515c1eb1cf3d7fd836cb52714f029d4bd 100644
--- a/ets2panda/scripts/es2panda_coverage.sh
+++ b/ets2panda/scripts/es2panda_coverage.sh
@@ -26,16 +26,16 @@ case "$ARGUMENT" in
 esac
 done
 
-python $PANDA_ROOT/plugins/ecmascript/es2panda/scripts/test_runner.py \
+python $PANDA_ROOT/tools/es2panda/scripts/test_runner.py \
     --builddir $PANDA_BINARY_ROOT --arkdir $PANDA_ROOT --all
 
-gcov $PANDA_BINARY_ROOT/plugins/ecmascript/es2panda/CMakeFiles/es2panda-lib.dir/*/*
+gcov $PANDA_BINARY_ROOT/tools/es2panda/CMakeFiles/es2panda-lib.dir/*/*
 
 if [ -x "$(command -v gcovr)" ]; then
     echo "gcovr found"
     gcovr --version
-    gcovr -v -r $PANDA_ROOT/plugins/ecmascript/es2panda \
-        -e $PANDA_ROOT/plugins/ecmascript/es2panda/test \
+    gcovr -v -r $PANDA_ROOT/tools/es2panda/ \
+        -e $PANDA_ROOT/tools/es2panda/test \
         --object-directory=$PANDA_BINARY_ROOT --html-details --html -o report.html
 
 else
diff --git a/ets2panda/test/compiler/ets/extended_conditional_expression_not-expected.txt b/ets2panda/test/compiler/ets/extended_conditional_expression_not-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..60a0330b805d2c13451cd7090c33072d4984b1f5
--- /dev/null
+++ b/ets2panda/test/compiler/ets/extended_conditional_expression_not-expected.txt
@@ -0,0 +1,444 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "f",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 10
+                },
+                "end": {
+                  "line": 16,
+                  "column": 11
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "f",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 11
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "n",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "number",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 16,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 16,
+                                "column": 21
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 22
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 22
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 22
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 27
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "IfStatement",
+                      "test": {
+                        "type": "UnaryExpression",
+                        "operator": "!",
+                        "prefix": true,
+                        "argument": {
+                          "type": "Identifier",
+                          "name": "n",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 17,
+                              "column": 10
+                            },
+                            "end": {
+                              "line": 17,
+                              "column": 11
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 9
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 11
+                          }
+                        }
+                      },
+                      "consequent": {
+                        "type": "BlockStatement",
+                        "statements": [
+                          {
+                            "type": "ReturnStatement",
+                            "argument": {
+                              "type": "NumberLiteral",
+                              "value": 0,
+                              "loc": {
+                                "start": {
+                                  "line": 18,
+                                  "column": 16
+                                },
+                                "end": {
+                                  "line": 18,
+                                  "column": 17
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 18,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 18,
+                                "column": 18
+                              }
+                            }
+                          }
+                        ],
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 13
+                          },
+                          "end": {
+                            "line": 19,
+                            "column": 6
+                          }
+                        }
+                      },
+                      "alternate": null,
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 19,
+                          "column": 6
+                        }
+                      }
+                    },
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 20,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 20,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 20,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 20,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 11
+                },
+                "end": {
+                  "line": 21,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 1
+              },
+              "end": {
+                "line": 21,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 22,
+      "column": 1
+    }
+  }
+}
diff --git a/ets2panda/test/compiler/ets/extended_conditional_expression_not.ets b/ets2panda/test/compiler/ets/extended_conditional_expression_not.ets
new file mode 100644
index 0000000000000000000000000000000000000000..a012fda36c85d881ae7b426a4f8b4911515bcc87
--- /dev/null
+++ b/ets2panda/test/compiler/ets/extended_conditional_expression_not.ets
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+function f(n: number): int {
+    if (!n) {
+        return 0;
+    }
+    return 1;
+}
diff --git a/ets2panda/test/compiler/ets/extended_conditional_expression_not_return_type-expected.txt b/ets2panda/test/compiler/ets/extended_conditional_expression_not_return_type-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..80a89ecb8f07b6a5a888052b2eb833e17e1edcc3
--- /dev/null
+++ b/ets2panda/test/compiler/ets/extended_conditional_expression_not_return_type-expected.txt
@@ -0,0 +1,374 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "f",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 10
+                },
+                "end": {
+                  "line": 16,
+                  "column": 11
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "f",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 11
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "n",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "string",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 16,
+                                "column": 15
+                              },
+                              "end": {
+                                "line": 16,
+                                "column": 21
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 15
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 22
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 15
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 22
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 22
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 24
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 31
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "UnaryExpression",
+                        "operator": "!",
+                        "prefix": true,
+                        "argument": {
+                          "type": "Identifier",
+                          "name": "n",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 17,
+                              "column": 13
+                            },
+                            "end": {
+                              "line": 17,
+                              "column": 14
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 14
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 15
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 32
+                    },
+                    "end": {
+                      "line": 18,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 11
+                  },
+                  "end": {
+                    "line": 18,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 11
+                },
+                "end": {
+                  "line": 18,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 1
+              },
+              "end": {
+                "line": 18,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 18,
+      "column": 2
+    }
+  }
+}
diff --git a/ets2panda/test/compiler/ets/extended_conditional_expression_not_return_type.ets b/ets2panda/test/compiler/ets/extended_conditional_expression_not_return_type.ets
new file mode 100644
index 0000000000000000000000000000000000000000..1462fb5522085e9cb34fd2819dad2f339b6a8c23
--- /dev/null
+++ b/ets2panda/test/compiler/ets/extended_conditional_expression_not_return_type.ets
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+function f(n: string): boolean {
+    return !n;
+}
\ No newline at end of file
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_1-expected.txt b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f30d48b4dac54ccd8fac1cdbe1b0b408f4a07e5b
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_1-expected.txt
@@ -0,0 +1,2409 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 13
+          },
+          "end": {
+            "line": 16,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "I",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 11
+          },
+          "end": {
+            "line": 16,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 13
+          },
+          "end": {
+            "line": 17,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "J",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 11
+          },
+          "end": {
+            "line": 17,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 13
+          },
+          "end": {
+            "line": 18,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "K",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 11
+          },
+          "end": {
+            "line": 18,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "A",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 7
+            },
+            "end": {
+              "line": 19,
+              "column": 8
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "J",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 20
+                },
+                "end": {
+                  "line": 19,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 20
+              },
+              "end": {
+                "line": 19,
+                "column": 23
+              }
+            }
+          }
+        ],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 24
+              },
+              "end": {
+                "line": 19,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 22
+          },
+          "end": {
+            "line": 19,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "B",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 7
+            },
+            "end": {
+              "line": 20,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "A",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 17
+                },
+                "end": {
+                  "line": 20,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 17
+              },
+              "end": {
+                "line": 20,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 17
+            },
+            "end": {
+              "line": 20,
+              "column": 20
+            }
+          }
+        },
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 21
+              },
+              "end": {
+                "line": 20,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 19
+          },
+          "end": {
+            "line": 20,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 7
+            },
+            "end": {
+              "line": 21,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 17
+                },
+                "end": {
+                  "line": 21,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 17
+              },
+              "end": {
+                "line": 21,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 17
+            },
+            "end": {
+              "line": 21,
+              "column": 29
+            }
+          }
+        },
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "I",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 33
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 30
+                },
+                "end": {
+                  "line": 21,
+                  "column": 33
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 30
+              },
+              "end": {
+                "line": 21,
+                "column": 33
+              }
+            }
+          }
+        ],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 34
+              },
+              "end": {
+                "line": 21,
+                "column": 34
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 32
+          },
+          "end": {
+            "line": 21,
+            "column": 34
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 34
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "D",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 7
+            },
+            "end": {
+              "line": 22,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 17
+                },
+                "end": {
+                  "line": 22,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 17
+              },
+              "end": {
+                "line": 22,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 17
+            },
+            "end": {
+              "line": 22,
+              "column": 20
+            }
+          }
+        },
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 21
+              },
+              "end": {
+                "line": 22,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 19
+          },
+          "end": {
+            "line": 22,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 10
+                },
+                "end": {
+                  "line": 24,
+                  "column": 13
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 13
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "x",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "I",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 24,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 24,
+                                "column": 18
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 24,
+                              "column": 17
+                            },
+                            "end": {
+                              "line": 24,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 24,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 24,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 19
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSTypeReference",
+                  "part": {
+                    "type": "ETSTypeReferencePart",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "string",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 29
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "StringLiteral",
+                        "value": "I",
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 25,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 25,
+                          "column": 16
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 13
+                },
+                "end": {
+                  "line": 26,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "J",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 27,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 27,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 27,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 27,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 27,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 27,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "string",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 27,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 27,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "J",
+                            "loc": {
+                              "start": {
+                                "line": 28,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 28,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 28,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 28,
+                              "column": 16
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 27,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 2
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "D",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 30,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 30,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 30,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 30,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 30,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 30,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 30,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 30,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 30,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 30,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "string",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 30,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 30,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 30,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 30,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "D",
+                            "loc": {
+                              "start": {
+                                "line": 31,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 31,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 31,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 31,
+                              "column": 16
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 2
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 1
+              },
+              "end": {
+                "line": 26,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "main",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 10
+                },
+                "end": {
+                  "line": 34,
+                  "column": 14
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "main",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 14
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 21
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "a",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "string",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 35,
+                                      "column": 13
+                                    },
+                                    "end": {
+                                      "line": 35,
+                                      "column": 19
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 35,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 35,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 35,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 35,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 35,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 35,
+                                "column": 10
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 35,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 35,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "A",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 35,
+                                          "column": 30
+                                        },
+                                        "end": {
+                                          "line": 35,
+                                          "column": 31
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 35,
+                                        "column": 30
+                                      },
+                                      "end": {
+                                        "line": 35,
+                                        "column": 32
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 35,
+                                      "column": 30
+                                    },
+                                    "end": {
+                                      "line": 35,
+                                      "column": 32
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 35,
+                                    "column": 26
+                                  },
+                                  "end": {
+                                    "line": 35,
+                                    "column": 34
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 35,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 35,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 35,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 35,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "b",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "string",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 36,
+                                      "column": 13
+                                    },
+                                    "end": {
+                                      "line": 36,
+                                      "column": 19
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 36,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 36,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 36,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 36,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 36,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 36,
+                                "column": 10
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 36,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 36,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "B",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 36,
+                                          "column": 30
+                                        },
+                                        "end": {
+                                          "line": 36,
+                                          "column": 31
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 36,
+                                        "column": 30
+                                      },
+                                      "end": {
+                                        "line": 36,
+                                        "column": 32
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 36,
+                                      "column": 30
+                                    },
+                                    "end": {
+                                      "line": 36,
+                                      "column": 32
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 36,
+                                    "column": 26
+                                  },
+                                  "end": {
+                                    "line": 36,
+                                    "column": 34
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 36,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 36,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 36,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 36,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "c",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "string",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 37,
+                                      "column": 13
+                                    },
+                                    "end": {
+                                      "line": 37,
+                                      "column": 19
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 37,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 37,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 37,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 37,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 37,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 37,
+                                "column": 10
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 37,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 37,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "C",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 37,
+                                          "column": 30
+                                        },
+                                        "end": {
+                                          "line": 37,
+                                          "column": 31
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 37,
+                                        "column": 30
+                                      },
+                                      "end": {
+                                        "line": 37,
+                                        "column": 32
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 37,
+                                      "column": 30
+                                    },
+                                    "end": {
+                                      "line": 37,
+                                      "column": 32
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 37,
+                                    "column": 26
+                                  },
+                                  "end": {
+                                    "line": 37,
+                                    "column": 34
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 37,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 37,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 37,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 37,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 37,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 37,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 0,
+                        "loc": {
+                          "start": {
+                            "line": 38,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 38,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 38,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 38,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 39,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 14
+                },
+                "end": {
+                  "line": 39,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 1
+              },
+              "end": {
+                "line": 39,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 41,
+      "column": 1
+    }
+  }
+}
+TypeError: Call to `foo` is ambiguous as `2` versions of `foo` are available: `foo(x: I): String` and `foo(x: J): String` [method-resolution-class-and-interface-in-signatures_1.ets:37:22]
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_1.ets b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_1.ets
new file mode 100644
index 0000000000000000000000000000000000000000..2cf7a458b711d4b28164da551d23a6c60655df72
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_1.ets
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+interface I {}
+interface J {}
+interface K {}
+class A implements J {}
+class B extends A {}
+class C extends B implements I {}
+class D extends C {}
+
+function foo(x: I): string {
+    return "I";
+}
+function foo(x: J): string {
+    return "J";
+}
+function foo(x: D): string {
+    return "D";
+}
+
+function main(): int {
+    let a : string = foo(new A());
+    let b : string = foo(new B());
+    let c : string = foo(new C());
+    return 0;
+}
+
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_2-expected.txt b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..095914af28b1db87b1529eddcd30bb278a0ad027
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_2-expected.txt
@@ -0,0 +1,2409 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 13
+          },
+          "end": {
+            "line": 16,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "I",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 11
+          },
+          "end": {
+            "line": 16,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 13
+          },
+          "end": {
+            "line": 17,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "J",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 11
+          },
+          "end": {
+            "line": 17,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 13
+          },
+          "end": {
+            "line": 18,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "K",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 11
+          },
+          "end": {
+            "line": 18,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "A",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 7
+            },
+            "end": {
+              "line": 19,
+              "column": 8
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "J",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 20
+                },
+                "end": {
+                  "line": 19,
+                  "column": 23
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 20
+              },
+              "end": {
+                "line": 19,
+                "column": 23
+              }
+            }
+          }
+        ],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 24
+              },
+              "end": {
+                "line": 19,
+                "column": 24
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 22
+          },
+          "end": {
+            "line": 19,
+            "column": 24
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 24
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "B",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 7
+            },
+            "end": {
+              "line": 20,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "A",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 17
+                },
+                "end": {
+                  "line": 20,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 17
+              },
+              "end": {
+                "line": 20,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 17
+            },
+            "end": {
+              "line": 20,
+              "column": 20
+            }
+          }
+        },
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 21
+              },
+              "end": {
+                "line": 20,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 19
+          },
+          "end": {
+            "line": 20,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 7
+            },
+            "end": {
+              "line": 21,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 17
+                },
+                "end": {
+                  "line": 21,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 17
+              },
+              "end": {
+                "line": 21,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 17
+            },
+            "end": {
+              "line": 21,
+              "column": 29
+            }
+          }
+        },
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "I",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 33
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 30
+                },
+                "end": {
+                  "line": 21,
+                  "column": 33
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 30
+              },
+              "end": {
+                "line": 21,
+                "column": 33
+              }
+            }
+          }
+        ],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 34
+              },
+              "end": {
+                "line": 21,
+                "column": 34
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 32
+          },
+          "end": {
+            "line": 21,
+            "column": 34
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 34
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "D",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 7
+            },
+            "end": {
+              "line": 22,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 17
+                },
+                "end": {
+                  "line": 22,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 17
+              },
+              "end": {
+                "line": 22,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 17
+            },
+            "end": {
+              "line": 22,
+              "column": 20
+            }
+          }
+        },
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 21
+              },
+              "end": {
+                "line": 22,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 19
+          },
+          "end": {
+            "line": 22,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 10
+                },
+                "end": {
+                  "line": 24,
+                  "column": 13
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 13
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "x",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "I",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 24,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 24,
+                                "column": 18
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 24,
+                              "column": 17
+                            },
+                            "end": {
+                              "line": 24,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 24,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 24,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 19
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSTypeReference",
+                  "part": {
+                    "type": "ETSTypeReferencePart",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "string",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 29
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "StringLiteral",
+                        "value": "I",
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 25,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 25,
+                          "column": 16
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 13
+                },
+                "end": {
+                  "line": 26,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "J",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 27,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 27,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 27,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 27,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 27,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 27,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "string",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 27,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 27,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "J",
+                            "loc": {
+                              "start": {
+                                "line": 28,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 28,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 28,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 28,
+                              "column": 16
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 27,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 2
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "B",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 30,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 30,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 30,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 30,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 30,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 30,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 30,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 30,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 30,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 30,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "string",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 30,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 30,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 30,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 30,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "B",
+                            "loc": {
+                              "start": {
+                                "line": 31,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 31,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 31,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 31,
+                              "column": 16
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 2
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 1
+              },
+              "end": {
+                "line": 26,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "main",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 10
+                },
+                "end": {
+                  "line": 34,
+                  "column": 14
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "main",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 14
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 21
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "a",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "string",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 35,
+                                      "column": 13
+                                    },
+                                    "end": {
+                                      "line": 35,
+                                      "column": 19
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 35,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 35,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 35,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 35,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 35,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 35,
+                                "column": 10
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 35,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 35,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "A",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 35,
+                                          "column": 30
+                                        },
+                                        "end": {
+                                          "line": 35,
+                                          "column": 31
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 35,
+                                        "column": 30
+                                      },
+                                      "end": {
+                                        "line": 35,
+                                        "column": 32
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 35,
+                                      "column": 30
+                                    },
+                                    "end": {
+                                      "line": 35,
+                                      "column": 32
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 35,
+                                    "column": 26
+                                  },
+                                  "end": {
+                                    "line": 35,
+                                    "column": 34
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 35,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 35,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 35,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 35,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "b",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "string",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 36,
+                                      "column": 13
+                                    },
+                                    "end": {
+                                      "line": 36,
+                                      "column": 19
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 36,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 36,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 36,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 36,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 36,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 36,
+                                "column": 10
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 36,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 36,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "B",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 36,
+                                          "column": 30
+                                        },
+                                        "end": {
+                                          "line": 36,
+                                          "column": 31
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 36,
+                                        "column": 30
+                                      },
+                                      "end": {
+                                        "line": 36,
+                                        "column": 32
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 36,
+                                      "column": 30
+                                    },
+                                    "end": {
+                                      "line": 36,
+                                      "column": 32
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 36,
+                                    "column": 26
+                                  },
+                                  "end": {
+                                    "line": 36,
+                                    "column": 34
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 36,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 36,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 36,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 36,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "d",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "string",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 37,
+                                      "column": 13
+                                    },
+                                    "end": {
+                                      "line": 37,
+                                      "column": 19
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 37,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 37,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 37,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 37,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 37,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 37,
+                                "column": 10
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 37,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 37,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "D",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 37,
+                                          "column": 30
+                                        },
+                                        "end": {
+                                          "line": 37,
+                                          "column": 31
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 37,
+                                        "column": 30
+                                      },
+                                      "end": {
+                                        "line": 37,
+                                        "column": 32
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 37,
+                                      "column": 30
+                                    },
+                                    "end": {
+                                      "line": 37,
+                                      "column": 32
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 37,
+                                    "column": 26
+                                  },
+                                  "end": {
+                                    "line": 37,
+                                    "column": 34
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 37,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 37,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 37,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 37,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 37,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 37,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 0,
+                        "loc": {
+                          "start": {
+                            "line": 38,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 38,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 38,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 38,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 39,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 14
+                },
+                "end": {
+                  "line": 39,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 1
+              },
+              "end": {
+                "line": 39,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 41,
+      "column": 1
+    }
+  }
+}
+TypeError: Call to `foo` is ambiguous as `2` versions of `foo` are available: `foo(x: B): String` and `foo(x: I): String` [method-resolution-class-and-interface-in-signatures_2.ets:37:22]
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_2.ets b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_2.ets
new file mode 100644
index 0000000000000000000000000000000000000000..c0928f87166814c5482d9831675fbafb4d591548
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_2.ets
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+interface I {}
+interface J {}
+interface K {}
+class A implements J {}
+class B extends A {}
+class C extends B implements I {}
+class D extends C {}
+
+function foo(x: I): string {
+    return "I";
+}
+function foo(x: J): string {
+    return "J";
+}
+function foo(x: B): string {
+    return "B";
+}
+
+function main(): int {
+    let a : string = foo(new A());
+    let b : string = foo(new B());
+    let d : string = foo(new D());
+    return 0;
+}
+
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_3-expected.txt b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8e8b4891d9c68b1b7cca4bf7ad665092ac3f3d6b
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_3-expected.txt
@@ -0,0 +1,1833 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 13
+          },
+          "end": {
+            "line": 16,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "I",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 11
+          },
+          "end": {
+            "line": 16,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 13
+          },
+          "end": {
+            "line": 17,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "J",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 11
+          },
+          "end": {
+            "line": 17,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 13
+          },
+          "end": {
+            "line": 18,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "K",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 18,
+            "column": 11
+          },
+          "end": {
+            "line": 18,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 18,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "A",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 7
+            },
+            "end": {
+              "line": 19,
+              "column": 8
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 11
+              },
+              "end": {
+                "line": 19,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 9
+          },
+          "end": {
+            "line": 19,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "B",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 7
+            },
+            "end": {
+              "line": 20,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "A",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 17
+                },
+                "end": {
+                  "line": 20,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 17
+              },
+              "end": {
+                "line": 20,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 17
+            },
+            "end": {
+              "line": 20,
+              "column": 29
+            }
+          }
+        },
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "I",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 32
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 30
+                },
+                "end": {
+                  "line": 20,
+                  "column": 32
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 30
+              },
+              "end": {
+                "line": 20,
+                "column": 32
+              }
+            }
+          },
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "J",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 34
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 36
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 33
+                },
+                "end": {
+                  "line": 20,
+                  "column": 36
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 33
+              },
+              "end": {
+                "line": 20,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 37
+              },
+              "end": {
+                "line": 20,
+                "column": 37
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 35
+          },
+          "end": {
+            "line": 20,
+            "column": 37
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 37
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 7
+            },
+            "end": {
+              "line": 21,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 17
+                },
+                "end": {
+                  "line": 21,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 17
+              },
+              "end": {
+                "line": 21,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 17
+            },
+            "end": {
+              "line": 21,
+              "column": 20
+            }
+          }
+        },
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 21
+              },
+              "end": {
+                "line": 21,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 19
+          },
+          "end": {
+            "line": 21,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "D",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 7
+            },
+            "end": {
+              "line": 22,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "C",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 17
+                },
+                "end": {
+                  "line": 22,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 17
+              },
+              "end": {
+                "line": 22,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 22,
+              "column": 17
+            },
+            "end": {
+              "line": 22,
+              "column": 20
+            }
+          }
+        },
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 21
+              },
+              "end": {
+                "line": 22,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 19
+          },
+          "end": {
+            "line": 22,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 22,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 10
+                },
+                "end": {
+                  "line": 24,
+                  "column": 13
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 13
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "x",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "I",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 24,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 24,
+                                "column": 18
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 24,
+                              "column": 17
+                            },
+                            "end": {
+                              "line": 24,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 24,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 24,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 19
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSTypeReference",
+                  "part": {
+                    "type": "ETSTypeReferencePart",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "string",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 29
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "StringLiteral",
+                        "value": "I",
+                        "loc": {
+                          "start": {
+                            "line": 25,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 25,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 25,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 25,
+                          "column": 16
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 13
+                },
+                "end": {
+                  "line": 26,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "J",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 27,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 27,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 27,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 27,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 27,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 27,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "string",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 27,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 27,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "J",
+                            "loc": {
+                              "start": {
+                                "line": 28,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 28,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 28,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 28,
+                              "column": 16
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 27,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 2
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 1
+              },
+              "end": {
+                "line": 26,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "main",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 31,
+                  "column": 10
+                },
+                "end": {
+                  "line": 31,
+                  "column": 14
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "main",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 14
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 21
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "d",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "string",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 32,
+                                      "column": 13
+                                    },
+                                    "end": {
+                                      "line": 32,
+                                      "column": 19
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 32,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 32,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 32,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 32,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 32,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 32,
+                                "column": 10
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 32,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 32,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "D",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 32,
+                                          "column": 30
+                                        },
+                                        "end": {
+                                          "line": 32,
+                                          "column": 31
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 32,
+                                        "column": 30
+                                      },
+                                      "end": {
+                                        "line": 32,
+                                        "column": 32
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 32,
+                                      "column": 30
+                                    },
+                                    "end": {
+                                      "line": 32,
+                                      "column": 32
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 32,
+                                    "column": 26
+                                  },
+                                  "end": {
+                                    "line": 32,
+                                    "column": 34
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 32,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 32,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 32,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 32,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 0,
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 31,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 31,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 31,
+                  "column": 14
+                },
+                "end": {
+                  "line": 34,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 31,
+                "column": 1
+              },
+              "end": {
+                "line": 34,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 36,
+      "column": 1
+    }
+  }
+}
+TypeError: Call to `foo` is ambiguous as `2` versions of `foo` are available: `foo(x: I): String` and `foo(x: J): String` [method-resolution-class-and-interface-in-signatures_3.ets:32:22]
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_3.ets b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_3.ets
new file mode 100644
index 0000000000000000000000000000000000000000..ef412316e118b65d514eb9b6eb2cf108279b406c
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_3.ets
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+interface I {}
+interface J {}
+interface K {}
+class A {}
+class B extends A implements I, J {}
+class C extends B {}
+class D extends C {}
+
+function foo(x: I): string {
+    return "I";
+}
+function foo(x: J): string {
+    return "J";
+}
+
+function main(): int {
+    let d : string = foo(new D());
+    return 0;
+}
+
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_4-expected.txt b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..80ef2eedb6715e433a4ab7efaacffbe967c03f13
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_4-expected.txt
@@ -0,0 +1,1846 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 13
+          },
+          "end": {
+            "line": 16,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "I",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 11
+          },
+          "end": {
+            "line": 16,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 13
+          },
+          "end": {
+            "line": 17,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "J",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 11
+          },
+          "end": {
+            "line": 17,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "A",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 7
+            },
+            "end": {
+              "line": 19,
+              "column": 8
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 11
+              },
+              "end": {
+                "line": 19,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 9
+          },
+          "end": {
+            "line": 19,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "B",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 7
+            },
+            "end": {
+              "line": 20,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "A",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 17
+                },
+                "end": {
+                  "line": 20,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 17
+              },
+              "end": {
+                "line": 20,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 17
+            },
+            "end": {
+              "line": 20,
+              "column": 29
+            }
+          }
+        },
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "I",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 32
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 30
+                },
+                "end": {
+                  "line": 20,
+                  "column": 32
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 30
+              },
+              "end": {
+                "line": 20,
+                "column": 32
+              }
+            }
+          },
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "J",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 34
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 36
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 33
+                },
+                "end": {
+                  "line": 20,
+                  "column": 36
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 33
+              },
+              "end": {
+                "line": 20,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 37
+              },
+              "end": {
+                "line": 20,
+                "column": 37
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 35
+          },
+          "end": {
+            "line": 20,
+            "column": 37
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 37
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 7
+            },
+            "end": {
+              "line": 21,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 17
+                },
+                "end": {
+                  "line": 21,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 17
+              },
+              "end": {
+                "line": 21,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 17
+            },
+            "end": {
+              "line": 21,
+              "column": 20
+            }
+          }
+        },
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 21
+              },
+              "end": {
+                "line": 21,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 19
+          },
+          "end": {
+            "line": 21,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 10
+                },
+                "end": {
+                  "line": 23,
+                  "column": 13
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 13
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "x",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "I",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 23,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 23,
+                                "column": 18
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 23,
+                              "column": 17
+                            },
+                            "end": {
+                              "line": 23,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 23,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 23,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 19
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSTypeReference",
+                  "part": {
+                    "type": "ETSTypeReferencePart",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "string",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 29
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "StringLiteral",
+                        "value": "I",
+                        "loc": {
+                          "start": {
+                            "line": 24,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 24,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 16
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 13
+                },
+                "end": {
+                  "line": 25,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 26,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 26,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "J",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 26,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 26,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 26,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 26,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 26,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 26,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 26,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 26,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 26,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 26,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "string",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 26,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 26,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 26,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 26,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 26,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 26,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "J",
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 16
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 26,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 28,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 28,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 2
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "A",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 29,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 29,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 29,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 29,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 29,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 29,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 29,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 29,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 29,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 29,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "string",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 29,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 29,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 29,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 29,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "A",
+                            "loc": {
+                              "start": {
+                                "line": 30,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 30,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 30,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 30,
+                              "column": 16
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 29,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 2
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 1
+              },
+              "end": {
+                "line": 25,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "main",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 10
+                },
+                "end": {
+                  "line": 33,
+                  "column": 14
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "main",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 14
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 21
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "c",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "string",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 34,
+                                      "column": 13
+                                    },
+                                    "end": {
+                                      "line": 34,
+                                      "column": 19
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 34,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 34,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 10
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 34,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 34,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "C",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 34,
+                                          "column": 30
+                                        },
+                                        "end": {
+                                          "line": 34,
+                                          "column": 31
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 34,
+                                        "column": 30
+                                      },
+                                      "end": {
+                                        "line": 34,
+                                        "column": 32
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 34,
+                                      "column": 30
+                                    },
+                                    "end": {
+                                      "line": 34,
+                                      "column": 32
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 34,
+                                    "column": 26
+                                  },
+                                  "end": {
+                                    "line": 34,
+                                    "column": 34
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 0,
+                        "loc": {
+                          "start": {
+                            "line": 35,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 35,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 35,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 36,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 36,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 33,
+                  "column": 14
+                },
+                "end": {
+                  "line": 36,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 33,
+                "column": 1
+              },
+              "end": {
+                "line": 36,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 38,
+      "column": 1
+    }
+  }
+}
+TypeError: Call to `foo` is ambiguous as `2` versions of `foo` are available: `foo(x: A): String` and `foo(x: I): String` [method-resolution-class-and-interface-in-signatures_4.ets:34:22]
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_4.ets b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_4.ets
new file mode 100644
index 0000000000000000000000000000000000000000..7eb0e88eb2d774d2cca77346aa8820d2772ae5bc
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_4.ets
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+interface I {}
+interface J {}
+
+class A {}
+class B extends A implements I, J {}
+class C extends B {}
+
+function foo(x: I): string {
+    return "I";
+}
+function foo(x: J): string {
+    return "J";
+}
+function foo(x: A): string {
+    return "A";
+}
+
+function main(): int {
+    let c : string = foo(new C());
+    return 0;
+}
+
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_5-expected.txt b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_5-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f4277701d6b36c899890e070b686bffb67c93c10
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_5-expected.txt
@@ -0,0 +1,2078 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 13
+          },
+          "end": {
+            "line": 16,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "I",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 11
+          },
+          "end": {
+            "line": 16,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 13
+          },
+          "end": {
+            "line": 17,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "J",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 11
+          },
+          "end": {
+            "line": 17,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "A",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 7
+            },
+            "end": {
+              "line": 19,
+              "column": 8
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 11
+              },
+              "end": {
+                "line": 19,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 9
+          },
+          "end": {
+            "line": 19,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "B",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 7
+            },
+            "end": {
+              "line": 20,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "A",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 17
+                },
+                "end": {
+                  "line": 20,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 17
+              },
+              "end": {
+                "line": 20,
+                "column": 29
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 20,
+              "column": 17
+            },
+            "end": {
+              "line": 20,
+              "column": 29
+            }
+          }
+        },
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "I",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 30
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 32
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 30
+                },
+                "end": {
+                  "line": 20,
+                  "column": 32
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 30
+              },
+              "end": {
+                "line": 20,
+                "column": 32
+              }
+            }
+          },
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "J",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 34
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 33
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 36
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 33
+                },
+                "end": {
+                  "line": 20,
+                  "column": 36
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 33
+              },
+              "end": {
+                "line": 20,
+                "column": 36
+              }
+            }
+          }
+        ],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 20,
+                "column": 37
+              },
+              "end": {
+                "line": 20,
+                "column": 37
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 20,
+            "column": 35
+          },
+          "end": {
+            "line": 20,
+            "column": 37
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 20,
+          "column": 1
+        },
+        "end": {
+          "line": 20,
+          "column": 37
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 7
+            },
+            "end": {
+              "line": 21,
+              "column": 8
+            }
+          }
+        },
+        "superClass": {
+          "type": "ETSTypeReference",
+          "part": {
+            "type": "ETSTypeReferencePart",
+            "name": {
+              "type": "Identifier",
+              "name": "B",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 17
+                },
+                "end": {
+                  "line": 21,
+                  "column": 18
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 17
+              },
+              "end": {
+                "line": 21,
+                "column": 20
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 21,
+              "column": 17
+            },
+            "end": {
+              "line": 21,
+              "column": 20
+            }
+          }
+        },
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 21
+              },
+              "end": {
+                "line": 21,
+                "column": 21
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 21,
+            "column": 19
+          },
+          "end": {
+            "line": 21,
+            "column": 21
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 21,
+          "column": 1
+        },
+        "end": {
+          "line": 21,
+          "column": 21
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 10
+                },
+                "end": {
+                  "line": 23,
+                  "column": 13
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 13
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "x",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "I",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 23,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 23,
+                                "column": 18
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 23,
+                              "column": 17
+                            },
+                            "end": {
+                              "line": 23,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 23,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 23,
+                            "column": 19
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 19
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 19
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSTypeReference",
+                  "part": {
+                    "type": "ETSTypeReferencePart",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "string",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 21
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 29
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 29
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "StringLiteral",
+                        "value": "I",
+                        "loc": {
+                          "start": {
+                            "line": 24,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 24,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 16
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 28
+                    },
+                    "end": {
+                      "line": 25,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 25,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 13
+                },
+                "end": {
+                  "line": 25,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 26,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 26,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "J",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 26,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 26,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 26,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 26,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 26,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 26,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 26,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 26,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 26,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 26,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "string",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 26,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 26,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 26,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 26,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 26,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 26,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "J",
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 16
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 26,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 28,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 26,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 28,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 26,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 26,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 2
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "A",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 29,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 29,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 29,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 29,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 29,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 29,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 29,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 29,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 29,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 29,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "string",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 29,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 29,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 29,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 29,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "A",
+                            "loc": {
+                              "start": {
+                                "line": 30,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 30,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 30,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 30,
+                              "column": 16
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 31,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 29,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 31,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 31,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 31,
+                    "column": 2
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "x",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "B",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 32,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 32,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 32,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 32,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 32,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 32,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 32,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 32,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 32,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 32,
+                            "column": 19
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "string",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 32,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 32,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 32,
+                            "column": 21
+                          },
+                          "end": {
+                            "line": 32,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 21
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 29
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "StringLiteral",
+                            "value": "B",
+                            "loc": {
+                              "start": {
+                                "line": 33,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 33,
+                                "column": 15
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 33,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 33,
+                              "column": 16
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 32,
+                          "column": 28
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 32,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 34,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 32,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 32,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 2
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 1
+              },
+              "end": {
+                "line": 25,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "main",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 10
+                },
+                "end": {
+                  "line": 36,
+                  "column": 14
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "main",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 36,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 36,
+                      "column": 14
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 36,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 36,
+                      "column": 21
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "b",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "string",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 37,
+                                      "column": 13
+                                    },
+                                    "end": {
+                                      "line": 37,
+                                      "column": 19
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 37,
+                                    "column": 13
+                                  },
+                                  "end": {
+                                    "line": 37,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 37,
+                                  "column": 13
+                                },
+                                "end": {
+                                  "line": 37,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 37,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 37,
+                                "column": 10
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 37,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 37,
+                                  "column": 25
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "B",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 37,
+                                          "column": 30
+                                        },
+                                        "end": {
+                                          "line": 37,
+                                          "column": 31
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 37,
+                                        "column": 30
+                                      },
+                                      "end": {
+                                        "line": 37,
+                                        "column": 32
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 37,
+                                      "column": 30
+                                    },
+                                    "end": {
+                                      "line": 37,
+                                      "column": 32
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 37,
+                                    "column": 26
+                                  },
+                                  "end": {
+                                    "line": 37,
+                                    "column": 34
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 37,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 37,
+                                "column": 34
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 37,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 37,
+                              "column": 34
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 37,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 37,
+                          "column": 35
+                        }
+                      }
+                    },
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 0,
+                        "loc": {
+                          "start": {
+                            "line": 38,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 38,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 38,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 38,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 36,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 39,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 36,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 39,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 14
+                },
+                "end": {
+                  "line": 39,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 1
+              },
+              "end": {
+                "line": 39,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 41,
+      "column": 1
+    }
+  }
+}
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_5.ets b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_5.ets
new file mode 100644
index 0000000000000000000000000000000000000000..11d737240216d9bfd5573dc7492858a7da392d02
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_5.ets
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+interface I {}
+interface J {}
+
+class A {}
+class B extends A implements I, J {}
+class C extends B {}
+
+function foo(x: I): string {
+    return "I";
+}
+function foo(x: J): string {
+    return "J";
+}
+function foo(x: A): string {
+    return "A";
+}
+function foo(x: B): string {
+    return "B";
+}
+
+function main(): int {
+    let b : string = foo(new B());
+    return 0;
+}
+
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_6-expected.txt b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..789f220c2c38621c255c5d84276e6bafab7767f8
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_6-expected.txt
@@ -0,0 +1,2642 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 13
+          },
+          "end": {
+            "line": 16,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "I",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 11
+          },
+          "end": {
+            "line": 16,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 13
+          },
+          "end": {
+            "line": 17,
+            "column": 15
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "J",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 11
+          },
+          "end": {
+            "line": 17,
+            "column": 12
+          }
+        }
+      },
+      "extends": [],
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "A",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 19,
+              "column": 7
+            },
+            "end": {
+              "line": 19,
+              "column": 8
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "I",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 20
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 21
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 20
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 22
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 20
+                },
+                "end": {
+                  "line": 19,
+                  "column": 22
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 20
+              },
+              "end": {
+                "line": 19,
+                "column": 22
+              }
+            }
+          },
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "J",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 24
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 23
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 26
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 23
+                },
+                "end": {
+                  "line": 19,
+                  "column": 26
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 23
+              },
+              "end": {
+                "line": 19,
+                "column": 26
+              }
+            }
+          }
+        ],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 27
+              },
+              "end": {
+                "line": 19,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 19,
+            "column": 25
+          },
+          "end": {
+            "line": 19,
+            "column": 27
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 19,
+          "column": 1
+        },
+        "end": {
+          "line": 19,
+          "column": 27
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 10
+                },
+                "end": {
+                  "line": 21,
+                  "column": 13
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 13
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "ETSPrimitiveType",
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 21,
+                            "column": 20
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 21,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 21,
+                          "column": 20
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 21,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 21,
+                        "column": 20
+                      }
+                    }
+                  },
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "I",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 21,
+                                "column": 25
+                              },
+                              "end": {
+                                "line": 21,
+                                "column": 26
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 25
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 27
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 21,
+                            "column": 27
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 21,
+                          "column": 22
+                        },
+                        "end": {
+                          "line": 21,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 21,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 21,
+                        "column": 27
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 32
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "b",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 22,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 22,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 22,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 22,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 33
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 21,
+                  "column": 13
+                },
+                "end": {
+                  "line": 23,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "d",
+                          "typeAnnotation": {
+                            "type": "ETSPrimitiveType",
+                            "loc": {
+                              "start": {
+                                "line": 24,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 24,
+                                "column": 23
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 24,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 24,
+                              "column": 23
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 24,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 24,
+                            "column": 23
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "J",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 24,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 24,
+                                    "column": 29
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 24,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 24,
+                                  "column": 30
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 24,
+                                "column": 28
+                              },
+                              "end": {
+                                "line": 24,
+                                "column": 30
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 24,
+                              "column": 25
+                            },
+                            "end": {
+                              "line": 24,
+                              "column": 30
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 24,
+                            "column": 25
+                          },
+                          "end": {
+                            "line": 24,
+                            "column": 30
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSPrimitiveType",
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 32
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 38
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "Identifier",
+                            "name": "d",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 25,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 25,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 25,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 25,
+                              "column": 14
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 26,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 26,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 26,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 26,
+                    "column": 2
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 27,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "I",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 27,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 27,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 27,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 27,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 27,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 27,
+                            "column": 19
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "typeAnnotation": {
+                            "type": "ETSPrimitiveType",
+                            "loc": {
+                              "start": {
+                                "line": 27,
+                                "column": 23
+                              },
+                              "end": {
+                                "line": 27,
+                                "column": 26
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 27,
+                              "column": 20
+                            },
+                            "end": {
+                              "line": 27,
+                              "column": 26
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 27,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 27,
+                            "column": 26
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSPrimitiveType",
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 29
+                        },
+                        "end": {
+                          "line": 27,
+                          "column": 32
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "Identifier",
+                            "name": "b",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 28,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 28,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 28,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 28,
+                              "column": 14
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 27,
+                          "column": 33
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 27,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 27,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 27,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 2
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 30,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "J",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 30,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 30,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 30,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 30,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 30,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 30,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 30,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 30,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 30,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 30,
+                            "column": 19
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "d",
+                          "typeAnnotation": {
+                            "type": "ETSPrimitiveType",
+                            "loc": {
+                              "start": {
+                                "line": 30,
+                                "column": 23
+                              },
+                              "end": {
+                                "line": 30,
+                                "column": 29
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 30,
+                              "column": 20
+                            },
+                            "end": {
+                              "line": 30,
+                              "column": 29
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 30,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 30,
+                            "column": 29
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSPrimitiveType",
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 32
+                        },
+                        "end": {
+                          "line": 30,
+                          "column": 38
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "Identifier",
+                            "name": "d",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 31,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 31,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 31,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 31,
+                              "column": 14
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 30,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 32,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 30,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 32,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 30,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 32,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 30,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 32,
+                    "column": 2
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 33,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "I",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 33,
+                                    "column": 17
+                                  },
+                                  "end": {
+                                    "line": 33,
+                                    "column": 18
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 33,
+                                  "column": 17
+                                },
+                                "end": {
+                                  "line": 33,
+                                  "column": 19
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 33,
+                                "column": 17
+                              },
+                              "end": {
+                                "line": 33,
+                                "column": 19
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 33,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 33,
+                              "column": 19
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 19
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "d",
+                          "typeAnnotation": {
+                            "type": "ETSPrimitiveType",
+                            "loc": {
+                              "start": {
+                                "line": 33,
+                                "column": 23
+                              },
+                              "end": {
+                                "line": 33,
+                                "column": 29
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 33,
+                              "column": 20
+                            },
+                            "end": {
+                              "line": 33,
+                              "column": 29
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 33,
+                            "column": 20
+                          },
+                          "end": {
+                            "line": 33,
+                            "column": 29
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSPrimitiveType",
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 32
+                        },
+                        "end": {
+                          "line": 33,
+                          "column": 38
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "Identifier",
+                            "name": "d",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 34,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 34,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 14
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 33,
+                          "column": 39
+                        },
+                        "end": {
+                          "line": 35,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 33,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 35,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 33,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 35,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 33,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 35,
+                    "column": 2
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 21,
+                "column": 1
+              },
+              "end": {
+                "line": 23,
+                "column": 2
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "main",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 10
+                },
+                "end": {
+                  "line": 37,
+                  "column": 14
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "main",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 14
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 37,
+                      "column": 21
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "asd1",
+                            "typeAnnotation": {
+                              "type": "ETSPrimitiveType",
+                              "loc": {
+                                "start": {
+                                  "line": 38,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 38,
+                                  "column": 18
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 38,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 38,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 38,
+                                  "column": 21
+                                },
+                                "end": {
+                                  "line": 38,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 38,
+                                    "column": 25
+                                  },
+                                  "end": {
+                                    "line": 38,
+                                    "column": 26
+                                  }
+                                }
+                              },
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "A",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 38,
+                                          "column": 32
+                                        },
+                                        "end": {
+                                          "line": 38,
+                                          "column": 33
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 38,
+                                        "column": 32
+                                      },
+                                      "end": {
+                                        "line": 38,
+                                        "column": 34
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 38,
+                                      "column": 32
+                                    },
+                                    "end": {
+                                      "line": 38,
+                                      "column": 34
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 38,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 38,
+                                    "column": 36
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 38,
+                                "column": 21
+                              },
+                              "end": {
+                                "line": 38,
+                                "column": 36
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 38,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 38,
+                              "column": 36
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 38,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 38,
+                          "column": 37
+                        }
+                      }
+                    },
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "asd2",
+                            "typeAnnotation": {
+                              "type": "ETSPrimitiveType",
+                              "loc": {
+                                "start": {
+                                  "line": 39,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 39,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 39,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 39,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 39,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 39,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "NumberLiteral",
+                                "value": 2.1,
+                                "loc": {
+                                  "start": {
+                                    "line": 39,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 39,
+                                    "column": 31
+                                  }
+                                }
+                              },
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "A",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 39,
+                                          "column": 37
+                                        },
+                                        "end": {
+                                          "line": 39,
+                                          "column": 38
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 39,
+                                        "column": 37
+                                      },
+                                      "end": {
+                                        "line": 39,
+                                        "column": 39
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 39,
+                                      "column": 37
+                                    },
+                                    "end": {
+                                      "line": 39,
+                                      "column": 39
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 39,
+                                    "column": 33
+                                  },
+                                  "end": {
+                                    "line": 39,
+                                    "column": 41
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 39,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 39,
+                                "column": 41
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 39,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 39,
+                              "column": 41
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 39,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 39,
+                          "column": 42
+                        }
+                      }
+                    },
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "asd3",
+                            "typeAnnotation": {
+                              "type": "ETSPrimitiveType",
+                              "loc": {
+                                "start": {
+                                  "line": 40,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 40,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 40,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 40,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 40,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 40,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "NumberLiteral",
+                                "value": 2,
+                                "loc": {
+                                  "start": {
+                                    "line": 40,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 40,
+                                    "column": 31
+                                  }
+                                }
+                              },
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "A",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 40,
+                                          "column": 37
+                                        },
+                                        "end": {
+                                          "line": 40,
+                                          "column": 38
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 40,
+                                        "column": 37
+                                      },
+                                      "end": {
+                                        "line": 40,
+                                        "column": 39
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 40,
+                                      "column": 37
+                                    },
+                                    "end": {
+                                      "line": 40,
+                                      "column": 39
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 40,
+                                    "column": 33
+                                  },
+                                  "end": {
+                                    "line": 40,
+                                    "column": 41
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 40,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 40,
+                                "column": 41
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 40,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 40,
+                              "column": 41
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 40,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 40,
+                          "column": 42
+                        }
+                      }
+                    },
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "asd4",
+                            "typeAnnotation": {
+                              "type": "ETSPrimitiveType",
+                              "loc": {
+                                "start": {
+                                  "line": 41,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 41,
+                                  "column": 18
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 41,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 41,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 41,
+                                  "column": 21
+                                },
+                                "end": {
+                                  "line": 41,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "A",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 41,
+                                          "column": 29
+                                        },
+                                        "end": {
+                                          "line": 41,
+                                          "column": 30
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 41,
+                                        "column": 29
+                                      },
+                                      "end": {
+                                        "line": 41,
+                                        "column": 31
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 41,
+                                      "column": 29
+                                    },
+                                    "end": {
+                                      "line": 41,
+                                      "column": 31
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 41,
+                                    "column": 25
+                                  },
+                                  "end": {
+                                    "line": 41,
+                                    "column": 33
+                                  }
+                                }
+                              },
+                              {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 41,
+                                    "column": 34
+                                  },
+                                  "end": {
+                                    "line": 41,
+                                    "column": 35
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 41,
+                                "column": 21
+                              },
+                              "end": {
+                                "line": 41,
+                                "column": 36
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 41,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 41,
+                              "column": 36
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 41,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 41,
+                          "column": 37
+                        }
+                      }
+                    },
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "asd5",
+                            "typeAnnotation": {
+                              "type": "ETSPrimitiveType",
+                              "loc": {
+                                "start": {
+                                  "line": 42,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 42,
+                                  "column": 21
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 42,
+                                "column": 9
+                              },
+                              "end": {
+                                "line": 42,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 42,
+                                  "column": 24
+                                },
+                                "end": {
+                                  "line": 42,
+                                  "column": 27
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "ETSNewClassInstanceExpression",
+                                "typeReference": {
+                                  "type": "ETSTypeReference",
+                                  "part": {
+                                    "type": "ETSTypeReferencePart",
+                                    "name": {
+                                      "type": "Identifier",
+                                      "name": "A",
+                                      "decorators": [],
+                                      "loc": {
+                                        "start": {
+                                          "line": 42,
+                                          "column": 32
+                                        },
+                                        "end": {
+                                          "line": 42,
+                                          "column": 33
+                                        }
+                                      }
+                                    },
+                                    "loc": {
+                                      "start": {
+                                        "line": 42,
+                                        "column": 32
+                                      },
+                                      "end": {
+                                        "line": 42,
+                                        "column": 34
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 42,
+                                      "column": 32
+                                    },
+                                    "end": {
+                                      "line": 42,
+                                      "column": 34
+                                    }
+                                  }
+                                },
+                                "arguments": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 42,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 42,
+                                    "column": 36
+                                  }
+                                }
+                              },
+                              {
+                                "type": "NumberLiteral",
+                                "value": 2.1,
+                                "loc": {
+                                  "start": {
+                                    "line": 42,
+                                    "column": 37
+                                  },
+                                  "end": {
+                                    "line": 42,
+                                    "column": 40
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 42,
+                                "column": 24
+                              },
+                              "end": {
+                                "line": 42,
+                                "column": 41
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 42,
+                              "column": 9
+                            },
+                            "end": {
+                              "line": 42,
+                              "column": 41
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "let",
+                      "loc": {
+                        "start": {
+                          "line": 42,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 42,
+                          "column": 42
+                        }
+                      }
+                    },
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 0,
+                        "loc": {
+                          "start": {
+                            "line": 43,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 43,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 43,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 43,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 37,
+                      "column": 22
+                    },
+                    "end": {
+                      "line": 44,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 37,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 44,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 37,
+                  "column": 14
+                },
+                "end": {
+                  "line": 44,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 37,
+                "column": 1
+              },
+              "end": {
+                "line": 44,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 44,
+      "column": 2
+    }
+  }
+}
+TypeError: Call to `foo` is ambiguous as `2` versions of `foo` are available: `foo(a: J, d: double): double` and `foo(a: I, d: double): double` [method-resolution-class-and-interface-in-signatures_6.ets:42:24]
diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_6.ets b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_6.ets
new file mode 100644
index 0000000000000000000000000000000000000000..a6b43ef72ce4b2c8b95ddf1fd4d679b66e09c7dd
--- /dev/null
+++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_6.ets
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+interface I {}
+interface J {}
+
+class A implements I, J {}
+
+function foo(b: int, a: I): int {
+    return b;
+}
+function foo(d: double, a: J): double {
+    return d;
+}
+function foo(a: I, b: int): int {
+    return b;
+}
+function foo(a: J, d: double): double {
+    return d;
+}
+function foo(a: I, d: double): double {
+    return d;
+}
+
+function main(): int {
+    let asd1: int = foo(1, new A());
+    let asd2: double = foo(2.1, new A());
+    let asd3: double = foo(2.0, new A());
+    let asd4: int = foo(new A(), 1);
+    let asd5: double = foo(new A(), 2.1);
+    return 0;
+}
\ No newline at end of file
diff --git a/ets2panda/test/compiler/ets/optionalLambdaParameter-expected.txt b/ets2panda/test/compiler/ets/optionalLambdaParameter-expected.txt
index ca7577b0c36d6ae925de3505c46b5f2b8364e2c6..9924e957d690a3113855b4d71560149411b50da3 100644
--- a/ets2panda/test/compiler/ets/optionalLambdaParameter-expected.txt
+++ b/ets2panda/test/compiler/ets/optionalLambdaParameter-expected.txt
@@ -513,7 +513,7 @@
                         "type": "ETSParameterExpression",
                         "name": {
                           "type": "Identifier",
-                          "name": "proxy_int",
+                          "name": "$proxy_mask$",
                           "typeAnnotation": {
                             "type": "ETSPrimitiveType",
                             "loc": {
@@ -608,7 +608,7 @@
                                 "operator": ">>",
                                 "left": {
                                   "type": "Identifier",
-                                  "name": "proxy_int",
+                                  "name": "$proxy_mask$",
                                   "decorators": [],
                                   "loc": {
                                     "start": {
diff --git a/ets2panda/test/compiler/ets/voidTypeInBinaryOperation-expected.txt b/ets2panda/test/compiler/ets/voidTypeInBinaryOperation-expected.txt
index 9447d6cad027d103c65b993701124e7455b4a3ba..b434ae012cb969a610d026fa49e92884441b5d35 100644
--- a/ets2panda/test/compiler/ets/voidTypeInBinaryOperation-expected.txt
+++ b/ets2panda/test/compiler/ets/voidTypeInBinaryOperation-expected.txt
@@ -494,3 +494,4 @@
     }
   }
 }
+TypeError: An expression of type 'void' cannot be tested for truthiness [voidTypeInBinaryOperation.ets:20:19]
diff --git a/ets2panda/test/parser/ets/ambiguous_call_3-expected.txt b/ets2panda/test/parser/ets/ambiguous_call_3-expected.txt
index 03787bbfbcd6076f575cf5dd893c470f666ee72d..eaca9b0b5c8b670de976435123d9890766056d5c 100644
--- a/ets2panda/test/parser/ets/ambiguous_call_3-expected.txt
+++ b/ets2panda/test/parser/ets/ambiguous_call_3-expected.txt
@@ -1209,4 +1209,4 @@
     }
   }
 }
-TypeError: Call to `goo` is ambiguous as `2` versions of `goo` are available: `goo(p1: I1): void` and `goo(p2: B): void` [ambiguous_call_3.ets:23:5]
+TypeError: Call to `goo` is ambiguous as `2` versions of `goo` are available: `goo(p2: B): void` and `goo(p1: I1): void` [ambiguous_call_3.ets:23:5]
diff --git a/ets2panda/test/parser/ets/default_parameter1-expected.txt b/ets2panda/test/parser/ets/default_parameter1-expected.txt
index 70a65a1979f1629eab79e45eba2f4ef217d0b2e3..41c4146c87dd859f8051680729b5de2477869813 100644
--- a/ets2panda/test/parser/ets/default_parameter1-expected.txt
+++ b/ets2panda/test/parser/ets/default_parameter1-expected.txt
@@ -691,7 +691,7 @@
                         "type": "ETSParameterExpression",
                         "name": {
                           "type": "Identifier",
-                          "name": "proxy_int",
+                          "name": "$proxy_mask$",
                           "typeAnnotation": {
                             "type": "ETSPrimitiveType",
                             "loc": {
@@ -758,7 +758,7 @@
                                 "operator": ">>",
                                 "left": {
                                   "type": "Identifier",
-                                  "name": "proxy_int",
+                                  "name": "$proxy_mask$",
                                   "decorators": [],
                                   "loc": {
                                     "start": {
@@ -1276,4 +1276,4 @@
     }
   }
 }
-TypeError: Reference to foo is ambiguous [default_parameter1.ets:18:5]
+TypeError: Function already declared. [default_parameter1.ets:26:1]
diff --git a/ets2panda/test/parser/ets/default_parameter2-expected.txt b/ets2panda/test/parser/ets/default_parameter2-expected.txt
index 0267fc1b3f8eade491362cbca4a141f84537a4b9..1bc729dc18971726d43817eb01a32178dba82144 100644
--- a/ets2panda/test/parser/ets/default_parameter2-expected.txt
+++ b/ets2panda/test/parser/ets/default_parameter2-expected.txt
@@ -676,7 +676,7 @@
                         "type": "ETSParameterExpression",
                         "name": {
                           "type": "Identifier",
-                          "name": "proxy_int",
+                          "name": "$proxy_mask$",
                           "typeAnnotation": {
                             "type": "ETSPrimitiveType",
                             "loc": {
@@ -743,7 +743,7 @@
                                 "operator": ">>",
                                 "left": {
                                   "type": "Identifier",
-                                  "name": "proxy_int",
+                                  "name": "$proxy_mask$",
                                   "decorators": [],
                                   "loc": {
                                     "start": {
@@ -1261,4 +1261,4 @@
     }
   }
 }
-TypeError: No matching call signature [default_parameter2.ets:18:5]
+TypeError: Function already declared. [default_parameter2.ets:26:1]
diff --git a/ets2panda/test/parser/ets/default_parameter4-expected.txt b/ets2panda/test/parser/ets/default_parameter4-expected.txt
index 35457f1bc8469a303faab6c21f02c386b621ccc7..9ddd3595837e5d7ce3500487c46e198fe039fd33 100644
--- a/ets2panda/test/parser/ets/default_parameter4-expected.txt
+++ b/ets2panda/test/parser/ets/default_parameter4-expected.txt
@@ -816,7 +816,7 @@
                         "type": "ETSParameterExpression",
                         "name": {
                           "type": "Identifier",
-                          "name": "proxy_int",
+                          "name": "$proxy_mask$",
                           "typeAnnotation": {
                             "type": "ETSPrimitiveType",
                             "loc": {
@@ -883,7 +883,7 @@
                                 "operator": ">>",
                                 "left": {
                                   "type": "Identifier",
-                                  "name": "proxy_int",
+                                  "name": "$proxy_mask$",
                                   "decorators": [],
                                   "loc": {
                                     "start": {
@@ -1067,7 +1067,7 @@
                                 "operator": ">>",
                                 "left": {
                                   "type": "Identifier",
-                                  "name": "proxy_int",
+                                  "name": "$proxy_mask$",
                                   "decorators": [],
                                   "loc": {
                                     "start": {
@@ -1656,7 +1656,7 @@
                         "type": "ETSParameterExpression",
                         "name": {
                           "type": "Identifier",
-                          "name": "proxy_int",
+                          "name": "$proxy_mask$",
                           "typeAnnotation": {
                             "type": "ETSPrimitiveType",
                             "loc": {
@@ -1723,7 +1723,7 @@
                                 "operator": ">>",
                                 "left": {
                                   "type": "Identifier",
-                                  "name": "proxy_int",
+                                  "name": "$proxy_mask$",
                                   "decorators": [],
                                   "loc": {
                                     "start": {
@@ -2048,4 +2048,4 @@
     }
   }
 }
-TypeError: Reference to foo is ambiguous [default_parameter4.ets:18:5]
+TypeError: Function already declared. [default_parameter4.ets:26:1]
diff --git a/ets2panda/test/parser/ets/default_parameter5-expected.txt b/ets2panda/test/parser/ets/default_parameter5-expected.txt
index c7eec1185058bceee24bce0c0d2d7f0ddb7b34d4..ab0a5a6760f5398fd88173f216c0a6321beaadcd 100644
--- a/ets2panda/test/parser/ets/default_parameter5-expected.txt
+++ b/ets2panda/test/parser/ets/default_parameter5-expected.txt
@@ -861,7 +861,7 @@
                         "type": "ETSParameterExpression",
                         "name": {
                           "type": "Identifier",
-                          "name": "proxy_int",
+                          "name": "$proxy_mask$",
                           "typeAnnotation": {
                             "type": "ETSPrimitiveType",
                             "loc": {
@@ -928,7 +928,7 @@
                                 "operator": ">>",
                                 "left": {
                                   "type": "Identifier",
-                                  "name": "proxy_int",
+                                  "name": "$proxy_mask$",
                                   "decorators": [],
                                   "loc": {
                                     "start": {
diff --git a/ets2panda/test/parser/ets/default_parameter6-expected.txt b/ets2panda/test/parser/ets/default_parameter6-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ad8c1be4b178b428ef903861db2327627164809c
--- /dev/null
+++ b/ets2panda/test/parser/ets/default_parameter6-expected.txt
@@ -0,0 +1,2637 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 10
+                },
+                "end": {
+                  "line": 16,
+                  "column": 13
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 13
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "a",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "Int",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 16,
+                                "column": 18
+                              },
+                              "end": {
+                                "line": 16,
+                                "column": 21
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 18
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 22
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 18
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 22
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 22
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 22
+                      }
+                    }
+                  },
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "b",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "Int",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 16,
+                                "column": 27
+                              },
+                              "end": {
+                                "line": 16,
+                                "column": 30
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 27
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 32
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 27
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 32
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 23
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 32
+                        }
+                      }
+                    },
+                    "initializer": {
+                      "type": "NumberLiteral",
+                      "value": 20,
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 33
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 35
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 23
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 35
+                      }
+                    }
+                  },
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "Int",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 16,
+                                "column": 41
+                              },
+                              "end": {
+                                "line": 16,
+                                "column": 44
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 41
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 46
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 46
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 37
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 46
+                        }
+                      }
+                    },
+                    "initializer": {
+                      "type": "NumberLiteral",
+                      "value": 30,
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 47
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 49
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 37
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 49
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSTypeReference",
+                  "part": {
+                    "type": "ETSTypeReferencePart",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "Int",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 53
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 56
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 53
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 53
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 2
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 18,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 18,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 18,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 18,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 13
+                },
+                "end": {
+                  "line": 19,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo_proxy",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 3
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo_proxy",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 3
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "$proxy_mask$",
+                          "typeAnnotation": {
+                            "type": "ETSPrimitiveType",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "Int",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 3
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 3
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "IfStatement",
+                          "test": {
+                            "type": "BinaryExpression",
+                            "operator": "==",
+                            "left": {
+                              "type": "BinaryExpression",
+                              "operator": "&",
+                              "left": {
+                                "type": "BinaryExpression",
+                                "operator": ">>",
+                                "left": {
+                                  "type": "Identifier",
+                                  "name": "$proxy_mask$",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "right": {
+                                  "type": "NumberLiteral",
+                                  "value": 1,
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "NumberLiteral",
+                              "value": 1,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "consequent": {
+                            "type": "BlockStatement",
+                            "statements": [
+                              {
+                                "type": "ExpressionStatement",
+                                "expression": {
+                                  "type": "AssignmentExpression",
+                                  "operator": "=",
+                                  "left": {
+                                    "type": "Identifier",
+                                    "name": "b",
+                                    "decorators": [],
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "right": {
+                                    "type": "NumberLiteral",
+                                    "value": 20,
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "alternate": null,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        {
+                          "type": "IfStatement",
+                          "test": {
+                            "type": "BinaryExpression",
+                            "operator": "==",
+                            "left": {
+                              "type": "BinaryExpression",
+                              "operator": "&",
+                              "left": {
+                                "type": "BinaryExpression",
+                                "operator": ">>",
+                                "left": {
+                                  "type": "Identifier",
+                                  "name": "$proxy_mask$",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "right": {
+                                  "type": "NumberLiteral",
+                                  "value": 2,
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "NumberLiteral",
+                              "value": 1,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "consequent": {
+                            "type": "BlockStatement",
+                            "statements": [
+                              {
+                                "type": "ExpressionStatement",
+                                "expression": {
+                                  "type": "AssignmentExpression",
+                                  "operator": "=",
+                                  "left": {
+                                    "type": "Identifier",
+                                    "name": "c",
+                                    "decorators": [],
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "right": {
+                                    "type": "NumberLiteral",
+                                    "value": 30,
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "alternate": null,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              {
+                                "type": "Identifier",
+                                "name": "c",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 3
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 3
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 3
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 3
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 3
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 3
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 21,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 21,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 21,
+                                    "column": 18
+                                  },
+                                  "end": {
+                                    "line": 21,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 21,
+                                  "column": 18
+                                },
+                                "end": {
+                                  "line": 21,
+                                  "column": 22
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 21,
+                                "column": 18
+                              },
+                              "end": {
+                                "line": 21,
+                                "column": 22
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 22
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 21,
+                            "column": 22
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "string",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 21,
+                                    "column": 27
+                                  },
+                                  "end": {
+                                    "line": 21,
+                                    "column": 33
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 21,
+                                  "column": 27
+                                },
+                                "end": {
+                                  "line": 21,
+                                  "column": 35
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 21,
+                                "column": 27
+                              },
+                              "end": {
+                                "line": 21,
+                                "column": 35
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 23
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 35
+                            }
+                          }
+                        },
+                        "initializer": {
+                          "type": "StringLiteral",
+                          "value": "a",
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 36
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 39
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 21,
+                            "column": 39
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 21,
+                                    "column": 45
+                                  },
+                                  "end": {
+                                    "line": 21,
+                                    "column": 48
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 21,
+                                  "column": 45
+                                },
+                                "end": {
+                                  "line": 21,
+                                  "column": 50
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 21,
+                                "column": 45
+                              },
+                              "end": {
+                                "line": 21,
+                                "column": 50
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 41
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 50
+                            }
+                          }
+                        },
+                        "initializer": {
+                          "type": "NumberLiteral",
+                          "value": 30,
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 51
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 53
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 41
+                          },
+                          "end": {
+                            "line": 21,
+                            "column": 53
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "Int",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 57
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 60
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 57
+                          },
+                          "end": {
+                            "line": 22,
+                            "column": 2
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 21,
+                          "column": 57
+                        },
+                        "end": {
+                          "line": 22,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 23,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 23,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 23,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 23,
+                              "column": 14
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 22,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 21,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 2
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo_proxy",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 3
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo_proxy",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 3
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "string",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "$proxy_mask$",
+                          "typeAnnotation": {
+                            "type": "ETSPrimitiveType",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "Int",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 3
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 3
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "IfStatement",
+                          "test": {
+                            "type": "BinaryExpression",
+                            "operator": "==",
+                            "left": {
+                              "type": "BinaryExpression",
+                              "operator": "&",
+                              "left": {
+                                "type": "BinaryExpression",
+                                "operator": ">>",
+                                "left": {
+                                  "type": "Identifier",
+                                  "name": "$proxy_mask$",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "right": {
+                                  "type": "NumberLiteral",
+                                  "value": 1,
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "NumberLiteral",
+                              "value": 1,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "consequent": {
+                            "type": "BlockStatement",
+                            "statements": [
+                              {
+                                "type": "ExpressionStatement",
+                                "expression": {
+                                  "type": "AssignmentExpression",
+                                  "operator": "=",
+                                  "left": {
+                                    "type": "Identifier",
+                                    "name": "b",
+                                    "decorators": [],
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "right": {
+                                    "type": "StringLiteral",
+                                    "value": "a",
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "alternate": null,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        {
+                          "type": "IfStatement",
+                          "test": {
+                            "type": "BinaryExpression",
+                            "operator": "==",
+                            "left": {
+                              "type": "BinaryExpression",
+                              "operator": "&",
+                              "left": {
+                                "type": "BinaryExpression",
+                                "operator": ">>",
+                                "left": {
+                                  "type": "Identifier",
+                                  "name": "$proxy_mask$",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "right": {
+                                  "type": "NumberLiteral",
+                                  "value": 2,
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "NumberLiteral",
+                              "value": 1,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "consequent": {
+                            "type": "BlockStatement",
+                            "statements": [
+                              {
+                                "type": "ExpressionStatement",
+                                "expression": {
+                                  "type": "AssignmentExpression",
+                                  "operator": "=",
+                                  "left": {
+                                    "type": "Identifier",
+                                    "name": "c",
+                                    "decorators": [],
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "right": {
+                                    "type": "NumberLiteral",
+                                    "value": 30,
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "alternate": null,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              {
+                                "type": "Identifier",
+                                "name": "c",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 3
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 3
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 3
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 3
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 3
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 3
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 1
+              },
+              "end": {
+                "line": 19,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 25,
+      "column": 1
+    }
+  }
+}
+TypeError: Function already declared. [default_parameter6.ets:21:1]
diff --git a/ets2panda/test/parser/ets/default_parameter6.ets b/ets2panda/test/parser/ets/default_parameter6.ets
new file mode 100644
index 0000000000000000000000000000000000000000..2cb74c5e6531a4080dba3db027298bf7a6ac4e08
--- /dev/null
+++ b/ets2panda/test/parser/ets/default_parameter6.ets
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+function foo(a : Int, b : Int = 20, c : Int = 30) : Int
+{
+    return 1;
+}
+
+function foo(a : Int, b : string = "a", c : Int = 30) : Int
+{
+    return 2;
+}
diff --git a/ets2panda/test/parser/ets/default_parameter7-expected.txt b/ets2panda/test/parser/ets/default_parameter7-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c6d4b58f37b4e7b7ec71d7ec93e3d29cc8df1f35
--- /dev/null
+++ b/ets2panda/test/parser/ets/default_parameter7-expected.txt
@@ -0,0 +1,1655 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "foo",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 10
+                },
+                "end": {
+                  "line": 16,
+                  "column": 13
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 16,
+                      "column": 13
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "rest parameter": {
+                      "type": "RestElement",
+                      "argument": {
+                        "type": "Identifier",
+                        "name": "a",
+                        "decorators": [],
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 17
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 18
+                          }
+                        }
+                      },
+                      "typeAnnotation": {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "ETSTypeReference",
+                          "part": {
+                            "type": "ETSTypeReferencePart",
+                            "name": {
+                              "type": "Identifier",
+                              "name": "Int",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 16,
+                                  "column": 21
+                                },
+                                "end": {
+                                  "line": 16,
+                                  "column": 24
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 16,
+                                "column": 21
+                              },
+                              "end": {
+                                "line": 16,
+                                "column": 25
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 16,
+                              "column": 21
+                            },
+                            "end": {
+                              "line": 16,
+                              "column": 25
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 16,
+                            "column": 26
+                          },
+                          "end": {
+                            "line": 16,
+                            "column": 27
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 14
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 27
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 16,
+                        "column": 27
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSTypeReference",
+                  "part": {
+                    "type": "ETSTypeReferencePart",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "Int",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 16,
+                          "column": 30
+                        },
+                        "end": {
+                          "line": 16,
+                          "column": 33
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 16,
+                        "column": 30
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 16,
+                      "column": 30
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 2
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ReturnStatement",
+                      "argument": {
+                        "type": "NumberLiteral",
+                        "value": 1,
+                        "loc": {
+                          "start": {
+                            "line": 18,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 18,
+                            "column": 13
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 18,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 18,
+                          "column": 14
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 13
+                  },
+                  "end": {
+                    "line": 19,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 13
+                },
+                "end": {
+                  "line": 19,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 13
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 21,
+                          "column": 10
+                        },
+                        "end": {
+                          "line": 21,
+                          "column": 13
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 21,
+                                    "column": 18
+                                  },
+                                  "end": {
+                                    "line": 21,
+                                    "column": 21
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 21,
+                                  "column": 18
+                                },
+                                "end": {
+                                  "line": 21,
+                                  "column": 22
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 21,
+                                "column": 18
+                              },
+                              "end": {
+                                "line": 21,
+                                "column": 22
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 14
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 22
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 14
+                          },
+                          "end": {
+                            "line": 21,
+                            "column": 22
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "String",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 21,
+                                    "column": 28
+                                  },
+                                  "end": {
+                                    "line": 21,
+                                    "column": 34
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 21,
+                                  "column": 28
+                                },
+                                "end": {
+                                  "line": 21,
+                                  "column": 35
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 21,
+                                "column": 28
+                              },
+                              "end": {
+                                "line": 21,
+                                "column": 35
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 23
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 35
+                            }
+                          }
+                        },
+                        "initializer": {
+                          "type": "UndefinedLiteral",
+                          "value": undefined,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 1
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 1
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 23
+                          },
+                          "end": {
+                            "line": 21,
+                            "column": 35
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 21,
+                                    "column": 40
+                                  },
+                                  "end": {
+                                    "line": 21,
+                                    "column": 43
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 21,
+                                  "column": 40
+                                },
+                                "end": {
+                                  "line": 21,
+                                  "column": 45
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 21,
+                                "column": 40
+                              },
+                              "end": {
+                                "line": 21,
+                                "column": 45
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 36
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 45
+                            }
+                          }
+                        },
+                        "initializer": {
+                          "type": "NumberLiteral",
+                          "value": 30,
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 46
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 48
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 36
+                          },
+                          "end": {
+                            "line": 21,
+                            "column": 48
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "Int",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 21,
+                              "column": 52
+                            },
+                            "end": {
+                              "line": 21,
+                              "column": 55
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 21,
+                            "column": 52
+                          },
+                          "end": {
+                            "line": 22,
+                            "column": 2
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 21,
+                          "column": 52
+                        },
+                        "end": {
+                          "line": 22,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "NumberLiteral",
+                            "value": 2,
+                            "loc": {
+                              "start": {
+                                "line": 23,
+                                "column": 12
+                              },
+                              "end": {
+                                "line": 23,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 23,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 23,
+                              "column": 14
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 22,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 2
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 21,
+                        "column": 13
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 2
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 21,
+                      "column": 13
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 2
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 21,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 2
+                  }
+                }
+              },
+              {
+                "type": "MethodDefinition",
+                "key": {
+                  "type": "Identifier",
+                  "name": "foo_proxy",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 3
+                    }
+                  }
+                },
+                "kind": "method",
+                "accessibility": "public",
+                "static": true,
+                "optional": false,
+                "computed": false,
+                "value": {
+                  "type": "FunctionExpression",
+                  "function": {
+                    "type": "ScriptFunction",
+                    "id": {
+                      "type": "Identifier",
+                      "name": "foo_proxy",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 1
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 3
+                        }
+                      }
+                    },
+                    "generator": false,
+                    "async": false,
+                    "expression": false,
+                    "params": [
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "a",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "b",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "String",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "c",
+                          "typeAnnotation": {
+                            "type": "ETSTypeReference",
+                            "part": {
+                              "type": "ETSTypeReferencePart",
+                              "name": {
+                                "type": "Identifier",
+                                "name": "Int",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      {
+                        "type": "ETSParameterExpression",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "$proxy_mask$",
+                          "typeAnnotation": {
+                            "type": "ETSPrimitiveType",
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      }
+                    ],
+                    "returnType": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "Int",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 1,
+                            "column": 3
+                          },
+                          "end": {
+                            "line": 1,
+                            "column": 3
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 3
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 3
+                        }
+                      }
+                    },
+                    "body": {
+                      "type": "BlockStatement",
+                      "statements": [
+                        {
+                          "type": "IfStatement",
+                          "test": {
+                            "type": "BinaryExpression",
+                            "operator": "==",
+                            "left": {
+                              "type": "BinaryExpression",
+                              "operator": "&",
+                              "left": {
+                                "type": "BinaryExpression",
+                                "operator": ">>",
+                                "left": {
+                                  "type": "Identifier",
+                                  "name": "$proxy_mask$",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "right": {
+                                  "type": "NumberLiteral",
+                                  "value": 1,
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "NumberLiteral",
+                              "value": 1,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "consequent": {
+                            "type": "BlockStatement",
+                            "statements": [
+                              {
+                                "type": "ExpressionStatement",
+                                "expression": {
+                                  "type": "AssignmentExpression",
+                                  "operator": "=",
+                                  "left": {
+                                    "type": "Identifier",
+                                    "name": "b",
+                                    "decorators": [],
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "right": {
+                                    "type": "UndefinedLiteral",
+                                    "value": undefined,
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "alternate": null,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        {
+                          "type": "IfStatement",
+                          "test": {
+                            "type": "BinaryExpression",
+                            "operator": "==",
+                            "left": {
+                              "type": "BinaryExpression",
+                              "operator": "&",
+                              "left": {
+                                "type": "BinaryExpression",
+                                "operator": ">>",
+                                "left": {
+                                  "type": "Identifier",
+                                  "name": "$proxy_mask$",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "right": {
+                                  "type": "NumberLiteral",
+                                  "value": 2,
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "right": {
+                                "type": "NumberLiteral",
+                                "value": 1,
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "right": {
+                              "type": "NumberLiteral",
+                              "value": 1,
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "consequent": {
+                            "type": "BlockStatement",
+                            "statements": [
+                              {
+                                "type": "ExpressionStatement",
+                                "expression": {
+                                  "type": "AssignmentExpression",
+                                  "operator": "=",
+                                  "left": {
+                                    "type": "Identifier",
+                                    "name": "c",
+                                    "decorators": [],
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "right": {
+                                    "type": "NumberLiteral",
+                                    "value": 30,
+                                    "loc": {
+                                      "start": {
+                                        "line": 1,
+                                        "column": 3
+                                      },
+                                      "end": {
+                                        "line": 1,
+                                        "column": 3
+                                      }
+                                    }
+                                  },
+                                  "loc": {
+                                    "start": {
+                                      "line": 1,
+                                      "column": 3
+                                    },
+                                    "end": {
+                                      "line": 1,
+                                      "column": 3
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              }
+                            ],
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "alternate": null,
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        },
+                        {
+                          "type": "ReturnStatement",
+                          "argument": {
+                            "type": "CallExpression",
+                            "callee": {
+                              "type": "Identifier",
+                              "name": "foo",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 1,
+                                  "column": 3
+                                },
+                                "end": {
+                                  "line": 1,
+                                  "column": 3
+                                }
+                              }
+                            },
+                            "arguments": [
+                              {
+                                "type": "Identifier",
+                                "name": "a",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              {
+                                "type": "Identifier",
+                                "name": "b",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              },
+                              {
+                                "type": "Identifier",
+                                "name": "c",
+                                "decorators": [],
+                                "loc": {
+                                  "start": {
+                                    "line": 1,
+                                    "column": 3
+                                  },
+                                  "end": {
+                                    "line": 1,
+                                    "column": 3
+                                  }
+                                }
+                              }
+                            ],
+                            "optional": false,
+                            "loc": {
+                              "start": {
+                                "line": 1,
+                                "column": 3
+                              },
+                              "end": {
+                                "line": 1,
+                                "column": 3
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 1,
+                              "column": 3
+                            },
+                            "end": {
+                              "line": 1,
+                              "column": 3
+                            }
+                          }
+                        }
+                      ],
+                      "loc": {
+                        "start": {
+                          "line": 1,
+                          "column": 3
+                        },
+                        "end": {
+                          "line": 1,
+                          "column": 3
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 1,
+                        "column": 3
+                      },
+                      "end": {
+                        "line": 1,
+                        "column": 3
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 3
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 3
+                    }
+                  }
+                },
+                "overloads": [],
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 3
+                  }
+                }
+              }
+            ],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 1
+              },
+              "end": {
+                "line": 19,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 25,
+      "column": 1
+    }
+  }
+}
+TypeError: Function already declared. [default_parameter7.ets:21:1]
diff --git a/ets2panda/test/parser/ets/default_parameter7.ets b/ets2panda/test/parser/ets/default_parameter7.ets
new file mode 100644
index 0000000000000000000000000000000000000000..490da83dbf0fbe969e33b5092425438102b5ed65
--- /dev/null
+++ b/ets2panda/test/parser/ets/default_parameter7.ets
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+function foo(...a : Int[]) : Int
+{
+    return 1;
+}
+
+function foo(a : Int, b? : String, c : Int = 30) : Int
+{
+    return 2;
+}
diff --git a/ets2panda/test/parser/ets/default_parameter_implicitly_typed_return_void-expected.txt b/ets2panda/test/parser/ets/default_parameter_implicitly_typed_return_void-expected.txt
index fcf3644024f2146e28017c9b5ad9926bf3a01826..1e351257677d50d8e4af096df8a815f5869a7b4d 100644
--- a/ets2panda/test/parser/ets/default_parameter_implicitly_typed_return_void-expected.txt
+++ b/ets2panda/test/parser/ets/default_parameter_implicitly_typed_return_void-expected.txt
@@ -690,7 +690,7 @@
                         "type": "ETSParameterExpression",
                         "name": {
                           "type": "Identifier",
-                          "name": "proxy_int",
+                          "name": "$proxy_mask$",
                           "typeAnnotation": {
                             "type": "ETSPrimitiveType",
                             "loc": {
@@ -744,7 +744,7 @@
                                 "operator": ">>",
                                 "left": {
                                   "type": "Identifier",
-                                  "name": "proxy_int",
+                                  "name": "$proxy_mask$",
                                   "decorators": [],
                                   "loc": {
                                     "start": {
@@ -928,7 +928,7 @@
                                 "operator": ">>",
                                 "left": {
                                   "type": "Identifier",
-                                  "name": "proxy_int",
+                                  "name": "$proxy_mask$",
                                   "decorators": [],
                                   "loc": {
                                     "start": {
diff --git a/ets2panda/test/parser/ets/import_tests/import_diff_paths-expected.txt b/ets2panda/test/parser/ets/import_tests/import_diff_paths-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..36509b55153e8311516dca72e239119504b13963
--- /dev/null
+++ b/ets2panda/test/parser/ets/import_tests/import_diff_paths-expected.txt
@@ -0,0 +1,491 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ImportDeclaration",
+      "source": {
+        "type": "StringLiteral",
+        "value": "./modules",
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 19
+          },
+          "end": {
+            "line": 16,
+            "column": 40
+          }
+        }
+      },
+      "specifiers": [
+        {
+          "type": "ImportSpecifier",
+          "local": {
+            "type": "Identifier",
+            "name": "C",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 10
+              },
+              "end": {
+                "line": 16,
+                "column": 11
+              }
+            }
+          },
+          "imported": {
+            "type": "Identifier",
+            "name": "C",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 10
+              },
+              "end": {
+                "line": 16,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 10
+            },
+            "end": {
+              "line": 16,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "ImportDeclaration",
+      "source": {
+        "type": "StringLiteral",
+        "value": "./modules",
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 19
+          },
+          "end": {
+            "line": 17,
+            "column": 40
+          }
+        }
+      },
+      "specifiers": [
+        {
+          "type": "ImportSpecifier",
+          "local": {
+            "type": "Identifier",
+            "name": "f",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 10
+              },
+              "end": {
+                "line": 17,
+                "column": 11
+              }
+            }
+          },
+          "imported": {
+            "type": "Identifier",
+            "name": "f",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 10
+              },
+              "end": {
+                "line": 17,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 10
+            },
+            "end": {
+              "line": 17,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 40
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "main",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 10
+                },
+                "end": {
+                  "line": 19,
+                  "column": 14
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "main",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 19,
+                      "column": 14
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "ExpressionStatement",
+                      "expression": {
+                        "type": "CallExpression",
+                        "callee": {
+                          "type": "Identifier",
+                          "name": "f",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 20,
+                              "column": 5
+                            },
+                            "end": {
+                              "line": 20,
+                              "column": 6
+                            }
+                          }
+                        },
+                        "arguments": [
+                          {
+                            "type": "ETSNewClassInstanceExpression",
+                            "typeReference": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "C",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 20,
+                                      "column": 11
+                                    },
+                                    "end": {
+                                      "line": 20,
+                                      "column": 12
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 20,
+                                    "column": 11
+                                  },
+                                  "end": {
+                                    "line": 20,
+                                    "column": 13
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 20,
+                                  "column": 11
+                                },
+                                "end": {
+                                  "line": 20,
+                                  "column": 13
+                                }
+                              }
+                            },
+                            "arguments": [],
+                            "loc": {
+                              "start": {
+                                "line": 20,
+                                "column": 7
+                              },
+                              "end": {
+                                "line": 20,
+                                "column": 15
+                              }
+                            }
+                          }
+                        ],
+                        "optional": false,
+                        "loc": {
+                          "start": {
+                            "line": 20,
+                            "column": 5
+                          },
+                          "end": {
+                            "line": 20,
+                            "column": 15
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 20,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 20,
+                          "column": 16
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 19,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 21,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 19,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 21,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 19,
+                  "column": 14
+                },
+                "end": {
+                  "line": 21,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 19,
+                "column": 1
+              },
+              "end": {
+                "line": 21,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 21,
+      "column": 2
+    }
+  }
+}
diff --git a/ets2panda/test/parser/ets/import_tests/import_diff_paths.ets b/ets2panda/test/parser/ets/import_tests/import_diff_paths.ets
new file mode 100644
index 0000000000000000000000000000000000000000..b768dbc1fc517af0a86ca3eb0b19f77873d6b0cf
--- /dev/null
+++ b/ets2panda/test/parser/ets/import_tests/import_diff_paths.ets
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 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.
+ */
+
+import { C } from "./modules/test_lib1"
+import { f } from "./modules/test_lib2"
+
+function main() {
+    f(new C());
+}
\ No newline at end of file
diff --git a/ets2panda/test/parser/ets/import_tests/modules/test_lib1-expected.txt b/ets2panda/test/parser/ets/import_tests/modules/test_lib1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8386d8940fdfa9763ec4838ac085a8774aca2486
--- /dev/null
+++ b/ets2panda/test/parser/ets/import_tests/modules/test_lib1-expected.txt
@@ -0,0 +1,290 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 14
+            },
+            "end": {
+              "line": 16,
+              "column": 15
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "constructor",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "constructor",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "constructor",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 18
+              },
+              "end": {
+                "line": 16,
+                "column": 18
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 16
+          },
+          "end": {
+            "line": 16,
+            "column": 18
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 8
+        },
+        "end": {
+          "line": 16,
+          "column": 18
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 18,
+      "column": 1
+    }
+  }
+}
diff --git a/ets2panda/test/parser/ets/import_tests/modules/test_lib1.ets b/ets2panda/test/parser/ets/import_tests/modules/test_lib1.ets
new file mode 100644
index 0000000000000000000000000000000000000000..03521fe13593e1469c909510dd335ce508a94cc4
--- /dev/null
+++ b/ets2panda/test/parser/ets/import_tests/modules/test_lib1.ets
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022 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.
+ */
+
+export class C {}
+
diff --git a/ets2panda/test/parser/ets/import_tests/modules/test_lib2-expected.txt b/ets2panda/test/parser/ets/import_tests/modules/test_lib2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..51e505772ffa256ffde70ae899396377f0748de7
--- /dev/null
+++ b/ets2panda/test/parser/ets/import_tests/modules/test_lib2-expected.txt
@@ -0,0 +1,389 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ImportDeclaration",
+      "source": {
+        "type": "StringLiteral",
+        "value": "./",
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 19
+          },
+          "end": {
+            "line": 16,
+            "column": 32
+          }
+        }
+      },
+      "specifiers": [
+        {
+          "type": "ImportSpecifier",
+          "local": {
+            "type": "Identifier",
+            "name": "C",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 10
+              },
+              "end": {
+                "line": 16,
+                "column": 11
+              }
+            }
+          },
+          "imported": {
+            "type": "Identifier",
+            "name": "C",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 10
+              },
+              "end": {
+                "line": 16,
+                "column": 11
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 10
+            },
+            "end": {
+              "line": 16,
+              "column": 11
+            }
+          }
+        }
+      ],
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 32
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "_$init$_",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "_$init$_",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 1,
+                      "column": 1
+                    },
+                    "end": {
+                      "line": 1,
+                      "column": 1
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 1,
+                    "column": 1
+                  },
+                  "end": {
+                    "line": 1,
+                    "column": 1
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 1,
+                  "column": 1
+                },
+                "end": {
+                  "line": 1,
+                  "column": 1
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "f",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 17
+                },
+                "end": {
+                  "line": 17,
+                  "column": 18
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "f",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 18
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "ETSParameterExpression",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "c",
+                      "typeAnnotation": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "C",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 17,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 17,
+                                "column": 23
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 17,
+                              "column": 22
+                            },
+                            "end": {
+                              "line": 17,
+                              "column": 24
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 22
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 24
+                          }
+                        }
+                      },
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 19
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 24
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 19
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 24
+                      }
+                    }
+                  }
+                ],
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 25
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 27
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 18
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 27
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 18
+                },
+                "end": {
+                  "line": 17,
+                  "column": 27
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 8
+              },
+              "end": {
+                "line": 17,
+                "column": 27
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 1,
+            "column": 1
+          },
+          "end": {
+            "line": 1,
+            "column": 1
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 1,
+          "column": 1
+        },
+        "end": {
+          "line": 1,
+          "column": 1
+        }
+      }
+    }
+  ],
+  "loc": {
+    "start": {
+      "line": 1,
+      "column": 1
+    },
+    "end": {
+      "line": 19,
+      "column": 1
+    }
+  }
+}
diff --git a/ets2panda/test/parser/ets/import_tests/modules/test_lib2.ets b/ets2panda/test/parser/ets/import_tests/modules/test_lib2.ets
new file mode 100644
index 0000000000000000000000000000000000000000..858acdc0f8047a12b81fb01915405adba4fa3b0a
--- /dev/null
+++ b/ets2panda/test/parser/ets/import_tests/modules/test_lib2.ets
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2022 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.
+ */
+
+import { C } from "./test_lib1"
+export function f(c: C) {}
+
diff --git a/ets2panda/test/parser/ets/rest_parameter_02-expected.txt b/ets2panda/test/parser/ets/rest_parameter_02-expected.txt
index 9dcbe17e90d034af530d6b66d7dddac9ec318cbc..87a53b8d5ad3652e22ff54d040f3e644ec706331 100644
--- a/ets2panda/test/parser/ets/rest_parameter_02-expected.txt
+++ b/ets2panda/test/parser/ets/rest_parameter_02-expected.txt
@@ -793,7 +793,7 @@
                         "type": "ETSParameterExpression",
                         "name": {
                           "type": "Identifier",
-                          "name": "proxy_int",
+                          "name": "$proxy_mask$",
                           "typeAnnotation": {
                             "type": "ETSPrimitiveType",
                             "loc": {
@@ -860,7 +860,7 @@
                                 "operator": ">>",
                                 "left": {
                                   "type": "Identifier",
-                                  "name": "proxy_int",
+                                  "name": "$proxy_mask$",
                                   "decorators": [],
                                   "loc": {
                                     "start": {
diff --git a/ets2panda/test/runtime/ets/BigInt.ets b/ets2panda/test/runtime/ets/BigInt.ets
new file mode 100644
index 0000000000000000000000000000000000000000..3366aa993e686418bdc78d7b2fe6fb5e47718934
--- /dev/null
+++ b/ets2panda/test/runtime/ets/BigInt.ets
@@ -0,0 +1,421 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+function test_type(): void {
+    let num0 = 0n;
+    let num1 = 100_100_100_100_100_100n
+    let num2 = -57896044618658097711785492504343953926634992332820282019728792003956564819967n
+
+    assert (num0 instanceof bigint)
+    assert (num1 instanceof bigint)
+    assert (num2 instanceof bigint)
+}
+
+function test_assignment(): void {
+    let a = -24059059045444224545405903904190343043049209420234290480n
+    let b = a
+    assert (a instanceof bigint)
+    assert (b instanceof bigint)
+    assert (a.toString() == b.toString());
+
+    a = 123n;
+    assert (a instanceof bigint)
+    assert (a.toString() == "123");
+    assert (a == 123n);
+
+    const zero = 0n;
+    let c = zero;
+    assert (zero instanceof bigint)
+    assert (c instanceof bigint)
+    assert (zero.toString() == c.toString());
+}
+
+function test_compare(): void {
+    const a = 24400569094091093912039019089543850580328542852805043n
+    const b = 34034240244909504590902901119302940942904944029040950n
+    const c = 140044940590459049067274048929058908989042385n
+    const d = 44493059209094029409209402940924902n
+
+    // Expecting successfull compilation
+    // NOTE(kkonsw): add asserts
+    44493059209094029409209402940924902n < 140044940590459049067274048929058908989042385n
+    44493059209094029409209402940924902n < a
+    a < 34034240244909504590902901119302940942904944029040950n
+    a < b
+
+    44493059209094029409209402940924902n <= 140044940590459049067274048929058908989042385n
+    44493059209094029409209402940924902n <= a
+    a <= 34034240244909504590902901119302940942904944029040950n
+    a <= b
+
+    44493059209094029409209402940924902n <= 44493059209094029409209402940924902n
+    24400569094091093912039019089543850580328542852805043n <= a
+    a <= 24400569094091093912039019089543850580328542852805043n
+    a <= a
+
+    40044940590459049067274048929058908989042385n > 44493059209094029409209402940924902n
+    34034240244909504590902901119302940942904944029040950n > a
+    a > 140044940590459049067274048929058908989042385n
+    b > a
+
+    40044940590459049067274048929058908989042385n >= 44493059209094029409209402940924902n
+    34034240244909504590902901119302940942904944029040950n >= a
+    a >= 140044940590459049067274048929058908989042385n
+    b >= a
+
+    44493059209094029409209402940924902n <= 44493059209094029409209402940924902n
+    24400569094091093912039019089543850580328542852805043n <= a
+    a <= 24400569094091093912039019089543850580328542852805043n
+    a <= a
+}
+
+function test_literals() : void {
+    let num0 = 0n
+    assert (num0.toString() == "0")
+
+    let num1 = 127n
+    assert (num1.toString() == "127")
+
+    let num2 = 32767n
+    assert (num2.toString() == "32767")
+
+    let num3 = 2147483647n
+    assert (num3.toString() == "2147483647")
+
+    let num4 = 9223372036854775807n
+    assert (num4.toString() == "9223372036854775807")
+
+    let num5 = 170141183460469231731687303715884105727n
+    assert (num5.toString() == "170141183460469231731687303715884105727")
+
+    let num6 = 57896044618658097711785492504343953926634992332820282019728792003956564819967n
+    assert (num6.toString() == "57896044618658097711785492504343953926634992332820282019728792003956564819967")
+
+    let num1_n = -128n
+    assert (num1_n.toString() == "-128")
+
+    let num2_n = -32768n
+    assert (num2_n.toString() == "-32768")
+
+    let num3_n = -2147483648n
+    assert (num3_n.toString() == "-2147483648")
+
+    let num4_n = -9223372036854775808n
+    assert (num4_n.toString() == "-9223372036854775808")
+
+    let num5_n = -170141183460469231731687303715884105728n
+    assert (num5_n.toString() == "-170141183460469231731687303715884105728")
+
+    let num6_n = -57896044618658097711785492504343953926634992332820282019728792003956564819968n
+    assert (num6_n.toString() == "-57896044618658097711785492504343953926634992332820282019728792003956564819968")
+
+    let num1_sep = 1_991_653_125_841_217_555_434419_9091_123000000_3_3313_5775_3282_29n
+    assert (num1_sep.toString() == "1_991_653_125_841_217_555_434419_9091_123000000_3_3313_5775_3282_29")
+
+    let num2_sep = -422_12_3333_9844_3333_3443_34111_43434_1111_11_1_3_3_411909_990081n
+    assert (num2_sep.toString() == "-422_12_3333_9844_3333_3443_34111_43434_1111_11_1_3_3_411909_990081")
+
+    let num0_t: bigint = 0n
+    assert (num0_t.toString() == "0")
+
+    let num1_t: bigint = 57896044618658097711785492504343953926634992332820282019728792003956564819967n
+    assert (num1_t.toString() == "57896044618658097711785492504343953926634992332820282019728792003956564819967")
+
+    let num2_t: bigint = -9223372036854775808n
+    assert (num2_t.toString() == "-9223372036854775808")
+
+    let num3_t: bigint = 1_991_653_125_841_217_555_434419_9091_123000000_3_3313_5775_3282_29n
+    assert (num3_t.toString() == "1_991_653_125_841_217_555_434419_9091_123000000_3_3313_5775_3282_29")
+
+    let num4_t: bigint = -422_12_3333_9844_3333_3443_34111_43434_1111_11_1_3_3_411909_990081n
+    assert (num4_t.toString() == "-422_12_3333_9844_3333_3443_34111_43434_1111_11_1_3_3_411909_990081")
+
+    const num0_c = 0n
+    assert (num0_c.toString() == "0")
+
+    const num1_c = 1267650600228229401496703205376n
+    assert (num1_c.toString() == "1267650600228229401496703205376")
+
+    const num2_c = -1427247692705959881058285969449495136382746624n
+    assert (num2_c.toString() == "-1427247692705959881058285969449495136382746624")
+
+    const num3_c = 4_000_000_000_000_000_000_000_100n
+    assert (num3_c.toString() == "4_000_000_000_000_000_000_000_100")
+
+    const num4_c: bigint = -7777777_666666_55555_4444_333_22_1n
+    assert (num4_c.toString() == "-7777777_666666_55555_4444_333_22_1")
+}
+
+function test_cast(): void {
+    const v = 1559053
+    const b: byte = 44
+    const s: short = -17600
+    const i: int = 1150483640
+    const l: long = -8223372036854775808
+
+    // NOTE(kkonsw): casts currently do not work
+}
+
+function test_bigint_methods(): void {
+    const b: byte = 44
+    const s: short = -17600
+    const i: int = 1150483640
+    const l: long = -8223372036854775808
+
+    /* Testing BigInt constructor */
+    let n0 = new BigInt(0)
+    assert n0 == 0n
+    assert(n0.toString() == "0")
+
+    let n1 = new BigInt(654093)
+    assert(n1.toString() == "654093")
+    assert n1 == 654093n
+
+    let n2 = new BigInt(b)
+    assert(n2.toString() == "44")
+    assert n2 == 44n
+
+    let n3 = new BigInt(s)
+    assert(n3.toString() == "-17600")
+    assert n3 == -17600n
+
+    let n4 = new BigInt(i)
+    assert(n4.toString() == "1150483640")
+    assert n4 == 1150483640n
+
+    let n5 = new BigInt(l)
+    assert(n5.toString() == "-8223372036854775808")
+    assert n5 == -8223372036854775808n
+
+    let dec = new BigInt("-12392320390239294724747283477947923471101032")
+    assert dec == -12392320390239294724747283477947923471101032n
+
+    // NOTE(kkonsw): asIntN not implemented
+    /* Testing asIntN() static method */
+
+    // NOTE(kkonsw): asUintN not implemented
+    /* Testing asUintN() static method */
+}
+
+function test_unary(): void {
+    let n = -128n
+    assert (n.toString() == "-128")
+
+    let a = 123n;
+    assert(a == 123n);
+    assert(a.toString() == "123");
+
+    a = -123n;
+    assert(a == -123n);
+    assert(a.toString() == "-123");
+
+    a = 123n
+    assert(a == 123n);
+    assert(a.toString() == "123");
+
+    a = -a;
+    assert(a == -123n);
+    assert(a.toString() == "-123");
+
+    a = -a;
+    assert(a == 123n);
+    assert(a.toString() == "123");
+
+    let e: bigint;
+    assert(a == 123n);
+    assert(a.toString() == "123");
+    e = -a;
+
+    // Check that original value does not change
+    assert(a == 123n);
+    assert(a.toString() == "123");
+    assert(e == -123n);
+    assert(e.toString() == "-123");
+    e = a;
+    assert(e == 123n);
+    assert(e.toString() == "123");
+
+    let b = -123n;
+    assert(b == -123n)
+    assert(b.toString() == "-123");
+
+    let c = -(123n);
+    assert(c == -123n)
+    assert(c.toString() == "-123");
+
+    // Double unary minus
+    let d = -(-123n);
+    assert(d == 123n);
+    assert(d.toString() == "123");
+
+    // Triple unary minux
+    let f = -(-(-123n));
+    assert(f == -123n);
+    assert(f.toString() == "-123");
+
+    a = new BigInt(321);
+    assert(a.toString() == "321")
+    assert(a == 321n)
+
+    b = -a;
+    assert(a.toString() == "321")
+    assert(a == 321n)
+    assert(b == -321n);
+    assert(b.toString() == "-321");
+}
+
+function test_multiplication(): void {
+    const a = 23443495146314363289895841n
+    const b = 245000234343499329134n
+    const c = -245000234343499329134n
+
+    /* Multiplication testing (*) */
+    978667632325344545n * 4534000101n 
+    a * b 
+    a * c 
+    a * 0n
+    c * 0n
+    
+    /* Division testing (/) */
+    39735235034886462n / 89221422n 
+    a / b
+    a / c
+    0n / a
+
+    let err = false;
+    try {
+        a / 0n
+    } catch (e) {
+        if (e instanceof ArithmeticException) {
+            err = true
+        }
+    }
+
+    /* Remainder of the division (%) */
+    493433405047004109n / 111114444n 
+    a / b
+    0n / a
+
+    err = false;
+    try {
+        a % 0n
+    } catch (e) {
+        if (e instanceof ArithmeticException) {
+            err = true
+        }
+    }
+}
+
+function test_addition_1(): void {
+    const a = 97567789101304567800013210071n
+    const b = -533923234343411557221n
+    const c = 0n;
+
+    /* Minus testing (-) */
+    assert (-a == -97567789101304567800013210071n)
+    assert (-b == 533923234343411557221n)
+    assert (-c == -0n)
+    assert (-(-a) == a)
+    assert (-(-b) == b)
+    assert (-(-c) == c)
+
+    /* Plus testing (+) */
+}
+
+function test_addition_2(): void {
+    const a = 18446744073709551616n;
+    const b = 36893488147419103232n;
+    const c = -10000000000000000000n;
+    
+    /* Addition testing (+) */
+    999_999_999_999_999n + 1n
+    a + b
+    a + a
+    a + c
+    a + b + b
+}
+
+function test_subtraction(): void {
+    const a = 18446744073709551616n;
+    const b = 36893488147419103232n;
+    const c = -10000000000000000000n;
+
+    // /* Subtraction testing (-) */
+    999_999_999_999_999n - 1n
+    b - a
+    a - b
+    b - a - a
+}
+
+function test_inc_dec(): void {
+    const a = 340282366920938463463374607431768211456n
+    const b = -2313455919991034304490n
+    
+    /* Increment testing */
+    /* Decrement testing */
+}
+
+function test_shift(): void {
+    const a = 245599210405555256299145n
+    
+    /* Testing left shift (<<) */
+    a << 100n
+    a << 0n
+
+    /* Testing right shift (>>) */
+    a >> 60n
+    a >> 0n
+
+    /* Testing unsigned right shift (>>>) */
+}
+
+function test_bitwise(): void {
+    const a = 123456789123456789123456789123456789123456789123456789n
+    let b = 123456790n
+    const zero = 0n
+
+    /* Testing bitwise NOT (~) */
+    
+    /* Testing bitwise AND (&) */
+    a & 0n
+    a & a
+
+    /* Testing bitwise XOR (^) */
+    a ^ 0n 
+    a ^ a
+    a ^ b
+
+    /* Testing bitwise OR (|) */
+    a | 0n 
+    a | a 
+    a | b
+}
+
+function main() : void {
+    test_type();
+    test_assignment();
+    test_compare();
+    test_literals();
+    test_cast();
+    test_bigint_methods();
+    test_unary();
+    test_multiplication();
+    test_addition_1();
+    test_addition_2();
+    test_subtraction();
+    test_inc_dec();
+    test_shift();
+    test_bitwise();
+}
diff --git a/ets2panda/test/runtime/ets/DefaultParam_1.ets b/ets2panda/test/runtime/ets/DefaultParam_1.ets
index af964ea38290210115ffa3634a3cb9ead5e0d2fa..72368a9610877e34c916d6490be473bf4c892aca 100644
--- a/ets2panda/test/runtime/ets/DefaultParam_1.ets
+++ b/ets2panda/test/runtime/ets/DefaultParam_1.ets
@@ -35,16 +35,6 @@ function main():void{
 
     assert foo15(10,5) == 20;
     assert foo16(10,5) == 30;
-
-
-    assert foo17(1,2) == 1;
-    assert foo17(1,9999999999) == 2;
-
-    assert foo18(1,2) == 1;
-    assert foo18(1,false) == 2;
-
-    assert foo19(1,2) == 1;
-    assert foo19(1,c'a') == 2;
 }
 
 function foo1(a : int = 10) : int {
@@ -96,27 +86,3 @@ function foo15(a : int, b : int, c : int = 5) : int {
 function foo16(a : int, b : int, c : int = 10, d : int = 5) : int {
     return a + b + c + d;
 }
-
-function foo17(a : int, b : int = 20, c : int = 30) : int {
-    return 1;
-}
-
-function foo17(a : int, b : long = 20, c : int = 30) : int {
-    return 2;
-}
-
-function foo18(a : int, b : int = 20, c : int = 30) : int {
-    return 1;
-}
-
-function foo18(a : int, b : boolean = true, c : int = 30) : int {
-    return 2;
-}
-
-function foo19(a : int, b : int = 20, c : int = 30) : int {
-    return 1;
-}
-
-function foo19(a : int, b : char = c'a', c : int = 30) : int {
-    return 2;
-}
diff --git a/ets2panda/test/runtime/ets/DefaultParam_2.ets b/ets2panda/test/runtime/ets/DefaultParam_2.ets
index d00f90d1989f11f944f16efa9f74c75462dcd8e8..c82f36b460aab51764a5f0cb312c113e8ea06503 100644
--- a/ets2panda/test/runtime/ets/DefaultParam_2.ets
+++ b/ets2panda/test/runtime/ets/DefaultParam_2.ets
@@ -43,15 +43,6 @@ function main():void{
 
     assert foo15(new Int(10),new Int(5)) == 20;
     assert foo16(new Int(10),new Int(5)) == 30;
-
-    assert foo17(new Int(1),new Int(2)) == 1;
-    assert foo17(new Int(1),new Long(9999999999)) == 2;
-
-    assert foo18(new Int(1),new Int(2)) == 1;
-    assert foo18(new Int(1),new Boolean(true)) == 2;
-
-    assert foo19(new Int(1),new Int(1)) == 1;
-    assert foo19(new Int(1),"a") == 2;
 }
 
 function foo1(a : Int = 10) : Int {
@@ -142,27 +133,3 @@ function foo15(a : Int, b : Int, c : Int = 5) : Int {
 function foo16(a : Int, b : Int, c : Int = 10, d : Int = 5) : Int {
     return a + b + c + d;
 }
-
-function foo17(a : Int, b : Int = 20, c : Int = 30) : Int {
-    return 1;
-}
-
-function foo17(a : Int, b : Long = 9999999999, c : Int = 30) : Int {
-    return 2;
-}
-
-function foo18(a : Int, b : Int = 20, c : Int = 30) : Int {
-    return 1;
-}
-
-function foo18(a : Int, b : Boolean = true, c : Int = 30) : Int {
-    return 2;
-}
-
-function foo19(a : Int, b : Int = 20, c : Int = 30) : Int {
-    return 1;
-}
-
-function foo19(a : Int, b : string = "a", c : Int = 30) : Int {
-    return 2;
-}
diff --git a/ets2panda/test/runtime/ets/DefaultParam_4.ets b/ets2panda/test/runtime/ets/DefaultParam_4.ets
index 696647a3b79e20d33363daf183484a23ef6ab8ba..38a37046f5d2a4536f7e35464002c74a2b7cfac5 100644
--- a/ets2panda/test/runtime/ets/DefaultParam_4.ets
+++ b/ets2panda/test/runtime/ets/DefaultParam_4.ets
@@ -45,15 +45,6 @@ function main():void{
 
     assert boo.foo15(new Int(10),new Int(5)) == 20;
     assert boo.foo16(new Int(10),new Int(5)) == 30;
-
-    assert boo.foo17(new Int(1),new Int(2)) == 1;
-    assert boo.foo17(new Int(1),new Long(9999999999)) == 2;
-
-    assert boo.foo18(new Int(1),new Int(2)) == 1;
-    assert boo.foo18(new Int(1),new Boolean(true)) == 2;
-
-    assert boo.foo19(new Int(1),new Int(1)) == 1;
-    assert boo.foo19(new Int(1),"a") == 2;
 }
 
 class bar {
@@ -145,28 +136,4 @@ class bar {
     foo16(a : Int, b : Int, c : Int = 10, d : Int = 5) : Int {
         return a + b + c + d;
     }
-
-    foo17(a : Int, b : Int = 20, c : Int = 30) : Int {
-        return 1;
-    }
-
-    foo17(a : Int, b : Long = 9999999999, c : Int = 30) : Int {
-        return 2;
-    }
-
-    foo18(a : Int, b : Int = 20, c : Int = 30) : Int {
-        return 1;
-    }
-
-    foo18(a : Int, b : Boolean = true, c : Int = 30) : Int {
-        return 2;
-    }
-
-    foo19(a : Int, b : Int = 20, c : Int = 30) : Int {
-        return 1;
-    }
-
-    foo19(a : Int, b : string = "a", c : Int = 30) : Int {
-        return 2;
-    }
 }
diff --git a/ets2panda/test/runtime/ets/StringBase64.ets b/ets2panda/test/runtime/ets/StringBase64.ets
index 17e894db3d19df9f7cf25ab5aa797c8f813d13d0..ebca0d923bae6144cba88c3a8c91888ddf41cc3d 100644
--- a/ets2panda/test/runtime/ets/StringBase64.ets
+++ b/ets2panda/test/runtime/ets/StringBase64.ets
@@ -67,7 +67,7 @@ export class StringBase64  {
         }
         return result.toString();
     }
-    n1 : int = 8192;
+    n1 : int = 4096;
     n2 : int = 16384;
     public run(): void {
         let str : String = "";
diff --git a/ets2panda/test/runtime/ets/autoboxing.ets b/ets2panda/test/runtime/ets/autoboxing.ets
new file mode 100644
index 0000000000000000000000000000000000000000..f66dbbb41beb1e59fbe8b454950c4bdca77c0a9d
--- /dev/null
+++ b/ets2panda/test/runtime/ets/autoboxing.ets
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+function foo_i(value: int): string {
+    return value.toString();
+}
+
+function foo_d(value: double): string {
+    return value.toString();
+}
+
+function foo_n(value: number): string {
+    return value.toString();
+}
+
+function main(): void {
+    let str_i: string = foo_i(4);
+    assert str_i == "4";
+    let str_d: string = foo_d(3.14);
+    assert str_d == "3.14";
+    let str_n: string = foo_n(5);
+    assert str_n == "5";
+}
\ No newline at end of file
diff --git a/ets2panda/test/runtime/ets/condition-with-boolean-reference.ets b/ets2panda/test/runtime/ets/condition-with-boolean-reference.ets
index afeab4d42883c20242e0282d38709e2920672987..1acb9754930406a5667c16a6545c776d8dec84ac 100644
--- a/ets2panda/test/runtime/ets/condition-with-boolean-reference.ets
+++ b/ets2panda/test/runtime/ets/condition-with-boolean-reference.ets
@@ -14,7 +14,7 @@
  */
 
 function main() : void {
-  let cond: Boolean = true;
+  let cond: boolean = true;
 
   // Check conditional expression
   let a: String = "foo";
@@ -39,13 +39,14 @@ function main() : void {
   assert(i == 3);
 
   // Check while statement
-  while (cond) {
-    cond = false;
+  let while_cond = true
+  while (while_cond) {
+    while_cond = !cond;
   }
-  assert (cond == false);
+  assert (while_cond == false);
 
   // Check do-while statement
   do {
-    assert (cond == false);
-  } while (cond);
+    assert (while_cond == false);
+  } while (while_cond);
 }
diff --git a/ets2panda/test/runtime/ets/conversion-char-boolean.ets b/ets2panda/test/runtime/ets/conversion-char-boolean.ets
index baa0ddaf614ab8e97a99219405246df2547f0e43..76f9ea8e29cc817dac783009e3bda81123d9b699 100644
--- a/ets2panda/test/runtime/ets/conversion-char-boolean.ets
+++ b/ets2panda/test/runtime/ets/conversion-char-boolean.ets
@@ -20,7 +20,7 @@ function check(): Boolean {
 
 function main(): void {
   let x: Boolean = false;
-  assert !(x && check());
+  assert (x || check());
 
   let y: Char = c'a';
   assert (y != c'b');
diff --git a/ets2panda/test/runtime/ets/default_parameters.ets b/ets2panda/test/runtime/ets/default_parameters.ets
new file mode 100644
index 0000000000000000000000000000000000000000..a660a80c0402aacf32fb2b3925706a3618af51aa
--- /dev/null
+++ b/ets2panda/test/runtime/ets/default_parameters.ets
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2021-2023 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.
+ */
+
+function foo(a: int = 3, b: int = 5): int {
+  return a * 10 + b;
+}
+
+class C {
+  x: int;
+  y: int;
+
+  constructor (a: int = 3, b: int = 5) {
+    this.x = a;
+    this.y = b;
+  }
+}
+
+function main(): void {
+
+  let res = foo(5, 7);
+  assert (res == 57);
+
+  res = foo(7);
+  assert (res == 75);
+
+  res = foo();
+  assert (res == 35);
+
+  let c0 = new C();
+  assert (c0.x == 3 && c0.y == 5);
+
+  let c1 = new C(7);
+  assert (c1.x == 7 && c1.y == 5);
+
+  let c2 = new C(5, 7);
+  assert (c2.x == 5 && c2.y == 7);
+}
diff --git a/ets2panda/test/runtime/ets/exdended_conditional_expression_float.ets b/ets2panda/test/runtime/ets/exdended_conditional_expression_float.ets
new file mode 100644
index 0000000000000000000000000000000000000000..1d07e495518354a1bbedce318bfb96313ac43886
--- /dev/null
+++ b/ets2panda/test/runtime/ets/exdended_conditional_expression_float.ets
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+function main(): int {
+    let res: int = 0.1 ? 0 : 1
+    return res
+}
\ No newline at end of file
diff --git a/ets2panda/test/runtime/ets/extended_conditional_expression_string.ets b/ets2panda/test/runtime/ets/extended_conditional_expression_string.ets
new file mode 100644
index 0000000000000000000000000000000000000000..f02379770060f14cd733ca1f152b4bf454508f46
--- /dev/null
+++ b/ets2panda/test/runtime/ets/extended_conditional_expression_string.ets
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+
+function fun(s: Object) : boolean {
+    if (s) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+
+function main(): int {
+    let emptyString = "";
+    if (fun(emptyString)) {
+        return 1;
+    } else {
+        return 0
+    }
+}
\ No newline at end of file
diff --git a/ets2panda/test/runtime/ets/number-from-narrow-prim.ets b/ets2panda/test/runtime/ets/number-from-narrow-prim.ets
new file mode 100644
index 0000000000000000000000000000000000000000..0c4744297c403b3b804c44fe10538ff22b76584b
--- /dev/null
+++ b/ets2panda/test/runtime/ets/number-from-narrow-prim.ets
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 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.
+ *
+ *
+ * Based on https://gitee.com/openharmony/arkcompiler_ets_frontend/issues/I8EZ44
+ */
+
+
+function main() {
+    let n: Number = 5
+
+    assert n == 5
+}
diff --git a/ets2panda/test/runtime/ets/unboxingBooleanConversion.ets b/ets2panda/test/runtime/ets/unboxingBooleanConversion.ets
index 4ee6904ae13e4915f4f2a1e0a5dd715bec9705a6..23ae74c084ab06775be988e3359841dcce893b3c 100644
--- a/ets2panda/test/runtime/ets/unboxingBooleanConversion.ets
+++ b/ets2panda/test/runtime/ets/unboxingBooleanConversion.ets
@@ -24,7 +24,7 @@ function returnRefBool(a: boolean): Boolean {
 function main(): void {
     let a: Boolean = false;
 
-    let b: Boolean = a || returnTrue();
+    let b: Boolean = a && returnTrue();
     assert b == true
 
     let c: Boolean = returnRefBool(a || returnRefBool(returnTrue() && returnRefBool(a)));
diff --git a/ets2panda/test/union_types_4-expected.txt b/ets2panda/test/union_types_4-expected.txt
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/ets2panda/util/helpers.cpp b/ets2panda/util/helpers.cpp
index aafd8d43e718abdef49471b48b332b09d574e6cc..b1f4abe0f922c5c9d3b8254d34c7016f3ec9581a 100644
--- a/ets2panda/util/helpers.cpp
+++ b/ets2panda/util/helpers.cpp
@@ -43,6 +43,7 @@
 #include "ir/module/importDeclaration.h"
 #include "lexer/token/letters.h"
 #include "libpandabase/utils/utf.h"
+#include "libpandabase/os/filesystem.h"
 
 namespace panda::es2panda::util {
 // Helpers
@@ -169,6 +170,40 @@ bool Helpers::IsRelativePath(const std::string &path)
     return ((path.find(current_dir_reference) == 0) || (path.find(parent_dir_reference) == 0));
 }
 
+std::string Helpers::GetAbsPath(const std::string &path)
+{
+    std::string full_file_path = path;
+    std::string import_extension;
+    if (!panda::os::file::File::IsRegularFile(path) && (panda::os::GetAbsolutePath(path).empty())) {
+        import_extension = ".ets";
+        full_file_path = path + import_extension;
+        if (!panda::os::file::File::IsRegularFile(full_file_path)) {
+            import_extension = ".ts";
+            full_file_path = path + import_extension;
+            if (!panda::os::file::File::IsRegularFile(full_file_path)) {
+                return path;
+            }
+        }
+    }
+    std::string abs_file_path = panda::os::GetAbsolutePath(full_file_path);
+    abs_file_path.erase(abs_file_path.find(import_extension), import_extension.size());
+    return abs_file_path;
+}
+
+bool Helpers::IsRealPath(const std::string &path)
+{
+    if (!panda::os::file::File::IsRegularFile(path) && (panda::os::GetAbsolutePath(path).empty())) {
+        auto import_extension = ".ets";
+        if (!panda::os::file::File::IsRegularFile(path + import_extension)) {
+            import_extension = ".ts";
+            if (!panda::os::file::File::IsRegularFile(path + import_extension)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 const ir::ScriptFunction *Helpers::GetContainingConstructor(const ir::AstNode *node)
 {
     const ir::ScriptFunction *iter = GetContainingFunction(node);
diff --git a/ets2panda/util/helpers.h b/ets2panda/util/helpers.h
index 2611e7914153a1febb170e0ce3c5d93883de6292..bd32ed03a52f53ddab63ad9ec57bdb8bb4cf6f15 100644
--- a/ets2panda/util/helpers.h
+++ b/ets2panda/util/helpers.h
@@ -79,6 +79,8 @@ public:
     static util::StringView ToStringView(ArenaAllocator *allocator, int32_t number);
     static util::StringView ToStringView(ArenaAllocator *allocator, uint32_t number);
     static bool IsRelativePath(const std::string &path);
+    static bool IsRealPath(const std::string &path);
+    static std::string GetAbsPath(const std::string &path);
 
     static const ir::ScriptFunction *GetContainingConstructor(const ir::AstNode *node);
     static const ir::ScriptFunction *GetContainingConstructor(const ir::ClassProperty *node);
diff --git a/ets2panda/varbinder/ETSBinder.cpp b/ets2panda/varbinder/ETSBinder.cpp
index d12f33d16ebc46442351abaf4cbce8080d666b16..61c93cd5b95543c6bf55f05b30c6d8353eeb0630 100644
--- a/ets2panda/varbinder/ETSBinder.cpp
+++ b/ets2panda/varbinder/ETSBinder.cpp
@@ -582,6 +582,23 @@ varbinder::Variable *ETSBinder::FindStaticBinding(const ArenaVector<parser::Prog
     return result->second;
 }
 
+ArenaVector<parser::Program *> ETSBinder::GetExternalProgram(const util::StringView &source_name,
+                                                             const ir::StringLiteral *import_path)
+{
+    const auto &ext_records = global_record_table_.Program()->ExternalSources();
+    auto record_res = [this, ext_records, source_name]() {
+        auto res = ext_records.find(source_name);
+        return (res != ext_records.end()) ? res : ext_records.find(GetResolvedImportPath(source_name));
+    }();
+    if (record_res == ext_records.end()) {
+        ThrowError(import_path->Start(), "Cannot find import: " + std::string(source_name));
+    }
+
+    ASSERT(!record_res->second.empty());
+
+    return record_res->second;
+}
+
 void ETSBinder::AddSpecifiersToTopBindings(ir::AstNode *const specifier, const ir::ETSImportDeclaration *const import)
 {
     const ir::StringLiteral *const import_path = import->Source();
@@ -591,18 +608,20 @@ void ETSBinder::AddSpecifiersToTopBindings(ir::AstNode *const specifier, const i
         return;
     }
 
-    const auto &ext_records = global_record_table_.Program()->ExternalSources();
-    const util::StringView source_name =
-        (import->Module() == nullptr)
-            ? import_path->Str()
-            : util::UString(import_path->Str().Mutf8() + import->Module()->Str().Mutf8(), Allocator()).View();
-    const auto record_res = ext_records.find(source_name);
-    if (record_res == ext_records.end()) {
-        ThrowError(import_path->Start(), "Cannot find import: " + std::string(source_name));
-    }
+    const util::StringView source_name = [import, import_path, this]() {
+        if (import->Module() == nullptr) {
+            return import_path->Str();
+        }
+        char path_delimiter = panda::os::file::File::GetPathDelim().at(0);
+        auto str_import_path = import_path->Str().Mutf8();
+        if (str_import_path.find(path_delimiter) == (str_import_path.size() - 1)) {
+            return util::UString(str_import_path + import->Module()->Str().Mutf8(), Allocator()).View();
+        }
+        return util::UString(str_import_path + path_delimiter + import->Module()->Str().Mutf8(), Allocator()).View();
+    }();
 
-    ASSERT(!record_res->second.empty());
-    const auto *const import_program = record_res->second.front();
+    auto record = GetExternalProgram(source_name, import_path);
+    const auto *const import_program = record.front();
     const auto *const import_global_scope = import_program->GlobalScope();
     const auto &global_bindings = import_global_scope->Bindings();
 
@@ -618,7 +637,7 @@ void ETSBinder::AddSpecifiersToTopBindings(ir::AstNode *const specifier, const i
         return;
     }
 
-    if (AddImportSpecifiersToTopBindings(specifier, global_bindings, import, record_res->second)) {
+    if (AddImportSpecifiersToTopBindings(specifier, global_bindings, import, record)) {
         return;
     }
 
@@ -628,7 +647,7 @@ void ETSBinder::AddSpecifiersToTopBindings(ir::AstNode *const specifier, const i
     auto item = std::find_if(global_bindings.begin(), global_bindings.end(), predicate_func);
     if (item == global_bindings.end()) {
         insert_foreign_binding(specifier->AsImportDefaultSpecifier()->Local()->Name(),
-                               FindStaticBinding(record_res->second, import_path));
+                               FindStaticBinding(record, import_path));
         return;
     }
 
diff --git a/ets2panda/varbinder/ETSBinder.h b/ets2panda/varbinder/ETSBinder.h
index 82f49cd9ae5f2af13edfb44d2e5ef50da9a4109b..48d7cf964ec457b0a99015b9c082b3f6925b2ac5 100644
--- a/ets2panda/varbinder/ETSBinder.h
+++ b/ets2panda/varbinder/ETSBinder.h
@@ -43,7 +43,8 @@ public:
           dynamic_imports_(Allocator()->Adapter()),
           lambda_objects_(Allocator()->Adapter()),
           dynamic_import_vars_(Allocator()->Adapter()),
-          import_specifiers_(Allocator()->Adapter())
+          import_specifiers_(Allocator()->Adapter()),
+          resolved_import_pathes_map_(Allocator()->Adapter())
     {
         InitImplicitThisParam();
     }
@@ -119,6 +120,8 @@ public:
     void BuildImportDeclaration(ir::ETSImportDeclaration *decl);
     void BuildETSNewClassInstanceExpression(ir::ETSNewClassInstanceExpression *class_instance);
     void AddSpecifiersToTopBindings(ir::AstNode *specifier, const ir::ETSImportDeclaration *import);
+    ArenaVector<parser::Program *> GetExternalProgram(const util::StringView &source_name,
+                                                      const ir::StringLiteral *import_path);
     bool AddImportNamespaceSpecifiersToTopBindings(ir::AstNode *specifier,
                                                    const varbinder::Scope::VariableMap &global_bindings,
                                                    const parser::Program *import_program,
@@ -184,6 +187,26 @@ public:
         default_export_ = default_export;
     }
 
+    const ArenaUnorderedMap<util::StringView, util::StringView> &ResolvedImportPathesMap() const
+    {
+        return resolved_import_pathes_map_;
+    }
+
+    const util::StringView &GetResolvedImportPath(const util::StringView &path) const
+    {
+        ASSERT(resolved_import_pathes_map_.find(path) != resolved_import_pathes_map_.end());
+
+        return resolved_import_pathes_map_.find(path)->second;
+    }
+
+    void FillResolvedImportPathes(const std::unordered_map<std::string, std::string> &map, ArenaAllocator *allocator)
+    {
+        for (const auto &path : map) {
+            resolved_import_pathes_map_.emplace(util::UString(path.first, allocator).View(),
+                                                util::UString(path.second, allocator).View());
+        }
+    }
+
     bool IsDynamicModuleVariable(const Variable *var) const;
     bool IsDynamicNamespaceVariable(const Variable *var) const;
     const DynamicImportData *DynamicImportDataForVar(const Variable *var) const;
@@ -218,6 +241,7 @@ private:
     DynamicImportVariables dynamic_import_vars_;
     ir::Identifier *this_param_ {};
     ArenaVector<std::pair<util::StringView, util::StringView>> import_specifiers_;
+    ArenaUnorderedMap<util::StringView, util::StringView> resolved_import_pathes_map_;
     ir::AstNode *default_export_ {};
 };