@lcap/nasl-language-server-core 3.14.0-rc.3 → 3.14.0-rc.5

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

@@ -21,6 +21,7 @@ const set_1 = require("mnemonist/set");
 const nasl_predicate_1 = require("../typer/nasl-predicate");
 const type_manager_1 = require("../typer/type-manager");
 const oql_1 = require("../utils/oql");
+const parseTsClassType_1 = require("../utils/parseTsClassType");
 /**
  * 考虑这样一个例子：
  * x = f(...)
@@ -117,7 +118,7 @@ const oql_1 = require("../utils/oql");
  */
 /**
  * 一些奇怪的引用或关联关系，特别容易出错的：
- * - BindAttr 的 field/valueField/textField 字符串暗含的特殊引用
+ * - BindAttr 的 field、valueField、textField、parentField 字符串暗含的特殊引用
  * - QueryFieldExpression、QueryJoinExpression、QueryFromExpression 中的特殊引用，可能是字符串也可能是别的，注意 QueryFromExpression 内部包含 QueryJoinExpression
  * - 触碰到 Logic 时，要同时看看 OverriddenLogic
  * - 触碰到实体时，要看看实体逻辑
@@ -188,9 +189,8 @@ class ReferenceManager {
         this.cachedQNameSymbolRefs = new Map();
         // 上一次查找引用局部符号建立的 cache
         this.lastBoundary = undefined;
-        this.localQNameDefs = new Map();
-        this.localSymbolRefs = new Map();
         this.isLocalCacheValid = true;
+        this.localQNameRefs = new Map();
         // 当前文件节点
         this.curFileNode = undefined;
         this.buildSymbolRefsFromSymbolGraph = (symbolGraph) => {
@@ -202,20 +202,62 @@ class ReferenceManager {
         // 约 20 万节点 200ms
         this.slowBuildSymbolRefsForApp = (env, app) => {
             this.modeForCollect = "create" /* Operation.Create */;
-            const allRefs = this.collectRefs(env, app);
-            // 如果 QA 说查找引用要能看到实体逻辑里的类型啥的，再给注释去掉
-            // 处理一下实体逻辑
-            // app.dataSources.forEach(ds => {
-            //     ds.entities.forEach(e => {
-            //         e.logics.forEach((l: Logic) => {
-            //             const refsInLogic = this.collectRefs(env, l);
-            //             refsInLogic.forEach((qName, ref) => {
-            //                 console.log('xx')
-            //                 allRefs.set(ref, qName);
-            //             });
-            //         });
-            //     });
-            // });
+            const allRefs = new Array();
+            for (const dataSource of app.dataSources) {
+                allRefs.push(...this.collectRefs(env, dataSource));
+            }
+            for (const structure of app.structures) {
+                allRefs.push(...this.collectRefs(env, structure));
+            }
+            for (const e of app.enums) {
+                allRefs.push(...this.collectRefs(env, e));
+            }
+            for (const l of app.logics) {
+                allRefs.push(...this.collectRefs(env, l));
+            }
+            for (const ol of app.overriddenLogics) {
+                allRefs.push(...this.collectRefs(env, ol));
+            }
+            for (const i of app.interfaces) {
+                allRefs.push(...this.collectRefs(env, i));
+            }
+            // 见下面
+            // for (const frontendType of app.frontendTypes) {
+            //     allRefs.push(...this.collectRefs(env, frontendType));
+            // }
+            for (const process of app.processes) {
+                allRefs.push(...this.collectRefs(env, process));
+            }
+            // 见下面
+            // for (const processV2 of app.processV2s) {
+            //     allRefs.push(...this.collectRefs(env, processV2));
+            // }
+            for (const role of app.roles) {
+                allRefs.push(...this.collectRefs(env, role));
+            }
+            for (const connectorDependency of app.connectorDependencies) {
+                allRefs.push(...this.collectRefs(env, connectorDependency));
+            }
+            for (const interfaceDependency of app.interfaceDependencies) {
+                allRefs.push(...this.collectRefs(env, interfaceDependency));
+            }
+            for (const sharedAppDependency of app?.sharedAppDependencies) {
+                allRefs.push(...this.collectRefs(env, sharedAppDependency));
+            }
+            for (const authLogic of app.authLogics) {
+                allRefs.push(...this.collectRefs(env, authLogic));
+            }
+            for (const triggerLauncher of app.triggerLaunchers) {
+                allRefs.push(...this.collectRefs(env, triggerLauncher));
+            }
+            for (const metadataType of app.metadataTypes) {
+                allRefs.push(...this.collectRefs(env, metadataType));
+            }
+            // for (const preference of app.preferenceMap) {
+            //     allRefs.push(...this.collectRefs(env, preference as any as ValidExtInp));
+            // }
+            app.integration && allRefs.push(...this.collectRefs(env, app.integration));
+            app.backend && allRefs.push(...this.collectRefs(env, app.backend));
             allRefs.forEach(([ref, qName]) => {
                 if (!ref) {
                     return;
@@ -233,6 +275,42 @@ class ReferenceManager {
                     }
                 }
             });
