arkanalyzer 1.0.41 → 1.0.43

package/lib/pass/Context.d.ts

@@ -0,0 +1,47 @@
+export type AnyKey<T> = {
+    new (): T;
+};
+export interface CtxArg {
+    readonly name: string;
+}
+export type UniMap<T> = Map<AnyKey<T>, T>;
+interface Upper {
+    readonly upper: Upper;
+    readonly unreachable: boolean;
+}
+/**
+ * Represents the root implementation of the Upper interface.
+ * Provides a singleton instance to ensure a single point of access.
+ * The class is designed to maintain immutability for its properties.
+ * The `getInstance` method allows retrieval of the singleton instance.
+ */
+export declare class UpperRoot implements Upper {
+    readonly upper: any;
+    readonly unreachable = true;
+    private static INSTANCE;
+    static getInstance(): UpperRoot;
+}
+/**
+ * Represents a context that manages a map of arguments and provides methods to manipulate them.
+ * Implements the Upper interface, allowing for hierarchical structures.
+ * The context maintains a reference to its upper context and provides utilities to traverse the hierarchy.
+ *
+ * The `unreachable` property indicates whether this context is considered unreachable in the hierarchy.
+ * The `upper` property refers to the parent or enclosing context.
+ * The `args` property is a map that stores key-value pairs specific to this context.
+ *
+ * Provides methods to retrieve, add, and remove entries from the argument map.
+ * Allows traversal to the root context in the hierarchy by following the chain of upper contexts.
+ */
+export declare class Context<U extends Upper, T> implements Upper {
+    unreachable: boolean;
+    upper: U;
+    protected args: UniMap<T>;
+    constructor(upper: U);
+    get<K extends T>(k: AnyKey<K>): K | undefined;
+    set<K extends T>(k: AnyKey<K>, v: K): void;
+    remove<K extends T>(k: AnyKey<K>): K | undefined;
+    root(): Upper;
+}
+export {};
+//# sourceMappingURL=Context.d.ts.map

package/lib/pass/Context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../src/pass/Context.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IAAE,QAAO,CAAC,CAAA;CAAE,CAAC;AAErC,MAAM,WAAW,MAAM;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACzB;AAGD,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE1C,UAAU,KAAK;IACX,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CACjC;AAED;;;;;GAKG;AACH,qBAAa,SAAU,YAAW,KAAK;IACnC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC;IACpB,QAAQ,CAAC,WAAW,QAAQ;IAC5B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAmB;IAE1C,MAAM,CAAC,WAAW,IAAI,SAAS;CAGlC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,OAAO,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,CAAE,YAAW,KAAK;IACrD,WAAW,EAAE,OAAO,CAAS;IAC7B,KAAK,EAAE,CAAC,CAAC;IACT,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;gBAEd,KAAK,EAAE,CAAC;IAKpB,GAAG,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS;IAI7C,GAAG,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI;IAI1C,MAAM,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS;IAMhD,IAAI,IAAI,KAAK;CAQhB"}

package/lib/pass/Context.js

@@ -0,0 +1,72 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 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.Context = exports.UpperRoot = void 0;
+/**
+ * Represents the root implementation of the Upper interface.
+ * Provides a singleton instance to ensure a single point of access.
+ * The class is designed to maintain immutability for its properties.
+ * The `getInstance` method allows retrieval of the singleton instance.
+ */
+class UpperRoot {
+    constructor() {
+        this.unreachable = true;
+    }
+    static getInstance() {
+        return UpperRoot.INSTANCE;
+    }
+}
+exports.UpperRoot = UpperRoot;
+UpperRoot.INSTANCE = new UpperRoot();
+/**
+ * Represents a context that manages a map of arguments and provides methods to manipulate them.
+ * Implements the Upper interface, allowing for hierarchical structures.
+ * The context maintains a reference to its upper context and provides utilities to traverse the hierarchy.
+ *
+ * The `unreachable` property indicates whether this context is considered unreachable in the hierarchy.
+ * The `upper` property refers to the parent or enclosing context.
+ * The `args` property is a map that stores key-value pairs specific to this context.
+ *
+ * Provides methods to retrieve, add, and remove entries from the argument map.
+ * Allows traversal to the root context in the hierarchy by following the chain of upper contexts.
+ */
+class Context {
+    constructor(upper) {
+        this.unreachable = false;
+        this.upper = upper;
+        this.args = new Map();
+    }
+    get(k) {
+        return this.args.get(k);
+    }
+    set(k, v) {
+        this.args.set(k, v);
+    }
+    remove(k) {
+        const v = this.get(k);
+        this.args.delete(k);
+        return v;
+    }
+    root() {
+        let up = this;
+        // upper is root,
+        while (!up.upper.unreachable) {
+            up = up.upper;
+        }
+        return up;
+    }
+}
+exports.Context = Context;

