arkanalyzer 1.0.5

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

@@ -0,0 +1,40 @@
+import { Stmt } from './Stmt';
+import { Type } from './Type';
+import { Value } from './Value';
+import { ArkClass } from '../model/ArkClass';
+import { ArkExport, ExportType } from '../model/ArkExport';
+import { Decorator } from './Decorator';
+import { LocalSignature } from '../model/ArkSignature';
+/**
+ * @category core/base
+ */
+export declare class Local implements Value, ArkExport {
+    private name;
+    private type;
+    private originalValue;
+    private declaringStmt;
+    private usedStmts;
+    private signature?;
+    private constFlag;
+    constructor(name: string, type?: Type);
+    inferType(arkClass: ArkClass): Local;
+    getName(): string;
+    setName(name: string): void;
+    getType(): Type;
+    setType(newType: Type): void;
+    getOriginalValue(): Value | null;
+    setOriginalValue(originalValue: Value): void;
+    getDeclaringStmt(): Stmt | null;
+    setDeclaringStmt(declaringStmt: Stmt): void;
+    getUses(): Value[];
+    addUsedStmt(usedStmt: Stmt): void;
+    getUsedStmts(): Stmt[];
+    toString(): string;
+    getExportType(): ExportType;
+    getModifiers(): Set<string | Decorator>;
+    getSignature(): LocalSignature;
+    setSignature(signature: LocalSignature): void;
+    getConstFlag(): boolean;
+    setConstFlag(newConstFlag: boolean): void;
+}
+//# sourceMappingURL=Local.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Local.d.ts","sourceRoot":"","sources":["../../../src/core/base/Local.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAe,MAAM,QAAQ,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAkB,cAAc,EAAmB,MAAM,uBAAuB,CAAC;AAIxF;;GAEG;AACH,qBAAa,KAAM,YAAW,KAAK,EAAE,SAAS;IAC1C,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,IAAI,CAAO;IAEnB,OAAO,CAAC,aAAa,CAAe;IAEpC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,SAAS,CAAkB;gBAEvB,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,IAAgC;IASzD,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK;IAUpC,OAAO,IAAI,MAAM;IAIjB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI3B,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAI5B,gBAAgB,IAAI,KAAK,GAAG,IAAI;IAIhC,gBAAgB,CAAC,aAAa,EAAE,KAAK,GAAG,IAAI;IAI5C,gBAAgB,IAAI,IAAI,GAAG,IAAI;IAI/B,gBAAgB,CAAC,aAAa,EAAE,IAAI;IAIpC,OAAO,IAAI,KAAK,EAAE;IAIlB,WAAW,CAAC,QAAQ,EAAE,IAAI;IAI1B,YAAY,IAAI,IAAI,EAAE;IAItB,QAAQ,IAAI,MAAM;IAIlB,aAAa,IAAI,UAAU;IAI3B,YAAY,IAAI,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC;IAIvC,YAAY,IAAI,cAAc;IAK9B,YAAY,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI;IAI7C,YAAY,IAAI,OAAO;IAIvB,YAAY,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI;CAGnD"}

package/lib/core/base/Local.js