+            // 如果 QA 说查找引用要能看到实体逻辑里的类型啥的，再给注释去掉
+            // 处理一下实体逻辑
+            // app.dataSources.forEach(ds => {
+            //     ds.entities.forEach(e => {
+            //         e.logics.forEach((l: Logic) => {
+            //             const refsInLogic = this.collectRefs(env, l);
+            //             refsInLogic.forEach((qName, ref) => {
+            //                 console.log('xx')
+            //                 allRefs.set(ref, qName);
+            //             });
+            //         });
+            //     });
+            // });
+            // 暂时特殊处理一下流程，应该不会太慢
+            for (const p of app.processV2s) {
+                this.addRefsForGlobalSym(env, p);
+            }
+            for (const fet of app.frontendTypes) {
+                for (const bc of fet.businessComponents) {
+                    this.addRefsForGlobalSym(env, bc);
+                }
+                for (const cd of fet.componentDependencies) {
+                    this.addRefsForGlobalSym(env, cd);
+                }
+                for (const fe of fet.frontends) {
+                    for (const v of fe.views) {
+                        this.addRefsForGlobalSym(env, v);
+                    }
+                    for (const be of fe.bindEvents) {
+                        this.addRefsForGlobalSym(env, be);
+                    }
+                    for (const v of fe.variables) {
+                        this.addRefsForGlobalSym(env, v);
+                    }
+                }
+            }
             this.modeForCollect = null;
         };
         this.fastBuildQNameDefs = (app) => {
@@ -242,7 +320,15 @@ class ReferenceManager {
                 this.addQNameDefs(app);
             }
             // Build builtin types
-            buildBuiltinTypeQNameDefs(this.qNameDefs);
+            (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]) => {
@@ -262,7 +348,7 @@ class ReferenceManager {
         };
         // Update the addQNameDefs method to use the new collection functions
         /**
-         * FIXME wudengke rename this
+         * FIXME wudengke rename this to collectFullDefs
          * @param app
          */
         this.addQNameDefs = (app) => {
@@ -270,11 +356,9 @@ class ReferenceManager {
                 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');
-                    }
-                    else {
-                        this.addQNameDef(qName, def);
+                        this.compDefMgr.add(def, 'referenceManager#addQNameDefs');
                     }
+                    this.addQNameDef(qName, def);
                 });
             }
         };