package/lib/pass/Dispatcher.d.ts

@@ -0,0 +1,102 @@
+import type { Value } from '../core/base/Value';
+import { ArkAliasTypeDefineStmt, ArkAssignStmt, ArkIfStmt, ArkInvokeStmt, ArkReturnStmt, ArkReturnVoidStmt, ArkThrowStmt, Stmt } from '../core/base/Stmt';
+import { AbstractBinopExpr, AbstractExpr, AbstractInvokeExpr, AliasTypeExpr, ArkAwaitExpr, ArkCastExpr, ArkConditionExpr, ArkDeleteExpr, ArkInstanceInvokeExpr, ArkInstanceOfExpr, ArkNewArrayExpr, ArkNewExpr, ArkNormalBinopExpr, ArkPhiExpr, ArkPtrInvokeExpr, ArkStaticInvokeExpr, ArkTypeOfExpr, ArkUnopExpr, ArkYieldExpr } from '../core/base/Expr';
+import { FallAction, MethodCtx } from './Pass';
+import { BigIntConstant, BooleanConstant, Constant, NullConstant, NumberConstant, StringConstant, UndefinedConstant } from '../core/base/Constant';
+import type { ArkMethod } from '../core/model/ArkMethod';
+import { Local } from '../core/base/Local';
+import { AbstractFieldRef, AbstractRef, ArkCaughtExceptionRef, ArkInstanceFieldRef, ArkParameterRef, ArkStaticFieldRef, ArkThisRef, ClosureFieldRef, GlobalRef } from '../core/base/Ref';
+/**
+ * Represents a function type that processes a value and context, optionally returning a FallAction to control flow.
+ * This function is invoked with a value of type T , a context object and a method object, and it can decide whether to skip subsequent passes.
+
+ * @param value:T - The inst to be executed
+ * @param ctx:MethodCtx - The method context of this inst
+ * @param mtd:ArkMethod - The method of this inst
+ * @returns  If a FallAction is returned, it indicates the action to take regarding skipping or halting further processing.
+ *           Returning nothing or void implies no special action, allowing the next passes to execute normally.
+ */
+export interface InstPass<T> {
+    (value: T, ctx: MethodCtx, mtd: ArkMethod): FallAction | void;
+}
+type IndexOf<T extends readonly any[]> = Extract<keyof T, `${number}`>;
+/**
+ * Represents all statement types used within the system.
+ */
+declare const STMTS: readonly [typeof ArkAssignStmt, typeof ArkInvokeStmt, typeof ArkIfStmt, typeof ArkReturnStmt, typeof ArkReturnVoidStmt, typeof ArkThrowStmt, typeof ArkAliasTypeDefineStmt, typeof Stmt];
+/**
+ * class of stmts
+ */
+export type StmtClass = typeof STMTS[number];
+/**
+ * stmts classes
+ */
+export type StmtTy = {
+    [K in IndexOf<typeof STMTS>]: InstanceType<typeof STMTS[K]>;
+}[IndexOf<typeof STMTS>];
+type StmtPass = {
+    [K in IndexOf<typeof STMTS>]: InstPass<InstanceType<typeof STMTS[K]>>;
+}[IndexOf<typeof STMTS>];
+type StmtList<S extends StmtClass> = [S, InstPass<InstanceType<S>>[] | InstPass<InstanceType<S>>];
+/**
+ * Represents an initialization statement type derived from the `STMTS` constant.
+ * This type maps each index of the `STMTS` array to a corresponding `StmtList` type,
+ * effectively creating a union of all possible statement list types defined by `STMTS`.
+ * It is used to ensure type safety and consistency when working with statement lists
+ * associated with the `STMTS` entries.
+ */
+export type StmtInit = {
+    [K in IndexOf<typeof STMTS>]: StmtList<typeof STMTS[K]>;
+}[IndexOf<typeof STMTS>];
+/**
+ * Represents all values types used within the system.
+ */
+declare const VALUES: readonly [typeof AliasTypeExpr, typeof ArkUnopExpr, typeof ArkPhiExpr, typeof ArkCastExpr, typeof ArkInstanceOfExpr, typeof ArkTypeOfExpr, typeof ArkNormalBinopExpr, typeof ArkConditionExpr, typeof AbstractBinopExpr, typeof ArkYieldExpr, typeof ArkAwaitExpr, typeof ArkDeleteExpr, typeof ArkNewArrayExpr, typeof ArkNewExpr, typeof ArkPtrInvokeExpr, typeof ArkStaticInvokeExpr, typeof ArkInstanceInvokeExpr, typeof AbstractInvokeExpr, typeof AbstractExpr, typeof ClosureFieldRef, typeof GlobalRef, typeof ArkCaughtExceptionRef, typeof ArkThisRef, typeof ArkParameterRef, typeof ArkStaticFieldRef, typeof ArkInstanceFieldRef, typeof AbstractFieldRef, typeof AbstractRef, typeof UndefinedConstant, typeof NullConstant, typeof StringConstant, typeof BigIntConstant, typeof NumberConstant, typeof BooleanConstant, typeof Constant, typeof Local];
+/**
+ * class of stmts
+ */
+type ValueClass = typeof VALUES[number];
+/**
+ * stmts classes
+ */
+export type ValueTy = {
+    [K in IndexOf<typeof VALUES>]: InstanceType<typeof VALUES[K]>;
+}[IndexOf<typeof VALUES>];
+type ValuePass = {
+    [K in IndexOf<typeof VALUES>]: InstPass<InstanceType<typeof VALUES[K]>>;
+}[IndexOf<typeof VALUES>];
+type ValuePair<S extends ValueClass> = [S, InstPass<InstanceType<S>>[] | InstPass<InstanceType<S>>];
+/**
+ * Represents an initialization value for a specific index in the VALUES array.
+ * This type maps each index of the VALUES array to a corresponding ValuePair type,
+ * ensuring that only valid initialization values for the given index are allowed.
+ * The resulting type is a union of all possible ValuePair types derived from the VALUES array.
+ */
+export type ValueInit = {
+    [K in IndexOf<typeof VALUES>]: ValuePair<typeof VALUES[K]>;
+}[IndexOf<typeof VALUES>];
+/**
+ * the dispatch table, it can be cached
+ */
+export declare class Dispatch {
+    name: string;
+    readonly stmts: StmtClass[];
+    readonly smap: Map<StmtClass, StmtPass[]>;
+    readonly values: ValueClass[];
+    readonly vmap: Map<ValueClass, ValuePass[]>;
+    constructor(stmts?: StmtInit[], values?: ValueInit[]);
+}
+/**
+ * the ArkIR dispatcher, to dispatch stmts and values actions
+ */
+export declare class Dispatcher {
+    private readonly ctx;
+    protected fallAction: FallAction;
+    private readonly dispatch;
+    private cache;
+    constructor(ctx: MethodCtx, dispatch?: Dispatch);
+    dispatchStmt(mtd: ArkMethod, stmt: Stmt): void;
+    dispatchValue(mtd: ArkMethod, value: Value): void;
+}
+export {};
+//# sourceMappingURL=Dispatcher.d.ts.map

