arkanalyzer 1.0.6 → 1.0.8

package/lib/core/common/TypeInference.js

@@ -61,27 +61,28 @@ class TypeInference {
         const arkClass = arkField.getDeclaringArkClass();
         const stmts = arkField.getInitializer();
         let rightType;
-        let fieldRef = undefined;
-        if (stmts) {
-            for (const stmt of stmts) {
-                this.resolveExprsInStmt(stmt, arkClass);
-                this.resolveFieldRefsInStmt(stmt, arkClass, arkClass.getMethodWithName('@instance_init'));
-                this.resolveArkAssignStmt(stmt, arkClass);
-            }
-            const lastStmt = stmts[stmts.length - 1];
-            if (lastStmt instanceof Stmt_1.ArkAssignStmt) {
-                rightType = lastStmt.getRightOp().getType();
-                if (lastStmt.getLeftOp() instanceof Ref_1.AbstractFieldRef) {
-                    fieldRef = lastStmt.getLeftOp();
-                }
+        let fieldRef;
+        const method = arkClass.getMethodWithName(Const_1.INSTANCE_INIT_METHOD_NAME);
+        for (const stmt of stmts) {
+            if (method) {
+                this.resolveExprsInStmt(stmt, method);
+                this.resolveFieldRefsInStmt(stmt, method);
             }
+            this.resolveArkAssignStmt(stmt, arkClass);
         }
         const beforeType = arkField.getType();
-        let fieldType;
-        if (arkField.getCategory() === ArkField_1.FieldCategory.ENUM_MEMBER) {
-            fieldType = new Type_1.ClassType(arkClass.getSignature());
+        if (!this.isUnclearType(beforeType)) {
+            return;
         }
-        else if (beforeType) {
+        const lastStmt = stmts[stmts.length - 1];
+        if (lastStmt instanceof Stmt_1.ArkAssignStmt) {
+            rightType = lastStmt.getRightOp().getType();
+            if (lastStmt.getLeftOp() instanceof Ref_1.AbstractFieldRef) {
+                fieldRef = lastStmt.getLeftOp();
+            }
+        }
+        let fieldType;
+        if (beforeType) {
             fieldType = this.inferUnclearedType(beforeType, arkClass, rightType);
         }
         if (fieldType) {
@@ -96,7 +97,7 @@ class TypeInference {
     static inferUnclearedType(leftOpType, declaringArkClass, rightType) {
         let type;
         if (leftOpType instanceof Type_1.UnclearReferenceType) {
-            type = this.inferUnclearReferenceType(leftOpType.getName(), declaringArkClass);
+            type = this.inferUnclearRefType(leftOpType, declaringArkClass);
         }
         else if (leftOpType instanceof Type_1.ClassType
             && leftOpType.getClassSignature().getDeclaringFileSignature().getFileName() === Const_1.UNKNOWN_FILE_NAME) {
@@ -116,10 +117,10 @@ class TypeInference {
                 else {
                     newType = optionType;
                 }
-                if (newType && newType != optionType) {
+                if (newType) {
                     types[i] = newType;
                 }
-                if (rightType && newType && newType === rightType) {
+                if (rightType && newType && newType.constructor === rightType.constructor) {
                     leftOpType.setCurrType(rightType);
                     type = leftOpType;
                 }
@@ -145,24 +146,42 @@ class TypeInference {
         return type;
     }
     static inferTypeInMethod(arkMethod) {
-        var _a;
+        var _a, _b;
+        const arkClass = arkMethod.getDeclaringArkClass();
+        this.inferGenericType(arkMethod.getGenericTypes(), arkClass);
+        const signatures = [];
+        (_a = arkMethod.getDeclareSignatures()) === null || _a === void 0 ? void 0 : _a.forEach(m => signatures.push(m));
+        const impl = arkMethod.getImplementationSignature();
+        if (impl) {
+            signatures.push(impl);
+        }
+        signatures.forEach(s => {
+            s.getMethodSubSignature().getParameters().forEach(p => {
+                const type = TypeInference.inferUnclearedType(p.getType(), arkClass);
+                if (type) {
+                    p.setType(type);
+                }
+            });
+            const type = TypeInference.inferUnclearedType(s.getMethodSubSignature().getReturnType(), arkClass);
+            if (type) {
+                s.getMethodSubSignature().setReturnType(type);
+            }
+        });
         const body = arkMethod.getBody();
         if (!body) {
             logger.warn('empty body');
             return;
         }
-        const arkClass = arkMethod.getDeclaringArkClass();
-        (_a = body.getAliasTypeMap()) === null || _a === void 0 ? void 0 : _a.forEach((value) => this.inferUnclearedType(value[0], arkClass));
+        (_b = body.getAliasTypeMap()) === null || _b === void 0 ? void 0 : _b.forEach((value) => this.inferUnclearedType(value[0], arkClass));
         this.inferGenericType(arkMethod.getGenericTypes(), arkClass);
         const cfg = body.getCfg();
         for (const block of cfg.getBlocks()) {
             for (const stmt of block.getStmts()) {
-                this.resolveExprsInStmt(stmt, arkClass);
-                this.resolveFieldRefsInStmt(stmt, arkClass, arkMethod);
+                this.resolveExprsInStmt(stmt, arkMethod);
+                this.resolveFieldRefsInStmt(stmt, arkMethod);
                 this.resolveArkAssignStmt(stmt, arkClass);
             }
         }
-        this.inferMethodReturnType(arkMethod);
     }
     /**
      * @Deprecated
@@ -185,10 +204,10 @@ class TypeInference {
      * infer type for Exprs in stmt which invoke method.
      * such as ArkInstanceInvokeExpr ArkStaticInvokeExpr ArkNewExpr
      */
-    static resolveExprsInStmt(stmt, arkClass) {
+    static resolveExprsInStmt(stmt, arkMethod) {
         const exprs = stmt.getExprs();
         for (const expr of exprs) {
-            const newExpr = expr.inferType(arkClass);
+            const newExpr = expr.inferType(arkMethod);
             if (stmt.containsInvokeExpr() && expr instanceof Expr_1.ArkInstanceInvokeExpr && newExpr instanceof Expr_1.ArkStaticInvokeExpr) {
                 if (stmt instanceof Stmt_1.ArkAssignStmt && stmt.getRightOp() instanceof Expr_1.ArkInstanceInvokeExpr) {
                     stmt.setRightOp(newExpr);
@@ -202,57 +221,50 @@ class TypeInference {
     /**
      * infer type for fieldRefs in stmt.
      */
-    static resolveFieldRefsInStmt(stmt, arkClass, arkMethod) {
-        var _a;
+    static resolveFieldRefsInStmt(stmt, arkMethod) {
         for (const use of stmt.getUses()) {
             if (use instanceof Ref_1.AbstractRef) {
-                const fieldRef = use.inferType(arkClass);
-                if (fieldRef instanceof Ref_1.ArkStaticFieldRef && stmt instanceof Stmt_1.ArkAssignStmt) {
-                    if (stmt.getRightOp() instanceof Ref_1.ArkInstanceFieldRef) {
-                        stmt.setRightOp(fieldRef);
-                    }
-                    else {
-                        stmt.replaceUse(use, fieldRef);
-                        stmt.setRightOp(stmt.getRightOp());
-                    }
-                }
-                else if (use instanceof Ref_1.ArkInstanceFieldRef && fieldRef instanceof Ref_1.ArkArrayRef && stmt instanceof Stmt_1.ArkAssignStmt) {
-                    const index = fieldRef.getIndex();
-                    if (index instanceof Constant_1.Constant && index.getType() instanceof Type_1.StringType) {
-                        const local = (_a = arkMethod === null || arkMethod === void 0 ? void 0 : arkMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(index.getValue());
-                        if (local) {
-                            fieldRef.setIndex(local);
-                        }
-                    }
-                    stmt.replaceUse(use, fieldRef);
-                    stmt.setRightOp(stmt.getRightOp());
-                }
+                this.processRef(use, stmt, arkMethod);
             }
         }
         const stmtDef = stmt.getDef();
         if (stmtDef && stmtDef instanceof Ref_1.AbstractRef) {
-            const fieldRef = stmtDef.inferType(arkClass);
+            const fieldRef = stmtDef.inferType(arkMethod);
             if (fieldRef instanceof Ref_1.ArkStaticFieldRef && stmt instanceof Stmt_1.ArkAssignStmt) {
                 stmt.setLeftOp(fieldRef);
             }
         }
     }
-    static parseArkExport2Type(arkExport) {
+    static processRef(use, stmt, arkMethod) {
         var _a;
+        const fieldRef = use.inferType(arkMethod);
+        if (fieldRef instanceof Ref_1.ArkStaticFieldRef && stmt instanceof Stmt_1.ArkAssignStmt) {
+            if (stmt.getRightOp() instanceof Ref_1.ArkInstanceFieldRef) {
+                stmt.setRightOp(fieldRef);
+            }
+            else {
+                stmt.replaceUse(use, fieldRef);
+                stmt.setRightOp(stmt.getRightOp());
+            }
+        }
+        else if (use instanceof Ref_1.ArkInstanceFieldRef && fieldRef instanceof Ref_1.ArkArrayRef && stmt instanceof Stmt_1.ArkAssignStmt) {
+            const index = fieldRef.getIndex();
+            if (index instanceof Constant_1.Constant && index.getType() instanceof Type_1.StringType) {
+                const local = (_a = arkMethod === null || arkMethod === void 0 ? void 0 : arkMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(index.getValue());
+                if (local) {
+                    fieldRef.setIndex(local);
+                }
+            }
+            stmt.replaceUse(use, fieldRef);
+            stmt.setRightOp(stmt.getRightOp());
+        }
+    }
+    static parseArkExport2Type(arkExport) {
         if (!arkExport) {
             return null;
         }
         if (arkExport instanceof ArkClass_1.ArkClass) {
-            return new Type_1.ClassType(arkExport.getSignature(), (_a = arkExport.getGenericsTypes()) === null || _a === void 0 ? void 0 : _a.map((x, index) => {
-                let defaultType = x.getDefaultType();
-                if (defaultType instanceof Type_1.UnclearReferenceType) {
-                    const newType = TypeInference.inferUnclearReferenceType(defaultType.getName(), arkExport);
-                    if (newType) {
-                        defaultType = newType;
-                    }
-                }
-                return defaultType !== null && defaultType !== void 0 ? defaultType : Type_1.UndefinedType.getInstance();
-            }));
+            return new Type_1.ClassType(arkExport.getSignature(), arkExport.getGenericsTypes());
         }
         else if (arkExport instanceof ArkNamespace_1.ArkNamespace) {
             let namespaceType = new Type_1.AnnotationNamespaceType(arkExport.getName());
@@ -298,28 +310,44 @@ class TypeInference {
             }
         }
         const leftOp = stmt.getLeftOp();
-        if (leftOp instanceof Local_1.Local) {
-            const leftOpType = leftOp.getType();
-            let type = this.inferUnclearedType(leftOpType, arkClass, rightOp.getType());
-            if (type) {
-                leftOp.setType(type);
-            }
-            else if (rightOp instanceof Ref_1.ArkThisRef) {
-                leftOp.setType(rightOp.getType());
-            }
-            else if (this.isUnclearType(leftOpType) && !this.isUnclearType(stmt.getRightOp().getType())) {
-                leftOp.setType(stmt.getRightOp().getType());
+        let type = leftOp.getType();
+        if (this.isUnclearType(type)) {
+            type = this.inferUnclearedType(type, arkClass, rightOp.getType());
+        }
+        if (type instanceof Type_1.UnionType &&
+            !this.isUnclearType(rightOp.getType()) && !(leftOp instanceof Ref_1.ArkArrayRef)) {
+            const cur = type.getTypes().find(t => rightOp.getType().constructor === t.constructor);
+            if (cur) {
+                type.setCurrType(cur);
             }
         }
+        if (this.isUnclearType(type) && !this.isUnclearType(rightOp.getType())) {
+            type = rightOp.getType();
+        }
+        if (type && leftOp instanceof Local_1.Local) {
+            leftOp.setType(type);
+        }
+        else if (type && leftOp instanceof Ref_1.AbstractFieldRef) {
+            leftOp.getFieldSignature().setType(type);
+        }
     }
     static isUnclearType(type) {
         if (!type || type instanceof Type_1.UnknownType || type instanceof Type_1.UnclearReferenceType) {
             return true;
         }
         else if (type instanceof Type_1.ClassType
-            && type.getClassSignature().getDeclaringFileSignature().getFileName() === '_UnknownFileName') {
+            && type.getClassSignature().getDeclaringFileSignature().getFileName() === Const_1.UNKNOWN_FILE_NAME) {
             return true;
         }
+        else if (type instanceof Type_1.UnionType) {
+            return !!type.getTypes().find(t => t instanceof Type_1.UnclearReferenceType);
+        }
+        else if (type instanceof Type_1.ArrayType) {
+            return (type.getBaseType() instanceof Type_1.UnclearReferenceType);
+        }
+        else if (type instanceof Type_1.AliasType) {
+            return (type.getOriginalType() instanceof Type_1.UnclearReferenceType);
+        }
         return false;
     }
     static inferSimpleTypeInStmt(stmt) {
@@ -353,40 +381,58 @@ class TypeInference {
                 return Type_1.VoidType.getInstance();
             case 'never':
                 return Type_1.NeverType.getInstance();
-            case 'RegularExpression':
+            case 'RegularExpression': {
                 const classSignature = Builtin_1.Builtin.REGEXP_CLASS_SIGNATURE;
                 return new Type_1.ClassType(classSignature);
+            }
             default:
                 return new Type_1.UnclearReferenceType(typeStr);
         }
     }
-    static inferValueType(value, arkClass) {
+    static inferValueType(value, arkMethod) {
         if (value instanceof Ref_1.ArkInstanceFieldRef || value instanceof Expr_1.ArkInstanceInvokeExpr) {
-            this.inferValueType(value.getBase(), arkClass);
+            this.inferValueType(value.getBase(), arkMethod);
         }
         if (value instanceof Ref_1.AbstractRef || value instanceof Expr_1.AbstractExpr || value instanceof Local_1.Local) {
-            value.inferType(arkClass);
+            value.inferType(arkMethod);
         }
         return value.getType();
     }
     static inferMethodReturnType(method) {
-        const oldMethodSignature = method.getSignature();
-        const oldMethodSubSignature = oldMethodSignature.getMethodSubSignature();
         if (method.getName() === TSConst_1.CONSTRUCTOR_NAME) {
+            const oldMethodSignature = method.getSignature();
+            const oldMethodSubSignature = oldMethodSignature.getMethodSubSignature();
             const newReturnType = new Type_1.ClassType(method.getDeclaringArkClass().getSignature());
             const newMethodSubSignature = new ArkSignature_1.MethodSubSignature(oldMethodSubSignature.getMethodName(), oldMethodSubSignature.getParameters(), newReturnType, oldMethodSubSignature.isStatic());
-            method.setSignature(new ArkSignature_1.MethodSignature(oldMethodSignature.getDeclaringClassSignature(), newMethodSubSignature));
+            method.setImplementationSignature(new ArkSignature_1.MethodSignature(oldMethodSignature.getDeclaringClassSignature(), newMethodSubSignature));
             return;
         }
-        const returnType = method.getReturnType();
-        let inferType;
-        if (returnType instanceof Type_1.UnclearReferenceType) {
-            inferType = this.inferUnclearReferenceType(returnType.getName(), method.getDeclaringArkClass());
+        let implSignature = method.getImplementationSignature();
+        if (implSignature !== null) {
+            const newSignature = this.inferSignatureReturnType(implSignature, method.getDeclaringArkClass());
+            if (newSignature !== null) {
+                method.setImplementationSignature(newSignature);
+            }
         }
-        if (inferType) {
-            const newMethodSubSignature = new ArkSignature_1.MethodSubSignature(oldMethodSubSignature.getMethodName(), oldMethodSubSignature.getParameters(), inferType, oldMethodSubSignature.isStatic());
-            method.setSignature(new ArkSignature_1.MethodSignature(oldMethodSignature.getDeclaringClassSignature(), newMethodSubSignature));
+        let declareSignatures = method.getDeclareSignatures();
+        declareSignatures === null || declareSignatures === void 0 ? void 0 : declareSignatures.forEach((signature, index) => {
+            const newSignature = this.inferSignatureReturnType(signature, method.getDeclaringArkClass());
+            if (newSignature !== null) {
+                method.setDeclareSignatureWithIndex(newSignature, index);
+            }
+        });
+    }
+    static inferSignatureReturnType(oldSignature, declaringClass) {
+        const currReturnType = oldSignature.getType();
+        if (currReturnType instanceof Type_1.UnclearReferenceType) {
+            const newReturnType = this.inferUnclearReferenceType(currReturnType.getName(), declaringClass);
+            if (newReturnType !== null) {
+                const oldSubSignature = oldSignature.getMethodSubSignature();
+                const newMethodSubSignature = new ArkSignature_1.MethodSubSignature(oldSubSignature.getMethodName(), oldSubSignature.getParameters(), newReturnType, oldSubSignature.isStatic());
+                return new ArkSignature_1.MethodSignature(oldSignature.getDeclaringClassSignature(), newMethodSubSignature);
+            }
         }
+        return null;
     }
     static inferGenericType(types, arkClass) {
         types === null || types === void 0 ? void 0 : types.forEach(type => {
@@ -406,6 +452,27 @@ class TypeInference {
             }
         });
     }
+    static inferUnclearRefType(urType, arkClass) {
+        var _a;
+        const realTypes = urType.getGenericTypes();
+        this.inferRealGenericTypes(realTypes, arkClass);
+        if (urType.getName() === Builtin_1.Builtin.ARRAY) {
+            return new Type_1.ArrayType((_a = realTypes[0]) !== null && _a !== void 0 ? _a : Type_1.AnyType, 1);
+        }
+        const type = this.inferUnclearReferenceType(urType.getName(), arkClass);
+        if (realTypes.length === 0) {
+            return type;
+        }
+        if (type instanceof Type_1.ClassType) {
+            return new Type_1.ClassType(type.getClassSignature(), realTypes);
+        }
+        else if (type instanceof Type_1.FunctionType) {
+            return new Type_1.FunctionType(type.getMethodSignature(), realTypes);
+        }
+        else {
+            return new Type_1.UnclearReferenceType(urType.getName(), realTypes);
+        }
+    }
     static inferUnclearReferenceType(refName, arkClass) {
         var _a;
         if (!refName) {
@@ -416,7 +483,7 @@ class TypeInference {
         let type = null;
         for (let i = 0; i < singleNames.length; i++) {
             let genericName = ValueUtil_1.EMPTY_STRING;
-            const name = singleNames[i].replace(/<(\w+)>/, function (match, group1) {
+            const name = singleNames[i].replace(/<(\w+)>/, (match, group1) => {
                 genericName = group1;
                 return ValueUtil_1.EMPTY_STRING;
             });
@@ -464,6 +531,10 @@ class TypeInference {
                 }
                 return propertyAndType;
             }
+            if (arkClass.isAnonymousClass()) {
+                const fieldType = this.inferUnclearReferenceType(fieldName, arkClass);
+                return fieldType ? [null, fieldType] : null;
+            }
             const property = ModelUtils_1.ModelUtils.findPropertyInClass(fieldName, arkClass);
             let propertyType = null;
             if (property instanceof ArkField_1.ArkField) {
@@ -520,5 +591,66 @@ class TypeInference {
             }
         }
     }
+    static inferAnonymousClass(anon, declaredSignature, set = new Set()) {
+        var _a;
+        if (!anon) {
+            return;
+        }
+        const key = anon.getSignature().toString();
+        if (set.has(key)) {
+            return;
+        }
+        else {
+            set.add(key);
+        }
+        const scene = anon.getDeclaringArkFile().getScene();
+        const declaredClass = scene.getClass(declaredSignature);
+        if (!declaredClass) {
+            return;
+        }
+        for (const anonField of anon.getFields()) {
+            const property = ModelUtils_1.ModelUtils.findPropertyInClass(anon.getName(), declaredClass);
+            if (property instanceof ArkField_1.ArkField) {
+                TypeInference.assignAnonField(property, anonField, scene, set);
+            }
+        }
+        for (const anonMethod of anon.getMethods()) {
+            const methodSignature = (_a = declaredClass.getMethodWithName(anonMethod.getName())) === null || _a === void 0 ? void 0 : _a.matchMethodSignature(anonMethod.getSubSignature().getParameterTypes());
+            if (methodSignature) {
+                anonMethod.setImplementationSignature(methodSignature);
+            }
+        }
+    }
+    static assignAnonField(property, anonField, scene, set) {
+        function deepInfer(anonType, declaredSignature) {
+            if (anonType instanceof Type_1.ClassType && anonType.getClassSignature().getClassName().startsWith(Const_1.ANONYMOUS_CLASS_PREFIX)) {
+                TypeInference.inferAnonymousClass(scene.getClass(anonType.getClassSignature()), declaredSignature, set);
+            }
+        }
+        const type = property.getSignature().getType();
+        const lastStmt = anonField.getInitializer().at(-1);
+        if (lastStmt instanceof Stmt_1.ArkAssignStmt) {
+            const rightType = lastStmt.getRightOp().getType();
+            if (type instanceof Type_1.ClassType) {
+                deepInfer(rightType, type.getClassSignature());
+            }
+            else if (type instanceof Type_1.ArrayType && type.getBaseType() instanceof Type_1.ClassType &&
+                rightType instanceof Type_1.ArrayType) {
+                const baseType = rightType.getBaseType();
+                const classSignature = type.getBaseType().getClassSignature();
+                if (baseType instanceof Type_1.UnionType) {
+                    baseType.getTypes().forEach(t => deepInfer(t, classSignature));
+                }
+                else {
+                    deepInfer(rightType, classSignature);
+                }
+            }
+            const leftOp = lastStmt.getLeftOp();
+            if (leftOp instanceof Ref_1.AbstractFieldRef) {
+                leftOp.setFieldSignature(property.getSignature());
+            }
+        }
+        anonField.setSignature(property.getSignature());
+    }
 }
 exports.TypeInference = TypeInference;

package/lib/core/common/ValueUtil.d.ts

@@ -2,10 +2,6 @@ import { Constant } from '../base/Constant';
 export declare const EMPTY_STRING = "";
 export declare class ValueUtil {
     private static readonly NumberConstantCache;
-    private static readonly UndefinedConstant;
-    private static readonly NullConstant;
-    private static readonly TrueConstant;
-    private static readonly FalseConstant;
     private static readonly EMPTY_STRING_CONSTANT;
     static getOrCreateNumberConst(n: number): Constant;
     static createStringConst(str: string): Constant;

package/lib/core/common/ValueUtil.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ValueUtil.d.ts","sourceRoot":"","sources":["../../../src/core/common/ValueUtil.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,eAAO,MAAM,YAAY,KAAK,CAAC;AAE/B,qBAAa,SAAS;IAClB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAYxC;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAA0D;IACnG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAgD;IACpF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAmD;IACvF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAoD;IACzF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAwD;WAEvF,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ;WAS3C,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;WAOxC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;WAQlC,iBAAiB,IAAI,QAAQ;WAI7B,eAAe,IAAI,QAAQ;WAI3B,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ;CAG7D"}
+{"version":3,"file":"ValueUtil.d.ts","sourceRoot":"","sources":["../../../src/core/common/ValueUtil.ts"],"names":[],"mappings":"AAeA,OAAO,EAEH,QAAQ,EAKX,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,YAAY,KAAK,CAAC;AAE/B,qBAAa,SAAS;IAClB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAoC;IAC/E,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAoC;WAEnE,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ;WAS3C,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;WAOxC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;WAQlC,iBAAiB,IAAI,QAAQ;WAI7B,eAAe,IAAI,QAAQ;WAI3B,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ;CAG7D"}

package/lib/core/common/ValueUtil.js

@@ -16,56 +16,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueUtil = exports.EMPTY_STRING = void 0;
 const Constant_1 = require("../base/Constant");
-const Type_1 = require("../base/Type");
 exports.EMPTY_STRING = '';
 class ValueUtil {
     static getOrCreateNumberConst(n) {
         let constant = this.NumberConstantCache.get(n);
-        if (constant == undefined) {
-            constant = new Constant_1.Constant(n.toString(), Type_1.NumberType.getInstance());
+        if (constant === undefined) {
+            constant = new Constant_1.NumberConstant(n);
             this.NumberConstantCache.set(n, constant);
         }
         return constant;
     }
     static createStringConst(str) {
-        if (str == exports.EMPTY_STRING) {
+        if (str === exports.EMPTY_STRING) {
             return this.EMPTY_STRING_CONSTANT;
         }
-        return new Constant_1.Constant(str, Type_1.StringType.getInstance());
+        return new Constant_1.StringConstant(str);
     }
     static createConst(str) {
         const n = Number(str);
         if (!isNaN(n)) {
             return this.getOrCreateNumberConst(n);
         }
-        return new Constant_1.Constant(str, Type_1.StringType.getInstance());
+        return new Constant_1.StringConstant(str);
     }
     static getUndefinedConst() {
-        return this.UndefinedConstant;
+        return Constant_1.UndefinedConstant.getInstance();
     }
     static getNullConstant() {
-        return this.NullConstant;
+        return Constant_1.NullConstant.getInstance();
     }
     static getBooleanConstant(value) {
-        return value ? this.TrueConstant : this.FalseConstant;
+        return Constant_1.BooleanConstant.getInstance(value);
     }
 }
 exports.ValueUtil = ValueUtil;
-ValueUtil.NumberConstantCache = new Map([
-    [0, new Constant_1.Constant('0', Type_1.NumberType.getInstance())],
-    [1, new Constant_1.Constant('1', Type_1.NumberType.getInstance())],
-    [2, new Constant_1.Constant('2', Type_1.NumberType.getInstance())],
-    [3, new Constant_1.Constant('3', Type_1.NumberType.getInstance())],
-    [4, new Constant_1.Constant('4', Type_1.NumberType.getInstance())],
-    [5, new Constant_1.Constant('5', Type_1.NumberType.getInstance())],
-    [6, new Constant_1.Constant('6', Type_1.NumberType.getInstance())],
-    [7, new Constant_1.Constant('7', Type_1.NumberType.getInstance())],
-    [8, new Constant_1.Constant('8', Type_1.NumberType.getInstance())],
-    [9, new Constant_1.Constant('9', Type_1.NumberType.getInstance())],
-    [10, new Constant_1.Constant('10', Type_1.NumberType.getInstance())],
-]);
-ValueUtil.UndefinedConstant = new Constant_1.Constant('undefined', Type_1.UndefinedType.getInstance());
-ValueUtil.NullConstant = new Constant_1.Constant('null', Type_1.NullType.getInstance());
-ValueUtil.TrueConstant = new Constant_1.Constant('true', Type_1.BooleanType.getInstance());
-ValueUtil.FalseConstant = new Constant_1.Constant('false', Type_1.BooleanType.getInstance());
-ValueUtil.EMPTY_STRING_CONSTANT = new Constant_1.Constant(exports.EMPTY_STRING, Type_1.StringType.getInstance());
+ValueUtil.NumberConstantCache = new Map();
+ValueUtil.EMPTY_STRING_CONSTANT = new Constant_1.StringConstant(exports.EMPTY_STRING);

package/lib/core/common/VisibleValue.js

@@ -176,7 +176,7 @@ class VisibleValue {
         const fields = cls.getFields();
         const classSignature = cls.getSignature();
         for (const field of fields) {
-            if (field.getModifiers().has('StaticKeyword')) {
+            if (field.isStatic()) {
                 const staticFieldRef = new Ref_1.ArkStaticFieldRef(field.getSignature());
                 values.push(staticFieldRef);
             }

package/lib/core/dataflow/DataflowProblem.d.ts

@@ -14,6 +14,7 @@ export declare abstract class DataflowProblem<D> {
     abstract createZeroValue(): D;
     abstract getEntryPoint(): Stmt;
     abstract getEntryMethod(): ArkMethod;
+    abstract factEqual(d1: D, d2: D): boolean;
 }
 export interface FlowFunction<D> {
     getDataFacts(d: D): Set<D>;

package/lib/core/dataflow/DataflowProblem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataflowProblem.d.ts","sourceRoot":"","sources":["../../../src/core/dataflow/DataflowProblem.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG/C,8BAAsB,eAAe,CAAC,CAAC;IAG5B,YAAY,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI;IAchD;;;;OAIG;IAWH,QAAQ,CAAC,qBAAqB,CAAC,OAAO,EAAC,IAAI,EAAE,OAAO,EAAC,IAAI,GAAI,YAAY,CAAC,CAAC,CAAC;IAE5E,QAAQ,CAAC,mBAAmB,CAAC,OAAO,EAAC,IAAI,EAAE,MAAM,EAAC,SAAS,GAAI,YAAY,CAAC,CAAC,CAAC;IAE9E,QAAQ,CAAC,2BAA2B,CAAC,OAAO,EAAC,IAAI,EAAE,OAAO,EAAC,IAAI,EAAE,QAAQ,EAAC,IAAI,GAAI,YAAY,CAAC,CAAC,CAAC;IAEjG,QAAQ,CAAC,2BAA2B,CAAC,OAAO,EAAC,IAAI,EAAE,OAAO,EAAC,IAAI,GAAI,YAAY,CAAC,CAAC,CAAC;IAElF,QAAQ,CAAC,eAAe,IAAK,CAAC;IAE9B,QAAQ,CAAC,aAAa,IAAK,IAAI;IAE/B,QAAQ,CAAC,cAAc,IAAK,SAAS;CACxC;AAED,MAAM,WAAW,YAAY,CAAC,CAAC;IAC3B,YAAY,CAAC,CAAC,EAAC,CAAC,GAAI,GAAG,CAAC,CAAC,CAAC,CAAC;CAC9B"}
+{"version":3,"file":"DataflowProblem.d.ts","sourceRoot":"","sources":["../../../src/core/dataflow/DataflowProblem.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG/C,8BAAsB,eAAe,CAAC,CAAC;IAG5B,YAAY,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI;IAchD;;;;OAIG;IAWH,QAAQ,CAAC,qBAAqB,CAAC,OAAO,EAAC,IAAI,EAAE,OAAO,EAAC,IAAI,GAAI,YAAY,CAAC,CAAC,CAAC;IAE5E,QAAQ,CAAC,mBAAmB,CAAC,OAAO,EAAC,IAAI,EAAE,MAAM,EAAC,SAAS,GAAI,YAAY,CAAC,CAAC,CAAC;IAE9E,QAAQ,CAAC,2BAA2B,CAAC,OAAO,EAAC,IAAI,EAAE,OAAO,EAAC,IAAI,EAAE,QAAQ,EAAC,IAAI,GAAI,YAAY,CAAC,CAAC,CAAC;IAEjG,QAAQ,CAAC,2BAA2B,CAAC,OAAO,EAAC,IAAI,EAAE,OAAO,EAAC,IAAI,GAAI,YAAY,CAAC,CAAC,CAAC;IAElF,QAAQ,CAAC,eAAe,IAAK,CAAC;IAE9B,QAAQ,CAAC,aAAa,IAAK,IAAI;IAE/B,QAAQ,CAAC,cAAc,IAAK,SAAS;IAErC,QAAQ,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO;CAC5C;AAED,MAAM,WAAW,YAAY,CAAC,CAAC;IAC3B,YAAY,CAAC,CAAC,EAAC,CAAC,GAAI,GAAG,CAAC,CAAC,CAAC,CAAC;CAC9B"}

package/lib/core/dataflow/DataflowProblem.js

@@ -19,14 +19,14 @@ const Edge_1 = require("./Edge");
 class DataflowProblem {
     transferEdge(srcStmt, tgtStmt) {
         let edgeKind = Edge_1.Edge.getKind(srcStmt, tgtStmt);
-        if (0 == edgeKind) {
+        if (0 === edgeKind) {
             //normal
         }
-        else if (1 == edgeKind) { //Call-Edge
+        else if (1 === edgeKind) { //Call-Edge
         }
-        else if (2 == edgeKind) { //Return-Edge
+        else if (2 === edgeKind) { //Return-Edge
         }
-        else if (3 == edgeKind) { //Call-To-Return-Edge
+        else if (3 === edgeKind) { //Call-To-Return-Edge
         }
     }
 }

package/lib/core/dataflow/DataflowSolver.d.ts

@@ -2,27 +2,30 @@ import { Scene } from '../../Scene';
 import { ArkInvokeStmt, Stmt } from '../base/Stmt';
 import { ArkMethod } from '../model/ArkMethod';
 import { DataflowProblem } from './DataflowProblem';
-import { PathEdge } from './Edge';
+import { PathEdge, PathEdgePoint } from './Edge';
+import { BasicBlock } from '../graph/BasicBlock';
+import { ClassHierarchyAnalysis } from '../../callgraph/algorithm/ClassHierarchyAnalysis';
+type CallToReturnCacheEdge<D> = PathEdge<D>;
 export declare abstract class DataflowSolver<D> {
-    private problem;
-    private workList;
-    private pathEdgeSet;
-    private zeroFact;
-    private inComing;
-    private endSummary;
-    private summaryEdge;
-    private scene;
-    private CHA;
-    private stmtNexts;
-    private laterEdges;
+    protected problem: DataflowProblem<D>;
+    protected workList: Array<PathEdge<D>>;
+    protected pathEdgeSet: Set<PathEdge<D>>;
+    protected zeroFact: D;
+    protected inComing: Map<PathEdgePoint<D>, Set<PathEdgePoint<D>>>;
+    protected endSummary: Map<PathEdgePoint<D>, Set<PathEdgePoint<D>>>;
+    protected summaryEdge: Set<CallToReturnCacheEdge<D>>;
+    protected scene: Scene;
+    protected CHA: ClassHierarchyAnalysis;
+    protected stmtNexts: Map<Stmt, Set<Stmt>>;
+    protected laterEdges: Set<PathEdge<D>>;
     constructor(problem: DataflowProblem<D>, scene: Scene);
     solve(): void;
     protected computeResult(stmt: Stmt, d: D): boolean;
     protected getChildren(stmt: Stmt): Stmt[];
     protected init(): void;
-    private buildStmtMapInClass;
-    private buildStmtMap;
-    private setCfg4AllStmt;
+    protected buildStmtMapInClass(): void;
+    protected buildStmtMapInBlock(block: BasicBlock): void;
+    protected setCfg4AllStmt(): void;
     protected getAllCalleeMethods(callNode: ArkInvokeStmt): Set<ArkMethod>;
     protected getReturnSiteOfCall(call: Stmt): Stmt;
     protected getStartOfCallerMethod(call: Stmt): Stmt;
@@ -31,10 +34,11 @@ export declare abstract class DataflowSolver<D> {
     protected processExitNode(edge: PathEdge<D>): void;
     protected processNormalNode(edge: PathEdge<D>): void;
     protected processCallNode(edge: PathEdge<D>): void;
+    protected callNodeFactPropagate(edge: PathEdge<D>, firstStmt: Stmt, fact: D, returnSite: Stmt): void;
     protected doSolve(): void;
     protected isCallStatement(stmt: Stmt): boolean;
     protected isExitStatement(stmt: Stmt): boolean;
     getPathEdgeSet(): Set<PathEdge<D>>;
 }
-export declare function factEqual<D>(fact1: D, fact2: D): boolean;
+export {};
 //# sourceMappingURL=DataflowSolver.d.ts.map