@@ -0,0 +1,101 @@
+"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.Local = void 0;
+const Type_1 = require("./Type");
+const TypeInference_1 = require("../common/TypeInference");
+const ArkExport_1 = require("../model/ArkExport");
+const ArkSignature_1 = require("../model/ArkSignature");
+const ArkSignatureBuilder_1 = require("../model/builder/ArkSignatureBuilder");
+const Const_1 = require("../common/Const");
+/**
+ * @category core/base
+ */
+class Local {
+    constructor(name, type = Type_1.UnknownType.getInstance()) {
+        this.constFlag = false;
+        this.name = name;
+        this.type = type;
+        this.originalValue = null;
+        this.declaringStmt = null;
+        this.usedStmts = [];
+    }
+    inferType(arkClass) {
+        if (TypeInference_1.TypeInference.isUnclearType(this.type)) {
+            const type = TypeInference_1.TypeInference.inferUnclearReferenceType(this.name, arkClass);
+            if (type) {
+                this.type = type;
+            }
+        }
+        return this;
+    }
+    getName() {
+        return this.name;
+    }
+    setName(name) {
+        this.name = name;
+    }
+    getType() {
+        return this.type;
+    }
+    setType(newType) {
+        this.type = newType;
+    }
+    getOriginalValue() {
+        return this.originalValue;
+    }
+    setOriginalValue(originalValue) {
+        this.originalValue = originalValue;
+    }
+    getDeclaringStmt() {
+        return this.declaringStmt;
+    }
+    setDeclaringStmt(declaringStmt) {
+        this.declaringStmt = declaringStmt;
+    }
+    getUses() {
+        return [];
+    }
+    addUsedStmt(usedStmt) {
+        this.usedStmts.push(usedStmt);
+    }
+    getUsedStmts() {
+        return this.usedStmts;
+    }
+    toString() {
+        return this.getName();
+    }
+    getExportType() {
+        return ArkExport_1.ExportType.LOCAL;
+    }
+    getModifiers() {
+        return new Set();
+    }
+    getSignature() {
+        var _a;
+        return (_a = this.signature) !== null && _a !== void 0 ? _a : new ArkSignature_1.LocalSignature(this.name, new ArkSignature_1.MethodSignature(ArkSignature_1.ClassSignature.DEFAULT, ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(Const_1.UNKNOWN_METHOD_NAME)));
+    }
+    setSignature(signature) {
+        this.signature = signature;
+    }
+    getConstFlag() {
+        return this.constFlag;
+    }
+    setConstFlag(newConstFlag) {
+        this.constFlag = newConstFlag;
+    }
+}
+exports.Local = Local;

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

@@ -0,0 +1,39 @@
+import ts from 'ohos-typescript';
+export declare abstract class Position {
+    abstract getFirstLine(): number;
+    abstract getLastLine(): number;
+    abstract getFirstCol(): number;
+    abstract getLastCol(): number;
+}
+export declare class LinePosition {
+    private readonly lineNo;
+    constructor(lineNo: number);
+    getLineNo(): number;
+}
+/**
+ * @category core/base
+ */
+export declare class LineColPosition {
+    private readonly lineNo;
+    private readonly colNo;
+    static readonly DEFAULT: LineColPosition;
+    constructor(lineNo: number, colNo: number);
+    getLineNo(): number;
+    getColNo(): number;
+    static buildFromNode(node: ts.Node, sourceFile: ts.SourceFile): LineColPosition;
+}
+export declare class FullPosition {
+    private readonly firstLine;
+    private readonly firstCol;
+    private readonly lastLine;
+    private readonly lastCol;
+    static readonly DEFAULT: FullPosition;
+    constructor(firstLine: number, firstCol: number, lastLine: number, lastCol: number);
+    getFirstLine(): number;
+    getLastLine(): number;
+    getFirstCol(): number;
+    getLastCol(): number;
+    static buildFromNode(node: ts.Node, sourceFile: ts.SourceFile): FullPosition;
+    static merge(leftMostPosition: FullPosition, rightMostPosition: FullPosition): FullPosition;
+}
+//# sourceMappingURL=Position.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Position.d.ts","sourceRoot":"","sources":["../../../src/core/base/Position.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAEjC,8BAAsB,QAAQ;aACV,YAAY,IAAI,MAAM;aAEtB,WAAW,IAAI,MAAM;aAErB,WAAW,IAAI,MAAM;aAErB,UAAU,IAAI,MAAM;CACvC;AAED,qBAAa,YAAY;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,MAAM,EAAE,MAAM;IAInB,SAAS,IAAI,MAAM;CAG7B;AAED;;GAEG;AACH,qBAAa,eAAe;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAE/B,gBAAuB,OAAO,EAAE,eAAe,CAA+B;gBAElE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAKlC,SAAS,IAAI,MAAM;IAInB,QAAQ,IAAI,MAAM;WAIX,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU;CAQvE;AAED,qBAAa,YAAY;IACrB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC,gBAAuB,OAAO,EAAE,YAAY,CAAoC;gBAEpE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAO3E,YAAY,IAAI,MAAM;IAItB,WAAW,IAAI,MAAM;IAIrB,WAAW,IAAI,MAAM;IAIrB,UAAU,IAAI,MAAM;WAIb,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,YAAY;WAcrE,KAAK,CAAC,gBAAgB,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,GAAG,YAAY;CAIrG"}

package/lib/core/base/Position.js

