@lcap/nasl 4.1.0-beta.2 → 4.1.0-beta.20

package/out/server/naslServer.js

@@ -46,9 +46,11 @@ const path = __importStar(require("path"));
 const worker_threads_1 = require("worker_threads");
 /// #endif
 const concepts_1 = require("../concepts");
+// import { validator, VusionValidator } from '@lcap/nasl-concepts';
 const asserts_1 = require("@lcap/nasl-concepts/asserts");
 const service_1 = require("@lcap/nasl-concepts/service");
 const utils = __importStar(require("../utils"));
+const memory_optimization_1 = require("../generator/release-body/memory-optimization");
 const createUiTs_1 = __importStar(require("./createUiTs"));
 const translator_1 = require("../translator");
 const translator_2 = require("./translator");
@@ -59,25 +61,7 @@ const decorators_1 = require("../decorators");
 const nasl_concepts_1 = require("@lcap/nasl-concepts");
 const nasl_language_server_core_1 = require("@lcap/nasl-language-server-core");
 const findReference_1 = require("./findReference");
-const NEED_SYNC_BIND_ATTRIBUTE = [
-    'textField',
-    'valueField',
-    'iconField',
-    'toField',
-    'parentField',
-    'childrenField',
-    'hasChildrenField',
-    'field',
-    'idField',
-    'titleField',
-    'closableField',
-    'descriptionField',
-    'expandedField',
-    'disabledField',
-    'nameField',
-    'labelField',
-    'sortField'
-];
+const nasl_server_client_1 = require("./client/nasl-server-client");
 const SentryMessager = (0, nasl_sentry_1.sentryMonitorTSWorkerMessager)(Messager_1.default);
 // naslStdlib文件缓存；作为全局变量给多实例用复用
 const __naslStdlibFileCacheMap = new Map();
@@ -371,7 +355,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                             // 目前里面包含所有定义、逻辑、业务组件、前端全局变量等
                             fixAllUseBeforeAssignTasks = await (0, nasl_language_server_core_1.firstScreenCheckAndCompare)(this.semEnv, rawApp);
                             // 类型检查完才能收集引用
