arkanalyzer 1.0.86 → 1.0.87

package/lib/frontend/cppFrontend/base/Type.js

@@ -0,0 +1,600 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoType = exports.CxxArrayType = exports.CxxNonType = exports.TypeInfo = exports.Thread = exports.ReferenceType = exports.ReferCategory = exports.SmartPointerType = exports.SmartPointerCategory = exports.PointerType = exports.CxxWcharType = exports.CxxCharType = exports.CxxLongDoubleType = exports.CxxDoubleType = exports.CxxFloatType = exports.CxxFloatingPointType = exports.CxxSizeTType = exports.CxxLongLongType = exports.CxxLongType = exports.CxxShortType = exports.CxxIntType = exports.CxxIntegralType = exports.CxxStdTypeName = exports.CxxTypeSigned = exports.CxxTypeBitWidth = void 0;
+const Type_1 = require("../../../core/base/Type");
+/** Enum representing the bitWidth of Cxx types. */
+var CxxTypeBitWidth;
+(function (CxxTypeBitWidth) {
+    CxxTypeBitWidth[CxxTypeBitWidth["EIGHT_BITS"] = 8] = "EIGHT_BITS";
+    CxxTypeBitWidth[CxxTypeBitWidth["SIXTEEN_BITS"] = 16] = "SIXTEEN_BITS";
+    CxxTypeBitWidth[CxxTypeBitWidth["THIRTY_TWO_BITS"] = 32] = "THIRTY_TWO_BITS";
+    CxxTypeBitWidth[CxxTypeBitWidth["SIXTY_FOUR_BITS"] = 64] = "SIXTY_FOUR_BITS";
+    CxxTypeBitWidth[CxxTypeBitWidth["UNKNOWN"] = -1] = "UNKNOWN";
+})(CxxTypeBitWidth = exports.CxxTypeBitWidth || (exports.CxxTypeBitWidth = {}));
+/** Enum representing the signedness attribute of Cxx types. */
+var CxxTypeSigned;
+(function (CxxTypeSigned) {
+    CxxTypeSigned[CxxTypeSigned["UNSIGNED"] = 0] = "UNSIGNED";
+    CxxTypeSigned[CxxTypeSigned["SIGNED"] = 1] = "SIGNED";
+    CxxTypeSigned[CxxTypeSigned["UNKNOWN"] = -1] = "UNKNOWN";
+})(CxxTypeSigned = exports.CxxTypeSigned || (exports.CxxTypeSigned = {}));
+/** Enumerate the standard library types of Cxx */
+var CxxStdTypeName;
+(function (CxxStdTypeName) {
+    CxxStdTypeName[CxxStdTypeName["CHAR"] = 1] = "CHAR";
+    CxxStdTypeName[CxxStdTypeName["SIGNED_CHAR"] = 2] = "SIGNED_CHAR";
+    CxxStdTypeName[CxxStdTypeName["UNSIGNED_CHAR"] = 3] = "UNSIGNED_CHAR";
+    CxxStdTypeName[CxxStdTypeName["WCHAR_T"] = 4] = "WCHAR_T";
+    CxxStdTypeName[CxxStdTypeName["CHAR16_T"] = 5] = "CHAR16_T";
+    CxxStdTypeName[CxxStdTypeName["CHAR32_T"] = 6] = "CHAR32_T";
+    CxxStdTypeName[CxxStdTypeName["SHORT"] = 7] = "SHORT";
+    CxxStdTypeName[CxxStdTypeName["UNSIGNED_SHORT"] = 8] = "UNSIGNED_SHORT";
+    CxxStdTypeName[CxxStdTypeName["INT"] = 9] = "INT";
+    CxxStdTypeName[CxxStdTypeName["UNSIGNED_INT"] = 10] = "UNSIGNED_INT";
+    CxxStdTypeName[CxxStdTypeName["LONG"] = 11] = "LONG";
+    CxxStdTypeName[CxxStdTypeName["UNSIGNED_LONG"] = 12] = "UNSIGNED_LONG";
+    CxxStdTypeName[CxxStdTypeName["LONG_LONG"] = 13] = "LONG_LONG";
+    CxxStdTypeName[CxxStdTypeName["UNSIGNED_LONG_LONG"] = 14] = "UNSIGNED_LONG_LONG";
+    CxxStdTypeName[CxxStdTypeName["UINT8_T"] = 15] = "UINT8_T";
+    CxxStdTypeName[CxxStdTypeName["UINT16_T"] = 16] = "UINT16_T";
+    CxxStdTypeName[CxxStdTypeName["UINT32_T"] = 17] = "UINT32_T";
+    CxxStdTypeName[CxxStdTypeName["UINT64_T"] = 18] = "UINT64_T";
+    CxxStdTypeName[CxxStdTypeName["INT8_T"] = 19] = "INT8_T";
+    CxxStdTypeName[CxxStdTypeName["INT16_T"] = 20] = "INT16_T";
+    CxxStdTypeName[CxxStdTypeName["INT32_T"] = 21] = "INT32_T";
+    CxxStdTypeName[CxxStdTypeName["INT64_T"] = 22] = "INT64_T";
+    CxxStdTypeName[CxxStdTypeName["SIZE_T"] = 23] = "SIZE_T";
+    CxxStdTypeName[CxxStdTypeName["INTPTR_T"] = 24] = "INTPTR_T";
+    CxxStdTypeName[CxxStdTypeName["UINTPTR_T"] = 25] = "UINTPTR_T";
+})(CxxStdTypeName = exports.CxxStdTypeName || (exports.CxxStdTypeName = {}));
+/**
+ * integral type in cxx, for example int, short, long and so on.
+ * @category core/base/type
+ */
+class CxxIntegralType extends Type_1.NumberType {
+    constructor(signType, bitWidth, oriTypeName) {
+        super();
+        this.signType = signType;
+        this.bitWidth = bitWidth;
+        this.oriTypeName = oriTypeName;
+    }
+    static getInstance(signType = CxxTypeSigned.UNKNOWN, size = CxxTypeBitWidth.UNKNOWN, oriTypeName) {
+        return new CxxIntegralType(signType, size, oriTypeName);
+    }
+    getSignType() {
+        return this.signType;
+    }
+    getBitWidth() {
+        return this.bitWidth;
+    }
+    getOriTypeName() {
+        return this.oriTypeName;
+    }
+}
+exports.CxxIntegralType = CxxIntegralType;
+/**
+ * int type in cxx
+ * @category core/base/type
+ */
+class CxxIntType extends CxxIntegralType {
+    static getInstance(signType, bitWidth, oriTypeName) {
+        return new CxxIntType(signType, bitWidth, oriTypeName);
+    }
+    getTypeString() {
+        if (this.oriTypeName) {
+            return cxxStdTypeNameToStr(this.oriTypeName);
+        }
+        const signStr = this.signType === CxxTypeSigned.UNSIGNED ? 'u' : '';
+        const bitStr = this.bitWidth === CxxTypeBitWidth.UNKNOWN ? '' : this.bitWidth.toString() + '_t';
+        return signStr + 'int' + bitStr;
+    }
+}
+exports.CxxIntType = CxxIntType;
+/**
+ * short type in cxx
+ * @category core/base/type
+ */
+class CxxShortType extends CxxIntegralType {
+    static getInstance(signType, bitWidth, oriTypeName) {
+        return new CxxShortType(signType, bitWidth, oriTypeName);
+    }
+    getTypeString() {
+        if (this.oriTypeName) {
+            return cxxStdTypeNameToStr(this.oriTypeName);
+        }
+        const signStr = this.signType === CxxTypeSigned.UNSIGNED ? 'unsigned ' : '';
+        return signStr + 'short';
+    }
+}
+exports.CxxShortType = CxxShortType;
+/**
+ * long type in cxx
+ * @category core/base/type
+ */
+class CxxLongType extends CxxIntegralType {
+    static getInstance(signType, bitWidth, oriTypeName) {
+        return new CxxLongType(signType, bitWidth, oriTypeName);
+    }
+    getTypeString() {
+        if (this.oriTypeName) {
+            return cxxStdTypeNameToStr(this.oriTypeName);
+        }
+        const signStr = this.signType === CxxTypeSigned.UNSIGNED ? 'unsigned ' : '';
+        return signStr + 'long';
+    }
+}
+exports.CxxLongType = CxxLongType;
+/**
+ * long long type in cxx
+ * @category core/base/type
+ */
+class CxxLongLongType extends CxxIntegralType {
+    static getInstance(signType, bitWidth, oriTypeName) {
+        return new CxxLongLongType(signType, bitWidth, oriTypeName);
+    }
+    getTypeString() {
+        if (this.oriTypeName) {
+            return cxxStdTypeNameToStr(this.oriTypeName);
+        }
+        const signStr = this.signType === CxxTypeSigned.UNSIGNED ? 'unsigned ' : '';
+        return signStr + 'long long';
+    }
+}
+exports.CxxLongLongType = CxxLongLongType;
+/**
+ * size_t type in cxx
+ * @category core/base/type
+ */
+class CxxSizeTType extends CxxIntegralType {
+    static getInstance(signType, bitWidth, oriTypeName) {
+        return new CxxSizeTType(signType, bitWidth, oriTypeName);
+    }
+    getTypeString() {
+        return 'size_t';
+    }
+}
+exports.CxxSizeTType = CxxSizeTType;
+/**
+ * floating-point types in cxx, for example float, double and so on.
+ * @category core/base/type
+ */
+class CxxFloatingPointType extends Type_1.NumberType {
+    static getInstance() {
+        return new CxxFloatingPointType();
+    }
+    getBitWith() {
+        return CxxTypeBitWidth.UNKNOWN;
+    }
+}
+exports.CxxFloatingPointType = CxxFloatingPointType;
+/**
+ * float type in cxx
+ * @category core/base/type
+ */
+class CxxFloatType extends CxxFloatingPointType {
+    static getInstance() {
+        return new CxxFloatType();
+    }
+    getTypeString() {
+        return 'float';
+    }
+    getBitWidth() {
+        return CxxTypeBitWidth.THIRTY_TWO_BITS;
+    }
+}
+exports.CxxFloatType = CxxFloatType;
+/**
+ * double type in cxx
+ * @category core/base/type
+ */
+class CxxDoubleType extends CxxFloatingPointType {
+    static getInstance() {
+        return new CxxDoubleType();
+    }
+    getTypeString() {
+        return 'double';
+    }
+    getBitWidth() {
+        return CxxTypeBitWidth.SIXTY_FOUR_BITS;
+    }
+}
+exports.CxxDoubleType = CxxDoubleType;
+/**
+ * long double type in cxx
+ * @category core/base/type
+ */
+class CxxLongDoubleType extends CxxFloatingPointType {
+    static getInstance() {
+        return new CxxLongDoubleType();
+    }
+    getTypeString() {
+        return 'long double';
+    }
+    getBitWidth() {
+        return CxxTypeBitWidth.UNKNOWN;
+    }
+}
+exports.CxxLongDoubleType = CxxLongDoubleType;
+/**
+ * char type in cxx
+ * @category core/base/type
+ */
+class CxxCharType extends Type_1.Type {
+    constructor(signType, bitWidth, oriTypeName) {
+        super();
+        this.signType = signType;
+        this.bitWidth = bitWidth;
+        this.oriTypeName = oriTypeName;
+    }
+    static getInstance(signType = CxxTypeSigned.UNKNOWN, size = CxxTypeBitWidth.UNKNOWN, oriTypeName) {
+        return new CxxCharType(signType, size, oriTypeName);
+    }
+    getSignType() {
+        return this.signType;
+    }
+    getBitWidth() {
+        return this.bitWidth;
+    }
+    getOriTypeName() {
+        return this.oriTypeName;
+    }
+    getTypeString() {
+        if (this.oriTypeName) {
+            return cxxStdTypeNameToStr(this.oriTypeName);
+        }
+        const signStr = this.signType === CxxTypeSigned.UNKNOWN ? '' : this.signType === CxxTypeSigned.SIGNED ? 'signed ' : 'unsigned ';
+        const bitStr = this.bitWidth === CxxTypeBitWidth.UNKNOWN ? '' : this.bitWidth.toString() + '_t';
+        return signStr + 'char' + bitStr;
+    }
+}
+exports.CxxCharType = CxxCharType;
+/**
+ * wchar_t type in cxx
+ * @category core/base/type
+ */
+class CxxWcharType extends CxxIntegralType {
+    static getInstance(signType = CxxTypeSigned.UNKNOWN, size = CxxTypeBitWidth.UNKNOWN, oriTypeName) {
+        return new CxxWcharType(signType, size, oriTypeName);
+    }
+    getTypeString() {
+        return 'wchar_t';
+    }
+}
+exports.CxxWcharType = CxxWcharType;
+function cxxStdTypeNameToStr(cxxStdTypeName) {
+    switch (cxxStdTypeName) {
+        case CxxStdTypeName.CHAR:
+            return 'char';
+        case CxxStdTypeName.SIGNED_CHAR:
+            return 'signed char';
+        case CxxStdTypeName.UNSIGNED_CHAR:
+            return 'unsigned char';
+        case CxxStdTypeName.WCHAR_T:
+            return 'wchar_t';
+        case CxxStdTypeName.CHAR16_T:
+            return 'char16_t';
+        case CxxStdTypeName.CHAR32_T:
+            return 'char32_t';
+        case CxxStdTypeName.SHORT:
+            return 'short';
+        case CxxStdTypeName.UNSIGNED_SHORT:
+            return 'unsigned short';
+        case CxxStdTypeName.INT:
+            return 'int';
+        case CxxStdTypeName.UNSIGNED_INT:
+            return 'unsigned int';
+        case CxxStdTypeName.LONG:
+            return 'long';
+        case CxxStdTypeName.UNSIGNED_LONG:
+            return 'unsigned long';
+        case CxxStdTypeName.LONG_LONG:
+            return 'long long';
+        case CxxStdTypeName.UNSIGNED_LONG_LONG:
+            return 'unsigned long long';
+        case CxxStdTypeName.UINT8_T:
+            return 'uint8_t';
+        case CxxStdTypeName.UINT16_T:
+            return 'uint16_t';
+        case CxxStdTypeName.UINT32_T:
+            return 'uint32_t';
+        case CxxStdTypeName.UINT64_T:
+            return 'uint64_t';
+        case CxxStdTypeName.INT8_T:
+            return 'int8_t';
+        case CxxStdTypeName.INT16_T:
+            return 'int16_t';
+        case CxxStdTypeName.INT32_T:
+            return 'int32_t';
+        case CxxStdTypeName.INT64_T:
+            return 'int64_t';
+        case CxxStdTypeName.SIZE_T:
+            return 'size_t';
+        case CxxStdTypeName.INTPTR_T:
+            return 'intptr_t';
+        case CxxStdTypeName.UINTPTR_T:
+            return 'uintptr_t';
+        default:
+            return '';
+    }
+}
+/**
+ *PointerType class represents pointer type, inherited from Type base class
+ *Pointer types used to represent C language style, such as int *, char * *, etc
+ */
+class PointerType extends Type_1.Type {
+    constructor(baseType, level) {
+        super();
+        this.isConstPointer = false; // Whether the pointer is a const pointer
+        this.isPointerToConst = false; // Whether the pointer points to a const type
+        this.isVolatilePointer = false; // Whether the pointer is a volatile pointer
+        this.isPointerToVolatileType = false; // Whether the pointer points to a volatile type
+        this.baseType = baseType;
+        this.level = level;
+    }
+    getBaseType() {
+        return this.baseType;
+    }
+    setBaseType(newBaseType) {
+        this.baseType = newBaseType;
+    }
+    getLevel() {
+        return this.level;
+    }
+    getTypeString() {
+        const strs = [];
+        if (this.baseType instanceof Type_1.UnionType) {
+            strs.push('(' + this.baseType.toString() + ')');
+        }
+        else if (this.baseType) {
+            strs.push(this.baseType.toString());
+        }
+        for (let i = 0; i < this.level; i++) {
+            strs.push('*');
+        }
+        return strs.join('');
+    }
+    getIsConstPointer() {
+        return this.isConstPointer;
+    }
+    setIsConstPointer(isConstPointer) {
+        this.isConstPointer = isConstPointer;
+    }
+    getIsPointerToConst() {
+        return this.isPointerToConst;
+    }
+    setIsPointerToConst(isPointerToConst) {
+        this.isPointerToConst = isPointerToConst;
+    }
+    getIsVolatilePointer() {
+        return this.isVolatilePointer;
+    }
+    setIsVolatilePointer(isVolatilePointer) {
+        this.isVolatilePointer = isVolatilePointer;
+    }
+    getIsPointerToVolatileType() {
+        return this.isPointerToVolatileType;
+    }
+    setIsPointerToVolatileType(isPointerToVolatileType) {
+        this.isPointerToVolatileType = isPointerToVolatileType;
+    }
+}
+exports.PointerType = PointerType;
+var SmartPointerCategory;
+(function (SmartPointerCategory) {
+    SmartPointerCategory[SmartPointerCategory["UNKNOWN"] = -1] = "UNKNOWN";
+    SmartPointerCategory[SmartPointerCategory["UNIQUE_PTR"] = 0] = "UNIQUE_PTR";
+    SmartPointerCategory[SmartPointerCategory["SHARED_PTR"] = 1] = "SHARED_PTR";
+    SmartPointerCategory[SmartPointerCategory["WEAK_PTR"] = 2] = "WEAK_PTR";
+})(SmartPointerCategory = exports.SmartPointerCategory || (exports.SmartPointerCategory = {}));
+class SmartPointerType extends PointerType {
+    constructor(baseType, level, source) {
+        let category = SmartPointerCategory.UNKNOWN;
+        super(baseType, level);
+        if (source.includes('unique')) {
+            category = SmartPointerCategory.UNIQUE_PTR;
+        }
+        else if (source.includes('shared')) {
+            category = SmartPointerCategory.SHARED_PTR;
+        }
+        else if (source.includes('weak')) {
+            category = SmartPointerCategory.WEAK_PTR;
+        }
+        this.category = category;
+    }
+    getCategory() {
+        return this.category;
+    }
+    setCategory(category) {
+        this.category = category;
+    }
+    getTypeString() {
+        const baseTypeStr = this.getBaseType().toString();
+        switch (this.category) {
+            case SmartPointerCategory.UNIQUE_PTR:
+                return `unique_ptr<${baseTypeStr}>`;
+            case SmartPointerCategory.SHARED_PTR:
+                return `shared_ptr<${baseTypeStr}>`;
+            case SmartPointerCategory.WEAK_PTR:
+                return `weak_ptr<${baseTypeStr}>`;
+            default:
+                return `smart_ptr<${baseTypeStr}>`;
+        }
+    }
+}
+exports.SmartPointerType = SmartPointerType;
+/**
+ *Reference category enumeration, used to distinguish different types of references
+ *LVALUE_REF: Left value reference, the reference type of address can be obtained
+ *RVALUE_REF: Right value reference, used to bind the reference type of temporary object
+ *UNIVERSAL_REF: universal reference, which can bind reference types of left or right values
+ */
+var ReferCategory;
+(function (ReferCategory) {
+    ReferCategory[ReferCategory["LVALUE_REF"] = 0] = "LVALUE_REF";
+    ReferCategory[ReferCategory["RVALUE_REF"] = 1] = "RVALUE_REF";
+    ReferCategory[ReferCategory["UNIVERSAL_REF"] = 2] = "UNIVERSAL_REF";
+})(ReferCategory = exports.ReferCategory || (exports.ReferCategory = {}));
+/**
+ *The ReferenceType class represents the reference type, inherited from the Type base class
+ *Used to represent the type of left value reference (&) and right value reference (&&) in C++
+ */
+class ReferenceType extends Type_1.Type {
+    constructor(bassType, category, sourceValue) {
+        super();
+        this.baseType = bassType;
+        this.category = category;
+        this.sourceValue = sourceValue;
+    }
+    getBaseType() {
+        return this.baseType;
+    }
+    setBaseType(newBaseType) {
+        this.baseType = newBaseType;
+    }
+    getCategory() {
+        return this.category;
+    }
+    setSourceValue(sourceValue) {
+        this.sourceValue = sourceValue;
+    }
+    getSourceValue() {
+        return this.sourceValue;
+    }
+    getTypeString() {
+        // Implement abstract method, return type string
+        const strs = [];
+        if (this.baseType instanceof Type_1.UnionType) {
+            strs.push('(' + this.baseType.toString() + ')');
+        }
+        else if (this.baseType) {
+            strs.push(this.baseType.toString());
+        }
+        if (this.category === ReferCategory.LVALUE_REF) {
+            strs.push('&');
+        }
+        else {
+            strs.push('&&');
+        }
+        return strs.join('');
+    }
+}
+exports.ReferenceType = ReferenceType;
+/**
+ *The Thread class inherits from the Type class and represents a thread type
+ *This class provides the basic implementation of thread types
+ */
+class Thread extends Type_1.Type {
+    constructor() {
+        super();
+    }
+    getTypeString() {
+        return 'thread ';
+    }
+}
+exports.Thread = Thread;
+class TypeInfo extends Type_1.Type {
+    constructor(name, type) {
+        super();
+        this.name = name;
+        this.type = type;
+    }
+    getName() {
+        return this.name;
+    }
+    getType() {
+        return this.type;
+    }
+    getTypeString() {
+        return this.name;
+    }
+}
+exports.TypeInfo = TypeInfo;
+class CxxNonType extends Type_1.GenericType {
+    constructor(name, defaultType, isAutoType = false) {
+        super(name, defaultType);
+    }
+}
+exports.CxxNonType = CxxNonType;
+class CxxArrayType extends Type_1.Type {
+    constructor(baseType, dimension, dimensionSizes) {
+        super();
+        this.baseType = baseType;
+        this.dimension = dimension;
+        this.dimension = dimension;
+        this.dimensionSizes = dimensionSizes || new Array(dimension).fill(0);
+    }
+    /**
+     * Returns the base type of this array, such as `Any`, `Unknown`, `TypeParameter`, etc.
+     * @returns The base type of array.
+     */
+    getBaseType() {
+        return this.baseType;
+    }
+    setBaseType(newType) {
+        this.baseType = newType;
+    }
+    getDimension() {
+        return this.dimension;
+    }
+    getDimensionSizes() {
+        return this.dimensionSizes;
+    }
+    setDimensionSizes(sizes) {
+        if (sizes.length !== this.dimension) {
+            throw new Error(`Dimension sizes length ${sizes.length} doesn't match array dimension ${this.dimension}`);
+        }
+        this.dimensionSizes = sizes;
+    }
+    getDimensionSize(index) {
+        if (index < 0 || index >= this.dimension) {
+            throw new Error(`Index ${index} out of bounds for dimension ${this.dimension}`);
+        }
+        return this.dimensionSizes[index];
+    }
+    getTypeString() {
+        const strs = [];
+        if (this.baseType instanceof Type_1.UnionType) {
+            strs.push('(' + this.baseType.toString() + ')');
+        }
+        else if (this.baseType) {
+            strs.push(this.baseType.toString());
+        }
+        for (let i = 0; i < this.dimension; i++) {
+            if (i < this.dimensionSizes.length && this.dimensionSizes[i] >= 0) {
+                strs.push(`[${this.dimensionSizes[i]}]`); // Display specific size
+            }
+            else {
+                strs.push('[]'); // No size specified
+            }
+        }
+        return strs.join('');
+    }
+}
+exports.CxxArrayType = CxxArrayType;
+class AutoType extends Type_1.Type {
+    static getInstance() {
+        return this.INSTANCE;
+    }
+    constructor() {
+        super();
+    }
+    getTypeString() {
+        return 'auto';
+    }
+}
+exports.AutoType = AutoType;
+AutoType.INSTANCE = new AutoType();