@@ -0,0 +1,86 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FullPosition = exports.LineColPosition = exports.LinePosition = exports.Position = void 0;
+const ohos_typescript_1 = __importDefault(require("ohos-typescript"));
+class Position {
+}
+exports.Position = Position;
+class LinePosition {
+    constructor(lineNo) {
+        this.lineNo = lineNo;
+    }
+    getLineNo() {
+        return this.lineNo;
+    }
+}
+exports.LinePosition = LinePosition;
+/**
+ * @category core/base
+ */
+class LineColPosition {
+    constructor(lineNo, colNo) {
+        this.lineNo = lineNo;
+        this.colNo = colNo;
+    }
+    getLineNo() {
+        return this.lineNo;
+    }
+    getColNo() {
+        return this.colNo;
+    }
+    static buildFromNode(node, sourceFile) {
+        let { line, character } = ohos_typescript_1.default.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+        // line start from 1.
+        return new LineColPosition(line + 1, character + 1);
+    }
+}
+exports.LineColPosition = LineColPosition;
+LineColPosition.DEFAULT = new LineColPosition(-1, -1);
+class FullPosition {
+    constructor(firstLine, firstCol, lastLine, lastCol) {
+        this.firstLine = firstLine;
+        this.firstCol = firstCol;
+        this.lastLine = lastLine;
+        this.lastCol = lastCol;
+    }
+    getFirstLine() {
+        return this.firstLine;
+    }
+    getLastLine() {
+        return this.lastLine;
+    }
+    getFirstCol() {
+        return this.firstCol;
+    }
+    getLastCol() {
+        return this.lastCol;
+    }
+    static buildFromNode(node, sourceFile) {
+        const { line: startLine, character: startCharacter } = ohos_typescript_1.default.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+        const { line: endLine, character: endCharacter } = ohos_typescript_1.default.getLineAndCharacterOfPosition(sourceFile, node.getEnd());
+        // line start from 1
+        return new FullPosition(startLine + 1, startCharacter + 1, endLine + 1, endCharacter + 1);
+    }
+    static merge(leftMostPosition, rightMostPosition) {
+        return new FullPosition(leftMostPosition.getFirstLine(), leftMostPosition.getFirstCol(), rightMostPosition.getLastLine(), rightMostPosition.getLastCol());
+    }
+}
+exports.FullPosition = FullPosition;
+FullPosition.DEFAULT = new FullPosition(-1, -1, -1, -1);

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