-                            this.semEnv.refMgr.buildSymbolRefsForApp(this.semEnv, rawApp, undefined);
+                            this.semEnv.refMgr.buildSymbolRefsForApp(this.semEnv, rawApp);
                         }
                         catch (err) {
                             this.semEnv.logger.fatal('\x1b[44m\x1b[97m 类型检查出错了，估计没标完 \x1b[0m');
@@ -387,13 +371,13 @@ let NaslServer = NaslServer_1 = class NaslServer {
                         const diagAppStartTime = performance.now();
                         await utils.runGeneratorAsync(this.semEnv.errorDiagnoser.diagnosticApp());
                         const diagAppEndTime = performance.now();
-                        console.error(`\x1b[44m\x1b[97m Diagnostic App \x1b[0m: ${((diagAppEndTime - diagAppStartTime) / 1000).toFixed(3)}s`);
+                        console.info(`\x1b[44m\x1b[97m Diagnostic App \x1b[0m: ${((diagAppEndTime - diagAppStartTime) / 1000).toFixed(3)}s`);
                         const diagnosticMap = this.semEnv.errorDiagnoser.getAllDiagnostics();
                         const transformStartTime = performance.now();
                         const records = transformDiagnosticMapToRecords(diagnosticMap);
                         await this.diagnosticManager.setInitialDiagData(records);
                         const transformEndTime = performance.now();
-                        console.error(`\x1b[44m\x1b[97m Transform Diagnostic Map To Records \x1b[0m: ${((transformEndTime - transformStartTime) / 1000).toFixed(3)}s`);
+                        console.info(`\x1b[44m\x1b[97m Transform Diagnostic Map To Records \x1b[0m: ${((transformEndTime - transformStartTime) / 1000).toFixed(3)}s`);
                         // 首屏和增量通路不同，首屏时需要手动调用lsRunEndSwitch；增量时则在增量代码中调用
                         this._lsRunEndSwitch();
                         this.isFirstScreen = false;
@@ -405,7 +389,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                         rawApp.emit('collect:end');
                         this.semData.isFirstScreen = false;
                         this.semEnv.allocatedVEQNames.forEach(n => {
-                            this.semEnv.refMgr.qNameDefs.delete(n);
+                            this.semEnv.refMgr.gQNameDefs.delete(n);
                         });
                         this.semEnv.allocatedVEQNames.length = 0;
                         for (const value of this.cachedEventPayloadValues) {
@@ -417,6 +401,12 @@ let NaslServer = NaslServer_1 = class NaslServer {
                         }
                         utils.isDebugMode && console.timeEnd('\x1b[44m\x1b[97m 用户体感首屏检查耗时 \x1b[0m');
                     }
+                    /**
+                     * @warning 不放在这里无法起到加速效果，且读到的 cache 为空，抛出 undefined 值
+                     * 放在这里的话好像是有些“时序”问题？
+                     */
+                    this.semData.recoverSlowGetters();
+                    this.semData.clearSemanticData();
                     (0, nasl_language_server_core_1.clearFileNodeCache)();
                 }
                 this.notifyPublishDiagnosticsEnd(tsDiagnostics);
@@ -852,8 +842,6 @@ let NaslServer = NaslServer_1 = class NaslServer {
         await this.waitOqlQueryComponentChildrenFinish(app);
         // 翻译 ts 文件
         const results = await utils.runGeneratorAsync(getAllTsFiles());
-        this.semData.recoverSlowGetters();
-        this.semData.clearSemanticData();
         const files = results.map((result) => ({
             file: result.filePath,
             fileContent: result.code,
@@ -1614,7 +1602,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
     //   // this.logger.info(refsList, 'refsList');
     //   return refsList;
     // }
-    // rename 等内部调用的查找引用，不是用户点击的 "查找引用"
+    /**
+     * @warning 主要是 rename 等内部调用的查找引用，不是用户点击的 "查找引用"
+     */
     async _isHaveRef(__node) {
         const wrapRefs = (refs) => {
             const result = [];
@@ -1642,35 +1632,34 @@ let NaslServer = NaslServer_1 = class NaslServer {
             return [];
         }
         const { parentNode } = nd;
-        let result = wrapRefs(this.semEnv.refMgr.getReferences(this.semEnv, nd));
-        if (nd.concept === 'Entity') {
-            // 加上所有实体逻辑调用的引用（实体逻辑可看做无定义，但要修改调用处的 namespace：实体名是 namespace 的一部分）
-            for (const l of nd.logics) {
-                result.push(...wrapRefs(this.semEnv.refMgr.getReferences(this.semEnv, l)));
-            }
-        }
-        else if (nd.concept === 'ViewElement') {
-            const refMemAddrs = this.semEnv.refMgr.getViewElementRefs(this.semEnv, nd);
-            result.push(...wrapRefs(refMemAddrs));
-        }
-        else if (nd.concept === 'ProcessElementV2') {
-            const refMemAddrs = this.semEnv.refMgr.getProcessElementRefs(this.semEnv, nd);
+        const semEnv = NaslServer_1.toRaw(this.semEnv);
+        let result = wrapRefs(semEnv.refMgr.getReferences(semEnv, nd));
+        if (nd.concept === 'ProcessElementV2') {
+            const refMemAddrs = semEnv.refMgr.getProcessElementRefs(semEnv, nd);
             result.push(...wrapRefs(refMemAddrs));
         }
         else if (nd.concept === 'DataSource') {
             for (const entity of nd.entities) {
-                const ettRefs = this.semEnv.refMgr.getReferences(this.semEnv, entity);
+                const ettRefs = semEnv.refMgr.getReferences(semEnv, entity);
                 result.push(...wrapRefs(ettRefs));
                 for (const l of entity.logics) {
-                    result.push(...wrapRefs(this.semEnv.refMgr.getReferences(this.semEnv, l)));
+                    result.push(...wrapRefs(semEnv.refMgr.getReferences(semEnv, l)));
                 }
             }
         }
-        else if (concepts_1.asserts.isStrictParam(nd)) {
+        else if (nd.concept === 'BindEvent') {
+            // v4.1 新增 绑定事件 改类型，需要把 事件逻辑的引用，全部迁移过去
+            // v4.1 修改：logics 其实只能有一个
+            if (nd.logics[0].concept === 'Logic') {
+                const eventLogicRefs = semEnv.refMgr.getReferences(semEnv, nd.logics[0]);
+                result.push(...wrapRefs(eventLogicRefs));
+            }
+        }
+        else if (nd.concept === 'Param' || nd.concept === 'ParamWithGroup') {
             // 调用处的 keyword = XXX 等也要修改，所以查 Logic、View 等的引用
             const pNode = NaslServer_1.toRaw(parentNode);
-            if (concepts_1.asserts.isStrictLogic(pNode) || concepts_1.asserts.isStrictView(pNode)) {
-                const refs = this.semEnv.refMgr.getReferences(this.semEnv, pNode);
+            if ((0, service_1.isCallableNaslLogic)(pNode) || concepts_1.asserts.isStrictView(pNode)) {
+                const refs = semEnv.refMgr.getReferences(semEnv, pNode);
                 result.push(...wrapRefs(refs));
             }
         }
@@ -1713,6 +1702,22 @@ let NaslServer = NaslServer_1 = class NaslServer {
             const minRange = {
                 ...record,
             };
+            // 搞事情：v4.1 新增 绑定事件 改类型，需要把 事件逻辑的引用，全部迁移过去
+            if (nd.concept === 'BindEvent') {
+                if (minRange.node.concept === 'Identifier') {
+                    /**
+                     * 使用正则替换倒数第二个点和倒数第一个点之间的内容
+                     * 例如 elements.button_1.bindEvents.XXX.logics -> elements.button_1.bindEvents.YYY.logics
+                     */
+                    minRange.newValue = minRange.node.namespace.replace(/(\.bindEvents\.)([^.]+)(\.logics)$/, `$1${newValue}$3`);
+                    minRange.setTypeMethods = 'setNamespace';
+                }
+                else if (minRange.node === nd) {
+                    // 自己
+                    minRange.newValue = newValue;
+                    minRange.setTypeMethods = 'setName';
+                }
+            }
             // 节点上ts临时变量标识，如果有这个就不rename
             if (minRange.node?.noTsReName) {
                 return null;
@@ -1746,6 +1751,22 @@ let NaslServer = NaslServer_1 = class NaslServer {
             }
             // 如果匹配到的节点是Identifier表达式
             if (minRange.node instanceof concepts_1.Identifier) {
+                /**
+                 * v4.1 新增 Identifier 可能是 页面元素 的事件逻辑 Logic 的引用 或 逻辑的引用
+                 * 页面元素 改名后，这个 Identifier 的 namespace 中间的元素名需要修改
+                 */
+                if (nd.concept === 'ViewElement') {
+                    minRange.setTypeMethods = 'setNamespace';
+                    /**
+                     * 使用正则替换第二个点和第三个点之间的内容
+                     * 例如 elements.XXX.bindEvents.click.logics -> elements.YYY.bindEvents.click.logics
+                     */
+                    const parts = minRange.node.namespace.split('.');
+                    if (parts.length >= 1) {
+                        parts[1] = newValue;
+                        minRange.newValue = parts.join('.');
+                    }
+                }
                 // 如果参数修改影响了Identifier, 就说明是上一级逻辑的引用，所以就直接过滤掉就好了
                 if (nd instanceof concepts_1.Param && minRange.node?.namespace?.endsWith('logics')) {
                     return null;
@@ -1824,7 +1845,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                     minRange.setTypeMethods = 'setUrlValue';
                     minRange.newValue = newTextValue;
                 }
-                else if (minRange.node instanceof concepts_1.BindAttribute && NEED_SYNC_BIND_ATTRIBUTE.includes(minRange.node.name)) {
+                else if (minRange.node instanceof concepts_1.BindAttribute && nasl_language_server_core_1.specialStringRefs.includes(minRange.node.name)) {
                     // eslint-disable-next-line no-confusing-arrow
                     minRange.newValue = (minRange.node.value ?? '').split('.').map((v, i) => i ? v : newValue.charAt(0).toLowerCase() + newValue.slice(1)).join('.');
                     minRange.setTypeMethods = 'setValue';
@@ -1863,7 +1884,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
             // 如果要修改实体属性
             if (nd instanceof concepts_1.EntityProperty) {
                 // 如果是修改实体属性，要同步绑定属性（属性名为 valueField / textField）
-                if (minRange.node instanceof concepts_1.BindAttribute && NEED_SYNC_BIND_ATTRIBUTE.includes(minRange.node.name)) {
+                if (minRange.node instanceof concepts_1.BindAttribute && nasl_language_server_core_1.specialStringRefs.includes(minRange.node.name)) {
                     // eslint-disable-next-line no-confusing-arrow
                     minRange.newValue = (minRange.node.value ?? '').split('.').slice(0, -1).concat(newValue).join('.');
                     minRange.setTypeMethods = 'setValue';
@@ -2128,7 +2149,16 @@ let NaslServer = NaslServer_1 = class NaslServer {
     // 增加参数的副作用，用于更新logic和view
     _addParamsEffect(refsList, nd) {
         const parentNode = nd?.parentNode;
-        refsList.forEach(({ node: minRangeNode }) => {
+        // 按 node.nodePath 降序排列，保证父级或更深层的引用先处理
+        const sortedRefs = (refsList || []).slice().sort((a, b) => {
+            const pa = a?.node?.nodePath ?? '';
+            const pb = b?.node?.nodePath ?? '';
+            return pb.localeCompare(pa);
+        });
+        // 考虑 CallA(CallA(null))
+        // 如果 不按 nodePath 降序排列，那么更新了第一个 CallA 后，第二个的 CallA 的 nodePath 中会有 -1
+        // 推测可能是 CallA 变成了新节点，所以存的 node 变了
+        sortedRefs.forEach(({ node: minRangeNode }) => {
             // 如果找到节点是callLogic就去更新
             if (nd instanceof concepts_1.Param) {
                 if (minRangeNode instanceof concepts_1.CallLogic || minRangeNode instanceof concepts_1.CallAuthInterface) {
@@ -2356,6 +2386,8 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 utils.delay(55);
             }
             const { node, filePath, item } = itemDetail;
+            if (!item)
+                return;
             // 先按照顺序占位
             types.set(node, null);
             // 获取已知节点类型的类型
@@ -2386,6 +2418,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 'CallFunction',
                 'CallInterface',
                 'CallMicroserviceInterface',
+                'CallGatewayInterface',
                 'MemberExpression',
                 'Return',
                 'Variable',
@@ -2621,32 +2654,12 @@ let NaslServer = NaslServer_1 = class NaslServer {
     // 不用 TS LS 的最新类型，用现有类型直接写入 NASL json
     async fastGetNaslAnnotatedJSON(naslNode) {
         // eslint-disable-next-line @typescript-eslint/no-shadow
-        const isApp = concepts_1.asserts.isApp(naslNode);
         if (this.changeStackList?.length) {
             throw new Error(`当前还有${this.changeStackList.length}个文件还在执行更新操作`);
         }
         this.logger.time('app to AnnotatedJSON');
-        if (isApp) {
-            const isSysEnum = (nsp) => ['nasl.configuration.enums', 'nasl.processV2.enums'].includes(nsp);
-            // 不知道为什么实体的（国际化、流程）枚举的默认值的 expr 和 expr.object 和 expr.property 都没标类型，但是逻辑变量的默认值就标了
-            // 不标类型，服务端就认为是用户自定义枚举，然后 import 一个奇怪的文件，就挂了
-            // Enum1.prop，怎么想 prop 也不应该标 Enum1 类型啊，现在就得是 prop、Enum1、Enum1.prop 都标成 Enum1 类型……
-            const fixEnumDefValTypesInEntity = (app) => {
-                app.dataSources.forEach(ds => ds.entities.forEach(ett => {
-                    ett.properties.forEach(prop => {
-                        // @ts-ignore
-                        if (isSysEnum(prop.defaultValue?.expression?.object?.namespace)) {
-                            const ty = prop.typeAnnotation;
-                            const memExp = prop.defaultValue.expression;
-                            memExp.__TypeAnnotation = ty;
-                            memExp.object.__TypeAnnotation = ty;
-                            memExp.property.__TypeAnnotation = ty;
-                        }
-                    });
-                }));
-            };
-            fixEnumDefValTypesInEntity(naslNode);
-        }
+        // 重置优化统计信息
+        (0, memory_optimization_1.resetOptimizationStats)();
         const timeZoneArgumentIndexMap = new Map([
             ['ToString', 1],
             ['CurrDateTime', 0],
@@ -2695,17 +2708,19 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 // Do not write redundant type annotation for TypeAnnotation concept.
                 return;
             }
-            // 删除多余属性，降低全量数据
-            delete newJson._aiUID;
+            // 集成内存优化：在标注过程中直接优化JSON，减少内存使用和处理时间
+            (0, memory_optimization_1.optimizeJsonDuringAnnotation)(newJson);
             let tyAnn = tyAnnToJSON(this.semEnv.getType(oldNd));
-            if ((oldNd.concept === 'Variable' || oldNd.concept === 'Return' || oldNd.concept === 'Param')
+            if ((oldNd.concept === 'Variable' || oldNd.concept === 'Return' || oldNd.concept === 'Param' || oldNd.concept === 'ParamWithGroup')
                 && !oldNd.typeAnnotation
                 && tyAnn?.typeKind !== 'typeParam') {
                 newJson.typeAnnotation = tyAnn;
             }
             // 原来的标注环节复制粘贴过来改写的，调整了顺序
             // jsonSerializer 是 CallLogic，其余是 CallFunction。CallLogic 有好几个子类。
-            if (oldNd.concept === 'CallFunction' || oldNd instanceof concepts_1.CallLogic) {
+            const isCallType1 = oldNd.concept === 'CallLogic' || oldNd.concept === 'CallConnector';
+            const isCallFn = oldNd.concept === 'CallFunction';
+            if (isCallType1 || isCallFn) {
                 const tzArgIdx = timeZoneArgumentIndexMap.get(oldNd.calleeName);
                 const args = oldNd.arguments;
                 const tzArg = args ? args[tzArgIdx] : undefined;
@@ -2718,9 +2733,9 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 /**
                 * 特殊处理，不想去查两次类型, 因为是从函数签名上拿类型，所以直接合并在一起，先这样
                 * 应该主要是 Java 扩展库逻辑调用
-                */
-                if (oldNd instanceof concepts_1.CallLogic && oldNd.__TypeArguments?.length) { // @ts-ignore
-                    newJson.typeArguments = oldNd.__TypeArguments.map(tyAnnToJSON); // @ts-ignore
+                */ // @ts-ignore
+                if (oldNd.__TypeArguments?.length && isCallType1) { // @ts-ignore
+                    newJson.typeArguments = oldNd.__TypeArguments.map(tyAnnToJSON);
                     newJson.typeAnnotation = tyAnn;
                 }
                 // 根据 https://projectmanage.netease-official.lcap.163yun.com/dashboard/FeatureDetail?id=2737356895760128&id1=null&iterationId=null&versionid=null&tab=info
@@ -2728,7 +2743,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 // - 对argument.expression.typeAnnotation 无需做修改，保持为其实际类型
                 // - 对argument.typeAnnotation，为根据对应Collection的泛型参数的类型填写其类型
                 // 先不动这里，有空再调整
-                if (newJson.concept === 'CallFunction') {
+                if (isCallFn) {
                     if (oldNd.calleeNamespace === 'nasl.util') {
                         const calleeName = oldNd.calleeName;
                         const listFunctionParamIndexMaps = new Map(Object.entries({
@@ -2784,44 +2799,56 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 }
             }
             if (!tyAnn) {
+                const isCallItfc = oldNd.concept === 'CallInterface' ||
+                    oldNd.concept === 'CallAuthInterface' ||
+                    oldNd.concept === 'CallMicroserviceInterface' ||
+                    oldNd.concept === 'CallGatewayInterface';
+                if (isCallType1 || isCallFn || isCallItfc) {
+                    newJson.typeAnnotation = nasl_language_server_core_1.naslVoidTy.toJSON();
+                }
                 return newJson;
             }
-            if (oldNd.concept === 'CallQueryComponent' /* && !oldNd.isAutoInfer()  直接覆盖得了，老版的 typeAnnotation 问题有点多 */) { // @ts-ignore
+            if (oldNd.concept === 'CallQueryComponent' /* && !oldNd.isAutoInfer()  直接覆盖得了，老版的 typeAnnotation 问题有点多 */) {
                 newJson.typeAnnotation = tyAnn;
                 // 新类型标注标的是对的，所以不再需要原来的改法（即，把 T 变为 { list:T, total: Long }
             }
             // 如果节点本身有类型就不去在塞一遍了
             // 有值而且没有类型再去设置
             // 但是Identifier 和 MemberExpression 都用标注出来的因为本身是变量，有类型也需要覆盖一下
-            else if (tyAnn && (oldNd.concept === 'Argument') && oldNd.getAncestor('Connector')?.concept === 'Connector') { // @ts-ignore
+            else if (tyAnn && (oldNd.concept === 'Argument') && oldNd.getAncestor('Connector')?.concept === 'Connector') {
                 newJson.typeAnnotation = tyAnn;
             }
             else if (oldNd.concept === 'Identifier' || oldNd.concept === 'MemberExpression') {
                 // @ts-ignore   处理 Match，还是需要，因为后端翻译比较特殊
-                const iName = getNameOfIdAndMemExpr(newJson); // @ts-ignore
+                const iName = getNameOfIdAndMemExpr(newJson);
                 newJson.typeAnnotation = matchExprTyAnnMap.has(iName) ? matchExprTyAnnMap.get(iName) : tyAnn;
             }
             else if ((oldNd.concept === 'NewComposite') &&
-                (oldNd.typeAnnotation?.typeKind === 'anonymousStructure' || oldNd.typeAnnotation?.typeKind === 'generic')) { // @ts-ignore
+                (oldNd.typeAnnotation?.typeKind === 'anonymousStructure' || oldNd.typeAnnotation?.typeKind === 'generic')) {
                 newJson.typeAnnotation = tyAnn;
             }
             // 服务端需要默认值节点有类型来判断父节点是否是日期类型
             else if (newJson.concept === 'DefaultValue') {
-                // @ts-ignore v3.14.x 先改成这样，应该直接拿就行
+                // v3.14.x 先改成这样，应该直接拿就行
                 newJson.typeAnnotation = tyAnn;
             }
             // 定义上不挂类型
-            else if ((!oldNd.typeAnnotation) && !nasl_language_server_core_1.ReferenceManager.defConcept.includes(oldNd.concept)) { // @ts-ignore
+            else if ((!oldNd.typeAnnotation) && !nasl_language_server_core_1.ReferenceManager.defConcept.includes(oldNd.concept)) {
                 newJson.typeAnnotation = tyAnn;
             }
             return newJson;
         };
         const json = NaslServer_1.toRaw(naslNode)._toJSON(doWork, preWork, postWork);
         this.logger.timeEnd('app to AnnotatedJSON');
-        // 测试环境或者是调试模式打印数据
-        if (utils.isDebugMode || utils.isTestBrowser) {
-            this.logger.info(`${isApp ? '全量' : '单文件'}标注数据`, json);
-        }
+        // 输出内存优化统计信息
+        const stats = (0, memory_optimization_1.getOptimizationStats)();
+        console.log('内存优化统计', {
+            节点处理数量: stats.totalCalls,
+            删除的属性: stats.propertiesRemoved,
+            删除的空数组: stats.emptyArraysRemoved,
+            删除的undefined值: stats.undefinedValuesRemoved,
+            总优化项: stats.propertiesRemoved + stats.emptyArraysRemoved + stats.undefinedValuesRemoved
+        });
         return json;
     }
     /**
@@ -3271,7 +3298,6 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 this.logger.timeEnd('语言服务变更');
             }
             catch (e) {
-                console.log('error', e);
                 console.error('error', e);
                 this.logger.info('no "naslServer:nodeChange" event received');
             }
@@ -3326,7 +3352,7 @@ let NaslServer = NaslServer_1 = class NaslServer {
                 this.typerErrRecords.length = 0;
                 this.oqlRemoveNodesTsPath.clear();
                 this.semEnv.allocatedVEQNames.forEach(n => {
-                    this.semEnv.refMgr.qNameDefs.delete(n);
+                    this.semEnv.refMgr.gQNameDefs.delete(n);
                 });
                 this.semEnv.allocatedVEQNames.length = 0;
                 this.originProxyTargetNodes.clear();
@@ -3449,26 +3475,6 @@ let NaslServer = NaslServer_1 = class NaslServer {
             }
         }
     }
-    /**
-     * 获取节点引用
-     *
-     * @param {SyntaxNode} node 查询的节点
-     * @param {SyntaxNode} [fileNode] 节点所属的文件节点，外部输入可以省去计算
-     */
-    getReferences(node, fileNode = (0, service_1.getFileNode)(node)) {
-        const refList = this.semEnv.refMgr.getReferences(this.semEnv, node)
-            .map((item) => ({ node: item, fileNode: (0, service_1.getFileNode)(item) })) // 我搞不定了，再说吧……
-            .filter((item) => item.fileNode && !item.fileNode.nodePath.includes('[-1]'));
-        const fileNodeRefList = this.semEnv.refMgr.getReferences(this.semEnv, fileNode)
-            .map((item) => ({ node: item, fileNode: (0, service_1.getFileNode)(item) })) // 我搞不定了，再说吧……
-            .filter((item) => item.fileNode && !item.fileNode.nodePath.includes('[-1]'));
-        // 引用要包含自身
-        refList.push({ node: node, fileNode });
-        return [
-            ...refList,
-            ...fileNodeRefList,
-        ];
-    }
     /**
     * 获取节点引用，不包括自己
     *
@@ -3622,14 +3628,20 @@ let NaslServer = NaslServer_1 = class NaslServer {
         uniqueViewLikes.forEach((viewLike) => {
             // 删除时，这些节点可能已经不在了，先用个 ?.
             viewLike?.getElementLogicRoot();
+            viewLike.concept === 'View' && viewLike?.getSubLogics();
         });
         uniqueLogicLikes.forEach((ctxLogic) => {
             ctxLogic?.getSubLogics();
         });
         uniqueProcessV2s.forEach((ctxProcessV2) => {
             ctxProcessV2?.getVariablesRoot();
+            ctxProcessV2?.getElementLogicRoot();
+            ctxProcessV2?.getSubLogics();
         });
     }
+    async getClient() {
+        return (0, nasl_server_client_1.getNaslServerClient)(this);
+    }
 };
 exports.NaslServer = NaslServer;
 __decorate([