diff --git a/binder/ETSBinder.cpp b/binder/ETSBinder.cpp
index 4f836b128bf9433373161d64d8be62a9b4a62151..5e1d1bd50ae980c7500a63536883449734af97cf 100644
--- a/binder/ETSBinder.cpp
+++ b/binder/ETSBinder.cpp
@@ -83,11 +83,7 @@ void ETSBinder::LookupTypeArgumentReferences(ir::ETSTypeReference *typeRef)
         }
 
         for (auto *it : iter->TypeParams()->Params()) {
-            if (!it->IsETSTypeReference()) {
-                continue;
-            }
-
-            ResolveReference(it);
+            ResolveReferences(it);
         }
 
         iter = iter->Previous();
diff --git a/checker/ets/helpers.cpp b/checker/ets/helpers.cpp
index 9bdff68ab82632c0dbf7d65606b086efc3d7e3f8..b5845116dac32addfca0b1ebbe6117f30828d59b 100644
--- a/checker/ets/helpers.cpp
+++ b/checker/ets/helpers.cpp
@@ -509,7 +509,10 @@ Type *ETSChecker::GetTypeFromTypeAliasReference(binder::Variable *var)
         return var->TsType();
     }
 
-    auto *aliasedType = var->Declaration()->Node()->AsTSTypeAliasDeclaration()->TypeAnnotation()->GetType(this);
+    auto aliasTypeNode = var->Declaration()->Node()->AsTSTypeAliasDeclaration();
+    TypeStackElement tse(this, aliasTypeNode, "Circular type alias reference", aliasTypeNode->Start());
+    auto *aliasedType = aliasTypeNode->TypeAnnotation()->GetType(this);
+
     var->SetTsType(aliasedType);
     return aliasedType;
 }
