arkanalyzer 1.0.86 → 1.0.88

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

@@ -0,0 +1,278 @@
+import { AbstractInvokeExpr } from '../../../core/base/Expr';
+import { Stmt } from '../../../core/base/Stmt';
+import { ClassType, EnumValueType, FunctionType, GenericType, Type, UnclearReferenceType } from '../../../core/base/Type';
+import { ArkMethod } from '../../../core/model/ArkMethod';
+import { ArkExport } from '../../../core/model/ArkExport';
+import { ArkClass } from '../../../core/model/ArkClass';
+import { ArkField } from '../../../core/model/ArkField';
+import { Value } from '../../../core/base/Value';
+import { MethodSignature, MethodSubSignature } from '../../../core/model/ArkSignature';
+import { MethodParameter } from '../../../core/model/builder/ArkMethodBuilder';
+export declare class TypeInference {
+    static inferTypeInArkField(arkField: ArkField): void;
+    /**
+     * Infer type for a given unclear type.
+     * It returns an array with 2 items, original object and original type.
+     * The original object is null if there is no object, or it failed to find the object.
+     * The original type is null if failed to infer the type.
+     * @param leftOpType
+     * @param declaringArkClass
+     * @param visited
+     * @returns
+     */
+    static inferUnclearedType(leftOpType: Type, declaringArkClass: ArkClass, visited?: Set<Type>): Type | null | undefined;
+    static inferUnclearComplexType(leftOpType: Type, declaringArkClass: ArkClass, visited: Set<Type>): Type | undefined;
+    /**
+     * Type information in inference method
+     * @param arkMethod Ark method object for type inference
+     */
+    static inferTypeInMethod(arkMethod: ArkMethod): void;
+    /**
+     * Parse statement and process various references and expressions within it
+     * @param stmt Statement object to be parsed
+     * @param arkMethod Current Ark method context
+     */
+    private static resolveStmt;
+    /**
+     * @Deprecated
+     * @param arkMethod
+     */
+    static inferSimpleTypeInMethod(arkMethod: ArkMethod): void;
+    /**
+     * infer type for Exprs in stmt which invoke method.
+     * such as ArkInstanceInvokeExpr ArkStaticInvokeExpr ArkNewExpr
+     */
+    private static resolveExprsInStmt;
+    /**
+     * infer value type for TypeExprs in stmt which specify the type such as TypeQueryExpr
+     */
+    private static resolveTypeExprsInStmt;
+    /**
+     * infer type for fieldRefs in stmt.
+     */
+    private static resolveFieldRefsInStmt;
+    /**
+     *Process field references, perform corresponding conversion processing according to the reference type and statement type,
+     * process static field references, process instance field references and field references as array references,
+     * and try to replace them with local variables when the index is a string constant
+     *@param use - abstract reference object, which may be a static field reference or an instance field reference
+     *@param stmt - statement object, used to replace references
+     *@param arkMethod - Ark method object, used to obtain method body information
+     *@param replaceUse - is new fieldRef replace use
+     */
+    private static processRef;
+    private static getLocalFromMethodBody;
+    /**
+     * Parse ArkExport object into corresponding Type
+     * @param arkExport - The ArkExport object to parse, may be undefined or null
+     * @returns The parsed Type object, or null if it cannot be parsed
+     */
+    static parseArkExport2Type(arkExport: ArkExport | undefined | null): Type | null;
+    /**
+     * infer and pass type for ArkAssignStmt right and left
+     * @param stmt
+     * @param arkMethod
+     */
+    static resolveArkAssignStmt(stmt: Stmt, arkMethod: ArkMethod): void;
+    /**
+     * Resolve type inference and setting for the left operand of an assignment statement
+     *
+     * @param stmt Assignment statement node
+     * @param arkClass The current Ark class
+     * @param rightType Type of the right-hand expression in the assignment
+     * @param arkMethod The current Ark method
+     */
+    private static resolveLeftOp;
+    /**
+     * Infer the type of the left operand in an assignment statement
+     *
+     * @param arkClass Current class object
+     * @param rightType The type on the right side of the assignment statement
+     * @param leftOp The operand on the left side of the assignment
+     * @param arkMethod Current method object
+     * @param stmt Assignment statement object
+     * @returns The inferred left type, or null/undefined if it cannot be inferred
+     */
+    private static inferLeftOpType;
+    /**
+     * Set the type of value
+     *
+     * @param value The value object whose type needs to be set
+     * @param type The type to be set
+     */
+    private static setValueType;
+    /**
+     * Determine if the given type is an unclear type
+     * @param type The type to check, which can be null or undefined
+     * @returns true if the type is unclear, otherwise false
+     */
+    static isUnclearType(type: Type | null | undefined): boolean;
+    /**
+     * This is the temporal function to check Type recursively and can be removed after typeInfer supports multiple candidate types.
+     * @param type The type to check
+     * @param check Condition checking function that takes a type parameter and returns a boolean
+     * @param visited Set of visited types to prevent infinite recursion from circular references, defaults to empty set
+     * @returns true if the type meets the condition, otherwise false
+     */
+    static checkType(type: Type, check: (t: Type) => boolean, visited?: Set<Type>): boolean;
+    /**
+     * Infer simple types in a statement
+     * @param stmt The statement to perform type inference on
+     */
+    static inferSimpleTypeInStmt(stmt: Stmt): void;
+    /**
+     * Build corresponding Type object based on TypeScript type string
+     * Deal only with simple situations
+     * @param tsTypeStr TypeScript type string used to identify basic types
+     * @param cxxTypeStr Optional C++ type string used for detailed type information of number and string types
+     * @returns Returns the Type instance corresponding to the input string
+     */
+    static buildTypeFromStr(tsTypeStr: string, cxxTypeStr?: string): Type;
+    static buildTypeFromCxxNumberStr(cxxTypeStr?: string): Type;
+    static buildTypeFromCxxStringStr(cxxTypeStr?: string): Type;
+    /**
+     * Infer the type of value
+     * @param value The value whose type needs to be inferred
+     * @param arkMethod The current method context
+     * @returns The inferred type, or null if it cannot be inferred
+     */
+    static inferValueType(value: Value, arkMethod: ArkMethod): Type | null;
+    /**
+     * Infer the type of method parameters and update the parameter's type information.
+     *
+     * @param param - The parameter object whose type needs to be inferred
+     * @param arkMethod - The method object that the parameter belongs to
+     */
+    static inferParameterType(param: MethodParameter, arkMethod: ArkMethod): void;
+    /**
+     * Infer the return type of method signature and update the return type information in the signature.
+     *
+     * @param oldSignature - The method signature object whose return type needs to be inferred
+     * @param arkMethod - The method object that corresponds to the signature
+     */
+    static inferSignatureReturnType(oldSignature: MethodSignature, arkMethod: ArkMethod): void;
+    /**
+     * Infer the return type of method and update the return type information in the method.
+     *
+     * @param arkMethod - The method object whose return type needs to be inferred
+     */
+    private static inferReturnType;
+    /**
+     * Infer the type of generic type and update the generic type information.
+     *
+     * @param types - The generic type array that needs to be inferred
+     * @param arkClass - The class object that the generic type belongs to
+     */
+    static inferGenericType(types: GenericType[] | undefined, arkClass: ArkClass): void;
+    /**
+     * Infer type for a given {@link UnclearReferenceType} type.
+     * It returns original type.
+     * The original type is null if it failed to infer the type.
+     * @param urType
+     * @param arkClass
+     * @returns
+     */
+    static inferUnclearRefType(urType: UnclearReferenceType, arkClass: ArkClass): Type | null;
+    /**
+     * Find out the original object and type for a given unclear reference type name.
+     * It returns original type.
+     * The original type is null if it failed to infer the type.
+     * @param refName
+     * @param arkClass
+     * @returns
+     */
+    static inferUnclearRefName(refName: string, arkClass: ArkClass): Type | null;
+    /**
+     *Inferred field type
+     *@ param baseType Base Type
+     *@ param fieldName
+     *@ param declareClass Declare the class
+     *@ returns a tuple of attributes and types. If the inference fails, null is returned
+     */
+    static inferFieldType(baseType: Type, fieldName: string, declareClass: ArkClass): [any, Type] | null;
+    /**
+     *Infer type information of class fields
+     *@ param declareClass Declare the class object
+     *@ param baseType Basic class type
+     *@ param fieldName
+     *@ returns a tuple containing property and type information. If it cannot be inferred, it returns null
+     */
+    private static inferClassFieldType;
+    static getEnumValueType(property: ArkField): EnumValueType | null;
+    private static inferArrayFieldType;
+    /**
+     *Infer Base Type
+     *@ param baseName
+     *@ param arkClass Ark class object
+     *@ returns the inferred type. If it cannot be inferred, it returns null
+     */
+    static inferBaseType(baseName: string, arkClass: ArkClass): Type | null;
+    /**
+     *Infer type information based on type name
+     *@ param typeName - the type name to infer
+     *@ param arkClass - the current Ark class object
+     *@ returns The type object inferred. If it cannot be inferred, null is returned
+     */
+    static inferTypeByName(typeName: string, arkClass: ArkClass): Type | null;
+    /**
+     * Infer real generic types
+     *
+     * This function iterates through the passed type array, infers unclear types,
+     * and replaces the unclear types in the original array with the inferred concrete types.
+     *
+     * @param realTypes - Type array that may contain unclear types, returns directly if undefined
+     * @param arkClass - ArkClass object used for type inference
+     */
+    static inferRealGenericTypes(realTypes: Type[] | undefined, arkClass: ArkClass): void;
+    /**
+     *Infer type information of dynamic import
+     *@ param from - import source path
+     *@ param arkClass - Ark class information
+     *@ returns The type information obtained by parsing. If it cannot be parsed, null is returned
+     */
+    static inferDynamicImportType(from: string, arkClass: ArkClass): Type | null;
+    /**
+     *Replace generic parameters in type with actual types
+     *@ param type - the original type to be replaced
+     *@ param realTypes - array of actual types, used to replace generic parameters
+     *@ param visited - the accessed type collection, used to prevent circular references
+     *@ returns The actual type after replacement
+     */
+    static replaceTypeWithReal(type: Type, realTypes?: Type[], visited?: Set<Type>): Type;
+    /**
+     * Recursively replace generic parameters in types with actual types.
+     *
+     * @param type The original type to process
+     * @param visited Set of visited types to prevent infinite recursion
+     * @param realTypes List of actual types used to replace generic parameters
+     * @returns The replaced type
+     */
+    static replaceRecursiveType(type: Type, visited: Set<Type>, realTypes?: Type[]): Type;
+    /**
+     * Replace alias types with their original types
+     *
+     * This function recursively resolves alias types by following the chain of type aliases
+     * until it reaches the original underlying type. If the input type is an alias type,
+     * it will trace through to the non-alias type.
+     *
+     * @param type - The type to be replaced, which may be an alias type
+     * @returns Returns the resolved original type; if the input is not an alias type, it returns the original type directly
+     */
+    static replaceAliasType(type: Type): Type;
+    /**
+     * Infer function type for generic type inference
+     * @param argType Function argument type
+     * @param paramSubSignature Parameter sub-signature
+     * @param realTypes Array of real types
+     */
+    static inferFunctionType(argType: FunctionType, paramSubSignature: MethodSubSignature | undefined, realTypes: Type[] | undefined): void;
+    /**
+     * Resolve Ark return statement, perform type inference processing
+     * @param stmt The statement object that needs to be parsed
+     * @param arkMethod The current Ark method
+     */
+    private static resolveArkReturnStmt;
+    static inferMethodFromImportNamespace(baseType: Type, expr: AbstractInvokeExpr, arkMethod: ArkMethod, methodName: string): AbstractInvokeExpr | null;
+    static inferNestedClassType(declareClass: ArkClass, baseType: ClassType, fieldName: string): [ArkClass, Type] | null;
+}
+//# sourceMappingURL=TypeInference.d.ts.map

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

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