package/lib/frontend/cppFrontend/common/ArkIRTransformer.d.ts

@@ -0,0 +1,109 @@
+import { UnaryOperator } from '../../../core/base/Expr';
+import { GlobalRef } from '../../../core/base/Ref';
+import { Value } from '../../../core/base/Value';
+import { Local } from '../../../core/base/Local';
+import { ArkAliasTypeDefineStmt, Stmt } from '../../../core/base/Stmt';
+import { AliasType } from '../../../core/base/Type';
+import { ArkMethod } from '../../../core/model/ArkMethod';
+import { FullPosition } from '../../../core/base/Position';
+import { ArkIRTransformer } from '../../../core/common/ArkIRTransformer';
+import { CxxAstNode, CxxTranslationUnit } from '../ast/ArkCxxAstNode';
+export type ValueAndStmts = {
+    value: Value;
+    valueOriginalPositions: FullPosition[];
+    stmts: Stmt[];
+};
+export declare class ArkCxxIRTransformer extends ArkIRTransformer {
+    static readonly DUMMY_IF_OPERATOR_AND_SIGNAL = "If(&&)";
+    static readonly DUMMY_IF_OPERATOR_END = "IfEnd";
+    static readonly DUMMY_IF_OPERATOR_OR_SIGNAL = "If(||)";
+    private readonly cxxSourceFile;
+    private ArkCxxValueTransformer;
+    private catchedExceptions;
+    constructor(sourceFile: CxxTranslationUnit, declaringMethod: ArkMethod);
+    getLocals(): Set<Local>;
+    getGlobals(): Map<string, GlobalRef> | null;
+    getThisLocal(): Local;
+    getAliasTypeMap(): Map<string, [AliasType, ArkAliasTypeDefineStmt]>;
+    prebuildStmts(): Stmt[];
+    private shouldGenerateCxxExtraAssignStmt;
+    /** The main function for converting C++ AST nodes to Stmts */
+    cxxNodeToStmts(node: CxxAstNode): Stmt[];
+    private cxxClassDeclarationToStmts;
+    private typeDefDeclToStmts;
+    /**
+     * Extracts the target declaration node and the type string (right operand).
+     */
+    private preprocessTypeAlias;
+    /**
+     * Resolves the basic right-hand side type, handling anonymous structs/unions/enums.
+     */
+    private resolveInitialRightType;
+    /**
+     * Configures generics for template aliases and handles the 'typename' keyword.
+     */
+    private configureTemplateAndTypename;
+    /**
+     * Extracts real generic types from TemplateTypeParmDecl nodes and sets them on the expression.
+     */
+    private populateRealGenericTypes;
+    /**
+     * Constructs the final ArkAliasTypeDefineStmt and sets source positions.
+     */
+    private createAliasStmt;
+    private getAnonymousInformation;
+    private cxxParameterToStmts;
+    private cxxGenerateAliasTypeExpr;
+    private forRangeStatementToStmts;
+    private handleForRangeIterInit;
+    private handleForRangeIterBegin;
+    private handleForRangeIterEnd;
+    private handleForRangeIterResult;
+    private cxxCatchClauseToStmts;
+    /** The main function for converting C++ AST nodes to ValueAndStmts */
+    cxxNodeToValueAndStmts(node: CxxAstNode): ValueAndStmts;
+    private cxxReturnStatementToStmts;
+    private cxxExpressionStatementToStmts;
+    private cxxAddInvokeStmts;
+    /** Convert C++ switch statements to ValueAndStmts */
+    cxxSwitchStatementToValueAndStmts(switchStatement: CxxAstNode): ValueAndStmts[];
+    /**
+     * Convert C++for statement nodes to Ark IR statement arrays
+     * Under forStmt, there will be 5 child nodes. Taking for (a ; b; c) as an example,
+     * the content of block a is at node 0, if block b contains assignments, it will be at node 1,
+     * the Boolean judgment of block b is at node 2, the successor operation of block c's loop body is at node 3,
+     * and the loop body is at node 4
+     * @param forStatement -The for statement node in C++AST
+     * @returns Converted Ark IR statement array
+     */
+    private cxxForStatementToStmts;
+    private cxxWhileStatementToStmts;
+    private cxxDoStatementToStmts;
+    private expressionWithCleanup;
+    private compoundToStmts;
+    private memberCallExprToStmts;
+    private memberCallExpressionToStmts;
+    private expressionToStmts;
+    private cxxDeclStatementToStmts;
+    private decompositionDeclToStmts;
+    private cxxVariableDeclarationListToStmts;
+    cxxIfStatementToStmts(ifStatement: CxxAstNode, depth?: number, context?: {
+        conditionExpr: Value | undefined;
+    }): Stmt[];
+    private cxxThrowStatementToStmts;
+    cxxMapStmtsToTsStmt(stmts: Stmt[], node: CxxAstNode): void;
+    /**
+     * Converts a C++ token to the corresponding unary operator.
+     *
+     * @param token - The C++ token to be converted.
+     * @returns - The corresponding `UnaryOperator` if the token matches, otherwise `null`.
+     */
+    static cxxTokenToUnaryOperator(token: string): UnaryOperator | null;
+    generateAssignStmtForValue(value: Value, valueOriginalPositions: FullPosition[]): ValueAndStmts;
+    private buildTypeForUnopExpr;
+    private buildTypeForDerefExpr;
+    private buildTypeForBinOpExpr;
+    private buildTypeForArrayRefExpr;
+    setBuilderMethodContextFlag(builderMethodContextFlag: boolean): void;
+}
+//# sourceMappingURL=ArkIRTransformer.d.ts.map