@lcap/nasl-language-server-core 4.1.0-rc.3 → 4.1.0-rc.4

package/out/reference-manager/reference-manager.js

@@ -1,125 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSubViews = exports.cheapTestLocalSymbol = exports.getNamespaceWithoutLast = exports.getDatasourceQName = exports.handleEntityAutoRef = exports.isEntityLogic = exports.easyGetOldQName = exports.ReferenceManager = void 0;
+exports.handleEntityAutoRef = exports.easyGetOldQName = exports.ReferenceManager = void 0;
 const nasl_concepts_1 = require("@lcap/nasl-concepts");
 const mnemonist_1 = require("mnemonist");
 const fp_macros_1 = require("../utils/fp-macros");
 const console_1 = require("console");
 const builtin_q_name_1 = require("./builtin-q-name");
-const collect_q_name_1 = require("./collect-q-name");
+const build_q_name_def_1 = require("./build-q-name-def");
+const get_q_name_1 = require("./get-q-name");
 const typer_1 = require("../typer");
 const type_predicate_1 = require("../typer/type-predicate");
 const helper_1 = require("../typer/helper");
 const component_def_manager_1 = require("../typer/component-def-manager/component-def-manager");
-const get_q_name_1 = require("./get-q-name");
 const string_1 = require("../utils/string");
 const symbol_type_1 = require("./symbol-type");
 const update_nasl_fragment_1 = require("./update-nasl-fragment");
-const nasl_predicate_1 = require("../typer/nasl-predicate");
+const special_string_ref_1 = require("./special-string-ref"); /** 页面组件中的字符串引用 */
+const service_1 = require("@lcap/nasl-concepts/service");
 const type_manager_1 = require("../typer/type-manager");
 const oql_1 = require("../utils/oql");
-const parseTsClassType_1 = require("../utils/parseTsClassType");
 const string_2 = require("../utils/string");