@@ -0,0 +1,75 @@
+import { FieldSignature } from '../model/ArkSignature';
+import { Local } from './Local';
+import { ClassType, Type } from './Type';
+import { Value } from './Value';
+import { ArkClass } from '../model/ArkClass';
+/**
+ * @category core/base/ref
+ */
+export declare abstract class AbstractRef implements Value {
+    abstract getUses(): Value[];
+    abstract getType(): Type;
+    inferType(arkClass: ArkClass): AbstractRef;
+}
+export declare class ArkArrayRef extends AbstractRef {
+    private base;
+    private index;
+    constructor(base: Local, index: Value);
+    getBase(): Local;
+    setBase(newBase: Local): void;
+    getIndex(): Value;
+    setIndex(newIndex: Value): void;
+    getType(): Type;
+    getUses(): Value[];
+    toString(): string;
+}
+export declare abstract class AbstractFieldRef extends AbstractRef {
+    private fieldSignature;
+    constructor(fieldSignature: FieldSignature);
+    getFieldName(): string;
+    getFieldSignature(): FieldSignature;
+    setFieldSignature(newFieldSignature: FieldSignature): void;
+    getType(): Type;
+}
+export declare class ArkInstanceFieldRef extends AbstractFieldRef {
+    private base;
+    constructor(base: Local, fieldSignature: FieldSignature);
+    getBase(): Local;
+    setBase(newBase: Local): void;
+    getUses(): Value[];
+    toString(): string;
+    inferType(arkClass: ArkClass): AbstractRef;
+    private getNewFieldSignature;
+}
+export declare class ArkStaticFieldRef extends AbstractFieldRef {
+    constructor(fieldSignature: FieldSignature);
+    getUses(): Value[];
+    toString(): string;
+}
+export declare class ArkParameterRef extends AbstractRef {
+    private index;
+    private paramType;
+    constructor(index: number, paramType: Type);
+    getIndex(): number;
+    getType(): Type;
+    setType(newType: Type): void;
+    inferType(arkClass: ArkClass): AbstractRef;
+    getUses(): Value[];
+    toString(): string;
+}
+export declare class ArkThisRef extends AbstractRef {
+    private type;
+    constructor(type: ClassType);
+    inferType(arkClass: ArkClass): AbstractRef;
+    getType(): ClassType;
+    getUses(): Value[];
+    toString(): string;
+}
+export declare class ArkCaughtExceptionRef extends AbstractRef {
+    private type;
+    constructor(type: Type);
+    getType(): Type;
+    getUses(): Value[];
+    toString(): string;
+}
+//# sourceMappingURL=Ref.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Ref.d.ts","sourceRoot":"","sources":["../../../src/core/base/Ref.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAiB,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAsC,SAAS,EAAE,IAAI,EAAqC,MAAM,QAAQ,CAAC;AAChH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAiB,MAAM,mBAAmB,CAAC;AAS5D;;GAEG;AACH,8BAAsB,WAAY,YAAW,KAAK;IAC9C,QAAQ,CAAC,OAAO,IAAI,KAAK,EAAE;IAE3B,QAAQ,CAAC,OAAO,IAAI,IAAI;IAEjB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW;CAGpD;AAED,qBAAa,WAAY,SAAQ,WAAW;IACxC,OAAO,CAAC,IAAI,CAAQ;IACpB,OAAO,CAAC,KAAK,CAAQ;gBAET,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK;IAM9B,OAAO,IAAI,KAAK;IAIhB,OAAO,CAAC,OAAO,EAAE,KAAK,GAAG,IAAI;IAI7B,QAAQ,IAAI,KAAK;IAIjB,QAAQ,CAAC,QAAQ,EAAE,KAAK,GAAG,IAAI;IAI/B,OAAO,IAAI,IAAI;IAUf,OAAO,IAAI,KAAK,EAAE;IASlB,QAAQ,IAAI,MAAM;CAG5B;AAED,8BAAsB,gBAAiB,SAAQ,WAAW;IACtD,OAAO,CAAC,cAAc,CAAiB;gBAE3B,cAAc,EAAE,cAAc;IAKnC,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,cAAc;IAInC,iBAAiB,CAAC,iBAAiB,EAAE,cAAc,GAAG,IAAI;IAI1D,OAAO,IAAI,IAAI;CAGzB;AAED,qBAAa,mBAAoB,SAAQ,gBAAgB;IACrD,OAAO,CAAC,IAAI,CAAQ;gBAER,IAAI,EAAE,KAAK,EAAE,cAAc,EAAE,cAAc;IAKhD,OAAO,IAAI,KAAK;IAIhB,OAAO,CAAC,OAAO,EAAE,KAAK,GAAG,IAAI;IAI7B,OAAO,IAAI,KAAK,EAAE;IAOlB,QAAQ,IAAI,MAAM;IAIlB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW;IA8BjD,OAAO,CAAC,oBAAoB;CA0B/B;AAED,qBAAa,iBAAkB,SAAQ,gBAAgB;gBACvC,cAAc,EAAE,cAAc;IAInC,OAAO,IAAI,KAAK,EAAE;IAIlB,QAAQ,IAAI,MAAM;CAG5B;AAED,qBAAa,eAAgB,SAAQ,WAAW;IAC5C,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,SAAS,CAAO;gBAEZ,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI;IAMnC,QAAQ,IAAI,MAAM;IAIlB,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAI5B,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW;IAQ1C,OAAO,IAAI,KAAK,EAAE;IAIlB,QAAQ,IAAI,MAAM;CAG5B;AAGD,qBAAa,UAAW,SAAQ,WAAW;IACvC,OAAO,CAAC,IAAI,CAAY;gBAEZ,IAAI,EAAE,SAAS;IAKpB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW;IAW1C,OAAO,IAAI,SAAS;IAIpB,OAAO,IAAI,KAAK,EAAE;IAIlB,QAAQ,IAAI,MAAM;CAG5B;AAED,qBAAa,qBAAsB,SAAQ,WAAW;IAClD,OAAO,CAAC,IAAI,CAAO;gBAEP,IAAI,EAAE,IAAI;IAKf,OAAO,IAAI,IAAI;IAIf,OAAO,IAAI,KAAK,EAAE;IAIlB,QAAQ,IAAI,MAAM;CAG5B"}

