arkanalyzer 1.0.5

package/lib/callgraph/algorithm/AbstractAnalysis.d.ts

@@ -0,0 +1,28 @@
+import { Scene } from '../../Scene';
+import { AbstractInvokeExpr } from '../../core/base/Expr';
+import { Stmt } from '../../core/base/Stmt';
+import { ArkClass } from '../../core/model/ArkClass';
+import { ArkMethod } from '../../core/model/ArkMethod';
+import { MethodSignature } from '../../core/model/ArkSignature';
+import { NodeID } from '../model/BaseGraph';
+import { CallGraph, FuncID, CallSite } from '../model/CallGraph';
+import { CallGraphBuilder } from '../model/builder/CallGraphBuilder';
+export declare abstract class AbstractAnalysis {
+    protected scene: Scene;
+    protected cg: CallGraph;
+    protected cgBuilder: CallGraphBuilder;
+    protected workList: FuncID[];
+    protected processedMethod: Set<FuncID>;
+    constructor(s: Scene);
+    getScene(): Scene;
+    getCallGraph(): CallGraph;
+    protected abstract resolveCall(sourceMethod: NodeID, invokeStmt: Stmt): CallSite[];
+    protected abstract preProcessMethod(funcID: FuncID): CallSite[];
+    resolveInvokeExpr(invokeExpr: AbstractInvokeExpr): ArkMethod | undefined;
+    getClassHierarchy(arkClass: ArkClass): ArkClass[];
+    start(displayGeneratedMethod: Boolean): void;
+    protected init(): void;
+    protected processMethod(methodID: FuncID): CallSite[];
+    protected getParamAnonymousMethod(invokeExpr: AbstractInvokeExpr): MethodSignature[];
+}
+//# sourceMappingURL=AbstractAnalysis.d.ts.map

package/lib/callgraph/algorithm/AbstractAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractAnalysis.d.ts","sourceRoot":"","sources":["../../../src/callgraph/algorithm/AbstractAnalysis.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAE5C,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAiB,MAAM,oBAAoB,CAAC;AAChF,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAIrE,8BAAsB,gBAAgB;IAClC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC;IACvB,SAAS,CAAC,EAAE,EAAG,SAAS,CAAC;IACzB,SAAS,CAAC,SAAS,EAAG,gBAAgB,CAAC;IACvC,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAM;IAClC,SAAS,CAAC,eAAe,EAAG,GAAG,CAAC,MAAM,CAAC,CAAC;gBAE5B,CAAC,EAAE,KAAK;IAIb,QAAQ,IAAI,KAAK;IAIjB,YAAY,IAAI,SAAS;IAIhC,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,GAAG,QAAQ,EAAE;IAClF,SAAS,CAAC,QAAQ,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,EAAE;IAExD,iBAAiB,CAAC,UAAU,EAAE,kBAAkB,GAAG,SAAS,GAAG,SAAS;IAOxE,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,EAAE;IAiBjD,KAAK,CAAC,sBAAsB,EAAE,OAAO,GAAG,IAAI;IAiCnD,SAAS,CAAC,IAAI,IAAI,IAAI;IAOtB,SAAS,CAAC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,EAAE;IAsBrD,SAAS,CAAC,uBAAuB,CAAC,UAAU,EAAE,kBAAkB,GAAG,eAAe,EAAE;CAYvF"}

package/lib/callgraph/algorithm/AbstractAnalysis.js