+const traverse_util_1 = require("../utils/traverse-util");
+const view_elem_logic_1 = require("./view-elem-logic");
+const helper_2 = require("./helper");
+const misc_1 = require("../utils/misc");
 /**
- * 考虑这样一个例子：
- * x = f(...)
- * result = x.a.b
- *
- * a 与 b 可能本来是 T1.a 和 T2.b 中的引用
- *
- * 用户修改 f(...) 后
- * a 与 b 可能变为 T3.a 和 T4.b 中的引用
- *
- * 因此不能只对 (...) 中的符号做增删，而是需要对整个文件级别的符号做增删
- * 并且 result 类型变化为，所有受牵连的文件也都需要对内部所有符号重新做增删
- */
-/**
- * 最核心的宗旨：（1）添加的东西可以链接到老的引用，但是新添加的东西里面都没有引用，所以先添加 qName，再做类型检查，再做引用计数
- * （2）删除的东西前，必须先更新引用计数、把里面的引用都删掉，再删 qName，再类型检查，再视情况按新类型添加引用
- * （3）更新时，必须按旧的类型删除引用，再做类型检查，再按新类型添加引用
- *
- * 增量类型检查时序：
- * 对于非 definitions：
- *  1 首先基于操作种类，对 xs 和内部引用符号做增删
- *  2 无论是什么操作，都直接 getFileNodeTransClosure 查到 FileNode 的引用传递闭包，设为 ys
- *  3 对 ys 中的所有引用，在 symbolRefs 中删除
- *  4 类型检查 ys
- *  5 对 ys 中的所有引用，在 symbolRefs 中添加
- *
- *
- * 对于 definitions:
- * Create xs
- *  1 创建 xs 的 qNames
- *  2 尝试 'relink' 到旧的 refs（需要 relink 所有下属定义，如 Structure 下的 StructureProperty）
- *  3 待检查项设为 ys：xs 所在的 FileNode，和 refs 所在的 FileNode 的 transitive closure
- *
- * （一般不需要处理 xs 的下属定义？如 Structure 下的 StructureProperty，
- *   因为引用下属定义前一定会先引用 xs 的 qName，如引用 .prop1 时必定有类似 x: Structure1, x.prop1。
- *   但也不一定，比如 f().prop1 时，只引用了 prop1 而没有 Structure1 的名字）
- *
- *  以下不在 preProcess 中做：
- *  4 拓扑排序 ys 确定类型检查顺序
- *  5 类型检查 ys
- *  6 更新 ys 中对 xs qNames 的引用 symbolRefs
- *
- *
- * Remove xs：
- *  1 扫描 xs 的 qNames
- *  2 确定待检查项 ys：xs 引用的 FileNodes,
- *  3 删除 xs 中对所有全局符号的引用，更新 symbolRefs
- *     （1 因为即使通过撤销重做，进来的 refs 对象的内存地址也不一样，无法重用）
- *     （2 xs 中其他符号的引用如果还在，查找其他符号时依然会找到"消失的xs"，然后再找到 xs 被引用的 FileNode，这样不对）
- *  4 缓存要删除的 qNames qNameDefsToRemove，现在不能删除，因为如果删除了，移除 ys 中的符号时就会报错，例子我不记得了，之后再想想……
- *
- *  以下不在 preProcess 中做：
- *  5 类型检查 ys
- *  6 不需要删除 ys 中对 xs 的引用 refs，所以不需要更新 symbolRefs（为了之后做 'relink'）
- *
- *
- * Rename xs:
- *  1 获取要删除的旧的 qNames1
- *  2 获取引用旧的 qNames1 的待检查项 ys
- *  3 获取要增加的新的 qNames2
- *  4 引用转移：qNameDefs 中增加 qNames2，并且把 qNames1 的 symbolRefs 转移到 qNames2，qNameDefs 中删除 qNames1
- *  5 尝试 'relink'：改名后，如果新名字已经存在一些存量 refs，也要加进去
- *  6 根据转移的 symbolRefs，获取引用新的 qNames2 的待检查项 zs（比如可能一个以前找不到的名字碰巧连接上了）
- *  7 类型检查 ys 和 zs
- *
- * 其他 update xs:
- *  1 拆成 delete oldObj 和 create newObj
- *  2 查找 xs 的引用, 确定待检查项 ys
- *
- *  3 （基于旧类型）删除 xs 和 ys 中的引用 symbolRefs
- *  4 类型检查 xs 和 ys
- *  5 （基于新类型）更新 xs 和 ys 中的引用 symbolRefs
- *
-* 以上所有的基于旧类型删除 symbolRefs，类型检查，然后基于新类型更新 symbolRefs 的操作，都需要在最后执行。在那之前只处理 def 的 qNames 和 ref 的局部更新等。
-*/
-// 鉴于 NASL AST 设计，本模块没有办法设计得很优雅
-/**
- * 特点：增量更新、惰性
- * 进入应用：扫描所有全局符号
- * 打开页面逻辑、逻辑、页面：啥也不动
- * 更新逻辑：增量更新局部引用、全局引用
- * 查找全局符号：直接返回
- * 查找局部符号：有缓存则从缓存返回结果，如无缓存则局部扫描局部所有符号建立缓存再返回结果
- */
-/**
- * 不考虑场景：剪切后粘贴并自动重命名等
- */
-// Type definitions moved to symbol-type.ts
-/**
- * 约定：不要在这里处理任何定义中的 type 删除，这里只管引用。
- * 删除引用时，需要一并移除类型：这里是删除引用的最后的现场，删除引用后类型检查阶段拿到的 NASL 是
- * 不带删除节点的 NASL，所以无法再处理了。（删除定义时，有一个删除定义列表可以处理，引用不在此列表里）。
- * 因为今天永远也不知道 public 方法明天会被什么地方调到，增量更新是时序非常敏感的，很容易出问题
- */
-/**
- * 一些奇怪的引用或关联关系，特别容易出错的：
- * - BindAttr 的 field、valueField、textField、parentField 字符串暗含的特殊引用
+ * 一些非常规引用或关联关系，特别容易出错的：
+ * - BindAttr 的
+ *      field、
+ *      valueField、
+ *      textField、
+ *      parentField 字符串暗含的特殊引用
+ * @warning 考虑之后开放一个接口，让组件库开发自己配置字符串引用
  * - QueryFieldExpression、QueryJoinExpression、QueryFromExpression 中的特殊引用，可能是字符串也可能是别的，注意 QueryFromExpression 内部包含 QueryJoinExpression
  * - 触碰到 Logic 时，要同时看看 OverriddenLogic
  * - 触碰到实体时，要看看实体逻辑
+ * - __TypeAnnotation 要单独管理，因为重命名不能碰这些推导的没有记录在 NASL 的数据
+ * - 页面引用了流程（通过“流程——关联页面”），但可能被页面局部符号 shadow
  */
 class ReferenceManager {
     static { this.refConcept = symbol_type_1.refConcept; } /** imported */
@@ -130,65 +47,80 @@ class ReferenceManager {
     static { this.connectionNsp = 'app.connections'; }
     // qNameDefs 和 symbolRefs 的构建时机不一样，所以不放在构造器中
     constructor() {
-        // qualified names to definition memory address
-        this.qNameDefs = new Map;
-        // definition to its references (memory address)
+        // qualified names to definition memory address for GLOBAL DEFINITIONS
+        this.gQNameDefs = new Map();
         /**
+         * @warning g 表示 global，这里基本只存放全局符号的引用
+         *
+         * 增量语义分析的范围基本由它决定：因为全局符号改动后，接口有变动，引用处需要重新做语义分析
+         * 局部符号变动后，仅直接影响所处的全局定义（如实体、逻辑接口类型）；其他的定义无法引用局部符号。
+         *
+         * definition to its references (memory address) for GLOBAL DEFINITIONS
          * 实体 def，11 个实体逻辑构成对其引用吗？
-         *    实体逻辑的定义的 params 的 typeAnnotation 确实对实体有引用，但那不是用户数据。加上引用 ==> rename 时 实体逻辑的 nodePath 直接 invalid ==> "数据不同步强制刷新"
+         *    实体逻辑的定义的 params 的 typeAnnotation 确实对实体有引用，但那不是用户数据。
+         *    如果加上引用，则 rename 时 实体逻辑的 nodePath 直接 invalid ==> "数据不同步强制刷新"
+         *
          *    实体逻辑对其不够成引用  ==> rename 时额外加上 11 个实体逻辑的引用
          *
          * 将实体看成 namespace，所有引用实体逻辑的地方也算引用了实体？
          */
-        this.symbolRefs = new Map; // Map 可就要小心内存泄漏咯 - 保存显式引用 (.typeAnnotation 字段)
+        this.gSymbolRefs = new Map; // 手动管理，小心内存泄漏
         // Accessor methods for symbolRefs to normalize input later
         this.getSymbolRefs = (__def) => {
             const def = this.normaliseEntityLogic(__def);
-            return this.symbolRefs.get(def);
+            return this.gSymbolRefs.get(def);
         };
         this.setSymbolRefs = (__def, refs) => {
             const def = this.normaliseEntityLogic(__def);
-            this.symbolRefs.set(def, refs);
+            this.gSymbolRefs.set(def, refs);
         };
         this.deleteSymbolRefs = (__def) => {
             const def = this.normaliseEntityLogic(__def);
-            return this.symbolRefs.delete(def);
+            return this.gSymbolRefs.delete(def);
         };
         this.clearSymbolRefs = () => {
-            this.symbolRefs.clear();
+            this.gSymbolRefs.clear();
         };
         this.getSymbolRefsSize = () => {
-            return this.symbolRefs.size;
+            return this.gSymbolRefs.size;
         };
+        // 辅助 map
+        this.veQNameDefs = new Map();
+        /**
+         * @warning ViewElement 和 Logic 都是局部符号，可以重名，qName 重复时会出错，不要搞这种例子谢谢
+         * key 是 memory addr 而不是 string 的原因：点查找引用时，不好高效获取 qName（如 Logic 没有 namespace 但调用处其实有，对的就是 elements.）
+         */
+        this.veRefs = new Map();
         // 当前的 collectRefs 是增加还是删除引用。先这样吧，没时间重构了……
         this.modeForCollect = null;
         /**
          * 非用户选择的"隐式引用"，如推导出的类型
          * 用于存储来自 __TypeAnnotation 字段的隐式引用
          */
-        this.symbolImplicitRefs = new WeakMap;
+        this.gSymbolImplicitRefs = new WeakMap();
         this.setSymbolImplicitRef = (def, ref) => {
             // 该功能目前仅为这三个类型提供
             if (def.concept !== 'Entity' && def.concept !== 'Structure' && def.concept !== 'Enum' && def.concept !== 'BackendVariable') {
                 return;
             }
-            (0, fp_macros_1.createOnAddWeakMap)(this.symbolImplicitRefs, def, ref);
+            (0, fp_macros_1.createOnAddWeakMap)(this.gSymbolImplicitRefs, def, ref);
         };
         this.getImplicitReferences = (__nd) => {
-            let nd = toRaw(__nd);
+            let nd = (0, misc_1.toRaw)(__nd);
             const emptySet = new Set();
             if (nd.concept !== 'Entity' && nd.concept !== 'Structure' && nd.concept !== 'Enum') {
                 return emptySet;
             }
             // 暂无"局部类型"，所以简化处理：
-            return this.symbolImplicitRefs.get(nd) ?? emptySet;
+            return this.gSymbolImplicitRefs.get(nd) ?? emptySet;
         };
         // 删除一个 def 时，缓存其 qName 到引用符号的关系，为了方便之后还能 relink 恢复
-        this.cachedQNameSymbolRefs = new Map();
+        this.gCachedQNameSymbolRefs = new Map();
+        this.compDefMgr = new component_def_manager_1.ComponentDefManager();
         // 上一次查找引用局部符号建立的 cache
         this.lastBoundary = undefined;
         this.isLocalCacheValid = true;
-        this.localQNameRefs = new Map();
+        this.lQNameRefs = new Map();
         // 当前文件节点
         this.curFileNode = undefined;
         // 约 20 万节点 200ms
@@ -254,16 +186,16 @@ class ReferenceManager {
                 if (!ref) {
                     return;
                 }
-                const def = this.qNameDefs.get(qName);
+                const def = this.gQNameDefs.get(qName);
                 if (def) {
                     // Add reference to existing definition
-                    (0, helper_1.createSetOnPush)(this.symbolRefs, def, ref);
+                    (0, helper_1.createSetOnPush)(this.gSymbolRefs, def, ref);
                 }
                 else {
                     // Cache reference for future relinking
                     // FIXME:这里有问题，脏脏的，比如局部变量、入参等都扔到这里面了，虽然暂时可能没有太大的正确性问题，但有内存泄漏
-                    if (!(0, exports.cheapTestLocalSymbol)(qName)) {
-                        (0, helper_1.createSetOnPush)(this.cachedQNameSymbolRefs, qName, ref);
+                    if (!(0, helper_2.cheapTestLocalSymbol)(qName)) {
+                        (0, helper_1.createSetOnPush)(this.gCachedQNameSymbolRefs, qName, ref);
                     }
                 }
             });
@@ -293,60 +225,13 @@ class ReferenceManager {
             }
             this.modeForCollect = null;
         };
-        this.fastBuildQNameDefs = (app) => {
-            this.qNameDefs = new Map();
-            this.compDefMgr.clearAll();
-            if (app) {
-                this.addQNameDefs(app);
-            }
-            // Build builtin types
-            (0, builtin_q_name_1.buildBuiltinTypeQNameDefs)(this.qNameDefs);
-            for (const fn of parseTsClassType_1.overloadedBuiltinFns) {
-                const def = (0, builtin_q_name_1.createDefaultOverloadedFnDef)(fn, 'nasl.util');
-                this.addQNameDef(def.name, def); // name 已经带了 namespace
-            }
-            for (const fn of parseTsClassType_1.overloadedSqlFns) {
-                const def = (0, builtin_q_name_1.createDefaultOverloadedFnDef)(fn, 'nasl.sqlFunction');
-                this.addQNameDef(def.name, def); // name 已经带了 namespace
-            }
-            // Process enums
-            const processEnumCollection = (0, collect_q_name_1.adhocBuildProcessEnum)();
-            processEnumCollection.forEach(([qName, def]) => {
-                this.addQNameDef(qName, def);
-            });
-            // I18N enums
-            const i18nEnumCollection = (0, collect_q_name_1.adhocBuildI18NEnum)();
-            i18nEnumCollection.forEach(([qName, def]) => {
-                this.addQNameDef(qName, def);
-            });
-            // 更多的 error structures
-            const stdNamespace = (0, nasl_concepts_1.getStdlibNamespace)();
-            const errorNamespace = stdNamespace.findChild("error");
-            errorNamespace.structures.forEach((structure) => {
-                (0, collect_q_name_1.collectStructure)('nasl')(structure);
-            });
-        };
-        // Update the addQNameDefs method to use the new collection functions
-        /**
-         * FIXME wudengke rename this to collectFullDefs
-         * @param app
-         */
-        this.addQNameDefs = (app) => {
-            if (app) {
-                const qNameDefs = (0, collect_q_name_1.collectAllQNames)('')(app);
-                qNameDefs.forEach(([qName, def]) => {
-                    if ((0, component_def_manager_1.isGeneralViewElementDefinition)(def)) {
-                        this.compDefMgr.add(def, 'referenceManager#addQNameDefs');
-                    }
-                    this.addQNameDef(qName, def);
-                });
-            }
-        };
-        this.addQNameDef = (qName, def) => {
-            this.qNameDefs.set(qName, def);
-        };
+        this.addQNameDefs = (0, build_q_name_def_1.mkAddQNameDefs)(this.gQNameDefs, this.compDefMgr);
+        /** 注释见具体实现 */
+        this.addViewElementLogicQNameDefs = (0, view_elem_logic_1.mkAddViewElementLogicQNameDefs)(this.veQNameDefs, this.gQNameDefs);
+        /** 注释见具体实现 */
+        this.addViewElementLogicRefs = (0, view_elem_logic_1.mkAddViewElementBindLogicRefs)(this.veQNameDefs, this.veRefs);
         this.queryQNameDef = (qName) => {
-            const res = this.qNameDefs.get(qName);
+            const res = this.gQNameDefs.get(qName);
             if (!res) {
                 console.log(`queryQNameDef: ${qName} not found`);
             }
@@ -397,7 +282,7 @@ class ReferenceManager {
             }
             else {
                 // @ts-expect-error
-                return this.qNameDefs.get(`${ty.typeNamespace}.${ty.typeName}`);
+                return this.gQNameDefs.get(`${ty.typeNamespace}.${ty.typeName}`);
             }
         };
         /**
@@ -407,7 +292,7 @@ class ReferenceManager {
          */
         this.getNodeDef = (ref) => {
             const qName = (0, get_q_name_1.getTokenQualifiedName)(ref);
-            return qName ? this.qNameDefs.get(qName) : undefined;
+            return qName ? this.gQNameDefs.get(qName) : undefined;
         };
         /**
          * 对外接口，指用户点击 "查找引用"，只返回用户手动指定的引用
@@ -415,49 +300,74 @@ class ReferenceManager {
          * @returns 所有引用处
          */
         this.getReferences = (env, __nd) => {
-            let nd = this.normaliseEntityLogic(toRaw(__nd));
-            let res;
+            let nd = this.normaliseEntityLogic((0, misc_1.toRaw)(__nd));
+            let res = new Set();
             // 比如 OverriddenLogic 和对应的 Logic 名字一样，但引用挂在 Logic 上
             // 比如 实体对应的实体逻辑可能有多份内存地址，归结到现存的一份上
             // nd = this.qNameDefs.get(getTokenQualifiedName(nd)!)!;
             // ==> 好像也不行，很多依赖库逻辑调用又挂了，这也不行，那也不行
             // 全局符号直接查找
-            if (isGlobalDef(nd)) {
-                res = this.getSymbolRefs(nd) ?? new Set();
-                if (nd.concept === 'Entity') {
-                    // 加上所有实体逻辑调用的引用（实体逻辑可看做无定义，但要修改调用处的 namespace：实体名是 namespace 的一部分）
-                    for (const l of nd.logics) {
-                        res = mnemonist_1.set.union(res, this.getSymbolRefs(l) ?? new Set());
-                    }
-                }
+            if ((0, symbol_type_1.isGlobalDef)(nd)) {
+                res = mnemonist_1.set.union(res, this.getSymbolRefs(nd) ?? new Set());
             }
-            else { // 局部符号才需要即时获取
-                const boundary = toRaw(getBoundary(nd));
+            else {
+                // 局部符号需要即时获取
+                const boundary = (0, misc_1.toRaw)((0, helper_2.getBoundary)(nd));
+                // 从缓存中获取
                 if (this.lastBoundary === boundary && this.isLocalCacheValid) {
-                    res = this.localQNameRefs.get((0, get_q_name_1.getTokenQualifiedName)(nd));
+                    res = this.lQNameRefs.get((0, get_q_name_1.getTokenQualifiedName)(nd)) ?? new Set();
+                    // 此处的 Logic 必然不是全局逻辑
+                    // @ts-expect-error 目前的 AST 设计，ViewElement 既是引用又是定义
+                    if (nd.concept === 'ViewElement' || nd.concept === 'Logic' || nd.concept === 'BusinessLogic') {
+                        res = mnemonist_1.set.union(res, this.getViewElementRefs(nd));
+                    }
                 }
                 else {
                     // 局部扫描，建立所有局部引用
-                    const startTime = Date.now();
-                    res = this.clearRebuildLocalCache(env, nd);
-                    const endTime = Date.now();
-                    (endTime - startTime > 200) && console.log(`Get reference: all time: ${endTime - startTime}ms`);
+                    this.lQNameRefs.clear();
+                    this.veQNameDefs.clear();
+                    this.veRefs.clear();
+                    this.timeAndLog('Get reference: collect local refs', this.buildMinimalLocalQNameRefs, env, nd);
+                    res = mnemonist_1.set.union(res, this.lQNameRefs.get((0, get_q_name_1.getTokenQualifiedName)(nd)) ?? new Set());
+                    // @ts-expect-error 同上，并且虽然 BindEvent 本身没引用但是要触发对 view 建立引用
+                    if (nd.concept === 'ViewElement' || nd.concept === 'Logic' || nd.concept === 'BusinessLogic' || nd.concept === 'BindEvent') {
+                        const ctxViewLike = (0, misc_1.toRaw)((0, nasl_concepts_1.getCtxViewLike)(nd));
+                        this.timeAndLog('Get reference: build view element logic qName defs cache', this.addViewElementLogicQNameDefs, ctxViewLike);
+                        this.timeAndLog('Get reference: build view element refs cache', this.addViewElementLogicRefs, ctxViewLike);
+                        // @ts-expect-error get 出来一个 undefined 无所谓
+                        res = mnemonist_1.set.union(res ?? new Set(), this.getViewElementRefs(nd));
+                    }
                 }
             }
-            // 这个东西很特殊……查三代
+            // 这些逻辑不要移到上面，因为放上面的话 局部引用 cache 可能还没建立
+            /** 这个东西很特殊……查三代
+             * 这玩意跟全局逻辑不一样，全局逻辑名字是固定的。
+             * 业务逻辑在页面调用的时候，名字前缀是随着业务组件实例名字而变化的，几乎是全应用查找……
+             */
             if (nd.concept === 'BusinessLogic') {
                 // 上面已经找到了业务组件内部对业务组件逻辑的内用
                 // 现在再找出所有 业务组件逻辑 所属的业务组件的外部引用
-                const bs = toRaw((0, nasl_concepts_1.getCtxViewLike)(nd));
+                const bs = (0, misc_1.toRaw)((0, nasl_concepts_1.getCtxViewLike)(nd));
                 if (bs?.concept === 'BusinessComponent') {
                     const bsRefs = this.getSymbolRefs(bs) ?? new Set();
                     let bsRefsRefs = new Array(); // 业务组件（在页面的引用）的引用
-                    // 再对每个实例找到所有引用
+                    /**
+                     * 再对每个实例找到所有引用
+                     * @warning 造孽，引用业务组件的每个 view 都要扫描一遍，应该很慢
+                     */
+                    const startTime = Date.now();
                     for (const bsInst of bsRefs) {
-                        bsRefsRefs.push(...this.getViewElementRefs(env, bsInst));
+                        const ctxViewLike = (0, misc_1.toRaw)((0, nasl_concepts_1.getCtxViewLike)(bsInst));
+                        this.addViewElementLogicQNameDefs(ctxViewLike);
+                        this.addViewElementLogicRefs(ctxViewLike);
+                        bsRefsRefs.push(...this.getViewElementRefs(bsInst));
                     }
                     // 再从引用中过滤出找到当前业务逻辑的调用
                     res = mnemonist_1.set.union(res, new Set(bsRefsRefs.filter(r => r.concept === 'CallLogic' && r.calleeName === nd.name))); // amazing!
+                    const endTime = Date.now();
+                    if (endTime - startTime > 200) {
+                        console.log(`Get reference: complex business logic took ${endTime - startTime}ms`);
+                    }
                 }
             }
             // 这个东西很特殊……查三代
@@ -468,63 +378,78 @@ class ReferenceManager {
                     res = mnemonist_1.set.union(res ?? new Set(), new Set(this.getReferences(env, l)));
                 }
             }
+            // 加上所有实体逻辑调用的引用（实体逻辑可看做无定义，但要修改调用处的 namespace：实体名是 namespace 的一部分）
+            if (nd.concept === 'Entity') {
+                for (const l of nd.logics) {
+                    res = mnemonist_1.set.union(res, this.getSymbolRefs(l) ?? new Set());
+                }
+            }
             return res ? Array.from(res) : [];
         };
-        // 建立所有局部引用，先处理上一次的缓存
-        this.clearRebuildLocalCache = (env, nd_) => {
-            this.localQNameRefs.clear();
-            return this.buildLocalQNameRefs(env, toRaw(nd_)) ?? new Set();
+        this.timeAndLog = (label, fn, ...args) => {
+            const startTime = Date.now();
+            fn(...args);
+            const endTime = Date.now();
+            if (endTime - startTime > 200) {
+                console.log(`${label}: ${endTime - startTime}ms`);
+            }
         };
         // 给类似 FileNode 级别的定义建立局部索引
-        // 修改后：不写入 env map 了，不做缓存，直接返回数据
-        this.buildLocalQNameRefs = (env, __nd) => {
+        this.buildMinimalLocalQNameRefs = (env, __nd) => {
             this.modeForCollect = "create" /* Operation.Create */;
-            const nd = toRaw(__nd);
+            const nd = (0, misc_1.toRaw)(__nd);
             let logicVars = new Array();
             let viewVars = new Array();
             let processVars = new Array();
-            let logics = new Array();
-            const boundary = getBoundary(nd);
+            /**
+             * @warning v4.1 开始，逻辑不在这里处理，在 veQNameRefs 那里处理
+             */
+            // let logics = new Array<DefConcept>();
+            let isViewLike = false;
+            const boundary = (0, helper_2.getBoundary)(nd);
             if (!boundary) {
                 return new Set();
             }
             if (boundary.concept === 'View' || boundary.concept === 'BusinessComponent') {
-                viewVars = (0, nasl_concepts_1.getViewVars)(nd).map(toRaw);
+                viewVars = (0, nasl_concepts_1.getViewVars)(nd).map(misc_1.toRaw);
                 const ctxLogic = (0, nasl_concepts_1.getCtxLogicLike)(nd);
                 if (ctxLogic && 'variables' in ctxLogic) {
-                    logicVars.push(...ctxLogic.variables?.map(toRaw) ?? []);
+                    logicVars.push(...ctxLogic.variables?.map(misc_1.toRaw) ?? []);
                 }
-                logics = (0, nasl_concepts_1.getViewLikeLogics)(nd).map(toRaw);
+                // logics = getViewLikeLogics(nd).map(toRaw);
+                isViewLike = true;
             }
             else if (boundary.concept === 'ProcessDefinitionV2') {
-                processVars = (0, nasl_concepts_1.getProcessVars)(nd).map(toRaw);
+                processVars = (0, nasl_concepts_1.getProcessVars)(nd).map(misc_1.toRaw);
                 const ctxLogic = (0, nasl_concepts_1.getCtxLogicLike)(nd);
                 if (ctxLogic && 'variables' in ctxLogic) {
-                    logicVars.push(...ctxLogic.variables?.map(toRaw) ?? []);
+                    logicVars.push(...ctxLogic.variables?.map(misc_1.toRaw) ?? []);
                 }
-                logics = (0, nasl_concepts_1.getProcessLikeLogics)(nd).map(toRaw);
+                // logics = getProcessLikeLogics(nd).map(toRaw);
             }
-            else if ((0, nasl_predicate_1.isCallableNaslLogic)(boundary) || (0, nasl_predicate_1.isCallableNaslInterface)(boundary)) {
-                logicVars = (0, nasl_concepts_1.getLogicVars)(nd).map(toRaw);
+            else if ((0, service_1.isCallableNaslLogic)(boundary) || (0, service_1.isCallableNaslInterface)(boundary)) {
+                logicVars = (0, nasl_concepts_1.getLogicVars)(nd).map(misc_1.toRaw);
             }
             let allVars = logicVars.concat(processVars).concat(viewVars);
+            // should also get view element definitions
+            if (isViewLike) {
+            }
             // initialize local cache
-            [...allVars, ...logics].forEach(def => {
+            [...allVars, /** ...logics  */].forEach(def => {
                 const qName = (0, get_q_name_1.getTokenQualifiedName)(def);
                 if (qName) {
-                    this.localQNameRefs.set(qName, new Set());
+                    this.lQNameRefs.set(qName, new Set());
                 }
             });
             let subRefs = this.collectRefs(env, boundary, true);
             this.lastBoundary = boundary;
             subRefs?.forEach(([rf, qName]) => {
                 // 不存在则表示不是局部符号
-                this.localQNameRefs.get(qName)?.add(rf);
+                this.lQNameRefs.get(qName)?.add(rf);
             });
             // Note: 暂不支持 BindAttr、BindDirective 里的变量的查找引用
             this.isLocalCacheValid = true;
             this.modeForCollect = null;
-            return this.localQNameRefs.get((0, get_q_name_1.getTokenQualifiedName)(nd));
         };
         /**
          * References to view elements are calls of component logic and access of properties
@@ -536,38 +461,7 @@ class ReferenceManager {
          *  "name": "uLinearLayout1",
          *
          */
-        this.getViewElementRefs = (env, __nd) => {
-            const result = new Array();
-            if (!__nd) {
-                return result;
-            }
-            const nd = toRaw(__nd);
-            if (nd.concept === 'ViewElement') {
-                const veQName = (0, get_q_name_1.getTokenQualifiedName)(nd);
-                const veLocalName = veQName ? veQName.substring(veQName.lastIndexOf('.') + 1) : '';
-                const ctxViewLike = toRaw((0, nasl_concepts_1.getCtxViewLike)(nd));
-                const lam = (n) => {
-                    if (n.concept === 'CallLogic') {
-                        const qName = (0, get_q_name_1.getTokenQualifiedName)(n);
-                        if (qName?.startsWith('elements.')) {
-                            const elementName = qName.substring('elements.'.length, qName.indexOf('.', 'elements.'.length));
-                            if (elementName === veLocalName) {
-                                result.push(n);
-                            }
-                        }
-                    }
-                    if (n.concept === 'Identifier') {
-                        if (n.namespace?.startsWith('elements.')) {
-                            if (n.name === veLocalName) {
-                                result.push(n);
-                            }
-                        }
-                    }
-                };
-                visitChildrenWith(ctxViewLike, lam);
-            }
-            return result;
-        };
+        this.getViewElementRefs = (nd) => !nd ? new Set() : this.veRefs.get(nd) ?? new Set();
         /**
          * 非常危险，但是先这样吧
          */
@@ -576,8 +470,8 @@ class ReferenceManager {
             if (!__nd) {
                 return result;
             }
-            const nd = toRaw(__nd);
-            const ctxProcLike = toRaw((0, nasl_concepts_1.getCtxProcessLike)(nd));
+            const nd = (0, misc_1.toRaw)(__nd);
+            const ctxProcLike = (0, misc_1.toRaw)((0, nasl_concepts_1.getCtxProcessLike)(nd));
             if (!ctxProcLike) {
                 return result;
             }
@@ -594,7 +488,7 @@ class ReferenceManager {
                     }
                 }
             };
-            visitChildrenWith(ctxProcLike, lam);
+            (0, traverse_util_1.visitChildrenWith)(ctxProcLike, lam);
             // 重命名时不需要处理 sourceRef targetRef，好像其他逻辑已经处理掉了
             return result;
         };
@@ -613,38 +507,37 @@ class ReferenceManager {
         this.transferQNameDef = (oldQName, newQName, mode) => {
             if (!oldQName || !newQName)
                 return;
-            const oldDef = this.qNameDefs.get(oldQName);
+            const oldDef = this.gQNameDefs.get(oldQName);
             if (!oldDef)
                 return;
             // 1. 删除 oldQName，建立 newQName，def 地址不变
-            this.qNameDefs.delete(oldQName);
-            this.qNameDefs.set(newQName, oldDef);
+            this.gQNameDefs.delete(oldQName);
+            this.gQNameDefs.set(newQName, oldDef);
             // 2. 处理引用集合
             if (mode === 'update') {
                 // 获取 oldQName 的既存引用
-                const oldRefs = this.symbolRefs.get(oldDef) ?? new Set();
+                const oldRefs = this.gSymbolRefs.get(oldDef) ?? new Set();
                 // 获取 newQName 在缓存中的引用
-                const newCachedRefs = this.cachedQNameSymbolRefs.get(newQName) ?? new Set();
+                const newCachedRefs = this.gCachedQNameSymbolRefs.get(newQName) ?? new Set();
                 // 合并引用集合
                 const mergedRefs = mnemonist_1.set.union(oldRefs, newCachedRefs);
                 // 设置新名字的引用集合
                 mergedRefs.size > 0 && this.setSymbolRefs(oldDef, mergedRefs);
                 // 删除 newQName 在缓存中的引用
-                this.cachedQNameSymbolRefs.delete(newQName);
+                this.gCachedQNameSymbolRefs.delete(newQName);
             }
             else {
                 // 不是 update，直接取 newQName 在缓存中的引用
-                const newCachedRefs = this.cachedQNameSymbolRefs.get(newQName) ?? new Set();
+                const newCachedRefs = this.gCachedQNameSymbolRefs.get(newQName) ?? new Set();
                 this.setSymbolRefs(oldDef, newCachedRefs);
                 // oldQName 的引用集合被放入 cachedQNameSymbolRefs
-                const oldRefs = this.symbolRefs.get(oldDef) ?? new Set();
-                oldRefs.size > 0 && this.cachedQNameSymbolRefs.set(oldQName, oldRefs);
+                const oldRefs = this.gSymbolRefs.get(oldDef) ?? new Set();
+                oldRefs.size > 0 && this.gCachedQNameSymbolRefs.set(oldQName, oldRefs);
                 // 删除 newQName 在缓存中的引用
-                this.cachedQNameSymbolRefs.delete(newQName);
+                this.gCachedQNameSymbolRefs.delete(newQName);
             }
         };
         this.updateRefsInNaslFragment = update_nasl_fragment_1.updateRefsInNaslFragment;
-        this.cacheRemovedConnectors = update_nasl_fragment_1.cacheRemovedConnectors;
         /**
         * @warning Only handle global symbols
         */
@@ -652,31 +545,31 @@ class ReferenceManager {
             switch (mode) {
                 // 目前的策略是 re-link：删除 logic1 后，不会删除引用。新建一个 logic1 后，自动关联到老的引用上
                 case "create" /* Operation.Create */: {
-                    if (symbol_type_1.localDefConcept.includes(defNode.concept)) {
+                    if (!(0, symbol_type_1.isGlobalDef)(defNode)) {
                         this.isLocalCacheValid = false;
                     }
                     else {
                         // 可以链接回旧的引用，类似于 rename
-                        const oldRefs = this.cachedQNameSymbolRefs.get(qName);
+                        const oldRefs = this.gCachedQNameSymbolRefs.get(qName);
                         oldRefs && this.setSymbolRefs(defNode, oldRefs);
                         // qName 链接到新的 defNode 的 mem addr
-                        this.addQNameDef(qName, defNode);
+                        this.gQNameDefs.set(qName, defNode);
                         if ((0, component_def_manager_1.isGeneralViewElementDefinition)(defNode)) {
                             this.compDefMgr.add(defNode, 'handleDefOp');
                         }
                         // 删除缓存
-                        this.cachedQNameSymbolRefs.delete(qName);
+                        this.gCachedQNameSymbolRefs.delete(qName);
                     }
                     break;
                 }
                 case "delete" /* Operation.Remove */: { // 连根拔起，但缓存
-                    if (symbol_type_1.localDefConcept.includes(defNode.concept)) {
+                    if (!(0, symbol_type_1.isGlobalDef)(defNode)) {
                         this.isLocalCacheValid = false;
                     }
                     else {
                         const refs = this.getSymbolRefs(defNode);
-                        refs && this.cachedQNameSymbolRefs.set(qName, refs);
-                        this.qNameDefs.delete(qName);
+                        refs && this.gCachedQNameSymbolRefs.set(qName, refs);
+                        this.gQNameDefs.delete(qName);
                         if ((0, component_def_manager_1.isGeneralViewElementDefinition)(defNode)) {
                             this.compDefMgr.removeComponentGroup(defNode);
                         }
@@ -690,13 +583,13 @@ class ReferenceManager {
          * @warning Only handle global symbols
          */
         this.handleRefOp = (env, mode, refNd, qName) => {
-            const def = this.qNameDefs.get(qName);
+            const def = this.gQNameDefs.get(qName);
             if (def) {
                 switch (mode) {
                     case "create" /* Operation.Create */: {
                         // Route reference to the appropriate map based on whether it's explicit or implicit
                         // Explicit references go to symbolRefs
-                        (0, fp_macros_1.createOnAdd)(this.symbolRefs, def, refNd);
+                        (0, fp_macros_1.createOnAdd)(this.gSymbolRefs, def, refNd);
                         break;
                     }
                     case "delete" /* Operation.Remove */: {
@@ -710,11 +603,11 @@ class ReferenceManager {
                 // cache 里的也要处理……
                 switch (mode) {
                     case "create" /* Operation.Create */: {
-                        (0, fp_macros_1.createOnAdd)(this.cachedQNameSymbolRefs, qName, refNd);
+                        (0, fp_macros_1.createOnAdd)(this.gCachedQNameSymbolRefs, qName, refNd);
                         break;
                     }
                     case "delete" /* Operation.Remove */: {
-                        this.cachedQNameSymbolRefs.get(qName)?.delete(refNd);
+                        this.gCachedQNameSymbolRefs.get(qName)?.delete(refNd);
                         break;
                     }
                 }
@@ -744,7 +637,7 @@ class ReferenceManager {
                     this.setSymbolImplicitRef(tyDef, nd);
                 }
                 else if (this.modeForCollect === "delete" /* Operation.Remove */) {
-                    this.symbolImplicitRefs.get(tyDef)?.delete(nd);
+                    this.gSymbolImplicitRefs.get(tyDef)?.delete(nd);
                 }
             }
             else {
@@ -761,7 +654,7 @@ class ReferenceManager {
                         this.setSymbolImplicitRef(tyDef, nd);
                     }
                     else if (this.modeForCollect === "delete" /* Operation.Remove */) {
-                        this.symbolImplicitRefs.get(tyDef)?.delete(nd);
+                        this.gSymbolImplicitRefs.get(tyDef)?.delete(nd);
                     }
                 }
             }
@@ -884,7 +777,7 @@ class ReferenceManager {
             // extract views
             const views = new Array();
             nd.concept === 'View' && views.push(nd);
-            !skipSubView && views.push(...(0, exports.getSubViews)(nd));
+            !skipSubView && views.push(...(0, misc_1.getSubViews)(nd));
             if (nd.concept === 'View' || nd.concept === 'BusinessComponent') {
                 this.curFileNode = nd;
                 env.viewAssocProcess = env.processV2ViewBindings.get((0, get_q_name_1.getTokenQualifiedName)(nd)) ?? null;
@@ -971,7 +864,7 @@ class ReferenceManager {
                     const lastCurFileNode = this.curFileNode;
                     this.curFileNode = v;
                     // @ts-expect-error contra-variance errors
-                    visitChildrenWith(v, normalCb, compositeNodePred, compositeNodeCb);
+                    (0, traverse_util_1.visitChildrenWith)(v, normalCb, compositeNodePred, compositeNodeCb);
                     this.curFileNode = lastCurFileNode;
                     env.viewAssocProcess = lastViewAssocProcess;
                 }
@@ -979,7 +872,7 @@ class ReferenceManager {
             else {
                 // 处理非页面
                 // @ts-expect-error contra-variance errors
-                visitChildrenWith(nd, normalCb, compositeNodePred, compositeNodeCb);
+                (0, traverse_util_1.visitChildrenWith)(nd, normalCb, compositeNodePred, compositeNodeCb);
             }
             // QFE 实在是没办法一致性处理
             if (nd.concept !== 'QueryFieldExpression') {
@@ -1014,12 +907,12 @@ class ReferenceManager {
             // 清理绑定属性中的 string 暗含的特殊引用，哇哦
             if (rmNd.concept === 'View' || rmNd.concept === 'BusinessComponent') {
                 rmNd.traverseStrictChildren((nd) => {
-                    if (nd.concept === 'BindAttribute' && !nd.expression && (0, update_nasl_fragment_1.isSpecialStringRefField)(nd.name)) {
+                    if (nd.concept === 'BindAttribute' && !nd.expression && special_string_ref_1.specialStringRefs.includes(nd.name)) {
                         (0, update_nasl_fragment_1.removeBindAttrRef)(this, nd);
                     }
                 }); // @ts-expect-error
             }
-            else if (rmNd.concept === 'BindAttribute' && !rmNd.expression && (0, update_nasl_fragment_1.isSpecialStringRefField)(rmNd.name)) {
+            else if (rmNd.concept === 'BindAttribute' && !rmNd.expression && special_string_ref_1.specialStringRefs.includes(rmNd.name)) {
                 (0, update_nasl_fragment_1.removeBindAttrRef)(this, rmNd);
             }
             env.processAssocEntity = null;
@@ -1039,7 +932,7 @@ class ReferenceManager {
             const refAndQNames = this.collectRefs(env, nd, skipSubView);
             const localVars = env.localVars.get(nd) ?? [];
             for (const [ref, qName] of refAndQNames) {
-                if (localVars.includes(qName) || (0, exports.cheapTestLocalSymbol)(qName)) {
+                if (localVars.includes(qName) || (0, helper_2.cheapTestLocalSymbol)(qName)) {
                     continue;
                 }
                 this.handleRefOp(env, "create" /* Operation.Create */, ref, qName);
@@ -1051,6 +944,9 @@ class ReferenceManager {
         this.invalidateLocalSymCache = () => {
             this.isLocalCacheValid = false;
         };
+        this.getLocalCacheState = () => {
+            return this.isLocalCacheValid;
+        };
         /**
          * 干的事太多了，只能改名 hack 了
          * 假设 a:A, b:B, c:C, d:D，a.b.c.d 拆解为
@@ -1109,8 +1005,8 @@ class ReferenceManager {
                     if (qName) {
                         // Handle process reference in view
                         if (env.viewAssocProcess && env.viewAssocProcess.name === ids[0].name) {
-                            const ctxLogic = toRaw((0, nasl_concepts_1.getCtxLogicLike)(nd));
-                            const ctxViewLike = toRaw((0, nasl_concepts_1.getCtxViewLike)(nd));
+                            const ctxLogic = (0, misc_1.toRaw)((0, nasl_concepts_1.getCtxLogicLike)(nd));
+                            const ctxViewLike = (0, misc_1.toRaw)((0, nasl_concepts_1.getCtxViewLike)(nd));
                             const logicVars = env.localVars.get(ctxLogic);
                             const viewVars = env.localVars.get(ctxViewLike);
                             // 哇，是 Process.data.XXX 特殊引用 && avoid shadowing
@@ -1225,7 +1121,7 @@ class ReferenceManager {
                     const getEntityProp = (prop, def) => def.properties.find(p => p.name === prop);
                     if (eNsp && eAsName) {
                         const entityQName = `${eNsp}.${eAsName}`; // namespace eNsp already contains '.entities'
-                        const entityDef = this.qNameDefs.get(`${eNsp}.${eAsName}`);
+                        const entityDef = this.gQNameDefs.get(`${eNsp}.${eAsName}`);
                         entityDef && res.push([nd, entityQName]);
                         if (entityDef && pName) {
                             const propQName = (0, string_2.getPropQName)(entityQName, pName, 'Entity');
@@ -1269,10 +1165,10 @@ class ReferenceManager {
          */
         this.getMemoryStats = () => {
             const stats = {
-                qNameDefs: this.qNameDefs,
-                symbolRefs: this.symbolRefs, // Exporting private map for serialization
-                cachedQNameSymbolRefs: this.cachedQNameSymbolRefs,
-                localQNameRefs: this.localQNameRefs,
+                qNameDefs: this.gQNameDefs,
+                symbolRefs: this.gSymbolRefs, // Exporting private map for serialization
+                cachedQNameSymbolRefs: this.gCachedQNameSymbolRefs,
+                localQNameRefs: this.lQNameRefs,
                 compDefMgr: this.compDefMgr,
             };
             const result = {
@@ -1321,36 +1217,35 @@ class ReferenceManager {
             return result;
         };
         this.normaliseEntityLogic = (nd) => {
-            if (!(0, exports.isEntityLogic)(nd)) {
+            if (!(0, helper_2.isEntityLogic)(nd)) {
                 return nd;
             }
             const qName = (0, get_q_name_1.getTokenQualifiedName)(nd);
             if (!qName) {
                 throw new Error('The entity logic does not have namespace');
             }
-            const def = this.qNameDefs.get(qName);
+            const def = this.gQNameDefs.get(qName);
             if (!def) {
                 return nd;
             }
-            // 同步跟新引用管理器，多快好省、力争上游，跟上实体逻辑变化的节奏
+            // 同步跟新引用管理器，跟上实体逻辑内存地址变化的节奏
             if (nd !== def) {
-                this.qNameDefs.set(qName, nd);
-                const refs = mnemonist_1.set.union(this.symbolRefs.get(def) ?? new Set(), this.symbolRefs.get(nd) ?? new Set());
-                refs.size > 0 && this.symbolRefs.set(nd, refs);
+                this.gQNameDefs.set(qName, nd);
+                const refs = mnemonist_1.set.union(this.gSymbolRefs.get(def) ?? new Set(), this.gSymbolRefs.get(nd) ?? new Set());
+                refs.size > 0 && this.gSymbolRefs.set(nd, refs);
             }
             return nd;
         };
-        this.compDefMgr = new component_def_manager_1.ComponentDefManager();
     }
     buildQNameDefsForApp(app) {
         console.time('\x1b[44m\x1b[97m Reference manager: Build Qualified Name to Definition Map \x1b[0m');
-        this.fastBuildQNameDefs(toRaw(app));
+        (0, build_q_name_def_1.mkBuildQNameDefs)(this.gQNameDefs, this.compDefMgr)((0, misc_1.toRaw)(app));
         console.timeEnd('\x1b[44m\x1b[97m Reference manager: Build Qualified Name to Definition Map \x1b[0m');
     }
     buildSymbolRefsForApp(env, app) {
         console.time('\x1b[44m\x1b[97m Reference manager: Build Symbol to Reference Map \x1b[0m');
         // symbolGraph && this.buildSymbolRefsFromSymbolGraph(symbolGraph); // 方舟的，后面可能不好修 bug 和维护
-        app && this.slowBuildSymbolRefsForApp(env, toRaw(app));
+        app && this.slowBuildSymbolRefsForApp(env, (0, misc_1.toRaw)(app));
         console.timeEnd('\x1b[44m\x1b[97m Reference manager: Build Symbol to Reference Map \x1b[0m');
     }
     // 属性名 p + 类型名 T，获取 T.p EntityProperty | StructureProperty | Enum
@@ -1378,87 +1273,19 @@ class ReferenceManager {
     }
     clearAll() {
         this.clearSymbolRefs();
-        this.qNameDefs.clear();
-        this.cachedQNameSymbolRefs.clear();
-        this.localQNameRefs.clear();
+        this.gQNameDefs.clear();
+        this.gCachedQNameSymbolRefs.clear();
+        this.lQNameRefs.clear();
+        this.veQNameDefs.clear();
+        this.veRefs.clear();
         this.compDefMgr.clearAll();
-        this.symbolImplicitRefs = new WeakMap();
+        this.gSymbolImplicitRefs = new WeakMap();
     }
 }
 exports.ReferenceManager = ReferenceManager;
-// prependStr moved to get-q-name.ts
-// getTokenQualifiedName moved to get-q-name.ts
-// getTokenQualifiedNameForMatchedExpr moved to get-q-name.ts
-// handleLogic moved to get-q-name.ts
-// handleFVar moved to get-q-name.ts
-// 是否是个全局定义呢？
-const isGlobalDef = (nd) => {
-    if (!symbol_type_1.globalDefConcept.includes(nd.concept)) {
-        return false;
-    }
-    if (nd.concept === 'View' || nd.concept === 'BusinessComponent' || nd.concept === 'ProcessV2') {
-        return true;
-    }
-    else if (nd.getAncestorRaw('View') ?? nd.getAncestorRaw('BusinessComponent')) {
-        // 但页面逻辑的 concept 也是 Logic，还需剔除
-        return false;
-    }
-    return true;
-};
 // 获取语义类型
 // @ts-ignore
 const getSemTy = (nd, env) => env.getType(nd) ?? nd.typeAnnotation; // Fallback to typeAnnotation using type assertion
-const toRaw = (nd) => {
-    // @ts-ignore
-    return nd?.__v_raw ?? nd;
-};
-const visitChildrenWith = (start, cb, pred, predCb) => {
-    const traverse = (node) => {
-        if (!(node.concept?.length)) {
-            return;
-        }
-        const { childProperties, childrenProperties } = (0, nasl_concepts_1.getConceptMeta)(node.concept);
-        for (const key of childProperties) {
-            const child = node[key];
-            if (!child || !(child.concept?.length)) {
-                continue;
-            }
-            if (pred && pred(child)) {
-                predCb(child); // 短路，不访问子节点
-            }
-            else {
-                cb(child);
-                traverse(child);
-            }
-        }
-        for (const key of childrenProperties) {
-            const children = node[key];
-            if (!Array.isArray(children)) {
-                continue;
-            }
-            for (const child of children) {
-                if (!child || !child.concept?.length) {
-                    continue;
-                }
-                if (pred && pred(child)) {
-                    predCb(child); // 短路，不访问子节点
-                }
-                else {
-                    cb(child);
-                    traverse(child);
-                }
-            }
-        }
-        // 不遍历 __TypeAnnotation，防止造成未知错误。例如 a.b.c 中每个节点都有 __TypeAnnotation，类型改名时查到这里可能都是无效的 nodePath
-    };
-    if (pred && pred(start)) {
-        predCb(start);
-    }
-    else {
-        cb(start);
-        traverse(start);
-    }
-};
 // 都用这个方法，安全些
 // getPropQName moved to get-q-name.ts
 const easyGetOldQName = (qName, oldName) => {
@@ -1480,20 +1307,6 @@ exports.easyGetOldQName = easyGetOldQName;
     - 页面的引用处只有 页面跳转
     - 放过的定义：App
 */
-/**
- * 判断字符串是否以 '.entities.X.logics' 结尾，其中 X 是任意字符串
- * @param str 需要判断的字符串
- * @returns 是否符合条件
- */
-const isEntitiesLogicsPath = (str) => {
-    // 使用正则表达式匹配以 .entities.任意字符串.logics 结尾的字符串
-    return /\.entities\.[^.]+\.logics$/.test(str);
-};
-/**
- * 今后大概率会改成 isNonUserNode，实体逻辑只是其中之一。比如文件夹应该也是 nonUserNode 吧
- */
-const isEntityLogic = (nd) => nd?.concept === 'Logic' && nd.getNamespace && isEntitiesLogicsPath(nd.getNamespace());
-exports.isEntityLogic = isEntityLogic;
 /**
  * 处理 CodeWave 编译器的一些连带的自动化行为，如自动生成 { abc: Abc } 这样的匿名结构体。
  * 这里实质上是否是引用？这里不是直接引用，但是 entityX 这个名字是从 EntityX 自动生成的，也可以看作是间接引用
@@ -1510,98 +1323,4 @@ const handleEntityAutoRef = (ty, nextProp, ident) => {
     return undefined;
 };
 exports.handleEntityAutoRef = handleEntityAutoRef;
-// Helper function to determine boundary according to custom rules
-const getBoundary = (nd) => {
-    if (!nd) {
-        return undefined;
-    }
-    const ctxViewLike = toRaw((0, nasl_concepts_1.getCtxViewLike)(nd));
-    const ctxLogicLike = toRaw((0, nasl_concepts_1.getCtxLogicLike)(nd));
-    const ctxProcessLike = toRaw((0, nasl_concepts_1.getCtxProcessLike)(nd));
-    // 1. 存在 ctxProcessLike，本身是逻辑，返回 ctxProcessLike
-    if (ctxProcessLike && ((0, nasl_predicate_1.isCallableNaslLogic)(nd) || (0, nasl_predicate_1.isCallableNaslInterface)(nd))) {
-        return ctxProcessLike;
-    }
-    // 2. 存在 ctxProcessLike，不存在 ctxLogicLike，返回 ctxProcessLike
-    if (ctxProcessLike && !ctxLogicLike) {
-        return ctxProcessLike;
-    }
-    // 3. 存在 ctxViewLike，本身是逻辑，返回 ctxViewLike
-    if (ctxViewLike && ((0, nasl_predicate_1.isCallableNaslLogic)(nd) || (0, nasl_predicate_1.isCallableNaslInterface)(nd))) {
-        return ctxViewLike;
-    }
-    // 4. 存在 ctxViewLike，不存在 ctxLogicLike，返回 ctxViewLike
-    if (ctxViewLike && !ctxLogicLike) {
-        return ctxViewLike;
-    }
-    // 5. 存在 ctxLogicLike（但本身不是逻辑），返回 ctxLogicLike
-    // backend logics or variables inside logic
-    if (ctxLogicLike && !(0, nasl_predicate_1.isCallableNaslLogic)(nd) && !(0, nasl_predicate_1.isCallableNaslInterface)(nd)) {
-        return ctxLogicLike;
-    }
-    return undefined;
-};
-const getDatasourceQName = (eNsp) => eNsp.lastIndexOf('.') !== -1
-    ? eNsp.substring(0, eNsp.lastIndexOf('.'))
-    : eNsp;
-exports.getDatasourceQName = getDatasourceQName;
-/**
- * 移除 nsp 中最后一个 . 之后的内容，
- * 如 app.logics 只保留 app,
- * extensions.encrypt_tool.logics 只保留 extensions.encrypt_tool
- * xxx.entities 只保留 xxx
- */
-const getNamespaceWithoutLast = (def) => {
-    // 你敢信，concept:Return 也没有 getNamespace() 方法，直接 throw 了，强无敌
-    const qName = (0, get_q_name_1.getTokenQualifiedName)(def) ?? '';
-    const lastDotIndex0 = qName.lastIndexOf('.');
-    const res0 = lastDotIndex0 !== -1 ? qName.slice(0, lastDotIndex0) : '';
-    // 枚举是 Identifier, namespace + name 是 app.enums.X，只保留 app.enums
-    // if (def.concept === 'Enum') {
-    //     return res0;
-    // }
-    // 其他都是 type，有 typeNamespace + typeName，都是  app.structure.properties.X 这种形式
-    const lastDotIndex1 = res0.lastIndexOf('.');
-    const res1 = lastDotIndex1 !== -1 ? res0.slice(0, lastDotIndex1) : '';
-    return res1;
-};
-exports.getNamespaceWithoutLast = getNamespaceWithoutLast;
-// 最好是与 typing 合成一个步骤，那里有 local nameBindings
-// 暂时用有没有 .、a、Tp 粗略判断吧，hack，对速度有点影响
-const cheapTestLocalSymbol = (qName) => {
-    if (qName.startsWith('a+') || qName.startsWith('Tp+') ||
-        qName.startsWith('nasl.core') || qName.startsWith('elements.') ||
-        qName.startsWith('nasl.util') ||
-        qName.startsWith('nasl.collection')) {
-        return true;
-    }
-    // 页面下引用的 Process 的 qName，一般是 Process_uniqueKey 的 hash
-    if (qName.startsWith('Process_')) {
-        return false;
-    }
-    if (qName.indexOf('.') === -1) {
-        return true;
-    }
-    return false;
-};
-exports.cheapTestLocalSymbol = cheapTestLocalSymbol;
-/**
- * 一个 FileNode 下面还可以有其他 FileNode 哦，其实没什么神秘的。
- * @warning 只会返回下属的 FileNode，不包含自己
- * @param node
- * @returns 下属 FileNodes，不包含自己
- */
-const getSubViews = (node) => {
-    const result = [];
-    if (node.concept === 'View') {
-        node.children?.forEach((nd) => {
-            if (nd.concept === 'View') {
-                result.push(nd);
-                result.push(...(0, exports.getSubViews)(nd));
-            }
-        });
-    }
-    return result;
-};
-exports.getSubViews = getSubViews;
 //# sourceMappingURL=reference-manager.js.map