package/lib/core/base/Ref.js

@@ -0,0 +1,286 @@
+"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.ArkCaughtExceptionRef = exports.ArkThisRef = exports.ArkParameterRef = exports.ArkStaticFieldRef = exports.ArkInstanceFieldRef = exports.AbstractFieldRef = exports.ArkArrayRef = exports.AbstractRef = void 0;
+const logger_1 = __importStar(require("../../utils/logger"));
+const ArkSignature_1 = require("../model/ArkSignature");
+const Local_1 = require("./Local");
+const Type_1 = require("./Type");
+const ArkClass_1 = require("../model/ArkClass");
+const TypeInference_1 = require("../common/TypeInference");
+const ValueUtil_1 = require("../common/ValueUtil");
+const ArkField_1 = require("../model/ArkField");
+const ArkMethod_1 = require("../model/ArkMethod");
+const Const_1 = require("../common/Const");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'Ref');
+/**
+ * @category core/base/ref
+ */
+class AbstractRef {
+    inferType(arkClass) {
+        return this;
+    }
+}
+exports.AbstractRef = AbstractRef;
+class ArkArrayRef extends AbstractRef {
+    constructor(base, index) {
+        super();
+        this.base = base;
+        this.index = index;
+    }
+    getBase() {
+        return this.base;
+    }
+    setBase(newBase) {
+        this.base = newBase;
+    }
+    getIndex() {
+        return this.index;
+    }
+    setIndex(newIndex) {
+        this.index = newIndex;
+    }
+    getType() {
+        const baseType = this.base.getType();
+        if (baseType instanceof Type_1.ArrayType) {
+            return baseType.getBaseType();
+        }
+        else {
+            logger.warn(`the type of base in ArrayRef is not ArrayType`);
+            return Type_1.UnknownType.getInstance();
+        }
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.base);
+        uses.push(...this.base.getUses());
+        uses.push(this.index);
+        uses.push(...this.index.getUses());
+        return uses;
+    }
+    toString() {
+        return this.base + '[' + this.index + ']';
+    }
+}
+exports.ArkArrayRef = ArkArrayRef;
+class AbstractFieldRef extends AbstractRef {
+    constructor(fieldSignature) {
+        super();
+        this.fieldSignature = fieldSignature;
+    }
+    getFieldName() {
+        return this.fieldSignature.getFieldName();
+    }
+    getFieldSignature() {
+        return this.fieldSignature;
+    }
+    setFieldSignature(newFieldSignature) {
+        this.fieldSignature = newFieldSignature;
+    }
+    getType() {
+        return this.fieldSignature.getType();
+    }
+}
+exports.AbstractFieldRef = AbstractFieldRef;
+class ArkInstanceFieldRef extends AbstractFieldRef {
+    constructor(base, fieldSignature) {
+        super(fieldSignature);
+        this.base = base;
+    }
+    getBase() {
+        return this.base;
+    }
+    setBase(newBase) {
+        this.base = newBase;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.base);
+        uses.push(...this.base.getUses());
+        return uses;
+    }
+    toString() {
+        return this.base.toString() + '.<' + this.getFieldSignature() + '>';
+    }
+    inferType(arkClass) {
+        let baseType = this.base.getType();
+        if (this.base instanceof Local_1.Local && baseType instanceof Type_1.UnknownType) {
+            baseType = TypeInference_1.TypeInference.inferBaseType(this.base.getName(), arkClass);
+            if (!baseType && (arkClass.hasComponentDecorator() || arkClass.getCategory() === ArkClass_1.ClassCategory.OBJECT)) {
+                const global = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(this.base.getName());
+                baseType = TypeInference_1.TypeInference.parseArkExport2Type(global);
+            }
+        }
+        else if (baseType instanceof Type_1.UnclearReferenceType) {
+            baseType = TypeInference_1.TypeInference.inferUnclearReferenceType(baseType.getName(), arkClass);
+        }
+        if (!baseType) {
+            logger.warn('infer field ref base type fail: ' + this.toString());
+            return this;
+        }
+        if (this.base instanceof Local_1.Local) {
+            this.base.setType(baseType);
+        }
+        if (baseType instanceof Type_1.ArrayType && this.getFieldName() !== 'length') {
+            return new ArkArrayRef(this.base, ValueUtil_1.ValueUtil.createConst(this.getFieldName()));
+        }
+        const newFieldSignature = this.getNewFieldSignature(arkClass, baseType);
+        if (newFieldSignature.isStatic()) {
+            return new ArkStaticFieldRef(newFieldSignature);
+        }
+        else {
+            this.setFieldSignature(newFieldSignature);
+        }
+        return this;
+    }
+    getNewFieldSignature(arkClass, baseType) {
+        var _a;
+        let oldFieldSignature = this.getFieldSignature();
+        const propertyAndType = TypeInference_1.TypeInference.inferFieldType(baseType, this.getFieldName(), arkClass);
+        let propertyType = (_a = propertyAndType === null || propertyAndType === void 0 ? void 0 : propertyAndType[1]) !== null && _a !== void 0 ? _a : oldFieldSignature.getType();
+        if (TypeInference_1.TypeInference.isUnclearType(propertyType)) {
+            const newType = TypeInference_1.TypeInference.inferUnclearedType(propertyType, arkClass);
+            if (newType) {
+                propertyType = newType;
+            }
+        }
+        let staticFlag;
+        let signature;
+        if (baseType instanceof Type_1.ClassType) {
+            const property = propertyAndType === null || propertyAndType === void 0 ? void 0 : propertyAndType[0];
+            staticFlag = baseType.getClassSignature().getClassName() === Const_1.DEFAULT_ARK_CLASS_NAME ||
+                ((property instanceof ArkMethod_1.ArkMethod || property instanceof ArkField_1.ArkField) && property.isStatic());
+            signature = baseType.getClassSignature();
+        }
+        else if (baseType instanceof Type_1.AnnotationNamespaceType) {
+            staticFlag = true;
+            signature = baseType.getNamespaceSignature();
+        }
+        else {
+            staticFlag = oldFieldSignature.isStatic();
+            signature = oldFieldSignature.getDeclaringSignature();
+        }
+        return new ArkSignature_1.FieldSignature(this.getFieldName(), signature, propertyType, staticFlag);
+    }
+}
+exports.ArkInstanceFieldRef = ArkInstanceFieldRef;
+class ArkStaticFieldRef extends AbstractFieldRef {
+    constructor(fieldSignature) {
+        super(fieldSignature);
+    }
+    getUses() {
+        return [];
+    }
+    toString() {
+        return this.getFieldSignature().toString();
+    }
+}
+exports.ArkStaticFieldRef = ArkStaticFieldRef;
+class ArkParameterRef extends AbstractRef {
+    constructor(index, paramType) {
+        super();
+        this.index = index;
+        this.paramType = paramType;
+    }
+    getIndex() {
+        return this.index;
+    }
+    getType() {
+        return this.paramType;
+    }
+    setType(newType) {
+        this.paramType = newType;
+    }
+    inferType(arkClass) {
+        let type = TypeInference_1.TypeInference.inferUnclearedType(this.paramType, arkClass);
+        if (type) {
+            this.paramType = type;
+        }
+        return this;
+    }
+    getUses() {
+        return [];
+    }
+    toString() {
+        return 'parameter' + this.index + ': ' + this.paramType;
+    }
+}
+exports.ArkParameterRef = ArkParameterRef;
+class ArkThisRef extends AbstractRef {
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    inferType(arkClass) {
+        const className = this.type.getClassSignature().getClassName();
+        if (className.startsWith(Const_1.ANONYMOUS_CLASS_PREFIX)) {
+            let type = TypeInference_1.TypeInference.inferBaseType(className.split(Const_1.ANONYMOUS_CLASS_DELIMITER)[1], arkClass);
+            if (type instanceof Type_1.ClassType) {
+                this.type = type;
+            }
+        }
+        return this;
+    }
+    getType() {
+        return this.type;
+    }
+    getUses() {
+        return [];
+    }
+    toString() {
+        return 'this: ' + this.type;
+    }
+}
+exports.ArkThisRef = ArkThisRef;
+class ArkCaughtExceptionRef extends AbstractRef {
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    getType() {
+        return this.type;
+    }
+    getUses() {
+        return [];
+    }
+    toString() {
+        return 'caughtexception: ' + this.type;
+    }
+}
+exports.ArkCaughtExceptionRef = ArkCaughtExceptionRef;