arkanalyzer 1.0.5

package/lib/callgraph/pointerAnalysis/PtsDS.d.ts

@@ -0,0 +1,58 @@
+interface Idx {
+}
+interface IPtsCollection<T extends Idx> {
+    contains(elem: T): boolean;
+    insert(elem: T): boolean;
+    remove(elem: T): boolean;
+    clone(): this;
+    union(other: this): boolean;
+    subtract(other: this): boolean;
+    clear(): void;
+    count(): number;
+    isEmpty(): boolean;
+    superset(other: this): boolean;
+    intersect(other: this): boolean;
+    [Symbol.iterator](): IterableIterator<T>;
+}
+export declare class PtsSet<T extends Idx> implements IPtsCollection<T> {
+    pts: Set<T>;
+    constructor();
+    contains(elem: T): boolean;
+    insert(elem: T): boolean;
+    remove(elem: T): boolean;
+    clone(): this;
+    union(other: this): boolean;
+    subtract(other: this): boolean;
+    clear(): void;
+    count(): number;
+    isEmpty(): boolean;
+    superset(other: this): boolean;
+    intersect(other: this): boolean;
+    getProtoPtsSet(): Set<T>;
+    [Symbol.iterator](): IterableIterator<T>;
+}
+export declare class DiffPTData<K, D extends Idx, DS extends IPtsCollection<D>> {
+    private DSCreator;
+    diffPtsMap: Map<K, DS>;
+    propaPtsMap: Map<K, DS>;
+    constructor(DSCreator: new () => DS);
+    clear(): void;
+    addPts(v: K, elem: D): boolean;
+    resetElem(v: K): boolean;
+    unionDiffPts(dstv: K, srcv: K): boolean;
+    unionPts(dstv: K, srcv: K): boolean;
+    unionPtsTo(dstv: K, srcDs: DS): boolean;
+    removePtsElem(v: K, elem: D): boolean;
+    getDiffPts(v: K): DS | undefined;
+    getMutDiffPts(v: K): DS | undefined;
+    getPropaPts(v: K): DS | undefined;
+    getPropaPtsMut(v: K): DS;
+    flush(v: K): void;
+    clearPts(v: K): void;
+    clearDiffPts(v: K): void;
+    clearPropaPts(v: K): void;
+    dumpPtData(): void;
+    calculateDiff(src: K, dst: K): DS;
+}
+export {};
+//# sourceMappingURL=PtsDS.d.ts.map

package/lib/callgraph/pointerAnalysis/PtsDS.d.ts.map

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

package/lib/callgraph/pointerAnalysis/PtsDS.js

