arkanalyzer 1.0.88 → 1.0.90

package/lib/frontend/cppFrontend/common/ArkValueTransformer.js

@@ -64,25 +64,29 @@ const ModelUtils_1 = require("../../../core/common/ModelUtils");
 const TSConst_1 = require("../../../core/common/TSConst");
 const TypeInference_1 = require("./TypeInference");
 const ModelUtils_2 = require("./ModelUtils");
-const ast_1 = require("../ast");
+const ArkCxxAstNode_1 = require("../utils/ArkCxxAstNode");
+const cppUtils_1 = require("../utils/cppUtils");
 const ArkIRTransformer_2 = require("../../../core/common/ArkIRTransformer");
 const Builtin_2 = require("./Builtin");
 const ArkClass_1 = require("../../../core/model/ArkClass");
 const ValueUtil_2 = require("../../../core/common/ValueUtil");
 const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkValueTransformer');
-var CompoundBinaryOperator;
-(function (CompoundBinaryOperator) {
-    CompoundBinaryOperator["AdditionEquals"] = "+=";
-    CompoundBinaryOperator["SubtractionEquals"] = "-=";
-    CompoundBinaryOperator["MultiplicationEquals"] = "*=";
-    CompoundBinaryOperator["DivisionEquals"] = "/=";
-    CompoundBinaryOperator["RemainderEquals"] = "%=";
-    CompoundBinaryOperator["LeftShiftEquals"] = "<<=";
-    CompoundBinaryOperator["RightShiftEquals"] = ">>=";
-    CompoundBinaryOperator["BitwiseAndEquals"] = "&=";
-    CompoundBinaryOperator["BitwiseOrEquals"] = "|=";
-    CompoundBinaryOperator["BitwiseXorEquals"] = "^=";
-})(CompoundBinaryOperator || (CompoundBinaryOperator = {}));
+const COMPOUND_BIN_OPS = new Set([
+    ArkCxxAstNode_1.CxxOpcode.PlusAssign,
+    ArkCxxAstNode_1.CxxOpcode.MinusAssign,
+    ArkCxxAstNode_1.CxxOpcode.MulAssign,
+    ArkCxxAstNode_1.CxxOpcode.DivAssign,
+    ArkCxxAstNode_1.CxxOpcode.ModAssign,
+    ArkCxxAstNode_1.CxxOpcode.ShlAssign,
+    ArkCxxAstNode_1.CxxOpcode.ShrAssign,
+    ArkCxxAstNode_1.CxxOpcode.BitAndAssign,
+    ArkCxxAstNode_1.CxxOpcode.BitOrAssign,
+    ArkCxxAstNode_1.CxxOpcode.BitXorAssign,
+]);
+function getDesignatedInitFieldName(node) {
+    var _a, _b, _c, _d, _e;
+    return (_e = (_c = (_a = node.name) !== null && _a !== void 0 ? _a : (_b = node.anyInit) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : (_d = node.referencedDecl) === null || _d === void 0 ? void 0 : _d.name) !== null && _e !== void 0 ? _e : '';
+}
 /**
  * Get the inner node of an AST node
  *
@@ -94,82 +98,81 @@ function nodeInnerNode(node) {
     if (Array.isArray(node === null || node === void 0 ? void 0 : node.inner) && node.inner.length > 0) {
         const last = node.inner[node.inner.length - 1];
         // Return InitListExpr first
-        if ((last === null || last === void 0 ? void 0 : last.kind) === ast_1.astKind.InitListExpr) {
+        if ((last === null || last === void 0 ? void 0 : last.kind) === ArkCxxAstNode_1.AstKind.InitListExpr) {
             return last;
         }
         // Arrays containing only one TypeRef node do not return
-        if (!(node.inner.length === 1 && ((_a = node.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ast_1.astKind.TypeRef) && !(0, builderUtils_1.isCxxFunctionPointer)(node.type.qualType)) {
+        if (!(node.inner.length === 1 && ((_a = node.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ArkCxxAstNode_1.AstKind.TypeRef) && !(0, builderUtils_1.isCxxFunctionPointer)(node.type.qualType)) {
             return last;
         }
     }
     logger.info(`unsupported node! kind: ${(_b = node === null || node === void 0 ? void 0 : node.kind) !== null && _b !== void 0 ? _b : ''}, node:`, node);
-    return { kind: 'unsupported kind' };
+    return { kind: ArkCxxAstNode_1.AstKind.UnsupportedKind };
 }
-const COMPOUND_BIN_OPS = new Set(Object.values(CompoundBinaryOperator));
 class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
     constructor(arkIRTransformer, sourceFile, declaringMethod) {
         super(arkIRTransformer, sourceFile, declaringMethod);
         // An object that records the corresponding processing functions of CXX ast nodes.
         this.nodeTransformerFuncMap = {
-            [ast_1.astKind.ArraySubscriptExpr]: this.cxxElementAccessExpressionToValueAndStmts,
-            [ast_1.astKind.ArrayTypeTraitExpr]: this.arrayTypeTraitExprToValueAndStmts,
-            [ast_1.astKind.AtomicCallExpr]: this.cxxCallExpressionToValueAndStmts,
-            [ast_1.astKind.BinaryConditionalOperator]: this.cxxConditionalExpressionToValueAndStmts,
-            [ast_1.astKind.CXXRewrittenBinaryOperator]: this.cxxBinaryExpressionToValueAndStmts,
-            [ast_1.astKind.BinaryOperator]: this.cxxBinaryExpressionToValueAndStmts,
-            [ast_1.astKind.BindingDecl]: this.bindingNodeToValueAndStmts,
-            [ast_1.astKind.CallExpr]: this.cxxCallExpressionToValueAndStmts,
-            [ast_1.astKind.CharacterLiteral]: this.cxxLiteralNodeToValueAndStmts,
-            [ast_1.astKind.CompoundAssignOperator]: this.cxxCompoundAssignmentToValueAndStmts,
-            [ast_1.astKind.CompoundLiteralExpr]: this.cxxAggregateToValueAndStmts,
-            [ast_1.astKind.ConditionalOperator]: this.cxxConditionalExpressionToValueAndStmts,
-            [ast_1.astKind.ConstantExpr]: this.processInnerNodeToValueAndStmts,
-            [ast_1.astKind.CXXBindTemporaryExpr]: this.processInnerNodeToValueAndStmts,
-            [ast_1.astKind.CXXBoolLiteralExpr]: this.cxxLiteralNodeToValueAndStmts,
-            [ast_1.astKind.CXXConstCastExpr]: this.castExpressionToValueAndStmts,
-            [ast_1.astKind.CXXConstructExpr]: this.cxxConstructExprToValueAndStmts,
-            [ast_1.astKind.CXXCtorInitializer]: this.cxxCtorInitializerToValueAndStmts,
-            [ast_1.astKind.CXXDeleteExpr]: this.cxxDeleteExpressionToValueAndStmts,
-            [ast_1.astKind.CXXDynamicCastExpr]: this.castExpressionToValueAndStmts,
-            [ast_1.astKind.CXXFoldExpr]: this.cxxFoldExprToValueAndStmts,
-            [ast_1.astKind.CXXFunctionalCastExpr]: this.castExpressionToValueAndStmts,
-            [ast_1.astKind.CXXMemberCallExpr]: this.cxxMemberCallExpressionToValueAndStmts,
-            [ast_1.astKind.CXXNewExpr]: this.cxxNewExpressionToValueAndStmts,
-            [ast_1.astKind.CXXNoexceptExpr]: this.cxxNoexceptExprToValueAndStmts,
-            [ast_1.astKind.CXXNullPtrLiteralExpr]: this.cxxLiteralNodeToValueAndStmts,
-            [ast_1.astKind.CXXOperatorCallExpr]: this.cxxOperatorExpressionToValueAndStmts,
-            [ast_1.astKind.CXXReinterpretCastExpr]: this.castExpressionToValueAndStmts,
-            [ast_1.astKind.CXXScalarValueInitExpr]: this.cxxScalarValueInitToValueAndStmts,
-            [ast_1.astKind.CXXStdInitializerListExpr]: this.processInnerNodeToValueAndStmts,
-            [ast_1.astKind.CXXStaticCastExpr]: this.castExpressionToValueAndStmts,
-            [ast_1.astKind.CXXThisExpr]: this.cxxThisExpressionToValueAndStmts,
-            [ast_1.astKind.CXXTypeidExpr]: this.cxxTypeidExprToValueAndStmts,
-            [ast_1.astKind.CStyleCastExpr]: this.castExpressionToValueAndStmts,
-            [ast_1.astKind.CXXTemporaryObjectExpr]: this.cxxTemporaryObjectExprToValueAndStmts,
-            [ast_1.astKind.DeclRefExpr]: this.declAndTypeRefToValueAndStmts,
-            [ast_1.astKind.DeclStmt]: this.declStmtToValueAndStmts,
-            [ast_1.astKind.DecompositionDecl]: this.bindingNodeToValueAndStmts,
-            [ast_1.astKind.ExprWithCleanups]: this.processInnerNodeToValueAndStmts,
-            [ast_1.astKind.FloatingLiteral]: this.cxxLiteralNodeToValueAndStmts,
-            [ast_1.astKind.ImplicitCastExpr]: this.implicitCastExprToValueAndStmts,
-            [ast_1.astKind.InitListExpr]: this.initListExprToValueAndStmts,
-            [ast_1.astKind.IntegerLiteral]: this.cxxLiteralNodeToValueAndStmts,
-            [ast_1.astKind.LambdaExpr]: this.cxxCallableNodeToValueAndStmts,
-            [ast_1.astKind.MaterializeTemporaryExpr]: this.materializeTemporaryExprToValueAndStmts,
-            [ast_1.astKind.MemberExpr]: this.memberExpressionToValueAndStmts,
-            [ast_1.astKind.MemberRef]: this.memberExpressionToValueAndStmts,
-            [ast_1.astKind.NamespaceRef]: this.cxxNamespaceRefToValueAndStmts,
-            [ast_1.astKind.ParenExpr]: this.processInnerNodeToValueAndStmts,
-            [ast_1.astKind.ParenListExpr]: this.processInnerNodeToValueAndStmts,
-            [ast_1.astKind.RecoveryExpr]: this.RecoverExpressionToValueAndStmts,
-            [ast_1.astKind.StringLiteral]: this.cxxLiteralNodeToValueAndStmts,
-            [ast_1.astKind.TypeRef]: this.declAndTypeRefToValueAndStmts,
-            [ast_1.astKind.UnaryExprOrTypeTraitExpr]: this.unaryExprToValueAndStmts,
-            [ast_1.astKind.UnaryOperator]: this.unaryOperatorToValueAndStmts,
-            [ast_1.astKind.UnexposedExpr]: this.processInnerNodeToValueAndStmts,
-            [ast_1.astKind.UnresolvedLookupExpr]: this.declAndTypeRefToValueAndStmts,
-            [ast_1.astKind.UserDefinedLiteral]: this.userDefinedLiteralToValueAndStmts,
-            [ast_1.astKind.VarDecl]: this.cxxVariableDeclarationToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.ArraySubscriptExpr]: this.cxxElementAccessExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.ArrayTypeTraitExpr]: this.arrayTypeTraitExprToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.AtomicCallExpr]: this.cxxCallExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.BinaryConditionalOperator]: this.cxxConditionalExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXRewrittenBinaryOperator]: this.cxxBinaryExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.BinaryOperator]: this.cxxBinaryExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.BindingDecl]: this.bindingNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CallExpr]: this.cxxCallExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CharacterLiteral]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CompoundAssignOperator]: this.cxxCompoundAssignmentToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CompoundLiteralExpr]: this.cxxAggregateToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.ConditionalOperator]: this.cxxConditionalExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.ConstantExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXBindTemporaryExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXBoolLiteralExpr]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXConstCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXConstructExpr]: this.cxxConstructExprToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXCtorInitializer]: this.cxxCtorInitializerToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXDeleteExpr]: this.cxxDeleteExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXDynamicCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXFoldExpr]: this.cxxFoldExprToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXFunctionalCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXMemberCallExpr]: this.cxxMemberCallExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXNewExpr]: this.cxxNewExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXNoexceptExpr]: this.cxxNoexceptExprToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXNullPtrLiteralExpr]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXOperatorCallExpr]: this.cxxOperatorExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXReinterpretCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXScalarValueInitExpr]: this.cxxScalarValueInitToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXStdInitializerListExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXStaticCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXThisExpr]: this.cxxThisExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXTypeidExpr]: this.cxxTypeidExprToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CStyleCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.CXXTemporaryObjectExpr]: this.cxxTemporaryObjectExprToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.DeclRefExpr]: this.declAndTypeRefToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.DeclStmt]: this.declStmtToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.DecompositionDecl]: this.bindingNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.ExprWithCleanups]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.FloatingLiteral]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.ImplicitCastExpr]: this.implicitCastExprToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.InitListExpr]: this.initListExprToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.IntegerLiteral]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.LambdaExpr]: this.cxxCallableNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.MaterializeTemporaryExpr]: this.materializeTemporaryExprToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.MemberExpr]: this.memberExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.MemberRef]: this.memberExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.NamespaceRef]: this.cxxNamespaceRefToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.ParenExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.ParenListExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.RecoveryExpr]: this.RecoverExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.StringLiteral]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.TypeRef]: this.declAndTypeRefToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.UnaryExprOrTypeTraitExpr]: this.unaryExprToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.UnaryOperator]: this.unaryOperatorToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.UnexposedExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.UnresolvedLookupExpr]: this.declAndTypeRefToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.UserDefinedLiteral]: this.userDefinedLiteralToValueAndStmts,
+            [ArkCxxAstNode_1.AstKind.VarDecl]: this.cxxVariableDeclarationToValueAndStmts,
         };
         this.ArkCxxIRTransformer = arkIRTransformer;
         this.cxxSourceFile = sourceFile;
@@ -207,37 +210,27 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         const stmts = [];
         const type = (0, builderUtils_1.cxxNode2Type)(aggregate, this.declaringMethod);
         const typeName = (_b = (_a = aggregate.type) === null || _a === void 0 ? void 0 : _a.qualType) !== null && _b !== void 0 ? _b : 'unknown';
-        let classSignature;
-        if (!(type instanceof Type_1.ClassType)) {
-            classSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(typeName);
-        }
-        else {
-            classSignature = type.getClassSignature();
-        }
-        const list = aggregate.kind === ast_1.astKind.InitListExpr ? aggregate : aggregate.inner[aggregate.inner.length - 1];
-        let elements = [];
-        if (list.kind !== ast_1.astKind.InitListExpr) {
+        const classSignature = type instanceof Type_1.ClassType ?
+            type.getClassSignature() :
+            ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(typeName);
+        const list = aggregate.kind === ArkCxxAstNode_1.AstKind.InitListExpr ? aggregate : aggregate.inner[aggregate.inner.length - 1];
+        const elements = [];
+        if (list.kind !== ArkCxxAstNode_1.AstKind.InitListExpr) {
             return this.unprocessedNodeToValueAndStmts(aggregate);
         }
         const aggregateExpr = new Expr_2.ArkAggregateExpr(elements, type);
         const fullPosition = [Position_1.FullPosition.cxxBuildFromNode(aggregate, this.cxxSourceFile)];
-        let { value: temp, valueOriginalPositions: tempPositions, stmts: exprStmts, } = this.ArkCxxIRTransformer.generateAssignStmtForValue(aggregateExpr, fullPosition);
+        const { value: temp, valueOriginalPositions: tempPositions, stmts: exprStmts, } = this.ArkCxxIRTransformer.generateAssignStmtForValue(aggregateExpr, fullPosition);
         for (let i = 0; i < list.inner.length; i++) {
-            if (list.inner[i].kind === ast_1.astKind.DesignatedInitExpr) {
-                // Because the syntax tree does not have fields representing field information,
-                // regular matching is used to preserve the information.
-                // If there are any changes to the syntax tree, optimization can be made here
-                const dotIndex = list.inner[i].code.indexOf('.');
-                const equalsIndex = list.inner[i].code.indexOf('=');
-                const field = list.inner[i].code.substring(dotIndex + 1, equalsIndex).trim();
-                const type = (0, builderUtils_1.cxxNode2Type)(list.inner[i].inner[0], this.declaringMethod);
-                const fieldSignature = new ArkSignature_1.FieldSignature(field, classSignature, type, false);
+            if (list.inner[i].kind === ArkCxxAstNode_1.AstKind.DesignatedInitExpr) {
+                const listItem = list.inner[i];
+                const field = getDesignatedInitFieldName(listItem);
+                const fieldType = (0, builderUtils_1.cxxNode2Type)(listItem.inner[0], this.declaringMethod);
+                const fieldSignature = new ArkSignature_1.FieldSignature(field, classSignature, fieldType, false);
                 const init = new Ref_2.ArkCxxInstanceFieldRef(temp, false, fieldSignature);
-                const valueAndStmts = this.cxxNodeToValueAndStmts(list.inner[i].inner[0]);
-                const designator = valueAndStmts.value;
+                const valueAndStmts = this.cxxNodeToValueAndStmts(listItem.inner[0]);
                 stmts.push(...valueAndStmts.stmts);
-                const designatedInitExpr = new Expr_2.ArkDesignatedInitExpr(init, designator);
-                elements.push(designatedInitExpr);
+                elements.push(new Expr_2.ArkDesignatedInitExpr(init, valueAndStmts.value));
             }
             else {
                 const valueAndStmts = this.cxxNodeToValueAndStmts(list.inner[i]);
@@ -265,25 +258,25 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
     // Judge whether the current node is related to the lambda function of CPP
     isNodeRelatedToCXXLambdaFunc(node) {
         var _a, _b, _c, _d;
-        return ((_b = (_a = node.type) === null || _a === void 0 ? void 0 : _a.qualType) === null || _b === void 0 ? void 0 : _b.startsWith('(lambda at')) || ((_d = (_c = node.inner) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.kind) === ast_1.astKind.LambdaExpr;
+        return ((_b = (_a = node.type) === null || _a === void 0 ? void 0 : _a.qualType) === null || _b === void 0 ? void 0 : _b.startsWith('(lambda at')) || ((_d = (_c = node.inner) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.kind) === ArkCxxAstNode_1.AstKind.LambdaExpr;
     }
     isNodeRelatedToImplicitNode(node) {
         var _a, _b;
         if (node.inner) {
-            return (((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ast_1.astKind.ImplicitCastExpr && (node.name === '__tree_const_iterator'));
+            return (((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.AstKind.ImplicitCastExpr && (node.name === '__tree_const_iterator'));
         }
         return false;
     }
     // Judge whether the child nodes of the current node are materializing temporary variables
     isNodeRelatedToMaterializeTemporaryExpr(node) {
         var _a, _b;
-        return ((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ast_1.astKind.MaterializeTemporaryExpr;
+        return ((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.AstKind.MaterializeTemporaryExpr;
     }
     // Check if the child nodes of the current node are member function calls
     isNodeRelatedToCXXMember(node) {
         var _a, _b;
-        return ((((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ast_1.astKind.CXXMemberCallExpr) ||
-            (node.inner[0].kind === ast_1.astKind.ImplicitCastExpr && node.inner[0].inner[0] && node.inner[0].inner[0].kind === ast_1.astKind.CXXMemberCallExpr));
+        return ((((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.AstKind.CXXMemberCallExpr) ||
+            (node.inner[0].kind === ArkCxxAstNode_1.AstKind.ImplicitCastExpr && node.inner[0].inner[0] && node.inner[0].inner[0].kind === ArkCxxAstNode_1.AstKind.CXXMemberCallExpr));
     }
     // Construction of std::pair type
     isPairConstructExpr(node) {
@@ -292,62 +285,66 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
     // Multi-layer std::pair construction
     isNodeRelatedToTemporary(node) {
         var _a, _b;
-        return ((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ast_1.astKind.CXXBindTemporaryExpr && node.code === node.inner[0].code;
+        return ((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.AstKind.CXXBindTemporaryExpr;
     }
     // Expressions that are not new statements (excluding constructors as parameters)
     isNotNewExpression(newExpression) {
+        var _a, _b;
         const firstChildKind = newExpression.inner.length > 0 ? newExpression.inner[0].kind : undefined;
         if (!firstChildKind) {
             return false;
         }
         const targetKinds = [
-            ast_1.astKind.IntegerLiteral,
-            ast_1.astKind.InitListExpr,
-            ast_1.astKind.CompoundLiteralExpr,
-            ast_1.astKind.CXXOperatorCallExpr,
-            ast_1.astKind.BinaryOperator
+            ArkCxxAstNode_1.AstKind.IntegerLiteral,
+            ArkCxxAstNode_1.AstKind.InitListExpr,
+            ArkCxxAstNode_1.AstKind.CompoundLiteralExpr,
+            ArkCxxAstNode_1.AstKind.CXXOperatorCallExpr,
+            ArkCxxAstNode_1.AstKind.BinaryOperator
         ];
         return (targetKinds.includes(firstChildKind) ||
-            (firstChildKind === ast_1.astKind.ImplicitCastExpr && !newExpression.inner[0].code.includes('(')));
+            (firstChildKind === ArkCxxAstNode_1.AstKind.ImplicitCastExpr &&
+                ((_b = (_a = newExpression.inner[0].inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) !== ArkCxxAstNode_1.AstKind.CXXFunctionalCastExpr &&
+                newExpression.inner[0].castKind !== ArkCxxAstNode_1.AstKind.CXXFunctionalCastExpr));
     }
     isNodeRelatedToCXXFuncCast(node) {
         var _a;
-        return ((_a = node.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === 'CXXFunctionalCastExpr';
+        return ((_a = node.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ArkCxxAstNode_1.AstKind.CXXFunctionalCastExpr;
     }
     undefinedToValueAndStmts() {
         var _a, _b;
         logger.warn('ArkValueTransformer-Cpp NodeToValueAndStmts: node is undefined. Method signature is : ', (_b = (_a = this.declaringMethod) === null || _a === void 0 ? void 0 : _a.getSignature()) === null || _b === void 0 ? void 0 : _b.toString());
         return {
             value: new Local_1.Local('undefined'),
-            valueOriginalPositions: [new Position_1.FullPosition(0, 0, 0, 0)],
+            valueOriginalPositions: [Position_1.FullPosition.DEFAULT],
             stmts: [],
         };
     }
     unprocessedNodeToValueAndStmts(node) {
         logger.warn(`ArkValueTransformer-cxxNodeToValueAndStmts: node '${node.kind}' is not specially processed.`);
         return {
-            value: new Local_1.Local(node.code),
+            value: new Local_1.Local('undefined'),
             valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(node, this.cxxSourceFile)],
             stmts: [],
         };
     }
     cxxNamespaceRefToValueAndStmts(node) {
+        var _a;
         return {
-            value: new Local_1.Local(node.code),
+            value: new Local_1.Local((_a = node.name) !== null && _a !== void 0 ? _a : ''),
             valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(node, this.cxxSourceFile)],
             stmts: [],
         };
     }
     cxxTemporaryObjectExprToValueAndStmts(node) {
-        var _a, _b;
+        var _a;
         // if case: return Vector(x + other.x, y + other.y); ==> In the C++17 standard, a temporary object is no longer created in the return statement,
         // instead, the object is directly constructed at the return value location. Therefore, it is processed here as a ConstructExpr.
         const parentNode = (_a = node.getParent) === null || _a === void 0 ? void 0 : _a.call(node, false);
         // case: Vector{1,2,3} Implicit call to destructor
-        if (((_b = parentNode === null || parentNode === void 0 ? void 0 : parentNode.dtor) === null || _b === void 0 ? void 0 : _b.kind) === ast_1.astKind.CXXDestructorDecl && node.inner.length > 0) {
+        if ((parentNode === null || parentNode === void 0 ? void 0 : parentNode.dtor) === ArkCxxAstNode_1.AstKind.CXXDestructorDecl && node.inner.length > 0) {
             return this.cxxConstructExprToValueAndStmts(node.inner[0]);
         }
-        if (!parentNode || parentNode.kind !== ast_1.astKind.ExprWithCleanups && parentNode.kind !== ast_1.astKind.ReturnStmt) {
+        if (!parentNode || parentNode.kind !== ArkCxxAstNode_1.AstKind.ExprWithCleanups && parentNode.kind !== ArkCxxAstNode_1.AstKind.ReturnStmt) {
             return this.unprocessedNodeToValueAndStmts(node);
         }
         return this.cxxConstructExprToValueAndStmts(node);
@@ -397,7 +394,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         stmts.push(...innerStmts);
         let index = 0;
         for (let i = 0; i < length; i++) {
-            if (node.inner[i].kind !== ast_1.astKind.BindingDecl) {
+            if (node.inner[i].kind !== ArkCxxAstNode_1.AstKind.BindingDecl) {
                 continue;
             }
             const leftValueAndStmts = this.cxxIdentifierToValueAndStmts(node.inner[i]);
@@ -427,12 +424,12 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      *@ returns ValueAndStmts object, including converted values and related statements
      */
     implicitCastExprToValueAndStmts(node) {
-        var _a;
+        var _a, _b;
         if (((_a = node.inner) === null || _a === void 0 ? void 0 : _a.length) === 1) {
             return this.cxxNodeToValueAndStmts(node.inner[0]);
         }
-        node.kind = 'DeclRefExpr';
-        node.name = node.code;
+        node.kind = ArkCxxAstNode_1.AstKind.DeclRefExpr;
+        node.name = node.name || ((_b = node.referencedDecl) === null || _b === void 0 ? void 0 : _b.name) || '';
         return this.cxxNodeToValueAndStmts(node);
     }
     /**
@@ -446,19 +443,18 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             return this.cxxNodeToValueAndStmts(node.inner[0]);
         }
         // Handle the scenario: using Color::RED; Color c = RED;
-        if (((_b = node.referencedDecl) === null || _b === void 0 ? void 0 : _b.kind) === ast_1.astKind.EnumConstantDecl && node.inner.length === 0) {
+        if (((_b = node.referencedDecl) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.AstKind.EnumConstantDecl && node.inner.length === 0) {
             const typeRefNode = {
-                kind: 'TypeRef',
+                kind: ArkCxxAstNode_1.AstKind.TypeRef,
                 name: node.referencedDecl.name,
-                code: node.referencedDecl.name,
                 inner: [],
                 type: node.referencedDecl.type,
             };
             node.inner.push(typeRefNode);
             return this.staticMemberExprToValueAndStmts(node);
         }
-        // when node.referencedDecl?.kind === astKind.NonTypeTemplateParmDecl ,this value is a const expr
-        if (((_c = node.referencedDecl) === null || _c === void 0 ? void 0 : _c.kind) === ast_1.astKind.NonTypeTemplateParmDecl) {
+        // when node.referencedDecl?.kind === AstKind.NonTypeTemplateParmDecl ,this value is a const expr
+        if (((_c = node.referencedDecl) === null || _c === void 0 ? void 0 : _c.kind) === ArkCxxAstNode_1.AstKind.NonTypeTemplateParmDecl) {
             return {
                 value: ValueUtil_1.CxxValueUtil.createCompileConst(node.name, (0, builderUtils_1.cxxNode2Type)(node, this.declaringMethod)),
                 valueOriginalPositions: [],
@@ -466,14 +462,14 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             };
         }
         // Handle the invocation of static members of a class, such as A::a
-        if (((_d = node.code) === null || _d === void 0 ? void 0 : _d.includes('::')) && node.inner.length > 0 &&
-            (((_e = node.inner[0]) === null || _e === void 0 ? void 0 : _e.kind) === ast_1.astKind.TypeRef || ((_f = node.inner[0]) === null || _f === void 0 ? void 0 : _f.kind) === ast_1.astKind.NamespaceRef && ((_g = node.inner[0]) === null || _g === void 0 ? void 0 : _g.name) !== Builtin_2.BuiltinCxx.CXXSTD)) {
+        if (((_d = node.name) === null || _d === void 0 ? void 0 : _d.includes('::')) && node.inner.length > 0 &&
+            (((_e = node.inner[0]) === null || _e === void 0 ? void 0 : _e.kind) === ArkCxxAstNode_1.AstKind.TypeRef || ((_f = node.inner[0]) === null || _f === void 0 ? void 0 : _f.kind) === ArkCxxAstNode_1.AstKind.NamespaceRef && ((_g = node.inner[0]) === null || _g === void 0 ? void 0 : _g.name) !== Builtin_2.BuiltinCxx.CXXSTD)) {
             return this.staticMemberExprToValueAndStmts(node);
         }
         return this.cxxIdentifierToValueAndStmts(node);
     }
     staticMemberExprToValueAndStmts(declRefExpr) {
-        declRefExpr.kind = ast_1.astKind.MemberExpr; // Replace the type with "member invocation"
+        declRefExpr.kind = ArkCxxAstNode_1.AstKind.MemberExpr; // Replace the type with "member invocation"
         return this.memberExpressionToValueAndStmts(declRefExpr);
     }
     materializeTemporaryExprToValueAndStmts(node) {
@@ -498,7 +494,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         }
         let pNode = (_e = ((_c = node.parent) !== null && _c !== void 0 ? _c : (_d = node.getParent) === null || _d === void 0 ? void 0 : _d.call(node, true))) !== null && _e !== void 0 ? _e : null;
         if (pNode && ((_f = pNode === null || pNode === void 0 ? void 0 : pNode.inner) === null || _f === void 0 ? void 0 : _f.length) > 0 &&
-            (((_g = pNode.inner[0]) === null || _g === void 0 ? void 0 : _g.kind) === ast_1.astKind.TypeRef || !node.type.qualType.includes('[') || (0, builderUtils_1.cxxNode2Type)(node, this.declaringMethod) instanceof Type_1.ClassType)) {
+            (((_g = pNode.inner[0]) === null || _g === void 0 ? void 0 : _g.kind) === ArkCxxAstNode_1.AstKind.TypeRef || !node.type.qualType.includes('[') || (0, builderUtils_1.cxxNode2Type)(node, this.declaringMethod) instanceof Type_1.ClassType)) {
             try {
                 return this.cxxAggregateToValueAndStmts(node);
             }
@@ -515,7 +511,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      *@ returns ValueAndStmts object, including converted values and related statements
      */
     unaryOperatorToValueAndStmts(node) {
-        if (node.isPostfix) {
+        if ((0, cppUtils_1.hasNodeFlag)(node, ArkCxxAstNode_1.CxxNodeFlag.Postfix)) {
             return this.cxxPostfixUnaryExpressionToValueAndStmts(node);
         }
         else {
@@ -525,7 +521,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
     // expression with either a type or (unevaluated) expression operand.
     // Used for sizeof/alignof (C99 6.5.3.4) and vec_step (OpenCL 1.1 6.11.12).
     unaryExprToValueAndStmts(unaryExprNode) {
-        var _a;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const stmts = [];
         let unaryValue;
         const operatorString = (_a = unaryExprNode.name) !== null && _a !== void 0 ? _a : '';
@@ -549,8 +545,10 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             operpositions.push(...innerPositions);
         }
         else {
-            const typeNameMatch = unaryExprNode.code.match(/\(([^)]*)\)/);
-            const typeName = typeNameMatch ? typeNameMatch[1] : '';
+            let typeName = (_d = (_c = (_b = unaryExprNode.typeArg) === null || _b === void 0 ? void 0 : _b.qualType) === null || _c === void 0 ? void 0 : _c.trim()) !== null && _d !== void 0 ? _d : '';
+            if (!typeName) {
+                typeName = ((_h = (_f = (_e = unaryExprNode.type) === null || _e === void 0 ? void 0 : _e.qualType) !== null && _f !== void 0 ? _f : (_g = unaryExprNode.type) === null || _g === void 0 ? void 0 : _g.desugaredQualType) !== null && _h !== void 0 ? _h : '').trim();
+            }
             unaryValue = (0, builderUtils_1.buildTypeFromPreStr)(typeName, unaryExprNode, this.declaringMethod);
         }
         const unaryExpr = new Expr_2.ArkCxxUnaryExpr(operator, unaryValue);
@@ -575,8 +573,14 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         }
         const stmts = [];
         const literalStr = this.getOverloadOpName(userDefinedLiteral).replace('operator""', '');
-        const argNode = userDefinedLiteral.inner[1];
-        argNode.code = argNode.code.replace(literalStr, ''); // Get the primitive value (e.g., 123, 'a')
+        const rawArg = userDefinedLiteral.inner[1];
+        let argNode = rawArg;
+        if (literalStr && rawArg.value) {
+            const bare = rawArg.value.endsWith(literalStr)
+                ? rawArg.value.slice(0, -literalStr.length)
+                : rawArg.value.replace(literalStr, '');
+            argNode = Object.assign(Object.assign({}, rawArg), { value: bare });
+        }
         return this.buildValueAndStmtsForMemberCall(stmts, userDefinedLiteral.inner[0], [argNode], userDefinedLiteral, undefined);
     }
     /**
@@ -593,24 +597,24 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             return this.unprocessedNodeToValueAndStmts(cxxCtorInitializer);
         }
         const firstInnerNode = cxxCtorInitializer.inner[0];
-        if (firstInnerNode.kind === ast_1.astKind.CXXInheritedCtorInitExpr) {
+        if (firstInnerNode.kind === ArkCxxAstNode_1.AstKind.CXXInheritedCtorInitExpr) {
             // Processing of using parent:: parent
             return this.cxxInheritedCtorInitExprToValueAndStmts(firstInnerNode);
         }
-        else if (firstInnerNode.kind === ast_1.astKind.CXXConstructExpr && cxxCtorInitializer.baseInit) {
+        else if (firstInnerNode.kind === ArkCxxAstNode_1.AstKind.CXXConstructExpr && cxxCtorInitializer.baseInit) {
             // Processing of case: Left(const char& name) : Base(name) // call base class constructor
             return this.cxxSuperExpressionToValueAndStmts(firstInnerNode);
         }
         // If the kind of firstNode is CXXConstructExpr and firstNode does not correspond to a parent class initialization call,
         // it is equivalent to directly assigning a value to the class member.
         // For example, the constructor of class Circle in file 'tests/cppResources/exports/crossFileCase/include/myHeader.h'.
-        const assignRight = (firstInnerNode.kind === ast_1.astKind.CXXConstructExpr && firstInnerNode.inner.length > 0) ? firstInnerNode.inner[0] : firstInnerNode;
+        const assignRight = (firstInnerNode.kind === ArkCxxAstNode_1.AstKind.CXXConstructExpr && firstInnerNode.inner.length > 0) ? firstInnerNode.inner[0] : firstInnerNode;
         const CtorInit2ThisMemberExpr = {
-            kind: 'MemberExpr',
+            kind: ArkCxxAstNode_1.AstKind.MemberExpr,
             name: (_b = (_a = cxxCtorInitializer.anyInit) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '',
             inner: [
                 {
-                    kind: 'CXXThisExpr',
+                    kind: ArkCxxAstNode_1.AstKind.CXXThisExpr,
                 },
             ],
             type: (_d = (_c = cxxCtorInitializer.anyInit) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : '',
@@ -627,7 +631,6 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      */
     cxxInheritedCtorInitExprToValueAndStmts(cxxInheritedCtorInitExpr) {
         var _a;
-        cxxInheritedCtorInitExpr.code = `using ${cxxInheritedCtorInitExpr.code}::${cxxInheritedCtorInitExpr.code}`;
         const cls = this.declaringMethod.getDeclaringArkClass();
         const clsInitMtd = cls.getInstanceInitMethod();
         if (!clsInitMtd) {
@@ -708,10 +711,10 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         let dimensionSizes = [];
         let op = null;
         for (let i = 0; i < ArrayTypeTraitExpr.inner.length; i++) {
-            if (ArrayTypeTraitExpr.inner[i].kind === ast_1.astKind.IntegerLiteral) {
+            if (ArrayTypeTraitExpr.inner[i].kind === ArkCxxAstNode_1.AstKind.IntegerLiteral) {
                 dimensionSizes.push(Number(ArrayTypeTraitExpr.inner[i].value));
             }
-            else if (ArrayTypeTraitExpr.inner[i].kind === ast_1.astKind.DeclRefExpr) {
+            else if (ArrayTypeTraitExpr.inner[i].kind === ArkCxxAstNode_1.AstKind.DeclRefExpr) {
                 const innerValueAndStmts = this.cxxNodeToValueAndStmts(ArrayTypeTraitExpr.inner[i]);
                 op = innerValueAndStmts.value;
                 stmts.push(...innerValueAndStmts.stmts);
@@ -804,7 +807,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      */
     cxxDeleteExpressionToValueAndStmts(deleteExpression) {
         const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts, } = this.cxxNodeToValueAndStmts(deleteExpression.inner[0]);
-        const isArray = deleteExpression.isArray;
+        const isArray = (0, cppUtils_1.hasNodeFlag)(deleteExpression, ArkCxxAstNode_1.CxxNodeFlag.Array);
         const deleteExpr = isArray ? new Expr_2.ArkCxxDeleteArrayExpr(exprValue) : new Expr_1.ArkDeleteExpr(exprValue);
         const deleteExprPosition = [Position_1.FullPosition.cxxBuildFromNode(deleteExpression, this.cxxSourceFile), ...exprPositions];
         return { value: deleteExpr, valueOriginalPositions: deleteExprPosition, stmts: stmts };
@@ -826,13 +829,12 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             } = this.ArkCxxIRTransformer.generateAssignStmtForValue(exprValue, exprPositions));
             stmts.push(...exprStmts);
         }
-        const castType = castExpression.kind;
+        const castType = (0, cppUtils_1.astKindToString)(castExpression.kind);
         const castExpr = new Expr_2.ArkCxxCastExpr(exprValue, (0, builderUtils_1.cxxNode2Type)(castExpression, this.declaringMethod), castType);
         const castExprPosition = [Position_1.FullPosition.cxxBuildFromNode(castExpression, this.cxxSourceFile), ...exprPositions];
         return { value: castExpr, valueOriginalPositions: castExprPosition, stmts: stmts };
     }
     cxxFoldExprToValueAndStmts(CXXFoldExpr) {
-        var _a;
         const stmts = [];
         let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.cxxNodeToValueAndStmts(CXXFoldExpr.inner[CXXFoldExpr.inner.length - 1]);
         stmts.push(...exprStmts);
@@ -844,7 +846,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             } = this.ArkCxxIRTransformer.generateAssignStmtForValue(exprValue, exprPositions));
             stmts.push(...exprStmts);
         }
-        const foldOp = (_a = CXXFoldExpr.op) !== null && _a !== void 0 ? _a : ' ';
+        const foldOp = CXXFoldExpr.op !== undefined ? (0, cppUtils_1.cxxFoldOpToString)(CXXFoldExpr.op) : (0, cppUtils_1.cxxFoldOpToString)(ArkCxxAstNode_1.CxxFoldOp.FoldSpace);
         const folderExpr = new Expr_2.ArkCxxFolderExpr(exprValue, foldOp);
         const folderExprPosition = [Position_1.FullPosition.cxxBuildFromNode(CXXFoldExpr, this.cxxSourceFile), ...exprPositions];
         return { value: folderExpr, valueOriginalPositions: folderExprPosition, stmts: stmts };
@@ -860,7 +862,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         const stmts = [];
         const currConditionalOperatorIndex = this.conditionalOperatorNo++;
         // Peel off 'ImplicitCastExpr'
-        const conditionNode = conditionalExpression.inner[InnerIdx].kind === ast_1.astKind.ImplicitCastExpr ?
+        const conditionNode = conditionalExpression.inner[InnerIdx].kind === ArkCxxAstNode_1.AstKind.ImplicitCastExpr ?
             conditionalExpression.inner[InnerIdx].inner[0] : conditionalExpression.inner[InnerIdx];
         let conditionExpr;
         const context = { conditionExpr: conditionExpr };
@@ -871,7 +873,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         // inner[1] is a value whose expression is true
         InnerIdx++;
         let whenTrueValueAndStmts;
-        if (conditionalExpression.kind === ast_1.astKind.ConditionalOperator) {
+        if (conditionalExpression.kind === ArkCxxAstNode_1.AstKind.ConditionalOperator) {
             whenTrueValueAndStmts = this.cxxNodeToValueAndStmts(conditionalExpression.inner[InnerIdx]);
             // else kind is BinaryConditionalOperator,No need to parse the node again, the result of the judgment is its value
         }
@@ -927,16 +929,16 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         }
         // Several callable kinds
         const CALLABLE_KINDS = new Set([
-            ast_1.astKind.DeclRefExpr,
-            ast_1.astKind.MemberExpr,
-            ast_1.astKind.OverloadedDeclRef,
-            ast_1.astKind.ArraySubscriptExpr,
-            ast_1.astKind.CXXOperatorCallExpr,
-            ast_1.astKind.UnresolvedLookupExpr,
+            ArkCxxAstNode_1.AstKind.DeclRefExpr,
+            ArkCxxAstNode_1.AstKind.MemberExpr,
+            ArkCxxAstNode_1.AstKind.OverloadedDeclRef,
+            ArkCxxAstNode_1.AstKind.ArraySubscriptExpr,
+            ArkCxxAstNode_1.AstKind.CXXOperatorCallExpr,
+            ArkCxxAstNode_1.AstKind.UnresolvedLookupExpr,
         ]);
         function unwrapImplicit(n) {
             var _a;
-            while (n && n.kind === ast_1.astKind.ImplicitCastExpr) {
+            while (n && n.kind === ArkCxxAstNode_1.AstKind.ImplicitCastExpr) {
                 n = (_a = n.inner) === null || _a === void 0 ? void 0 : _a[0];
             }
             return n;
@@ -965,7 +967,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
     getDeclRef(astNode) {
         let n = astNode;
         while (n) {
-            if (n.kind === ast_1.astKind.DeclRefExpr) {
+            if (n.kind === ArkCxxAstNode_1.AstKind.DeclRefExpr) {
                 return n;
             }
             // No child node or empty child node, end
@@ -1043,7 +1045,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         else {
             varNode = identifier;
         }
-        let varName = varNode.kind === ast_1.astKind.TypeRef ? varNode.code : varNode.name;
+        let varName = varNode.name;
         const varType = (0, builderUtils_1.cxxNode2Type)(identifier, this.declaringMethod);
         if (varName === Type_1.UndefinedType.getInstance().getName()) {
             identifierValue = ValueUtil_1.CxxValueUtil.getUndefinedConst();
@@ -1072,15 +1074,14 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      *  such as determining the base in advance when resolving the parent node)
      */
     memberExpressionToValueAndStmts(memberExpression, localValue) {
-        var _a, _b, _c;
+        var _a, _b;
         const stmts = [];
         // [Scenario 1] Process this ->field or this ->method calls in C++code
         // If it's a class member reference (MemberExpr/MemberRef) but has no inner[0], it means implicit this, need to supplement this node
-        if ((memberExpression.kind === ast_1.astKind.MemberExpr || memberExpression.kind === ast_1.astKind.MemberRef) && memberExpression.inner[0] === undefined) {
+        if ((memberExpression.kind === ArkCxxAstNode_1.AstKind.MemberExpr || memberExpression.kind === ArkCxxAstNode_1.AstKind.MemberRef) && memberExpression.inner[0] === undefined) {
             memberExpression.inner[0] = {
-                kind: 'CXXThisExpr',
+                kind: ArkCxxAstNode_1.AstKind.CXXThisExpr,
                 name: memberExpression.name,
-                code: '',
                 type: { qualType: 'void' },
                 inner: [],
             }; //  As base node
@@ -1090,7 +1091,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         let { value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts, } = this.cxxNodeToValueAndStmts(memberExpression.inner[0]);
         // [Scenario 3] Processing chained member access, such as a.b.c or (* ptr). field
         // If the base is a member access, generate an assignment statement to ensure the validity of SSA
-        if (((_a = memberExpression.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ast_1.astKind.MemberExpr || memberExpression.kind === ast_1.astKind.MemberRef) {
+        if (((_a = memberExpression.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ArkCxxAstNode_1.AstKind.MemberExpr || memberExpression.kind === ArkCxxAstNode_1.AstKind.MemberRef) {
             ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
                 this.ArkCxxIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
         }
@@ -1106,12 +1107,12 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         const fieldSignature = this.buildFieldSignatureFromMemberExpr(baseValue, memberExpression);
         // [Scenario 6] Generate the field reference object of IR layer (such as testMap. insert)
         let fieldRef;
-        if (((_b = memberExpression.referencedDecl) === null || _b === void 0 ? void 0 : _b.kind) === ast_1.astKind.EnumConstantDecl) {
+        if (((_b = memberExpression.referencedDecl) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.AstKind.EnumConstantDecl) {
             fieldRef = new Ref_1.ArkStaticFieldRef(fieldSignature);
         }
         else {
             fieldRef = new Ref_2.ArkCxxInstanceFieldRef(baseValue, // baseValue（eg: testMap）
-            (_c = memberExpression.isArrow) !== null && _c !== void 0 ? _c : false, // Whether it is arrow access (->)
+            (0, cppUtils_1.hasNodeFlag)(memberExpression, ArkCxxAstNode_1.CxxNodeFlag.Arrow), // Whether it is arrow access (->)
             fieldSignature);
         }
         // Record node location information for subsequent traceability and debugging
@@ -1122,9 +1123,9 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
     buildFieldSignatureFromMemberExpr(baseValue, memberExpression) {
         var _a, _b;
         let fieldSignature;
-        const memberName = ((_a = memberExpression.referencedDecl) === null || _a === void 0 ? void 0 : _a.name) || memberExpression.name || memberExpression.code;
+        const memberName = ((_a = memberExpression.referencedDecl) === null || _a === void 0 ? void 0 : _a.name) || memberExpression.name;
         // ==Scenarios for Special Handling of Enum Members==
-        if (((_b = memberExpression.referencedDecl) === null || _b === void 0 ? void 0 : _b.kind) === ast_1.astKind.EnumConstantDecl) {
+        if (((_b = memberExpression.referencedDecl) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.AstKind.EnumConstantDecl) {
             const enumClassName = memberExpression.type.qualType.replace('enum', '').trim();
             const enumArkClass = ModelUtils_2.CxxModelUtils.findSymbolInFileWithName(enumClassName, this.declaringMethod.getDeclaringArkClass());
             const enumSignature = (enumArkClass instanceof ArkClass_1.ArkClass) ?
@@ -1212,14 +1213,14 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
     }
     cxxCallExpressionToValueAndStmts(callExpression) {
         var _a, _b, _c, _d, _e, _f;
-        if (callExpression.kind === ast_1.astKind.CallExpr && ((_a = callExpression.inner) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        if (callExpression.kind === ArkCxxAstNode_1.AstKind.CallExpr && ((_a = callExpression.inner) === null || _a === void 0 ? void 0 : _a.length) > 0) {
             if (((_e = (_d = ((_b = callExpression.parent) !== null && _b !== void 0 ? _b : (_c = callExpression.getParent) === null || _c === void 0 ? void 0 : _c.call(callExpression, true))) === null || _d === void 0 ? void 0 : _d.type) === null || _e === void 0 ? void 0 : _e.qualType) === 'std::thread') {
                 return this.cxxNewExpressionToValueAndStmts(callExpression);
             }
-            else if (callExpression.inner[0].kind === ast_1.astKind.CXXPseudoDestructorExpression) {
+            else if (callExpression.inner[0].kind === ArkCxxAstNode_1.AstKind.CXXPseudoDestructorExpression) {
                 return this.cxxCallExpressionToValueAndStmts(callExpression.inner[0]);
             }
-            else if (callExpression.name === 'basic_string' || callExpression.inner[0].kind === ast_1.astKind.MaterializeTemporaryExpr) {
+            else if (callExpression.name === 'basic_string' || callExpression.inner[0].kind === ArkCxxAstNode_1.AstKind.MaterializeTemporaryExpr) {
                 return this.cxxNodeToValueAndStmts(callExpression.inner[0]);
             }
         }
@@ -1227,14 +1228,13 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         const [callNode, argumentNodes] = this.getArgumentNode(callExpression.inner);
         if (callNode && (0, builderUtils_1.isFuncInClassOrNamespace)(callNode) && ((_f = callNode.referencedDecl) === null || _f === void 0 ? void 0 : _f.name)) {
             // Process static function calls
-            callNode.kind = 'MemberExpr';
+            callNode.kind = ArkCxxAstNode_1.AstKind.MemberExpr;
             const replaceFuncName = callNode.referencedDecl.name;
+            const outerName = this.getDeclRefScopePrefix(callNode, replaceFuncName);
             callNode.name = replaceFuncName;
-            const outerName = callNode.code.replace('::' + replaceFuncName, '');
             callNode.inner[0] = {
-                kind: 'DeclRefExpr',
+                kind: ArkCxxAstNode_1.AstKind.DeclRefExpr,
                 name: outerName,
-                code: outerName,
                 type: { qualType: outerName },
                 inner: [],
             };
@@ -1259,13 +1259,10 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         // Because inner extracts the last parameters in turn, it traverses the last parameters in reverse order
         for (let i = callExpression.inner.length - 1; i >= 0; i--) {
             let innerNode = callExpression.inner[i];
-            if (!innerNode.code.includes('cout') &&
-                !innerNode.code.includes('<<') &&
-                !innerNode.code.includes('endl') &&
-                !callExpression.code.startsWith(innerNode.code)) {
+            if (!this.isCxxStreamSyntaxNode(innerNode)) {
                 callArgus.push(innerNode);
             }
-            if (innerNode.kind === ast_1.astKind.CXXOperatorCallExpr) {
+            if (innerNode.kind === ArkCxxAstNode_1.AstKind.CXXOperatorCallExpr) {
                 // Recursive call processing CXXOperatorCallExpr
                 if (innerNode.type.qualType !== 'std::ostream') {
                     return this.streamOrLambdaExprToValueAndStmts(innerNode, callArgus);
@@ -1273,16 +1270,18 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
                 // When the type is std:: ostream, it indicates an overloaded stream operator and records the overloaded node of the stream operator
                 callArgus.push(innerNode);
                 // Recursive call to process CXXOperatorCallExpr nested in the inner of CXXOperatorCallExpr
-                if (innerNode.inner[1].kind === ast_1.astKind.CXXOperatorCallExpr) {
+                if (innerNode.inner[1].kind === ArkCxxAstNode_1.AstKind.CXXOperatorCallExpr) {
                     return this.streamOrLambdaExprToValueAndStmts(innerNode.inner[1], callArgus);
                 }
                 // If there is no nested CXXOperatorCallExpr, the ValueAndStmts of overloaded stream operators will be built directly
                 return this.buildValueAndStmtsForStreamOrLambdaCall(innerNode.inner[1], callArgus.reverse(), stmts, callExpression);
             }
-            while (innerNode.kind === ast_1.astKind.ImplicitCastExpr && innerNode.valueCategory === 'lvalue' && innerNode.inner.length > 0) {
+            while (innerNode.kind === ArkCxxAstNode_1.AstKind.ImplicitCastExpr &&
+                innerNode.valueCategory === ArkCxxAstNode_1.CxxValueCategory.Lvalue &&
+                innerNode.inner.length > 0) {
                 innerNode = innerNode.inner[0];
             }
-            if (innerNode.kind === ast_1.astKind.DeclRefExpr &&
+            if (innerNode.kind === ArkCxxAstNode_1.AstKind.DeclRefExpr &&
                 (innerNode.type.qualType.includes('iostream') ||
                     innerNode.type.qualType.includes('ostream') ||
                     innerNode.type.qualType.includes('istream') ||
@@ -1303,15 +1302,16 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      *@ returns The ValueAndStmts object containing values and statements
      */
     buildValueAndStmtsForStreamOrLambdaCall(streamNode, args, stmts, streamExpr) {
+        var _a;
         let nonOverloadedArgs = [];
         const currValueAndStmts = {
-            value: new Local_1.Local(streamExpr.code),
+            value: new Local_1.Local((_a = streamExpr.name) !== null && _a !== void 0 ? _a : ''),
             valueOriginalPositions: [],
             stmts: [...stmts],
         };
         for (let i = 0; i < args.length; i += 1) {
             let arg = args[i];
-            if (arg.kind === ast_1.astKind.CXXOperatorCallExpr) {
+            if (arg.kind === ArkCxxAstNode_1.AstKind.CXXOperatorCallExpr) {
                 // Standard stream operator+overloaded stream operator
                 // 1. Object of standard stream operator, call std:: stream function
                 this.buildValueAndStmtsForStdStreamOrLambdaCall(streamNode, nonOverloadedArgs, streamExpr, currValueAndStmts);
@@ -1376,10 +1376,8 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      *@ returns the converted values and statements
      */
     CXXOperatorExpressionToBinaryOperator(expression) {
-        let operatorExpression = Object.assign({}, expression);
-        operatorExpression.opcode = expression.inner[0].code;
-        operatorExpression.inner = [expression.inner[1], expression.inner[2]];
-        return this.cxxBinaryExpressionToValueAndStmts(operatorExpression);
+        const operatorExpression = Object.assign(Object.assign({}, expression), { inner: [expression.inner[1], expression.inner[2]] });
+        return this.cxxBinaryExpressionToValueAndStmts(operatorExpression, this.getOperatorTokenFromNode(expression.inner[0]));
     }
     /**
      *Convert C++operator expression to unary operator expression
@@ -1387,13 +1385,12 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      *@ returns ValueAndStmts object, including converted values and statements
      */
     CXXOperatorExpressionToUnaryOperator(expression) {
-        let operatorExpression = Object.assign({}, expression);
-        operatorExpression.opcode = expression.inner[0].code;
-        operatorExpression.inner = [expression.inner[1]];
-        if (expression.code.indexOf(expression.inner[0].code) === 0) {
-            return this.cxxPrefixUnaryExpressionToValueAndStmts(operatorExpression);
+        const operatorExpression = Object.assign(Object.assign({}, expression), { inner: [expression.inner[1]] });
+        const operatorToken = this.getOperatorTokenFromNode(expression.inner[0]);
+        if (!(0, cppUtils_1.hasNodeFlag)(expression.inner[0], ArkCxxAstNode_1.CxxNodeFlag.Postfix)) {
+            return this.cxxPrefixUnaryExpressionToValueAndStmts(operatorExpression, operatorToken);
         }
-        return this.cxxPostfixUnaryExpressionToValueAndStmts(operatorExpression);
+        return this.cxxPostfixUnaryExpressionToValueAndStmts(operatorExpression, operatorToken);
     }
     cxxOperatorExpressionToValueAndStmts(callExpression, layer = true) {
         var _a;
@@ -1439,33 +1436,34 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      * Handle special operator scenarios and return early if matched
      */
     handleSpecialOperators(callExpression) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g;
         // Overloaded operator
         const overloadedOpToValueAndStmts = this.handleOverloadedOp(callExpression);
         if (overloadedOpToValueAndStmts) {
             return overloadedOpToValueAndStmts;
         }
         // operator<< / operator>> and lambda cout scenario
-        if ((((_a = callExpression.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ast_1.astKind.ImplicitCastExpr && ((_b = callExpression.inner[0]) === null || _b === void 0 ? void 0 : _b.name) === 'operator>>') ||
+        if ((((_a = callExpression.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ArkCxxAstNode_1.AstKind.ImplicitCastExpr && ((_b = callExpression.inner[0]) === null || _b === void 0 ? void 0 : _b.name) === 'operator>>') ||
             callExpression.name === 'operator<<' ||
             ((_c = callExpression.inner[0]) === null || _c === void 0 ? void 0 : _c.name) === 'operator<<' ||
             ((_d = callExpression.inner[1]) === null || _d === void 0 ? void 0 : _d.type.qualType.toString().includes('(lambda at'))) {
             return this.streamOrLambdaExprToValueAndStmts(callExpression, []);
         }
         // Relational binary operator or assignment operator
-        if (((_e = callExpression.inner[0]) === null || _e === void 0 ? void 0 : _e.kind) === ast_1.astKind.ImplicitCastExpr &&
-            (ArkCxxValueTransformer.isRelationalBinaryOperator((_f = callExpression.inner[0]) === null || _f === void 0 ? void 0 : _f.code) ||
+        if (((_e = callExpression.inner[0]) === null || _e === void 0 ? void 0 : _e.kind) === ArkCxxAstNode_1.AstKind.ImplicitCastExpr &&
+            (ArkCxxValueTransformer.isRelationalBinaryOperator(this.getOperatorTokenFromNode(callExpression.inner[0])) ||
                 this.getOverloadOpName(callExpression) === 'operator=')) {
             return this.CXXOperatorExpressionToBinaryOperator(callExpression);
         }
         // Unary operators (++ / --)
-        if (((_g = callExpression.inner[0]) === null || _g === void 0 ? void 0 : _g.kind) === ast_1.astKind.ImplicitCastExpr &&
-            ['++', '--', '*'].includes((_h = callExpression.inner[0]) === null || _h === void 0 ? void 0 : _h.code)) {
+        const unaryOpToken = this.getOperatorTokenFromNode(callExpression.inner[0]);
+        if (((_f = callExpression.inner[0]) === null || _f === void 0 ? void 0 : _f.kind) === ArkCxxAstNode_1.AstKind.ImplicitCastExpr &&
+            ['++', '--', '*'].includes(unaryOpToken)) {
             return this.CXXOperatorExpressionToUnaryOperator(callExpression);
         }
         // Arrow operator (->) in iteration
-        if (((_j = callExpression.inner[0]) === null || _j === void 0 ? void 0 : _j.kind) === ast_1.astKind.ImplicitCastExpr &&
-            ((_k = callExpression.inner[0]) === null || _k === void 0 ? void 0 : _k.code) === '->') {
+        if (((_g = callExpression.inner[0]) === null || _g === void 0 ? void 0 : _g.kind) === ArkCxxAstNode_1.AstKind.ImplicitCastExpr &&
+            unaryOpToken === '->') {
             return this.cxxNodeToValueAndStmts(callExpression.inner[1]);
         }
         return null;
@@ -1477,19 +1475,19 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         for (let innerNode of callExpression.inner) {
             // 将第一组递归表达式类型定义为 string 数组
             const recursiveKinds = [
-                ast_1.astKind.CXXOperatorCallExpr,
-                ast_1.astKind.MaterializeTemporaryExpr,
-                ast_1.astKind.CXXBindTemporaryExpr,
-                ast_1.astKind.CXXConstructExpr
+                ArkCxxAstNode_1.AstKind.CXXOperatorCallExpr,
+                ArkCxxAstNode_1.AstKind.MaterializeTemporaryExpr,
+                ArkCxxAstNode_1.AstKind.CXXBindTemporaryExpr,
+                ArkCxxAstNode_1.AstKind.CXXConstructExpr
             ];
             if (recursiveKinds.includes(innerNode.kind) ||
-                (innerNode.kind === ast_1.astKind.ImplicitCastExpr && innerNode.castKind !== 'FunctionToPointerDecay')) {
+                (innerNode.kind === ArkCxxAstNode_1.AstKind.ImplicitCastExpr && innerNode.castKind !== ArkCxxAstNode_1.AstKind.FunctionToPointerDecay)) {
                 innerStmts.push(...this.cxxOperatorExpressionToValueAndStmts(innerNode, false));
             }
-            else if (innerNode.kind === ast_1.astKind.DeclRefExpr) {
+            else if (innerNode.kind === ArkCxxAstNode_1.AstKind.DeclRefExpr) {
                 innerStmts.push(this.cxxIdentifierToValueAndStmts(innerNode));
             }
-            else if (innerNode.kind === ast_1.astKind.IntegerLiteral || innerNode.kind === ast_1.astKind.StringLiteral) {
+            else if (innerNode.kind === ArkCxxAstNode_1.AstKind.IntegerLiteral || innerNode.kind === ArkCxxAstNode_1.AstKind.StringLiteral) {
                 let literalNode = this.cxxLiteralNodeToValueAndStmts(innerNode);
                 if (literalNode) {
                     innerStmts.push(literalNode);
@@ -1497,6 +1495,50 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             }
         }
     }
+    getOperatorTokenFromNode(node) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (!node) {
+            return '';
+        }
+        if (node.opcode !== undefined && node.opcode !== ArkCxxAstNode_1.CxxOpcode.Unknown) {
+            return (0, cppUtils_1.cxxOpcodeToString)(node.opcode);
+        }
+        const refName = (_f = (_b = (_a = node.referencedDecl) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_e = (_d = (_c = node.inner) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.referencedDecl) === null || _e === void 0 ? void 0 : _e.name) !== null && _f !== void 0 ? _f : '';
+        if (refName.startsWith('operator')) {
+            return refName.slice('operator'.length);
+        }
+        if (refName !== '') {
+            return refName;
+        }
+        return (_g = node.name) !== null && _g !== void 0 ? _g : '';
+    }
+    getDeclRefScopePrefix(callNode, funcName) {
+        var _a, _b, _c;
+        const qualifiedName = (_a = callNode.name) !== null && _a !== void 0 ? _a : '';
+        const suffix = '::' + funcName;
+        if (qualifiedName.includes('::')) {
+            return qualifiedName.endsWith(suffix)
+                ? qualifiedName.slice(0, -suffix.length)
+                : (_b = qualifiedName.split('::')[0]) !== null && _b !== void 0 ? _b : qualifiedName;
+        }
+        const scopeNode = callNode.inner.find(child => child.kind === ArkCxxAstNode_1.AstKind.NamespaceRef || child.kind === ArkCxxAstNode_1.AstKind.TypeRef);
+        return (_c = scopeNode === null || scopeNode === void 0 ? void 0 : scopeNode.name) !== null && _c !== void 0 ? _c : qualifiedName;
+    }
+    isCxxStreamSyntaxNode(node) {
+        var _a;
+        const streamIds = new Set(['cout', 'cin', 'cerr', 'clog', 'endl', 'std::endl']);
+        if (streamIds.has(node.name)) {
+            return true;
+        }
+        if (node.kind === ArkCxxAstNode_1.AstKind.CXXOperatorCallExpr) {
+            const op = this.getOverloadOpName(node) || node.name;
+            return op === 'operator<<' || op === 'operator>>';
+        }
+        if (node.kind === ArkCxxAstNode_1.AstKind.ImplicitCastExpr && ((_a = node.inner) === null || _a === void 0 ? void 0 : _a[0])) {
+            return this.isCxxStreamSyntaxNode(node.inner[0]);
+        }
+        return false;
+    }
     getOverloadOpName(cxxOperatorCallExpr) {
         var _a, _b, _c, _d;
         return (_d = (_c = (_b = (_a = cxxOperatorCallExpr.inner[0]) === null || _a === void 0 ? void 0 : _a.inner[0]) === null || _b === void 0 ? void 0 : _b.referencedDecl) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : '';
@@ -1509,13 +1551,15 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
     handleOverloadedOp(cxxOperatorCallExpr) {
         var _a, _b, _c, _d;
         if (((_a = cxxOperatorCallExpr.type) === null || _a === void 0 ? void 0 : _a.qualType) === '' ||
-            ((_c = (_b = cxxOperatorCallExpr.inner) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.castKind) !== 'FunctionToPointerDecay') {
+            ((_c = (_b = cxxOperatorCallExpr.inner) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.castKind) !== ArkCxxAstNode_1.AstKind.FunctionToPointerDecay) {
             return null;
         }
         // Handling Recursive function, e.g. Case10 in lambdaFuncSample.cpp
         if ((_d = cxxOperatorCallExpr.inner) === null || _d === void 0 ? void 0 : _d[1]) {
             let callNode = cxxOperatorCallExpr.inner[1];
-            while (callNode.kind === ast_1.astKind.ImplicitCastExpr && callNode.valueCategory === 'lvalue' && callNode.inner.length > 0) {
+            while (callNode.kind === ArkCxxAstNode_1.AstKind.ImplicitCastExpr &&
+                callNode.valueCategory === ArkCxxAstNode_1.CxxValueCategory.Lvalue &&
+                callNode.inner.length > 0) {
                 callNode = callNode.inner[0];
             }
             if (callNode.type.qualType.includes('std::function') || this.isNodeRelatedToCXXLambdaFunc(callNode)) {
@@ -1590,7 +1634,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         const callNode = {
             code: cxxOperatorCallExpr.name,
             name: cxxOperatorCallExpr.name,
-            kind: 'DeclRefExpr',
+            kind: ArkCxxAstNode_1.AstKind.DeclRefExpr,
             inner: [],
             range: cxxOperatorCallExpr.range,
             type: cxxOperatorCallExpr.type,
@@ -1615,10 +1659,9 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         // For example, when overloading operator+, a+b is equivalent to a.operator+(b), and the memberExpr of a.operator+is constructed as the caller
         const overloadOpName = this.getOverloadOpName(cxxOperatorCallExpr);
         const callNode = {
-            code: cxxOperatorCallExpr.inner[1].code + '.' + overloadOpName,
             name: overloadOpName,
             range: cxxOperatorCallExpr.range,
-            kind: 'MemberExpr',
+            kind: ArkCxxAstNode_1.AstKind.MemberExpr,
             type: { qualType: '<bound member function type>' },
             inner: [cxxOperatorCallExpr.inner[1]],
         };
@@ -1658,7 +1701,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             const callerName = callerValue.getName();
             let classSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(callerName);
             let cls = ModelUtils_1.ModelUtils.getClass(this.declaringMethod, classSignature);
-            const callExprs = [ast_1.astKind.CallExpr, ast_1.astKind.CXXOperatorCallExpr];
+            const callExprs = [ArkCxxAstNode_1.AstKind.CallExpr, ArkCxxAstNode_1.AstKind.CXXOperatorCallExpr];
             if ((cls === null || cls === void 0 ? void 0 : cls.hasComponentDecorator()) && callExprs.includes(callExpression.kind)) {
                 return this.cxxGenerateCustomViewStmt(callerName, args, argPositions, callExpression, stmts);
             }
@@ -1859,7 +1902,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         const argPositions = [];
         if (argumentNodes) {
             for (let i = 0; i < argumentNodes.length; i++) {
-                if (argumentNodes[i].kind === ast_1.astKind.CXXDefaultArgExpr) {
+                if (argumentNodes[i].kind === ArkCxxAstNode_1.AstKind.CXXDefaultArgExpr) {
                     continue;
                 }
                 const argument = argumentNodes[i];
@@ -1902,13 +1945,13 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         var _a, _b;
         let className = this.getNewExpressionClassName(newExpression);
         // Add handling for dynamic array creation: int *arr = new int[10]
-        if (className === Builtin_1.Builtin.ARRAY || newExpression.isArray) {
+        if (className === Builtin_1.Builtin.ARRAY || (0, cppUtils_1.hasNodeFlag)(newExpression, ArkCxxAstNode_1.CxxNodeFlag.Array)) {
             return this.cxxNewArrayExpressionToValueAndStmts(newExpression);
         }
         const stmts = [];
         let realGenericTypes = this.getRealGenericTypes(newExpression);
         // Handle the scenarios of namespace::Member and class::member
-        const parentClassOrNs = (_a = newExpression.getParent) === null || _a === void 0 ? void 0 : _a.call(newExpression, true).inner.filter(inn => [ast_1.astKind.TypeRef, ast_1.astKind.NamespaceRef].includes(inn.kind));
+        const parentClassOrNs = (_a = newExpression.getParent) === null || _a === void 0 ? void 0 : _a.call(newExpression, true).inner.filter(inn => [ArkCxxAstNode_1.AstKind.TypeRef, ArkCxxAstNode_1.AstKind.NamespaceRef].includes(inn.kind));
         let refType = null;
         // If the parent node has a namespaceRef or TypeRef, it indicates a constructor call,
         // and should infer the type of the corresponding namespace/class.
@@ -1931,7 +1974,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         const expr = new Expr_1.ArkNewExpr(classType);
         const { value: newLocal, valueOriginalPositions: newLocalPositions, stmts: newExprStmts } = this.ArkCxxIRTransformer.generateAssignStmtForValue(expr, [Position_1.FullPosition.cxxBuildFromNode(newExpression, this.cxxSourceFile)]);
         // When using the new keyword, the type of Local should be a pointer type.
-        if (newExpression.kind === ast_1.astKind.CXXNewExpr) {
+        if (newExpression.kind === ArkCxxAstNode_1.AstKind.CXXNewExpr) {
             newLocal.setType(new Type_2.PointerType(classType, 1));
         }
         stmts.push(...newExprStmts);
@@ -1953,25 +1996,25 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         const constructArgs = (() => {
             var _a, _b;
             let args = newExpression.inner;
-            if (newExpression.kind === ast_1.astKind.CXXNewExpr && ((_a = newExpression.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ast_1.astKind.CXXConstructExpr) {
+            if (newExpression.kind === ArkCxxAstNode_1.AstKind.CXXNewExpr && ((_a = newExpression.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ArkCxxAstNode_1.AstKind.CXXConstructExpr) {
                 return [...newExpression.inner[0].inner];
             }
-            else if (newExpression.kind === ast_1.astKind.CompoundLiteralExpr) {
+            else if (newExpression.kind === ArkCxxAstNode_1.AstKind.CompoundLiteralExpr) {
                 return this.getConstructArgs(args);
             }
             else if (
             // if case : struct LargeStruct s;, inner.length is 0, so we need to avoid it
-            newExpression.kind === ast_1.astKind.CXXConstructExpr &&
+            newExpression.kind === ArkCxxAstNode_1.AstKind.CXXConstructExpr &&
                 newExpression.type.qualType.startsWith('struct') &&
-                args.length > 0 && ((_b = args[0].inner[0]) === null || _b === void 0 ? void 0 : _b.kind) === ast_1.astKind.CompoundLiteralExpr) {
+                args.length > 0 && ((_b = args[0].inner[0]) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.AstKind.CompoundLiteralExpr) {
                 return this.getConstructArgs(args[0].inner[0].inner);
             }
-            else if (newExpression.kind === ast_1.astKind.InitListExpr) {
+            else if (newExpression.kind === ArkCxxAstNode_1.AstKind.InitListExpr) {
                 return this.getConstructArgs(newExpression);
             }
-            return args.filter(arg => (arg === null || arg === void 0 ? void 0 : arg.kind) !== ast_1.astKind.TemplateRef &&
-                (arg === null || arg === void 0 ? void 0 : arg.kind) !== ast_1.astKind.NamespaceRef &&
-                (arg === null || arg === void 0 ? void 0 : arg.kind) !== ast_1.astKind.TypeRef);
+            return args.filter(arg => (arg === null || arg === void 0 ? void 0 : arg.kind) !== ArkCxxAstNode_1.AstKind.TemplateRef &&
+                (arg === null || arg === void 0 ? void 0 : arg.kind) !== ArkCxxAstNode_1.AstKind.NamespaceRef &&
+                (arg === null || arg === void 0 ? void 0 : arg.kind) !== ArkCxxAstNode_1.AstKind.TypeRef);
         })();
         const { args: argValues, argPositions } = this.cxxParseArguments(stmts, constructArgs);
         const constructorMethodSignature = this.getConstructorSignatureByClassTypeAndArgs(classType, argValues);
@@ -2024,7 +2067,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         if (Array.isArray(constructArgs)) {
             arr = constructArgs;
         }
-        else if (constructArgs.kind === ast_1.astKind.InitListExpr) {
+        else if (constructArgs.kind === ArkCxxAstNode_1.AstKind.InitListExpr) {
             arr = (_a = constructArgs.inner) !== null && _a !== void 0 ? _a : [];
         }
         else {
@@ -2032,11 +2075,11 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             arr = (_b = constructArgs.inner) !== null && _b !== void 0 ? _b : [];
         }
         // 2) If the second element itself is InitListExpr, take its inner as the real parameter
-        if (((_c = arr[1]) === null || _c === void 0 ? void 0 : _c.kind) === ast_1.astKind.InitListExpr) {
+        if (((_c = arr[1]) === null || _c === void 0 ? void 0 : _c.kind) === ArkCxxAstNode_1.AstKind.InitListExpr) {
             arr = (_d = arr[1].inner) !== null && _d !== void 0 ? _d : [];
         }
         // 3) If there is "implicit conversion" (original logic: check whether the second element is ImplicitCastExpr)
-        const useInner1 = ((_e = arr[1]) === null || _e === void 0 ? void 0 : _e.kind) === ast_1.astKind.ImplicitCastExpr;
+        const useInner1 = ((_e = arr[1]) === null || _e === void 0 ? void 0 : _e.kind) === ArkCxxAstNode_1.AstKind.ImplicitCastExpr;
         // 4) Generate a new parameter list (equivalent to the original logic)
         const newConstructArgs = [];
         for (let i = 0; i < arr.length; i++) {
@@ -2063,9 +2106,6 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         else if (newExpression.type.qualType) {
             oriType = newExpression.type.qualType;
         }
-        else if (newExpression.code) {
-            oriType = newExpression.code;
-        }
         oriType = this.removeOutermostTemplateArgs(oriType);
         if ((0, builderUtils_1.isCXXSTLContainer)(oriType)) {
             return oriType;
@@ -2164,7 +2204,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         arrayLength = (_a = dimensions[0]) !== null && _a !== void 0 ? _a : arrayLiteralExpression.inner.length;
         elementsNumber = (_b = dimensions.reduce((acc, cur) => acc * cur, 1)) !== null && _b !== void 0 ? _b : arrayLength;
         dimensions.shift();
-        isInitZero = (((_c = arrayLiteralExpression.inner) === null || _c === void 0 ? void 0 : _c.length) === 1 && arrayLiteralExpression.inner[0].code === '0' ||
+        isInitZero = (((_c = arrayLiteralExpression.inner) === null || _c === void 0 ? void 0 : _c.length) === 1 && arrayLiteralExpression.inner[0].value === '0' ||
             ((_d = arrayLiteralExpression.inner) === null || _d === void 0 ? void 0 : _d.length) === 0);
         this.getArrayLiteralExpression(arrayLiteralExpression, stmts, elementTypes, elementValues, elementPositions, dimensions, isInitZero);
         if ((0, builderUtils_1.isCxxFunctionPointer)(oriType)) {
@@ -2269,8 +2309,22 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      *@ param prefixUnaryExpression - prefix unary expression node in C++AST
      *@ returns The object containing the converted value and the generated statement list
      */
-    cxxPrefixUnaryExpressionToValueAndStmts(prefixUnaryExpression) {
-        var _a;
+    cxxPrefixIncDecToValueAndStmts(prefixUnaryExpression, operatorToken, operandValue, operandPositions, stmts) {
+        const binaryOperator = operatorToken === (0, cppUtils_1.cxxOpcodeToString)(ArkCxxAstNode_1.CxxOpcode.Inc) ?
+            Expr_1.NormalBinaryOperator.Addition : Expr_1.NormalBinaryOperator.Subtraction;
+        const binopExpr = new Expr_2.ArkCxxNormalBinOpExpr(operandValue, ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(1), binaryOperator);
+        const exprPositions = [Position_1.FullPosition.cxxBuildFromNode(prefixUnaryExpression, this.cxxSourceFile)];
+        exprPositions.push(...operandPositions, Position_1.FullPosition.DEFAULT);
+        const assignStmt = new Stmt_1.ArkAssignStmt(operandValue, binopExpr);
+        assignStmt.setOperandOriginalPositions([...operandPositions, ...exprPositions]);
+        stmts.push(assignStmt);
+        return {
+            value: operandValue,
+            valueOriginalPositions: operandPositions,
+            stmts: stmts,
+        };
+    }
+    cxxPrefixUnaryExpressionToValueAndStmts(prefixUnaryExpression, opcodeOverride) {
         const stmts = [];
         let { value: operandValue, valueOriginalPositions: operandPositions, stmts: operandStmts } = this.cxxNodeToValueAndStmts(prefixUnaryExpression.inner[0]);
         stmts.push(...operandStmts);
@@ -2282,45 +2336,33 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             } = this.ArkCxxIRTransformer.generateAssignStmtForValue(operandValue, operandPositions));
             stmts.push(...operandStmts);
         }
-        const operatorToken = (_a = prefixUnaryExpression.opcode) !== null && _a !== void 0 ? _a : ''; // Optional fields default to empty strings.
-        let exprPositions = [Position_1.FullPosition.cxxBuildFromNode(prefixUnaryExpression, this.cxxSourceFile)];
-        if (operatorToken === '++' || operatorToken === '--') {
-            const binaryOperator = operatorToken === '++' ? Expr_1.NormalBinaryOperator.Addition : Expr_1.NormalBinaryOperator.Subtraction;
-            const binopExpr = new Expr_2.ArkCxxNormalBinOpExpr(operandValue, ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(1), binaryOperator);
-            exprPositions.push(...operandPositions, Position_1.FullPosition.DEFAULT);
-            const assignStmt = new Stmt_1.ArkAssignStmt(operandValue, binopExpr);
-            assignStmt.setOperandOriginalPositions([...operandPositions, ...exprPositions]);
-            stmts.push(assignStmt);
-            return {
-                value: operandValue,
-                valueOriginalPositions: operandPositions,
-                stmts: stmts,
-            };
+        const operatorToken = opcodeOverride !== null && opcodeOverride !== void 0 ? opcodeOverride : (prefixUnaryExpression.opcode !== undefined ? (0, cppUtils_1.cxxOpcodeToString)(prefixUnaryExpression.opcode) : '');
+        if (operatorToken === (0, cppUtils_1.cxxOpcodeToString)(ArkCxxAstNode_1.CxxOpcode.Inc) || operatorToken === (0, cppUtils_1.cxxOpcodeToString)(ArkCxxAstNode_1.CxxOpcode.Dec)) {
+            return this.cxxPrefixIncDecToValueAndStmts(prefixUnaryExpression, operatorToken, operandValue, operandPositions, stmts);
         }
-        else if (operatorToken === '+') {
+        if (operatorToken === (0, cppUtils_1.cxxOpcodeToString)(ArkCxxAstNode_1.CxxOpcode.Plus)) {
             return {
                 value: operandValue,
                 valueOriginalPositions: operandPositions,
                 stmts: stmts,
             };
         }
+        let unopExpr;
+        let exprPositions = [Position_1.FullPosition.cxxBuildFromNode(prefixUnaryExpression, this.cxxSourceFile)];
+        const operator = ArkIRTransformer_1.ArkCxxIRTransformer.cxxTokenToUnaryOperator(operatorToken);
+        if (operator) {
+            unopExpr = new Expr_1.ArkUnopExpr(operandValue, operator);
+            exprPositions.push(...operandPositions);
+        }
         else {
-            let unopExpr;
-            const operator = ArkIRTransformer_1.ArkCxxIRTransformer.cxxTokenToUnaryOperator(operatorToken);
-            if (operator) {
-                unopExpr = new Expr_1.ArkUnopExpr(operandValue, operator);
-                exprPositions.push(...operandPositions);
-            }
-            else {
-                unopExpr = ValueUtil_1.CxxValueUtil.getUndefinedConst();
-                exprPositions = [Position_1.FullPosition.DEFAULT];
-            }
-            return {
-                value: unopExpr,
-                valueOriginalPositions: exprPositions,
-                stmts: stmts,
-            };
+            unopExpr = ValueUtil_1.CxxValueUtil.getUndefinedConst();
+            exprPositions = [Position_1.FullPosition.DEFAULT];
         }
+        return {
+            value: unopExpr,
+            valueOriginalPositions: exprPositions,
+            stmts: stmts,
+        };
     }
     /**
      *Convert a C++suffix unary expression to a sequence of values and statements
@@ -2328,7 +2370,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      *@ param postfixUnaryExpression - suffix unary expression node in C++AST
      *@ returns The object containing the converted value and related statements
      */
-    cxxPostfixUnaryExpressionToValueAndStmts(postfixUnaryExpression) {
+    cxxPostfixUnaryExpressionToValueAndStmts(postfixUnaryExpression, opcodeOverride) {
         var _a, _b, _c;
         const stmts = [];
         let { value: operandValue, valueOriginalPositions: operandPositions, stmts: exprStmts, } = this.cxxNodeToValueAndStmts(postfixUnaryExpression.inner[0]);
@@ -2341,12 +2383,12 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         }
         let value = undefined;
         let exprPositions = [Position_1.FullPosition.cxxBuildFromNode(postfixUnaryExpression, this.cxxSourceFile)];
-        const operatorToken = postfixUnaryExpression.opcode;
+        const operatorToken = opcodeOverride !== null && opcodeOverride !== void 0 ? opcodeOverride : (postfixUnaryExpression.opcode !== undefined ? (0, cppUtils_1.cxxOpcodeToString)(postfixUnaryExpression.opcode) : '');
         // Use temporary variables to store the value before self increment, and avoid this expression for some non assignment operation scenarios
-        if (operatorToken === '++' || operatorToken === '--') {
+        if (operatorToken === (0, cppUtils_1.cxxOpcodeToString)(ArkCxxAstNode_1.CxxOpcode.Inc) || operatorToken === (0, cppUtils_1.cxxOpcodeToString)(ArkCxxAstNode_1.CxxOpcode.Dec)) {
             const needAssign = [
-                ast_1.astKind.VarDecl, ast_1.astKind.BinaryOperator, ast_1.astKind.BinaryConditionalOperator,
-                ast_1.astKind.ConditionalOperator, ast_1.astKind.ArraySubscriptExpr,
+                ArkCxxAstNode_1.AstKind.VarDecl, ArkCxxAstNode_1.AstKind.BinaryOperator, ArkCxxAstNode_1.AstKind.BinaryConditionalOperator,
+                ArkCxxAstNode_1.AstKind.ConditionalOperator, ArkCxxAstNode_1.AstKind.ArraySubscriptExpr,
             ];
             let parent = (_c = ((_a = postfixUnaryExpression.parent) !== null && _a !== void 0 ? _a : (_b = postfixUnaryExpression.getParent) === null || _b === void 0 ? void 0 : _b.call(postfixUnaryExpression, true))) !== null && _c !== void 0 ? _c : null;
             if (parent && needAssign.includes(parent.kind)) {
@@ -2354,7 +2396,8 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
                 stmts.push(...tempStmts);
                 value = tempValue;
             }
-            const binaryOperator = operatorToken === '++' ? Expr_1.NormalBinaryOperator.Addition : Expr_1.NormalBinaryOperator.Subtraction;
+            const binaryOperator = operatorToken === (0, cppUtils_1.cxxOpcodeToString)(ArkCxxAstNode_1.CxxOpcode.Inc) ?
+                Expr_1.NormalBinaryOperator.Addition : Expr_1.NormalBinaryOperator.Subtraction;
             const binopExpr = new Expr_2.ArkCxxNormalBinOpExpr(operandValue, ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(1), binaryOperator);
             exprPositions.push(...operandPositions, Position_1.FullPosition.DEFAULT);
             const assignStmt = new Stmt_1.ArkAssignStmt(operandValue, binopExpr);
@@ -2401,9 +2444,12 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         let rightOpNode = undefined;
         if (variableDeclaration.inner !== null && variableDeclaration.inner.length !== 0) {
             rightOpNode = nodeInnerNode(variableDeclaration);
+            if ((rightOpNode === null || rightOpNode === void 0 ? void 0 : rightOpNode.kind) === ArkCxxAstNode_1.AstKind.UnsupportedKind) {
+                rightOpNode = undefined;
+            }
         }
         // In this case, the non assigned information on the right node needs to be discarded
-        if (this.isCxxArray(leftOpNode.type.qualType) && (rightOpNode === null || rightOpNode === void 0 ? void 0 : rightOpNode.kind) === ast_1.astKind.IntegerLiteral) {
+        if (this.isCxxArray(leftOpNode.type.qualType) && (rightOpNode === null || rightOpNode === void 0 ? void 0 : rightOpNode.kind) === ArkCxxAstNode_1.AstKind.IntegerLiteral) {
             rightOpNode = undefined;
         }
         const declarationType = variableDeclaration.type ? (0, builderUtils_1.cxxNode2Type)(variableDeclaration, this.declaringMethod) : Type_1.UnknownType.getInstance();
@@ -2430,7 +2476,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      */
     cxxAssignmentToValueAndStmts(leftOpNode, rightOpNode, variableDefFlag, isConst, declarationType, needRightOp = true) {
         let leftValueAndStmts;
-        if (leftOpNode.kind.toString() === ast_1.astKind.VarDecl) {
+        if (leftOpNode.kind === ArkCxxAstNode_1.AstKind.VarDecl) {
             leftValueAndStmts = this.cxxIdentifierToValueAndStmts(leftOpNode, variableDefFlag);
         }
         else {
@@ -2452,7 +2498,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
             }
             const assignStmt = new Stmt_1.ArkAssignStmt(leftValue, rightValue);
             assignStmt.setOperandOriginalPositions([...leftPositions, ...rightPositions]);
-            if (leftOpNode.kind === ast_1.astKind.InitListExpr) {
+            if (leftOpNode.kind === ArkCxxAstNode_1.AstKind.InitListExpr) {
                 stmts.push(...rightStmts);
                 stmts.push(assignStmt);
                 stmts.push(...leftStmts);
@@ -2535,9 +2581,8 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      *@ param binaryExpression - Binary expression node in C++AST
      *@ returns The ValueAndStmts object containing calculated values and related statements
      */
-    cxxBinaryExpressionToValueAndStmts(binaryExpression) {
-        var _a;
-        const operatorToken = (_a = binaryExpression.opcode) !== null && _a !== void 0 ? _a : '!=';
+    cxxBinaryExpressionToValueAndStmts(binaryExpression, opcodeOverride) {
+        const operatorToken = opcodeOverride !== null && opcodeOverride !== void 0 ? opcodeOverride : (binaryExpression.opcode !== undefined ? (0, cppUtils_1.cxxOpcodeToString)(binaryExpression.opcode) : (0, cppUtils_1.cxxOpcodeToString)(ArkCxxAstNode_1.CxxOpcode.Ne));
         const binaryExpressionLeft = binaryExpression.inner[0];
         const binaryExpressionRight = binaryExpression.inner[1];
         if (operatorToken === '=') {
@@ -2599,7 +2644,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         }
         let leftOpValue;
         let leftOpPositions;
-        const operator = this.cxxCcompoundAssignmentTokenToBinaryOperator((_a = binaryExpression.opcode) !== null && _a !== void 0 ? _a : '');
+        const operator = this.cxxCcompoundAssignmentTokenToBinaryOperator((_a = binaryExpression.opcode) !== null && _a !== void 0 ? _a : ArkCxxAstNode_1.CxxOpcode.Unknown);
         if (operator) {
             const exprValue = new Expr_2.ArkCxxNormalBinOpExpr(leftValue, rightValue, operator);
             const exprValuePosition = Position_1.FullPosition.cxxBuildFromNode(binaryExpression, this.cxxSourceFile);
@@ -2627,25 +2672,25 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      */
     cxxCcompoundAssignmentTokenToBinaryOperator(token) {
         switch (token) {
-            case CompoundBinaryOperator.AdditionEquals:
+            case ArkCxxAstNode_1.CxxOpcode.PlusAssign:
                 return Expr_1.NormalBinaryOperator.Addition;
-            case CompoundBinaryOperator.SubtractionEquals:
+            case ArkCxxAstNode_1.CxxOpcode.MinusAssign:
                 return Expr_1.NormalBinaryOperator.Subtraction;
-            case CompoundBinaryOperator.MultiplicationEquals:
+            case ArkCxxAstNode_1.CxxOpcode.MulAssign:
                 return Expr_1.NormalBinaryOperator.Multiplication;
-            case CompoundBinaryOperator.DivisionEquals:
+            case ArkCxxAstNode_1.CxxOpcode.DivAssign:
                 return Expr_1.NormalBinaryOperator.Division;
-            case CompoundBinaryOperator.RemainderEquals:
+            case ArkCxxAstNode_1.CxxOpcode.ModAssign:
                 return Expr_1.NormalBinaryOperator.Remainder;
-            case CompoundBinaryOperator.LeftShiftEquals:
+            case ArkCxxAstNode_1.CxxOpcode.ShlAssign:
                 return Expr_1.NormalBinaryOperator.LeftShift;
-            case CompoundBinaryOperator.RightShiftEquals:
+            case ArkCxxAstNode_1.CxxOpcode.ShrAssign:
                 return Expr_1.NormalBinaryOperator.RightShift;
-            case CompoundBinaryOperator.BitwiseAndEquals:
+            case ArkCxxAstNode_1.CxxOpcode.BitAndAssign:
                 return Expr_1.NormalBinaryOperator.BitwiseAnd;
-            case CompoundBinaryOperator.BitwiseOrEquals:
+            case ArkCxxAstNode_1.CxxOpcode.BitOrAssign:
                 return Expr_1.NormalBinaryOperator.BitwiseOr;
-            case CompoundBinaryOperator.BitwiseXorEquals:
+            case ArkCxxAstNode_1.CxxOpcode.BitXorAssign:
                 return Expr_1.NormalBinaryOperator.BitwiseXor;
             default:
         }
@@ -2696,37 +2741,52 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
      *@ param literalNode - an AST node representing a C++literal
      *@ returns the object containing the value, original location information and statement list. If the node type cannot be processed, null is returned
      */
+    characterLiteralText(literalNode) {
+        var _a;
+        if (literalNode.name) {
+            return literalNode.name;
+        }
+        const raw = (_a = literalNode.value) !== null && _a !== void 0 ? _a : '';
+        if (raw.length === 1) {
+            return raw;
+        }
+        const code = Number(raw);
+        if (Number.isInteger(code) && code >= 0 && code <= 127) {
+            return String.fromCharCode(code);
+        }
+        return raw;
+    }
     cxxLiteralNodeToValueAndStmts(literalNode) {
-        var _a, _b;
+        var _a;
         const stmts = [];
         const pos = [Position_1.FullPosition.cxxBuildFromNode(literalNode, this.cxxSourceFile)];
         const S = (v) => v !== null && v !== void 0 ? v : '';
         switch (literalNode.kind) {
-            case ast_1.astKind.IntegerLiteral: {
-                const num = (S(literalNode.value) || S(literalNode.code));
+            case ArkCxxAstNode_1.AstKind.IntegerLiteral: {
+                const num = S(literalNode.value);
                 const constant = ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(num ? num : 0);
                 return { value: constant, valueOriginalPositions: pos, stmts };
             }
-            case ast_1.astKind.FloatingLiteral: {
-                const num = this.parseFloatAsCxxFloat(S(literalNode.value) || S(literalNode.code));
+            case ArkCxxAstNode_1.AstKind.FloatingLiteral: {
+                const num = this.parseFloatAsCxxFloat(S(literalNode.value));
                 const constant = ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(Number.isFinite(num) ? num : 0);
                 return { value: constant, valueOriginalPositions: pos, stmts };
             }
-            case ast_1.astKind.StringLiteral: {
-                const constant = ValueUtil_1.CxxValueUtil.createStringConst(S(literalNode.value) || S(literalNode.code));
+            case ArkCxxAstNode_1.AstKind.StringLiteral: {
+                const constant = ValueUtil_1.CxxValueUtil.createStringConst(S(literalNode.value));
                 return { value: constant, valueOriginalPositions: pos, stmts };
             }
-            case ast_1.astKind.CharacterLiteral: {
-                const constant = ValueUtil_1.CxxValueUtil.createCharConst(S(literalNode.code));
+            case ArkCxxAstNode_1.AstKind.CharacterLiteral: {
+                const constant = ValueUtil_1.CxxValueUtil.createCharConst(S(this.characterLiteralText(literalNode)));
                 return { value: constant, valueOriginalPositions: pos, stmts };
             }
-            case ast_1.astKind.CXXBoolLiteralExpr: {
-                const raw = ((_b = (_a = literalNode.value) !== null && _a !== void 0 ? _a : literalNode.code) !== null && _b !== void 0 ? _b : '').toString().trim().toLowerCase();
+            case ArkCxxAstNode_1.AstKind.CXXBoolLiteralExpr: {
+                const raw = ((_a = literalNode.value) !== null && _a !== void 0 ? _a : '').toString().trim().toLowerCase();
                 const b = raw === 'true' || raw === '1';
                 const constant = ValueUtil_1.CxxValueUtil.getBooleanConstant(b);
                 return { value: constant, valueOriginalPositions: pos, stmts };
             }
-            case ast_1.astKind.CXXNullPtrLiteralExpr: {
+            case ArkCxxAstNode_1.AstKind.CXXNullPtrLiteralExpr: {
                 const constant = Constant_1.NullConstant.getInstance();
                 return { value: constant, valueOriginalPositions: pos, stmts };
             }
@@ -2737,7 +2797,7 @@ class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
         }
     }
     static isCxxCompoundAssignmentOperator(op) {
-        return !!op && COMPOUND_BIN_OPS.has(op);
+        return op !== undefined && COMPOUND_BIN_OPS.has(op);
     }
     static isRelationalBinaryOperator(op) {
         return Object.values(Expr_1.RelationalBinaryOperator).includes(op);