@@ -366,7 +450,7 @@ class ReferenceManager {
             else { // 局部符号才需要即时获取
                 const boundary = toRaw(getBoundary(nd));
                 if (this.lastBoundary === boundary && this.isLocalCacheValid) {
-                    res = this.localSymbolRefs.get(nd);
+                    res = this.localQNameRefs.get((0, get_q_name_1.getTokenQualifiedName)(nd));
                 }
                 else {
                     // 局部扫描，建立所有局部引用
@@ -380,15 +464,12 @@ class ReferenceManager {
         };
         // 建立所有局部引用，先处理上一次的缓存
         this.clearRebuildLocalCache = (env, nd_) => {
-            if (this.localSymbolRefs.size > 0) {
-                this.localQNameDefs.clear();
-                this.localSymbolRefs.clear();
-            }
-            return this.buildLocalQNameDefs(env, toRaw(nd_));
+            this.localQNameRefs.clear();
+            return this.buildLocalQNameRefs(env, toRaw(nd_));
         };
         // 给类似 FileNode 级别的定义建立局部索引
         // 修改后：不写入 env map 了，不做缓存，直接返回数据
-        this.buildLocalQNameDefs = (env, __nd) => {
+        this.buildLocalQNameRefs = (env, __nd) => {
             this.modeForCollect = "create" /* Operation.Create */;
             const nd = toRaw(__nd);
             let logicVars = new Array();
@@ -417,20 +498,19 @@ class ReferenceManager {
             [...allVars, ...logics].forEach(def => {
                 const qName = (0, get_q_name_1.getTokenQualifiedName)(def);
                 if (qName) {
-                    this.localQNameDefs.set(qName, def);
-                    this.localSymbolRefs.set(def, new Set());
+                    this.localQNameRefs.set(qName, new Set());
                 }
             });
             let subRefs = this.collectRefs(env, boundary);
             this.lastBoundary = boundary;
             subRefs?.forEach(([rf, qName]) => {
-                const def = this.localQNameDefs.get(qName);
-                def && this.localSymbolRefs.get(def).add(rf);
+                // 不存在则表示不是局部符号
+                this.localQNameRefs.get(qName)?.add(rf);
             });
             // Note: 暂不支持 BindAttr、BindDirective 里的变量的查找引用
             this.isLocalCacheValid = true;
             this.modeForCollect = null;
-            return this.localSymbolRefs.get(nd);
+            return this.localQNameRefs.get((0, get_q_name_1.getTokenQualifiedName)(nd));
         };
         /**
          * References to view elements are calls of component logic and access of properties
@@ -557,8 +637,6 @@ class ReferenceManager {
                 // 目前的策略是 re-link：删除 logic1 后，不会删除引用。新建一个 logic1 后，自动关联到老的引用上
                 case "create" /* Operation.Create */: {
                     if (symbol_type_1.localDefConcept.includes(defNode.concept)) {
-                        this.localQNameDefs.set(qName, defNode);
-                        this.localSymbolRefs.set(defNode, new Set());
                         this.isLocalCacheValid = false;
                     }
                     else {
@@ -567,6 +645,9 @@ class ReferenceManager {
                         oldRefs && this.setSymbolRefs(defNode, oldRefs);
                         // qName 链接到新的 defNode 的 mem addr
                         this.addQNameDef(qName, defNode);
+                        if ((0, component_def_manager_1.isGeneralViewElementDefinition)(defNode)) {
+                            this.compDefMgr.add(defNode, 'handleDefOp');
+                        }
                         // 删除缓存
                         this.cachedQNameSymbolRefs.delete(qName);
                     }
@@ -574,14 +655,15 @@ class ReferenceManager {
                 }
                 case "delete" /* Operation.Remove */: { // 连根拔起，但缓存
                     if (symbol_type_1.localDefConcept.includes(defNode.concept)) {
-                        this.localQNameDefs.delete(qName);
-                        this.localSymbolRefs.delete(defNode);
                         this.isLocalCacheValid = false;
                     }
                     else {
                         const refs = this.getSymbolRefs(defNode);
                         refs && this.cachedQNameSymbolRefs.set(qName, refs);
                         this.qNameDefs.delete(qName);
+                        if ((0, component_def_manager_1.isGeneralViewElementDefinition)(defNode)) {
+                            this.compDefMgr.removeComponentGroup(defNode);
+                        }
                         this.deleteSymbolRefs(defNode);
                     }
                     break;
@@ -668,35 +750,51 @@ class ReferenceManager {
                 }
             }
         };
-        this.handleNewCompositeNode = (nd) => {
-            if (nd.concept !== 'NewComposite' || !nd.typeAnnotation) {
+        // 处理的 concept 是 Identifier，可以由调用方处理
+        this.handleNewCompositeNode = (nd, res) => {
+            if (!nd.typeAnnotation) {
                 return;
             }
-            if (!(0, type_predicate_1.isEntityTy)(nd.typeAnnotation) && !(0, type_predicate_1.isStructureTy)(nd.typeAnnotation)) {
+            const typeAnnotation = nd.typeAnnotation;
+            if (!(0, type_predicate_1.isEntityTy)(typeAnnotation) && !(0, type_predicate_1.isStructureTy)(typeAnnotation)) {
                 return;
             }
-            const tyQName = (0, get_q_name_1.getTokenQualifiedName)(nd.typeAnnotation);
+            const tyQName = (0, get_q_name_1.getTokenQualifiedName)(typeAnnotation);
             if (!tyQName) {
                 return;
             }
-            const def = this.qNameDefs.get(tyQName);
-            if (!def) {
-                this.cachedQNameSymbolRefs.set(tyQName, new Set([nd.typeAnnotation]));
-                return;
+            res.push([typeAnnotation, tyQName]);
+            const parentConcept = (0, type_predicate_1.isEntityTy)(typeAnnotation) ? 'Entity' : 'Structure';
+            for (const prop of nd.properties) {
+                const propQName = (0, get_q_name_1.getPropQName)(tyQName, prop.name, parentConcept);
+                res.push([prop, propQName]);
             }
-            else {
-                (0, fp_macros_1.createOnAdd)(this.symbolRefs, def, nd.typeAnnotation);
+        };
+        /**
+         * RefConcept 里暂时没有加 EntityProperty，因为它是个 Definition，
+         * 所以只能在这个函数里直接加入，而不能由调用方处理
+         */
+        this.handleForeignKeyRef = (env, nd) => {
+            const relNsp = nd.relationNamespace;
+            const relEntity = nd.relationEntity;
+            const relProperty = nd.relationProperty;
+            if (!relNsp || !relEntity || !relProperty) {
+                return;
             }
-            for (const prop of nd.properties) {
-                const propQName = (0, get_q_name_1.getPropQName)(tyQName, prop.name, 'Entity');
-                const propDef = this.qNameDefs.get(propQName);
-                if (propDef) {
-                    (0, fp_macros_1.createOnAdd)(this.symbolRefs, propDef, prop);
-                }
-                else {
-                    (0, fp_macros_1.createOnAdd)(this.cachedQNameSymbolRefs, propQName, prop);
-                }
+            const relEntityQName = `${relNsp}.${relEntity}`;
+            this.handleRefOp(env, this.modeForCollect, nd, relEntityQName);
+            const relPropQName = (0, get_q_name_1.getPropQName)(`${relNsp}.${relEntity}`, `${relProperty}`, 'Entity');
+            this.handleRefOp(env, this.modeForCollect, nd, relPropQName);
+        };
+        this.handleBusinessComponentRefs = (env, nd) => {
+            const bsName = nd.tag.split('bs-')[1];
+            // 虽然慢，但它数量少哇！
+            const fet = nd.frontendType;
+            const bsDef = fet.businessComponents.find(bc => bc.name === bsName);
+            if (!bsDef) {
+                return;
             }
+            this.handleRefOp(env, this.modeForCollect, nd, (0, get_q_name_1.getTokenQualifiedName)(bsDef));
         };
         /**
          * 无论根节点是 ref 还是 def，都要递归收集下层所有的引用节点
@@ -719,8 +817,8 @@ class ReferenceManager {
             const normalCb = (n) => {
                 // 隐式引用 - 来自 __TypeAnnotation
                 this.handleSymbolImplicitRefs(n);
-                // New 左侧不是成员访问，需单独特殊处理，但也不用终止子树迭代
-                this.handleNewCompositeNode(n);
+                n.concept === 'ViewElement' && n.tag.startsWith('bs-') && this.handleBusinessComponentRefs(env, n);
+                n.concept === 'EntityProperty' && this.handleForeignKeyRef(env, n);
                 if (!symbol_type_1.refConcept.includes(n.concept)) {
                     return;
                 }
@@ -735,7 +833,10 @@ class ReferenceManager {
             const compositeNodePred = (n) => n.concept === 'MemberExpression' ||
                 n.concept === 'QueryFieldExpression' ||
                 n.concept === 'TypeAnnotation' ||
-                n.concept === 'OqlQueryComponent';
+                n.concept === 'OqlQueryComponent' ||
+                n.concept === 'FieldPermissionV2' ||
+                // @ts-expect-error 临时 hack，下个版本应该把左侧 concept 改一改
+                n.concept === 'NewComposite';
             // 会终止子树迭代
             const compositeNodeCb = (n) => {
                 let qNameRefs = new Array();
@@ -743,11 +844,6 @@ class ReferenceManager {
                     case 'MemberExpression':
                         qNameRefs = this.hackMemExpr(env, n);
                         break;
-                    case 'QueryFieldExpression':
-                        // case 'QueryFromExpression': 这样做行不通或者说很难处理，因为 from 里包含了 join，不会再走到 join
-                        // case 'QueryJoinExpression':
-                        qNameRefs = this.splitQueryLike(n);
-                        break;
                     case 'TypeAnnotation':
                         const refs = this.splitPolyType(n);
                         for (const ref of refs) {
@@ -755,11 +851,26 @@ class ReferenceManager {
                             qName && qNameRefs.push([ref, qName]);
                         }
                         break;
+                    case 'NewComposite':
+                        // New 左侧不是成员访问，需单独特殊处理，且需要终止子树迭代：否则会给局部同名变量错误添加引用，如 Entity1.variable1 会错误给局部变量 variable1 添加引用
+                        this.handleNewCompositeNode(n, res);
+                        // 右侧构成的引用
+                        qNameRefs = n.rights
+                            .flatMap(r => this.collectRefs(env, r));
+                        break;
                     case 'OqlQueryComponent':
                         for (const qName of (0, oql_1.extractSymbolsFromOqlQueryComponent)(n)) {
                             qNameRefs.push([n, qName]);
                         }
                         break;
+                    case 'QueryFieldExpression':
+                        // case 'QueryFromExpression': 这样做行不通或者说很难处理，因为 from 里包含了 join，不会再走到 join
+                        // case 'QueryJoinExpression':
+                        qNameRefs = this.splitQueryLike(n);
+                        break;
+                    case 'FieldPermissionV2':
+                        qNameRefs = this.splitFieldPermissionV2(env, n);
+                        break;
                     default: break;
                 }
                 for (const [ref, qName] of qNameRefs) {
@@ -794,6 +905,7 @@ class ReferenceManager {
         /**
          * @warning Only handle global symbols
          * 仅清除全局符号的引用。外部优先调用此接口，不要直接调用 collectRefs
+         * 不是说输入是 global symbol，而是说对于任何输入，只移除内部对 global symbol 的引用
          */
         this.removeRefsForGlobalSym = (env, rmNd) => {
             this.curFileNode = rmNd;
@@ -801,12 +913,16 @@ class ReferenceManager {
             if (rmNd.concept === 'View' || rmNd.concept === 'BusinessComponent') {
                 env.viewAssocProcess = env.processViewBindings.get((0, get_q_name_1.getTokenQualifiedName)(rmNd)) ?? null;
             }
-            const localVars = env.localVars.get(rmNd) ?? [];
+            if (rmNd.concept === 'ProcessV2') {
+                env.processAssocBind = rmNd.bind;
+            }
+            // const localVars = env.localVars.get(rmNd as any) ?? [];
             const refAndQNames = this.collectRefs(env, rmNd);
             for (const [ref, qName] of refAndQNames) {
-                if (localVars.includes(qName) || cheapTestLocalSymbol(qName)) {
-                    continue;
-                }
+                // if (localVars.includes(qName) || cheapTestLocalSymbol(qName)) {
+                //     continue;
+                // }
+                // 删的时候似乎也不用管是不是局部的、全局的，虽然添加的时候要注意
                 this.handleRefOp(env, "delete" /* Operation.Remove */, ref, qName);
             }
             this.modeForCollect = null;
@@ -823,10 +939,12 @@ class ReferenceManager {
                 (0, update_nasl_fragment_1.removeBindAttrRef)(this, rmNd);
             }
             env.viewAssocProcess = null;
+            env.processAssocBind = null;
         };
         /**
          * @warning Only handle global symbols
          * 仅收集全局符号的引用。外部优先调用此接口，不要直接调用 collectRefs
+         * 不是说输入是 global symbol，而是说对于任何输入，只收集内部对 global symbol 的引用
          */
         this.addRefsForGlobalSym = (env, nd) => {
             this.curFileNode = nd;
@@ -835,6 +953,9 @@ class ReferenceManager {
                 // 如果是 null，则设置为 null，否则会报错
                 env.viewAssocProcess = env.processViewBindings.get((0, get_q_name_1.getTokenQualifiedName)(nd)) ?? null;
             }
+            if (nd.concept === 'ProcessV2') {
+                env.processAssocBind = nd.bind;
+            }
             const refAndQNames = this.collectRefs(env, nd);
             const localVars = env.localVars.get(nd) ?? [];
             for (const [ref, qName] of refAndQNames) {
@@ -846,11 +967,9 @@ class ReferenceManager {
             this.modeForCollect = null;
             this.curFileNode = undefined;
             env.viewAssocProcess = null;
+            env.processAssocBind = null;
         };
-        this.removeLocalSymbol = (nd) => {
-            const qName = (0, get_q_name_1.getTokenQualifiedName)(nd);
-            this.localQNameDefs.delete(qName);
-            this.localSymbolRefs.delete(nd);
+        this.invalidateLocalSymCache = (nd) => {
             this.isLocalCacheValid = false;
         };
         /**
@@ -1053,6 +1172,24 @@ class ReferenceManager {
             }
             return res;
         };
+        this.splitFieldPermissionV2 = (env, nd) => {
+            const res = [];
+            const bind = env.processAssocBind;
+            if (!bind) {
+                return res;
+            }
+            const entityRef = bind.typeAnnotation.properties.find(p => p.name === nd.propertyName);
+            if (!entityRef) {
+                return res;
+            }
+            const entityQName = nd.propertyName === 'data'
+                ? (0, get_q_name_1.getTokenQualifiedName)(entityRef.typeAnnotation) // data 是 Entity
+                : (0, get_q_name_1.getTokenQualifiedName)(entityRef.typeAnnotation.typeArguments[0]); // relation_data 是 List<Entity>
+            for (const sub of nd.subFieldPermissions) {
+                res.push([sub, (0, get_q_name_1.getPropQName)(entityQName, sub.propertyName, 'Entity')]);
+            }
+            return res;
+        };
         /**
          * 获取 Reference Manager 的内存统计信息
          */
@@ -1061,8 +1198,7 @@ class ReferenceManager {
                 qNameDefs: this.qNameDefs,
                 symbolRefs: this.symbolRefs, // Exporting private map for serialization
                 cachedQNameSymbolRefs: this.cachedQNameSymbolRefs,
-                localQNameDefs: this.localQNameDefs,
-                localSymbolRefs: this.localSymbolRefs,
+                localQNameRefs: this.localQNameRefs,
                 compDefMgr: this.compDefMgr,
             };
             const result = {
@@ -1170,44 +1306,12 @@ class ReferenceManager {
         this.clearSymbolRefs();
         this.qNameDefs.clear();
         this.cachedQNameSymbolRefs.clear();
-        this.localQNameDefs.clear();
-        this.localSymbolRefs.clear();
+        this.localQNameRefs.clear();
         this.compDefMgr.clearAll();
         this.symbolImplicitRefs = new WeakMap();
     }
 }
 exports.ReferenceManager = ReferenceManager;
-const buildBuiltinTypeQNameDefs = (qNameDefs) => {
-    const createNaslPrimTyDef = (name) => nasl_concepts_1.Structure.createProtoTypeOnly({ name, properties: [] });
-    ['Boolean', 'String', 'Long', 'Decimal', 'Date', 'DateTime', 'Time', 'Binary', 'Null', 'any', 'void'].forEach(str => {
-        const def = createNaslPrimTyDef(str);
-        if (def.name === 'String') {
-            def.properties.push(nasl_concepts_1.StructureProperty.createProtoTypeOnly({
-                name: 'length',
-                typeAnnotation: typer_1.naslLongTy
-            }));
-        }
-        // type namespace is nasl.core
-        qNameDefs.set(`nasl.core.${str}`, def);
-    });
-    const createNaslGenericTyDef = (name) => nasl_concepts_1.Structure.createProtoTypeOnly({
-        name,
-        properties: [nasl_concepts_1.StructureProperty.createProtoTypeOnly({ name: 'length', typeAnnotation: typer_1.naslLongTy })],
-    });
-    ['Map', 'List'].forEach(str => {
-        const def = createNaslGenericTyDef(str);
-        if (str === 'List') {
-            def.typeParams = [(0, typer_1.createTyParam)('T')];
-        }
-        else if (str === 'Map') {
-            def.typeParams = [(0, typer_1.createTyParam)('K'), (0, typer_1.createTyParam)('V')];
-        }
-        // type namespace is nasl.collection
-        qNameDefs.set(`nasl.collection.${str}`, def);
-    });
-    // Current<T>
-    (0, builtin_q_name_1.collectAllNaslNameSpace)(qNameDefs);
-};
 // prependStr moved to get-q-name.ts
 // getTokenQualifiedName moved to get-q-name.ts
 // getTokenQualifiedNameForMatchedExpr moved to get-q-name.ts
@@ -1401,8 +1505,14 @@ 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') ||
-        qName.indexOf('.') === -1) {
+        qName.startsWith('nasl.collection')) {
+        return true;
+    }
+    // 页面下引用的 Process 的 qName
+    // if (qName.startsWith('Process_')) {
+    //     return false;
+    // }
+    if (qName.indexOf('.') === -1) {
         return true;
     }
     return false;