@@ -0,0 +1,137 @@
+"use strict";
+/*
+ * Copyright (c) 2024 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractAnalysis = void 0;
+const Type_1 = require("../../core/base/Type");
+const logger_1 = __importStar(require("../../utils/logger"));
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'CG');
+class AbstractAnalysis {
+    constructor(s) {
+        this.workList = [];
+        this.scene = s;
+    }
+    getScene() {
+        return this.scene;
+    }
+    getCallGraph() {
+        return this.cg;
+    }
+    resolveInvokeExpr(invokeExpr) {
+        const method = this.scene.getMethod(invokeExpr.getMethodSignature());
+        if (method != null) {
+            return method;
+        }
+    }
+    getClassHierarchy(arkClass) {
+        // TODO: remove abstract class
+        let classWorkList = [arkClass];
+        // TODO: check class with no super Class
+        // let classHierarchy: ArkClass[] = [arkClass.getSuperClass()]
+        let classHierarchy = [];
+        while (classWorkList.length > 0) {
+            // TODO: no dumplicated check, TS doesn't allow multi extend
+            let tempClass = classWorkList.shift();
+            classWorkList.push(...tempClass.getExtendedClasses().values());
+            classHierarchy.push(tempClass);
+        }
+        return classHierarchy;
+    }
+    start(displayGeneratedMethod) {
+        this.init();
+        while (this.workList.length != 0) {
+            const method = this.workList.shift();
+            const cgNode = this.cg.getNode(method);
+            if (this.processedMethod.has(method) || cgNode.getIsSdkMethod()) {
+                continue;
+            }
+            // pre process for RTA only
+            this.preProcessMethod(method).forEach((cs) => {
+                this.workList.push(cs.calleeFuncID);
+            });
+            this.processMethod(method).forEach((cs) => {
+                var _a;
+                let me = this.cg.getArkMethodByFuncID(cs.calleeFuncID);
+                // check if need to display generated method
+                if (displayGeneratedMethod || (me === null || me === void 0 ? void 0 : me.isGenerated())) {
+                    this.cg.addDynamicCallEdge(method, cs.calleeFuncID, cs.callStmt);
+                }
+                if (!this.processedMethod.has(cs.calleeFuncID)) {
+                    this.workList.push(cs.calleeFuncID);
+                    logger.info(`New workList item ${cs.calleeFuncID}: ${(_a = this.cg.getArkMethodByFuncID(cs.calleeFuncID)) === null || _a === void 0 ? void 0 : _a.getSignature().toString()}`);
+                    this.processedMethod.add(cs.callerFuncID);
+                }
+            });
+        }
+    }
+    init() {
+        this.processedMethod = new Set();
+        this.cg.getEntries().forEach((entryFunc) => {
+            this.workList.push(entryFunc);
+        });
+    }
+    processMethod(methodID) {
+        let cgNode = this.cg.getNode(methodID);
+        let arkMethod = this.scene.getMethod(cgNode.getMethod(), true);
+        let calleeMethods = [];
+        if (!arkMethod) {
+            throw new Error("can not find method");
+        }
+        const cfg = arkMethod.getCfg();
+        if (!cfg) {
+            return [];
+        }
+        cfg.getStmts().forEach((stmt) => {
+            if (stmt.containsInvokeExpr()) {
+                calleeMethods.push(...this.resolveCall(cgNode.getID(), stmt));
+            }
+        });
+        return calleeMethods;
+    }
+    getParamAnonymousMethod(invokeExpr) {
+        let paramMethod = [];
+        invokeExpr.getArgs().forEach((args) => {
+            let argsType = args.getType();
+            if (argsType instanceof Type_1.FunctionType) {
+                paramMethod.push(argsType.getMethodSignature());
+            }
+        });
+        return paramMethod;
+    }
+}
+exports.AbstractAnalysis = AbstractAnalysis;

package/lib/callgraph/algorithm/ClassHierarchyAnalysis.d.ts

@@ -0,0 +1,11 @@
+import { Scene } from '../../Scene';
+import { Stmt } from '../../core/base/Stmt';
+import { NodeID } from '../model/BaseGraph';
+import { CallGraph, CallSite } from '../model/CallGraph';
+import { AbstractAnalysis } from './AbstractAnalysis';
+export declare class ClassHierarchyAnalysis extends AbstractAnalysis {
+    constructor(scene: Scene, cg: CallGraph);
+    resolveCall(callerMethod: NodeID, invokeStmt: Stmt): CallSite[];
+    protected preProcessMethod(): CallSite[];
+}
+//# sourceMappingURL=ClassHierarchyAnalysis.d.ts.map

package/lib/callgraph/algorithm/ClassHierarchyAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassHierarchyAnalysis.d.ts","sourceRoot":"","sources":["../../../src/callgraph/algorithm/ClassHierarchyAnalysis.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAE5C,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,qBAAa,sBAAuB,SAAQ,gBAAgB;gBAE5C,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS;IAKhC,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,GAAG,QAAQ,EAAE;IAyDtE,SAAS,CAAC,gBAAgB,IAAI,QAAQ,EAAE;CAI3C"}

package/lib/callgraph/algorithm/ClassHierarchyAnalysis.js

@@ -0,0 +1,71 @@
+"use strict";
+/*
+ * Copyright (c) 2024 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.ClassHierarchyAnalysis = void 0;
+const Expr_1 = require("../../core/base/Expr");
+const CallGraph_1 = require("../model/CallGraph");
+const AbstractAnalysis_1 = require("./AbstractAnalysis");
+const TSConst_1 = require("../../core/common/TSConst");
+class ClassHierarchyAnalysis extends AbstractAnalysis_1.AbstractAnalysis {
+    constructor(scene, cg) {
+        super(scene);
+        this.cg = cg;
+    }
+    resolveCall(callerMethod, invokeStmt) {
+        let invokeExpr = invokeStmt.getInvokeExpr();
+        let resolveResult = [];
+        if (!invokeExpr) {
+            return [];
+        }
+        // process anonymous method call
+        this.getParamAnonymousMethod(invokeExpr).forEach(method => {
+            resolveResult.push(new CallGraph_1.CallSite(invokeStmt, undefined, this.cg.getCallGraphNodeByMethod(method).getID(), callerMethod));
+        });
+        let calleeMethod = this.resolveInvokeExpr(invokeExpr);
+        if (!calleeMethod) {
+            return resolveResult;
+        }
+        if (invokeExpr instanceof Expr_1.ArkStaticInvokeExpr) {
+            // get specific method
+            // resolveResult.push(calleeMethod.getSignature())
+            resolveResult.push(new CallGraph_1.CallSite(invokeStmt, undefined, this.cg.getCallGraphNodeByMethod(calleeMethod.getSignature()).getID(), callerMethod));
+        }
+        else {
+            let declareClass = calleeMethod.getDeclaringArkClass();
+            // TODO: super class method should be placed at the end
+            this.getClassHierarchy(declareClass).forEach((arkClass) => {
+                if (arkClass.getModifiers().has(TSConst_1.ABSTRACT_KEYWORD)) {
+                    return;
+                }
+                let possibleCalleeMethod = arkClass.getMethodWithName(calleeMethod.getName());
+                if (possibleCalleeMethod && possibleCalleeMethod.isGenerated() &&
+                    arkClass.getSignature().toString() !== declareClass.getSignature().toString()) {
+                    // remove the generated method in extended classes
+                    return;
+                }
+                if (possibleCalleeMethod && !possibleCalleeMethod.getModifiers().has(TSConst_1.ABSTRACT_KEYWORD)) {
+                    resolveResult.push(new CallGraph_1.CallSite(invokeStmt, undefined, this.cg.getCallGraphNodeByMethod(possibleCalleeMethod.getSignature()).getID(), callerMethod));
+                }
+            });
+        }
+        return resolveResult;
+    }
+    preProcessMethod() {
+        // do nothing
+        return [];
+    }
+}
+exports.ClassHierarchyAnalysis = ClassHierarchyAnalysis;

package/lib/callgraph/algorithm/RapidTypeAnalysis.d.ts

@@ -0,0 +1,16 @@
+import { Scene } from '../../Scene';
+import { Stmt } from '../../core/base/Stmt';
+import { ClassSignature } from '../../core/model/ArkSignature';
+import { NodeID } from '../model/BaseGraph';
+import { CallGraph, CallSite, FuncID } from '../model/CallGraph';
+import { AbstractAnalysis } from './AbstractAnalysis';
+export declare class RapidTypeAnalysis extends AbstractAnalysis {
+    private instancedClasses;
+    private ignoredCalls;
+    constructor(scene: Scene, cg: CallGraph);
+    resolveCall(callerMethod: NodeID, invokeStmt: Stmt): CallSite[];
+    protected preProcessMethod(funcID: FuncID): CallSite[];
+    private collectInstancedClassesInMethod;
+    addIgnoredCalls(arkClass: ClassSignature, callerID: FuncID, calleeID: FuncID, invokeStmt: Stmt): void;
+}
+//# sourceMappingURL=RapidTypeAnalysis.d.ts.map

package/lib/callgraph/algorithm/RapidTypeAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RapidTypeAnalysis.d.ts","sourceRoot":"","sources":["../../../src/callgraph/algorithm/RapidTypeAnalysis.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAOtD,qBAAa,iBAAkB,SAAQ,gBAAgB;IAEnD,OAAO,CAAC,gBAAgB,CAAkC;IAE1D,OAAO,CAAC,YAAY,CAA2F;gBAEnG,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS;IAKhC,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,GAAG,QAAQ,EAAE;IA4DtE,SAAS,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,EAAE;IAqBtD,OAAO,CAAC,+BAA+B;IA4BhC,eAAe,CAAC,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI;CAKxG"}

package/lib/callgraph/algorithm/RapidTypeAnalysis.js

@@ -0,0 +1,147 @@
+"use strict";
+/*
+ * Copyright (c) 2024 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RapidTypeAnalysis = void 0;
+const Expr_1 = require("../../core/base/Expr");
+const CallGraph_1 = require("../model/CallGraph");
+const AbstractAnalysis_1 = require("./AbstractAnalysis");
+const logger_1 = __importStar(require("../../utils/logger"));
+const TSConst_1 = require("../../core/common/TSConst");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'RTA');
+class RapidTypeAnalysis extends AbstractAnalysis_1.AbstractAnalysis {
+    constructor(scene, cg) {
+        super(scene);
+        // TODO: signature duplicated check
+        this.instancedClasses = new Set();
+        // TODO: Set duplicated check
+        this.ignoredCalls = new Map();
+        this.cg = cg;
+    }
+    resolveCall(callerMethod, invokeStmt) {
+        let invokeExpr = invokeStmt.getInvokeExpr();
+        let resolveResult = [];
+        if (!invokeExpr) {
+            return [];
+        }
+        // process anonymous method call
+        this.getParamAnonymousMethod(invokeExpr).forEach(method => {
+            resolveResult.push(new CallGraph_1.CallSite(invokeStmt, undefined, this.cg.getCallGraphNodeByMethod(method).getID(), callerMethod));
+        });
+        let calleeMethod = this.resolveInvokeExpr(invokeExpr);
+        if (!calleeMethod) {
+            return resolveResult;
+        }
+        if (invokeExpr instanceof Expr_1.ArkStaticInvokeExpr) {
+            // get specific method
+            resolveResult.push(new CallGraph_1.CallSite(invokeStmt, undefined, this.cg.getCallGraphNodeByMethod(calleeMethod.getSignature()).getID(), callerMethod));
+        }
+        else {
+            let declareClass = calleeMethod.getDeclaringArkClass();
+            // TODO: super class method should be placed at the end
+            this.getClassHierarchy(declareClass).forEach((arkClass) => {
+                if (arkClass.getModifiers().has(TSConst_1.ABSTRACT_KEYWORD)) {
+                    return;
+                }
+                let possibleCalleeMethod = arkClass.getMethodWithName(calleeMethod.getName());
+                if (possibleCalleeMethod && possibleCalleeMethod.isGenerated() &&
+                    arkClass.getSignature().toString() !== declareClass.getSignature().toString()) {
+                    // remove the generated method in extended classes
+                    return;
+                }
+                if (possibleCalleeMethod && !possibleCalleeMethod.getModifiers().has(TSConst_1.ABSTRACT_KEYWORD)) {
+                    if (!this.instancedClasses.has(arkClass.getSignature())) {
+                        this.addIgnoredCalls(arkClass.getSignature(), callerMethod, this.cg.getCallGraphNodeByMethod(possibleCalleeMethod.getSignature()).getID(), invokeStmt);
+                    }
+                    else {
+                        resolveResult.push(new CallGraph_1.CallSite(invokeStmt, undefined, this.cg.getCallGraphNodeByMethod(possibleCalleeMethod.getSignature()).getID(), callerMethod));
+                    }
+                }
+            });
+        }
+        return resolveResult;
+    }
+    preProcessMethod(funcID) {
+        let newCallSites = [];
+        let instancedClasses = this.collectInstancedClassesInMethod(funcID);
+        let newlyInstancedClasses = new Set(Array.from(instancedClasses).filter(item => !this.instancedClasses.has(item)));
+        newlyInstancedClasses.forEach(sig => {
+            let ignoredCalls = this.ignoredCalls.get(sig);
+            if (ignoredCalls) {
+                ignoredCalls.forEach((call) => {
+                    this.cg.addDynamicCallEdge(call.caller, call.callee, call.callStmt);
+                    newCallSites.push(new CallGraph_1.CallSite(call.callStmt, undefined, call.callee, call.caller));
+                });
+            }
+            this.instancedClasses.add(sig);
+            this.ignoredCalls.delete(sig);
+        });
+        return newCallSites;
+    }
+    collectInstancedClassesInMethod(funcID) {
+        let instancedClasses = new Set();
+        let arkMethod = this.cg.getArkMethodByFuncID(funcID);
+        if (!arkMethod) {
+            logger.error(`can not find arkMethod by funcID`);
+            return instancedClasses;
+        }
+        let cfg = arkMethod.getCfg();
+        if (!cfg) {
+            logger.error(`arkMethod ${arkMethod.getSignature().toString()} has no cfg`);
+            return instancedClasses;
+        }
+        for (let stmt of cfg.getStmts()) {
+            let stmtExpr = stmt.getExprs()[0];
+            if (stmtExpr instanceof Expr_1.ArkNewExpr) {
+                let classSig = stmtExpr.getType().getClassSignature();
+                if (classSig != null) {
+                    // TODO: need to check if different stmt has single sig
+                    instancedClasses.add(classSig);
+                }
+            }
+        }
+        return instancedClasses;
+    }
+    addIgnoredCalls(arkClass, callerID, calleeID, invokeStmt) {
+        var _a;
+        let classMap = (_a = this.ignoredCalls.get(arkClass)) !== null && _a !== void 0 ? _a : new Set();
+        classMap.add({ caller: callerID, callee: calleeID, callStmt: invokeStmt });
+        this.ignoredCalls.set(arkClass, classMap);
+    }
+}
+exports.RapidTypeAnalysis = RapidTypeAnalysis;

package/lib/callgraph/common/Statistics.d.ts

@@ -0,0 +1,58 @@
+import { CallGraphNodeKind } from "../model/CallGraph";
+import { PointerAnalysis } from "../pointerAnalysis/PointerAnalysis";
+declare abstract class StatTraits {
+    getStat(): string;
+    printStat(): void;
+}
+export declare class PTAStat implements StatTraits {
+    pta: PointerAnalysis;
+    numProcessedAddr: number;
+    numProcessedCopy: number;
+    numProcessedLoad: number;
+    numProcessedWrite: number;
+    numProcessedThis: number;
+    numRealWrite: number;
+    numRealLoad: number;
+    numUnhandledFun: number;
+    numTotalValuesInHandedFun: number;
+    numTotalHandledValue: number;
+    numInferedUnknownValue: number;
+    numInferedDiffTypeValue: number;
+    totalValuesInVisitedFunc: number;
+    numNotInferedUnknownValue: number;
+    numUnhandledFunc: number;
+    iterTimes: number;
+    TotalTime: number;
+    startTime: number;
+    endTime: number;
+    startMemUsage: any;
+    endMemUsage: any;
+    rssUsed: number;
+    heapUsed: number;
+    constructor(pta: PointerAnalysis);
+    startStat(): void;
+    endStat(): void;
+    getNow(): number;
+    private getInferedStat;
+    private getUnhandledFuncStat;
+    getStat(): string;
+    printStat(): void;
+}
+export declare class PAGStat implements StatTraits {
+    numDynamicCall: number;
+    numTotalFunction: number;
+    numTotalNode: number;
+    getStat(): string;
+    printStat(): void;
+}
+export declare class CGStat extends StatTraits {
+    numTotalNode: number;
+    numReal: number;
+    numVirtual: number;
+    numIntrinsic: number;
+    numConstructor: number;
+    addNodeStat(kind: CallGraphNodeKind): void;
+    getStat(): string;
+}
+export {};
+//# sourceMappingURL=Statistics.d.ts.map

package/lib/callgraph/common/Statistics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Statistics.d.ts","sourceRoot":"","sources":["../../../src/callgraph/common/Statistics.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAiB,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAErE,uBAAe,UAAU;IACd,OAAO,IAAI,MAAM;IAIjB,SAAS,IAAI,IAAI;CAG3B;AAED,qBAAa,OAAQ,YAAW,UAAU;IACtC,GAAG,EAAE,eAAe,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAK;IAC7B,gBAAgB,EAAE,MAAM,CAAK;IAC7B,gBAAgB,EAAE,MAAM,CAAK;IAC7B,iBAAiB,EAAE,MAAM,CAAK;IAC9B,gBAAgB,EAAE,MAAM,CAAK;IAC7B,YAAY,EAAE,MAAM,CAAK;IACzB,WAAW,EAAE,MAAM,CAAK;IAExB,eAAe,EAAE,MAAM,CAAK;IAC5B,yBAAyB,EAAE,MAAM,CAAK;IACtC,oBAAoB,EAAE,MAAM,CAAK;IAGjC,sBAAsB,EAAE,MAAM,CAAK;IAEnC,uBAAuB,EAAE,MAAM,CAAK;IAEpC,wBAAwB,EAAE,MAAM,CAAK;IAErC,yBAAyB,EAAE,MAAM,CAAK;IACtC,gBAAgB,EAAE,MAAM,CAAK;IAE7B,SAAS,EAAE,MAAM,CAAK;IACtB,SAAS,EAAE,MAAM,CAAK;IAEtB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE,MAAM,CAAK;IAEpB,aAAa,EAAE,GAAG,CAAC;IACnB,WAAW,EAAE,GAAG,CAAC;IACjB,OAAO,EAAE,MAAM,CAAK;IACpB,QAAQ,EAAE,MAAM,CAAK;gBAET,GAAG,EAAE,eAAe;IAIzB,SAAS,IAAI,IAAI;IAKjB,OAAO,IAAI,IAAI;IAUf,MAAM,IAAI,MAAM;IAIvB,OAAO,CAAC,cAAc;IAkCtB,OAAO,CAAC,oBAAoB;IAerB,OAAO,IAAI,MAAM;IAsBjB,SAAS,IAAI,IAAI;CAG3B;AAED,qBAAa,OAAQ,YAAW,UAAU;IACtC,cAAc,EAAE,MAAM,CAAK;IAC3B,gBAAgB,EAAE,MAAM,CAAK;IAC7B,YAAY,EAAE,MAAM,CAAK;IAElB,OAAO,IAAI,MAAM;IASjB,SAAS,IAAI,IAAI;CAG3B;AAED,qBAAa,MAAO,SAAQ,UAAU;IAElC,YAAY,EAAE,MAAM,CAAK;IACzB,OAAO,EAAE,MAAM,CAAK;IACpB,UAAU,EAAE,MAAM,CAAK;IACvB,YAAY,EAAE,MAAM,CAAK;IACzB,cAAc,EAAE,MAAM,CAAK;IAEpB,WAAW,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI;IAmB1C,OAAO,IAAI,MAAM;CAU3B"}