package/lib/pass/Dispatcher.d.ts.map

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

package/lib/pass/Dispatcher.js

@@ -0,0 +1,202 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 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.Dispatcher = exports.Dispatch = void 0;
+const Stmt_1 = require("../core/base/Stmt");
+const Expr_1 = require("../core/base/Expr");
+const Constant_1 = require("../core/base/Constant");
+const logger_1 = __importStar(require("../utils/logger"));
+const Local_1 = require("../core/base/Local");
+const Ref_1 = require("../core/base/Ref");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'Inst');
+/**
+ * Represents all statement types used within the system.
+ */
+const STMTS = [
+    Stmt_1.ArkAssignStmt,
+    Stmt_1.ArkInvokeStmt,
+    Stmt_1.ArkIfStmt,
+    Stmt_1.ArkReturnStmt,
+    Stmt_1.ArkReturnVoidStmt,
+    Stmt_1.ArkThrowStmt,
+    Stmt_1.ArkAliasTypeDefineStmt,
+    Stmt_1.Stmt,
+];
+/**
+ * Represents all values types used within the system.
+ */
+const VALUES = [
+    // expr
+    Expr_1.AliasTypeExpr,
+    Expr_1.ArkUnopExpr,
+    Expr_1.ArkPhiExpr,
+    Expr_1.ArkCastExpr,
+    Expr_1.ArkInstanceOfExpr,
+    Expr_1.ArkTypeOfExpr,
+    Expr_1.ArkNormalBinopExpr,
+    Expr_1.ArkConditionExpr,
+    Expr_1.AbstractBinopExpr,
+    Expr_1.ArkYieldExpr,
+    Expr_1.ArkAwaitExpr,
+    Expr_1.ArkDeleteExpr,
+    Expr_1.ArkNewArrayExpr,
+    Expr_1.ArkNewExpr,
+    Expr_1.ArkPtrInvokeExpr,
+    Expr_1.ArkStaticInvokeExpr,
+    Expr_1.ArkInstanceInvokeExpr,
+    Expr_1.AbstractInvokeExpr,
+    Expr_1.AbstractExpr,
+    // ref
+    Ref_1.ClosureFieldRef,
+    Ref_1.GlobalRef,
+    Ref_1.ArkCaughtExceptionRef,
+    Ref_1.ArkThisRef,
+    Ref_1.ArkParameterRef,
+    Ref_1.ArkStaticFieldRef,
+    Ref_1.ArkInstanceFieldRef,
+    Ref_1.AbstractFieldRef,
+    Ref_1.AbstractRef,
+    // constant
+    Constant_1.UndefinedConstant,
+    Constant_1.NullConstant,
+    Constant_1.StringConstant,
+    Constant_1.BigIntConstant,
+    Constant_1.NumberConstant,
+    Constant_1.BooleanConstant,
+    Constant_1.Constant,
+    // local
+    Local_1.Local,
+];
+/**
+ * the dispatch table, it can be cached
+ */
+class Dispatch {
+    constructor(stmts = [], values = []) {
+        this.name = 'dispatch';
+        this.stmts = [];
+        this.smap = new Map();
+        this.values = [];
+        this.vmap = new Map();
+        this.stmts = stmts.map(v => v[0]);
+        const smap = new Map();
+        for (const [k, v] of stmts) {
+            if (Array.isArray(v)) {
+                smap.set(k, v);
+            }
+            else {
+                smap.set(k, [v]);
+            }
+        }
+        // replace it, in case of modified
+        this.smap = smap;
+        this.values = values.map(v => v[0]);
+        const vmap = new Map();
+        for (const [k, v] of values) {
+            if (Array.isArray(v)) {
+                vmap.set(k, v);
+            }
+            else {
+                vmap.set(k, [v]);
+            }
+        }
+        // replace it, in case of modified
+        this.vmap = vmap;
+    }
+}
+exports.Dispatch = Dispatch;
+/**
+ * the ArkIR dispatcher, to dispatch stmts and values actions
+ */
+class Dispatcher {
+    constructor(ctx, dispatch = new Dispatch()) {
+        // action when match stmts
+        this.fallAction = 1 /* FallAction.Break */;
+        // value cache to prevent cycle dependencies
+        this.cache = new Set();
+        this.ctx = ctx;
+        this.dispatch = dispatch;
+    }
+    dispatchStmt(mtd, stmt) {
+        var _a;
+        logger.debug(`dispatch stmt ${stmt}`);
+        const tys = this.dispatch.stmts;
+        for (let ty of tys) {
+            if (stmt instanceof ty) {
+                let pass = (_a = this.dispatch.smap.get(ty)) !== null && _a !== void 0 ? _a : [];
+                for (const p of pass) {
+                    p(stmt, this.ctx, mtd);
+                }
+                if (this.fallAction === 1 /* FallAction.Break */) {
+                    break;
+                }
+            }
+        }
+        for (let use of stmt.getUses()) {
+            this.dispatchValue(mtd, use);
+        }
+    }
+    dispatchValue(mtd, value) {
+        var _a;
+        logger.debug(`dispatch value ${value}`);
+        // skip uses if there is no value pass
+        if (this.dispatch.values.length === 0) {
+            return;
+        }
+        if (this.cache.has(value)) {
+            return;
+        }
+        this.cache.add(value);
+        const tys = this.dispatch.values;
+        for (let ty of tys) {
+            if (value instanceof ty) {
+                let pass = (_a = this.dispatch.vmap.get(ty)) !== null && _a !== void 0 ? _a : [];
+                for (const p of pass) {
+                    p(value, this.ctx, mtd);
+                }
+                if (this.fallAction === 1 /* FallAction.Break */) {
+                    break;
+                }
+            }
+        }
+        for (let use of value.getUses()) {
+            this.dispatchValue(mtd, use);
+        }
+    }
+}
+exports.Dispatcher = Dispatcher;