diff --git a/compiler/core/ETSGen.cpp b/compiler/core/ETSGen.cpp
index 8226e9740303bc6361dc73ee21633cecdff5e98f..378388d9f83cc6eae6a24bc09aa9ec84c1c3ea9b 100644
--- a/compiler/core/ETSGen.cpp
+++ b/compiler/core/ETSGen.cpp
@@ -37,6 +37,16 @@
 
 namespace panda::es2panda::compiler {
 
+void ETSGen::SetAccumulatorType(const checker::Type *type)
+{
+    SetVRegType(acc_, type);
+}
+
+const checker::Type *ETSGen::GetAccumulatorType() const
+{
+    return GetVRegType(acc_);
+}
+
 const checker::ETSChecker *ETSGen::Checker() const
 {
     return Context()->Checker()->AsETSChecker();
@@ -58,48 +68,51 @@ VReg ETSGen::StoreException(const ir::AstNode *node)
     VReg exception = AllocReg();
     Ra().Emit<StaObj>(node, exception);
 
-    acc_.SetType(Checker()->GlobalBuiltinExceptionType());
-    exception.SetType(acc_.GetType());
+    SetAccumulatorType(Checker()->GlobalBuiltinExceptionType());
+    SetVRegType(exception, GetAccumulatorType());
     return exception;
 }
 
 void ETSGen::StoreAccumulator(const ir::AstNode *node, VReg &vreg)
 {
-    if (acc_.GetType()->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
+    const auto *accType = GetAccumulatorType();
+    if (accType->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
         Ra().Emit<StaObj>(node, vreg);
-    } else if (acc_.GetType()->HasTypeFlag(checker::TypeFlag::ETS_WIDE_NUMERIC)) {
+    } else if (accType->HasTypeFlag(checker::TypeFlag::ETS_WIDE_NUMERIC)) {
         Ra().Emit<StaWide>(node, vreg);
     } else {
         Ra().Emit<Sta>(node, vreg);
     }
 
-    vreg.SetType(acc_.GetType());
+    SetVRegType(vreg, accType);
 }
 
 void ETSGen::LoadAccumulator(const ir::AstNode *node, VReg vreg)
 {
-    if (vreg.GetType()->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
+    const auto *vregType = GetVRegType(vreg);
+    if (vregType->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
         Ra().Emit<LdaObj>(node, vreg);
-    } else if (vreg.GetType()->HasTypeFlag(checker::TypeFlag::ETS_WIDE_NUMERIC)) {
+    } else if (vregType->HasTypeFlag(checker::TypeFlag::ETS_WIDE_NUMERIC)) {
         Ra().Emit<LdaWide>(node, vreg);
     } else {
         Ra().Emit<Lda>(node, vreg);
     }
 
-    acc_.SetType(vreg.GetType());
+    SetAccumulatorType(vregType);
 }
 
 void ETSGen::MoveVreg(const ir::AstNode *node, VReg &vd, VReg vs)
 {
-    if (vs.GetType()->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
+    const auto *sourceType = GetVRegType(vs);
+    if (sourceType->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
         Ra().Emit<MovObj>(node, vd, vs);
-    } else if (vs.GetType()->HasTypeFlag(checker::TypeFlag::ETS_WIDE_NUMERIC)) {
+    } else if (sourceType->HasTypeFlag(checker::TypeFlag::ETS_WIDE_NUMERIC)) {
         Ra().Emit<MovWide>(node, vd, vs);
     } else {
         Ra().Emit<Mov>(node, vd, vs);
     }
 
-    vd.SetType(vs.GetType());
+    SetVRegType(vd, sourceType);
 }
 
 void ETSGen::LoadVar(const ir::AstNode *node, binder::Variable *var)
@@ -120,7 +133,7 @@ void ETSGen::LoadVar(const ir::AstNode *node, binder::Variable *var)
         case ReferenceKind::STATIC_METHOD:
         case ReferenceKind::CLASS:
         case ReferenceKind::STATIC_CLASS: {
-            acc_.SetType(var->TsType());
+            SetAccumulatorType(var->TsType());
             break;
         }
         case ReferenceKind::LOCAL: {
@@ -207,13 +220,13 @@ void ETSGen::LoadStaticProperty(const ir::AstNode *node, const checker::Type *pr
         Sa().Emit<Ldstatic>(node, fullName);
     }
 
-    acc_.SetType(propType);
+    SetAccumulatorType(propType);
 }
 
 void ETSGen::StoreProperty(const ir::AstNode *node, const checker::Type *propType, VReg objReg,
                            const util::StringView &name)
 {
-    util::StringView fullName = FormClassPropReference(objReg.GetType()->AsETSObjectType(), name);
+    util::StringView fullName = FormClassPropReference(GetVRegType(objReg)->AsETSObjectType(), name);
 
     if (propType->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
         Ra().Emit<StobjObj>(node, objReg, fullName);
@@ -227,7 +240,7 @@ void ETSGen::StoreProperty(const ir::AstNode *node, const checker::Type *propTyp
 void ETSGen::LoadProperty(const ir::AstNode *node, const checker::Type *propType, VReg objReg,
                           const util::StringView &name)
 {
-    util::StringView fullName = FormClassPropReference(objReg.GetType()->AsETSObjectType(), name);
+    util::StringView fullName = FormClassPropReference(GetVRegType(objReg)->AsETSObjectType(), name);
 
     if (propType->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
         Ra().Emit<LdobjObj>(node, objReg, fullName);
@@ -237,7 +250,7 @@ void ETSGen::LoadProperty(const ir::AstNode *node, const checker::Type *propType
         Ra().Emit<Ldobj>(node, objReg, fullName);
     }
 
-    acc_.SetType(propType);
+    SetAccumulatorType(propType);
 }
 
 void ETSGen::LoadThis(const ir::AstNode *node)
@@ -270,9 +283,10 @@ void ETSGen::EmitReturnVoid(const ir::AstNode *node)
 
 void ETSGen::ReturnAcc(const ir::AstNode *node)
 {
-    if (acc_.GetType()->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
+    const auto *accType = GetAccumulatorType();
+    if (accType->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
         Sa().Emit<ReturnObj>(node);
-    } else if (acc_.GetType()->HasTypeFlag(checker::TypeFlag::ETS_WIDE_NUMERIC)) {
+    } else if (accType->HasTypeFlag(checker::TypeFlag::ETS_WIDE_NUMERIC)) {
         Sa().Emit<ReturnWide>(node);
     } else {
         Sa().Emit<Return>(node);
@@ -340,7 +354,7 @@ void ETSGen::ApplyConversion(const ir::AstNode *node, const checker::Type *targe
 
     auto typeKind = checker::ETSChecker::TypeKind(targetType);
 
-    auto sourceType = acc_.GetType();
+    const auto *sourceType = GetAccumulatorType();
 
     if (sourceType->IsETSObjectType() &&
         sourceType->AsETSObjectType()->HasObjectFlag(checker::ETSObjectFlags::UNBOXABLE_TYPE) &&
@@ -377,45 +391,46 @@ void ETSGen::ApplyConversion(const ir::AstNode *node, const checker::Type *targe
 void ETSGen::EmitUnboxingConversion(const ir::AstNode *node, const checker::Type *targetType,
                                     checker::TypeFlag typeKind)
 {
+    RegScope rs(this);
     switch (typeKind) {
         case checker::TypeFlag::ETS_BOOLEAN: {
-            Ra().Emit<CallVirtAccShort>(node, Signatures::BUILTIN_BOOLEAN_BOOLEAN_VALUE, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallVirtAccShort, 0>(node, Signatures::BUILTIN_BOOLEAN_BOOLEAN_VALUE, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::BYTE: {
-            Ra().Emit<CallVirtAccShort>(node, Signatures::BUILTIN_BYTE_BYTE_VALUE, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallVirtAccShort, 0>(node, Signatures::BUILTIN_BYTE_BYTE_VALUE, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::CHAR: {
-            Ra().Emit<CallVirtAccShort>(node, Signatures::BUILTIN_CHAR_CHAR_VALUE, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallVirtAccShort, 0>(node, Signatures::BUILTIN_CHAR_CHAR_VALUE, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::SHORT: {
-            Ra().Emit<CallVirtAccShort>(node, Signatures::BUILTIN_SHORT_SHORT_VALUE, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallVirtAccShort, 0>(node, Signatures::BUILTIN_SHORT_SHORT_VALUE, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::INT: {
-            Ra().Emit<CallVirtAccShort>(node, Signatures::BUILTIN_INT_INT_VALUE, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallVirtAccShort, 0>(node, Signatures::BUILTIN_INT_INT_VALUE, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::LONG: {
-            Ra().Emit<CallVirtAccShort>(node, Signatures::BUILTIN_LONG_LONG_VALUE, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallVirtAccShort, 0>(node, Signatures::BUILTIN_LONG_LONG_VALUE, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::FLOAT: {
-            Ra().Emit<CallVirtAccShort>(node, Signatures::BUILTIN_FLOAT_FLOAT_VALUE, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallVirtAccShort, 0>(node, Signatures::BUILTIN_FLOAT_FLOAT_VALUE, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::DOUBLE: {
-            Ra().Emit<CallVirtAccShort>(node, Signatures::BUILTIN_DOUBLE_DOUBLE_VALUE, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallVirtAccShort, 0>(node, Signatures::BUILTIN_DOUBLE_DOUBLE_VALUE, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         default: {
@@ -427,46 +442,47 @@ void ETSGen::EmitUnboxingConversion(const ir::AstNode *node, const checker::Type
 void ETSGen::EmitBoxingConversion(const ir::AstNode *node, const checker::Type *targetType,
                                   const checker::Type *sourceType)
 {
+    RegScope rs(this);
     auto sourceTypeKind = checker::ETSChecker::TypeKind(sourceType);
     switch (sourceTypeKind) {
         case checker::TypeFlag::ETS_BOOLEAN: {
-            Ra().Emit<CallAccShort>(node, Signatures::BUILTIN_BOOLEAN_VALUE_OF, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallAccShort, 0>(node, Signatures::BUILTIN_BOOLEAN_VALUE_OF, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::BYTE: {
-            Ra().Emit<CallAccShort>(node, Signatures::BUILTIN_BYTE_VALUE_OF, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallAccShort, 0>(node, Signatures::BUILTIN_BYTE_VALUE_OF, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::CHAR: {
-            Ra().Emit<CallAccShort>(node, Signatures::BUILTIN_CHAR_VALUE_OF, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallAccShort, 0>(node, Signatures::BUILTIN_CHAR_VALUE_OF, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::SHORT: {
-            Ra().Emit<CallAccShort>(node, Signatures::BUILTIN_SHORT_VALUE_OF, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallAccShort, 0>(node, Signatures::BUILTIN_SHORT_VALUE_OF, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::INT: {
-            Ra().Emit<CallAccShort>(node, Signatures::BUILTIN_INT_VALUE_OF, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallAccShort, 0>(node, Signatures::BUILTIN_INT_VALUE_OF, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::LONG: {
-            Ra().Emit<CallAccShort>(node, Signatures::BUILTIN_LONG_VALUE_OF, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallAccShort, 0>(node, Signatures::BUILTIN_LONG_VALUE_OF, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::FLOAT: {
-            Ra().Emit<CallAccShort>(node, Signatures::BUILTIN_FLOAT_VALUE_OF, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallAccShort, 0>(node, Signatures::BUILTIN_FLOAT_VALUE_OF, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         case checker::TypeFlag::DOUBLE: {
-            Ra().Emit<CallAccShort>(node, Signatures::BUILTIN_DOUBLE_VALUE_OF, VReg::RegStart(), 0);
-            acc_.SetType(targetType);
+            Ra().Emit<CallAccShort, 0>(node, Signatures::BUILTIN_DOUBLE_VALUE_OF, DUMMY_REG, 0);
+            SetAccumulatorType(targetType);
             break;
         }
         default: {
@@ -487,7 +503,7 @@ void ETSGen::SwapBinaryOpArgs(const ir::AstNode *node, VReg &lhs)
 
 void ETSGen::CastToBoolean([[maybe_unused]] const ir::AstNode *node)
 {
-    auto typeKind = checker::ETSChecker::TypeKind(acc_.GetType());
+    auto typeKind = checker::ETSChecker::TypeKind(GetAccumulatorType());
     switch (typeKind) {
         case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE:
@@ -516,12 +532,12 @@ void ETSGen::CastToBoolean([[maybe_unused]] const ir::AstNode *node)
         }
     }
 
-    acc_.SetType(Checker()->GlobalETSBooleanType());
+    SetAccumulatorType(Checker()->GlobalETSBooleanType());
 }
 
 void ETSGen::CastToByte([[maybe_unused]] const ir::AstNode *node)
 {
-    auto typeKind = checker::ETSChecker::TypeKind(acc_.GetType());
+    auto typeKind = checker::ETSChecker::TypeKind(GetAccumulatorType());
     switch (typeKind) {
         case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE: {
@@ -553,12 +569,12 @@ void ETSGen::CastToByte([[maybe_unused]] const ir::AstNode *node)
         }
     }
 
-    acc_.SetType(Checker()->GlobalByteType());
+    SetAccumulatorType(Checker()->GlobalByteType());
 }
 
 void ETSGen::CastToChar([[maybe_unused]] const ir::AstNode *node)
 {
-    auto typeKind = checker::ETSChecker::TypeKind(acc_.GetType());
+    auto typeKind = checker::ETSChecker::TypeKind(GetAccumulatorType());
     switch (typeKind) {
         case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE:
@@ -591,12 +607,12 @@ void ETSGen::CastToChar([[maybe_unused]] const ir::AstNode *node)
         }
     }
 
-    acc_.SetType(Checker()->GlobalCharType());
+    SetAccumulatorType(Checker()->GlobalCharType());
 }
 
 void ETSGen::CastToShort([[maybe_unused]] const ir::AstNode *node)
 {
-    auto typeKind = checker::ETSChecker::TypeKind(acc_.GetType());
+    auto typeKind = checker::ETSChecker::TypeKind(GetAccumulatorType());
     switch (typeKind) {
         case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE:
@@ -628,12 +644,12 @@ void ETSGen::CastToShort([[maybe_unused]] const ir::AstNode *node)
         }
     }
 
-    acc_.SetType(Checker()->GlobalShortType());
+    SetAccumulatorType(Checker()->GlobalShortType());
 }
 
 void ETSGen::CastToDouble(const ir::AstNode *node)
 {
-    auto typeKind = checker::ETSChecker::TypeKind(acc_.GetType());
+    auto typeKind = checker::ETSChecker::TypeKind(GetAccumulatorType());
     switch (typeKind) {
         case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE:
@@ -659,12 +675,12 @@ void ETSGen::CastToDouble(const ir::AstNode *node)
         }
     }
 
-    acc_.SetType(Checker()->GlobalDoubleType());
+    SetAccumulatorType(Checker()->GlobalDoubleType());
 }
 
 void ETSGen::CastToFloat(const ir::AstNode *node)
 {
-    auto typeKind = checker::ETSChecker::TypeKind(acc_.GetType());
+    auto typeKind = checker::ETSChecker::TypeKind(GetAccumulatorType());
     switch (typeKind) {
         case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE:
@@ -690,12 +706,12 @@ void ETSGen::CastToFloat(const ir::AstNode *node)
         }
     }
 
-    acc_.SetType(Checker()->GlobalFloatType());
+    SetAccumulatorType(Checker()->GlobalFloatType());
 }
 
 void ETSGen::CastToLong(const ir::AstNode *node)
 {
-    auto typeKind = checker::ETSChecker::TypeKind(acc_.GetType());
+    auto typeKind = checker::ETSChecker::TypeKind(GetAccumulatorType());
     switch (typeKind) {
         case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE:
@@ -721,12 +737,12 @@ void ETSGen::CastToLong(const ir::AstNode *node)
         }
     }
 
-    acc_.SetType(Checker()->GlobalLongType());
+    SetAccumulatorType(Checker()->GlobalLongType());
 }
 
 void ETSGen::CastToInt(const ir::AstNode *node)
 {
-    auto typeKind = checker::ETSChecker::TypeKind(acc_.GetType());
+    auto typeKind = checker::ETSChecker::TypeKind(GetAccumulatorType());
     switch (typeKind) {
         case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE:
@@ -752,7 +768,7 @@ void ETSGen::CastToInt(const ir::AstNode *node)
         }
     }
 
-    acc_.SetType(Checker()->GlobalIntType());
+    SetAccumulatorType(Checker()->GlobalIntType());
 }
 
 void ETSGen::ToBinaryResult(const ir::AstNode *node, Label *ifFalse)
@@ -865,7 +881,7 @@ void ETSGen::Binary(const ir::AstNode *node, lexer::TokenType op, VReg lhs)
         }
         case lexer::TokenType::KEYW_INSTANCEOF: {
             SwapBinaryOpArgs(node, lhs);
-            IsInstance(node, lhs.GetType()->AsETSObjectType()->AssemblerName());
+            IsInstance(node, GetVRegType(lhs)->AsETSObjectType()->AssemblerName());
             break;
         }
         default: {
@@ -905,9 +921,9 @@ void ETSGen::Condition(const ir::AstNode *node, lexer::TokenType op, VReg lhs, L
         }
         case lexer::TokenType::KEYW_INSTANCEOF: {
             SwapBinaryOpArgs(node, lhs);
-            Sa().Emit<Isinstance>(node, lhs.GetType()->AsETSObjectType()->AssemblerName());
+            Sa().Emit<Isinstance>(node, GetVRegType(lhs)->AsETSObjectType()->AssemblerName());
             BranchIfFalse(node, ifFalse);
-            acc_.SetType(Checker()->GlobalETSBooleanType());
+            SetAccumulatorType(Checker()->GlobalETSBooleanType());
             break;
         }
         default: {
@@ -970,7 +986,7 @@ void ETSGen::CompileStatementList(const ArenaVector<ir::Statement *> &statements
 
 void ETSGen::Negate(const ir::AstNode *node)
 {
-    auto typeKind = checker::ETSChecker::TypeKind(acc_.GetType());
+    auto typeKind = checker::ETSChecker::TypeKind(GetAccumulatorType());
 
     switch (typeKind) {
         case checker::TypeFlag::BYTE:
@@ -1000,7 +1016,7 @@ void ETSGen::Negate(const ir::AstNode *node)
 
 void ETSGen::LogicalNot(const ir::AstNode *node)
 {
-    ASSERT(acc_.GetType()->IsETSBooleanType());
+    ASSERT(GetAccumulatorType()->IsETSBooleanType());
     Sa().Emit<Neg>(node);
     Sa().Emit<Addi>(node, 1);
 }
@@ -1031,7 +1047,7 @@ void ETSGen::Unary(const ir::AstNode *node, lexer::TokenType op)
 
 void ETSGen::UnaryMinus(const ir::AstNode *node)
 {
-    switch (checker::ETSChecker::ETSType(acc_.GetType())) {
+    switch (checker::ETSChecker::ETSType(GetAccumulatorType())) {
         case checker::TypeFlag::LONG: {
             Sa().Emit<NegWide>(node);
             break;
@@ -1059,7 +1075,7 @@ void ETSGen::UnaryMinus(const ir::AstNode *node)
 
 void ETSGen::UnaryTilde(const ir::AstNode *node)
 {
-    switch (checker::ETSChecker::ETSType(acc_.GetType())) {
+    switch (checker::ETSChecker::ETSType(GetAccumulatorType())) {
         case checker::TypeFlag::LONG: {
             Sa().Emit<NotWide>(node);
             break;
@@ -1101,7 +1117,7 @@ void ETSGen::StringBuilderAppend(const ir::AstNode *node, VReg builder)
 
     node->Compile(this);
 
-    switch (checker::ETSChecker::ETSType(acc_.GetType())) {
+    switch (checker::ETSChecker::ETSType(GetAccumulatorType())) {
         case checker::TypeFlag::ETS_BOOLEAN: {
             signature = Signatures::BUILTIN_STRING_BUILDER_APPEND_BOOLEAN;
             break;
@@ -1134,14 +1150,15 @@ void ETSGen::StringBuilderAppend(const ir::AstNode *node, VReg builder)
         }
     }
 
-    if (acc_.GetType()->IsETSObjectType() && !acc_.GetType()->IsETSStringType()) {
-        Ra().Emit<CallVirtAccShort>(node, Signatures::BUILTIN_OBJECT_TO_STRING, VReg::RegStart(), 0);
+    if (GetAccumulatorType()->IsETSObjectType() && !GetAccumulatorType()->IsETSStringType()) {
+        Ra().Emit<CallVirtAccShort, 0>(node, Signatures::BUILTIN_OBJECT_TO_STRING, DUMMY_REG, 0);
     }
 
     VReg arg0 = AllocReg();
     StoreAccumulator(node, arg0);
 
     CallThisStatic1(node, builder, signature, arg0);
+    SetAccumulatorType(Checker()->GetGlobalTypesHolder()->GlobalStringBuilderBuiltinType());
 }
 
 void ETSGen::AppendString(const ir::Expression *expr, VReg &builder)
@@ -1172,16 +1189,17 @@ void ETSGen::StringBuilder(const ir::Expression *left, const ir::Expression *rig
 void ETSGen::BuildString(const ir::Expression *node)
 {
     RegScope rs(this);
-    VReg builder = AllocReg();
 
-    Sa().Emit<InitobjShort>(node, Signatures::BUILTIN_STRING_BUILDER_CTOR, VReg::RegStart(), VReg::RegStart());
-    acc_.SetType(Checker()->GlobalStringBuilderBuiltinType());
+    Ra().Emit<InitobjShort, 0>(node, Signatures::BUILTIN_STRING_BUILDER_CTOR, DUMMY_REG, DUMMY_REG);
+    SetAccumulatorType(Checker()->GlobalStringBuilderBuiltinType());
+
+    auto builder = AllocReg();
     StoreAccumulator(node, builder);
 
     AppendString(node, builder);
     CallThisStatic0(node, builder, Signatures::BUILTIN_STRING_BUILDER_TO_STRING);
 
-    acc_.SetType(Checker()->GlobalETSStringLiteralType());
+    SetAccumulatorType(Checker()->GlobalBuiltinETSStringType());
 }
 
 void ETSGen::NewObject(const ir::AstNode *node, VReg &ctor, util::StringView name)
@@ -1201,24 +1219,27 @@ void ETSGen::NewArray(const ir::AstNode *node, VReg &arr, VReg dim, const checke
 void ETSGen::LoadArrayLength(const ir::AstNode *node, VReg arrayReg)
 {
     Ra().Emit<Lenarr>(node, arrayReg);
-    acc_.SetType(Checker()->GlobalIntType());
+    SetAccumulatorType(Checker()->GlobalIntType());
 }
 
 void ETSGen::LoadArrayElement(const ir::AstNode *node, VReg objectReg)
 {
-    auto *elementType = objectReg.GetType()->AsETSArrayType()->ElementType();
+    auto *elementType = GetVRegType(objectReg)->AsETSArrayType()->ElementType();
 
     switch (checker::ETSChecker::ETSType(elementType)) {
+        case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE: {
             Ra().Emit<Ldarr8>(node, objectReg);
             break;
         }
-        case checker::TypeFlag::CHAR:
+        case checker::TypeFlag::CHAR: {
+            Ra().Emit<Ldarru16>(node, objectReg);
+            break;
+        }
         case checker::TypeFlag::SHORT: {
             Ra().Emit<Ldarr16>(node, objectReg);
             break;
         }
-        case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::INT: {
             Ra().Emit<Ldarr>(node, objectReg);
             break;
@@ -1246,14 +1267,15 @@ void ETSGen::LoadArrayElement(const ir::AstNode *node, VReg objectReg)
         }
     }
 
-    acc_.SetType(elementType);
+    SetAccumulatorType(elementType);
 }
 
 void ETSGen::StoreArrayElement(const ir::AstNode *node, VReg objectReg, VReg index)
 {
-    auto *elementType = objectReg.GetType()->AsETSArrayType()->ElementType();
+    auto *elementType = GetVRegType(objectReg)->AsETSArrayType()->ElementType();
 
     switch (checker::ETSChecker::ETSType(elementType)) {
+        case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::BYTE: {
             Ra().Emit<Starr8>(node, objectReg, index);
             break;
@@ -1263,7 +1285,6 @@ void ETSGen::StoreArrayElement(const ir::AstNode *node, VReg objectReg, VReg ind
             Ra().Emit<Starr16>(node, objectReg, index);
             break;
         }
-        case checker::TypeFlag::ETS_BOOLEAN:
         case checker::TypeFlag::INT: {
             Ra().Emit<Starr>(node, objectReg, index);
             break;
@@ -1291,7 +1312,7 @@ void ETSGen::StoreArrayElement(const ir::AstNode *node, VReg objectReg, VReg ind
         }
     }
 
-    acc_.SetType(elementType);
+    SetAccumulatorType(elementType);
 }
 
 void ETSGen::ThrowException(const ir::Expression *expr)
diff --git a/compiler/core/ETSGen.h b/compiler/core/ETSGen.h
index 43f72693fbfe0ddd3515a18f466dae967c4c8a15..a3e7cd24e88ee34237649c605ae341db84a5e2db 100644
--- a/compiler/core/ETSGen.h
+++ b/compiler/core/ETSGen.h
@@ -54,6 +54,9 @@ public:
         return acc_;
     }
 
+    void SetAccumulatorType(const checker::Type *type);
+    const checker::Type *GetAccumulatorType() const;
+
     VReg StoreException(const ir::AstNode *node);
     void ApplyConversionAndStoreAccumulator(const ir::AstNode *node, VReg &vreg, const checker::Type *targetType);
     void StoreAccumulator(const ir::AstNode *node, VReg &vreg);
@@ -84,7 +87,7 @@ public:
     void IsInstance(const ir::AstNode *node, util::StringView name)
     {
         Sa().Emit<Isinstance>(node, name);
-        acc_.SetType(Checker()->GlobalETSBooleanType());
+        SetAccumulatorType(Checker()->GlobalETSBooleanType());
     }
 
     void Binary(const ir::AstNode *node, lexer::TokenType op, VReg lhs);
@@ -153,23 +156,23 @@ public:
         Sa().Emit<Ldai>(node, value ? 1 : 0);
         if (typeKind == checker::TypeFlag::ETS_OBJECT &&
             targetType_->AsETSObjectType()->HasObjectFlag(checker::ETSObjectFlags::BUILTIN_BOOLEAN)) {
-            Ra().Emit<CallAccShort>(node, Signatures::BUILTIN_BOOLEAN_VALUE_OF, VReg::RegStart(), 0);
-            acc_.SetType(targetType_);
+            Ra().Emit<CallAccShort, 0>(node, Signatures::BUILTIN_BOOLEAN_VALUE_OF, DUMMY_REG, 0);
+            SetAccumulatorType(targetType_);
         } else {
-            acc_.SetType(Checker()->GlobalETSBooleanType());
+            SetAccumulatorType(Checker()->GlobalETSBooleanType());
         }
     }
 
     void LoadAccumulatorString(const ir::AstNode *node, util::StringView str)
     {
         Sa().Emit<LdaStr>(node, str);
-        acc_.SetType(Checker()->GlobalETSStringLiteralType());
+        SetAccumulatorType(Checker()->GlobalETSStringLiteralType());
     }
 
     void LoadAccumulatorNull(const ir::AstNode *node, const checker::Type *type)
     {
         Sa().Emit<LdaNull>(node);
-        acc_.SetType(type);
+        SetAccumulatorType(type);
     }
 
     void LoadAccumulatorChar(const ir::AstNode *node, char16_t value)
@@ -178,10 +181,10 @@ public:
         Sa().Emit<Ldai>(node, value);
         if (typeKind == checker::TypeFlag::ETS_OBJECT &&
             targetType_->AsETSObjectType()->HasObjectFlag(checker::ETSObjectFlags::BUILTIN_CHAR)) {
-            Ra().Emit<CallAccShort>(node, Signatures::BUILTIN_CHAR_VALUE_OF, VReg::RegStart(), 0);
-            acc_.SetType(targetType_);
+            Ra().Emit<CallAccShort, 0>(node, Signatures::BUILTIN_CHAR_VALUE_OF, DUMMY_REG, 0);
+            SetAccumulatorType(targetType_);
         } else {
-            acc_.SetType(Checker()->GlobalCharType());
+            SetAccumulatorType(Checker()->GlobalCharType());
         }
     }
 
@@ -243,7 +246,7 @@ public:
 
     void CallThisStatic0(const ir::AstNode *node, VReg &ctor, util::StringView name)
     {
-        Ra().Emit<CallShort>(node, name, ctor, VReg::RegStart());
+        Ra().Emit<CallShort, 1>(node, name, ctor, DUMMY_REG);
     }
 
     void CallThisStatic1(const ir::AstNode *node, VReg &ctor, util::StringView name, VReg &arg0)
@@ -253,7 +256,7 @@ public:
 
     void CallThisStatic2(const ir::AstNode *node, VReg &ctor, util::StringView name, VReg &arg0, VReg &arg1)
     {
-        Ra().Emit<Call>(node, name, ctor, arg0, arg1, VReg::RegStart());
+        Ra().Emit<Call, 3>(node, name, ctor, arg0, arg1, DUMMY_REG);
     }
 
     void GetType(const ir::AstNode *node, bool isETSPrimitive)
@@ -261,7 +264,7 @@ public:
         if (isETSPrimitive) {
             // TODO(SzD) LoadStaticProperty if ETS stdlib has static TYPE constants otherwise fallback to LdaType
         } else {
-            auto classRef = acc_.GetType()->AsETSObjectType()->AssemblerName();
+            auto classRef = GetAccumulatorType()->AsETSObjectType()->AssemblerName();
             Sa().Emit<LdaType>(node, classRef);
         }
     }
@@ -271,6 +274,8 @@ public:
     NO_MOVE_SEMANTIC(ETSGen);
 
 private:
+    const VReg DUMMY_REG = VReg::RegStart();
+
     void StringBuilderAppend(const ir::AstNode *node, VReg builder);
     void AppendString(const ir::Expression *binExpr, VReg &builder);
     void StringBuilder(const ir::Expression *left, const ir::Expression *right, VReg &builder);
@@ -289,7 +294,7 @@ private:
     template <typename LongOp, typename IntOp, typename DoubleOp, typename FloatOp>
     void UpdateOperator(const ir::AstNode *node)
     {
-        switch (checker::ETSChecker::ETSType(acc_.GetType())) {
+        switch (checker::ETSChecker::ETSType(GetAccumulatorType())) {
             case checker::TypeFlag::LONG: {
                 RegScope scope(this);
                 VReg reg = AllocReg();
@@ -342,7 +347,7 @@ private:
     {
         BinaryEqualityCondition<ObjCompare, IntCompare, CondCompare>(node, lhs, ifFalse);
         ToBinaryResult(node, ifFalse);
-        acc_.SetType(Checker()->GlobalETSBooleanType());
+        SetAccumulatorType(Checker()->GlobalETSBooleanType());
     }
 
     template <typename ObjCompare, typename IntCompare, typename CondCompare>
@@ -352,13 +357,13 @@ private:
 
         switch (typeKind) {
             case checker::TypeFlag::ETS_OBJECT: {
-                ASSERT(lhs.GetType()->IsETSObjectType());
-                if (lhs.GetType()->IsETSStringType()) {
+                ASSERT(GetVRegType(lhs)->IsETSObjectType());
+                if (GetVRegType(lhs)->IsETSStringType()) {
                     RegScope rs(this);
                     VReg arg0 = AllocReg();
                     StoreAccumulator(node, arg0);
                     CallThisStatic1(node, lhs, Signatures::BUILTIN_STRING_EQUALS, arg0);
-                    acc_.SetType(Checker()->GlobalETSBooleanType());
+                    SetAccumulatorType(Checker()->GlobalETSBooleanType());
                     if constexpr (std::is_same_v<CondCompare, Jeqz>) {
                         LogicalNot(node);
                     }
@@ -395,7 +400,7 @@ private:
             }
         }
 
-        acc_.SetType(Checker()->GlobalETSBooleanType());
+        SetAccumulatorType(Checker()->GlobalETSBooleanType());
     }
 
     template <typename IntCompare, typename CondCompare>
@@ -403,7 +408,7 @@ private:
     {
         BinaryRelationCondition<IntCompare, CondCompare>(node, lhs, ifFalse);
         ToBinaryResult(node, ifFalse);
-        acc_.SetType(Checker()->GlobalETSBooleanType());
+        SetAccumulatorType(Checker()->GlobalETSBooleanType());
     }
 
     template <typename IntCompare, typename CondCompare>
@@ -436,7 +441,7 @@ private:
             }
         }
 
-        acc_.SetType(Checker()->GlobalETSBooleanType());
+        SetAccumulatorType(Checker()->GlobalETSBooleanType());
     }
 
     template <typename IntOp, typename LongOp, typename FloatOp, typename DoubleOp>
@@ -447,12 +452,12 @@ private:
         switch (typeKind) {
             case checker::TypeFlag::DOUBLE: {
                 Ra().Emit<DoubleOp>(node, lhs);
-                acc_.SetType(Checker()->GlobalDoubleType());
+                SetAccumulatorType(Checker()->GlobalDoubleType());
                 break;
             }
             case checker::TypeFlag::FLOAT: {
                 Ra().Emit<FloatOp>(node, lhs);
-                acc_.SetType(Checker()->GlobalFloatType());
+                SetAccumulatorType(Checker()->GlobalFloatType());
                 break;
             }
             default: {
@@ -469,19 +474,19 @@ private:
         switch (typeKind) {
             case checker::TypeFlag::LONG: {
                 Ra().Emit<LongOp>(node, lhs);
-                acc_.SetType(Checker()->GlobalLongType());
+                SetAccumulatorType(Checker()->GlobalLongType());
                 break;
             }
             case checker::TypeFlag::BYTE:
             case checker::TypeFlag::SHORT:
             case checker::TypeFlag::INT: {
                 Ra().Emit<IntOp>(node, lhs);
-                acc_.SetType(Checker()->GlobalIntType());
+                SetAccumulatorType(Checker()->GlobalIntType());
                 break;
             }
             case checker::TypeFlag::ETS_BOOLEAN: {
                 Ra().Emit<IntOp>(node, lhs);
-                acc_.SetType(Checker()->GlobalETSBooleanType());
+                SetAccumulatorType(Checker()->GlobalETSBooleanType());
                 break;
             }
             default: {
@@ -503,11 +508,11 @@ private:
                       const ArenaVector<ir::Expression *> &arguments)
     {
         RegScope rs(this);
-        util::StringView name = signature->InternalName();
+        const auto name = signature->InternalName();
 
         switch (arguments.size()) {
             case 0: {
-                Ra().Emit<Short>(node, name, ctor, VReg::RegStart());
+                Ra().Emit<Short, 1>(node, name, ctor, DUMMY_REG);
                 break;
             }
             case 1: {
@@ -518,7 +523,7 @@ private:
             case 2: {
                 COMPILE_ARG(0);
                 COMPILE_ARG(1);
-                Ra().Emit<General>(node, name, ctor, arg0, arg1, VReg::RegStart());
+                Ra().Emit<General, 3>(node, name, ctor, arg0, arg1, DUMMY_REG);
                 break;
             }
             case 3: {
@@ -547,16 +552,16 @@ private:
                   const ArenaVector<ir::Expression *> &arguments)
     {
         RegScope rs(this);
-        util::StringView name = signature->InternalName();
+        const auto name = signature->InternalName();
 
         switch (arguments.size()) {
             case 0: {
-                Ra().Emit<Short>(node, name, VReg::RegStart(), VReg::RegStart());
+                Ra().Emit<Short, 0>(node, name, DUMMY_REG, DUMMY_REG);
                 break;
             }
             case 1: {
                 COMPILE_ARG(0);
-                Ra().Emit<Short>(node, name, arg0, VReg::RegStart());
+                Ra().Emit<Short, 1>(node, name, arg0, DUMMY_REG);
                 break;
             }
             case 2: {
@@ -569,7 +574,7 @@ private:
                 COMPILE_ARG(0);
                 COMPILE_ARG(1);
                 COMPILE_ARG(2);
-                Ra().Emit<General>(node, name, arg0, arg1, arg2, VReg::RegStart());
+                Ra().Emit<General, 3>(node, name, arg0, arg1, arg2, DUMMY_REG);
                 break;
             }
             case 4: {
@@ -621,37 +626,37 @@ void ETSGen::LoadAccumulatorNumber(const ir::AstNode *node, T number, checker::T
     switch (typeKind) {
         case checker::TypeFlag::BYTE: {
             Sa().Emit<Ldai>(node, static_cast<checker::ByteType::UType>(number));
-            acc_.SetType(Checker()->GlobalByteType());
+            SetAccumulatorType(Checker()->GlobalByteType());
             break;
         }
         case checker::TypeFlag::CHAR: {
             Sa().Emit<Ldai>(node, static_cast<checker::CharType::UType>(number));
-            acc_.SetType(Checker()->GlobalCharType());
+            SetAccumulatorType(Checker()->GlobalCharType());
             break;
         }
         case checker::TypeFlag::SHORT: {
             Sa().Emit<Ldai>(node, static_cast<checker::ShortType::UType>(number));
-            acc_.SetType(Checker()->GlobalShortType());
+            SetAccumulatorType(Checker()->GlobalShortType());
             break;
         }
         case checker::TypeFlag::INT: {
             Sa().Emit<Ldai>(node, static_cast<checker::IntType::UType>(number));
-            acc_.SetType(Checker()->GlobalIntType());
+            SetAccumulatorType(Checker()->GlobalIntType());
             break;
         }
         case checker::TypeFlag::LONG: {
             Sa().Emit<LdaiWide>(node, static_cast<checker::LongType::UType>(number));
-            acc_.SetType(Checker()->GlobalLongType());
+            SetAccumulatorType(Checker()->GlobalLongType());
             break;
         }
         case checker::TypeFlag::FLOAT: {
             Sa().Emit<Fldai>(node, static_cast<checker::FloatType::UType>(number));
-            acc_.SetType(Checker()->GlobalFloatType());
+            SetAccumulatorType(Checker()->GlobalFloatType());
             break;
         }
         case checker::TypeFlag::DOUBLE: {
             Sa().Emit<FldaiWide>(node, static_cast<checker::DoubleType::UType>(number));
-            acc_.SetType(Checker()->GlobalDoubleType());
+            SetAccumulatorType(Checker()->GlobalDoubleType());
             break;
         }
         default: {
@@ -661,7 +666,7 @@ void ETSGen::LoadAccumulatorNumber(const ir::AstNode *node, T number, checker::T
 
     if (targetType_ && targetType_->IsETSObjectType()) {
         ApplyConversion(node, targetType_);
-        acc_.SetType(targetType_);
+        SetAccumulatorType(targetType_);
     }
 }
 
diff --git a/compiler/core/codeGen.h b/compiler/core/codeGen.h
index e56b67fe10b4b799ba65e7ea894285bb7219b2ee..e3dec74dbe3aa04f2af52185e3a2da219a5ceba4 100644
--- a/compiler/core/codeGen.h
+++ b/compiler/core/codeGen.h
@@ -67,6 +67,8 @@ private:
 
 class CodeGen {
 public:
+    using TypeMap = ArenaUnorderedMap<VReg::Index, const checker::Type *>;
+
     explicit CodeGen(ArenaAllocator *allocator, RegSpiller *spiller, CompilerContext *context,
                      binder::FunctionScope *scope, ProgramElement *programElement)
         : allocator_(allocator),
@@ -77,6 +79,7 @@ public:
           rootNode_(scope->Node()),
           insns_(allocator_->Adapter()),
           catchList_(allocator_->Adapter()),
+          typeMap_(allocator_->Adapter()),
           programElement_(programElement),
           sa_(this),
           ra_(this, spiller),
@@ -112,12 +115,12 @@ public:
         return rootNode_;
     }
 
-    ArenaList<IRNode *> &Insns()
+    ArenaVector<IRNode *> &Insns()
     {
         return insns_;
     }
 
-    const ArenaList<IRNode *> &Insns() const
+    const ArenaVector<IRNode *> &Insns() const
     {
         return insns_;
     }
@@ -129,7 +132,9 @@ public:
 
     VReg AllocReg(const checker::Type *type)
     {
-        return VReg(usedRegs_--, type);
+        VReg vreg(usedRegs_--);
+        SetVRegType(vreg, type);
+        return vreg;
     }
 
     VReg NextReg() const
@@ -191,6 +196,17 @@ public:
         throw Error(ErrorType::GENERIC, "", "Unimplemented code path");
     }
 
+    void SetVRegType(VReg vreg, const checker::Type *type)
+    {
+        typeMap_.insert_or_assign(vreg.GetIndex(), type);
+    }
+
+    const checker::Type *GetVRegType(VReg vreg) const
+    {
+        const auto it = typeMap_.find(vreg.GetIndex());
+        return it != typeMap_.end() ? it->second : nullptr;
+    }
+
 protected:
     SimpleAllocator &Sa()
     {
@@ -232,6 +248,16 @@ protected:
         return programElement_;
     }
 
+    TypeMap &GetTypeMap()
+    {
+        return typeMap_;
+    }
+
+    const TypeMap &GetTypeMap() const
+    {
+        return typeMap_;
+    }
+
 private:
     ArenaAllocator *allocator_;
     CompilerContext *context_;
@@ -239,8 +265,9 @@ private:
     binder::FunctionScope *topScope_;
     binder::Scope *scope_;
     const ir::AstNode *rootNode_;
-    ArenaList<IRNode *> insns_;
+    ArenaVector<IRNode *> insns_;
     ArenaVector<CatchTable *> catchList_;
+    TypeMap typeMap_;
     ProgramElement *programElement_;
     DynamicContext *dynamicContext_ {};
 
diff --git a/compiler/core/regAllocator.cpp b/compiler/core/regAllocator.cpp
index e95c6c7d48447dcd5cfc0fa0d236b3f10bc5987f..1e0beff71fb4992d4744d164a8a2c6bbe23124a7 100644
--- a/compiler/core/regAllocator.cpp
+++ b/compiler/core/regAllocator.cpp
@@ -40,30 +40,23 @@ Label *SimpleAllocator::AllocLabel(std::string &&id)
     return Alloc<Label>(lastInsNode, std::move(id));
 }
 
-// FrontAllocator
-
-FrontAllocator::FrontAllocator(CodeGen *pg)
-    : AllocatorBase(pg), insn_(std::move(cg_->Insns()), cg_->Allocator()->Adapter())
-{
-}
-
-FrontAllocator::~FrontAllocator()
-{
-    cg_->Insns().splice(cg_->Insns().end(), std::move(insn_));
-}
-
 // RegAllocatorBase
 
 VReg RegAllocatorBase::Spill(IRNode *ins, VReg reg)
 {
     VReg origin = spiller_->NewOrigin();
-    VReg spillReg = spiller_->NewSpill(origin.GetType());
+    const auto *originType = spiller_->GetCodeGen()->GetVRegType(origin);
+    VReg spillReg = spiller_->NewSpill(originType);
 
-    if (origin.GetType() != nullptr) {
-        PushBack(spiller_->MoveReg(ins->Node(), spillReg, origin));
+    if (originType != nullptr) {
+        if (auto *mov = spiller_->MoveReg(ins->Node(), spillReg, origin); mov != nullptr) {
+            PushBack(mov);
+        }
     }
 
-    PushBack(spiller_->MoveReg(ins->Node(), origin, reg));
+    if (auto *mov = spiller_->MoveReg(ins->Node(), origin, reg); mov != nullptr) {
+        PushBack(mov);
+    }
 
     return origin;
 }
@@ -73,21 +66,24 @@ void RegAllocatorBase::Restore(IRNode *ins)
     VReg origin = spiller_->RestoreOrigin();
     VReg spillReg = spiller_->RestoreSpill();
 
-    if (origin.GetType() == nullptr) {
+    if (spiller_->GetCodeGen()->GetVRegType(origin) == nullptr) {
         return;
     }
 
-    PushBack(spiller_->MoveReg(ins->Node(), origin, spillReg));
+    if (auto *mov = spiller_->MoveReg(ins->Node(), origin, spillReg); mov != nullptr) {
+        PushBack(mov);
+    }
 }
 
 // RegAllocator
 
-void RegAllocator::Run(IRNode *ins)
+void RegAllocator::Run(IRNode *ins, const int32_t spillMax)
 {
     ASSERT(spiller_->Restored());
     std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
     auto regCnt = ins->Registers(&regs);
-    auto registers = Span<VReg *>(regs.data(), regs.data() + regCnt);
+    auto registers =
+        Span<VReg *>(regs.data(), regs.data() + (spillMax == std::numeric_limits<int32_t>::max() ? regCnt : spillMax));
 
     if (CheckRegIndices(ins, registers)) {
         PushBack(ins);
diff --git a/compiler/core/regAllocator.h b/compiler/core/regAllocator.h
index 97248e30acfebdabb715c4c28b46b89ed518b986..544562fae315a8e4a415ee46dcc47edf12e8ed60 100644
--- a/compiler/core/regAllocator.h
+++ b/compiler/core/regAllocator.h
@@ -74,17 +74,6 @@ public:
     }
 };
 
-class FrontAllocator : public AllocatorBase {
-public:
-    explicit FrontAllocator(CodeGen *pg);
-    NO_COPY_SEMANTIC(FrontAllocator);
-    NO_MOVE_SEMANTIC(FrontAllocator);
-    ~FrontAllocator();
-
-private:
-    ArenaList<IRNode *> insn_;
-};
-
 class RegAllocatorBase : public AllocatorBase {
 public:
     explicit RegAllocatorBase(CodeGen *cg, RegSpiller *spiller) : AllocatorBase(cg), spiller_(spiller) {}
@@ -131,15 +120,15 @@ public:
     NO_MOVE_SEMANTIC(RegAllocator);
     ~RegAllocator() = default;
 
-    template <typename T, typename... Args>
+    template <typename T, int32_t ValidVregs = std::numeric_limits<int32_t>::max(), typename... Args>
     void Emit(const ir::AstNode *node, Args &&...args)
     {
         auto *ins = Alloc<T>(node, std::forward<Args>(args)...);
-        Run(ins);
+        Run(ins, ValidVregs);
     }
 
 private:
-    void Run(IRNode *ins);
+    void Run(IRNode *ins, int32_t spillMax);
 };
 
 class RangeRegAllocator : public RegAllocatorBase {
diff --git a/compiler/core/regScope.cpp b/compiler/core/regScope.cpp
index 3cc63532cb19d00f3d7889744ea49da95d93c9ac..7fe199097ab15f522dc8dd7d5b24edfcbc335717 100644
--- a/compiler/core/regScope.cpp
+++ b/compiler/core/regScope.cpp
@@ -94,7 +94,7 @@ void FunctionRegScope::InitializeParams(const StoreParamCb &cb)
 
     VReg paramReg = VReg(VReg::PARAM_START);
     for (auto *param : funcScope->ParamScope()->Params()) {
-        paramReg.SetType(param->TsType());
+        cg_->SetVRegType(paramReg, param->TsType());
         cb(param, paramReg);
         paramReg++;
     }
@@ -106,7 +106,7 @@ void FunctionRegScope::InitializeParams(const StoreParamCb &cb)
         }
 
         if (!var->LexicalBound() && var->IsLocalVariable()) {
-            var->AsLocalVariable()->BindVReg(cg_->AllocReg(var->TsType()));
+            var->AsLocalVariable()->BindVReg(cg_->AllocReg());
         }
     }
 
diff --git a/compiler/core/regSpiller.cpp b/compiler/core/regSpiller.cpp
index 58eb019d7b51f836e8b3bea5e0177411ae453c03..e75cd5a86e974f22e7fc51f59440ea95cf8fcea1 100644
--- a/compiler/core/regSpiller.cpp
+++ b/compiler/core/regSpiller.cpp
@@ -26,67 +26,124 @@ RegScope RegSpiller::Start(CodeGen *cg)
     return RegScope(cg);
 }
 
-VReg DynamicRegSpiller::NewSpill(const checker::Type *type)
+bool RegSpiller::Restored() const
 {
-    return cg_->AllocReg(type);
+    return spillIndex_ == 0;
 }
 
-IRNode *DynamicRegSpiller::MoveReg(const ir::AstNode *node, VReg &vd, VReg vs) const
+size_t RegSpiller::SpillIndex() const
 {
-    return cg_->Allocator()->New<MovDyn>(node, vd, vs);
+    return spillIndex_;
 }
 
-const checker::Type *StaticRegSpiller::At(size_t index)
+size_t RegSpiller::RegEnd() const
 {
-    std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
+    return regEnd_;
+}
 
-    for (auto iter = cg_->Insns().rbegin(); iter != cg_->Insns().rend(); iter++) {
-        auto *insn = *iter;
+size_t RegSpiller::operator++()
+{
+    return ++spillIndex_;
+}
 
-        auto regCnt = insn->Registers(&regs);
-        auto registers = Span<VReg *>(regs.data(), regs.data() + regCnt);
+size_t RegSpiller::operator++(int)
+{
+    return spillIndex_++;
+}
 
-        for (auto *reg : registers) {
-            if (reg->GetIndex() == index) {
-                return reg->GetType();
-            }
-        }
-    }
+size_t RegSpiller::operator--()
+{
+    return --spillIndex_;
+}
+
+size_t RegSpiller::operator--(int)
+{
+    return spillIndex_--;
+}
+
+CodeGen *RegSpiller::GetCodeGen() const
+{
+    return cg_;
+}
+
+VReg DynamicRegSpiller::NewSpill(const checker::Type *type)
+{
+    return GetCodeGen()->AllocReg(type);
+}
 
-    return nullptr;
+VReg DynamicRegSpiller::RestoreSpill()
+{
+    return VReg(RegEnd() - SpillIndex());
+}
+
+VReg DynamicRegSpiller::NewOrigin()
+{
+    const auto oldSpillIndex = (*this)++;
+    return VReg(VReg::REG_START - oldSpillIndex);
+}
+
+VReg DynamicRegSpiller::RestoreOrigin()
+{
+    const auto newSpillIndex = --(*this);
+    return VReg(VReg::REG_START - newSpillIndex);
+}
+
+IRNode *DynamicRegSpiller::MoveReg(const ir::AstNode *node, VReg &vd, VReg vs) const
+{
+    return GetCodeGen()->Allocator()->New<MovDyn>(node, vd, vs);
 }
 
+void DynamicRegSpiller::Finalize() {}
+
 VReg StaticRegSpiller::NewSpill(const checker::Type *type)
 {
-    auto reg = cg_->AllocReg(type);
+    auto reg = GetCodeGen()->AllocReg(type);
     spills_.push_back(reg);
     return reg;
 }
 
+VReg StaticRegSpiller::RestoreSpill()
+{
+    const auto newSpillIndex = --(*this);
+    return spills_[newSpillIndex];
+}
+
 VReg StaticRegSpiller::NewOrigin()
 {
-    auto idx = VReg::REG_START - spillIndex_++;
-    return VReg(idx, At(idx));
+    const auto oldSpillIndex = (*this)++;
+    const auto idx = VReg::REG_START - oldSpillIndex;
+    return VReg(idx);
 }
 
 VReg StaticRegSpiller::RestoreOrigin()
 {
-    auto idx = spillIndex_ - 1;
-    return VReg(VReg::REG_START - idx, spills_[idx].GetType());
+    const auto idx = SpillIndex() - 1;
+    return VReg(VReg::REG_START - idx);
+}
+
+void StaticRegSpiller::Finalize()
+{
+    spills_.clear();
 }
 
 IRNode *StaticRegSpiller::MoveReg(const ir::AstNode *node, VReg &vd, VReg vs) const
 {
-    IRNode *ins {};
-    if (vs.GetType()->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
-        ins = cg_->Allocator()->New<MovObj>(node, vd, vs);
-    } else if (vs.GetType()->HasTypeFlag(checker::TypeFlag::ETS_WIDE_NUMERIC)) {
-        ins = cg_->Allocator()->New<MovWide>(node, vd, vs);
-    } else {
-        ins = cg_->Allocator()->New<Mov>(node, vd, vs);
+    const auto *sourceType = GetCodeGen()->GetVRegType(vs);
+    if (sourceType == nullptr) {
+        return nullptr;
     }
 
-    vd.SetType(vs.GetType());
+    const auto ins = [&vd, &vs, sourceType, node, this]() -> IRNode * {
+        if (sourceType->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT)) {
+            return GetCodeGen()->Allocator()->New<MovObj>(node, vd, vs);
+        }
+        if (sourceType->HasTypeFlag(checker::TypeFlag::ETS_WIDE_NUMERIC)) {
+            return GetCodeGen()->Allocator()->New<MovWide>(node, vd, vs);
+        }
+        return GetCodeGen()->Allocator()->New<Mov>(node, vd, vs);
+    }();
+
+    GetCodeGen()->SetVRegType(vd, sourceType);
 
     return ins;
 }
diff --git a/compiler/core/regSpiller.h b/compiler/core/regSpiller.h
index 232d60516bf20f5fe4e64990a2f3859b3bf83c7a..c91040991da8b1344720e32b5ad423130ae25e61 100644
--- a/compiler/core/regSpiller.h
+++ b/compiler/core/regSpiller.h
@@ -44,17 +44,20 @@ public:
     virtual VReg RestoreOrigin() = 0;
     virtual void Finalize() = 0;
 
-    bool Restored() const
-    {
-        return spillIndex_ == 0;
-    }
+    bool Restored() const;
+    size_t SpillIndex() const;
+    size_t RegEnd() const;
+    CodeGen *GetCodeGen() const;
 
-    // NOLINTBEGIN(misc-non-private-member-variables-in-classes)
-protected:
+    size_t operator++();
+    size_t operator++(int);
+    size_t operator--();
+    size_t operator--(int);
+
+private:
     CodeGen *cg_ {};
     size_t spillIndex_ {0};
     size_t regEnd_ {0};
-    // NOLINTEND(misc-non-private-member-variables-in-classes)
 };
 
 class DynamicRegSpiller : public RegSpiller {
@@ -65,23 +68,10 @@ public:
     ~DynamicRegSpiller() override = default;
 
     VReg NewSpill(const checker::Type *type) override;
-
-    VReg RestoreSpill() override
-    {
-        return VReg(regEnd_ - spillIndex_);
-    }
-
-    VReg NewOrigin() override
-    {
-        return VReg(VReg::REG_START - spillIndex_++);
-    }
-
-    VReg RestoreOrigin() override
-    {
-        return VReg(VReg::REG_START - --spillIndex_);
-    }
-
-    void Finalize() override {}
+    VReg RestoreSpill() override;
+    VReg NewOrigin() override;
+    VReg RestoreOrigin() override;
+    void Finalize() override;
 
     IRNode *MoveReg(const ir::AstNode *node, VReg &vd, VReg vs) const override;
 
@@ -96,24 +86,14 @@ public:
     ~StaticRegSpiller() override = default;
 
     VReg NewSpill(const checker::Type *type) override;
-
-    VReg RestoreSpill() override
-    {
-        return spills_[--spillIndex_];
-    }
-
+    VReg RestoreSpill() override;
     VReg NewOrigin() override;
     VReg RestoreOrigin() override;
-    void Finalize() override
-    {
-        spills_.clear();
-    }
+    void Finalize() override;
 
     IRNode *MoveReg(const ir::AstNode *node, VReg &vd, VReg vs) const override;
 
 private:
-    const checker::Type *At(size_t index);
-
     std::vector<VReg> spills_ {};
 };
 
diff --git a/compiler/core/switchBuilder.h b/compiler/core/switchBuilder.h
index 9614c0f1158fa53bb90507cbd70c48890f42ec98..a32f3900e6a77d00ed2c90ef29810958ff292264 100644
--- a/compiler/core/switchBuilder.h
+++ b/compiler/core/switchBuilder.h
@@ -75,7 +75,7 @@ public:
         if constexpr (std::is_same_v<CodeGen, PandaGen>) {
             cg_->Condition(caseTarget, lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL, tag, caseLabels_[index]);
         } else {
-            compiler::TargetTypeContext ttctx(cg_, tag.GetType());
+            compiler::TargetTypeContext ttctx(cg_, cg_->GetVRegType(tag));
             cg_->Condition(caseTarget, lexer::TokenType::PUNCTUATOR_NOT_EQUAL, tag, caseLabels_[index]);
         }
     }
diff --git a/compiler/core/vReg.h b/compiler/core/vReg.h
index ac7ec63896f3168864fe0021f8a9f4652c274c96..8b316cd94d787b59c4d6b24d78e14d68edfe50c9 100644
--- a/compiler/core/vReg.h
+++ b/compiler/core/vReg.h
@@ -29,8 +29,8 @@ class VReg {
 public:
     using Index = uint32_t;
     explicit constexpr VReg() : VReg(INVALID_IDX) {}
-    explicit constexpr VReg(uint32_t idx) : VReg(idx, nullptr) {}
-    explicit constexpr VReg(uint32_t idx, const checker::Type *type) : idx_(idx), type_(type) {}
+    explicit constexpr VReg(uint32_t idx) : idx_(idx) {}
+
     ~VReg() = default;
     DEFAULT_COPY_SEMANTIC(VReg);
     DEFAULT_MOVE_SEMANTIC(VReg);
@@ -45,24 +45,14 @@ public:
         idx_ = idx;
     }
 
-    void SetType(const checker::Type *type)
-    {
-        type_ = type;
-    }
-
-    const checker::Type *GetType() const
-    {
-        return type_;
-    }
-
     static constexpr VReg Invalid()
     {
-        return VReg(INVALID_IDX, nullptr);
+        return VReg(INVALID_IDX);
     }
 
     static constexpr VReg RegStart()
     {
-        return VReg(REG_START, nullptr);
+        return VReg(REG_START);
     }
 
     bool IsInvalid() const
@@ -125,12 +115,12 @@ public:
 
     VReg operator+(const Index idx)
     {
-        return VReg(idx_ + idx, type_);
+        return VReg(idx_ + idx);
     }
 
     VReg operator+(const VReg &other)
     {
-        return VReg(idx_ + other.idx_, type_);
+        return VReg(idx_ + other.idx_);
     }
 
     static constexpr auto REG_START = std::numeric_limits<uint16_t>::max();
@@ -141,7 +131,6 @@ private:
     static constexpr auto INVALID_IDX = std::numeric_limits<Index>::max();
 
     Index idx_;
-    const checker::Type *type_;
 };
 }  // namespace panda::es2panda::compiler
 
diff --git a/ir/astNode.h b/ir/astNode.h
index c16c5497bde7fd40855a89689931a095726a1cdd..f87f7e96f3635634f6005a69b97cb822131079f4 100644
--- a/ir/astNode.h
+++ b/ir/astNode.h
@@ -82,6 +82,8 @@ enum class ModifierFlags : uint32_t {
     CONSTRUCTOR = 1U << 14U,
     SYNCHRONIZED = 1U << 15U,
     FUNCTIONAL = 1U << 16U,
+    IN = 1U << 17U,
+    OUT = 1U << 18U,
     ACCESS = PUBLIC | PROTECTED | PRIVATE,
     ALL = STATIC | ASYNC | ACCESS | DECLARE | READONLY | ABSTRACT,
     ALLOWED_IN_CTOR_PARAMETER = ACCESS | READONLY,
@@ -387,6 +389,16 @@ public:
         return (flags_ & ModifierFlags::DECLARE) != 0;
     }
 
+    bool IsIn() const
+    {
+        return (flags_ & ModifierFlags::IN) != 0;
+    }
+
+    bool IsOut() const
+    {
+        return (flags_ & ModifierFlags::OUT) != 0;
+    }
+
     void AddModifier(ModifierFlags flags)
     {
         flags_ |= flags;
diff --git a/ir/ets/etsClassLiteral.cpp b/ir/ets/etsClassLiteral.cpp
index 2bb1c2c655b384441400dc5adf7b2204dafbb8b2..0ae1bcce09c766f6406c967b200021dc74b951a1 100644
--- a/ir/ets/etsClassLiteral.cpp
+++ b/ir/ets/etsClassLiteral.cpp
@@ -41,7 +41,7 @@ void ETSClassLiteral::Compile([[maybe_unused]] compiler::ETSGen *etsg) const
         etsg->GetType(this, false);
     } else {
         ASSERT(expr_->TsType()->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE));
-        etsg->Acc().SetType(expr_->TsType());
+        etsg->SetAccumulatorType(expr_->TsType());
         etsg->GetType(this, true);
     }
 }
diff --git a/ir/ets/etsMethodReferenceExpression.cpp b/ir/ets/etsMethodReferenceExpression.cpp
index 59419ec91e508fdbaca7c147c7de03989ac91d38..ccdb0517bfc69f25914b1652ba5ca0c65f6271ed 100644
--- a/ir/ets/etsMethodReferenceExpression.cpp
+++ b/ir/ets/etsMethodReferenceExpression.cpp
@@ -61,7 +61,7 @@ void ETSMethodReferenceExpression::Compile([[maybe_unused]] compiler::ETSGen *et
     ArenaVector<ir::Expression *> args(etsg->Allocator()->Adapter());
     args.push_back(base_);
     etsg->InitObject(this, lambdaObject_->TsType()->AsETSObjectType()->ConstructSignatures()[0], args);
-    etsg->Acc().SetType(lambdaObject_->TsType());
+    etsg->SetAccumulatorType(lambdaObject_->TsType());
 }
 
 checker::Type *ETSMethodReferenceExpression::Check([[maybe_unused]] checker::TSChecker *checker)
diff --git a/ir/ets/etsNewClassInstanceExpression.cpp b/ir/ets/etsNewClassInstanceExpression.cpp
index 8df28aefa5ec5688c6ef219729159b7c1d5a308a..7e80b1268f289a7132dfab7dc7b74a4c0e138cb3 100644
--- a/ir/ets/etsNewClassInstanceExpression.cpp
+++ b/ir/ets/etsNewClassInstanceExpression.cpp
@@ -50,7 +50,7 @@ void ETSNewClassInstanceExpression::Compile([[maybe_unused]] compiler::PandaGen
 void ETSNewClassInstanceExpression::Compile([[maybe_unused]] compiler::ETSGen *etsg) const
 {
     etsg->InitObject(this, signature_, arguments_);
-    etsg->Acc().SetType(TsType());
+    etsg->SetAccumulatorType(TsType());
 }
 
 checker::Type *ETSNewClassInstanceExpression::Check([[maybe_unused]] checker::TSChecker *checker)
diff --git a/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp b/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp
index e21c0405e0bad6ea5685257a99ddd7ad4fc6bb7e..a69f77b608e67385ae0b601a81f56ffa025be3b1 100644
--- a/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp
+++ b/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp
@@ -42,7 +42,7 @@ void ETSNewMultiDimArrayInstanceExpression::Compile([[maybe_unused]] compiler::P
 void ETSNewMultiDimArrayInstanceExpression::Compile([[maybe_unused]] compiler::ETSGen *etsg) const
 {
     etsg->InitObject(this, signature_, dimensions_);
-    etsg->Acc().SetType(TsType());
+    etsg->SetAccumulatorType(TsType());
 }
 
 checker::Type *ETSNewMultiDimArrayInstanceExpression::Check([[maybe_unused]] checker::TSChecker *checker)
diff --git a/ir/ets/etsWildcardType.cpp b/ir/ets/etsWildcardType.cpp
index 2912d0d236a7b6416d03f40707e00659101208e0..500c167cca2401e34992528050b378760b53664a 100644
--- a/ir/ets/etsWildcardType.cpp
+++ b/ir/ets/etsWildcardType.cpp
@@ -24,20 +24,17 @@
 namespace panda::es2panda::ir {
 void ETSWildcardType::Iterate([[maybe_unused]] const NodeTraverser &cb) const
 {
-    if (extendsBound_ != nullptr) {
-        cb(extendsBound_);
-    }
-
-    if (superBound_ != nullptr) {
-        cb(superBound_);
+    if (typeReference_ != nullptr) {
+        cb(typeReference_);
     }
 }
 
 void ETSWildcardType::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "ETSWildcardType"},
-                 {"superBound", AstDumper::Optional(superBound_)},
-                 {"extendsBound", AstDumper::Optional(extendsBound_)}});
+                 {"typeReference", AstDumper::Optional(typeReference_)},
+                 {"in", AstDumper::Optional(IsIn())},
+                 {"out", AstDumper::Optional(IsOut())}});
 }
 
 void ETSWildcardType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ets/etsWildcardType.h b/ir/ets/etsWildcardType.h
index 7a8c9c90b3982ceb4d92a2b0eac276b4ed32dd47..0f1588ed8592a40c45a17934340d5a4b5fc58dd4 100644
--- a/ir/ets/etsWildcardType.h
+++ b/ir/ets/etsWildcardType.h
@@ -22,36 +22,15 @@ namespace panda::es2panda::ir {
 
 class ETSWildcardType : public TypeNode {
 public:
-    explicit ETSWildcardType() : TypeNode(AstNodeType::ETS_WILDCARD_TYPE) {}
-
-    void SetExtendsBound(ir::ETSTypeReference *bound)
-    {
-        extendsBound_ = bound;
-    }
-
-    const ir::ETSTypeReference *ExtendsBound() const
-    {
-        return extendsBound_;
-    }
-
-    ir::ETSTypeReference *ExtendsBound()
-    {
-        return extendsBound_;
-    }
-
-    void SetSuperBound(ir::ETSTypeReference *bound)
-    {
-        superBound_ = bound;
-    }
-
-    const ir::ETSTypeReference *SuperBound() const
+    explicit ETSWildcardType(ir::ETSTypeReference *typeReference, ModifierFlags flags)
+        : TypeNode(AstNodeType::ETS_WILDCARD_TYPE, flags), typeReference_(typeReference)
     {
-        return superBound_;
+        ASSERT((flags == ModifierFlags::IN && typeReference != nullptr) || flags == ModifierFlags::OUT);
     }
 
-    ir::ETSTypeReference *SuperBound()
+    ir::ETSTypeReference *TypeReference()
     {
-        return superBound_;
+        return typeReference_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -64,8 +43,7 @@ public:
     checker::Type *GetType([[maybe_unused]] checker::ETSChecker *checker) override;
 
 private:
-    ir::ETSTypeReference *extendsBound_ {};
-    ir::ETSTypeReference *superBound_ {};
+    ir::ETSTypeReference *typeReference_ {};
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/expression.h b/ir/expression.h
index b9a56eadd113d92bb23b472274e1e8247a3372b4..abc8997019c27ea145fc8b0ca3509df4e5ceb968 100644
--- a/ir/expression.h
+++ b/ir/expression.h
@@ -93,6 +93,7 @@ public:
 
 protected:
     explicit Expression(AstNodeType type) : TypedAstNode(type) {}
+    explicit Expression(AstNodeType type, ModifierFlags flags) : TypedAstNode(type, flags) {}
 
 private:
     bool grouped_ {};
diff --git a/ir/expressions/callExpression.cpp b/ir/expressions/callExpression.cpp
index e29d45fbe9478ee46481efc4b89864c78a81f9c0..70ef923381fc847a768f94e4b073e08f0a87f797 100644
--- a/ir/expressions/callExpression.cpp
+++ b/ir/expressions/callExpression.cpp
@@ -174,7 +174,7 @@ void CallExpression::Compile(compiler::ETSGen *etsg) const
     } else {
         etsg->CallThisVirtual(this, calleeReg, signature_, arguments_);
     }
-    etsg->Acc().SetType(TsType());
+    etsg->SetAccumulatorType(TsType());
 }
 
 checker::Type *CallExpression::Check(checker::TSChecker *checker)
diff --git a/ir/expressions/sequenceExpression.cpp b/ir/expressions/sequenceExpression.cpp
index a763309d424cb624acd0f86584070751e13e34e2..8629be59e0a3d03f617a1d7c81ffe2c33bdd9f85 100644
--- a/ir/expressions/sequenceExpression.cpp
+++ b/ir/expressions/sequenceExpression.cpp
@@ -38,14 +38,24 @@ void SequenceExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const
     }
 }
 
+void SequenceExpression::Compile(compiler::ETSGen *etsg) const
+{
+    for (const auto *it : sequence_) {
+        it->Compile(etsg);
+    }
+}
+
 checker::Type *SequenceExpression::Check([[maybe_unused]] checker::TSChecker *checker)
 {
     // TODO(aszilagyi)
     return checker->GlobalAnyType();
 }
 
-checker::Type *SequenceExpression::Check([[maybe_unused]] checker::ETSChecker *checker)
+checker::Type *SequenceExpression::Check(checker::ETSChecker *checker)
 {
+    for (auto *it : sequence_) {
+        it->Check(checker);
+    }
     return nullptr;
 }
 }  // namespace panda::es2panda::ir
diff --git a/ir/expressions/sequenceExpression.h b/ir/expressions/sequenceExpression.h
index 386321e13045a2fbecd9ba4da7b67939c27beead..b3bd90204a6f3a3fb55bacb9f37f06cad14b1a60 100644
--- a/ir/expressions/sequenceExpression.h
+++ b/ir/expressions/sequenceExpression.h
@@ -38,8 +38,9 @@ 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;
+    checker::Type *Check(checker::ETSChecker *checker) override;
 
 private:
     ArenaVector<Expression *> sequence_;
diff --git a/ir/statements/panicStatement.cpp b/ir/statements/panicStatement.cpp
index d741905e2336f7df25458fd3d5b34b27db85fb96..a728dd523a0efa227bf71f984919cf144c328f02 100644
--- a/ir/statements/panicStatement.cpp
+++ b/ir/statements/panicStatement.cpp
@@ -41,7 +41,7 @@ void PanicStatement::Compile([[maybe_unused]] compiler::ETSGen *etsg) const
 
     expr_->Compile(etsg);
 
-    if (etsg->Acc().GetType()->IsETSNullType()) {
+    if (etsg->GetAccumulatorType()->IsETSNullType()) {
         etsg->EmitNullPointerException(this);
         return;
     }
diff --git a/ir/ts/tsAsExpression.cpp b/ir/ts/tsAsExpression.cpp
index a600e65b8531c6bd8d3c7d5de303c8627775a667..c0d9d62d7e4e79f487983e5f79621ace34609be9 100644
--- a/ir/ts/tsAsExpression.cpp
+++ b/ir/ts/tsAsExpression.cpp
@@ -78,7 +78,7 @@ void TSAsExpression::Compile([[maybe_unused]] compiler::ETSGen *etsg) const
         }
         default: {
             // TODO(user): implement for objects properly: add runtime check, implement for intersection types
-            etsg->Acc().SetType(TsType());
+            etsg->SetAccumulatorType(TsType());
         }
     }
 }
diff --git a/ir/ts/tsTypeParameter.cpp b/ir/ts/tsTypeParameter.cpp
index 69b18aeb8dae98fb9daa4b9cde8b8fbbfeb405dc..f63c96415508cc72cdeaada161c6d79e94476bb8 100644
--- a/ir/ts/tsTypeParameter.cpp
+++ b/ir/ts/tsTypeParameter.cpp
@@ -40,6 +40,8 @@ void TSTypeParameter::Dump(ir::AstDumper *dumper) const
         {"name", name_},
         {"constraint", AstDumper::Optional(constraint_)},
         {"default", AstDumper::Optional(defaultType_)},
+        {"in", AstDumper::Optional(IsIn())},
+        {"out", AstDumper::Optional(IsOut())},
     });
 }
 
diff --git a/ir/ts/tsTypeParameter.h b/ir/ts/tsTypeParameter.h
index 0824ff561cb77fa4f723794d2e15f8f9ae0a21d1..a7be6d3745eb678f5d27a647353fda0dc4e9dc6a 100644
--- a/ir/ts/tsTypeParameter.h
+++ b/ir/ts/tsTypeParameter.h
@@ -28,6 +28,15 @@ public:
     {
     }
 
+    explicit TSTypeParameter(Identifier *name, TypeNode *constraint, TypeNode *defaultType, ModifierFlags flags)
+        : Expression(AstNodeType::TS_TYPE_PARAMETER, flags),
+          name_(name),
+          constraint_(constraint),
+          defaultType_(defaultType)
+    {
+        ASSERT(flags == ModifierFlags::NONE || flags == ModifierFlags::IN || flags == ModifierFlags::OUT);
+    }
+
     const Identifier *Name() const
     {
         return name_;
diff --git a/ir/typeNode.h b/ir/typeNode.h
index 20d0c22ff379fa7b8afd32ad3b1258533e137985..e36d0d4ed62474b7e3e6e3d55296a1dc9fbd7125 100644
--- a/ir/typeNode.h
+++ b/ir/typeNode.h
@@ -27,6 +27,7 @@ namespace panda::es2panda::ir {
 class TypeNode : public Expression {
 public:
     explicit TypeNode(AstNodeType type) : Expression(type) {}
+    explicit TypeNode(AstNodeType type, ModifierFlags flags) : Expression(type, flags) {}
 
     bool IsTypeNode() const override
     {
diff --git a/lexer/scripts/keywords.yaml b/lexer/scripts/keywords.yaml
index ed1ff9684822de6ad1aedc5654db7eb87f3a7eb2..97b395468e974dba611409a0e3af98d4517616ed 100644
--- a/lexer/scripts/keywords.yaml
+++ b/lexer/scripts/keywords.yaml
@@ -246,7 +246,8 @@ keywords:
 
   - name: 'in'
     token: KEYW_IN
-    keyword: [as, js, ets, ts]
+    keyword: [as, js, ts]
+    keyword_like: [ets]
 
   - name: 'infer'
     token: KEYW_INFER
@@ -330,6 +331,10 @@ keywords:
     token: KEYW_OPEN
     keyword: [ets]
 
+  - name: 'out'
+    token: KEYW_OUT
+    keyword_like: [ets]
+
   - name: 'override'
     token: KEYW_OVERRIDE
     keyword: [ets]
diff --git a/lexer/token/token.cpp b/lexer/token/token.cpp
index 6fdb73ff4015fe59a0906154b28b878527279161..97ea93fd9ca1c779ad4e84d4a05d72af2c5b7208 100644
--- a/lexer/token/token.cpp
+++ b/lexer/token/token.cpp
@@ -288,6 +288,8 @@ const char *TokenToString(TokenType type)  // NOLINT(readability-function-size)
             return "char";
         case TokenType::KEYW_CONST:
             return "const";
+        case TokenType::KEYW_CONSTRUCTOR:
+            return "constructor";
         case TokenType::KEYW_CONTINUE:
             return "continue";
         case TokenType::KEYW_DEBUGGER:
@@ -416,8 +418,10 @@ const char *TokenToString(TokenType type)  // NOLINT(readability-function-size)
             return "else";
         case TokenType::EOS:
             return "eos";
+        case TokenType::KEYW_OUT:
+            return "out";
         default:
-            return {};
+            return "";
     }
 }
 }  // namespace panda::es2panda::lexer
diff --git a/lexer/token/tokenType.h b/lexer/token/tokenType.h
index e73529c4995efe0820ffc97b86b44a0d91ae3d36..b4600837552c2b81218ac357c2f080df828e8157 100644
--- a/lexer/token/tokenType.h
+++ b/lexer/token/tokenType.h
@@ -106,6 +106,7 @@ enum class TokenType {
     KEYW_REQUIRE,
     KEYW_ABSTRACT,
     KEYW_TARGET,
+    KEYW_OUT,
 
     /* reserved keywords */
     FIRST_KEYW,
diff --git a/migrator/build.xml b/migrator/build.xml
index b2f2388064cfe78e38a273efd59fdd69adb5cbca..859cb7fc0afc224c5608a1d52c0643d1296bcba3 100644
--- a/migrator/build.xml
+++ b/migrator/build.xml
@@ -35,6 +35,7 @@
 
     <property name="typescript.dir" location="typescript"/>
     <property name="typescript.build.dir" location="${typescript.dir}/build"/>
+    <property name="typescript.out.dir" location="${out.dir}/typescript"/>
 
     <!-- Set of all project libraries needed to compile sources -->
     <path id="project.classpath">
@@ -79,6 +80,7 @@
         <mkdir dir="${build.classes.dir}"/>
         <mkdir dir="${out.dir}"/>
         <mkdir dir="${out.dir}/config"/>
+        <mkdir dir="${typescript.out.dir}"/>
     </target>
 
     <!-- Run Antlr4 to generate lexer/parser for specified grammar file -->
@@ -119,14 +121,14 @@
                 <arg value="npm"/>
                 <arg value="install"/>
             </exec>
-
-            <!-- Do the same command for unix/macosx? -->
+            <exec executable="npm" dir="${typescript.dir}" osfamily="unix" failonerror="true">
+                <arg value="install"/>
+            </exec>
         </sequential>
     </macrodef>
 
     <target name="-typescript" description="compile typescript">
         <npm-install/>
-        <!-- TODO: Copy the compiled files to 'out/typescript' -->
     </target>
 
     <target name="-compile" depends="-compile_without_ts,-typescript" description="compile all sources"/>
@@ -149,6 +151,13 @@
         </copy>
     </target>
 
+    <target name="-copy_ts_translator" description="copy compiled TS translator">
+        <copy todir="${typescript.out.dir}" flatten="false">
+            <fileset dir="${typescript.build.dir}" includes="javascript/**/*"/>
+            <fileset dir="${typescript.dir}" includes="node_modules/**/*"/>
+        </copy>
+    </target>
+
     <target name="-copy_mapping_rules" description="copy API mapping rule files to the distribution directory">
         <copy todir="${out.dir}/config" flatten="true">
             <fileset dir="${api.mapper.rules.dir}">
@@ -254,7 +263,7 @@
         <run-tests lang="ts"/>
     </target>
 
-    <target name="build" depends="-compile,-copy_lib,-copy_mapping_rules,-make_jar"
+    <target name="build" depends="-compile,-copy_lib,-copy_mapping_rules,-copy_ts_translator,-make_jar"
             description="compile and generate all project files">
         <tstamp>
             <format property="done.tstamp" pattern="yyyy-MM-dd HH:mm:ss"/>
diff --git a/migrator/config/java-api-mapper.xml b/migrator/config/java-api-mapper.xml
index ed623b6419a8f3b9064d3a2ca8e0c7703815a424..964748e077f4292c996b4c9d603b053da54a6102 100644
--- a/migrator/config/java-api-mapper.xml
+++ b/migrator/config/java-api-mapper.xml
@@ -55,7 +55,7 @@
         <!-- This rule specifies the type argument for the resulting generic method. -->
         <ArktsMethodTypeArgs>
             <TypeArguments>
-                <TypeReference arktsName="Float"/>
+                <TypeReference arktsTypeName="Float"/>
             </TypeArguments>
         </ArktsMethodTypeArgs>
     </CallExpressionRule>
@@ -65,7 +65,7 @@
         <!-- This rule specifies the type argument for the resulting generic method. -->
         <ArktsMethodTypeArgs>
             <TypeArguments>
-                <TypeReference arktsName="Double"/>
+                <TypeReference arktsTypeName="Double"/>
             </TypeArguments>
         </ArktsMethodTypeArgs>
     </CallExpressionRule>
@@ -199,7 +199,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Boolean(x) -->
-                <TypeReference arktsName="Boolean"/>
+                <TypeReference arktsTypeName="Boolean"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -209,7 +209,7 @@
         <ArktsMethodName value="compareTo"/>
         <Arguments>
             <NewClassInstanceExpression> <!-- new Boolean(y) -->
-                <TypeReference arktsName="Boolean"/>
+                <TypeReference arktsTypeName="Boolean"/>
                 <Arguments>
                     <SrcArgument index="1"/>
                 </Arguments>
@@ -225,7 +225,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Boolean(x) -->
-                <TypeReference arktsName="Boolean"/>
+                <TypeReference arktsTypeName="Boolean"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -243,7 +243,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Boolean(x) -->
-                <TypeReference arktsName="Boolean"/>
+                <TypeReference arktsTypeName="Boolean"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -258,20 +258,37 @@
     <CallRules.java.lang.Byte>
     <CallExpressionRule javaType="java.lang.Byte" javaMethodName="toString" javaMethodArgs="byte">
         <!--
-            static int toString(byte b)
+            static String toString(byte b)
             ==>
             new Byte(b).toString()
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Byte(b) -->
-                <TypeReference arktsName="Byte"/>
+                <TypeReference arktsTypeName="Byte"/>
+                <Arguments>
+                    <SrcArgument index="0"/>
+                </Arguments>
+            </NewClassInstanceExpression>
+        </ArktsObject>
+
+        <Arguments/> <!-- Denotes an empty list of arguments. -->
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Byte" javaMethodName="toString" javaMethodArgs="byte">
+        <!--
+            static int hashCode(byte b)
+            ==>
+            new Byte(b).hashCode()
+        -->
+        <ArktsObject>
+            <NewClassInstanceExpression> <!-- new Byte(b) -->
+                <TypeReference arktsTypeName="Byte"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
             </NewClassInstanceExpression>
         </ArktsObject>
 
-        <!--        <ArktsMethodName value="toString"/>-->
         <Arguments/> <!-- Denotes an empty list of arguments. -->
     </CallExpressionRule>
 
@@ -283,7 +300,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Byte(b1) -->
-                <TypeReference arktsName="Byte"/>
+                <TypeReference arktsTypeName="Byte"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -293,7 +310,7 @@
         <ArktsMethodName value="compareTo"/>
         <Arguments>
             <NewClassInstanceExpression> <!-- new Byte(b2) -->
-                <TypeReference arktsName="Byte"/>
+                <TypeReference arktsTypeName="Byte"/>
                 <Arguments>
                     <SrcArgument index="1"/>
                 </Arguments>
@@ -303,57 +320,169 @@
     </CallRules.java.lang.Byte>
 
     <CallRules.java.lang.Character>
-    <CallExpressionRule javaType="java.lang.Character" javaMethodName="highSurrogate">
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="compare" javaMethodArgs="char,char">
         <!--
-            char highSurrogate(int codePoint)
+            static int compare(char c1, char c2)
             ==>
-            static getHighSurrogate(value: int): char
+            new Char(c1).compareTo(new Char(c2))
         -->
+        <ArktsObject>
+            <NewClassInstanceExpression> <!-- new Char(c1) -->
+                <TypeReference arktsTypeName="Char"/>
+                <Arguments>
+                    <SrcArgument index="0"/>
+                </Arguments>
+            </NewClassInstanceExpression>
+        </ArktsObject>
+
+        <ArktsMethodName value="compareTo"/>
+        <Arguments>
+            <NewClassInstanceExpression> <!-- new Double(c2) -->
+                <TypeReference arktsTypeName="Char"/>
+                <Arguments>
+                    <SrcArgument index="1"/>
+                </Arguments>
+            </NewClassInstanceExpression>
+        </Arguments>
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="hashCode" javaMethodArgs="char">
+        <!--
+            static int Character.hashCode(char value)
+            ==>
+            static Char.hashCode(value: char): int
+        -->
+        <ArktsTypeName value="Char"/>
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="highSurrogate" javaMethodArgs="int">
+        <!--
+            static char Character.highSurrogate(int codePoint)
+            ==>
+            static Char.getHighSurrogate(codePoint: int): char
+        -->
+        <ArktsTypeName value="Char"/>
         <ArktsMethodName value="getHighSurrogate"/>
     </CallExpressionRule>
 
-    <CallExpressionRule javaType="java.lang.Character" javaMethodName="lowSurrogate">
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="lowSurrogate" javaMethodArgs="int">
         <!--
-            char lowSurrogate(int codePoint)
+            static char Character.lowSurrogate(int codePoint)
             ==>
-            static getLowSurrogate(value: int): char
+            static Char.getLowSurrogate(codePoint: int): char
         -->
+        <ArktsTypeName value="Char"/>
         <ArktsMethodName value="getLowSurrogate"/>
     </CallExpressionRule>
 
-    <CallExpressionRule javaType="java.lang.Character" javaMethodName="isDigit">
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="isDigit" javaMethodArgs="char">
         <!--
-            static boolean isDigit(char ch)
+            static boolean Character.isDigit(char ch)
             ==>
-            static isDecDigit(value: char): boolean
+            static Char.isDecDigit(ch: char): boolean
         -->
+        <ArktsTypeName value="Char"/>
         <ArktsMethodName value="isDecDigit"/>
     </CallExpressionRule>
 
-    <CallExpressionRule javaType="java.lang.Character" javaMethodName="compare" javaMethodArgs="char,char">
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="isHighSurrogate" javaMethodArgs="char">
         <!--
-            static int compare(char c1, char c2)
+            static boolean Character.isHighSurrogate(char ch)
             ==>
-            new Char(c1).compareTo(new Char(c2))
+            static Char.isHighSurrogate(ch: char): boolean
+        -->
+        <ArktsTypeName value="Char"/>
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="isLetter" javaMethodArgs="char">
+        <!--
+            static boolean Character.isLetter(char ch)
+            ==>
+            static Char.isLetter(ch: char): boolean
+        -->
+        <ArktsTypeName value="Char"/>
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="isLowerCase" javaMethodArgs="char">
+        <!--
+            static boolean Character.isLowerCase(char ch)
+            ==>
+            static Char.isLowerCase(ch: char): boolean
+        -->
+        <ArktsTypeName value="Char"/>
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="isLowSurrogate" javaMethodArgs="char">
+        <!--
+            static boolean Character.isLowSurrogate(char ch)
+            ==>
+            static Char.isLowSurrogate(ch: char): boolean
+        -->
+        <ArktsTypeName value="Char"/>
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="isUpperCase" javaMethodArgs="char">
+        <!--
+            static boolean Character.isUpperCase(char ch)
+            ==>
+            static Char.isUpperCase(ch: char): boolean
+        -->
+        <ArktsTypeName value="Char"/>
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="isWhitespace" javaMethodArgs="char">
+        <!--
+            static boolean Character.isWhitespace(char ch)
+            ==>
+            static Char.isWhitespace(ch: char): boolean
+        -->
+        <ArktsTypeName value="Char"/>
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="toLowerCase" javaMethodArgs="char">
+        <!--
+            static char Character.toLowerCase(char ch)
+            ==>
+            static Char.toLowerCase(ch: char): char
+        -->
+        <ArktsTypeName value="Char"/>
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="toString" javaMethodArgs="char">
+        <!--
+            static String toString(char c)
+            ==>
+            new Char(c).toString()
         -->
         <ArktsObject>
-            <NewClassInstanceExpression> <!-- new Char(c1) -->
-                <TypeReference arktsName="Char"/>
+            <NewClassInstanceExpression> <!-- new Char(b) -->
+                <TypeReference arktsTypeName="Char"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
             </NewClassInstanceExpression>
         </ArktsObject>
 
-        <ArktsMethodName value="compareTo"/>
-        <Arguments>
-            <NewClassInstanceExpression> <!-- new Double(c2) -->
-                <TypeReference arktsName="Char"/>
-                <Arguments>
-                    <SrcArgument index="1"/>
-                </Arguments>
-            </NewClassInstanceExpression>
-        </Arguments>
+        <Arguments/> <!-- Denotes an empty list of arguments. -->
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="toUpperCase" javaMethodArgs="char">
+        <!--
+            static char Character.toUpperCase(char ch)
+            ==>
+            static Char.toUpperCase(ch: char): char
+        -->
+        <ArktsTypeName value="Char"/>
+    </CallExpressionRule>
+
+    <CallExpressionRule javaType="java.lang.Character" javaMethodName="valueOf" javaMethodArgs="char">
+        <!--
+            static Character Character.valueOf(char ch)
+            ==>
+            static Char.valueOf(ch: char): Char
+        -->
+        <ArktsTypeName value="Char"/>
     </CallExpressionRule>
     </CallRules.java.lang.Character>
 
@@ -366,7 +495,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Double(d1) -->
-                <TypeReference arktsName="Double"/>
+                <TypeReference arktsTypeName="Double"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -376,7 +505,7 @@
         <ArktsMethodName value="compareTo"/>
         <Arguments>
             <NewClassInstanceExpression> <!-- new Double(d2) -->
-                <TypeReference arktsName="Double"/>
+                <TypeReference arktsTypeName="Double"/>
                 <Arguments>
                     <SrcArgument index="1"/>
                 </Arguments>
@@ -394,7 +523,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Float(f1) -->
-                <TypeReference arktsName="Float"/>
+                <TypeReference arktsTypeName="Float"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -404,7 +533,7 @@
         <ArktsMethodName value="compareTo"/>
         <Arguments>
             <NewClassInstanceExpression> <!-- new Float(f2) -->
-                <TypeReference arktsName="Float"/>
+                <TypeReference arktsTypeName="Float"/>
                 <Arguments>
                     <SrcArgument index="1"/>
                 </Arguments>
@@ -420,7 +549,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Float(f) -->
-                <TypeReference arktsName="Float"/>
+                <TypeReference arktsTypeName="Float"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -439,7 +568,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Float(f) -->
-                <TypeReference arktsName="Float"/>
+                <TypeReference arktsTypeName="Float"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -460,7 +589,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Int(i1) -->
-                <TypeReference arktsName="Int"/>
+                <TypeReference arktsTypeName="Int"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -470,7 +599,7 @@
         <ArktsMethodName value="compareTo"/>
         <Arguments>
             <NewClassInstanceExpression> <!-- new Int(i2) -->
-                <TypeReference arktsName="Int"/>
+                <TypeReference arktsTypeName="Int"/>
                 <Arguments>
                     <SrcArgument index="1"/>
                 </Arguments>
@@ -486,7 +615,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Int(i1) -->
-                <TypeReference arktsName="Int"/>
+                <TypeReference arktsTypeName="Int"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -505,7 +634,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Int(i1) -->
-                <TypeReference arktsName="Int"/>
+                <TypeReference arktsTypeName="Int"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -526,7 +655,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Long(l1) -->
-                <TypeReference arktsName="Long"/>
+                <TypeReference arktsTypeName="Long"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -536,7 +665,7 @@
         <ArktsMethodName value="compareTo"/>
         <Arguments>
             <NewClassInstanceExpression> <!-- new Long(l2) -->
-                <TypeReference arktsName="Long"/>
+                <TypeReference arktsTypeName="Long"/>
                 <Arguments>
                     <SrcArgument index="1"/>
                 </Arguments>
@@ -552,7 +681,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Long(i1) -->
-                <TypeReference arktsName="Long"/>
+                <TypeReference arktsTypeName="Long"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -571,7 +700,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Long(i1) -->
-                <TypeReference arktsName="Long"/>
+                <TypeReference arktsTypeName="Long"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -592,7 +721,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Short(s1) -->
-                <TypeReference arktsName="Short"/>
+                <TypeReference arktsTypeName="Short"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -602,7 +731,7 @@
         <ArktsMethodName value="compareTo"/>
         <Arguments>
             <NewClassInstanceExpression> <!-- new Short(s2) -->
-                <TypeReference arktsName="Short"/>
+                <TypeReference arktsTypeName="Short"/>
                 <Arguments>
                     <SrcArgument index="1"/>
                 </Arguments>
@@ -618,7 +747,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Short(s) -->
-                <TypeReference arktsName="Short"/>
+                <TypeReference arktsTypeName="Short"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -637,7 +766,7 @@
         -->
         <ArktsObject>
             <NewClassInstanceExpression> <!-- new Short(s) -->
-                <TypeReference arktsName="Short"/>
+                <TypeReference arktsTypeName="Short"/>
                 <Arguments>
                     <SrcArgument index="0"/>
                 </Arguments>
@@ -650,7 +779,7 @@
     </CallRules.java.lang.Short>
 
     <CallRules.java.lang.String>
-    <CallExpressionRule javaType="java.lang.String" javaMethodName="contains" javaMethodArgs="CharSequence">
+    <CallExpressionRule javaType="java.lang.String" javaMethodName="contains" javaMethodArgs="java.lang.CharSequence">
         <!--
             boolean contains(CharSequence s)
             ==>
@@ -664,29 +793,30 @@
         </Arguments>
     </CallExpressionRule>
 
-    <CallExpressionRule javaType="java.lang.String" javaMethodName="join" javaMethodArgs="CharSequence,CharSequence..."> <!-- TODO: verify/correct the arguments signature -->
+    <CallExpressionRule javaType="java.lang.String" javaMethodName="join" javaMethodArgs="java.lang.CharSequence,java.lang.CharSequence[]">
         <!--
             static String join(CharSequence delimiter, CharSequence... elements)
             ==>
-            public join(strings: String[], delim: String): String       // Actually the method should be re-declared as a static one in the library
+            public join(strings: String[], delim: String): String
         -->
-        <Arguments> <!-- Just reorder arguments. -->
+        <Arguments> <!--; Just reorder arguments. -->
             <SrcArgument index="1"/>
             <SrcArgument index="0"/>
         </Arguments>
     </CallExpressionRule>
 
-    <CallExpressionRule javaType="java.lang.String" javaMethodName="join" javaMethodArgs="CharSequence,Iterable_CharSequence"> <!-- TODO: verify/correct the arguments signature -->
-        <!--
-            join(CharSequence delimiter, Iterable<? extends CharSequence> elements)
-            ==>
-            public join(strings: String[], delim: String): String       // Actually the method should be re-declared as a static one in the library
-        -->
-        <Arguments> <!-- Just reorder arguments. -->
-            <SrcArgument index="1"/>
-            <SrcArgument index="0"/>
-        </Arguments>
-    </CallExpressionRule>
+<!-- The next rule is commented out as at the moment there is no way to convert Iterable<? extencs String> into an array of strings. -->
+<!--    <CallExpressionRule javaType="java.lang.String" javaMethodName="join" javaMethodArgs="java.lang.CharSequence,java.lang.Iterable<? extends java.lang.CharSequence>">-->
+<!--        &lt;!&ndash;-->
+<!--            join(CharSequence delimiter, Iterable<? extends CharSequence> elements)-->
+<!--            ==>-->
+<!--            public join(strings: String[], delim: String): String-->
+<!--        &ndash;&gt;-->
+<!--        <Arguments> &lt;!&ndash; Just reorder arguments. &ndash;&gt;-->
+<!--            <SrcArgument index="1"/>-->
+<!--            <SrcArgument index="0"/>-->
+<!--        </Arguments>-->
+<!--    </CallExpressionRule>-->
 
     <CallExpressionRule javaType="java.lang.String" javaMethodName="valueOf" javaMethodArgs="char">
         <!--
@@ -716,6 +846,15 @@
         -->
         <ArktsTypeName value="StringBuilder"/>
         <ArktsMethodName value="toString"/>
+        <!-- <Arguments> element is needed only to doe the type cast. And it needed as the convertor flat literals
+        converts to double (as ArkTS doesn't have any prefix for float literal types). -->
+        <Arguments>
+            <CastExpression index="0"> <!-- The original argument index to be cast. -->
+                <PrimaryType> <!-- The type to which to do the cast. -->
+                    <PredefinedType name="float"/>
+                </PrimaryType>
+            </CastExpression>
+        </Arguments>
     </CallExpressionRule>
 
     <CallExpressionRule javaType="java.lang.String" javaMethodName="valueOf" javaMethodArgs="int">
@@ -736,20 +875,29 @@
         -->
         <ArktsTypeName value="StringBuilder"/>
         <ArktsMethodName value="toString"/>
+        <!-- <Arguments> element is needed only to do the type cast. And it needed as the convertor long literals
+        converts to int (as ArkTS doesn't have any prefix for long literal types). -->
+        <Arguments>
+            <CastExpression index="0"> <!-- The original argument index to be cast. -->
+                <PrimaryType> <!-- The type to which to do the cast. -->
+                    <PredefinedType name="long"/>
+                </PrimaryType>
+            </CastExpression>
+        </Arguments>
     </CallExpressionRule>
     </CallRules.java.lang.String>
 
     <TypeReferenceRules>
     <TypeReferenceRule javaType="java.lang.Integer">
-        <TypeReference arktsName="Int"/>
+        <TypeReference arktsTypeName="Int"/>
     </TypeReferenceRule>
 
     <TypeReferenceRule javaType="java.lang.Character">
-        <TypeReference arktsName="Char"/>
+        <TypeReference arktsTypeName="Char"/>
     </TypeReferenceRule>
 
     <TypeReferenceRule javaType="java.lang.Number">
-        <TypeReference arktsName="Integral"/>
+        <TypeReference arktsTypeName="Integral"/>
     </TypeReferenceRule>
     </TypeReferenceRules>
 
@@ -758,48 +906,41 @@
     <MemberAccessExpressionRule javaType="java.lang.Math" javaMemberName="E" arktsName="e"/>
     <MemberAccessExpressionRule javaType="java.lang.Byte" javaMemberName="BYTES" arktsName="BYTE_SIZE"/>
     <MemberAccessExpressionRule javaType="java.lang.Byte" javaMemberName="SIZE" arktsName="BIT_SIZE"/>
-    <MemberAccessExpressionRule javaType="java.lang.Character" javaMemberName="SIZE" arktsName="CHAR_BIT_SIZE"/>
-    <MemberAccessExpressionRule javaType="java.lang.Character" javaMemberName="MIN_HIGH_SURROGATE" arktsName="HIGH_SURROGATE_MIN"/>
-    <MemberAccessExpressionRule javaType="java.lang.Character" javaMemberName="MIN_LOW_SURROGATE" arktsName="LOW_SURROGATE_MIN"/>
-    <MemberAccessExpressionRule javaType="java.lang.Character" javaMemberName="MAX_HIGH_SURROGATE" arktsName="HIGH_SURROGATE_MAX"/>
-    <MemberAccessExpressionRule javaType="java.lang.Character" javaMemberName="MAX_LOW_SURROGATE" arktsName="LOW_SURROGATE_MAX"/>
+    <MemberAccessExpressionRule javaType="java.lang.Character" javaMemberName="SIZE" arktsName="CHAR_BIT_SIZE">
+        <TypeReference arktsTypeName="Char"/>
+    </MemberAccessExpressionRule>
+    <MemberAccessExpressionRule javaType="java.lang.Character" javaMemberName="MIN_HIGH_SURROGATE" arktsName="HIGH_SURROGATE_MIN">
+        <TypeReference arktsTypeName="Char"/>
+    </MemberAccessExpressionRule>
+    <MemberAccessExpressionRule javaType="java.lang.Character" javaMemberName="MIN_LOW_SURROGATE" arktsName="LOW_SURROGATE_MIN">
+        <TypeReference arktsTypeName="Char"/>
+    </MemberAccessExpressionRule>
+    <MemberAccessExpressionRule javaType="java.lang.Character" javaMemberName="MAX_HIGH_SURROGATE" arktsName="HIGH_SURROGATE_MAX">
+        <TypeReference arktsTypeName="Char"/>
+    </MemberAccessExpressionRule>
+    <MemberAccessExpressionRule javaType="java.lang.Character" javaMemberName="MAX_LOW_SURROGATE" arktsName="LOW_SURROGATE_MAX">
+        <TypeReference arktsTypeName="Char"/>
+    </MemberAccessExpressionRule>
     <MemberAccessExpressionRule javaType="java.lang.Double" javaMemberName="BYTES" arktsName="BYTE_SIZE"/>
     <MemberAccessExpressionRule javaType="java.lang.Double" javaMemberName="SIZE" arktsName="BIT_SIZE"/>
     <MemberAccessExpressionRule javaType="java.lang.Float" javaMemberName="BYTES" arktsName="BYTE_SIZE"/>
     <MemberAccessExpressionRule javaType="java.lang.Float" javaMemberName="SIZE" arktsName="BIT_SIZE"/>
-    <MemberAccessExpressionRule javaType="java.lang.Integer" javaMemberName="BYTES" arktsName="BYTE_SIZE"/>
-    <MemberAccessExpressionRule javaType="java.lang.Integer" javaMemberName="SIZE" arktsName="BIT_SIZE"/>
+    <MemberAccessExpressionRule javaType="java.lang.Integer" javaMemberName="BYTES" arktsName="BYTE_SIZE">
+        <TypeReference arktsTypeName="Int"/>
+    </MemberAccessExpressionRule>
+    <MemberAccessExpressionRule javaType="java.lang.Integer" javaMemberName="SIZE" arktsName="BIT_SIZE">
+        <TypeReference arktsTypeName="Int"/>
+    </MemberAccessExpressionRule>
     <MemberAccessExpressionRule javaType="java.lang.Long" javaMemberName="BYTES" arktsName="BYTE_SIZE"/>
     <MemberAccessExpressionRule javaType="java.lang.Long" javaMemberName="SIZE" arktsName="BIT_SIZE"/>
     <MemberAccessExpressionRule javaType="java.lang.Short" javaMemberName="BYTES" arktsName="BYTE_SIZE"/>
     <MemberAccessExpressionRule javaType="java.lang.Short" javaMemberName="SIZE" arktsName="BIT_SIZE"/>
     </MemberAccessRules>
 
-    <!--
-        | New                typeReference arguments? classBody?    # NewClassExpression
-        | New typeArguments? typeReference arguments? classBody?    # NewClassInstanceExpression
-        arguments: OpenParen expressionSequence? CloseParen
-
-        Need a rule for transformation.
-        It's possible the class and/or arguments order/number are changed.
-        It's assumed the class body will not be modified by this rule.
-    -->
-<!--    <NewClassInstanceExpressionRule javaObjectType="java.class" javaTypeArgsSignature="comma.separated.list.of.types" javaMethodTypeArgsSignature="comma.separated.list.of.types" javaArgsSignature="comma.separated.list.of.types">-->
-<!--        &lt;!&ndash; Optional ArkTS class. If it's not specified then current class remains. &ndash;&gt;-->
-<!--        <TypeReference/>-->
-
-<!--        &lt;!&ndash; Optional list of ArkTS type arguments. If it's not specified then the current type arguments remain. &ndash;&gt;-->
-<!--        <TypeArguments/> &lt;!&ndash; Look <CallExpressionRule> for <TypeArguments> children description. &ndash;&gt;-->
+    <NewClassInstanceExpressionRules>
+    <NewClassInstanceExpressionRule javaType="java.lang.Character" javaMethodArgs="char">
+        <TypeReference arktsTypeName="Char"/>
+    </NewClassInstanceExpressionRule>
+    </NewClassInstanceExpressionRules>
 
-<!--        &lt;!&ndash; Optional new list of arguments. If it's not specified then the current arguments remain. &ndash;&gt;-->
-<!--        <Arguments/> &lt;!&ndash; Look <CallExpressionRule> for <Argmuments> children description. &ndash;&gt;-->
-<!--    </NewClassInstanceExpressionRule>-->
-
-    <!--
-        typeReference: typeReferencePart (Dot typeReferencePart)*
-        typeReferencePart: qualifiedName typeArguments?
-    -->
-<!--    <TypeReferenceRule javaObjectType="fully.qualified.java.type" javaTypeArgsSignature="comma.separated.list.of.types">-->
-<!--        <TypeReference/> &lt;!&ndash; Look above <CallExpressionRule><TypeArguments> for the structure of <TypeReference>. &ndash;&gt;-->
-<!--    </TypeReferenceRule>-->
 </JavaApiMappingRules>
diff --git a/migrator/docs/Java_API_to_ArkTS_API_mapping_rules.docx b/migrator/docs/Java_API_to_ArkTS_API_mapping_rules.docx
index 546e10db26560dce2b175475fd9fb67838fe1cc6..792dbc5959dbc45c10b9692309c6b4e847c7e4bf 100644
Binary files a/migrator/docs/Java_API_to_ArkTS_API_mapping_rules.docx and b/migrator/docs/Java_API_to_ArkTS_API_mapping_rules.docx differ
diff --git a/migrator/docs/java-api-list.xml b/migrator/docs/java-api-list.xml
index 4ffec05bcd3b170396dc7b8db123a53083bb17fb..ce3cb0dd184ec72f28be9b7603c06d8b2eb19981 100644
--- a/migrator/docs/java-api-list.xml
+++ b/migrator/docs/java-api-list.xml
@@ -93,7 +93,7 @@
         // Interfaces:
         java.lang.Appendable
         java.lang.AutoCloseable
-        java.lang.CharSequence
+        java.lang.CharSequence                          ==> std.core.String ????
         java.lang.Cloneable
         <java.lang.Comparable>
             ==> std.core.Comparable
@@ -149,7 +149,7 @@
             boolean equals(Object obj)                          ArkTS: the same
             float floatValue()                                  ArkTS: the same
             int hashCode()                                      ArkTS: the same
-            static int hashCode(byte value)
+            static int hashCode(byte value)                     ArkTS: new Byte(value).hasCode()
             int intValue()                                      ArkTS: the same
             long longValue()                                    ArkTS: the same
             static byte parseByte(String s)
@@ -233,7 +233,7 @@
             static byte UNASSIGNED
             static byte UPPERCASE_LETTER
 
-            Character(char value)                                           ArkTS: the same
+            Character(char value)                                           ArkTS: Char(char value)
             static int 	charCount(int codePoint)
             char charValue()
             static int codePointAt(char[] a, int index)
@@ -258,15 +258,15 @@
             static int getType(char ch)
             static int getType(int codePoint)
             int hashCode()                                                  ArkTS: the same
-            static int hashCode(char value)                                 ArkTS: the same
-            static char highSurrogate(int codePoint)                        ArkTS: static getHighSurrogate(value: int): char
+            static int hashCode(char value)                                 ArkTS: the same function name but the type is renamed
+            static char highSurrogate(int codePoint)                        ArkTS: static getHighSurrogate(codePoint: int): char
             static boolean isAlphabetic(int codePoint)
             static boolean isBmpCodePoint(int codePoint)
             static boolean isDefined(char ch)
             static boolean isDefined(int codePoint)
-            static boolean isDigit(char ch)                                 ArkTS:  static isDecDigit(value: char): boolean
+            static boolean isDigit(char ch)                                 ArkTS: the same function name but the type is renamed
             static boolean isDigit(int codePoint)
-            static boolean isHighSurrogate(char ch)                         ArkTS: the same
+            static boolean isHighSurrogate(char ch)                         ArkTS: the same function name but the type is renamed
             static boolean isIdentifierIgnorable(char ch)
             static boolean isIdentifierIgnorable(int codePoint)
             static boolean isIdeographic(int codePoint)
@@ -278,13 +278,13 @@
             static boolean isJavaIdentifierStart(int codePoint)
             static boolean isJavaLetter(char ch)
             static boolean isJavaLetterOrDigit(char ch)
-            static boolean isLetter(char ch)
-            static boolean isLetter(int codePoint)                          ArkTS: the same
+            static boolean isLetter(char ch)                                ArkTS: the same function but the type is renamed
+            static boolean isLetter(int codePoint)
             static boolean isLetterOrDigit(char ch)
             static boolean isLetterOrDigit(int codePoint)
-            static boolean isLowerCase(char ch)                             ArkTS: the same
+            static boolean isLowerCase(char ch)                             ArkTS: the same function but the type is renamed
             static boolean isLowerCase(int codePoint)
-            static boolean isLowSurrogate(char ch)                          ArkTS: the same
+            static boolean isLowSurrogate(char ch)                          ArkTS: the same function but the type is renamed
             static boolean isMirrored(char ch)
             static boolean isMirrored(int codePoint)
             static boolean isSpace(char ch)
@@ -299,27 +299,27 @@
             static boolean isUnicodeIdentifierPart(int codePoint)
             static boolean isUnicodeIdentifierStart(char ch)
             static boolean isUnicodeIdentifierStart(int codePoint)
-            static boolean isUpperCase(char ch)                             ArkTS: the same
+            static boolean isUpperCase(char ch)                             ArkTS: the same function but the type is renamed
             static boolean isUpperCase(int codePoint)
             static boolean isValidCodePoint(int codePoint)
-            static boolean isWhitespace(char ch)                            ArkTS: the same
+            static boolean isWhitespace(char ch)                            ArkTS: the same function but the type is renamed
             static boolean isWhitespace(int codePoint)
-            static char lowSurrogate(int codePoint)                         ArkTS:  static getLowSurrogate(value: int): char
+            static char lowSurrogate(int codePoint)                         ArkTS:  static getLowSurrogate(codePoint: int): char
             static int offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)
             static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset)
             static char reverseBytes(char ch)
             static char[] toChars(int codePoint)
             static int toChars(int codePoint, char[] dst, int dstIndex)
             static int toCodePoint(char high, char low)
-            static char toLowerCase(char ch)                                ArkTS: the same
+            static char toLowerCase(char ch)                                ArkTS: the same function but the type is renamed
             static int toLowerCase(int codePoint)
-            String 	toString()
-            static String toString(char c)
+            String 	toString()                                              ArkTS: the same
+            static String toString(char c)                                  ArkTS: new Char(c).toString();
             static char toTitleCase(char ch)
             static int toTitleCase(int codePoint)
-            static char toUpperCase(char ch)                                ArkTS: the same
+            static char toUpperCase(char ch)                                ArkTS: the same function but the type is renamed
             static int toUpperCase(int codePoint)
-            static Character valueOf(char c)                                ArkTS: the same
+            static Character valueOf(char c)                                ArkTS: the same function but the type is renamed
         </java.lang.Character>
         java.lang.Character.Subset
         java.lang.Character.UnicodeBlock
diff --git a/migrator/docs/java-api-mapper.xml b/migrator/docs/java-api-mapper.xml
deleted file mode 100644
index bba24e162b06813dd7a9b8f5d929e032b7f5cfea..0000000000000000000000000000000000000000
--- a/migrator/docs/java-api-mapper.xml
+++ /dev/null
@@ -1,417 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<JavaApiMappingRules>
-    <ImportDeclarationRule action="add"> <ImportDeclaration arktsItem="someArktsName" arktAlias="optionalAliasName" arktsFrom="arkts/path"/> </ImportDeclarationRule>
-    <ImportDeclarationRule javaImport="imported.name.one" action="remove" />
-    <ImportDeclarationRule javaImport="imported.name.two" action="replace">
-        <ImportDeclaration arktsItem="name1" arktAlias="optionalAliasName" arktsFrom="arkts/patj"/>
-        <!-- ... -->
-        <ImportDeclaration arktsItem="nameN" arktAlias="optionalAliasName" arktsFrom="arkts/path"/>
-    </ImportDeclarationRule>
-
-    <!--
-        | singleExpression typeArguments? arguments # CallExpression
-        typeArguments: LessThan typeArgumentList? MoreThan
-        typeArgumentList: typeArgument (Comma typeArgument)*
-        typeArgument: typeReference | arrayType | wildcardType
-
-        Need a rule for transformation.
-        It's possible that the name of the method and the type arguments and/or arguments are changed.
-    -->
-    <CallExpressionRule javaType="qualified.java.type" javaTypeArgs="list.of.java.types" javaMethodName="javaMethodName" javaMethodTypeArgs="list.of.java.types" javaMethodArgs="list.of.java.types">
-        <!-- Optional qualified name of ArkTS class or interface for a static method call.
-         If the method is a static one then it should be called via name of the class or interface.
-         The class/interface in ArkTS may change.
-         If the element is present and its value is an empty string then in ArkTS the method is a global one (doesn't belong to any class). -->
-        <ArktsTypeName value="arktsTypeName"/>
-
-        <!-- Optional. The object (in general case an expression) whose method has to be called.
-          By default (the element is not specified at all) the same object as it is in the source code is used.
-          If this element specified then <ArktsTypeName> must not be present. It has to have one child element
-          which may be one of:
-              <NewClassInstanceExpression>
-                  <TypeReference/>
-                  <Arguments/>
-              </NewClassInstanceExpression>
-          or
-              <SrcArgument/>
-          -->
-        <ArktsObject>
-
-        </ArktsObject>
-
-        <!-- Optional method rename. If it's not specified then the method name remains.-->
-        <ArktsMethodName value="arktsMethodName"/>
-
-        <!-- Optional list of ArkTS object type arguments. If it's not specified then the current type arguments remain. -->
-        <ArktsObjectTypeArgs>
-             <TypeArguments>
-                <SrcTypeArgument index="srcArgIndex"/> <!-- The source TypeArgument with the specified index. -->
-                <!-- typeReference: typeReferencePart (Dot typeReferencePart)* -->
-                <!-- ypeReferencePart: qualifiedName typeArguments? -->
-                <TypeReference arktsName="arktsTypeName">
-                    <!-- Optional type arguments -->
-                    <TypeArguments>
-                        <!-- Any sequence of children of following types: -->
-                        <TypeReference/>
-                        <ArrayType/> <!-- Look below for the structure of arrayType element. -->
-                        <WildcardType/> <!-- Look below for the structure of wildcardType element. -->
-                    </TypeArguments>
-                </TypeReference>
-                <!-- arrayType: (predefinedType | typeReference) {notLineTerminator()}? (OpenBracket CloseBracket)+ -->
-                <ArrayType>
-                    <PredefinedType name="byte OR ubyte OR short OR ushort OR int OR uint OR long OR ulong OR float OR double OR boolean OR string OR char OR void"/>
-                    <!-- OR -->
-                    <TypeReference/> <!-- Look above for the structure of typeReference element. -->
-                </ArrayType>
-                <!-- wildcardType: QuestionMark wildcardBound? -->
-                <WildcardType>
-                    <!-- Optional WildcardBound. If it's not specified then only a question mark will be used as the wildcard type. -->
-                    <!-- wildcardBound: (Extends | Super) typeReference -->
-                    <WildcardBound type="extends OR super">
-                        <TypeReference/> <!-- Look above for the structure of typeReference element. -->
-                    </WildcardBound>
-                </WildcardType>
-            </TypeArguments>
-        </ArktsObjectTypeArgs>
-
-        <!-- Optional list of ArkTS method type arguments. If it's not specified then the current type arguments remain. -->
-        <ArktsMethodTypeArgs>
-            <TypeArguments/>
-        </ArktsMethodTypeArgs>
-
-        <!-- Optional new list of arguments. If it's not specified then the current arguments remain. -->
-        <Arguments>
-            <!-- arguments: OpenParen expressionSequence? CloseParen-->
-            <!-- expressionSequence: singleExpression (Comma singleExpression)* -->
-            <SrcArgument index="srcArgIndex"/> <!-- The source Argument with the specified index. -->
-
-            <!-- Any of the possible literals: -->
-            <Literal type="null OR boolean OR string OR char OR decimal OR hexInteger OR octalInteger OR binaryInteger" value="proper.value"/>
-
-            <!-- Any of the suitable SingleExpressions (see the grammar) which may use source arguments to form the expression: -->
-            <CallExpression name="name.of.the.function.to.call">
-                <TypeArgjments/> <!-- Optional -->
-                <Arguments/> <!-- Optional -->
-            </CallExpression>
-            <UnaryExpression index="srcArgIndex" operation="- or + or ~ or !"/> <!-- The unary operation applied to the source Argument with the specified index. -->
-            <BinaryExpression operation="* OR / OR + OR - OR << OR >> OR >>> OR < OR <= OR == OR >= OR > OR &amp; OR  ^ OR | OR &amp;&amp; OR ||">
-                <!-- The two operands of the operation which could be either: -->
-                <SrcArgument index="src.index.value"/> <!-- The source Argument with the specified index. -->
-                <!-- or any of possible literals -->
-                <!-- or any of the suitable SingleExpressions which may use source arguments to form the expression. -->
-            </BinaryExpression>
-            <TernaryExpression>
-                <!-- | singleExpression QuestionMark singleExpression Colon singleExpression  # TernaryExpression -->
-                <!-- The tree operands which form the TernaryExpression and could be any of: -->
-                <SrcArgument index="srcArgIndex"/> <!-- The source Argument with the specified index. -->
-                <!-- or any of possible literals -->
-                <!-- or any of the suitable SingleExpressions which may use source arguments to form the expression. -->
-            </TernaryExpression>
-            <ThisExpression>
-                <!-- | (typeReference Dot)? This  # ThisExpression -->
-                <TypeReference/> <!-- Look above <TypeArguments> for the structure of <TypeReference> -->
-            </ThisExpression>
-            <SuperExpression>
-                <!-- | (typeReference Dot)? Super  # SuperExpression -->
-                <TypeReference/> <!-- Look above <TypeArguments> for the structure of <TypeReference> -->
-            </SuperExpression>
-            <ArrayLiteralExpression>
-                <!-- A sequence of SingleExpressions which could be any of: -->
-                <SrcArgument index="srcArgIndex"/> <!-- The source Argument with the specified index. -->
-                <!-- or any of possible literals -->
-                <!-- or any of the suitable SingleExpressions which may use source arguments to form the expression. -->
-            </ArrayLiteralExpression>
-            <CastExpression>
-                <!-- | singleExpression As (intersectionType | primaryType) # CastExpression -->
-                <!-- SingleExpression which could be any of: -->
-                <SrcArgument index="srcArgIndex"/> <!-- The source Argument with the specified index. -->
-                <CallExpression/>
-                <UnaryExpression/>
-                <BinaryExpression/>
-
-                <!-- And the type to which to cast. Any of: -->
-                <IntersectionType>
-                    <!-- Not limited list of TypeReferences -->
-                    <TypeReference/>
-                </IntersectionType>
-                <!-- OR -->
-<!--                <PrimaryType> &lt;!&ndash; One of the:&ndash;&gt;-->
-                <PredefinedType/>
-                <TypeReference/>
-                <ArrayType/>
-<!--                </PrimaryType>-->
-            </CastExpression>
-        </Arguments>
-    </CallExpressionRule>
-
-    <!--
-        | singleExpression Dot Identifier # MemberAccessExpression
-
-        Need a rule for transformation.
-        It's possible the name of the member is changed.
-    -->
-    <MemberAccessExpressionRule javaObjectType="qualified.java.type" javaMemberName="javaMemberName" arktsName="arktsMemberName"/>
-
-    <!--
-        | New typeReference arguments? classBody? # NewClassExpression
-        arguments: OpenParen expressionSequence? CloseParen
-
-        Need a rule for transformation.
-        It's possible the class and/or arguments order/number are changed.
-        It's assumed the class body will not be modified by this rule.
-    -->
-    <NewClassExpressionRule javaObjectType="qualified.java.type" javaObjectTypeArgs="list.of.java.types" javaMethodTypeArgs="list.of.java.types" javaMethodArgs="list.of.java.types">
-        <!-- Optional ArkTS class. If it's not specified then current class remains. -->
-        <TypeReference/>
-
-        <!-- Optional new list of ArkTS type arguments of the constructor. -->
-        <TypeArguments/>
-
-        <!-- Optional new list of arguments. If it's not specified then the current arguments remain. -->
-        <Arguments/> <!-- Look <CallExpressionRule> for <Argmuments> children description. -->
-    </NewClassExpressionRule>
-
-    <!--
-        typeReference: typeReferencePart (Dot typeReferencePart)*
-        typeReferencePart: qualifiedName typeArguments?
-    -->
-    <TypeReferenceRule javaObjectType="qualified.java.type" javaObjectTypeArgs="list.of.java.types">
-        <TypeReference/> <!-- Look above <CallExpressionRule><TypeArguments> for the structure of <TypeReference>. -->
-    </TypeReferenceRule>
-
-    <!--
-    <AccessibilityModifier value="public|protected|private" action="remove | replace" new_value=" "/>
-
-    Nothing has to be done at this node level.
-    -->
-
-    <!-- <ArrayType/> typeReference -->
-    <!--
-        arrayType: (predefinedType | typeReference) (OpenBracket CloseBracket)+
-
-        typeReference: typeReferencePart (Dot typeReferencePart)*
-        typeReferencePart: qualifiedName typeArguments?
-        qualifiedName: Identifier (Dot Identifier)*
-        typeArguments: LessThan typeArgumentList? MoreThan
-        typeArgumentList: typeArgument (Comma typeArgument)*
-        typeArgument: typeReference | arrayType | wildcardType
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <ClassDeclaration/> -->
-    <!--
-        classDeclaration: (Static? (Abstract | Open) | (Abstract | Open)? Static)?
-            Class Identifier typeParameters? classExtendsClause? implementsClause? classBody
-
-        classExtendsClause and implementsClause has to be checked and maybe modified.
-    -->
-
-    <!-- <ClassExtends/> -->
-    <!--
-        classExtendsClause: Extends typeReference
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <ClassFieldDeclaration/> -->
-    <!--
-        classFieldDeclaration: Static? (variableDeclaration | Const constantDeclaration) SemiColon
-            | Const Static? constantDeclaration SemiColon
-        variableDeclaration: Identifier typeAnnotation initializer?
-        typeAnnotation: Colon primaryType
-        primaryType: predefinedType | typeReference | arrayType
-        variadicParameter: Ellipsis Identifier typeAnnotation
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <ClassMethodDeclaration/> typeAnnotation -->
-    <!--
-        classMethodDeclaration:
-              (Static | Override | Open)? Identifier signature block                        #ClassMethodWithBody
-            | (Abstract | Static? Native | Native Static)? Identifier signature SemiColon   #AbstractOrNativeClassMethod
-        signature: typeParameters? OpenParen parameterList? CloseParen typeAnnotation;
-        parameterList: parameter (Comma parameter)* (Comma variadicParameter)? | variadicParameter
-        parameter: Identifier typeAnnotation
-        typeAnnotation: Colon primaryType
-
-        typeAnnotation has to be checked and maybe replaced
-    -->
-
-    <!--  <ConstantDeclaration/>-->
-    <!--
-        constantDeclaration: Identifier typeAnnotation? initializer
-
-        typeAnnotation has to be checked and maybe replaced
-     -->
-
-    <!--  <ConstructorDeclaration/>-->
-    <!--
-        constructorDeclaration: Constructor OpenParen parameterList? CloseParen constructorBody
-        parameterList: parameter (Comma parameter)* (Comma variadicParameter)? | variadicParameter
-        parameter: Identifier typeAnnotation
-        typeAnnotation: Colon primaryType
-
-        typeAnnotation has to be checked and maybe replaced
-    -->
-
-    <!-- <FunctionDeclaration/>-->
-    <!--
-        functionDeclaration: Function Identifier signature block
-        signature: typeParameters? OpenParen parameterList? CloseParen typeAnnotation;
-        parameterList: parameter (Comma parameter)* (Comma variadicParameter)? | variadicParameter
-        parameter: Identifier typeAnnotation
-        typeAnnotation: Colon primaryType
-
-        typeAnnotation has to be checked and maybe replaced
-    -->
-
-    <!-- <Implements/> typeReference -->
-    <!--
-        implementsClause: Implements interfaceTypeList
-        interfaceTypeList: typeReference (Comma typeReference)*
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <InterfaceDeclaration/>-->
-    <!--
-        interfaceDeclaration: Static? Interface Identifier typeParameters? interfaceExtendsClause? OpenBrace interfaceBody CloseBrace
-        interfaceExtendsClause: Extends interfaceTypeList
-        interfaceTypeList: typeReference (Comma typeReference)*
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <InterfaceMember/>-->
-    <!--
-        interfaceMember:
-              Identifier signature SemiColon                  #InterfaceMethod
-            | (Static | Private)? Identifier signature block  #InterfaceMethodWithBody
-            | constantDeclaration SemiColon                   #InterfaceField
-            | interfaceDeclaration                            #InterfaceInInterface
-            | classDeclaration                                #ClassInInterface
-            | enumDeclaration                                 #EnumInInterface
-
-        Nothing special has to be done (All child productions are considered).
-    -->
-
-    <!-- <IntersectionType/>-->
-    <!--
-        intersectionType: OpenParen typeReference (BitAnd typeReference)+ CloseParen
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <Parameter/> typeAnnotation -->
-    <!--
-        parameter: Identifier typeAnnotation
-        typeAnnotation: Colon primaryType
-
-        typeAnnotation has to be checked and maybe replaced
-    -->
-
-    <!-- <PrimaryType/> typeReference -->
-    <!--
-        primaryType: predefinedType | typeReference| arrayType
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <QualifiedName/>-->
-    <!--
-        qualifiedName: Identifier (Dot Identifier)*
-
-        Nothing can be done at this node level.
-    -->
-
-    <!-- <TrapStatement/> typeAnnotation -->
-    <!--
-        trapStatement: Trap block catchOrRecoverClause+
-        catchOrRecoverClause: (Catch | Recover) exceptionParameter? block
-        exceptionParameter: OpenParen Identifier typeAnnotation CloseParen
-
-        typeAnnotation has to be checked and maybe replaced
-    -->
-
-    <!--  <TypeAnnotation/> typeReference -->
-    <!--
-        typeAnnotation: Colon primaryType
-        primaryType: predefinedType | typeReference | arrayType
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <TypeArgument/>-->
-    <!--
-        typeArgument: typeReference | arrayType | wildcardType
-        wildcardType: QuestionMark wildcardBound?
-        wildcardBound: (Extends | Super) typeReference
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <VariableDeclaration/>-->
-    <!--
-        variableDeclaration: Identifier typeAnnotation initializer? | Identifier initializer
-
-        typeAnnotation has to be checked and maybe replaced
-    -->
-
-    <!-- <WildcardType/>-->
-    <!--
-        wildcardType: QuestionMark wildcardBound?
-        wildcardBound: (Extends | Super) typeReference
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <CastExpression/> typeReference -->
-    <!--
-        | singleExpression As (intersectionType | primaryType) # CastExpression
-        intersectionType: OpenParen typeReference (BitAnd typeReference)+ CloseParen
-        primaryType: predefinedType | typeReference | arrayType
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <ClassLiteralExpression/> typeReference -->
-    <!--
-        | primaryType Dot Class # ClassLiteralExpression
-        primaryType: predefinedType | typeReference | arrayType
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <NewArrayExpression/> typeReference-->
-    <!--
-        | New primaryType indexExpression+ # NewArrayExpression
-        primaryType: predefinedType | typeReference | arrayType
-
-        typeReference has to be checked and maybe replaced.
-    -->
-
-    <!-- <InterfaceMethod/> typeAnnotation -->
-    <!--
-        : Identifier signature SemiColon  #InterfaceMethod
-        signature: typeParameters? OpenParen parameterList? CloseParen typeAnnotation;
-        parameterList: parameter (Comma parameter)* (Comma variadicParameter)? | variadicParameter
-        parameter: Identifier typeAnnotation
-        typeAnnotation: Colon primaryType
-
-        typeAnnotation has to be checked and maybe replaced
-    -->
-
-    <!-- <InterfaceMethodWithBody/> typeAnnotation -->
-    <!--
-        | (Static | Private)? Identifier signature block  #InterfaceMethodWithBody
-        signature: typeParameters? OpenParen parameterList? CloseParen typeAnnotation;
-        parameterList: parameter (Comma parameter)* (Comma variadicParameter)? | variadicParameter
-        parameter: Identifier typeAnnotation
-        typeAnnotation: Colon primaryType
-
-        typeAnnotation has to be checked and maybe replaced
-    -->
-</JavaApiMappingRules>
\ No newline at end of file
diff --git a/migrator/src/com/ohos/migrator/Main.java b/migrator/src/com/ohos/migrator/Main.java
index d6d897bb55978fb7aa4ab3fffe03f962cebacafd..5b350727919c75d5baf698a57cdd4b0775960bf1 100644
--- a/migrator/src/com/ohos/migrator/Main.java
+++ b/migrator/src/com/ohos/migrator/Main.java
@@ -50,8 +50,13 @@ public class Main {
                 String errorName = e.getResult().getErrorName();
                 System.err.print("[" + errorName + "] ");
 
-                if (e.getCause() != null)
-                    System.err.println(e.getCause().getMessage());
+                if (e.getCause() != null) {
+                    String message = e.getCause().getMessage();
+                    if (message != null && !message.isEmpty())
+                        System.err.println();
+                    else
+                        e.getCause().printStackTrace();
+                }
                 else
                     System.err.println(e.getMessage());
             }
diff --git a/migrator/src/com/ohos/migrator/apimapper/ArrayLiteralExpression.java b/migrator/src/com/ohos/migrator/apimapper/ArrayLiteralExpression.java
index a582394c7e940d9bc169b02375fc6e0713d3718b..ed9f1b7851194112c08eaf0a18f40339dec9162f 100644
--- a/migrator/src/com/ohos/migrator/apimapper/ArrayLiteralExpression.java
+++ b/migrator/src/com/ohos/migrator/apimapper/ArrayLiteralExpression.java
@@ -109,6 +109,7 @@ public class ArrayLiteralExpression extends ArrayList<Object> {
     public SingleExpressionContext buildArktsNode(List<SingleExpressionContext> arktsOrigArguments) {
         SingleExpressionContext arktsArrayLiteralExprParent = new SingleExpressionContext();
         ArrayLiteralExpressionContext arktsArrayLiteralExpr = new ArrayLiteralExpressionContext(arktsArrayLiteralExprParent);
+        arktsArrayLiteralExprParent.addChild(arktsArrayLiteralExpr).setParent(arktsArrayLiteralExprParent);
 
         ExpressionSequenceContext arktsExprSequence = new ExpressionSequenceContext(arktsArrayLiteralExpr, 0);
 
diff --git a/migrator/src/com/ohos/migrator/apimapper/BinaryExpression.java b/migrator/src/com/ohos/migrator/apimapper/BinaryExpression.java
index 8b5c00736c1344798e96420b58178504fe04775a..5156a6b8636aa185b6fa26c7d00763c17127334c 100644
--- a/migrator/src/com/ohos/migrator/apimapper/BinaryExpression.java
+++ b/migrator/src/com/ohos/migrator/apimapper/BinaryExpression.java
@@ -358,6 +358,8 @@ public class BinaryExpression {
         arktsBinExpr.addChild(buildArktsOperandNode(operand2, arktsOrigArguments)).setParent(arktsBinExpr);
 
         assert (arktsBinExpr != null);
+        arktsBinExprParent.addChild(arktsBinExpr).setParent(arktsBinExprParent);
+
         return arktsBinExprParent;
     }
 }
diff --git a/migrator/src/com/ohos/migrator/apimapper/CastExpression.java b/migrator/src/com/ohos/migrator/apimapper/CastExpression.java
index 9a7026d7342ca54885330144977b1454a1ca7a9e..d495154f274533852c603582667dd408292d36fa 100644
--- a/migrator/src/com/ohos/migrator/apimapper/CastExpression.java
+++ b/migrator/src/com/ohos/migrator/apimapper/CastExpression.java
@@ -57,7 +57,7 @@ public class CastExpression {
                     castExpression.index = Integer.valueOf(getAttribute(startElement, indexAttr));
                 }
                 else if (PrimaryType.tag.equals(tag)) {
-                    castExpression.primaryType = PrimaryType.read(xmlReader, xmlEvent);
+                    castExpression.primaryType = PrimaryType.read(xmlReader);
                 }
                 else if (IntersectionType.tag.equals(tag)) {
                     castExpression.intersectionType = IntersectionType.read(xmlReader, xmlEvent);
@@ -87,8 +87,10 @@ public class CastExpression {
 
         SingleExpressionContext arktsCastExprParent = new SingleExpressionContext();
         CastExpressionContext arktsCastExpr = new CastExpressionContext(arktsCastExprParent);
+        arktsCastExprParent.addChild(arktsCastExpr).setParent(arktsCastExprParent);
 
-        arktsCastExpr.children.add(arktsOrigArguments.get(index));
+        //arktsCastExpr.children.add(arktsOrigArguments.get(index));
+        arktsCastExpr.addChild(arktsOrigArguments.get(index));
         arktsCastExpr.addChild(NodeBuilder.terminalNode(StaticTSParser.As));
 
         if (primaryType != null ) {
diff --git a/migrator/src/com/ohos/migrator/apimapper/Literal.java b/migrator/src/com/ohos/migrator/apimapper/Literal.java
index 60598a70e5ac2303f8e1d547682c8b3532ccfe0b..8b1309eb28b4b839509d67f2b92eec1a576d28a6 100644
--- a/migrator/src/com/ohos/migrator/apimapper/Literal.java
+++ b/migrator/src/com/ohos/migrator/apimapper/Literal.java
@@ -18,7 +18,7 @@ package com.ohos.migrator.apimapper;
 // <Literal type="null OR boolean OR string OR char OR decimal OR hexInteger OR octalInteger OR binaryInteger" value="proper_value"/>
 
 import com.ohos.migrator.java.NodeBuilder;
-import com.ohos.migrator.staticTS.parser.StaticTSParser;
+import com.ohos.migrator.staticTS.parser.StaticTSParser.SingleExpressionContext;
 
 import static com.ohos.migrator.apimapper.Util.*;
 
@@ -89,7 +89,7 @@ public class Literal {
         return literal;
     }
 
-    public StaticTSParser.SingleExpressionContext buildArktsNode() {
+    public SingleExpressionContext buildArktsNode() {
         switch (type) {
             case NULL: return NodeBuilder.nullLiteral();
             case BOOLEAN: return NodeBuilder.boolLiteral(Boolean.parseBoolean(value));
diff --git a/migrator/src/com/ohos/migrator/apimapper/PrimaryType.java b/migrator/src/com/ohos/migrator/apimapper/PrimaryType.java
index 2bb839215d6d6004b22389f46e1d2b46736835d3..b56e79e622c97e4c57966d4880100758b7668404 100644
--- a/migrator/src/com/ohos/migrator/apimapper/PrimaryType.java
+++ b/migrator/src/com/ohos/migrator/apimapper/PrimaryType.java
@@ -35,7 +35,7 @@ public class PrimaryType {
     private TypeReference typeReference = null;
     private ArrayType arrayType = null;
 
-    static PrimaryType read(XMLEventReader xmlReader, XMLEvent xmlPrimaryTypeEveent) throws XMLStreamException {
+    static PrimaryType read(XMLEventReader xmlReader) throws XMLStreamException {
         PrimaryType primaryType = new PrimaryType();
 
         while (xmlReader.hasNext()) {
@@ -46,7 +46,7 @@ public class PrimaryType {
                 String tag = startElement.getName().getLocalPart();
 
                 if (tagPredefinedType.equals(tag)) {
-                    primaryType.predefinedType = Util.getAttribute(startElement, Util.nameAttr);
+                    primaryType.predefinedType = getAttribute(startElement, nameAttr);
                 }
                 else if (TypeReference.tag.equals(tag)) {
                     primaryType.typeReference = TypeReference.read(xmlReader, xmlEvent);
@@ -75,7 +75,7 @@ public class PrimaryType {
     public PrimaryTypeContext buildArktsNode() {
         PrimaryTypeContext arktsPrimaryType = new PrimaryTypeContext(null, 0);
 
-        if (!Util.isStringEmpty(predefinedType)) {
+        if (!isStringEmpty(predefinedType)) {
             arktsPrimaryType.addChild(NodeBuilder.predefinedType(predefinedType)).setParent(arktsPrimaryType);
         }
         else if (typeReference != null) {
diff --git a/migrator/src/com/ohos/migrator/apimapper/TernaryExpression.java b/migrator/src/com/ohos/migrator/apimapper/TernaryExpression.java
index 95c01de4579848901bdd5908c5da01d87e7be909..d688c6310b2a2f11e2e2841eaab618e1a257b92b 100644
--- a/migrator/src/com/ohos/migrator/apimapper/TernaryExpression.java
+++ b/migrator/src/com/ohos/migrator/apimapper/TernaryExpression.java
@@ -166,12 +166,14 @@ public class TernaryExpression {
     }
     public SingleExpressionContext buildArktsNode(List<SingleExpressionContext> arktsOrigArguments) {
         SingleExpressionContext arktsTernaryExprParent = new SingleExpressionContext();
-        TernaryExpressionContext arktsTernaryExpr =new TernaryExpressionContext(arktsTernaryExprParent);
+        TernaryExpressionContext arktsTernaryExpr = new TernaryExpressionContext(arktsTernaryExprParent);
 
         arktsTernaryExpr.addChild(buildOperandArktsNode(operand1, arktsOrigArguments)).setParent(arktsTernaryExpr);
         arktsTernaryExpr.addChild(buildOperandArktsNode(operand2, arktsOrigArguments)).setParent(arktsTernaryExpr);
         arktsTernaryExpr.addChild(buildOperandArktsNode(operand3, arktsOrigArguments)).setParent(arktsTernaryExpr);
 
+        arktsTernaryExprParent.addChild(arktsTernaryExpr).setParent(arktsTernaryExprParent);
+
         return arktsTernaryExprParent;
     }
 }
diff --git a/migrator/src/com/ohos/migrator/apimapper/TypeReference.java b/migrator/src/com/ohos/migrator/apimapper/TypeReference.java
index 7c96ecfece81a3fd227ac2d2a61b47e8c00bfcec..05f59cb1fcfa4c00f1232adced30505dd206f10f 100644
--- a/migrator/src/com/ohos/migrator/apimapper/TypeReference.java
+++ b/migrator/src/com/ohos/migrator/apimapper/TypeReference.java
@@ -18,6 +18,7 @@ package com.ohos.migrator.apimapper;
 import com.ohos.migrator.java.NodeBuilder;
 import com.ohos.migrator.staticTS.parser.StaticTSParser.TypeReferenceContext;
 import com.ohos.migrator.staticTS.parser.StaticTSParser.TypeArgumentContext;
+import static com.ohos.migrator.apimapper.Util.*;
 
 import javax.xml.stream.XMLEventReader;
 import javax.xml.stream.XMLStreamException;
@@ -35,11 +36,11 @@ import java.util.List;
 //</TypeReference>
 public class TypeReference {
     static public String tag = "TypeReference";
-    private String arktsName = null;
+    private String arktsTypeName = null;
     private TypeArguments typeArguments = null;
 
     public String getArktsName() {
-        return arktsName;
+        return arktsTypeName;
     }
 
     static public TypeReference read(XMLEventReader xmlReader, XMLEvent xmlTypeReferenceEvent) throws XMLStreamException {
@@ -47,7 +48,7 @@ public class TypeReference {
 
         assert xmlTypeReferenceEvent.isStartElement();
         StartElement startElement = xmlTypeReferenceEvent.asStartElement();
-        typeReference.arktsName = Util.getAttribute(startElement, Util.arktsNameAttr);
+        typeReference.arktsTypeName = getAttribute(startElement, arktsTypeNameAttr);
 
         while (xmlReader.hasNext()) {
             XMLEvent xmlEvent = xmlReader.nextEvent();
@@ -79,7 +80,7 @@ public class TypeReference {
     }
 
     public TypeReferenceContext buildArktsNode(List<TypeArgumentContext> arktsOrigTypeArguments) {
-        TypeReferenceContext arktsTypeReference = NodeBuilder.typeReference(arktsName);
+        TypeReferenceContext arktsTypeReference = NodeBuilder.typeReference(arktsTypeName);
 
         if (typeArguments != null) {
             arktsTypeReference.addChild(typeArguments.buildArktsNode(arktsOrigTypeArguments)).setParent(arktsTypeReference);
diff --git a/migrator/src/com/ohos/migrator/apimapper/UnaryExpression.java b/migrator/src/com/ohos/migrator/apimapper/UnaryExpression.java
index 074e4fefd18910d80fbd9f672d974a0cd299fd8d..cc2fd617efc600b1c9c1202d2f0c88fe93411400 100644
--- a/migrator/src/com/ohos/migrator/apimapper/UnaryExpression.java
+++ b/migrator/src/com/ohos/migrator/apimapper/UnaryExpression.java
@@ -115,7 +115,9 @@ public class UnaryExpression {
 
         arktsUnaryExpr.addChild(NodeBuilder.terminalNode(arktsOpType));
 
-        arktsUnaryExpr.addChild((RuleContext)arktsOrigArguments.get(index));
+        arktsUnaryExpr.addChild(arktsOrigArguments.get(index));
+
+        arktsUnaryExprParent.addChild(arktsUnaryExpr).setParent(arktsUnaryExprParent);
 
         return arktsUnaryExprParent;
     }
diff --git a/migrator/src/com/ohos/migrator/apimapper/Util.java b/migrator/src/com/ohos/migrator/apimapper/Util.java
index 60fa7be25c86be86b76efb9b58005be5cca08401..e266d757c0339f742f14c816367c70f9f79b7451 100644
--- a/migrator/src/com/ohos/migrator/apimapper/Util.java
+++ b/migrator/src/com/ohos/migrator/apimapper/Util.java
@@ -36,6 +36,7 @@ public class Util {
     static public QName javaMethodArgsAttr = new QName("javaMethodArgs");
     static public QName javaImportAttr = new QName("javaImport");
     static public QName arktsNameAttr = new QName("arktsName");
+    static public QName arktsTypeNameAttr = new QName("arktsTypeName");
     static public QName arktsItemAttr = new QName("arktsItem");
     static public QName arktsAliasAttr = new QName("arktsAlias");
     static public QName arktsFromAttr = new QName("arktsFrom");
diff --git a/migrator/src/com/ohos/migrator/java/JavaApiMapper.java b/migrator/src/com/ohos/migrator/java/JavaApiMapper.java
index 6d2611444297913eff34c111e55f52d5a94140a5..aa543e34d8732f1f0aab3dd02d44448bb6e0256b 100644
--- a/migrator/src/com/ohos/migrator/java/JavaApiMapper.java
+++ b/migrator/src/com/ohos/migrator/java/JavaApiMapper.java
@@ -241,10 +241,8 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor<Void> {
 
         private void substituteObject(CallExpressionContext arktsCallExpression, List<SingleExpressionContext> arktsOrigArguments) {
             SingleExpressionContext arktsMethodExpression = arktsCallExpression.singleExpression();
-            assert (arktsMethodExpression instanceof SingleExpressionContext);
-            ParseTree arktsChildNode = arktsMethodExpression.getChild(0);
-            assert (arktsChildNode instanceof MemberAccessExpressionContext);
-            MemberAccessExpressionContext arktsMemberAccessExpr = (MemberAccessExpressionContext)arktsChildNode;
+            assert (arktsMethodExpression.getChild(0) instanceof MemberAccessExpressionContext);
+            MemberAccessExpressionContext arktsMemberAccessExpr = (MemberAccessExpressionContext)arktsMethodExpression.getChild(0);
             SingleExpressionContext arktsOrigObject = arktsMemberAccessExpr.singleExpression();
 
             SingleExpressionContext arktsNewObject = null;
@@ -267,6 +265,19 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor<Void> {
             }
         }
 
+        private void substituteType(CallExpressionContext arktsCallExpression) {
+            SingleExpressionContext arktsMethodExpression = arktsCallExpression.singleExpression();
+            assert (arktsMethodExpression.getChild(0) instanceof MemberAccessExpressionContext);
+            MemberAccessExpressionContext arktsMemberAccessExpr = (MemberAccessExpressionContext)arktsMethodExpression.getChild(0);
+
+            SingleExpressionContext arktsIdentifier = arktsMemberAccessExpr.singleExpression();
+            assert (arktsIdentifier.getChildCount() == 1 && arktsIdentifier.getChild(0) instanceof IdentifierExpressionContext);
+            IdentifierExpressionContext arktsIdentifierExpr = (IdentifierExpressionContext)arktsIdentifier.getChild(0);
+            assert (arktsIdentifierExpr.getChildCount() == 1);
+            arktsIdentifierExpr.children.clear();
+            arktsIdentifierExpr.addChild(new TerminalNodeImpl(new CommonToken(StaticTSParser.Identifier, arktsTypeName)));
+        }
+
         private List<SingleExpressionContext> getOrigArgs(CallExpressionContext arktsCallExpression) {
             ArgumentsContext arktsArguments = arktsCallExpression.arguments();
             ExpressionSequenceContext arktsExpressionSequence = arktsArguments.expressionSequence();
@@ -291,22 +302,21 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor<Void> {
         }
 
         public void apply(CallExpressionContext arktsCallExpression) {
-//            if (arktsMethodName != null) {
-//                assert (!arktsMethodName.isEmpty());
-//                renameMethod(arktsCallExpression.singleExpression());
-//            }
-//
             List<SingleExpressionContext> arktsOrigArguments = null;
             if (arguments != null || arktsObject != null) {
                 arktsOrigArguments = getOrigArgs(arktsCallExpression);
             }
 
-            if (arktsTypeName != null && arktsTypeName.isEmpty()) { // Note: Here it's checked for NOT null AND empty string.
+            if (arktsTypeName != null) {
                 assert (arktsObject == null);
-                makeMethodGlobal(arktsCallExpression);
+                if (arktsTypeName.isEmpty()) { // Note: Here it's checked for NOT null AND empty string.
+                    makeMethodGlobal(arktsCallExpression);
+                }
+                else {
+                    substituteType(arktsCallExpression);
+                }
             }
             else if (arktsObject != null) {
-                assert(arktsTypeName == null);
                 substituteObject(arktsCallExpression, arktsOrigArguments);
             }
 
@@ -530,6 +540,7 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor<Void> {
         static public String tag = "MemberAccessExpressionRule";
 
         private String arktsName = null;
+        private TypeReference typeReference = null; // Optional ArkTS type for a static field access.
 
         // ArkTS:
         //  | singleExpression Dot Identifier # MemberAccessExpression
@@ -537,7 +548,14 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor<Void> {
             assert arktsName != null;
 
             arktsMemberAccessExpression.children.remove(arktsMemberAccessExpression.Identifier());
+//            assert(arktsMemberAccessExpression.getChildCount() == 1);
+//            arktsMemberAccessExpression.children.clear();
             arktsMemberAccessExpression.addChild(new TerminalNodeImpl(new CommonToken(StaticTSParser.Identifier, arktsName)));
+
+            if (typeReference != null) {
+                arktsMemberAccessExpression.children.remove(arktsMemberAccessExpression.singleExpression());
+                arktsMemberAccessExpression.addChild(typeReference.buildArktsNode(null));
+            }
          }
 
         static private String signature(String javaObjectType, String javaName) {
@@ -566,17 +584,30 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor<Void> {
 
             return signature(javaObjectType, javaName);
         }
-        static MemberAccessExpressionRule read(XMLEventReader xmlReader, XMLEvent xmlMemberAccessExpressionEvent, StartElement ruleStartElement) throws XMLStreamException {
+        static MemberAccessExpressionRule read(XMLEventReader xmlReader, StartElement ruleStartElement) throws XMLStreamException {
             MemberAccessExpressionRule memberAccessExpressionRule = new MemberAccessExpressionRule();
 
             memberAccessExpressionRule.arktsName = getAttribute(ruleStartElement, arktsNameAttr);
 
-            // Read the end event (</MemberAccessExpressionRule>)
-            assert (xmlReader.hasNext());
-            XMLEvent xmlEvent = xmlReader.nextEvent();
-            assert (xmlEvent.isEndElement());
-            EndElement endElement = xmlEvent.asEndElement();
-            assert (tag.equals(endElement.getName().getLocalPart()));
+            // Read an optional <TypeReferenc> element and the end event (</MemberAccessExpressionRule>)
+            while (xmlReader.hasNext()) {
+                XMLEvent xmlEvent = xmlReader.nextEvent();
+
+                if (xmlEvent.isStartElement()) {
+                    StartElement startElement = xmlEvent.asStartElement();
+                    String tag = startElement.getName().getLocalPart();
+
+                    if (TypeReference.tag.equals(tag)) {
+                        memberAccessExpressionRule.typeReference = TypeReference.read(xmlReader, xmlEvent);
+                    }
+                    else assert false;
+                }
+                else if (xmlEvent.isEndElement()) {
+                    EndElement endElement = xmlEvent.asEndElement();
+                    assert MemberAccessExpressionRule.tag.equals(endElement.getName().getLocalPart());
+                    break;
+                }
+            }
 
             return memberAccessExpressionRule;
         }
@@ -934,7 +965,7 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor<Void> {
                 }
                 else if (MemberAccessExpressionRule.tag.equals(tag)) {
                     String signature = MemberAccessExpressionRule.signature(startElement);
-                    MemberAccessExpressionRule rule = MemberAccessExpressionRule.read(xmlReader, xmlEvent, startElement);
+                    MemberAccessExpressionRule rule = MemberAccessExpressionRule.read(xmlReader, startElement);
 
                     assert !isStringEmpty(signature) && rule != null;
                     memberAccessExpressionRules.put(signature, rule);
diff --git a/migrator/src/com/ohos/migrator/java/JavaTransformer.java b/migrator/src/com/ohos/migrator/java/JavaTransformer.java
index 91037ada0d7cf8cb2e3b58b69760daa3b3077f33..2bed8fb4f8dedbcb9de5eabf32cbd9dd4b4471bb 100644
--- a/migrator/src/com/ohos/migrator/java/JavaTransformer.java
+++ b/migrator/src/com/ohos/migrator/java/JavaTransformer.java
@@ -1075,6 +1075,22 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
         else
             reportError("Failed to resolve import declaration", javaImportDeclaration);
 
+        // Check for validity - regular (not on-demand) import should always use a qualified name.
+        // If invalid, warn and emit original import syntax in a comment.
+        if (!javaImportDeclaration.isOnDemand() && javaImportName.lastIndexOf('.') == -1) {
+            reportError("Invalid import declaration", javaImportDeclaration);
+            TerminalNode stsComment = NodeBuilder.multiLineComment("/* Untranslated import declaration: " +
+                                                                    javaImportDeclaration.toString() + " */");
+            if (stsCU.getChildCount() > 0) {
+                StaticTSContextBase lastChild = (StaticTSContextBase)stsCU.getChild(stsCU.getChildCount()-1);
+                lastChild.addTrailingComment(stsComment);
+            }
+            else
+                stsCU.addLeadingComment(stsComment);
+
+            return false; // Bail out as we don't need to do anything further here.
+        }
+
         ImportDeclarationContext stsImportDeclaration = new ImportDeclarationContext(stsCurrent, 0);
         pushCurrent(stsImportDeclaration);
 
@@ -1527,6 +1543,10 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
     //      singleExpression: | Identifier # IdentifierExpression
     @Override
     public boolean visit(QualifiedName javaQualifiedName) {
+        // TODO: Check if this javaQualifiedName referes to a calss static field access. Like: Character.MAX_HIGH_SURROGATE.
+        //       In this case it has to be translated to a MemberAccessExpression and not to a simple Identifier.
+        //       It's needed to let the ApiMapper to apply corresponding MemberAccessExpressionRule.
+        //       See #272
         String name = javaQualifiedName.getFullyQualifiedName();
         stsCurrent.addChild(NodeBuilder.identifierExpression(name)).setParent(stsCurrent);
         // Don't count names as transformed as most of them are transformed manually.
@@ -3045,12 +3065,15 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
             javaClassType = javaCtorExpr.resolveTypeBinding();
         }
 
+        ITypeBinding[] javaParamsTypes = null;
+
         if (javaCtorBinding != null) {
             isThrowingCall = javaCtorBinding.getExceptionTypes().length > 0;
             if(isThrowingCall && checkThrownExceptionSet(javaCtorInvocation))
                 addMultipleThrownExceptions(javaCtorBinding.getExceptionTypes());
 
-            stsConstructorCall.javaMethodArgs = buildSignature(javaCtorBinding.getParameterTypes());
+            javaParamsTypes = javaCtorBinding.getParameterTypes();
+            stsConstructorCall.javaMethodArgs = buildSignature(javaParamsTypes);
 
             if (javaCtorExpr == null) {
                 javaClassType = javaCtorBinding.getDeclaringClass();
@@ -3081,7 +3104,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
         translateTypeArguments(javaTypeArgs);
         stsConstructorCall.javaMethodTypeArgs = buildSignature(javaTypeArgs);
 
-        translateArguments(javaArgs);
+        translateArguments(javaArgs, javaParamsTypes);
 
         popCurrent(); // ConstructorCallContext
 
@@ -3110,7 +3133,41 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
         return false;
     }
 
-    private List<SingleExpressionContext> translateArguments(List<Expression> javaArgs) {
+//    private List<SingleExpressionContext> translateArguments(List<Expression> javaArgs) {
+//        pushCurrent(new ArgumentsContext(stsCurrent, 0));
+//
+//        List<SingleExpressionContext> result = null;
+//        if (javaArgs != null && !javaArgs.isEmpty()) {
+//            ExpressionSequenceContext stsExprSeq = new ExpressionSequenceContext(stsCurrent, 0);
+//            pushCurrent(stsExprSeq);
+//
+//            for (Expression javaExpr : javaArgs) {
+//                ITypeBinding javaTypeBinding = javaExpr.resolveTypeBinding();
+//                if (javaTypeBinding != null) {
+//                    sbForApiMapper.append(javaTypeBinding.getQualifiedName());
+//                }
+//                else {
+//                    reportError("Fail to resolve argument", javaExpr);
+//                }
+//
+//                sbForApiMapper.append(',');
+//
+//                javaExpr.accept(this);
+//            }
+//
+//            if (sbForApiMapper.length() > 1) {
+//                sbForApiMapper.setLength(sbForApiMapper.length() - 1); // Remove the ending extra comma.
+//            }
+//
+//            popCurrent(); // ExpressionSequenceContext
+//            result = stsExprSeq.singleExpression();
+//        }
+//
+//        popCurrent(); // ArgumentsContext
+//        return result;
+//    }
+
+    private List<SingleExpressionContext> translateArguments(List<Expression> javaArgs, ITypeBinding[] javaParamsTypes) {
         pushCurrent(new ArgumentsContext(stsCurrent, 0));
 
         List<SingleExpressionContext> result = null;
@@ -3118,22 +3175,43 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
             ExpressionSequenceContext stsExprSeq = new ExpressionSequenceContext(stsCurrent, 0);
             pushCurrent(stsExprSeq);
 
-            for (Expression javaExpr : javaArgs) {
+            int nargs = javaArgs.size();
+            int n = nargs;
+            // For the case of vararg the number of actual arguments may be more than the list of formal parameters.
+            // In such case the last format parameter has to have type of an array.
+            if (javaParamsTypes != null && javaParamsTypes.length < nargs) {
+                // The last parameter should be of array type to which all ending extra arguments will be packed.
+                n = javaParamsTypes.length - 1;
+                assert (javaParamsTypes[n].isArray()) : "For vararg functions the last parameter has to be an array.";
+            }
+
+            for (int i = 0; i < n; i++) {
+                Expression javaExpr = javaArgs.get(i);
+
                 ITypeBinding javaTypeBinding = javaExpr.resolveTypeBinding();
-                if (javaTypeBinding != null) {
-                    sbForApiMapper.append(javaTypeBinding.getQualifiedName());
-                }
-                else {
+                if (javaTypeBinding == null) {
                     reportError("Fail to resolve argument", javaExpr);
                 }
 
-                sbForApiMapper.append(',');
-
                 javaExpr.accept(this);
             }
 
-            if (sbForApiMapper.length() > 1) {
-                sbForApiMapper.setLength(sbForApiMapper.length() - 1); // Remove the ending extra comma.
+            if (n < nargs) {
+                pushCurrent(new ArrayLiteralExpressionContext(pushSingleExpression()));
+                pushCurrent(new ExpressionSequenceContext(stsCurrent, 0));
+
+                for (int i = n; i < nargs; i++) {
+                    Expression javaExpr = javaArgs.get(i);
+                    javaExpr.accept(this);
+
+                    ITypeBinding javaTypeBinding = javaExpr.resolveTypeBinding();
+                    if (javaTypeBinding == null) {
+                        reportError("Fail to resolve argument", javaExpr);
+                    }
+                }
+
+                popCurrent(); // ExpressionSequenceContext
+                popSingleExpression(); // ArrayLiteralContext
             }
 
             popCurrent(); // ExpressionSequenceContext
@@ -3326,7 +3404,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
     //    AnonymousClassDeclaration: { ClassBodyDeclaration }
     // STS tree:
     //   singleExpression:
-    //      | New (singleExpression Dot)? typeReference arguments? classBody?  # NewClassExpression
+    //      | New typeArguments? typeReference arguments? classBody? # NewClassInstanceExpression
     //   arguments: OpenParen expressionSequence? CloseParen
     //   classBody: OpenBrace classMember* clinit=classInitializer? classMember* CloseBrace
     // NOTE: If ctor called by class instance creation expression can throw exceptions,
@@ -3389,12 +3467,15 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
             reportError("Fail to resolve class type", javaClassType);
         }
 
-        List<SingleExpressionContext> stsArgs = translateArguments(javaClassInstanceCreation.arguments());
+        ITypeBinding[] javaParamsTypes = null;
 
         if (javaCtorBinding != null) {
-            stsNewClassInstanceExpr.javaMethodArgs = buildSignature(javaCtorBinding.getParameterTypes());
+            javaParamsTypes = javaCtorBinding.getParameterTypes();
+            stsNewClassInstanceExpr.javaMethodArgs = buildSignature(javaParamsTypes);
         }
 
+        List<SingleExpressionContext> stsArgs = translateArguments(javaClassInstanceCreation.arguments(), javaParamsTypes);
+
         AnonymousClassDeclaration javaAnonymousClassDeclaration = javaClassInstanceCreation.getAnonymousClassDeclaration();
 
         if (javaAnonymousClassDeclaration != null) {
@@ -3784,12 +3865,15 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
         translateTypeArguments(javaMethodInvocation.typeArguments());
         stsCallExpression.javaMethodTypeArgs = buildSignature(javaMethodInvocation.typeArguments());
 
-        translateArguments(javaMethodInvocation.arguments());
+        ITypeBinding[] javaParamsTypes = null;
 
         if (javaMethodBinding != null) {
-            stsCallExpression.javaMethodArgs = buildSignature(javaMethodBinding.getParameterTypes());
+            javaParamsTypes = javaMethodBinding.getParameterTypes();
+            stsCallExpression.javaMethodArgs = buildSignature(javaParamsTypes);
         }
 
+        translateArguments(javaMethodInvocation.arguments(), javaParamsTypes);
+
         popSingleExpression(); // CallExpressionContext
 
         if (isThrowingCall) {
@@ -3863,11 +3947,14 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
         translateTypeArguments(javaSuperMethodInvocation.typeArguments());
         stsCallExpression.javaTypeArgs = buildSignature(javaSuperMethodInvocation.typeArguments());
 
+        ITypeBinding[] javaParamsTypes = null;
+
         if (javaMethodBinding != null) {
-            stsCallExpression.javaMethodArgs = buildSignature(javaMethodBinding.getParameterTypes());
+            javaParamsTypes = javaMethodBinding.getParameterTypes();
+            stsCallExpression.javaMethodArgs = buildSignature(javaParamsTypes);
         }
 
-        translateArguments(javaSuperMethodInvocation.arguments());
+        translateArguments(javaSuperMethodInvocation.arguments(), javaParamsTypes);
 
         popSingleExpression(); // CallExpressionContext
 
diff --git a/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSParser.g4 b/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSParser.g4
index 3acfb9041bf82ec75f6ad42223e2cbac19eea98e..75a0879f98bf55aebc9b0b6c119ac9a65774cdf3 100644
--- a/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSParser.g4
+++ b/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSParser.g4
@@ -186,7 +186,7 @@ signature
 
 // Interfaces
 interfaceDeclaration
-    : Static? Interface Identifier typeParameters? interfaceExtendsClause? OpenBrace interfaceBody CloseBrace
+    : Interface Identifier typeParameters? interfaceExtendsClause? OpenBrace interfaceBody CloseBrace
     ;
 
 interfaceExtendsClause
diff --git a/migrator/src/com/ohos/migrator/ts/TSTranspiler.java b/migrator/src/com/ohos/migrator/ts/TSTranspiler.java
index fce1317d17e33f465749928aced305758f912498..3a8f473f30f85d535c8f2a270da30261901c56ed 100755
--- a/migrator/src/com/ohos/migrator/ts/TSTranspiler.java
+++ b/migrator/src/com/ohos/migrator/ts/TSTranspiler.java
@@ -30,7 +30,7 @@ import java.util.List;
 public class TSTranspiler extends AbstractTranspiler {
 
     private static String XML_EXT = ".xml";
-    private static String tsTranspilerJS = "typescript/build/javascript/src/transpiler/TypeScriptTranspiler.js";
+    private static String tsTranspilerJS = "typescript/javascript/src/transpiler/TypeScriptTranspiler.js";
 
     private boolean keepXML;
     public TSTranspiler(List<File> src, String outDir, boolean keepXML) {
@@ -41,7 +41,7 @@ public class TSTranspiler extends AbstractTranspiler {
     @Override
     protected void transpileFile(File srcFile) throws TranspileException {
         try {
-            String baseDir = FileUtils.getMigratorJarPath().getParentFile().getParent();
+            String baseDir = FileUtils.getMigratorJarPath().getParent();
             String tsTranspilerPath = new File(baseDir, tsTranspilerJS).getPath();
 
             // Run TS translator and wait for it to exit. 
diff --git a/migrator/test/java-mapper/CallExpressionRulesByte.java b/migrator/test/java-mapper/CallExpressionRulesByte.java
new file mode 100644
index 0000000000000000000000000000000000000000..14b6b2c82c6356d9d913153b5b1374250553ad50
--- /dev/null
+++ b/migrator/test/java-mapper/CallExpressionRulesByte.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2022-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.
+ */
+
+package com.ohos.migrator.test.java;
+
+class CallExpressiontRulesByte {
+    public static void Test() {
+        byte v1 = 3;
+        byte v2 = 4;
+        int res = Byte.compare(v1, v2);
+
+        int hesh = Byte.hashCode((byte)3);
+
+        String s = Byte.toString((byte)8);
+    }
+}
\ No newline at end of file
diff --git a/migrator/test/java-mapper/CallExpressionRulesByte.java.sts b/migrator/test/java-mapper/CallExpressionRulesByte.java.sts
new file mode 100644
index 0000000000000000000000000000000000000000..f8e9f6557dd36aa51c8cdd3208042928afb033ac
--- /dev/null
+++ b/migrator/test/java-mapper/CallExpressionRulesByte.java.sts
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022-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.
+ */
+package com.ohos.migrator.test.java;
+
+import * from "std/math/math";
+open class CallExpressiontRulesByte  {
+    public static Test(): void {
+        let v1 : byte = 3;
+        let v2 : byte = 4;
+        let res : int = new Byte(v1).compareTo(new Byte(v2));
+        let hesh : int = Byte.hashCode(3 as byte);
+        let s : String = new Byte(8 as byte).toString();
+    }
+}
+
diff --git a/migrator/test/java-mapper/CallExpressionRulesCharacter.java b/migrator/test/java-mapper/CallExpressionRulesCharacter.java
new file mode 100644
index 0000000000000000000000000000000000000000..65010899afe7e670a32db692c24aa7539492207c
--- /dev/null
+++ b/migrator/test/java-mapper/CallExpressionRulesCharacter.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2022-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.
+ */
+
+package com.ohos.migrator.test.java;
+
+class CallExpressiontRulesCharacter {
+    public static void Test() {
+        Character c = new Character('g');
+
+        int res = Character.compare('c', 'b');
+
+        int hash = Character.hashCode('3');
+
+        c = Character.highSurrogate(386);
+        c = Character.lowSurrogate(386);
+
+        boolean b;
+        b = Character.isDigit('8');
+        b = Character.isHighSurrogate('c');
+        b = Character.isLetter('8');
+        b = Character.isLowerCase('8');
+        b = Character.isLowSurrogate('8');
+        b = Character.isUpperCase('8');
+        b = Character.isWhitespace('8');
+
+        c = Character.toLowerCase('C');
+        c = Character.toUpperCase('a');
+
+        Character ch = Character.valueOf('d');
+
+        String s = Character.toString('s');
+    }
+}
\ No newline at end of file
diff --git a/migrator/test/java-mapper/CallExpressionRulesCharacter.java.sts b/migrator/test/java-mapper/CallExpressionRulesCharacter.java.sts
new file mode 100644
index 0000000000000000000000000000000000000000..b91955fafdac564e741a8422843488ffed56df16
--- /dev/null
+++ b/migrator/test/java-mapper/CallExpressionRulesCharacter.java.sts
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2022-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.
+ */
+package com.ohos.migrator.test.java;
+
+import * from "std/math/math";
+open class CallExpressiontRulesCharacter  {
+    public static Test(): void {
+        let c : Char = new Char('g');
+        let res : int = new Char('c').compareTo(new Char('b'));
+        let hash : int = Char.hashCode('3');
+        c = Char.getHighSurrogate(386);
+        c = Char.getLowSurrogate(386);
+        let b : boolean ;
+        b = Char.isDecDigit('8');
+        b = Char.isHighSurrogate('c');
+        b = Char.isLetter('8');
+        b = Char.isLowerCase('8');
+        b = Char.isLowSurrogate('8');
+        b = Char.isUpperCase('8');
+        b = Char.isWhitespace('8');
+        c = Char.toLowerCase('C');
+        c = Char.toUpperCase('a');
+        let ch : Char = Char.valueOf('d');
+        let s : String = new Char('s').toString();
+    }
+}
+
diff --git a/migrator/test/java-mapper/CallExpressionRulesString.java b/migrator/test/java-mapper/CallExpressionRulesString.java
new file mode 100644
index 0000000000000000000000000000000000000000..e590bc8cee80609f39f1ee0cb8dd115b29d49c6d
--- /dev/null
+++ b/migrator/test/java-mapper/CallExpressionRulesString.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2022-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.
+ */
+
+package com.ohos.migrator.test.java;
+
+import java.util.List;
+import java.util.ArrayList;
+
+class CallExpressiontRulesString {
+    public static void Test() {
+        String s1 = new String("abc");
+        boolean b = s1.contains("d");
+
+//        List<CharSequence> l = new ArrayList<>(2);
+//        l.add("a");
+//        l.add("b");
+
+//        List<? extends CharSequence> strs = l;
+//
+//        String s2 = String.join("+", strs);
+
+        String s3 = String.join("+", "a", "b", "c");
+
+        String sc = String.valueOf('c');
+        String si = String.valueOf(1);
+        String sl = String.valueOf(2l);
+        String sf = String.valueOf(3.f);
+        String sd = String.valueOf(4.);
+    }
+}
\ No newline at end of file
diff --git a/migrator/test/java-mapper/CallExpressionRulesString.java.sts b/migrator/test/java-mapper/CallExpressionRulesString.java.sts
new file mode 100644
index 0000000000000000000000000000000000000000..96b6a5d29d79a4a651fb2cffc04fdede22dbd6ed
--- /dev/null
+++ b/migrator/test/java-mapper/CallExpressionRulesString.java.sts
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2022-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.
+ */
+package com.ohos.migrator.test.java;
+
+import * from "std/math/math";
+import List from "java/util";
+import ArrayList from "java/util";
+open class CallExpressiontRulesString  {
+    public static Test(): void {
+        let s1 : String = new String("abc");
+        let b : boolean = s1.contains("d", 0);
+//        List<CharSequence> l = new ArrayList<>(2);
+//        l.add("a");
+//        l.add("b");
+//        List<? extends CharSequence> strs = l;
+//
+//        String s2 = String.join("+", strs);
+        let s3 : String = String.join(["a", "b", "c"], "+");
+        let sc : String = StringBuilder.toString('c');
+        let si : String = StringBuilder.toString(1);
+        let sl : String = StringBuilder.toString(2 as long);
+        let sf : String = StringBuilder.toString(3. as float);
+        let sd : String = StringBuilder.toString(4.);
+    }
+}
+
diff --git a/migrator/test/java/import_declarations.java b/migrator/test/java/import_declarations.java
index 8dc2954e97ebaad765abc1ae752fae5c4748a0cc..c6121938c314243bbf772e8f704d258e3aa991f4 100644
--- a/migrator/test/java/import_declarations.java
+++ b/migrator/test/java/import_declarations.java
@@ -21,6 +21,8 @@ import static java.util.Collections.*;
 import static java.util.Collections.sort;
 import com.ohos.migrator.staticTS.parser.StaticTSParser.*;
 import com.ohos.migrator.staticTS.parser.StaticTSParser.CompilationUnitContext;
+import Test;
+import static interface_public;
 
 class import_declarations {
     List<String> names;
diff --git a/migrator/test/java/import_declarations.java.sts b/migrator/test/java/import_declarations.java.sts
index 9fe5de252f3dec270e58e21824554b570668e1a3..f193ef5b5bcdb52cc3faa861246cf86955f8ca73 100755
--- a/migrator/test/java/import_declarations.java.sts
+++ b/migrator/test/java/import_declarations.java.sts
@@ -21,6 +21,10 @@ import Collections.* from "java/util";
 import Collections.sort as sort from "java/util";
 import StaticTSParser.* from "com/ohos/migrator/staticTS/parser";
 import StaticTSParser.CompilationUnitContext as CompilationUnitContext from "com/ohos/migrator/staticTS/parser";
+/* Untranslated import declaration: import Test;
+ */
+/* Untranslated import declaration: import static interface_public;
+ */
 open class import_declarations  {
     names : List<String> ;
     ioe : IOException ;
diff --git a/migrator/test/ts/empty_class.ts b/migrator/test/ts/empty_class.ts
index b4dc58541069a208be526a0a8df15d9343e24ad9..fd193d855c1078b0b55d5d8377cd6ac05983c096 100644
--- a/migrator/test/ts/empty_class.ts
+++ b/migrator/test/ts/empty_class.ts
@@ -13,13 +13,15 @@
  * limitations under the License.
  */
 
-class A {
+import {IA, IB} from "interface_module";
+
+class A implements IA {
 }
 
-export class B extends A {
+export class B extends A implements IB {
 }
 
-abstract class C<T, U> extends B {
+abstract class C<T, U> extends B implements IA, IB {
 }
 
 export abstract class D<T> extends C<T, A> {
diff --git a/migrator/test/ts/empty_class.ts.sts b/migrator/test/ts/empty_class.ts.sts
index 8e4b7d1aef0ad24d14cb97354aac420670562607..538945af7e964f8acc47ffce2f8102319acf4413 100644
--- a/migrator/test/ts/empty_class.ts.sts
+++ b/migrator/test/ts/empty_class.ts.sts
@@ -13,13 +13,15 @@
  * limitations under the License.
  */
 
-open class A  {
+import IA, IB from "interface_module";
+
+open class A implements IA  {
 }
 
-export open class B extends A  {
+export open class B extends A implements IB  {
 }
 
-abstract class C<T, U> extends B  {
+abstract class C<T, U> extends B implements IA, IB  {
 }
 
 export abstract class D<T> extends C<T, A>  {
diff --git a/migrator/test/ts/empty_interface.ts b/migrator/test/ts/empty_interface.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bda025edd9f2cd899c01b3411216236b557f557f
--- /dev/null
+++ b/migrator/test/ts/empty_interface.ts
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2022-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 interface A {
+}
+
+interface B extends A {
+}
+
+interface C {
+}
+
+interface D extends B, C {
+}
diff --git a/migrator/test/ts/empty_interface.ts.sts b/migrator/test/ts/empty_interface.ts.sts
new file mode 100755
index 0000000000000000000000000000000000000000..077da5b65e269cc0cbfa22f4a7645771d73beeb4
--- /dev/null
+++ b/migrator/test/ts/empty_interface.ts.sts
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022-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 interface A {
+}
+
+interface B extends A {
+}
+
+interface C {
+}
+
+interface D extends B, C {
+}
+
diff --git a/migrator/test/ts/enums.ts b/migrator/test/ts/enums.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cfce0d31104e8f563cc9bbd8bc2905d6c22a07c0
--- /dev/null
+++ b/migrator/test/ts/enums.ts
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2022-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.
+ */
+
+enum E {
+   A = 1,
+   B,
+   C,
+   D = 20,
+   F = D*C,
+   G = B+F,
+   "H",
+   "100\tI",
+   100
+}
+
+enum Constants {
+   pi = 3.1415,
+   e = 2.7182,
+   h = 6.626e-34,
+   au = 149597870700
+}
+
+enum Empty {
+}
+
+enum MyEnum {
+   "100\tA",
+   [foo()]
+}
+
+function foo(): Symbol {
+   return new Symbol("foo");
+
+   enum Local {
+      A,
+      B = 100,
+      C
+   }
+
+   enum Empty {
+   }
+}
diff --git a/migrator/test/ts/enums.ts.sts b/migrator/test/ts/enums.ts.sts
new file mode 100755
index 0000000000000000000000000000000000000000..89e49ed870081407d88705232f448adce1076106
--- /dev/null
+++ b/migrator/test/ts/enums.ts.sts
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2022-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.
+ */
+
+enum E {
+    A = 1,
+    B,
+    C,
+    D = 20,
+    F = D * C,
+    G = B + F,
+    H /* "100\tI" */,
+    __migrator_ident_100 /* 100 */
+}
+/* Untranslated enum declaration: enum Constants {    pi = 3.1415,    e = 2.7182,    h = 6.626e-34,    au = 149597870700 } */
+/* Untranslated enum declaration: enum Empty { } */
+/* Untranslated enum declaration: enum MyEnum {    "100\tA",    [foo()] } */
+function foo(): Symbol {
+    __untranslated_statement( /* return new Symbol("foo"); */);
+    enum Local {
+        A,
+        B = 100,
+        C
+    }
+    __untranslated_statement( /* enum Empty {    } */);
+}
diff --git a/migrator/typescript/package.json b/migrator/typescript/package.json
index ee7a7bcbe7ad0b891ac1eb89327b8f3584133286..ce904941aefb735d4748816721f740ff3e6eded2 100644
--- a/migrator/typescript/package.json
+++ b/migrator/typescript/package.json
@@ -4,7 +4,7 @@
   "private": true,
   "license": "Apache-2.0",
   "scripts": {
-    "antlr4ts": "antlr4ts -no-listener -no-visitor -o build/typescript -Xexact-output-dir ..\\src\\com\\ohos\\migrator\\staticTS\\parser\\StaticTSLexer.g4 ..\\src\\com\\ohos\\migrator\\staticTS\\parser\\StaticTSParser.g4",
+    "antlr4ts": "antlr4ts -no-listener -no-visitor -o build/typescript -Xexact-output-dir ../src/com/ohos/migrator/staticTS/parser/StaticTSLexer.g4 ../src/com/ohos/migrator/staticTS/parser/StaticTSParser.g4",
     "postantlr4ts": "node scripts/fix-generated-parser.mjs build/typescript",
     "tsc": "tsc",
     "build": "npm run antlr4ts && npm run tsc",
@@ -18,4 +18,4 @@
   "devDependencies": {
     "antlr4ts-cli": "0.5.0-alpha.4"
   }
-}
\ No newline at end of file
+}
diff --git a/migrator/typescript/src/staticts/StaticTSLexerBase.ts b/migrator/typescript/src/staticts/StaticTSLexerBase.ts
index 7351627e55f2bccdb27bd0e4eecc77383f1e441b..a2e65e1fb4b2ac9cc9b27f9e6953fb5992e6619c 100644
--- a/migrator/typescript/src/staticts/StaticTSLexerBase.ts
+++ b/migrator/typescript/src/staticts/StaticTSLexerBase.ts
@@ -52,9 +52,9 @@ export class StaticTSLexerBase extends Lexer {
     public IsInTemplateString(): boolean {
         return false;
     }
-    public nextToken(): Token {
-        return null;
-    }
+    //public nextToken(): Token {
+    //    return null;
+    //}
     protected ProcessOpenBrace(): void {
     }
     protected ProcessCloseBrace(): void {
diff --git a/migrator/typescript/src/transpiler/TranslationUtils.ts b/migrator/typescript/src/transpiler/TranslationUtils.ts
index c331d378bb6b1a2f0db47ed6107d5b302421b091..da3f362b6df6588cfa4f7be2f8651ad2c09ec1af 100644
--- a/migrator/typescript/src/transpiler/TranslationUtils.ts
+++ b/migrator/typescript/src/transpiler/TranslationUtils.ts
@@ -41,6 +41,10 @@ export function hasModifier(tsModifiers: readonly ts.Modifier[], tsModifierKind:
     return false;
 }
 
+export function isConst(tsNode: ts.Node): boolean {
+    return !!(ts.getCombinedNodeFlags(tsNode) & ts.NodeFlags.Const);
+}
+
 export function isExpression(tsNode: ts.Node): boolean {
     switch (tsNode.kind) {
         case ts.SyntaxKind.ConditionalExpression:
diff --git a/migrator/typescript/src/transpiler/TypeScriptTransformer.ts b/migrator/typescript/src/transpiler/TypeScriptTransformer.ts
index fed660e9c9a716bd755479f4a435e625eab695f5..c353edaf581cc34c8ba505c3df18369ffd18512c 100644
--- a/migrator/typescript/src/transpiler/TypeScriptTransformer.ts
+++ b/migrator/typescript/src/transpiler/TypeScriptTransformer.ts
@@ -19,6 +19,10 @@ import * as sts from "../../build/typescript/StaticTSParser";
 import * as TranslationUtils from "./TranslationUtils";
 import * as NodeBuilder from "./NodeBuilder";
 import { TerminalNode } from "antlr4ts/tree";
+import { CharStreams } from "antlr4ts";
+import { StaticTSLexer } from "../../build/typescript/StaticTSLexer";
+
+const MIGRATOR_IDENT_PREFIX = "__migrator_ident_";
 
 type VisitFunction<T extends ts.Node> = (tsNode: T) => StaticTSContextBase;
 type VisitorTable = { [key: number]: VisitFunction<ts.Node> };
@@ -27,6 +31,10 @@ type stsHeritageContext = sts.ClassExtendsClauseContext
                         | sts.InterfaceExtendsClauseContext 
                         | sts.ImplementsClauseContext;
 
+type stsTopDeclarations = sts.ClassDeclarationContext | sts.InterfaceDeclarationContext |
+                          sts.EnumDeclarationContext | sts.FunctionDeclarationContext |
+                          sts.VariableOrConstantDeclarationContext | sts.TypeAliasDeclarationContext;
+
 export class TypeScriptTransformer {
     private tsTypeChecker: ts.TypeChecker;
 
@@ -63,6 +71,8 @@ export class TypeScriptTransformer {
         [ts.SyntaxKind.SourceFile]: this.visitSourceFile,
         [ts.SyntaxKind.ClassDeclaration]: this.visitClassDeclaration,
         [ts.SyntaxKind.FunctionDeclaration]: this.visitFunctionDeclaration,
+        [ts.SyntaxKind.InterfaceDeclaration]: this.visitInterfaceDeclaration,
+        [ts.SyntaxKind.EnumDeclaration]: this.visitEnumDeclaration,
         [ts.SyntaxKind.Parameter]: this.visitParameter,
         [ts.SyntaxKind.Block]: this.visitBlock,
         [ts.SyntaxKind.TypeReference]: this.visitTypeReference,
@@ -176,15 +186,19 @@ export class TypeScriptTransformer {
             }
         }
 
-        stsClassDecl.addChild(new sts.ClassBodyContext(stsClassDecl, 0));
-
         // TODO: Translate class body.
+        stsClassDecl.addChild(new sts.ClassBodyContext(stsClassDecl, 0));
 
         // If this is not a top-level class declaration, 
-        // return ClassDeclarationContext node, otherwise
-        // wrap it in TopDeclarationContext before returning.
+        // return ClassDeclarationContext node. 
         if (!ts.isSourceFile(tsClassDecl.parent)) return stsClassDecl;
         
+        // Otherwise, wrap it in TopDeclarationContext before returning.
+        let stsTopDecl = this.wrapInTopDecl(stsClassDecl, tsModifiers);
+        return stsTopDecl;
+    }
+
+    private wrapInTopDecl(stsDecl: stsTopDeclarations, tsModifiers: readonly ts.Modifier[]): sts.TopDeclarationContext {
         let stsTopDecl = new sts.TopDeclarationContext(undefined, 0);
 
         // Add export modifier, if necessary.
@@ -192,13 +206,45 @@ export class TypeScriptTransformer {
             stsTopDecl.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Export));
         }
 
-        stsTopDecl.addChild(stsClassDecl);
+        stsTopDecl.addChild(stsDecl);
+        return stsTopDecl;
+    }
+
+    visitInterfaceDeclaration(tsInterfaceDecl: ts.InterfaceDeclaration): StaticTSContextBase {
+        let tsModifiers = ts.getModifiers(tsInterfaceDecl);
+        let stsInterfaceDecl = new sts.InterfaceDeclarationContext(undefined, 0);
+
+        stsInterfaceDecl.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Interface));
+        stsInterfaceDecl.addChild(NodeBuilder.terminalIdentifier(tsInterfaceDecl.name.text));
+
+        // Translate type parameters.
+        let stsTypeParams = this.translateTypeParameters(tsInterfaceDecl.typeParameters);
+        if (stsTypeParams) stsInterfaceDecl.addChild(stsTypeParams);
+
+        // Translate heritage clause.
+        let tsHeritage = tsInterfaceDecl.heritageClauses;
+        if (tsHeritage && tsHeritage.length > 0) {
+            // There should never be more than one extends clause for interfaces.
+            let stsExtendsClause = this.visitNode(tsInterfaceDecl.heritageClauses[0]);
+            if (stsExtendsClause) stsInterfaceDecl.addChild(stsExtendsClause);
+        }
+
+        // TODO: Translate interface body.
+        stsInterfaceDecl.addChild(new sts.InterfaceBodyContext(stsInterfaceDecl, 0));
+        
+        // If this is not a top-level interface declaration,
+        // return InterfaceDeclarationContext node.
+        if (!ts.isSourceFile(tsInterfaceDecl.parent)) return stsInterfaceDecl;
+
+        // Otherwise, wrap it in TopDeclarationContext before returning.
+        let stsTopDecl = this.wrapInTopDecl(stsInterfaceDecl, tsModifiers);
         return stsTopDecl;
     }
 
     visitHeritageClause(tsHeritageClause: ts.HeritageClause): stsHeritageContext {
         let tsToken = tsHeritageClause.token;
         let stsHeritageClause: stsHeritageContext;
+        let isClassExtends = false;
         if (tsToken === ts.SyntaxKind.ExtendsKeyword) {
             let tsParent = tsHeritageClause.parent;
             if (ts.isInterfaceDeclaration(tsParent)) {
@@ -206,6 +252,7 @@ export class TypeScriptTransformer {
             }
             else {
                 stsHeritageClause = new sts.ClassExtendsClauseContext(undefined, 0);
+                isClassExtends = true;
             }
 
             stsHeritageClause.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Extends));
@@ -215,12 +262,16 @@ export class TypeScriptTransformer {
             stsHeritageClause.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Implements));
         }
 
+        let stsTypeContainer = isClassExtends ? stsHeritageClause : 
+                                                new sts.InterfaceTypeListContext(stsHeritageClause, 0);
+
         for (let tsType of tsHeritageClause.types) {
             // Translate only what we can convert to arkTS type refs,
             // everything else denote as __UnknownType__.
             let tsTypeExpr = tsType.expression;
+            let stsTypeRef: sts.TypeReferenceContext;
             if (ts.isEntityName(tsTypeExpr)) {
-                let stsTypeRef = NodeBuilder.typeReference(tsTypeExpr);
+                stsTypeRef = NodeBuilder.typeReference(tsTypeExpr);
 
                 // Translate type arguments.
                 let stsTypeArgs = this.translateTypeArguments(tsType.typeArguments);
@@ -228,43 +279,207 @@ export class TypeScriptTransformer {
                     let stsTypeRefParts = stsTypeRef.typeReferencePart();
                     stsTypeRefParts[stsTypeRefParts.length-1].addChild(stsTypeArgs);
                 }
+            }
+            else {
+                stsTypeRef = NodeBuilder.unknownTypeReference(tsType);
+            }
+
+            stsTypeContainer.addChild(stsTypeRef);
 
-                stsHeritageClause.addChild(stsTypeRef);
+            if (isClassExtends) { 
+                // There should be no more than one type in class extends clause.
+                if (tsHeritageClause.types.length > 1) break;
             }
             else {
-                stsHeritageClause.addChild(NodeBuilder.unknownTypeReference(tsType));
+                // Add interface type list to heritage clause.
+                stsHeritageClause.addChild(stsTypeContainer);
             }
         }
 
         return stsHeritageClause;
     }
 
-    visitFunctionDeclaration(tsFunDecl: ts.FunctionDeclaration): sts.TopDeclarationContext {
-        // Note: Only global function declarations are allowed in arkTS,
-        // so we should always wrap them in TopDeclarationContext, as 
-        // opposed to class/interface/enum or variable declarations.
-        // Local TS functions will be translated as lambdas.
-        let stsTopDecl = new sts.TopDeclarationContext(undefined, 0);
+    visitEnumDeclaration(tsEnumDecl: ts.EnumDeclaration): StaticTSContextBase {
+        if (this.isCompatibleWithArkTSEnum(tsEnumDecl)) {
+            return this.translateEnumDeclAsArkTSEnum(tsEnumDecl);
+        }
+        
+        return this.translateEnumDeclAsClass(tsEnumDecl);
+    }
 
-        // Add export modifier, if necessary.
-        let tsModifiers = ts.getModifiers(tsFunDecl);
-        if (TranslationUtils.hasModifier(tsModifiers, ts.SyntaxKind.ExportKeyword)) {
-            stsTopDecl.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Export));
+    private translateEnumDeclAsClass(tsEnumDecl: ts.EnumDeclaration): StaticTSContextBase {
+        // TODO: Translate non-trivial TS enums as classes.
+
+        // Warn and, if this is a top-level enum, add a top-level comment with
+        // original enum declaration syntax. 
+        // Note: No need to do the same for block-level enums as they will be 
+        // picked up by visitBlock function and emitted as __untranslated_statement() 
+        // calls there.
+        this.reportError("Failed to translate enum declaration", tsEnumDecl);
+
+        if (ts.isSourceFile(tsEnumDecl.parent)) {
+            this.addTopLevelComment("Untranslated enum declaration", tsEnumDecl);
         }
 
-        let stsFunDecl = new sts.FunctionDeclarationContext(stsTopDecl, 0);
-        stsFunDecl.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Function));
-        stsFunDecl.addChild(NodeBuilder.terminalIdentifier(tsFunDecl.name.text));
-        stsFunDecl.addChild(this.translateSignature(tsFunDecl));
+        return null;
+    }
+
+    private translateEnumDeclAsArkTSEnum(tsEnumDecl: ts.EnumDeclaration): StaticTSContextBase {
+        let stsEnumDecl = new sts.EnumDeclarationContext(undefined, 0);
+
+        stsEnumDecl.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Enum));
+        stsEnumDecl.addChild(NodeBuilder.terminalIdentifier(tsEnumDecl.name.text));
         
-        if (tsFunDecl.body) {
-            stsFunDecl.addChild(this.visitNode(tsFunDecl.body));
+        // Translate enum members.
+        let stsEnumBodyComments: TerminalNode[] = [];
+        let stsEnumBody = new sts.EnumBodyContext(stsEnumDecl, 0);
+        for (let tsEnumMember of tsEnumDecl.members) {
+            let stsEnumMember = new sts.EnumMemberContext(stsEnumBody, 0);
+            let stsEnumMemberName = this.translatePropertyName(tsEnumMember.name);
+
+            if (stsEnumMemberName) {
+                if (stsEnumMemberName.text.startsWith(MIGRATOR_IDENT_PREFIX)) {
+                    // Append a comment with original enum member name syntax.
+                    let stsComment = NodeBuilder.multiLineComment("/* " + tsEnumMember.name.getText() + " */");
+                    stsEnumMember.addTrailingComment(stsComment);
+                }
+                stsEnumMember.addChild(stsEnumMemberName);
+            }
+            else {
+                this.reportError("Failed to translate enum member", tsEnumMember);
+                
+                // Emit a comment with original enum member syntax and continue.
+                let stsComment = NodeBuilder.multiLineComment("/* " + tsEnumMember.getText() + " */");
+                if (stsEnumBody.childCount > 0) {
+                    let stsLastChild = stsEnumBody.getChild(stsEnumBody.childCount-1) as StaticTSContextBase;
+                    stsLastChild.addTrailingComment(stsComment);
+                }
+                else {
+                    // Store comment until we have a enum member
+                    // to attach it to.
+                    stsEnumBodyComments.push(stsComment);
+                }
+                continue;
+            }
+
+            if (tsEnumMember.initializer) {
+                let stsInitializer = this.visitNode(tsEnumMember.initializer);
+                if (stsInitializer) stsEnumMember.addChild(stsInitializer);
+            }
+            
+            // Pick up unattached comments (if any).
+            // See above for details.
+            if (stsEnumBodyComments.length > 0) {
+                for (let stsComment of stsEnumBodyComments) {
+                    stsEnumMember.addLeadingComment(stsComment);
+                }
+                stsEnumBodyComments = [];
+            }
+
+            stsEnumBody.addChild(stsEnumMember);
+        }
+
+        // Don't emit empty enums.
+        if (stsEnumBody.childCount === 0) {
+            // Warn and, if this is a top-level enum, add a top-level comment with
+            // original enum declaration syntax. 
+            // Note: No need to do the same for block-level enums as they will be 
+            // picked up by visitBlock function and emitted as __untranslated_statement() 
+            // calls there.
+            this.reportError("Failed to translate enum declaration", tsEnumDecl);
+
+            if (ts.isSourceFile(tsEnumDecl.parent)) {
+                this.addTopLevelComment("Untranslated enum declaration", tsEnumDecl);
+            }
+
+            return null;
         }
 
-        stsTopDecl.addChild(stsFunDecl);
+        stsEnumDecl.addChild(stsEnumBody);
+
+        // If this is not a top-level enum declaration,
+        // return EnumDeclarationContext node.
+        if (!ts.isSourceFile(tsEnumDecl.parent)) return stsEnumDecl;
+
+        // Otherwise, wrap it in TopDeclarationContext before returning.
+        let tsModifiers = ts.getModifiers(tsEnumDecl);
+        let stsTopDecl = this.wrapInTopDecl(stsEnumDecl, tsModifiers);
         return stsTopDecl;
     }
 
+    private addTopLevelComment(commentHeader: string, tsNode: ts.Node): void {
+        let stsComment = NodeBuilder.multiLineComment("/* " + commentHeader + ":\n" + 
+                                                      tsNode.getText() + " */");
+        this.stsTopLevelComments.push(stsComment);
+    }
+
+    // Returns false if there is at least one enum member with 
+    // non-constant value or a value of non-integer type.
+    private isCompatibleWithArkTSEnum(tsEnumDecl: ts.EnumDeclaration): boolean {
+        for (let tsEnumMember of tsEnumDecl.members) {
+            if (tsEnumMember.initializer) {
+                let tsConstValue = this.tsTypeChecker.getConstantValue(tsEnumMember);
+                if (!tsConstValue) return false;
+                
+                if (typeof tsConstValue !== 'number' || 
+                    tsConstValue.toFixed(0) !== tsConstValue.toString())
+                    return false;
+            }
+        }
+
+        return true;
+    }
+
+    private translatePropertyName(tsPropName: ts.PropertyName): TerminalNode {
+        // Cannot translate dynamically-computed property names.
+        if (ts.isComputedPropertyName(tsPropName)) return null;
+
+        // For property names specified by string literals, check
+        // that the literal is compatible with arkTS identifier.
+        if (ts.isStringLiteral(tsPropName)) {
+            let stsCharStream = CharStreams.fromString(tsPropName.text);
+            let stsLexer = new StaticTSLexer(stsCharStream);
+            let stsTokens = stsLexer.getAllTokens();
+            if (stsTokens.length !== 1 || 
+                stsLexer.vocabulary.getSymbolicName(stsTokens[0].type) !== 'Identifier') {
+                return null;
+            }
+        }
+
+        // For all other cases except identifier or string literal,
+        // prepend migrator-specific prefix to the property name to 
+        // make it a valid arkTS identifier.
+        let stsIdentifierName = tsPropName.text;
+        if (!ts.isIdentifier(tsPropName) && !ts.isStringLiteral(tsPropName)) {
+            stsIdentifierName = MIGRATOR_IDENT_PREFIX + stsIdentifierName;
+        }
+
+        return NodeBuilder.terminalIdentifier(stsIdentifierName);
+    }
+
+    visitFunctionDeclaration(tsFunDecl: ts.FunctionDeclaration): sts.TopDeclarationContext {
+        if (ts.isSourceFile(tsFunDecl.parent)) {
+            let stsFunDecl = new sts.FunctionDeclarationContext(undefined, 0);
+            stsFunDecl.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Function));
+            stsFunDecl.addChild(NodeBuilder.terminalIdentifier(tsFunDecl.name.text));
+            stsFunDecl.addChild(this.translateSignature(tsFunDecl));
+            
+            if (tsFunDecl.body) {
+                stsFunDecl.addChild(this.visitNode(tsFunDecl.body));
+            }
+
+            // Note: Only global function declarations are allowed in arkTS,
+            // so we should always wrap them in TopDeclarationContext, as 
+            // opposed to class/interface/enum or variable declarations.
+            let tsModifiers = ts.getModifiers(tsFunDecl);
+            let stsTopDecl = this.wrapInTopDecl(stsFunDecl, tsModifiers)
+            return stsTopDecl;
+        }
+        
+        // TODO: Local TS functions should be translated as lambdas.
+        return null;
+    }
+
     translateSignature(tsSignatureDecl: ts.SignatureDeclaration): sts.SignatureContext {
         let stsSignature = new sts.SignatureContext(undefined, 0);
 
@@ -330,8 +545,14 @@ export class TypeScriptTransformer {
         let stsBlock = new sts.BlockContext(undefined, 0);
 
         for (const tsStmt of tsBlock.statements) {
+            let stsStmt = this.visitNode(tsStmt);
+            if (!stsStmt) {
+                this.reportError("Failed to translate statement", tsStmt);
+                stsStmt = NodeBuilder.untranslatedStatement(tsStmt);
+            }
+
             let stmtOrLocalDecl = new sts.StatementOrLocalDeclarationContext(stsBlock, 0);
-            stmtOrLocalDecl.addChild(this.visitNode(tsStmt));
+            stmtOrLocalDecl.addChild(stsStmt);
             stsBlock.addChild(stmtOrLocalDecl);
         }
 
@@ -442,12 +663,9 @@ export class TypeScriptTransformer {
 
         // Sanity check.
         if (!ts.isStringLiteral(tsModuleSpec) || !tsImportClause) {
-            // Warn and emit a comment with original import syntax.
+            // Warn and add a top-level comment with original import declaration syntax.
             this.reportError("Failed to translate import declaration", tsImportDecl);
-
-            let stsComment = NodeBuilder.multiLineComment("/* Untranslated import declaration: " + 
-                                                            tsImportDecl.getText() + " */");
-            this.stsTopLevelComments.push(stsComment);
+            this.addTopLevelComment("Untranslated import declaration", tsImportDecl);
             return null;
         }
 
@@ -504,58 +722,48 @@ export class TypeScriptTransformer {
     }
 
     visitVariableStatement(tsVarStmt: ts.VariableStatement): StaticTSContextBase {
-        let stsVarOrConstDecl = this.visitNode(tsVarStmt.declarationList);
+        let tsModifiers = ts.getModifiers(tsVarStmt)
+        let stsVarOrConstDecl = new sts.VariableOrConstantDeclarationContext(undefined, 0);
+
+        // Add const or let keyword, as necessary.
+        // Note: For some reason, const flag is not set on variable statement itself, so
+        // we need to query declaration list inside it to figure out which keyword to add.
+        // TODO: Should we hoist var-declared variables onto enclosing function scope?
+        let stsTermId = TranslationUtils.isConst(tsVarStmt.declarationList) ?
+                        sts.StaticTSParser.Const : sts.StaticTSParser.Let;
+        stsVarOrConstDecl.addChild(NodeBuilder.terminalNode(stsTermId));
+
+        // Translate declaration list.
+        stsVarOrConstDecl.addChild(this.visitNode(tsVarStmt.declarationList))
 
-        // If this is not a top-level declaration, return declaration node itself;
-        // it'll be wrapped in StatementOrLocalDeclarationContext inside visitBlock 
-        // function (see above).
+        // If this is not a top-level declaration, return declaration node;
+        // it'll be wrapped in StatementOrLocalDeclarationContext inside 
+        // visitBlock function (see above).
         if (!ts.isSourceFile(tsVarStmt.parent)) return stsVarOrConstDecl;
 
         // Otherwise, wrap declaration node in TopDeclarationContext before returning.
-        let stsTopDecl = new sts.TopDeclarationContext(undefined, 0);
-
-        // Add export modifier, if necessary.
-        let tsModifiers = ts.getModifiers(tsVarStmt);
-        if (TranslationUtils.hasModifier(tsModifiers, ts.SyntaxKind.ExportKeyword)) {
-            stsTopDecl.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Export));
-        }
-        
-        stsTopDecl.addChild(stsVarOrConstDecl);
+        let stsTopDecl = this.wrapInTopDecl(stsVarOrConstDecl, tsModifiers);
         return stsTopDecl;
     }
 
     visitVariableDeclarationList(tsVarDeclList: ts.VariableDeclarationList): StaticTSContextBase {
-        // TODO: Should we hoist function-scoped variables (i.e. declared as 'var').
-
-        let stsVarOrConstDecl = new sts.VariableOrConstantDeclarationContext(undefined, 0);
         let isConst: boolean = !!(tsVarDeclList.flags & ts.NodeFlags.Const);
 
-        let stsDeclList: StaticTSContextBase;
-        if (isConst) {
-            stsVarOrConstDecl.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Const))
-            stsDeclList = new sts.ConstantDeclarationListContext(stsVarOrConstDecl, 0); 
-        } else {
-            stsVarOrConstDecl.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Let))
-            stsDeclList = new sts.VariableDeclarationListContext(stsVarOrConstDecl, 0); 
-        }
-        stsVarOrConstDecl.addChild(stsDeclList);
+        let stsDeclList = TranslationUtils.isConst(tsVarDeclList) ? 
+                                    new sts.ConstantDeclarationListContext(undefined, 0) :
+                                    new sts.VariableDeclarationListContext(undefined, 0);
 
         for (const tsVarDecl of tsVarDeclList.declarations) {
             stsDeclList.addChild(this.visitNode(tsVarDecl));
         }
 
-        return stsVarOrConstDecl;
+        return stsDeclList;
     }
 
     visitVariableDeclaration(tsVarDecl: ts.VariableDeclaration): StaticTSContextBase {
-        let isConst: boolean = !!(ts.getCombinedNodeFlags(tsVarDecl) & ts.NodeFlags.Const);
-
-        let stsDecl: StaticTSContextBase;
-        if (isConst) {
-            stsDecl = new sts.ConstantDeclarationContext(undefined, 0); 
-        } else {
-            stsDecl = new sts.VariableDeclarationContext(undefined, 0); 
-        }
+        let stsDecl = TranslationUtils.isConst(tsVarDecl) ? 
+                                    new sts.ConstantDeclarationContext(undefined, 0) :
+                                    new sts.VariableDeclarationContext(undefined, 0); 
 
         let varName = tsVarDecl.name;
         if (ts.isIdentifier(varName)) {
@@ -781,14 +989,6 @@ export class TypeScriptTransformer {
     }
 
     visitTypeAliasDeclaration(tsTypeAliasDecl: ts.TypeAliasDeclaration): sts.TopDeclarationContext {
-        let stsTopDecl = new sts.TopDeclarationContext(undefined, 0);
-
-        // Add export modifier, if necessary.
-        let tsModifiers = ts.getModifiers(tsTypeAliasDecl);
-        if (TranslationUtils.hasModifier(tsModifiers, ts.SyntaxKind.ExportKeyword)) {
-            stsTopDecl.addChild(NodeBuilder.terminalNode(sts.StaticTSParser.Export));
-        }
-
         let stsTypeAliasDecl = new sts.TypeAliasDeclarationContext(undefined, 0);
         stsTypeAliasDecl.addChild(NodeBuilder.terminalIdentifier(sts.StaticTSParser.TYPE));
         stsTypeAliasDecl.addChild(NodeBuilder.terminalIdentifier(tsTypeAliasDecl.name.text));  
@@ -803,7 +1003,10 @@ export class TypeScriptTransformer {
         stsPrimaryType.addChild(stsAliasedType);
         stsTypeAliasDecl.addChild(stsPrimaryType);
 
-        stsTopDecl.addChild(stsTypeAliasDecl);
+        // Always wrap in TopDeclarationContext, as arkTS
+        // allows only top-level type alias declarations.
+        let tsModifiers = ts.getModifiers(tsTypeAliasDecl);
+        let stsTopDecl = this.wrapInTopDecl(stsTypeAliasDecl, tsModifiers);
         return stsTopDecl;
     }
 
diff --git a/parser/ASparser.cpp b/parser/ASparser.cpp
index 737789826d0d2f7099c99e0a415c27477cf752e2..4d67c7d11bb0aafc5fd0c5aac3031bf56719d35e 100644
--- a/parser/ASparser.cpp
+++ b/parser/ASparser.cpp
@@ -131,7 +131,8 @@ ir::TSTypeAliasDeclaration *ASParser::ParseTypeAliasDeclaration()
     auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
     ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-        typeParamDecl = ParseTypeParameterDeclaration();
+        auto options = TypeAnnotationParsingOptions::THROW_ERROR;
+        typeParamDecl = ParseTypeParameterDeclaration(&options);
     }
 
     if (Lexer()->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
@@ -1023,7 +1024,8 @@ ir::AstNode *ASParser::ParsePropertyOrMethodSignature(const lexer::SourcePositio
         ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
 
         if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-            typeParamDecl = ParseTypeParameterDeclaration();
+            auto options = TypeAnnotationParsingOptions::THROW_ERROR;
+            typeParamDecl = ParseTypeParameterDeclaration(&options);
         }
 
         FunctionParameterContext funcParamContext(&GetContext(), Binder());
diff --git a/parser/ETSparser.cpp b/parser/ETSparser.cpp
index bb4eb0412d8f05e3834a7a762e98d776470e9f6e..48f2cbe86c72d3eebd0659bb98a4fa6d78ae8b68 100644
--- a/parser/ETSparser.cpp
+++ b/parser/ETSparser.cpp
@@ -92,6 +92,10 @@
 #include "libpandabase/os/file.h"
 #include "generated/signatures.h"
 
+#if defined PANDA_TARGET_MOBILE || defined PANDA_TARGET_UNIX || defined PANDA_TARGET_ARM32
+#define USE_FTW
+#endif
+
 #ifdef USE_FTW
 #include <ftw.h>
 #else
@@ -195,39 +199,6 @@ ArenaVector<ir::Statement *> ETSParser::PrepareExternalGlobalClass()
     return statements;
 }
 
-#ifdef USE_FTW
-static bool endsWith(const char *src, const char *suffix, const size_t len_suffix)
-{
-    if (src == nullptr || suffix == nullptr) {
-        return false;
-    }
-
-    const size_t len_src = strlen(src);
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-    return len_src >= len_suffix && strncmp(src + len_src - len_suffix, suffix, len_suffix) == 0;
-}
-
-std::vector<std::string> ETSParser::externalSourcePaths_;  // NOLINT(fuchsia-statically-constructed-objects)
-int ETSParser::NFTWCallBack(const char *fpath, const struct stat * /*unused*/, int tflag, struct FTW * /*unused*/)
-{
-    constexpr const char *Object_ETS = "Object.ets";
-    const size_t len_Object_ETS = strlen(Object_ETS);
-    constexpr const char *ETS_Suffix = ".ets";
-    const size_t len_ETS_Suffix = strlen(ETS_Suffix);
-
-    if (tflag != FTW_F || !endsWith(fpath, ETS_Suffix, len_ETS_Suffix)) {
-        return 0;
-    }
-
-    if (endsWith(fpath, Object_ETS, len_Object_ETS)) {
-        externalSourcePaths_.emplace(externalSourcePaths_.begin(), std::string(fpath));
-    } else {
-        externalSourcePaths_.emplace_back(std::string(fpath));
-    }
-    return 0;
-}
-#endif
-
 std::vector<std::string> ETSParser::CollectExternalSources()
 {
     const std::string stdLib(StdLib());
@@ -236,8 +207,33 @@ std::vector<std::string> ETSParser::CollectExternalSources()
     }
 
 #ifdef USE_FTW
-    nftw(stdLib.c_str(), NFTWCallBack, 16, 0);  // NOLINT(readability-magic-numbers)
-    return std::move(externalSourcePaths_);
+    static std::vector<std::string> paths;
+
+    const auto nftwCallBack = [](const char *fpath, const struct stat *, int tflag, struct FTW *) -> int {
+        constexpr std::string_view Object_ETS = "Object.ets";
+        constexpr std::string_view ETS_Suffix = ".ets";
+
+        const auto endsWith = [](const std::string_view value, const std::string_view ending) -> bool {
+            if (ending.size() > value.size()) {
+                return false;
+            }
+
+            return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
+        };
+
+        if (tflag != FTW_F || !endsWith(fpath, ETS_Suffix)) {
+            return 0;
+        }
+
+        if (endsWith(fpath, Object_ETS)) {
+            paths.emplace(paths.begin(), fpath);
+        } else {
+            paths.emplace_back(fpath);
+        }
+        return 0;
+    };
+    nftw(stdLib.c_str(), nftwCallBack, 16, 0);  // NOLINT(readability-magic-numbers)
+    return std::move(paths);
 #else
     std::vector<std::string> paths;
     for (auto const &entry : fs::recursive_directory_iterator(StdLib())) {
@@ -253,6 +249,7 @@ std::vector<std::string> ETSParser::CollectExternalSources()
     return paths;
 #endif
 }
+#undef USE_FTW
 
 void ETSParser::ParseExternalSources(std::vector<std::string> &paths)
 {
@@ -544,9 +541,8 @@ ir::ModifierFlags ETSParser::ParseClassModifiers()
 
 std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ETSParser::ParseClassImplementsElement()
 {
-    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR |
-                                           TypeAnnotationParsingOptions::DISALLOW_PRIMARY_TYPE |
-                                           TypeAnnotationParsingOptions::ALLOW_WILDCARD;
+    TypeAnnotationParsingOptions options =
+        TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::DISALLOW_PRIMARY_TYPE;
     return {ParseTypeReference(&options), nullptr};
 }
 
@@ -555,9 +551,8 @@ ir::Expression *ETSParser::ParseSuperClassReference()
     if (Lexer()->GetToken().Type() == lexer::TokenType::KEYW_EXTENDS) {
         Lexer()->NextToken();
 
-        TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR |
-                                               TypeAnnotationParsingOptions::DISALLOW_PRIMARY_TYPE |
-                                               TypeAnnotationParsingOptions::ALLOW_WILDCARD;
+        TypeAnnotationParsingOptions options =
+            TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::DISALLOW_PRIMARY_TYPE;
         return ParseTypeReference(&options);
     }
 
@@ -566,9 +561,8 @@ ir::Expression *ETSParser::ParseSuperClassReference()
 
 ir::TypeNode *ETSParser::ParseInterfaceExtendsElement()
 {
-    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR |
-                                           TypeAnnotationParsingOptions::DISALLOW_PRIMARY_TYPE |
-                                           TypeAnnotationParsingOptions::ALLOW_WILDCARD;
+    TypeAnnotationParsingOptions options =
+        TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::DISALLOW_PRIMARY_TYPE;
     return ParseTypeReference(&options);
 }
 
@@ -1017,7 +1011,9 @@ ir::TSTypeAliasDeclaration *ETSParser::ParseTypeAliasDeclaration()
 
     auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-        ir::TSTypeParameterDeclaration *params = ParseTypeParameterDeclaration();
+        auto options =
+            TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::ALLOW_DECLARATION_SITE_VARIANCE;
+        ir::TSTypeParameterDeclaration *params = ParseTypeParameterDeclaration(&options);
         typeAliasDecl->AddTypeParameters(params);
         params->SetParent(typeAliasDecl);
     }
@@ -1044,7 +1040,9 @@ ir::TSInterfaceDeclaration *ETSParser::ParseInterfaceBody(ir::Identifier *name,
     auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
     ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-        typeParamDecl = ParseTypeParameterDeclaration();
+        auto options =
+            TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::ALLOW_DECLARATION_SITE_VARIANCE;
+        typeParamDecl = ParseTypeParameterDeclaration(&options);
     }
 
     ArenaVector<ir::TSInterfaceHeritage *> extends(Allocator()->Adapter());
@@ -1112,7 +1110,9 @@ ir::ClassDefinition *ETSParser::ParseClassDefinition(ir::ClassDefinitionModifier
     auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
     ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-        typeParamDecl = ParseTypeParameterDeclaration();
+        auto options =
+            TypeAnnotationParsingOptions::THROW_ERROR | TypeAnnotationParsingOptions::ALLOW_DECLARATION_SITE_VARIANCE;
+        typeParamDecl = ParseTypeParameterDeclaration(&options);
     }
 
     auto classCtx = binder::LexicalScope<binder::ClassScope>(Binder());
@@ -1374,8 +1374,9 @@ std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ETSParser::Pars
         if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SHIFT) {
             Lexer()->BackwardToken(lexer::TokenType::PUNCTUATOR_LESS_THAN, 1);
         }
-
+        *options |= TypeAnnotationParsingOptions::ALLOW_WILDCARD;
         typeParamInst = ParseTypeParameterInstantiation(options);
+        *options &= ~TypeAnnotationParsingOptions::ALLOW_WILDCARD;
     }
 
     return {typeName, typeParamInst};
@@ -1492,34 +1493,26 @@ ir::TSIntersectionType *ETSParser::ParseIntersectionType(ir::Expression *type)
     intersectionType->SetRange({startLoc, endLoc});
     return intersectionType;
 }
-
 ir::TypeNode *ETSParser::ParseWildcardType(TypeAnnotationParsingOptions *options)
 {
-    if (((*options) & TypeAnnotationParsingOptions::ALLOW_WILDCARD) == 0) {
-        return nullptr;
-    }
-
-    auto *typeAnnotation = AllocNode<ir::ETSWildcardType>();
-    typeAnnotation->SetRange(Lexer()->GetToken().Loc());
-    Lexer()->NextToken();
-
-    if (Lexer()->GetToken().Type() == lexer::TokenType::KEYW_EXTENDS ||
-        Lexer()->GetToken().Type() == lexer::TokenType::KEYW_SUPER) {
-        bool superBound = Lexer()->GetToken().Type() == lexer::TokenType::KEYW_SUPER;
-        Lexer()->NextToken();  // eat 'extends'
+    const auto varianceStartLoc = Lexer()->GetToken().Start();
+    const auto varianceEndLoc = Lexer()->GetToken().End();
+    const auto varianceModifier = ParseTypeVarianceModifier(options);
 
-        auto *bound = ParseTypeReference(options);
-
-        if (superBound) {
-            typeAnnotation->SetSuperBound(bound->AsETSTypeReference());
-        } else {
-            typeAnnotation->SetExtendsBound(bound->AsETSTypeReference());
+    auto *typeReference = [this, &varianceModifier, options]() -> ir::ETSTypeReference * {
+        if (varianceModifier == ir::ModifierFlags::OUT &&
+            (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_GREATER_THAN ||
+             Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA)) {
+            // unbounded 'out'
+            return nullptr;
         }
+        return ParseTypeReference(options)->AsETSTypeReference();
+    }();
 
-        typeAnnotation->SetEnd(bound->End());
-    }
+    auto *wildcardType = AllocNode<ir::ETSWildcardType>(typeReference, varianceModifier);
+    wildcardType->SetRange({varianceStartLoc, typeReference == nullptr ? varianceEndLoc : typeReference->End()});
 
-    return typeAnnotation;
+    return wildcardType;
 }
 
 ir::TypeNode *ETSParser::ParseFunctionType()
@@ -1627,7 +1620,13 @@ ir::TypeNode *ETSParser::ParseTypeAnnotation(TypeAnnotationParsingOptions *optio
 
     switch (Lexer()->GetToken().Type()) {
         case lexer::TokenType::LITERAL_IDENT: {
-            typeAnnotation = ParseTypeReference(options);
+            if (const auto keyword = Lexer()->GetToken().KeywordType();
+                keyword == lexer::TokenType::KEYW_IN || keyword == lexer::TokenType::KEYW_OUT) {
+                typeAnnotation = ParseWildcardType(options);
+            } else {
+                typeAnnotation = ParseTypeReference(options);
+            }
+
             if (((*options) & TypeAnnotationParsingOptions::POTENTIAL_CLASS_LITERAL) != 0 &&
                 Lexer()->GetToken().Type() == lexer::TokenType::KEYW_CLASS) {
                 return typeAnnotation;
@@ -1670,10 +1669,6 @@ ir::TypeNode *ETSParser::ParseTypeAnnotation(TypeAnnotationParsingOptions *optio
             typeAnnotation = ParsePrimitiveType(options, ir::PrimitiveType::SHORT);
             break;
         }
-        case lexer::TokenType::PUNCTUATOR_QUESTION_MARK: {
-            typeAnnotation = ParseWildcardType(options);
-            break;
-        }
         case lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS: {
             if (((*options) & TypeAnnotationParsingOptions::IGNORE_FUNCTION_TYPE) != 0) {
                 break;
@@ -2240,9 +2235,8 @@ bool ETSParser::ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, i
         Lexer()->BackwardToken(lexer::TokenType::PUNCTUATOR_LESS_THAN, 1);
     }
 
-    TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::DISALLOW_PRIMARY_TYPE |
-                                           TypeAnnotationParsingOptions::ALLOW_WILDCARD |
-                                           TypeAnnotationParsingOptions::IGNORE_FUNCTION_TYPE;
+    TypeAnnotationParsingOptions options =
+        TypeAnnotationParsingOptions::DISALLOW_PRIMARY_TYPE | TypeAnnotationParsingOptions::IGNORE_FUNCTION_TYPE;
     ir::TSTypeParameterInstantiation *typeParams = ParseTypeParameterInstantiation(&options);
 
     if (typeParams == nullptr) {
@@ -2492,7 +2486,7 @@ ir::Expression *ETSParser::ParseNewExpression()
     TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::THROW_ERROR;
     ir::TypeNode *typeReference = ParseBaseTypeReference(&options);
     if (typeReference == nullptr) {
-        options |= TypeAnnotationParsingOptions::DISALLOW_PRIMARY_TYPE | TypeAnnotationParsingOptions::ALLOW_WILDCARD;
+        options |= TypeAnnotationParsingOptions::DISALLOW_PRIMARY_TYPE;
         typeReference = ParseTypeReference(&options);
     } else if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE) {
         ThrowSyntaxError("Invalid { after base types.");
@@ -2580,9 +2574,42 @@ ir::Expression *ETSParser::ParseNewExpression()
     return newExprNode;
 }
 
+ir::ModifierFlags ETSParser::ParseTypeVarianceModifier(TypeAnnotationParsingOptions *const options)
+{
+    if ((*options & TypeAnnotationParsingOptions::ALLOW_WILDCARD) == 0 &&
+        (*options & TypeAnnotationParsingOptions::ALLOW_DECLARATION_SITE_VARIANCE) == 0) {
+        ThrowSyntaxError("Variance modifier is not allowed here.");
+    }
+
+    switch (Lexer()->GetToken().KeywordType()) {
+        case lexer::TokenType::KEYW_IN: {
+            Lexer()->NextToken();
+            return ir::ModifierFlags::IN;
+        }
+        case lexer::TokenType::KEYW_OUT: {
+            Lexer()->NextToken();
+            return ir::ModifierFlags::OUT;
+        }
+        default: {
+            return ir::ModifierFlags::NONE;
+        }
+    }
+}
+
 ir::TSTypeParameter *ETSParser::ParseTypeParameter([[maybe_unused]] TypeAnnotationParsingOptions *options)
 {
     lexer::SourcePosition startLoc = Lexer()->GetToken().Start();
+
+    const auto varianceModifier = [this, options] {
+        switch (Lexer()->GetToken().KeywordType()) {
+            case lexer::TokenType::KEYW_IN:
+            case lexer::TokenType::KEYW_OUT:
+                return ParseTypeVarianceModifier(options);
+            default:
+                return ir::ModifierFlags::NONE;
+        }
+    }();
+
     auto *paramIdent = ExpectIdentifier();
     binder::Decl *decl = Binder()->AddDecl<binder::TypeParameterDecl>(paramIdent->Start(), paramIdent->Name());
 
@@ -2595,7 +2622,7 @@ ir::TSTypeParameter *ETSParser::ParseTypeParameter([[maybe_unused]] TypeAnnotati
         constraint = ParseTypeAnnotation(&newOptions);
     }
 
-    auto *typeParam = AllocNode<ir::TSTypeParameter>(paramIdent, constraint, nullptr);
+    auto *typeParam = AllocNode<ir::TSTypeParameter>(paramIdent, constraint, nullptr, varianceModifier);
     decl->BindNode(typeParam);
     typeParam->SetRange({startLoc, Lexer()->GetToken().End()});
     return typeParam;
diff --git a/parser/ETSparser.h b/parser/ETSparser.h
index 702bfee3d921f96ab6ec7501e5140fc84d338876..97a0e2639bf4db467308f4b41792a5d4e84de526 100644
--- a/parser/ETSparser.h
+++ b/parser/ETSparser.h
@@ -18,14 +18,6 @@
 
 #include "TypedParser.h"
 
-#if defined PANDA_TARGET_MOBILE || defined PANDA_TARGET_UNIX || defined PANDA_TARGET_ARM32
-#define USE_FTW
-#endif
-
-#ifdef USE_FTW
-struct FTW;
-#endif
-
 namespace panda::es2panda::ir {
 class ETSPackageDeclaration;
 enum class ClassDefinitionModifiers : uint32_t;
@@ -47,9 +39,6 @@ private:
     void ParsePackageDeclaration(ArenaVector<ir::Statement *> &statements);
     ArenaVector<ir::AstNode *> ParseTopLevelStatements(ArenaVector<ir::Statement *> &statements);
     void ParseTopLevelDeclaration(ArenaVector<ir::Statement *> &statements);
-#ifdef USE_FTW
-    static int NFTWCallBack(const char *fpath, const struct stat * /*unused*/, int tflag, struct FTW * /*unused*/);
-#endif
     std::vector<std::string> CollectExternalSources();
     void ParseExternalSources(std::vector<std::string> &paths);
     ArenaVector<ir::ImportDeclaration *> ParseImportDeclarations();
@@ -178,14 +167,13 @@ private:
 
     util::StringView FormInterfaceOrEnumDeclarationIdBinding(ir::Identifier *id) override;
 
+    ir::ModifierFlags ParseTypeVarianceModifier(TypeAnnotationParsingOptions *options);
+
     friend class ExternalSourceParser;
     friend class InnerSourceParser;
 
 private:
     parser::Program *globalProgram_;
-#ifdef USE_FTW
-    static std::vector<std::string> externalSourcePaths_;
-#endif
 };
 
 class ExternalSourceParser {
diff --git a/parser/TSparser.cpp b/parser/TSparser.cpp
index 08f715ffc4f0002bd62567b25df1e25d1e554e6c..1a09f3c755fc3483fe2d2ffb74bafa6ee851b4b9 100644
--- a/parser/TSparser.cpp
+++ b/parser/TSparser.cpp
@@ -204,7 +204,8 @@ ir::TSTypeAliasDeclaration *TSParser::ParseTypeAliasDeclaration()
     auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
     ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-        typeParamDecl = ParseTypeParameterDeclaration();
+        auto options = TypeAnnotationParsingOptions::THROW_ERROR;
+        typeParamDecl = ParseTypeParameterDeclaration(&options);
     }
 
     if (Lexer()->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
@@ -1431,7 +1432,8 @@ ir::TypeNode *TSParser::ParseFunctionType(lexer::SourcePosition startLoc, bool i
 
     ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-        typeParamDecl = ParseTypeParameterDeclaration(throwError);
+        auto options = throwError ? TypeAnnotationParsingOptions::THROW_ERROR : TypeAnnotationParsingOptions::NO_OPTS;
+        typeParamDecl = ParseTypeParameterDeclaration(&options);
 
         if (Lexer()->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
             if (!throwError) {
@@ -1636,7 +1638,8 @@ ir::ArrowFunctionExpression *TSParser::ParsePotentialArrowExpression(ir::Express
             const auto savedPos = Lexer()->Save();
 
             auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
-            typeParamDecl = ParseTypeParameterDeclaration(false);
+            auto options = TypeAnnotationParsingOptions::NO_OPTS;
+            typeParamDecl = ParseTypeParameterDeclaration(&options);
             if (typeParamDecl == nullptr) {
                 Lexer()->Rewind(savedPos);
                 return nullptr;
@@ -1781,7 +1784,8 @@ ir::TSSignatureDeclaration *TSParser::ParseSignatureMember(bool isCallSignature)
     auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
     ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-        typeParamDecl = ParseTypeParameterDeclaration();
+        auto options = TypeAnnotationParsingOptions::THROW_ERROR;
+        typeParamDecl = ParseTypeParameterDeclaration(&options);
 
         if (Lexer()->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
             ThrowSyntaxError("'(' expected");
@@ -1980,7 +1984,8 @@ ir::AstNode *TSParser::ParsePropertyOrMethodSignature(const lexer::SourcePositio
         auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
         ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
         if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-            typeParamDecl = ParseTypeParameterDeclaration();
+            auto options = TypeAnnotationParsingOptions::THROW_ERROR;
+            typeParamDecl = ParseTypeParameterDeclaration(&options);
         }
 
         if (Lexer()->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
diff --git a/parser/TypedParser.cpp b/parser/TypedParser.cpp
index 1af3a75fc9a994676f645a9bb1d7747a89e51bcc..284aaccdcb1a1b0b6135cbc47aef5c0577288171 100644
--- a/parser/TypedParser.cpp
+++ b/parser/TypedParser.cpp
@@ -202,7 +202,9 @@ ir::ArrowFunctionExpression *TypedParser::ParseGenericArrowFunction()
     lexer::SourcePosition startLoc = Lexer()->GetToken().Start();
 
     auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
-    ir::TSTypeParameterDeclaration *typeParamDecl = ParseTypeParameterDeclaration(false);
+
+    auto typeParamDeclOptions = TypeAnnotationParsingOptions::NO_OPTS;
+    ir::TSTypeParameterDeclaration *typeParamDecl = ParseTypeParameterDeclaration(&typeParamDeclOptions);
 
     if (Lexer()->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
         return nullptr;
@@ -439,7 +441,8 @@ ArenaVector<ir::TSInterfaceHeritage *> TypedParser::ParseInterfaceExtendsClause(
 ir::TSTypeParameterDeclaration *TypedParser::ParseFunctionTypeParameters()
 {
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-        return ParseTypeParameterDeclaration();
+        auto options = TypeAnnotationParsingOptions::THROW_ERROR;
+        return ParseTypeParameterDeclaration(&options);
     }
 
     return nullptr;
@@ -499,7 +502,8 @@ ir::Statement *TypedParser::ParseInterfaceDeclaration(bool isStatic)
     auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
     ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-        typeParamDecl = ParseTypeParameterDeclaration();
+        auto options = TypeAnnotationParsingOptions::THROW_ERROR;
+        typeParamDecl = ParseTypeParameterDeclaration(&options);
     }
 
     ArenaVector<ir::TSInterfaceHeritage *> extends(Allocator()->Adapter());
@@ -774,7 +778,7 @@ ir::TSTypeParameter *TypedParser::ParseTypeParameter(TypeAnnotationParsingOption
     return typeParam;
 }
 
-ir::TSTypeParameterDeclaration *TypedParser::ParseTypeParameterDeclaration(bool throwError)
+ir::TSTypeParameterDeclaration *TypedParser::ParseTypeParameterDeclaration(TypeAnnotationParsingOptions *options)
 {
     ASSERT(Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN);
 
@@ -785,16 +789,11 @@ ir::TSTypeParameterDeclaration *TypedParser::ParseTypeParameterDeclaration(bool
     Lexer()->NextToken();  // eat '<'
 
     while (Lexer()->GetToken().Type() != lexer::TokenType::PUNCTUATOR_GREATER_THAN) {
-        TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::ADD_TYPE_PARAMETER_BINDING;
-
-        if (throwError) {
-            options |= TypeAnnotationParsingOptions::THROW_ERROR;
-        }
-
-        ir::TSTypeParameter *currentParam = ParseTypeParameter(&options);
+        auto newOptions = *options | TypeAnnotationParsingOptions::ADD_TYPE_PARAMETER_BINDING;
+        ir::TSTypeParameter *currentParam = ParseTypeParameter(&newOptions);
 
         if (currentParam == nullptr) {
-            ASSERT(!throwError);
+            ASSERT((newOptions & TypeAnnotationParsingOptions::THROW_ERROR) == 0);
             return nullptr;
         }
 
@@ -814,7 +813,7 @@ ir::TSTypeParameterDeclaration *TypedParser::ParseTypeParameterDeclaration(bool
         }
 
         if (Lexer()->GetToken().Type() != lexer::TokenType::PUNCTUATOR_GREATER_THAN) {
-            if (!throwError) {
+            if ((newOptions & TypeAnnotationParsingOptions::THROW_ERROR) == 0) {
                 return nullptr;
             }
 
@@ -942,7 +941,8 @@ ir::ClassDefinition *TypedParser::ParseClassDefinition(ir::ClassDefinitionModifi
     auto typeParamsCtx = binder::LexicalScope<binder::LocalScope>(Binder());
     ir::TSTypeParameterDeclaration *typeParamDecl = nullptr;
     if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN) {
-        typeParamDecl = ParseTypeParameterDeclaration();
+        auto options = TypeAnnotationParsingOptions::THROW_ERROR;
+        typeParamDecl = ParseTypeParameterDeclaration(&options);
     }
     auto classCtx = binder::LexicalScope<binder::LocalScope>(Binder());
 
diff --git a/parser/TypedParser.h b/parser/TypedParser.h
index 4bda1a036d7e0eadb5e438693cf37fa043b99add..0348c6ba11f1f261beb5978e6a436f7168cd73e7 100644
--- a/parser/TypedParser.h
+++ b/parser/TypedParser.h
@@ -43,7 +43,7 @@ protected:
     ir::TSTypeAssertion *ParseTypeAssertion();
     ir::TSTypeParameterInstantiation *ParseTypeParameterInstantiation(TypeAnnotationParsingOptions *options);
 
-    ir::TSTypeParameterDeclaration *ParseTypeParameterDeclaration(bool throwError = true);
+    ir::TSTypeParameterDeclaration *ParseTypeParameterDeclaration(TypeAnnotationParsingOptions *options);
     ir::Expression *ParseQualifiedName(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
     ir::Expression *ParseQualifiedReference(ir::Expression *typeName,
                                             ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
diff --git a/parser/parserImpl.h b/parser/parserImpl.h
index ee04d21295dbfc76068d569340770e88213cd902..0614946e4c311471356c0d7f4128e1806d913397 100644
--- a/parser/parserImpl.h
+++ b/parser/parserImpl.h
@@ -160,7 +160,8 @@ enum class TypeAnnotationParsingOptions : uint32_t {
     ADD_TYPE_PARAMETER_BINDING = 1U << 10U,
     DISALLOW_PRIMARY_TYPE = 1U << 11U,
     ALLOW_WILDCARD = 1U << 12U,
-    IGNORE_FUNCTION_TYPE = 1U << 13U
+    IGNORE_FUNCTION_TYPE = 1U << 13U,
+    ALLOW_DECLARATION_SITE_VARIANCE = 1U << 14U,
 };
 
 DEFINE_BITOPS(TypeAnnotationParsingOptions)
diff --git a/test/parser/ets/assign_bad-expected.txt b/test/parser/ets/assign_bad-expected.txt
index 1692a1cba290082527943215eaa537a83254915e..682c9345dbfbe3517ebe05a522fafa57e5df3543 100644
--- a/test/parser/ets/assign_bad-expected.txt
+++ b/test/parser/ets/assign_bad-expected.txt
@@ -1 +1 @@
-SyntaxError: Unexpected token: ' [assign_bad.ets:16:1]
+SyntaxError: Unexpected token: ''. [assign_bad.ets:16:1]
diff --git a/test/parser/ets/lexer001-expected.txt b/test/parser/ets/lexer001-expected.txt
index 47e6214e61f85646541fb637c960d507b99a31b1..349cf2d164d26b139b4f10d37236dbb024bfe50c 100644
--- a/test/parser/ets/lexer001-expected.txt
+++ b/test/parser/ets/lexer001-expected.txt
@@ -1 +1 @@
-SyntaxError: Unexpected token: ' [lexer001.ets:16:1]
+SyntaxError: Unexpected token: ''. [lexer001.ets:16:1]
diff --git a/test/parser/ets/lexer002-expected.txt b/test/parser/ets/lexer002-expected.txt
index 5d0f6d1d3f4ca6ee8cb5ad63607b36b8ffbeda3e..73e63cc0985088229488306471058b05c9930899 100644
--- a/test/parser/ets/lexer002-expected.txt
+++ b/test/parser/ets/lexer002-expected.txt
@@ -1 +1 @@
-SyntaxError: Unexpected token: ' [lexer002.ets:16:1]
+SyntaxError: Unexpected token: ''. [lexer002.ets:16:1]
diff --git a/test/parser/ets/test_type_alias10-expected.txt b/test/parser/ets/test_type_alias10-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1179a20b17806f48e7313f0867e44c12d5a977d2
--- /dev/null
+++ b/test/parser/ets/test_type_alias10-expected.txt
@@ -0,0 +1,197 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "firstType",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 6
+          },
+          "end": {
+            "line": 16,
+            "column": 15
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "ETSTypeReference",
+        "part": {
+          "type": "ETSTypeReferencePart",
+          "name": {
+            "type": "Identifier",
+            "name": "secondType",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 16,
+                "column": 18
+              },
+              "end": {
+                "line": 16,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 18
+            },
+            "end": {
+              "line": 16,
+              "column": 29
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 18
+          },
+          "end": {
+            "line": 16,
+            "column": 29
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 16,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "TSTypeAliasDeclaration",
+      "id": {
+        "type": "Identifier",
+        "name": "secondType",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 6
+          },
+          "end": {
+            "line": 17,
+            "column": 16
+          }
+        }
+      },
+      "typeAnnotation": {
+        "type": "ETSTypeReference",
+        "part": {
+          "type": "ETSTypeReferencePart",
+          "name": {
+            "type": "Identifier",
+            "name": "firstType",
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 19
+              },
+              "end": {
+                "line": 17,
+                "column": 28
+              }
+            }
+          },
+          "loc": {
+            "start": {
+              "line": 17,
+              "column": 19
+            },
+            "end": {
+              "line": 17,
+              "column": 29
+            }
+          }
+        },
+        "loc": {
+          "start": {
+            "line": 17,
+            "column": 19
+          },
+          "end": {
+            "line": 17,
+            "column": 29
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 17,
+          "column": 1
+        },
+        "end": {
+          "line": 17,
+          "column": 29
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "ETSGLOBAL",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 1,
+              "column": 1
+            },
+            "end": {
+              "line": 1,
+              "column": 1
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [],
+        "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
+    }
+  }
+}
+TypeError: Circular type alias reference [test_type_alias10.ets:17:1]
diff --git a/test/parser/ets/test_type_alias10.ets b/test/parser/ets/test_type_alias10.ets
new file mode 100644
index 0000000000000000000000000000000000000000..cf1e242a71017d1851009ce529881e64256a16d7
--- /dev/null
+++ b/test/parser/ets/test_type_alias10.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.
+ */
+
+type firstType = secondType;
+type secondType = firstType;
diff --git a/test/parser/ets/type_variance1-expected.txt b/test/parser/ets/type_variance1-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b28540a5f332178ed5b48b0e9e2f988ab3e5fed3
--- /dev/null
+++ b/test/parser/ets/type_variance1-expected.txt
@@ -0,0 +1,3331 @@
+{
+  "type": "Program",
+  "statements": [
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 7
+            },
+            "end": {
+              "line": 16,
+              "column": 8
+            }
+          }
+        },
+        "typeParameters": {
+          "type": "TSTypeParameterDeclaration",
+          "params": [
+            {
+              "type": "TSTypeParameter",
+              "name": {
+                "type": "Identifier",
+                "name": "T",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 16,
+                    "column": 12
+                  },
+                  "end": {
+                    "line": 16,
+                    "column": 13
+                  }
+                }
+              },
+              "in": true,
+              "loc": {
+                "start": {
+                  "line": 16,
+                  "column": 9
+                },
+                "end": {
+                  "line": 16,
+                  "column": 14
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 16,
+              "column": 8
+            },
+            "end": {
+              "line": 16,
+              "column": 14
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [],
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "set",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 5
+                },
+                "end": {
+                  "line": 17,
+                  "column": 8
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "set",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 8
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "_",
+                    "typeAnnotation": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "T",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 17,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 17,
+                              "column": 13
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 17,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 17,
+                            "column": 14
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 17,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 17,
+                          "column": 14
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 17,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 17,
+                        "column": 14
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 16
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 20
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [],
+                  "loc": {
+                    "start": {
+                      "line": 17,
+                      "column": 21
+                    },
+                    "end": {
+                      "line": 17,
+                      "column": 23
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 17,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 17,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 17,
+                  "column": 8
+                },
+                "end": {
+                  "line": 17,
+                  "column": 23
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 17,
+                "column": 5
+              },
+              "end": {
+                "line": 17,
+                "column": 23
+              }
+            }
+          },
+          {
+            "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": 18,
+                "column": 2
+              },
+              "end": {
+                "line": 18,
+                "column": 2
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 16,
+            "column": 15
+          },
+          "end": {
+            "line": 18,
+            "column": 2
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 16,
+          "column": 1
+        },
+        "end": {
+          "line": 18,
+          "column": 2
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "set",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 5
+                },
+                "end": {
+                  "line": 23,
+                  "column": 8
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "set",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 8
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "_",
+                    "typeAnnotation": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "In_T",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 23,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 23,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 23,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 23,
+                            "column": 17
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 23,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 23,
+                          "column": 17
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 23,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 23,
+                        "column": 17
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 23,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 23,
+                      "column": 23
+                    }
+                  }
+                },
+                "declare": true,
+                "loc": {
+                  "start": {
+                    "line": 23,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 23,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 23,
+                  "column": 8
+                },
+                "end": {
+                  "line": 23,
+                  "column": 23
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 23,
+                "column": 5
+              },
+              "end": {
+                "line": 23,
+                "column": 23
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "get",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 5
+                },
+                "end": {
+                  "line": 24,
+                  "column": 8
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "get",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 8
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "ETSTypeReference",
+                  "part": {
+                    "type": "ETSTypeReferencePart",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "Out_T",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 24,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 24,
+                          "column": 17
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 24,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 24,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 24,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 24,
+                      "column": 18
+                    }
+                  }
+                },
+                "declare": true,
+                "loc": {
+                  "start": {
+                    "line": 24,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 24,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 24,
+                  "column": 8
+                },
+                "end": {
+                  "line": 24,
+                  "column": 18
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 24,
+                "column": 5
+              },
+              "end": {
+                "line": 24,
+                "column": 18
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 50
+          },
+          "end": {
+            "line": 25,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Declaration_Site_I",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 11
+          },
+          "end": {
+            "line": 22,
+            "column": 29
+          }
+        }
+      },
+      "extends": [],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "In_T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 33
+                },
+                "end": {
+                  "line": 22,
+                  "column": 37
+                }
+              }
+            },
+            "in": true,
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 30
+              },
+              "end": {
+                "line": 22,
+                "column": 38
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "Out_T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 22,
+                  "column": 43
+                },
+                "end": {
+                  "line": 22,
+                  "column": 48
+                }
+              }
+            },
+            "out": true,
+            "loc": {
+              "start": {
+                "line": 22,
+                "column": 39
+              },
+              "end": {
+                "line": 22,
+                "column": 49
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 22,
+            "column": 29
+          },
+          "end": {
+            "line": 22,
+            "column": 49
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 22,
+          "column": 1
+        },
+        "end": {
+          "line": 27,
+          "column": 10
+        }
+      }
+    },
+    {
+      "type": "TSInterfaceDeclaration",
+      "body": {
+        "type": "TSInterfaceBody",
+        "body": [
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "set",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 28,
+                  "column": 5
+                },
+                "end": {
+                  "line": 28,
+                  "column": 8
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "set",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 28,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 8
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [
+                  {
+                    "type": "Identifier",
+                    "name": "_",
+                    "typeAnnotation": {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "In_T",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 28,
+                              "column": 12
+                            },
+                            "end": {
+                              "line": 28,
+                              "column": 16
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 28,
+                            "column": 12
+                          },
+                          "end": {
+                            "line": 28,
+                            "column": 17
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 28,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 28,
+                          "column": 17
+                        }
+                      }
+                    },
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 28,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 28,
+                        "column": 17
+                      }
+                    }
+                  }
+                ],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 28,
+                      "column": 19
+                    },
+                    "end": {
+                      "line": 28,
+                      "column": 23
+                    }
+                  }
+                },
+                "declare": true,
+                "loc": {
+                  "start": {
+                    "line": 28,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 28,
+                    "column": 23
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 28,
+                  "column": 8
+                },
+                "end": {
+                  "line": 28,
+                  "column": 23
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 28,
+                "column": 5
+              },
+              "end": {
+                "line": 28,
+                "column": 23
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "get",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 5
+                },
+                "end": {
+                  "line": 29,
+                  "column": 8
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": false,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "get",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 5
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 8
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "ETSTypeReference",
+                  "part": {
+                    "type": "ETSTypeReferencePart",
+                    "name": {
+                      "type": "Identifier",
+                      "name": "Out_T",
+                      "decorators": [],
+                      "loc": {
+                        "start": {
+                          "line": 29,
+                          "column": 12
+                        },
+                        "end": {
+                          "line": 29,
+                          "column": 17
+                        }
+                      }
+                    },
+                    "loc": {
+                      "start": {
+                        "line": 29,
+                        "column": 12
+                      },
+                      "end": {
+                        "line": 29,
+                        "column": 18
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 29,
+                      "column": 12
+                    },
+                    "end": {
+                      "line": 29,
+                      "column": 18
+                    }
+                  }
+                },
+                "declare": true,
+                "loc": {
+                  "start": {
+                    "line": 29,
+                    "column": 8
+                  },
+                  "end": {
+                    "line": 29,
+                    "column": 18
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 29,
+                  "column": 8
+                },
+                "end": {
+                  "line": 29,
+                  "column": 18
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 29,
+                "column": 5
+              },
+              "end": {
+                "line": 29,
+                "column": 18
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 35
+          },
+          "end": {
+            "line": 30,
+            "column": 2
+          }
+        }
+      },
+      "id": {
+        "type": "Identifier",
+        "name": "Use_Site_I",
+        "decorators": [],
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 11
+          },
+          "end": {
+            "line": 27,
+            "column": 21
+          }
+        }
+      },
+      "extends": [],
+      "typeParameters": {
+        "type": "TSTypeParameterDeclaration",
+        "params": [
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "In_T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 22
+                },
+                "end": {
+                  "line": 27,
+                  "column": 26
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 22
+              },
+              "end": {
+                "line": 27,
+                "column": 27
+              }
+            }
+          },
+          {
+            "type": "TSTypeParameter",
+            "name": {
+              "type": "Identifier",
+              "name": "Out_T",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 27,
+                  "column": 28
+                },
+                "end": {
+                  "line": 27,
+                  "column": 33
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 27,
+                "column": 28
+              },
+              "end": {
+                "line": 27,
+                "column": 34
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 27,
+            "column": 21
+          },
+          "end": {
+            "line": 27,
+            "column": 34
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 27,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 6
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "O",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 32,
+              "column": 7
+            },
+            "end": {
+              "line": 32,
+              "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": 32,
+                "column": 11
+              },
+              "end": {
+                "line": 32,
+                "column": 11
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 32,
+            "column": 9
+          },
+          "end": {
+            "line": 32,
+            "column": 11
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 32,
+          "column": 1
+        },
+        "end": {
+          "line": 32,
+          "column": 11
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Declaration_Site_C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 34,
+              "column": 7
+            },
+            "end": {
+              "line": 34,
+              "column": 25
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "Declaration_Site_I",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 37
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 55
+                    }
+                  }
+                },
+                "typeParams": {
+                  "type": "TSTypeParameterInstantiation",
+                  "params": [
+                    {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "O",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 56
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 57
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 56
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 58
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 56
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 58
+                        }
+                      }
+                    },
+                    {
+                      "type": "ETSTypeReference",
+                      "part": {
+                        "type": "ETSTypeReferencePart",
+                        "name": {
+                          "type": "Identifier",
+                          "name": "O",
+                          "decorators": [],
+                          "loc": {
+                            "start": {
+                              "line": 34,
+                              "column": 59
+                            },
+                            "end": {
+                              "line": 34,
+                              "column": 60
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 34,
+                            "column": 59
+                          },
+                          "end": {
+                            "line": 34,
+                            "column": 61
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 34,
+                          "column": 59
+                        },
+                        "end": {
+                          "line": 34,
+                          "column": 61
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 34,
+                      "column": 55
+                    },
+                    "end": {
+                      "line": 34,
+                      "column": 61
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 34,
+                    "column": 37
+                  },
+                  "end": {
+                    "line": 34,
+                    "column": 63
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 34,
+                  "column": 37
+                },
+                "end": {
+                  "line": 34,
+                  "column": 63
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 34,
+                "column": 37
+              },
+              "end": {
+                "line": 34,
+                "column": 63
+              }
+            }
+          }
+        ],
+        "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": 34,
+                "column": 64
+              },
+              "end": {
+                "line": 34,
+                "column": 64
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 34,
+            "column": 62
+          },
+          "end": {
+            "line": 34,
+            "column": 64
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 34,
+          "column": 1
+        },
+        "end": {
+          "line": 34,
+          "column": 64
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Use_Site_C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 36,
+              "column": 7
+            },
+            "end": {
+              "line": 36,
+              "column": 17
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "Use_Site_I",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 36,
+                      "column": 29
+                    },
+                    "end": {
+                      "line": 36,
+                      "column": 39
+                    }
+                  }
+                },
+                "typeParams": {
+                  "type": "TSTypeParameterInstantiation",
+                  "params": [
+                    {
+                      "type": "ETSWildcardType",
+                      "typeReference": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "O",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 36,
+                                "column": 43
+                              },
+                              "end": {
+                                "line": 36,
+                                "column": 44
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 36,
+                              "column": 43
+                            },
+                            "end": {
+                              "line": 36,
+                              "column": 45
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 36,
+                            "column": 43
+                          },
+                          "end": {
+                            "line": 36,
+                            "column": 45
+                          }
+                        }
+                      },
+                      "in": true,
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 40
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 45
+                        }
+                      }
+                    },
+                    {
+                      "type": "ETSWildcardType",
+                      "typeReference": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "O",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 36,
+                                "column": 50
+                              },
+                              "end": {
+                                "line": 36,
+                                "column": 51
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 36,
+                              "column": 50
+                            },
+                            "end": {
+                              "line": 36,
+                              "column": 52
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 36,
+                            "column": 50
+                          },
+                          "end": {
+                            "line": 36,
+                            "column": 52
+                          }
+                        }
+                      },
+                      "out": true,
+                      "loc": {
+                        "start": {
+                          "line": 36,
+                          "column": 46
+                        },
+                        "end": {
+                          "line": 36,
+                          "column": 52
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 36,
+                      "column": 39
+                    },
+                    "end": {
+                      "line": 36,
+                      "column": 52
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 36,
+                    "column": 29
+                  },
+                  "end": {
+                    "line": 36,
+                    "column": 54
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 36,
+                  "column": 29
+                },
+                "end": {
+                  "line": 36,
+                  "column": 54
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 36,
+                "column": 29
+              },
+              "end": {
+                "line": 36,
+                "column": 54
+              }
+            }
+          }
+        ],
+        "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": 36,
+                "column": 55
+              },
+              "end": {
+                "line": 36,
+                "column": 55
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 36,
+            "column": 53
+          },
+          "end": {
+            "line": 36,
+            "column": 55
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 36,
+          "column": 1
+        },
+        "end": {
+          "line": 36,
+          "column": 55
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "Outbounded_Use_Site_C",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 38,
+              "column": 7
+            },
+            "end": {
+              "line": 38,
+              "column": 28
+            }
+          }
+        },
+        "superClass": null,
+        "implements": [
+          {
+            "type": "TSClassImplements",
+            "expression": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "Use_Site_I",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 38,
+                      "column": 40
+                    },
+                    "end": {
+                      "line": 38,
+                      "column": 50
+                    }
+                  }
+                },
+                "typeParams": {
+                  "type": "TSTypeParameterInstantiation",
+                  "params": [
+                    {
+                      "type": "ETSWildcardType",
+                      "typeReference": {
+                        "type": "ETSTypeReference",
+                        "part": {
+                          "type": "ETSTypeReferencePart",
+                          "name": {
+                            "type": "Identifier",
+                            "name": "O",
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 38,
+                                "column": 54
+                              },
+                              "end": {
+                                "line": 38,
+                                "column": 55
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 38,
+                              "column": 54
+                            },
+                            "end": {
+                              "line": 38,
+                              "column": 56
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 38,
+                            "column": 54
+                          },
+                          "end": {
+                            "line": 38,
+                            "column": 56
+                          }
+                        }
+                      },
+                      "in": true,
+                      "loc": {
+                        "start": {
+                          "line": 38,
+                          "column": 51
+                        },
+                        "end": {
+                          "line": 38,
+                          "column": 56
+                        }
+                      }
+                    },
+                    {
+                      "type": "ETSWildcardType",
+                      "out": true,
+                      "loc": {
+                        "start": {
+                          "line": 38,
+                          "column": 57
+                        },
+                        "end": {
+                          "line": 38,
+                          "column": 60
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 38,
+                      "column": 50
+                    },
+                    "end": {
+                      "line": 38,
+                      "column": 61
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 38,
+                    "column": 40
+                  },
+                  "end": {
+                    "line": 38,
+                    "column": 63
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 38,
+                  "column": 40
+                },
+                "end": {
+                  "line": 38,
+                  "column": 63
+                }
+              }
+            },
+            "loc": {
+              "start": {
+                "line": 38,
+                "column": 40
+              },
+              "end": {
+                "line": 38,
+                "column": 63
+              }
+            }
+          }
+        ],
+        "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": 38,
+                "column": 64
+              },
+              "end": {
+                "line": 38,
+                "column": 64
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 38,
+            "column": 62
+          },
+          "end": {
+            "line": 38,
+            "column": 64
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 38,
+          "column": 1
+        },
+        "end": {
+          "line": 38,
+          "column": 64
+        }
+      }
+    },
+    {
+      "type": "ClassDeclaration",
+      "definition": {
+        "id": {
+          "type": "Identifier",
+          "name": "O2",
+          "decorators": [],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 7
+            },
+            "end": {
+              "line": 40,
+              "column": 9
+            }
+          }
+        },
+        "typeParameters": {
+          "type": "TSTypeParameterDeclaration",
+          "params": [
+            {
+              "type": "TSTypeParameter",
+              "name": {
+                "type": "Identifier",
+                "name": "T",
+                "decorators": [],
+                "loc": {
+                  "start": {
+                    "line": 40,
+                    "column": 10
+                  },
+                  "end": {
+                    "line": 40,
+                    "column": 11
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 40,
+                  "column": 10
+                },
+                "end": {
+                  "line": 40,
+                  "column": 12
+                }
+              }
+            }
+          ],
+          "loc": {
+            "start": {
+              "line": 40,
+              "column": 9
+            },
+            "end": {
+              "line": 40,
+              "column": 12
+            }
+          }
+        },
+        "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": 40,
+                "column": 15
+              },
+              "end": {
+                "line": 40,
+                "column": 15
+              }
+            }
+          }
+        ],
+        "loc": {
+          "start": {
+            "line": 40,
+            "column": 13
+          },
+          "end": {
+            "line": 40,
+            "column": 15
+          }
+        }
+      },
+      "loc": {
+        "start": {
+          "line": 40,
+          "column": 1
+        },
+        "end": {
+          "line": 40,
+          "column": 15
+        }
+      }
+    },
+    {
+      "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": "ClassProperty",
+            "key": {
+              "type": "Identifier",
+              "name": "C_GLOBAL",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 7
+                },
+                "end": {
+                  "line": 20,
+                  "column": 15
+                }
+              }
+            },
+            "value": {
+              "type": "ETSNewClassInstanceExpression",
+              "typeReference": {
+                "type": "ETSTypeReference",
+                "part": {
+                  "type": "ETSTypeReferencePart",
+                  "name": {
+                    "type": "Identifier",
+                    "name": "C",
+                    "decorators": [],
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 38
+                      },
+                      "end": {
+                        "line": 20,
+                        "column": 39
+                      }
+                    }
+                  },
+                  "typeParams": {
+                    "type": "TSTypeParameterInstantiation",
+                    "params": [
+                      {
+                        "type": "TSArrayType",
+                        "elementType": {
+                          "type": "ETSTypeReference",
+                          "part": {
+                            "type": "ETSTypeReferencePart",
+                            "name": {
+                              "type": "Identifier",
+                              "name": "Object",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 20,
+                                  "column": 40
+                                },
+                                "end": {
+                                  "line": 20,
+                                  "column": 46
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 20,
+                                "column": 40
+                              },
+                              "end": {
+                                "line": 20,
+                                "column": 47
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 20,
+                              "column": 40
+                            },
+                            "end": {
+                              "line": 20,
+                              "column": 47
+                            }
+                          }
+                        },
+                        "loc": {
+                          "start": {
+                            "line": 20,
+                            "column": 48
+                          },
+                          "end": {
+                            "line": 20,
+                            "column": 49
+                          }
+                        }
+                      }
+                    ],
+                    "loc": {
+                      "start": {
+                        "line": 20,
+                        "column": 39
+                      },
+                      "end": {
+                        "line": 20,
+                        "column": 49
+                      }
+                    }
+                  },
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 38
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 50
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 38
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 50
+                  }
+                }
+              },
+              "arguments": [],
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 34
+                },
+                "end": {
+                  "line": 20,
+                  "column": 52
+                }
+              }
+            },
+            "accessibility": "public",
+            "static": true,
+            "readonly": false,
+            "declare": false,
+            "optional": false,
+            "computed": false,
+            "typeAnnotation": {
+              "type": "ETSTypeReference",
+              "part": {
+                "type": "ETSTypeReferencePart",
+                "name": {
+                  "type": "Identifier",
+                  "name": "C",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 17
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 18
+                    }
+                  }
+                },
+                "typeParams": {
+                  "type": "TSTypeParameterInstantiation",
+                  "params": [
+                    {
+                      "type": "TSArrayType",
+                      "elementType": {
+                        "type": "ETSWildcardType",
+                        "typeReference": {
+                          "type": "ETSTypeReference",
+                          "part": {
+                            "type": "ETSTypeReferencePart",
+                            "name": {
+                              "type": "Identifier",
+                              "name": "Object",
+                              "decorators": [],
+                              "loc": {
+                                "start": {
+                                  "line": 20,
+                                  "column": 22
+                                },
+                                "end": {
+                                  "line": 20,
+                                  "column": 28
+                                }
+                              }
+                            },
+                            "loc": {
+                              "start": {
+                                "line": 20,
+                                "column": 22
+                              },
+                              "end": {
+                                "line": 20,
+                                "column": 29
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 20,
+                              "column": 22
+                            },
+                            "end": {
+                              "line": 20,
+                              "column": 29
+                            }
+                          }
+                        },
+                        "in": true,
+                        "loc": {
+                          "start": {
+                            "line": 20,
+                            "column": 19
+                          },
+                          "end": {
+                            "line": 20,
+                            "column": 29
+                          }
+                        }
+                      },
+                      "loc": {
+                        "start": {
+                          "line": 20,
+                          "column": 30
+                        },
+                        "end": {
+                          "line": 20,
+                          "column": 31
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 20,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 20,
+                      "column": 31
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 20,
+                    "column": 17
+                  },
+                  "end": {
+                    "line": 20,
+                    "column": 33
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 20,
+                  "column": 17
+                },
+                "end": {
+                  "line": 20,
+                  "column": 33
+                }
+              }
+            },
+            "definite": false,
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 1,
+                "column": 1
+              },
+              "end": {
+                "line": 1,
+                "column": 1
+              }
+            }
+          },
+          {
+            "type": "MethodDefinition",
+            "key": {
+              "type": "Identifier",
+              "name": "test",
+              "decorators": [],
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 10
+                },
+                "end": {
+                  "line": 42,
+                  "column": 14
+                }
+              }
+            },
+            "kind": "method",
+            "accessibility": "public",
+            "static": true,
+            "optional": false,
+            "computed": false,
+            "value": {
+              "type": "FunctionExpression",
+              "function": {
+                "type": "ScriptFunction",
+                "id": {
+                  "type": "Identifier",
+                  "name": "test",
+                  "decorators": [],
+                  "loc": {
+                    "start": {
+                      "line": 42,
+                      "column": 10
+                    },
+                    "end": {
+                      "line": 42,
+                      "column": 14
+                    }
+                  }
+                },
+                "generator": false,
+                "async": false,
+                "expression": false,
+                "params": [],
+                "returnType": {
+                  "type": "ETSPrimitiveType",
+                  "loc": {
+                    "start": {
+                      "line": 42,
+                      "column": 18
+                    },
+                    "end": {
+                      "line": 42,
+                      "column": 22
+                    }
+                  }
+                },
+                "body": {
+                  "type": "BlockStatement",
+                  "statements": [
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "o",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "O2",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 43,
+                                      "column": 14
+                                    },
+                                    "end": {
+                                      "line": 43,
+                                      "column": 16
+                                    }
+                                  }
+                                },
+                                "typeParams": {
+                                  "type": "TSTypeParameterInstantiation",
+                                  "params": [
+                                    {
+                                      "type": "ETSWildcardType",
+                                      "typeReference": {
+                                        "type": "ETSTypeReference",
+                                        "part": {
+                                          "type": "ETSTypeReferencePart",
+                                          "name": {
+                                            "type": "Identifier",
+                                            "name": "Object",
+                                            "decorators": [],
+                                            "loc": {
+                                              "start": {
+                                                "line": 43,
+                                                "column": 20
+                                              },
+                                              "end": {
+                                                "line": 43,
+                                                "column": 26
+                                              }
+                                            }
+                                          },
+                                          "loc": {
+                                            "start": {
+                                              "line": 43,
+                                              "column": 20
+                                            },
+                                            "end": {
+                                              "line": 43,
+                                              "column": 27
+                                            }
+                                          }
+                                        },
+                                        "loc": {
+                                          "start": {
+                                            "line": 43,
+                                            "column": 20
+                                          },
+                                          "end": {
+                                            "line": 43,
+                                            "column": 27
+                                          }
+                                        }
+                                      },
+                                      "in": true,
+                                      "loc": {
+                                        "start": {
+                                          "line": 43,
+                                          "column": 17
+                                        },
+                                        "end": {
+                                          "line": 43,
+                                          "column": 27
+                                        }
+                                      }
+                                    }
+                                  ],
+                                  "loc": {
+                                    "start": {
+                                      "line": 43,
+                                      "column": 16
+                                    },
+                                    "end": {
+                                      "line": 43,
+                                      "column": 27
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 43,
+                                    "column": 14
+                                  },
+                                  "end": {
+                                    "line": 43,
+                                    "column": 29
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 43,
+                                  "column": 14
+                                },
+                                "end": {
+                                  "line": 43,
+                                  "column": 29
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 43,
+                                "column": 11
+                              },
+                              "end": {
+                                "line": 43,
+                                "column": 12
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "ETSNewClassInstanceExpression",
+                            "typeReference": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "O2",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 43,
+                                      "column": 34
+                                    },
+                                    "end": {
+                                      "line": 43,
+                                      "column": 36
+                                    }
+                                  }
+                                },
+                                "typeParams": {
+                                  "type": "TSTypeParameterInstantiation",
+                                  "params": [
+                                    {
+                                      "type": "ETSTypeReference",
+                                      "part": {
+                                        "type": "ETSTypeReferencePart",
+                                        "name": {
+                                          "type": "Identifier",
+                                          "name": "Object",
+                                          "decorators": [],
+                                          "loc": {
+                                            "start": {
+                                              "line": 43,
+                                              "column": 37
+                                            },
+                                            "end": {
+                                              "line": 43,
+                                              "column": 43
+                                            }
+                                          }
+                                        },
+                                        "loc": {
+                                          "start": {
+                                            "line": 43,
+                                            "column": 37
+                                          },
+                                          "end": {
+                                            "line": 43,
+                                            "column": 44
+                                          }
+                                        }
+                                      },
+                                      "loc": {
+                                        "start": {
+                                          "line": 43,
+                                          "column": 37
+                                        },
+                                        "end": {
+                                          "line": 43,
+                                          "column": 44
+                                        }
+                                      }
+                                    }
+                                  ],
+                                  "loc": {
+                                    "start": {
+                                      "line": 43,
+                                      "column": 36
+                                    },
+                                    "end": {
+                                      "line": 43,
+                                      "column": 44
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 43,
+                                    "column": 34
+                                  },
+                                  "end": {
+                                    "line": 43,
+                                    "column": 45
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 43,
+                                  "column": 34
+                                },
+                                "end": {
+                                  "line": 43,
+                                  "column": 45
+                                }
+                              }
+                            },
+                            "arguments": [],
+                            "loc": {
+                              "start": {
+                                "line": 43,
+                                "column": 30
+                              },
+                              "end": {
+                                "line": 43,
+                                "column": 47
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 43,
+                              "column": 11
+                            },
+                            "end": {
+                              "line": 43,
+                              "column": 47
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "const",
+                      "loc": {
+                        "start": {
+                          "line": 43,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 43,
+                          "column": 47
+                        }
+                      }
+                    },
+                    {
+                      "type": "VariableDeclaration",
+                      "declarations": [
+                        {
+                          "type": "VariableDeclarator",
+                          "id": {
+                            "type": "Identifier",
+                            "name": "o2",
+                            "typeAnnotation": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "O2",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 44,
+                                      "column": 15
+                                    },
+                                    "end": {
+                                      "line": 44,
+                                      "column": 17
+                                    }
+                                  }
+                                },
+                                "typeParams": {
+                                  "type": "TSTypeParameterInstantiation",
+                                  "params": [
+                                    {
+                                      "type": "TSArrayType",
+                                      "elementType": {
+                                        "type": "ETSWildcardType",
+                                        "typeReference": {
+                                          "type": "ETSTypeReference",
+                                          "part": {
+                                            "type": "ETSTypeReferencePart",
+                                            "name": {
+                                              "type": "Identifier",
+                                              "name": "Object",
+                                              "decorators": [],
+                                              "loc": {
+                                                "start": {
+                                                  "line": 44,
+                                                  "column": 21
+                                                },
+                                                "end": {
+                                                  "line": 44,
+                                                  "column": 27
+                                                }
+                                              }
+                                            },
+                                            "loc": {
+                                              "start": {
+                                                "line": 44,
+                                                "column": 21
+                                              },
+                                              "end": {
+                                                "line": 44,
+                                                "column": 28
+                                              }
+                                            }
+                                          },
+                                          "loc": {
+                                            "start": {
+                                              "line": 44,
+                                              "column": 21
+                                            },
+                                            "end": {
+                                              "line": 44,
+                                              "column": 28
+                                            }
+                                          }
+                                        },
+                                        "in": true,
+                                        "loc": {
+                                          "start": {
+                                            "line": 44,
+                                            "column": 18
+                                          },
+                                          "end": {
+                                            "line": 44,
+                                            "column": 28
+                                          }
+                                        }
+                                      },
+                                      "loc": {
+                                        "start": {
+                                          "line": 44,
+                                          "column": 29
+                                        },
+                                        "end": {
+                                          "line": 44,
+                                          "column": 30
+                                        }
+                                      }
+                                    }
+                                  ],
+                                  "loc": {
+                                    "start": {
+                                      "line": 44,
+                                      "column": 17
+                                    },
+                                    "end": {
+                                      "line": 44,
+                                      "column": 30
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 44,
+                                    "column": 15
+                                  },
+                                  "end": {
+                                    "line": 44,
+                                    "column": 32
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 44,
+                                  "column": 15
+                                },
+                                "end": {
+                                  "line": 44,
+                                  "column": 32
+                                }
+                              }
+                            },
+                            "decorators": [],
+                            "loc": {
+                              "start": {
+                                "line": 44,
+                                "column": 11
+                              },
+                              "end": {
+                                "line": 44,
+                                "column": 13
+                              }
+                            }
+                          },
+                          "init": {
+                            "type": "ETSNewClassInstanceExpression",
+                            "typeReference": {
+                              "type": "ETSTypeReference",
+                              "part": {
+                                "type": "ETSTypeReferencePart",
+                                "name": {
+                                  "type": "Identifier",
+                                  "name": "O2",
+                                  "decorators": [],
+                                  "loc": {
+                                    "start": {
+                                      "line": 44,
+                                      "column": 37
+                                    },
+                                    "end": {
+                                      "line": 44,
+                                      "column": 39
+                                    }
+                                  }
+                                },
+                                "typeParams": {
+                                  "type": "TSTypeParameterInstantiation",
+                                  "params": [
+                                    {
+                                      "type": "TSArrayType",
+                                      "elementType": {
+                                        "type": "ETSTypeReference",
+                                        "part": {
+                                          "type": "ETSTypeReferencePart",
+                                          "name": {
+                                            "type": "Identifier",
+                                            "name": "Object",
+                                            "decorators": [],
+                                            "loc": {
+                                              "start": {
+                                                "line": 44,
+                                                "column": 40
+                                              },
+                                              "end": {
+                                                "line": 44,
+                                                "column": 46
+                                              }
+                                            }
+                                          },
+                                          "loc": {
+                                            "start": {
+                                              "line": 44,
+                                              "column": 40
+                                            },
+                                            "end": {
+                                              "line": 44,
+                                              "column": 47
+                                            }
+                                          }
+                                        },
+                                        "loc": {
+                                          "start": {
+                                            "line": 44,
+                                            "column": 40
+                                          },
+                                          "end": {
+                                            "line": 44,
+                                            "column": 47
+                                          }
+                                        }
+                                      },
+                                      "loc": {
+                                        "start": {
+                                          "line": 44,
+                                          "column": 48
+                                        },
+                                        "end": {
+                                          "line": 44,
+                                          "column": 49
+                                        }
+                                      }
+                                    }
+                                  ],
+                                  "loc": {
+                                    "start": {
+                                      "line": 44,
+                                      "column": 39
+                                    },
+                                    "end": {
+                                      "line": 44,
+                                      "column": 49
+                                    }
+                                  }
+                                },
+                                "loc": {
+                                  "start": {
+                                    "line": 44,
+                                    "column": 37
+                                  },
+                                  "end": {
+                                    "line": 44,
+                                    "column": 50
+                                  }
+                                }
+                              },
+                              "loc": {
+                                "start": {
+                                  "line": 44,
+                                  "column": 37
+                                },
+                                "end": {
+                                  "line": 44,
+                                  "column": 50
+                                }
+                              }
+                            },
+                            "arguments": [],
+                            "loc": {
+                              "start": {
+                                "line": 44,
+                                "column": 33
+                              },
+                              "end": {
+                                "line": 44,
+                                "column": 52
+                              }
+                            }
+                          },
+                          "loc": {
+                            "start": {
+                              "line": 44,
+                              "column": 11
+                            },
+                            "end": {
+                              "line": 44,
+                              "column": 52
+                            }
+                          }
+                        }
+                      ],
+                      "kind": "const",
+                      "loc": {
+                        "start": {
+                          "line": 44,
+                          "column": 5
+                        },
+                        "end": {
+                          "line": 44,
+                          "column": 52
+                        }
+                      }
+                    }
+                  ],
+                  "loc": {
+                    "start": {
+                      "line": 42,
+                      "column": 23
+                    },
+                    "end": {
+                      "line": 45,
+                      "column": 2
+                    }
+                  }
+                },
+                "loc": {
+                  "start": {
+                    "line": 42,
+                    "column": 14
+                  },
+                  "end": {
+                    "line": 45,
+                    "column": 2
+                  }
+                }
+              },
+              "loc": {
+                "start": {
+                  "line": 42,
+                  "column": 14
+                },
+                "end": {
+                  "line": 45,
+                  "column": 2
+                }
+              }
+            },
+            "overloads": [],
+            "decorators": [],
+            "loc": {
+              "start": {
+                "line": 42,
+                "column": 1
+              },
+              "end": {
+                "line": 45,
+                "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": 46,
+      "column": 1
+    }
+  }
+}
diff --git a/test/parser/ets/type_variance1.ets b/test/parser/ets/type_variance1.ets
new file mode 100644
index 0000000000000000000000000000000000000000..208a215a034238943dc608e76378e1b04c9ed4e8
--- /dev/null
+++ b/test/parser/ets/type_variance1.ets
@@ -0,0 +1,45 @@
+/*
+ * 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.
+ */
+
+class C<in T> {
+    set(_: T): void {}
+}
+
+const C_GLOBAL: C<in Object[]> = new C<Object[]>();
+
+interface Declaration_Site_I<in In_T, out Out_T> {
+    set(_: In_T): void;
+    get(): Out_T;
+}
+
+interface Use_Site_I<In_T, Out_T> {
+    set(_: In_T): void;
+    get(): Out_T;
+}
+
+class O {}
+
+class Declaration_Site_C implements Declaration_Site_I<O, O> {}
+
+class Use_Site_C implements Use_Site_I<in O, out O> {}
+
+class Outbounded_Use_Site_C implements Use_Site_I<in O, out> {}
+
+class O2<T> {}
+
+function test(): void {
+    const o: O2<in Object> = new O2<Object>();
+    const o2: O2<in Object[]> = new O2<Object[]>();
+}
diff --git a/test/parser/ets/type_variance2-expected.txt b/test/parser/ets/type_variance2-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..13712ea828f11896ca6ebbc12347ec311cfc76e0
--- /dev/null
+++ b/test/parser/ets/type_variance2-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Variance modifier is not allowed here. [type_variance2.ets:17:15]
diff --git a/test/parser/ets/type_variance2.ets b/test/parser/ets/type_variance2.ets
new file mode 100644
index 0000000000000000000000000000000000000000..b7066130f420bb4af53dbc6202422c8a477cd3c2
--- /dev/null
+++ b/test/parser/ets/type_variance2.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.
+ */
+
+class C {
+  constructor<in T2>() {}
+}
diff --git a/test/parser/ets/type_variance3-expected.txt b/test/parser/ets/type_variance3-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..307d2d822f9c055d46f4cd59a781bc5da5e83df9
--- /dev/null
+++ b/test/parser/ets/type_variance3-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Variance modifier is not allowed here. [type_variance3.ets:17:7]
diff --git a/test/parser/ets/type_variance3.ets b/test/parser/ets/type_variance3.ets
new file mode 100644
index 0000000000000000000000000000000000000000..ffb011318b77b1ee98144275e50844cf9bb65b4a
--- /dev/null
+++ b/test/parser/ets/type_variance3.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.
+ */
+
+class C {
+  set<in T2>(t: T2): void { }
+}
diff --git a/test/parser/ets/type_variance4-expected.txt b/test/parser/ets/type_variance4-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b99676727c3edfad5cb39c157167c7593cf4ee2
--- /dev/null
+++ b/test/parser/ets/type_variance4-expected.txt
@@ -0,0 +1 @@
+SyntaxError: Unexpected token, expected: '('. [type_variance4.ets:18:12]
diff --git a/test/parser/ets/type_variance4.ets b/test/parser/ets/type_variance4.ets
new file mode 100644
index 0000000000000000000000000000000000000000..0155a55beb8ad442798c24c048bb80dc90c651c4
--- /dev/null
+++ b/test/parser/ets/type_variance4.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.
+ */
+
+// TODO: Should be a "SyntaxError: Variance modifier is not allowed here [type_variance4.ets:18:13]",
+// after generic global function parsing is implemented.
+function fn<in T>(t: T): void {}
diff --git a/test/runtime/ets/LongLiteralLimits.ets b/test/runtime/ets/LongLiteralLimits.ets
index 51123303e0dbe790b2564acb45e10f711487a029..d25e467252616d89ea22fe7173664c00629924a3 100644
--- a/test/runtime/ets/LongLiteralLimits.ets
+++ b/test/runtime/ets/LongLiteralLimits.ets
@@ -1,3 +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.
+ */
+
 function main(): void {
     const decLongMax = 9223372036854775807;
     const binLongMax = 0b0111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111;
diff --git a/test/runtime/ets/RegisterSpiller.ets b/test/runtime/ets/RegisterSpiller.ets
new file mode 100644
index 0000000000000000000000000000000000000000..3260b0245188897d4a282968ad543b03b4034f52
--- /dev/null
+++ b/test/runtime/ets/RegisterSpiller.ets
@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+
+function main(): void {
+    let str: String = "hello\nworld\n";
+    assert str.charAt(2) == 'l';
+    assert str.length() == 12;
+    assert str.charAt(str.length() - 1) == '\n';
+
+    let a: String = "abc";
+    let b: String = "ace";
+    let c: String = "abc";
+    assert !a.equals(b);
+    assert a.equals(c);
+    assert !b.equals(c);
+
+    let n2: int = 41;
+    let n3: long = 42;
+    let n4: float = 43.43;
+    let n5: double = 44.44;
+    let n6: double = random();
+    let n7: double = random() + 42;
+    assert n6 >= 0.0 && n6 <= 1.0;
+    assert n7 >= 42.0 && n7 <= 43.0;
+
+    let s1: String = "This ";
+    let s2: String = "is ";
+    let s3: String = "another ";
+    let s4: String = "string";
+    let s5: String = "This is another string";
+    assert (s1 + s2 + s3 + s4).equals(s5);
+}
diff --git a/test/runtime/ets/array-expression.ets b/test/runtime/ets/array-expression.ets
index 49bfd32c8d383797153d41a9c27a61ebb9f9052c..98a7acd632405ce86e657a11183db6a3a0be9ef5 100644
--- a/test/runtime/ets/array-expression.ets
+++ b/test/runtime/ets/array-expression.ets
@@ -2,9 +2,64 @@ function add(arg : double[]): double {
   return arg[0] + arg[1] + arg[2];
 }
 
+// TODO(user): unify copyBooleanArr and copyCharArr once generics are supported
+function copyBooleanArr(src: boolean[]): boolean[] {
+    let dst: boolean[] = new boolean[src.length];
+    for (let i = 0; i < src.length; i++) {
+        dst[i] = src[i];
+    }
+    return dst;
+}
+
+// TODO(user): unify copyBooleanArr and copyCharArr once generics are supported
+function copyCharArr(src: char[]): char[] {
+    let dst: char[] = new char[src.length];
+    for (let i = 0; i < src.length; i++) {
+        dst[i] = src[i];
+    }
+    return dst;
+}
+
+// TODO(user): unify cmpBooleanArr and cmpCharArr once generics are supported
+function cmpBooleanArr(arg0: boolean[], arg1: boolean[]): boolean {
+    if (arg0.length != arg1.length) {
+        return false;
+    }
+
+    for (let i = 0; i < arg0.length; i++) {
+        if (arg0[i] != arg1[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// TODO(user): unify cmpBooleanArr and cmpCharArr once generics are supported
+function cmpCharArr(arg0: char[], arg1: char[]): boolean {
+    if (arg0.length != arg1.length) {
+        return false;
+    }
+
+    for (let i = 0; i < arg0.length; i++) {
+        if (arg0[i] != arg1[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 function main(): void {
   let arr : double[] = [1.1, 2.1, 3.5, 4.9];
-  assert arr[0] == 1.1 && arr[1] == 2.1 && arr[2] == 3.5 && arr[3] == 4.9
-  assert add([1.1, 2.2, 3.3]) == 6.6
+  assert arr[0] == 1.1 && arr[1] == 2.1 && arr[2] == 3.5 && arr[3] == 4.9;
+  assert add([1.1, 2.2, 3.3]) == 6.6;
+
+  let arr2 : boolean[] = [false, true, false, true, true, false, false, true];
+  assert cmpBooleanArr(copyBooleanArr(arr2), arr2);
+
+  let arr3 : char[] = ['a', 'b', 'c', 'd'];
+  assert cmpCharArr(copyCharArr(arr3), arr3);
+
   return;
 }
diff --git a/test/runtime/ets/for-statement.ets b/test/runtime/ets/for-statement.ets
new file mode 100644
index 0000000000000000000000000000000000000000..2ab9767fa911f9593ed452c9180f755cfa65583f
--- /dev/null
+++ b/test/runtime/ets/for-statement.ets
@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+function main(): void {
+  let a : int = 0;
+  let b : int = 0;
+
+  for (let aa : int = 1, bb : int = 1; aa<5 && bb<5; aa++, bb++) {
+    a += aa;
+    b += bb;
+  }
+  assert (a == 10 && b == 10)
+
+  let aa : int = 10;
+  let bb : int = 10;
+  for (aa = 1, bb = 1; aa<5 && bb<5; aa++, bb++) {
+    a += aa;
+    b += bb;
+  }
+  assert (a == 20 && b == 20)
+}