@@ -0,0 +1,234 @@
+"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.DiffPTData = exports.PtsSet = void 0;
+/*
+ * A simple set to store pts data
+ */
+class PtsSet {
+    // static new<T extends Idx>(this: new () => PtsSet<T>): PtsSet<T> {
+    //     return new this();
+    // }
+    constructor() {
+        this.pts = new Set();
+    }
+    contains(elem) {
+        return this.pts.has(elem);
+    }
+    insert(elem) {
+        if (this.pts.has(elem)) {
+            return false;
+        }
+        this.pts.add(elem);
+        return true;
+    }
+    remove(elem) {
+        if (!this.pts.has(elem)) {
+            return false;
+        }
+        this.pts.delete(elem);
+        return true;
+    }
+    clone() {
+        let clonedSet = new PtsSet();
+        clonedSet.pts = new Set(this.pts);
+        // TODO: need validate
+        return clonedSet;
+    }
+    union(other) {
+        let changed = false;
+        for (const elem of other.pts) {
+            changed = this.insert(elem) || changed;
+        }
+        return changed;
+    }
+    subtract(other) {
+        let changed = false;
+        for (const elem of other.pts) {
+            changed = this.remove(elem) || changed;
+        }
+        return changed;
+    }
+    clear() {
+        this.pts.clear();
+    }
+    count() {
+        return this.pts.size;
+    }
+    isEmpty() {
+        return this.pts.size === 0;
+    }
+    // If current collection is a super set of other
+    superset(other) {
+        for (const elem of other.pts) {
+            if (!this.pts.has(elem)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // If current collection is intersect with other
+    intersect(other) {
+        for (const elem of other.pts) {
+            if (this.pts.has(elem)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getProtoPtsSet() {
+        return this.pts;
+    }
+    [Symbol.iterator]() {
+        return this.pts[Symbol.iterator]();
+    }
+}
+exports.PtsSet = PtsSet;
+class DiffPTData {
+    constructor(DSCreator) {
+        this.DSCreator = DSCreator;
+        this.diffPtsMap = new Map();
+        this.propaPtsMap = new Map();
+    }
+    clear() {
+        this.diffPtsMap.clear();
+        this.propaPtsMap.clear();
+    }
+    addPts(v, elem) {
+        let propa = this.propaPtsMap.get(v);
+        if (propa && propa.contains(elem)) {
+            return false;
+        }
+        let diff = this.diffPtsMap.get(v) || new this.DSCreator();
+        this.diffPtsMap.set(v, diff);
+        return diff.insert(elem);
+    }
+    resetElem(v) {
+        let propa = this.propaPtsMap.get(v);
+        if (propa) {
+            this.diffPtsMap.set(v, propa.clone());
+            // this.propaPtsMap.set(v, new this.DSCreator());
+            return true;
+        }
+        return false;
+    }
+    unionDiffPts(dstv, srcv) {
+        if (dstv === srcv) {
+            return false;
+        }
+        let changed = false;
+        let diff = this.diffPtsMap.get(srcv);
+        if (diff) {
+            let srcDs = diff.clone();
+            changed = this.unionPtsTo(dstv, srcDs);
+        }
+        return changed;
+    }
+    unionPts(dstv, srcv) {
+        if (dstv === srcv) {
+            return false;
+        }
+        let changed = false;
+        let diff = this.diffPtsMap.get(srcv);
+        if (diff) {
+            let srcDs = diff.clone();
+            changed = this.unionPtsTo(dstv, srcDs);
+        }
+        let propa = this.propaPtsMap.get(srcv);
+        if (propa) {
+            let srcDs = propa.clone();
+            changed = this.unionPtsTo(dstv, srcDs) || changed;
+        }
+        return changed;
+    }
+    unionPtsTo(dstv, srcDs) {
+        let diff = this.diffPtsMap.get(dstv) || new this.DSCreator();
+        let propa = this.propaPtsMap.get(dstv) || new this.DSCreator();
+        let newSet = srcDs.clone();
+        newSet.subtract(propa);
+        let changed = diff.union(newSet);
+        this.diffPtsMap.set(dstv, diff);
+        return changed;
+    }
+    removePtsElem(v, elem) {
+        var _a, _b, _c, _d;
+        let removedFromDiff = (_b = (_a = this.diffPtsMap.get(v)) === null || _a === void 0 ? void 0 : _a.remove(elem)) !== null && _b !== void 0 ? _b : false;
+        let removedFromPropa = (_d = (_c = this.propaPtsMap.get(v)) === null || _c === void 0 ? void 0 : _c.remove(elem)) !== null && _d !== void 0 ? _d : false;
+        return removedFromDiff || removedFromPropa;
+    }
+    getDiffPts(v) {
+        return this.diffPtsMap.get(v);
+    }
+    getMutDiffPts(v) {
+        if (!this.diffPtsMap.has(v)) {
+            this.diffPtsMap.set(v, new this.DSCreator());
+        }
+        return this.diffPtsMap.get(v);
+    }
+    getPropaPts(v) {
+        return this.propaPtsMap.get(v);
+    }
+    getPropaPtsMut(v) {
+        if (!this.propaPtsMap.has(v)) {
+            this.propaPtsMap.set(v, new this.DSCreator());
+        }
+        return this.propaPtsMap.get(v);
+    }
+    flush(v) {
+        if (!this.diffPtsMap.has(v))
+            return;
+        let diff = this.diffPtsMap.get(v);
+        let propa = this.getPropaPtsMut(v);
+        // do not clear origin propa, only copy the pt and add it to diff
+        //let propa = this.propaPtsMap.get(v) || new this.DSCreator();
+        propa.union(diff);
+        diff.clear();
+    }
+    clearPts(v) {
+        let diff = this.diffPtsMap.get(v);
+        if (diff)
+            diff.clear();
+        let propa = this.propaPtsMap.get(v);
+        if (propa)
+            propa.clear();
+    }
+    clearDiffPts(v) {
+        let diff = this.diffPtsMap.get(v);
+        if (diff)
+            diff.clear();
+    }
+    clearPropaPts(v) {
+        let propa = this.propaPtsMap.get(v);
+        if (propa)
+            propa.clear();
+    }
+    dumpPtData() {
+        // TODO: to be implemented
+        console.log(this.diffPtsMap);
+        console.log(this.propaPtsMap);
+    }
+    calculateDiff(src, dst) {
+        let srcDiff = this.diffPtsMap.get(src);
+        let dstPropa = this.propaPtsMap.get(dst);
+        if (!dstPropa) {
+            return srcDiff.clone();
+        }
+        let result = srcDiff.clone();
+        result.subtract(dstPropa);
+        return result;
+    }
+}
+exports.DiffPTData = DiffPTData;

package/lib/core/base/Constant.d.ts

@@ -0,0 +1,17 @@
+import { Type } from './Type';
+import { Value } from './Value';
+/**
+ * @category core/base
+ */
+export declare class Constant implements Value {
+    private value;
+    private type;
+    constructor(value: string, type?: Type);
+    getValue(): string;
+    setValue(newValue: string): void;
+    getUses(): Value[];
+    getType(): Type;
+    setType(newType: Type): void;
+    toString(): string;
+}
+//# sourceMappingURL=Constant.d.ts.map

package/lib/core/base/Constant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Constant.d.ts","sourceRoot":"","sources":["../../../src/core/base/Constant.ts"],"names":[],"mappings":"AAeA,OAAO,EAAc,IAAI,EAAe,MAAM,QAAQ,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;GAEG;AACH,qBAAa,QAAS,YAAW,KAAK;IAClC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,IAAI,CAAO;gBAEP,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,IAAgC;IAK1D,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIhC,OAAO,IAAI,KAAK,EAAE;IAIlB,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAI5B,QAAQ,IAAI,MAAM;CAS5B"}

package/lib/core/base/Constant.js

@@ -0,0 +1,53 @@
+"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.Constant = void 0;
+const Type_1 = require("./Type");
+/**
+ * @category core/base
+ */
+class Constant {
+    constructor(value, type = Type_1.UnknownType.getInstance()) {
+        this.value = value;
+        this.type = type;
+    }
+    getValue() {
+        return this.value;
+    }
+    setValue(newValue) {
+        this.value = newValue;
+    }
+    getUses() {
+        return [];
+    }
+    getType() {
+        return this.type;
+    }
+    setType(newType) {
+        this.type = newType;
+    }
+    toString() {
+        let str = '';
+        if (this.type instanceof Type_1.StringType) {
+            str = '\'' + this.value + '\'';
+        }
+        else {
+            str = this.value;
+        }
+        return str;
+    }
+}
+exports.Constant = Constant;

package/lib/core/base/Decorator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @category core/base
+ */
+export declare class Decorator {
+    kind: string;
+    content: string;
+    param: string;
+    constructor(name: string);
+    getKind(): string;
+    setContent(content: string): void;
+    getContent(): string;
+    setParam(param: string): void;
+    getParam(): string;
+}
+//# sourceMappingURL=Decorator.d.ts.map

package/lib/core/base/Decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decorator.d.ts","sourceRoot":"","sources":["../../../src/core/base/Decorator.ts"],"names":[],"mappings":"AAeA;;GAEG;AACH,qBAAa,SAAS;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAM;IACrB,KAAK,EAAE,MAAM,CAAM;gBACP,IAAI,EAAE,MAAM;IAGjB,OAAO,IAAI,MAAM;IAGjB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAGjC,UAAU,IAAI,MAAM;IAGpB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAG7B,QAAQ,IAAI,MAAM;CAG5B"}

package/lib/core/base/Decorator.js

@@ -0,0 +1,43 @@
+"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.Decorator = void 0;
+/**
+ * @category core/base
+ */
+class Decorator {
+    constructor(name) {
+        this.content = '';
+        this.param = '';
+        this.kind = name;
+    }
+    getKind() {
+        return this.kind;
+    }
+    setContent(content) {
+        this.content = content;
+    }
+    getContent() {
+        return this.content;
+    }
+    setParam(param) {
+        this.param = param;
+    }
+    getParam() {
+        return this.param;
+    }
+}
+exports.Decorator = Decorator;

package/lib/core/base/DefUseChain.d.ts

@@ -0,0 +1,9 @@
+import { Value } from './Value';
+import { Stmt } from './Stmt';
+export declare class DefUseChain {
+    value: Value;
+    def: Stmt;
+    use: Stmt;
+    constructor(value: Value, def: Stmt, use: Stmt);
+}
+//# sourceMappingURL=DefUseChain.d.ts.map

package/lib/core/base/DefUseChain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefUseChain.d.ts","sourceRoot":"","sources":["../../../src/core/base/DefUseChain.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,qBAAa,WAAW;IACpB,KAAK,EAAC,KAAK,CAAC;IACZ,GAAG,EAAC,IAAI,CAAC;IACT,GAAG,EAAC,IAAI,CAAC;gBACG,KAAK,EAAC,KAAK,EAAC,GAAG,EAAC,IAAI,EAAC,GAAG,EAAC,IAAI;CAK5C"}

package/lib/core/base/DefUseChain.js

@@ -0,0 +1,25 @@
+"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.DefUseChain = void 0;
+class DefUseChain {
+    constructor(value, def, use) {
+        this.value = value;
+        this.def = def;
+        this.use = use;
+    }
+}
+exports.DefUseChain = DefUseChain;

package/lib/core/base/Expr.d.ts

@@ -0,0 +1,219 @@
+import { BasicBlock } from '../graph/BasicBlock';
+import { ArkClass } from '../model/ArkClass';
+import { MethodSignature } from '../model/ArkSignature';
+import { Local } from './Local';
+import { ArrayType, ClassType, Type } from './Type';
+import { Value } from './Value';
+import { AbstractFieldRef } from './Ref';
+/**
+ * @category core/base/expr
+ */
+export declare abstract class AbstractExpr implements Value {
+    abstract getUses(): Value[];
+    abstract getType(): Type;
+    abstract toString(): string;
+    inferType(arkClass: ArkClass): AbstractExpr;
+}
+export declare abstract class AbstractInvokeExpr extends AbstractExpr {
+    private methodSignature;
+    private args;
+    private realGenericTypes?;
+    constructor(methodSignature: MethodSignature, args: Value[], realGenericTypes?: Type[]);
+    getMethodSignature(): MethodSignature;
+    setMethodSignature(newMethodSignature: MethodSignature): void;
+    getArg(index: number): Value;
+    getArgs(): Value[];
+    setArgs(newArgs: Value[]): void;
+    getType(): Type;
+    getRealGenericTypes(): Type[] | undefined;
+    getUses(): Value[];
+}
+export declare class ArkInstanceInvokeExpr extends AbstractInvokeExpr {
+    private base;
+    constructor(base: Local, methodSignature: MethodSignature, args: Value[], realGenericTypes?: Type[]);
+    getBase(): Local;
+    setBase(newBase: Local): void;
+    getUses(): Value[];
+    toString(): string;
+    inferType(arkClass: ArkClass): AbstractInvokeExpr;
+    private processForEach;
+    private tryInferFormGlobal;
+    private inferMethod;
+}
+export declare class ArkStaticInvokeExpr extends AbstractInvokeExpr {
+    constructor(methodSignature: MethodSignature, args: Value[], realGenericTypes?: Type[]);
+    toString(): string;
+    inferType(arkClass: ArkClass): ArkStaticInvokeExpr;
+}
+export declare class ArkPtrInvokeExpr extends AbstractInvokeExpr {
+    private funPtrLocal;
+    constructor(methodSignature: MethodSignature, ptr: Local, args: Value[], realGenericTypes?: Type[]);
+    setFunPtrLocal(ptr: Local): void;
+    getFuncPtrLocal(): Local;
+    toString(): string;
+    inferType(arkClass: ArkClass): ArkPtrInvokeExpr;
+}
+export declare class ArkNewExpr extends AbstractExpr {
+    private classType;
+    constructor(classType: ClassType);
+    getClassType(): ClassType;
+    getUses(): Value[];
+    getType(): Type;
+    toString(): string;
+    inferType(arkClass: ArkClass): ArkNewExpr;
+}
+export declare class ArkNewArrayExpr extends AbstractExpr {
+    private baseType;
+    private size;
+    private fromLiteral;
+    constructor(baseType: Type, size: Value, fromLiteral?: boolean);
+    getSize(): Value;
+    setSize(newSize: Value): void;
+    getType(): ArrayType;
+    getBaseType(): Type;
+    setBaseType(newType: Type): void;
+    isFromLiteral(): boolean;
+    inferType(arkClass: ArkClass): ArkNewArrayExpr;
+    getUses(): Value[];
+    toString(): string;
+}
+export declare class ArkDeleteExpr extends AbstractExpr {
+    private field;
+    constructor(field: AbstractFieldRef);
+    getField(): AbstractFieldRef;
+    setField(newField: AbstractFieldRef): void;
+    getType(): Type;
+    getUses(): Value[];
+    toString(): string;
+}
+export declare class ArkAwaitExpr extends AbstractExpr {
+    private promise;
+    constructor(promise: Value);
+    getPromise(): Value;
+    setPromise(newPromise: Value): void;
+    getType(): Type;
+    inferType(arkClass: ArkClass): ArkAwaitExpr;
+    getUses(): Value[];
+    toString(): string;
+}
+export declare class ArkYieldExpr extends AbstractExpr {
+    private yieldValue;
+    constructor(yieldValue: Value);
+    getYieldValue(): Value;
+    setYieldValue(newYieldValue: Value): void;
+    getType(): Type;
+    getUses(): Value[];
+    toString(): string;
+}
+export declare enum NormalBinaryOperator {
+    NullishCoalescing = "??",
+    Exponentiation = "**",
+    Division = "/",
+    Addition = "+",
+    Subtraction = "-",
+    Multiplication = "*",
+    Remainder = "%",
+    LeftShift = "<<",
+    RightShift = ">>",
+    UnsignedRightShift = ">>>",
+    BitwiseAnd = "&",
+    BitwiseOr = "|",
+    BitwiseXor = "^",
+    LogicalAnd = "&&",
+    LogicalOr = "||"
+}
+export declare enum RelationalBinaryOperator {
+    LessThan = "<",
+    LessThanOrEqual = "<=",
+    GreaterThan = ">",
+    GreaterThanOrEqual = ">=",
+    Equality = "==",
+    InEquality = "!=",
+    StrictEquality = "===",
+    StrictInequality = "!=="
+}
+export type BinaryOperator = NormalBinaryOperator | RelationalBinaryOperator;
+export declare abstract class AbstractBinopExpr extends AbstractExpr {
+    protected op1: Value;
+    protected op2: Value;
+    protected operator: BinaryOperator;
+    protected type: Type;
+    constructor(op1: Value, op2: Value, operator: BinaryOperator);
+    getOp1(): Value;
+    setOp1(newOp1: Value): void;
+    getOp2(): Value;
+    setOp2(newOp2: Value): void;
+    getOperator(): BinaryOperator;
+    getType(): Type;
+    getUses(): Value[];
+    toString(): string;
+    protected inferOpType(op: Value, arkClass: ArkClass): void;
+    protected setType(): void;
+    inferType(arkClass: ArkClass): AbstractBinopExpr;
+}
+export declare class ArkConditionExpr extends AbstractBinopExpr {
+    constructor(op1: Value, op2: Value, operator: RelationalBinaryOperator);
+    inferType(arkClass: ArkClass): ArkConditionExpr;
+}
+export declare class ArkNormalBinopExpr extends AbstractBinopExpr {
+    constructor(op1: Value, op2: Value, operator: NormalBinaryOperator);
+}
+export declare class ArkTypeOfExpr extends AbstractExpr {
+    private op;
+    constructor(op: Value);
+    getOp(): Value;
+    setOp(newOp: Value): void;
+    getUses(): Value[];
+    getType(): Type;
+    toString(): string;
+}
+export declare class ArkInstanceOfExpr extends AbstractExpr {
+    private op;
+    private checkType;
+    constructor(op: Value, checkType: Type);
+    getOp(): Value;
+    setOp(newOp: Value): void;
+    getCheckType(): Type;
+    getType(): Type;
+    getUses(): Value[];
+    toString(): string;
+}
+export declare class ArkCastExpr extends AbstractExpr {
+    private op;
+    private type;
+    constructor(op: Value, type: Type);
+    getOp(): Value;
+    setOp(newOp: Value): void;
+    getUses(): Value[];
+    getType(): Type;
+    inferType(arkClass: ArkClass): AbstractExpr;
+    toString(): string;
+}
+export declare class ArkPhiExpr extends AbstractExpr {
+    private args;
+    private argToBlock;
+    constructor();
+    getUses(): Value[];
+    getArgs(): Local[];
+    setArgs(args: Local[]): void;
+    getArgToBlock(): Map<Local, BasicBlock>;
+    setArgToBlock(argToBlock: Map<Local, BasicBlock>): void;
+    getType(): Type;
+    toString(): string;
+}
+export declare enum UnaryOperator {
+    Neg = "-",
+    BitwiseNot = "~",
+    LogicalNot = "!"
+}
+export declare class ArkUnopExpr extends AbstractExpr {
+    private op;
+    private operator;
+    constructor(op: Value, operator: UnaryOperator);
+    getUses(): Value[];
+    getOp(): Value;
+    getType(): Type;
+    getOperator(): UnaryOperator;
+    toString(): string;
+}
+//# sourceMappingURL=Expr.d.ts.map