package/lib/pass/Pass.d.ts

@@ -0,0 +1,83 @@
+import { Context, CtxArg } from './Context';
+import { SceneCtx } from './ScenePassMgr';
+import type { ArkFile } from '../core/model/ArkFile';
+import type { ArkClass } from '../core/model/ArkClass';
+import type { ArkMethod } from '../core/model/ArkMethod';
+/**
+    fallthrough actions
+    Continue: will run next pass
+    Break: will break the pass list
+*/
+export declare const enum FallAction {
+    Continue = 0,
+    Break = 1
+}
+/**
+ * Represents an abstract file responsible for handling file-related operations.
+ * The ClassPass class is designed to define a contract for executing specific logic
+ * when processing a given class within a particular context. Implementations of this
+ * class are expected to provide concrete behavior for the `run` method.
+ *
+ * @param cls:ArkFile - The class to be executed
+ * @param ctx:FileCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+export declare abstract class FilePass {
+    abstract run(file: ArkFile, ctx: FileCtx): FallAction | void;
+}
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The FileCtx is bound to a SceneCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+export declare class FileCtx extends Context<SceneCtx, CtxArg> {
+    root(): SceneCtx;
+}
+/**
+ * Represents an abstract class responsible for handling class-related operations.
+ * The ClassPass class is designed to define a contract for executing specific logic
+ * when processing a given class within a particular context. Implementations of this
+ * class are expected to provide concrete behavior for the `run` method.
+ *
+ * @param cls:ArkClass - The class to be executed
+ * @param ctx:ClassCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+export declare abstract class ClassPass {
+    abstract run(cls: ArkClass, ctx: ClassCtx): FallAction | void;
+}
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The ClassCtx is bound to a FileCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+export declare class ClassCtx extends Context<FileCtx, CtxArg> {
+    root(): SceneCtx;
+}
+/**
+ * Represents an abstract class for executing a method within a specific context.
+ * The MethodPass class is designed to be extended by concrete implementations
+ * that define how a given method should be processed or executed.
+ *
+ * The `run` method must be implemented by subclasses to provide the logic
+ * for handling the execution of the provided method using the given context.
+ *
+ * @param method: ArkMethod - The method to be executed
+ * @param ctx: MethodCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+export declare abstract class MethodPass {
+    abstract run(method: ArkMethod, ctx: MethodCtx): FallAction | void;
+}
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The MethodCtx is bound to a ClassCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+export declare class MethodCtx extends Context<ClassCtx, CtxArg> {
+    root(): SceneCtx;
+}
+//# sourceMappingURL=Pass.d.ts.map

package/lib/pass/Pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pass.d.ts","sourceRoot":"","sources":["../../src/pass/Pass.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD;;;;EAIE;AACF,0BAAkB,UAAU;IACxB,QAAQ,IAAA;IACR,KAAK,IAAA;CACR;AAED;;;;;;;;;GASG;AACH,8BAAsB,QAAQ;IAC1B,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI;CAC/D;AAED;;;;;GAKG;AACH,qBAAa,OAAQ,SAAQ,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC;IAClD,IAAI,IAAI,QAAQ;CAGnB;AAGD;;;;;;;;;GASG;AACH,8BAAsB,SAAS;IAC3B,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;CAChE;AAGD;;;;;GAKG;AACH,qBAAa,QAAS,SAAQ,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC;IAClD,IAAI,IAAI,QAAQ;CAGnB;AAED;;;;;;;;;;;GAWG;AACH,8BAAsB,UAAU;IAC5B,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG,UAAU,GAAG,IAAI;CACrE;AAED;;;;;GAKG;AACH,qBAAa,SAAU,SAAQ,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC;IACpD,IAAI,IAAI,QAAQ;CAGnB"}

package/lib/pass/Pass.js

@@ -0,0 +1,95 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 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.MethodCtx = exports.MethodPass = exports.ClassCtx = exports.ClassPass = exports.FileCtx = exports.FilePass = void 0;
+const Context_1 = require("./Context");
+/**
+ * Represents an abstract file responsible for handling file-related operations.
+ * The ClassPass class is designed to define a contract for executing specific logic
+ * when processing a given class within a particular context. Implementations of this
+ * class are expected to provide concrete behavior for the `run` method.
+ *
+ * @param cls:ArkFile - The class to be executed
+ * @param ctx:FileCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+class FilePass {
+}
+exports.FilePass = FilePass;
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The FileCtx is bound to a SceneCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+class FileCtx extends Context_1.Context {
+    root() {
+        return this.upper.root();
+    }
+}
+exports.FileCtx = FileCtx;
+/**
+ * Represents an abstract class responsible for handling class-related operations.
+ * The ClassPass class is designed to define a contract for executing specific logic
+ * when processing a given class within a particular context. Implementations of this
+ * class are expected to provide concrete behavior for the `run` method.
+ *
+ * @param cls:ArkClass - The class to be executed
+ * @param ctx:ClassCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+class ClassPass {
+}
+exports.ClassPass = ClassPass;
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The ClassCtx is bound to a FileCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+class ClassCtx extends Context_1.Context {
+    root() {
+        return this.upper.root();
+    }
+}
+exports.ClassCtx = ClassCtx;
+/**
+ * Represents an abstract class for executing a method within a specific context.
+ * The MethodPass class is designed to be extended by concrete implementations
+ * that define how a given method should be processed or executed.
+ *
+ * The `run` method must be implemented by subclasses to provide the logic
+ * for handling the execution of the provided method using the given context.
+ *
+ * @param method: ArkMethod - The method to be executed
+ * @param ctx: MethodCtx - The context used in executed
+ * @returns The result of the method execution, which can be of FallAction or void.
+ */
+class MethodPass {
+}
+exports.MethodPass = MethodPass;
+/**
+ * Represents a specialized context class that extends the base Context class with specific types.
+ * Provides functionality to access the root context within a hierarchical structure.
+ * The MethodCtx is bound to a ClassCtx and CtxArg, defining its operational scope.
+ * The root method retrieves the top-level SceneCtx by traversing the context hierarchy.
+ */
+class MethodCtx extends Context_1.Context {
+    root() {
+        return this.upper.root();
+    }
+}
+exports.MethodCtx = MethodCtx;