arkanalyzer 1.0.86 → 1.0.87

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

@@ -0,0 +1,477 @@
+import { Value } from '../../../core/base/Value';
+import { ArkMethod } from '../../../core/model/ArkMethod';
+import { ArkCxxIRTransformer, ValueAndStmts } from './ArkIRTransformer';
+import { ArkValueTransformer } from '../../../core/common/ArkValueTransformer';
+import { CxxAstNode, CxxTranslationUnit } from '../ast/ArkCxxAstNode';
+export declare class ArkCxxValueTransformer extends ArkValueTransformer {
+    private ArkCxxIRTransformer;
+    private readonly cxxSourceFile;
+    private nodeTransformerFuncMap;
+    constructor(arkIRTransformer: ArkCxxIRTransformer, sourceFile: CxxTranslationUnit, declaringMethod: ArkMethod);
+    /**
+     *Convert C++AST nodes into a combination of values and statements
+     *@ param node - C++AST node to be converted
+     *@ returns Objects containing converted values and related statements
+     */
+    cxxNodeToValueAndStmts(node: CxxAstNode): ValueAndStmts;
+    /**
+     * Convert an unprocessed C++AST node into a combination of values and statements
+     * @param aggregate - C++AST node to be converted
+     * @returns Objects containing converted values and related statements
+     * @throws Error if the node cannot be processed
+     * For example:
+     *     struct Point q = (struct Point){.x = 5, .y = 8, .name = 'c'};
+     *     int* arr = (int[5]){1, 2, 3, 4, 5};
+     *     the right value is {},its kind is CompoundLiteralExpr or InitListExpr
+    */
+    private cxxAggregateToValueAndStmts;
+    private cxxThisExpressionToValueAndStmts;
+    private isNodeRelatedToCXXLambdaFunc;
+    private isNodeRelatedToImplicitNode;
+    private isNodeRelatedToMaterializeTemporaryExpr;
+    private isNodeRelatedToCXXMember;
+    private isPairConstructExpr;
+    private isNodeRelatedToTemporary;
+    private isNotNewExpression;
+    private isNodeRelatedToCXXFuncCast;
+    private undefinedToValueAndStmts;
+    private unprocessedNodeToValueAndStmts;
+    private cxxNamespaceRefToValueAndStmts;
+    private cxxTemporaryObjectExprToValueAndStmts;
+    /**
+     *Convert the C++construction expression node into a combination of values and statements.
+     * The main scenarios are structure and class construction, STL data structure object construction, and thread object construction
+     *@ param node - C++AST node, representing the construction expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    private cxxConstructExprToValueAndStmts;
+    bindingNodeToValueAndStmts(node: CxxAstNode, yieldValue?: Value): ValueAndStmts;
+    private processInnerNodeToValueAndStmts;
+    /**
+     *Converts an implicit conversion expression node to a combination of values and statements
+     *@ param node - C++AST node, representing implicit type conversion expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    private implicitCastExprToValueAndStmts;
+    /**
+     *Convert declaration and type reference nodes to collections of values and statements
+     *@ param node - C++AST node
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    private declAndTypeRefToValueAndStmts;
+    private staticMemberExprToValueAndStmts;
+    private materializeTemporaryExprToValueAndStmts;
+    /**
+     *Initialize a list expression into a collection of values and statements
+     *@ param node - C++abstract syntax tree node
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    private initListExprToValueAndStmts;
+    /**
+     *Convert the unary operator node into a combination of values and statements
+     *@ param node - C++AST node, representing unary operator expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    private unaryOperatorToValueAndStmts;
+    private unaryExprToValueAndStmts;
+    /**
+     *Convert user-defined literals into sets of values and statements
+     *The syntax format of user-defined literals is: original value+suffix (for example: 123_km, "hello" _s, 'a' _s)
+     *
+     *@ param userDefinedLiteral - AST node of user-defined literal
+     *@ returns The ValueAndStmts object containing the converted value and related statements
+     */
+    private userDefinedLiteralToValueAndStmts;
+    /**
+     *Convert the C++constructor initialization list node to a collection of values and statements
+     *  1. C++uses the initialization list to initialize class member variables: Base (char pname): name (pname) {...}.
+     *         The final effect is similar to this ->name=pname, which is also processed as an assignment here
+     *  2. using parent::parent， The constructor of the subclass calls the constructor inherited from the parent class
+     *@ param cxxCtorInitializer C++constructor initializes list nodes
+     *@ returns An object containing a collection of values and statements
+     */
+    private cxxCtorInitializerToValueAndStmts;
+    /**
+     *Convert the C++inheritance constructor initialization expression to a collection of values and statements
+     * Using parent:: parent==>The constructor of the sub——class calls the constructor inherited from the parent
+     * class==>The same as calling the constructor of the parent class directly
+     *@ param cxxInheritedCtorInitExpr - C++inheritance constructor initialization expression node
+     *@ returns The object containing the converted value and statement array
+     */
+    private cxxInheritedCtorInitExprToValueAndStmts;
+    /**
+     *Convert super expression in C++to IR
+     * C++subclasses call the parent class constructor for initialization,
+     * similar to ts super (xx). For example, Left (const char&name, int power): Base (name) {...}
+     *@ param cxxConstructExpr C++construction expression node
+     *@ returns The ValueAndStmts object containing the converted value and related statements
+     */
+    private cxxSuperExpressionToValueAndStmts;
+    /**
+     *Convert array type characteristic expression to IR
+     * ArrayTypeTraitExpr is processed by function call
+     *@ param ArrayTypeTraitExpr - C++AST node, representing array type characteristic expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    private arrayTypeTraitExprToValueAndStmts;
+    /**
+     * Convert C++typeid expression to IR, And CXXTypeidExpr is processed by function call.
+     *@ param CXXTypeidExpr - typeid expression node in C++AST
+     *@ returns Objects containing converted values and related statements
+     */
+    private cxxTypeidExprToValueAndStmts;
+    /**
+     *Convert the noexcept expression of C++syntax tree to IR
+     *@ param CXXNoexceptExpr - AST node representing C++noexcept expression
+     *@ returns Objects containing converted values and related statements
+     */
+    private cxxNoexceptExprToValueAndStmts;
+    /**
+     *Process the C++scalar value initialization expression and convert it to IR
+     *@ param CXXScalarValueInitExpr - C++abstract syntax tree node, representing scalar value initialization expression
+     *@ returns an object containing initialization values and related statements. If it cannot be processed, it returns null
+     */
+    private cxxScalarValueInitToValueAndStmts;
+    /**
+     *Convert C++delete expression to IR
+     *@ param deleteExpression - C++AST node, representing delete expression
+     *@ returns The object containing the converted value and statement array
+     */
+    private cxxDeleteExpressionToValueAndStmts;
+    /**
+     *Convert C++type conversion expression to IR
+     *@ param castExpression C++AST node, representing type conversion expression
+     *@ returns ValueAndStmts object, including converted values, original location information and related statements
+     */
+    private castExpressionToValueAndStmts;
+    private cxxFoldExprToValueAndStmts;
+    /**
+     *Convert C++conditional expression to IR
+     *@ param conditionalExpression - C++AST node, representing conditional expression
+     *@ returns ValueAndStmts object, including converted values, original location information and related statements
+     */
+    private cxxConditionalExpressionToValueAndStmts;
+    /**
+     *Extract the calling node and parameter node from the internal AST node array for overwriting
+     *@ param innerAsNodes An AST node array containing call information and parameters. The first element is the call node, and the rest are parameter nodes
+     *@ returns an array containing two elements: the first element is the call node, and the second element is the parameter node array
+     */
+    private getArgumentNodeForRecover;
+    private getArgumentNode;
+    private getDeclRef;
+    private cxxGenerateSystemComponentStmt;
+    private cxxGenerateCustomViewStmt;
+    private cxxGenerateComponentCreationStmts;
+    /**
+     *Convert C++identifiers to collections of values and statements
+     *@ param identifier C++AST node identifier
+     *@ param variableDefFlag Optional variable definition flag, used to distinguish variable declaration from variable use
+     *@ returns Objects containing values, location information and statement arrays
+     */
+    private cxxIdentifierToValueAndStmts;
+    /**
+     *Convert the member expression of C++(such as testMap. insert) to ValueAndStmts of Ark IR
+     *@ param memberExpression - shaped like an AST MemberExpr/MemberRef node, which usually means obj. field or obj ->field
+     *@ param localValue - (Optional) The scenario where the baseValue is specified directly (
+     *  such as determining the base in advance when resolving the parent node)
+     */
+    private memberExpressionToValueAndStmts;
+    private buildFieldSignatureFromMemberExpr;
+    /**
+     *Convert element access expressions (such as array [index] or object. field) in C++AST to values and statements in intermediate representation (IR).
+     *
+     *@ param elementAccessExpression represents the AST node of C++element access expression
+     *@ returns contains the generated IR value, original location information and the ValueAndStmts object of related statements
+     */
+    private cxxElementAccessExpressionToValueAndStmts;
+    private cxxCallExpressionToValueAndStmts;
+    /**
+     *Process the 'cout<<...' or lambda expression in C++, extract its operands and construct corresponding statements and values.
+     *
+     *@ param callExpression - The currently processed C++AST node, which represents an operator calling expression (such as<<).
+     *@ param callArgus - An array used to collect the parameter nodes involved in the expression.
+     *@ returns the ValueAndStmts object containing values and statements. If it cannot be processed, it returns null.
+     */
+    private streamOrLambdaExprToValueAndStmts;
+    /**
+     *Build a collection of values and statements for stream operations or lambda function call
+     *
+     *@ param streamNode The AST node of the stream node
+     *@ param args parameter array of stream operation
+     *@ param stmts statement array
+     *@ param streamExpr AST node of stream expression
+     *@ returns The ValueAndStmts object containing values and statements
+     */
+    private buildValueAndStmtsForStreamOrLambdaCall;
+    /**
+     *Build values and statements of overloaded flow operators
+     *@ param streamNode
+     *@ param overloadedArg overload parameter node
+     *@ param currValueAndStmts Current value and statement collection
+     */
+    private buildValueAndStmtsForOverloadedStream;
+    /**
+     *Build a collection of values and statements for standard flow or lambda call nodes
+     *@ param streamNode - AST node of the stream node
+     *@ param nonOverlooadedArgs - non overloaded parameter array
+     *@ param streamExpr - AST node of stream expression
+     *@ param currValueAndStmts - current value and statement collection object, used to store processing results
+     */
+    private buildValueAndStmtsForStdStreamOrLambdaCall;
+    /**
+     *Convert C++operator expression to binary operator expression
+     *@ param expression - C++AST node, representing operator expression
+     *@ returns the converted values and statements
+     */
+    private CXXOperatorExpressionToBinaryOperator;
+    /**
+     *Convert C++operator expression to unary operator expression
+     *@ param expression - C++AST node, representing operator expression
+     *@ returns ValueAndStmts object, including converted values and statements
+     */
+    private CXXOperatorExpressionToUnaryOperator;
+    /**
+     *Convert C++operator expressions to lists of values and statements
+     *@ param callExpression - C++AST node, representing the operator expression to be converted
+     *@ param layer - Boolean value, which controls whether to process the final output layer. The default value is true
+     *@ returns a list of converted values and statements, which may include special operator processing results or array reference expressions
+     */
+    private cxxOperatorExpressionToValueAndStmts;
+    /**
+     * Handle special operator scenarios and return early if matched
+     */
+    private handleSpecialOperators;
+    /**
+     * Collect ValueAndStmts from each inner node
+     */
+    private collectInnerOperatorStmts;
+    private getOverloadOpName;
+    /**
+     *Handling C++overloaded operator call expressions
+     *@ param cxxOperatorCallExpr C++AST node, representing operator calling expression
+     *@ returns the processed value and statement object. If it cannot be processed, it returns null
+     */
+    private handleOverloadedOp;
+    /**
+     *Build values and statements called by overloaded flow operators, such as<<or>>.
+     * Call IR for the function corresponding to the overload construction of the input/output stream operators operator<<, operator>>
+     *This function is used to handle operator overloading call expressions in C++, especially for input/output stream operators.
+     *It will parse parameters, find matching Ark methods, and generate corresponding call expressions.
+     *
+     *@ param cxxOperatorCallExpr represents the AST node of the C++operator call expression
+     *@ returns an object containing values and statements. If it cannot be constructed, it returns null
+     */
+    private buildInvokeValueForOverloadedStreamOp;
+    private buildInvokeValueForNormalOverloadedOp;
+    private RecoverExpressionToValueAndStmts;
+    /**
+     *Generate the value and statement block of the C++call expression (ValueAndStmts).
+     *
+     *@ param functionNameNode - the node corresponding to the function name, which is used to resolve the caller information.
+     *@ param argus - The object containing the actual generic type, parameter value list, and parameter location information.
+     *- realGenericTypes: list of actual generic types.
+     *- args: parameter value list.
+     *- argPositions: The location information of the parameter in the source code.
+     *@ param currStmts - List of existing statements. The newly generated statements will be appended on this basis.
+     *@ param callExpression - represents the AST node of the call expression, which is used to obtain the call location information.
+     *@ returns a ValueAndStmts object that contains the call value, value location information, and related statements.
+     */
+    private cxxGenerateInvokeValueAndStmts;
+    /**
+     *IR Processing of C++Function Calls
+     *@ param callExpression - C++AST node, representing member call expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    private cxxMemberCallExpressionToValueAndStmts;
+    /**
+     *Build values and statements called by members
+     *@ param stmts statement array, used to collect generated statements
+     *@ param callerNode Caller Node
+     *@ param argNodes parameter node array
+     *@ param callExpression calls the expression node
+     *@ param realGenericTypes Actual generic type array
+     *@ returns The ValueAndStmts object containing values, location information, and statements
+     */
+    private buildValueAndStmtsForMemberCall;
+    /**
+     *Build the call value referenced by the field
+     *
+     *@ param callerValue The caller value indicates the field reference
+     *@ param args calls the parameter array
+     *@ param realGenericTypes The actual generic type array may be undefined
+     *@ param invokeValuePositions calls the value position information array
+     *@ param callerPositions Caller position information array
+     *@ returns the ArkInstanceFieldRef or ArkStaticInvokeExpr instance
+     */
+    private buildInvokeValueForFieldRef;
+    private buildInvokeValueForLocal;
+    private cxxParseArgumentsOfCallExpression;
+    private getRealGenericTypes;
+    /**
+     * Resolves the type string based on priority (provided qualType > desugared > default).
+     */
+    private getTargetQualType;
+    /**
+     * Splits template arguments by comma, but remains aware of nested brackets
+     * to prevent incorrect splitting of nested templates.
+     */
+    private splitTemplateArguments;
+    private cxxParseArguments;
+    private cxxCallableNodeToValueAndStmts;
+    private cxxNewExpressionToValueAndStmts;
+    /**
+     *Generate C++code representation of constructor calls and member initialization, and add related statements to stmts.
+     * Extracted tail logic: construction call+special case processing+member initialization
+     *@ param stmts - an array that stores the generated statement nodes
+     *@ param newExpression - C++AST node representing new expression
+     *@ param newLocal - local variable representing the newly created object
+     *@ param newLocalPositions - the location information of the new local variable in the source code
+     *@ param constructorMethodSignature - constructor's method signature
+     *@ param className - the name of the current class, which is used for special processing of certain types (such as napi_property_descriptor)
+     */
+    private cxxEmitCtorInvokeAndMemberInits;
+    private getConstructorSignatureByClassTypeAndArgs;
+    /**
+     *Get the constructor parameter list, and process parameter resolution and conversion of various AST node types
+     *@ param constructArgs constructor parameter, which can be a single AST node or AST node array
+     *@ returns The constructor parameter array after parsing
+     */
+    private getConstructArgs;
+    /**
+     *Get the class name of the new expression
+     *@ param newExpression - new expression node of CxxAstNode type
+     *@ returns the processed class name string
+     */
+    private getNewExpressionClassName;
+    /**
+     *Remove the outermost template parameter (angle brackets and their contents) from the string
+     *@ param typeStr is a type string containing template parameters
+     *@ returns string after removing the outermost template parameter
+     */
+    private removeOutermostTemplateArgs;
+    /**
+     *Convert the new array expression of C++to ValueAndStmts
+     *@ param newArrayExpression - C++AST node, representing new array expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    private cxxNewArrayExpressionToValueAndStmts;
+    /**
+     *Convert C++array literal expression to ValueAndStmts
+     *@ param arrayLiteralExpression - Array literal node in C++abstract syntax tree
+     *@ returns The ValueAndStmts object containing the converted value and related statements
+     */
+    private cxxArrayLiteralExpressionToValueAndStmts;
+    private getArrayDimensions;
+    /**
+     *Process array literal expression and convert it to intermediate representation
+     *@ param arrayLiteralExpression array literal expression node
+     *@ param stmts is used to collect the generated statement list
+     *@ param elementTypes is used to collect the collection of array element types
+     *@ param elementValues is used to collect the list of array element values
+     *@ param elementPositions is used to collect the list of array element position information
+     */
+    private getArrayLiteralExpression;
+    /**
+     *Generate IR expressed by C++array
+     *
+     *@ param baseType - the basic type of the array element
+     *@ param arrayLengthValue - value object of array length
+     *@ param arrayLengthPosition - position information of array length
+     *@ param arrayLength - the actual length of the array
+     *@ param initializerValues - array initialization value list
+     *@ param initializerPositions - List of location information of initialization values
+     *@ param currStmts - List of existing statements
+     *@ param newArrayExprPosition - position information of the new array expression
+     *@ param fromLiteral - whether from literal
+     *@ returns The ValueAndStmts object containing values and statements
+     */
+    private cxxGenerateArrayExprAndStmts;
+    /**
+     *Converts C++prefix unary expression nodes to IR values and statement lists.
+     *
+     *@ param prefixUnaryExpression - prefix unary expression node in C++AST
+     *@ returns The object containing the converted value and the generated statement list
+     */
+    private cxxPrefixUnaryExpressionToValueAndStmts;
+    /**
+     *Convert a C++suffix unary expression to a sequence of values and statements
+     *
+     *@ param postfixUnaryExpression - suffix unary expression node in C++AST
+     *@ returns The object containing the converted value and related statements
+     */
+    private cxxPostfixUnaryExpressionToValueAndStmts;
+    declStmtToValueAndStmts(decl: CxxAstNode): ValueAndStmts;
+    /**
+     *Convert C++variable declarations to combinations of values and statements
+     *@ param variableDeclaration - C++variable declaration node
+     *@ param isConst - whether it is a constant declaration
+     *@ param needRightOp - Whether the right operand is required, the default is true
+     *@ returns the ValueAndStmts object containing values and statements
+     */
+    cxxVariableDeclarationToValueAndStmts(variableDeclaration: CxxAstNode, needRightOp?: boolean): ValueAndStmts;
+    private isCxxArray;
+    /**
+     *Process C++assignment expressions and convert them into ValueAndStmts structures.
+     *
+     *@ param leftOpNode The AST node of the left operand
+     *@ param rightOpNode The AST node of the right operand, which may be undefined
+     *@ param variableDefFlag indicates whether the variable is defined
+     *@ param isConst indicates whether it is a constant
+     *@ param declarationType Declared type
+     *@ param needRightOp Whether to process the right operand, the default is true
+     *@ returns the ValueAndStmts object containing the value, original position and statement list
+     */
+    private cxxAssignmentToValueAndStmts;
+    /**
+     *CPP implementation of converting the right operand node to a list of values and statements
+     *@ param rightOpNode The AST node of the right operand, which may be undefined
+     *@ param leftValue Left value object
+     *@ returns Objects containing values, location information, and statement lists
+     */
+    private cxxAssignmentRightOpToValueAndStmts;
+    /**
+     *Convert the C++AST node to a single address value and statement list
+     *@ param node - C++AST node to be converted
+     *@ returns An object containing a list of values, original positions, and statements
+     */
+    private cxxNodeToSingleAddressValueAndStmts;
+    /**
+     *Converts a C++binary expression node to a list of values and statements.
+     *In assignment patterns, the left operand will be an array literal expression
+     *In assignment patterns, the left operand will be an object literal expression
+     *@ param binaryExpression - Binary expression node in C++AST
+     *@ returns The ValueAndStmts object containing calculated values and related statements
+     */
+    private cxxBinaryExpressionToValueAndStmts;
+    /**
+     *Convert compound assignment expressions (such as+=, -=, etc.) in C++to values and statement lists in intermediate representation (IR).
+     *
+     *@ param binaryExpression represents the C++AST node of the compound assignment operation
+     *@ returns an object containing the calculated value, the original location information, and the generated statement list
+     */
+    private cxxCompoundAssignmentToValueAndStmts;
+    /**
+     *Convert the compound assignment operator to the corresponding binary operator
+     *
+     *@ param token - compound assignment operator string
+     *@ returns The corresponding binary operator. If no match is found, null is returned
+     */
+    private cxxCcompoundAssignmentTokenToBinaryOperator;
+    /**
+     *Convert C++conditional expression nodes to a combination of values and statements
+     *@ param condition - Condition node in C++abstract syntax tree
+     *@ returns Objects containing conditional expression values and related statements
+     */
+    cxxConditionToValueAndStmts(condition: CxxAstNode): ValueAndStmts;
+    private parseFloatAsCxxFloat;
+    /**
+     *Convert literal nodes in C++AST into corresponding value and statement lists.
+     *Literals currently processed: integer, floating point, string, character, Boolean value, null pointer, address label
+     *@ 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
+     */
+    private cxxLiteralNodeToValueAndStmts;
+    static isCxxCompoundAssignmentOperator(op?: string): boolean;
+    private static isRelationalBinaryOperator;
+}
+//# sourceMappingURL=ArkValueTransformer.d.ts.map

package/lib/frontend/cppFrontend/common/ArkValueTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArkValueTransformer.d.ts","sourceRoot":"","sources":["../../../../src/frontend/cppFrontend/common/ArkValueTransformer.ts"],"names":[],"mappings":"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"}