@lcap/nasl 2.19.0-beta.1 → 2.19.0-beta.2

package/out/server/naslServer.js

@@ -33,6 +33,7 @@ const path = __importStar(require("path"));
 const worker_threads_1 = require("worker_threads");
 /// #endif
 const config_1 = require("../config");
+const sentry_1 = require("../sentry");
 const Messager_1 = __importDefault(require("../common/Messager"));
 const getMemberIdentifier_1 = require("../server/getMemberIdentifier");
 const concepts_1 = require("../concepts");
@@ -44,24 +45,30 @@ const diagnostic_1 = require("../manager/diagnostic");
 const createUiTs_1 = __importDefault(require("./createUiTs"));
 const coreTypeList_1 = require("../concepts/basics/types/coreTypeList");
 const formatTsUtils_1 = require("./formatTsUtils");
+const utils = __importStar(require("../utils"));
 const naslStdlibMap_1 = __importDefault(require("./naslStdlibMap"));
 const jsoner = __importStar(require("../service/storage/jsoner"));
 const EventEmitter_1 = require("../common/EventEmitter");
+const utils_1 = require("../utils");
+const decimal_js_1 = require("decimal.js");
 const EmbeddedTSFileLineMap = {
     Entity: 3,
 };
 const EmbeddedTSFileOffsetMap = {
     Variable: 12,
+    ConfigProperty: 12,
 };
-// 要Check的文件
-const filesToCheck = new Set();
-// 单个文件正在change，不允许同时两个文件一起change
-let singleFileChangeIng = false;
+const SentryMessager = (0, sentry_1.sentryMonitorTSWorkerMessager)(Messager_1.default);
 let isChangeInterface = false; //判断是否导入接口
 let actionArr = []; //用于导入接口收集更改的节点
 let timer = null; //超时器用于收集导入接口相关
 // 联合类型切割取出类型
 function getDisplayString2Type(displayString) {
+    const targetString = displayString.match(/value:\s(\S+)\)/)[1];
+    let targetType = null;
+    if (targetString.startsWith('nasl.core.')) {
+        targetType = targetString.slice(10);
+    }
     // 取出匹配的内容
     const reg = /<([^()]+)>/g;
     // 解决extends 导致类型缺失的问题
@@ -86,6 +93,9 @@ function getDisplayString2Type(displayString) {
             return item;
         }
     });
+    if (targetType) {
+        return typeList.filter((item) => item !== targetType);
+    }
     return typeList;
 }
 exports.getDisplayString2Type = getDisplayString2Type;
@@ -104,6 +114,10 @@ class NaslServer {
     embeddedTSEmitter = undefined;
     // 需要执行修改的文件
     changeStackList = [];
+    filesToCheck;
+    singleFileChangeIng;
+    // 包含组件逻辑调用的逻辑map
+    logicSetWithComponentLogic = new Set();
     constructor() {
         /// #if process.env.BUILD_TARGET === 'node'
         if (globalThis.process) // For TS build
@@ -112,10 +126,15 @@ class NaslServer {
         /// #endif
         /// #if process.env.BUILD_TARGET !== 'node'
         if (globalThis.window) // For TS build
+            /* !!!如果改动这里需要看下关联的对应文件：webpack/ts-worker/loader.js */
             this.worker = new worker_threads_1.Worker('/ts-worker.js');
         /// #endif
+        // 要Check的文件
+        this.filesToCheck = new Set();
+        // 单个文件正在change，不允许同时两个文件一起change
+        this.singleFileChangeIng = false;
         this.diagnosticManager = new diagnostic_1.DiagnosticManager();
-        this.messager = new Messager_1.default({
+        this.messager = new SentryMessager({
             protocol: 'ts-worker',
             sender: 'ide',
             context: this,
@@ -125,6 +144,12 @@ class NaslServer {
                 if (data && data.event === 'publishDiagnostics') {
                     const records = await this._resolveDiagnosticRecords(data.records);
                     this.diagnosticManager.pushAll(records);
+                    try {
+                        (0, common_1.invokeCommand)('naslServer:nodeChange');
+                    }
+                    catch (e) {
+                        console.log('no "naslServer:nodeChange" event received');
+                    }
                 }
             },
         });
@@ -148,12 +173,12 @@ class NaslServer {
                     const changeNode = changeEvent.target;
                     const { fileNode } = this.getCurrentSource(changeNode);
                     if (changeNode !== fileNode || !changeEvent.field) {
-                        const findIndex = this.changeStackList.findIndex((changeStackItem) => {
+                        const findLastIndex = this.changeStackList.findLastIndex((changeStackItem) => {
                             const target = changeStackItem.target;
                             const { fileNode: targetFileNode } = this.getCurrentSource(target);
                             return targetFileNode === fileNode;
                         });
-                        if (findIndex === this.changeStackList.length - 1) {
+                        if (findLastIndex === this.changeStackList.length - 1) {
                             this.changeStackList.pop();
                         }
                     }
@@ -194,6 +219,10 @@ class NaslServer {
         await this.getDiagnosticRecordsAndPushAll();
     }
     contentToFile(module, results) {
+        // 禁用的依赖库不生成代码 区分 undefined 和 false
+        if (module instanceof concepts_1.Module && module.type === 'extension' && module.enable === false) {
+            return;
+        }
         module.structures.forEach((structure) => {
             try {
                 const result = structure.toEmbeddedTSFile();
@@ -205,18 +234,53 @@ class NaslServer {
             catch (err) {
             }
         });
-        module.frontendVariables?.forEach((frontendVariable) => {
-            try {
-                const result = frontendVariable.toEmbeddedTSFile();
-                results.push(result);
-                // sourceMap都存在目录级别内容下，在页面层级下去找
-                frontendVariable.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, frontendVariable);
-            }
-            catch (err) {
-                console.log(err);
-            }
-        });
+        if (module instanceof concepts_1.App) {
+            module.frontends?.forEach((frontend) => {
+                try {
+                    const result = frontend.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    frontend.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, frontend);
+                }
+                catch (err) {
+                    console.log(err);
+                }
+                frontend.variables?.forEach((frontendVariable) => {
+                    try {
+                        const result = frontendVariable.toEmbeddedTSFile();
+                        results.push(result);
+                        // sourceMap都存在目录级别内容下，在页面层级下去找
+                        frontendVariable.sourceMap = result.sourceMap;
+                        this.file2NodeMap.set(result.filePath, frontendVariable);
+                    }
+                    catch (err) {
+                        console.log(err);
+                    }
+                });
+                // view的生成
+                if (!config_1.config.closeViews) {
+                    this.view2TSFile(frontend.views, results);
+                }
+                frontend.componentDependencies?.forEach((item) => this.contentToFile(item, results));
+            });
+        }
+        else {
+            module.frontends?.forEach((frontend) => {
+                try {
+                    frontend.logics.forEach((logic) => {
+                        const result = logic.toEmbeddedTSFile();
+                        results.push(result);
+                        // sourceMap都存在目录级别内容下，在页面层级下去找
+                        logic.sourceMap = result.sourceMap;
+                        this.file2NodeMap.set(result.filePath, logic);
+                    });
+                }
+                catch (err) {
+                    console.log(err);
+                }
+            });
+        }
         module.dataSources?.forEach((dataSource) => {
             // 本身dataSource也要生成一个文件用于改名
             try {
@@ -274,10 +338,6 @@ class NaslServer {
             catch (err) {
             }
         });
-        // view的生成
-        if (!config_1.config.closeViews) {
-            this.view2TSFile(module.views, results);
-        }
         module.processes.forEach((process) => {
             try {
                 const result = process.toEmbeddedTSFile();
@@ -301,6 +361,21 @@ class NaslServer {
                 }
             });
         }
+        module.configuration?.groups?.forEach((_group) => {
+            if (_group.name === 'custom') {
+                _group.properties.forEach((_property) => {
+                    try {
+                        const result = _property.toEmbeddedTSFile();
+                        results.push(result);
+                        // sourceMap都存在目录级别内容下，在页面层级下去找
+                        _property.sourceMap = result.sourceMap;
+                        this.file2NodeMap.set(result.filePath, _property);
+                    }
+                    catch (err) {
+                    }
+                });
+            }
+        });
     }
     view2TSFile(viewsChildren, results) {
         // 如果有子页面
@@ -328,7 +403,6 @@ class NaslServer {
             // 其他模块的创建内容
             app.dependencies.forEach((item) => this.contentToFile(item, results));
             app.interfaceDependencies.forEach((item) => this.contentToFile(item, results));
-            app.componentDependencies.forEach((item) => this.contentToFile(item, results));
         }
         catch (err) {
             console.log(err);
@@ -358,8 +432,7 @@ class NaslServer {
         await this.openApp(app);
         // 重新check一遍所有内容
         await this.getDiagnosticRecordsAndPushAll();
-        // 重新补一遍标注
-        await this.createdNaslAnnotatedJSON(app);
+        // check内容后，会自动走增量类型标注完善全部类型
     }
     /**
      * 初始化之前添加文件
@@ -464,6 +537,9 @@ class NaslServer {
              * fileNode
              */
             const { currentSource, fileNode } = this.getCurrentSource(callFunction);
+            if (!currentSource) {
+                return [];
+            }
             try {
                 const quickInfo = await this._getTypeQuickinfo({
                     file: fileNode.getEmbeddedFilePath(),
@@ -503,8 +579,8 @@ class NaslServer {
         }
     }
     /**
-     * 获取表单的dataschema类型
-     * @param node 当前表单节点
+     * 获取表格的dataschema类型
+     * @param node 当前表格节点
      * @param allType 是不是需要全部类型 默认不要
      * @returns 全部类型的str 或者 最后一个.后的内容
      */
@@ -512,6 +588,9 @@ class NaslServer {
         if (!(node instanceof concepts_1.ViewElement))
             return;
         const { currentSource, fileNode } = this.getCurrentSource(node);
+        if (!currentSource) {
+            return;
+        }
         const quickInfo = await this._getTypeQuickinfo({
             file: fileNode.getEmbeddedFilePath(),
             line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
@@ -570,6 +649,9 @@ class NaslServer {
         if (!(node instanceof concepts_1.ViewElement))
             return;
         const { currentSource, fileNode } = this.getCurrentSource(node);
+        if (!currentSource) {
+            return;
+        }
         const quickInfo = await this._getTypeQuickinfo({
             file: fileNode.getEmbeddedFilePath(),
             line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
@@ -684,6 +766,14 @@ class NaslServer {
         const records = await this.getDiagnosticRecords(fileNames);
         // diagnosticManager.pushAll(records);
     }
+    /**
+     * 节点异常是只能挂载单个，如果已经了就不赋值了
+     */
+    baseNodeAssignmentTsError(node, tsErrorDetail) {
+        if (node.tsErrorDetail)
+            return;
+        node.tsErrorDetail = tsErrorDetail;
+    }
     /**
      * 处理诊断结果
      * @param records 结果
@@ -704,7 +794,7 @@ class NaslServer {
                 if (item.node) {
                     item.node.tsErrorDetail = undefined;
                     // 如果logic中有报错就把标识置为true
-                    if (item.node.logic) {
+                    if (item.node?.logic?.haveError) {
                         item.node.logic.haveError = false;
                     }
                 }
@@ -737,6 +827,51 @@ class NaslServer {
                 .map((diag) => this._resolveDiagnostic(diag, node, record))
                 .filter((diag) => !!diag);
             record.semanticDiagnostics.push(...this._attachDiagnostics(node));
+            // 报错降级逻辑
+            record.semanticDiagnostics = record.semanticDiagnostics
+                .map((diagnostic) => {
+                // 错误降级如果属于草稿态的就降级
+                if (diagnostic?.node) {
+                    let currentNode = diagnostic.node;
+                    if (diagnostic.severity === 'warning') {
+                        record.suggestionDiagnostics.push(diagnostic);
+                        return null;
+                    }
+                    else if (currentNode.concept === 'OqlQueryComponent') {
+                        // OQL别名错误降级为警告
+                        if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
+                            // 重置 图标和错误等级
+                            diagnostic.severity = 'warning';
+                            if (diagnostic.node?.tsErrorDetail) {
+                                // 重置组件节点上的错误信息
+                                diagnostic.node.tsErrorDetail.severity = 'warning';
+                            }
+                            record.suggestionDiagnostics.push(diagnostic);
+                            return null;
+                        }
+                    }
+                    while (currentNode?.parentNode?.concept !== 'App') {
+                        if (currentNode.parentKey?.toLowerCase()?.includes('playground')) {
+                            // 草稿区降级
+                            // 重置 图标和错误等级
+                            diagnostic.severity = 'warning';
+                            if (diagnostic.node?.tsErrorDetail) {
+                                // 重置组件节点上的错误信息
+                                diagnostic.node.tsErrorDetail.severity = 'warning';
+                            }
+                            record.suggestionDiagnostics.push(diagnostic);
+                            return null;
+                        }
+                        currentNode = currentNode.parentNode;
+                    }
+                    // 没有降级的继续遍历，如果在logic中，logic本身需要有error状态
+                    // 如果logic中有报错就把标识置为true
+                    if (diagnostic.node?.logic) {
+                        diagnostic.node.logic.haveError = true;
+                    }
+                }
+                return diagnostic;
+            }).filter((diag) => !!diag);
             // 建议诊断
             // 实体下的建议不用展示，因为都是平台自己写的逻辑
             // if (node instanceof Entity) {
@@ -750,15 +885,71 @@ class NaslServer {
             //     // logic在for循环中，不展示any提示
             //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
             // }
-            record.suggestionDiagnostics = record.suggestionDiagnostics
-                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`,
-                `'__UpdateNoProperty__' is declared but its value is never read.`].includes(item.text))
-                .map((diag) => this._resolveDiagnostic(diag, node, record))
-                .filter((diag) => !!diag);
+            // 处理后的警告异常提示信息
+            record.suggestionDiagnostics = record.suggestionDiagnostics.map((diag) => {
+                // 上面错误降级下来的
+                if (diag?.node) {
+                    return diag;
+                    // 一些已知警告的单独处理
+                }
+                else if ([`'__LogicEmpty' is declared but its value is never read.`,
+                    `'__destinationEmpty__' is declared but its value is never read.`,
+                    `'__devConfigValueEmpty' is declared but its value is never read.`,
+                    `'__onlineConfigValueEmpty' is declared but its value is never read.`,
+                    `'__UpdateNoProperty__' is declared but its value is never read.`].includes(diag.text)) {
+                    return this._resolveDiagnostic(diag, node, record);
+                }
+                else if ((diag.text).includes(` is declared but its value is never read.`)) {
+                    // 局部变量和输入变量未使用的警告
+                    if ((node.concept === 'View' || node.concept === 'Logic') && node.parentNode.concept !== 'Module') {
+                        /**
+                         * javalogic不用提示
+                         */
+                        if (node.concept === 'Logic' && this._isJavalogic(node)) {
+                            return;
+                        }
+                        const minRange = this._findMinRange(diag, node);
+                        if (minRange) {
+                            /**
+                             * 如果节点是入参类型
+                             * 而且不是foreach中
+                             * 而且不是事件逻辑的入参
+                             */
+                            if (minRange.node instanceof concepts_1.Param && minRange.node.parentNode.concept !== 'ForEachStatement' && !minRange.node.getAncestor('BindEvent')) {
+                                const diagnostic = {
+                                    node: minRange.node,
+                                    severity: 'warning',
+                                    message: `未使用的输入参数${minRange.node.name}`,
+                                };
+                                return diagnostic;
+                            }
+                            else if (minRange.node instanceof concepts_1.Variable) {
+                                const diagnostic = {
+                                    node: minRange.node,
+                                    severity: 'warning',
+                                    message: `未使用的变量${minRange.node.name}`,
+                                };
+                                return diagnostic;
+                            }
+                        }
+                    }
+                }
+                return null;
+            }).filter((diag) => !!diag);
             record.suggestionDiagnostics.push(...this._attachSuggestionDiagnostics(node));
         });
         return records;
     }
+    /**
+     * 判断是否是Javalogic
+     */
+    _isJavalogic(node) {
+        const body = node.body || [];
+        if (body && body.length && body[0].concept === 'JavaLogic') {
+            return true;
+        }
+        return false;
+    }
     /**
      * 额外的建议诊断
      * @param fileNode 文件级别的节点
@@ -767,24 +958,9 @@ class NaslServer {
     _attachSuggestionDiagnostics(fileNode) {
         const diagnostics = [];
         if (fileNode instanceof concepts_1.Logic || fileNode instanceof concepts_1.View) {
-            // 判断逻辑是否已经删除
-            if (fileNode instanceof concepts_1.Logic && fileNode.parentNode instanceof concepts_1.App && !fileNode.parentNode.logics.includes(fileNode))
-                return diagnostics;
-            // 判断页面是否已经删除
-            let removed = false;
-            let curNode = fileNode;
-            // 递归检查，防止从顶层页面开始删除影响子页面内容检查
-            while (curNode instanceof concepts_1.View && !removed) {
-                if (curNode.parentNode instanceof concepts_1.View && !curNode.parentNode.children.includes(curNode)
-                    || curNode.parentNode instanceof concepts_1.App && !curNode.parentNode.views.includes(curNode)) {
-                    removed = true;
-                }
-                curNode = curNode.parentNode;
-            }
-            if (removed)
-                return diagnostics;
             fileNode?.sourceMap.forEach((value, node) => {
-                if (node instanceof concepts_1.Match) {
+                // 表达式模式才需要校验返回值类型
+                if (node instanceof concepts_1.Match && node.isExpression) {
                     const { cases, expression } = node || {};
                     const typeAnnotationMap = {};
                     // 最多数的类型
@@ -898,8 +1074,8 @@ class NaslServer {
                                     if (Array.isArray(body) && body.length) {
                                         const lastExpression = body[body.length - 1];
                                         diagnostic.node = lastExpression;
-                                        diagnostic.message = `${lastExpression?.toUI()}期望的类型是${maxTypeAnnotation?.headTitle}`;
-                                        lastExpression.tsErrorDetail = diagnostic;
+                                        diagnostic.message = `匹配：该分支类型与多数类型不一致，将产生Union类型。当前类型：${typeAnnotation?.headTitle}，多数类型：${maxTypeAnnotation?.headTitle}`;
+                                        this.baseNodeAssignmentTsError(lastExpression, diagnostic);
                                         diagnostics.push(diagnostic);
                                     }
                                 });
@@ -907,31 +1083,235 @@ class NaslServer {
                         }
                     }
                 }
+                else if (node instanceof concepts_1.NewList && !node.typeAnnotation) {
+                    // 匿名函数返回值有可能是newList，需要过滤。代码来源：AnonymousFunction.__ts
+                    const grandParent = node.parentNode?.parentNode?.parentNode;
+                    if (grandParent instanceof concepts_1.CallLogic
+                        && /dataSources\.[^.]+\.entities\.[^.]+\.logics/.test(grandParent.calleeNamespace)
+                        && ['update', 'updateBy', 'createOrUpdate', 'batchUpdate'].includes(grandParent.calleeName)) {
+                        return;
+                    }
+                    const { items } = node || {};
+                    const typeAnnotationMap = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo = {
+                        typeAnnotation: null,
+                        count: 0,
+                    };
+                    if (Array.isArray(items)) {
+                        items.forEach((item) => {
+                            const typeAnnotation = item.__TypeAnnotation;
+                            // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
+                            if (typeAnnotation) {
+                                const sortedTypeKey = typeAnnotation.sortedTypeKey;
+                                if (!typeAnnotationMap[sortedTypeKey]) {
+                                    typeAnnotationMap[sortedTypeKey] = {
+                                        typeAnnotation,
+                                        items: [],
+                                        count: 0,
+                                    };
+                                }
+                                const typeAnnotationInfo = typeAnnotationMap[sortedTypeKey];
+                                typeAnnotationInfo.items.push(item);
+                                typeAnnotationInfo.count++;
+                                const { count } = typeAnnotationInfo;
+                                if (maxTypeAnnotationInfo.count < count) {
+                                    maxTypeAnnotationInfo = {
+                                        typeAnnotation,
+                                        count,
+                                    };
+                                }
+                            }
+                        });
+                    }
+                    const { typeAnnotation: maxTypeAnnotation, } = maxTypeAnnotationInfo;
+                    for (const sortedTypeKey in typeAnnotationMap) {
+                        const { typeAnnotation, items } = typeAnnotationMap[sortedTypeKey];
+                        if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
+                            if (Array.isArray(items)) {
+                                items.forEach((item) => {
+                                    const diagnostic = {
+                                        node: item,
+                                        severity: 'warning',
+                                        message: `NewList期望的类型是${maxTypeAnnotation?.headTitle}`,
+                                    };
+                                    this.baseNodeAssignmentTsError(item, diagnostic);
+                                    diagnostics.push(diagnostic);
+                                });
+                            }
+                        }
+                    }
+                }
+                else if (node instanceof concepts_1.NewMap && !node.typeAnnotation) {
+                    const { values } = node || {};
+                    const typeAnnotationMap = {};
+                    // 最多数的类型
+                    let maxTypeAnnotationInfo = {
+                        typeAnnotation: null,
+                        count: 0,
+                    };
+                    if (Array.isArray(values)) {
+                        values.forEach((value) => {
+                            if (!value)
+                                return;
+                            const typeAnnotation = value.__TypeAnnotation;
+                            // 仅处理有类型的情况，返回类型为void的情况由其他地方处理成报错
+                            if (typeAnnotation) {
+                                const sortedTypeKey = typeAnnotation.sortedTypeKey;
+                                if (!typeAnnotationMap[sortedTypeKey]) {
+                                    typeAnnotationMap[sortedTypeKey] = {
+                                        typeAnnotation,
+                                        values: [],
+                                        count: 0,
+                                    };
+                                }
+                                const typeAnnotationInfo = typeAnnotationMap[sortedTypeKey];
+                                typeAnnotationInfo.values.push(value);
+                                typeAnnotationInfo.count++;
+                                const { count } = typeAnnotationInfo;
+                                if (maxTypeAnnotationInfo.count < count) {
+                                    maxTypeAnnotationInfo = {
+                                        typeAnnotation,
+                                        count,
+                                    };
+                                }
+                            }
+                        });
+                    }
+                    const { typeAnnotation: maxTypeAnnotation, } = maxTypeAnnotationInfo;
+                    for (const sortedTypeKey in typeAnnotationMap) {
+                        const { typeAnnotation, values } = typeAnnotationMap[sortedTypeKey];
+                        if (maxTypeAnnotation?.sortedTypeKey !== typeAnnotation?.sortedTypeKey) {
+                            if (Array.isArray(values)) {
+                                values.forEach((value) => {
+                                    const diagnostic = {
+                                        node: value,
+                                        severity: 'warning',
+                                        message: `NewMap中values值所期望的类型是${maxTypeAnnotation?.headTitle}`,
+                                    };
+                                    this.baseNodeAssignmentTsError(value, diagnostic);
+                                    diagnostics.push(diagnostic);
+                                });
+                            }
+                        }
+                    }
+                }
+                else if (node.concept === 'JSBlock') {
+                    // 初始js代码块先屏蔽掉
+                    if (node.code === `location.href = '/';`) {
+                        return null;
+                    }
+                    const diagnostic = {
+                        node,
+                        severity: 'warning',
+                        message: '不建议使用js代码块',
+                    };
+                    diagnostics.push(diagnostic);
+                }
+                else if (node.concept === 'Unparsed') {
+                    const diagnostic = {
+                        node,
+                        severity: 'warning',
+                        message: '不建议使用自定义表达式',
+                    };
+                    diagnostics.push(diagnostic);
+                }
+                else if (node instanceof concepts_1.CallQueryComponent) {
+                    // 可视化查询中不允许有复杂的数据结构
+                    const contentVariables = [];
+                    utils.traverse(({ node }) => {
+                        if (node?.parentNode?.concept !== 'MemberExpression') {
+                            if (node?.concept === 'MemberExpression') {
+                                contentVariables.push(node);
+                            }
+                            else if (node?.concept === 'Identifier') {
+                                // 因为要是父级是MemberExpression， 就放入了父级，子级就不需要了
+                                contentVariables.push(node);
+                                // QueryFromExpression QueryJoinExpression
+                            }
+                            else if ((node?.concept === 'QueryFieldExpression' && !node.isDotStar) || node?.concept === 'QueryGroupByExpression') {
+                                contentVariables.push(node);
+                            }
+                        }
+                    }, { node }, {
+                        mode: 'anyObject',
+                        excludedKeySet: new Set(['parentNode', '_events', 'globalDataMap', 'havingPlayground', 'wherePlayground']),
+                    });
+                    contentVariables?.forEach((variable) => {
+                        // 如果是复杂数据结构
+                        if (variable.__TypeAnnotation?.isComplexType()) {
+                            if (variable.__TypeAnnotation?.typeName === 'List' && variable.__TypeAnnotation?.typeArguments?.[0]?.typeKind === 'primitive') {
+                                return;
+                            }
+                            const diagnostic = {
+                                node,
+                                severity: 'warning',
+                                message: `数据查询中不可以使用复杂类型！当前类型：${variable.__TypeAnnotation?.typeChineseTitle}。`,
+                            };
+                            this.baseNodeAssignmentTsError(variable, diagnostic);
+                            diagnostics.push(diagnostic);
+                        }
+                    });
+                }
             });
         }
         return diagnostics;
     }
+    // 是否包含组件逻辑
+    hasComponentLogics(expression) {
+        let flag = false;
+        (0, utils_1.traverse)((current) => {
+            const { node } = current || {};
+            const { concept } = node || {};
+            if (concept === 'CallLogic') {
+                // 调用组件逻辑
+                if (node.isComponentLogic) {
+                    flag = true;
+                }
+                else if (node.isViewLogic) { // 调用页面逻辑
+                    const logicNode = node.view?.logics?.find?.((viewLogic) => viewLogic.name === node.calleeName);
+                    if (logicNode) {
+                        if (this.logicSetWithComponentLogic.has(logicNode.nodePath)) {
+                            flag = true;
+                        }
+                        else {
+                            const logicItem = logicNode.body?.find?.((logicItem) => this.hasComponentLogics(logicItem));
+                            if (logicItem) {
+                                flag = true;
+                                this.logicSetWithComponentLogic.add(logicNode.nodePath);
+                            }
+                        }
+                    }
+                }
+            }
+        }, {
+            node: expression,
+        }, {
+            mode: 'anyObject',
+            excludedKeySet: new Set([
+                'parentNode',
+                'sourceMap',
+                'storageJSON',
+                'tsErrorDetail',
+                'NaslAnnotatedJSON',
+                'calledFrom',
+                '_events',
+                '_collectingList',
+                '_historyList',
+            ]),
+        });
+        return flag;
+    }
     /**
      * 额外的诊断
      * @param fileNode 文件级别的节点
      * @returns 诊断结果
      */
     _attachDiagnostics(fileNode) {
+        // 每次诊断前先清空这个Set
+        this.logicSetWithComponentLogic = new Set();
         const diagnostics = [];
         if (fileNode instanceof concepts_1.View) {
-            // 判断页面是否已经删除
-            let removed = false;
-            let curNode = fileNode;
-            // 递归检查，防止从顶层页面开始删除影响子页面内容检查
-            while (curNode instanceof concepts_1.View && !removed) {
-                if (curNode.parentNode instanceof concepts_1.View && !curNode.parentNode.children.includes(curNode)
-                    || curNode.parentNode instanceof concepts_1.App && !curNode.parentNode.views.includes(curNode)) {
-                    removed = true;
-                }
-                curNode = curNode.parentNode;
-            }
-            if (removed)
-                return diagnostics;
             fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof concepts_1.ViewElement && node.view === fileNode) {
                     if (node.tag) {
@@ -939,24 +1319,38 @@ class NaslServer {
                             if ((bindAttr.model || bindAttr.sync) && bindAttr.expression) {
                                 const bindExpression = bindAttr.expression;
                                 let diagnostic;
-                                if (bindExpression.concept !== 'Identifier' && bindExpression.concept !== 'MemberExpression') {
-                                    diagnostic = {
-                                        node: bindAttr,
-                                        severity: 'error',
-                                        message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
-                                    };
-                                }
-                                else {
+                                if (bindExpression.concept === 'MemberExpression') {
+                                    let current = bindExpression;
                                     if (bindExpression.isEnum()) {
                                         diagnostic = {
-                                            node: bindAttr,
+                                            node: bindExpression,
                                             severity: 'error',
                                             message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
                                         };
                                     }
+                                    else {
+                                        while (current.object) {
+                                            if (current.object.concept !== 'MemberExpression' && current.object.concept !== 'Identifier') {
+                                                diagnostic = {
+                                                    node: bindExpression,
+                                                    severity: 'error',
+                                                    message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
+                                                };
+                                                break;
+                                            }
+                                            current = current.object;
+                                        }
+                                    }
+                                }
+                                else if (bindExpression.concept !== 'Identifier') {
+                                    diagnostic = {
+                                        node: bindExpression,
+                                        severity: 'error',
+                                        message: '页面元素双向绑定：只允许绑定可赋值的变量和属性。',
+                                    };
                                 }
                                 if (diagnostic) {
-                                    bindAttr.tsErrorDetail = diagnostic;
+                                    bindExpression.tsErrorDetail = diagnostic;
                                     diagnostics.push(diagnostic);
                                 }
                             }
@@ -976,7 +1370,13 @@ class NaslServer {
                                 if (node.logic && node.logic !== nodeIn.logic)
                                     return;
                                 // 跟变量无关的赋值过滤
-                                const jsCode = nodeIn.toJS();
+                                let jsCode = '';
+                                try {
+                                    jsCode = nodeIn.toJS();
+                                }
+                                catch (err) {
+                                    console.log(err);
+                                }
                                 if (!jsCode.includes(`${node.name} = `))
                                     return;
                                 // 页面局部变量
@@ -1013,7 +1413,7 @@ class NaslServer {
                             }
                         });
                         if (!msg)
-                            msg = '未设置类型或未赋值，直接赋值系统会自动推断类型。';
+                            msg = '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
                         const diagnostic = {
                             node,
                             severity: 'error',
@@ -1023,6 +1423,31 @@ class NaslServer {
                         diagnostics.push(diagnostic);
                     }
                 }
+                else if (node instanceof concepts_1.BindAttribute || node instanceof concepts_1.BindDirective || node instanceof concepts_1.BindStyle) {
+                    if (Array.isArray(node.bindExpressions)) {
+                        const exp = node.bindExpressions.find((bindExpression) => this.hasComponentLogics(bindExpression));
+                        if (exp) {
+                            //const element: any = node.getAncestor('ViewElement');
+                            //const api = config.allNodesAPI[element?.tag];
+                            //const attr = api?.attrs?.find?.((attr) => {
+                            //    return attr.name === node.name;
+                            //});
+                            const map = {
+                                BindAttribute: '属性',
+                                BindDirective: '指令',
+                                BindStyle: '样式属性',
+                            };
+                            //“${attr?.title || node.title || node.name}”
+                            const diagnostic = {
+                                node,
+                                severity: 'error',
+                                message: `${map[node.concept]}表达式不能绑定组件逻辑`,
+                            };
+                            node.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        }
+                    }
+                }
                 else {
                     this.checkNodeError(node, diagnostics);
                 }
@@ -1074,14 +1499,14 @@ class NaslServer {
                             if (envText) {
                                 const diagnostic = {
                                     node: fileNode,
-                                    severity: 'error',
+                                    severity: 'warning',
                                     message: `数据源配置：数据源 ${property.name} ${envText}环境数据源连接不通，请先检查${envText}环境数据源配置`,
                                     // 保留原来的内容方便查询一些问题
                                     originalDiagnostic: {
                                         fileName: '',
                                         start: null,
                                         end: null,
-                                        category: 'error',
+                                        category: 'warning',
                                         text: `DataSource connection error`,
                                     },
                                 };
@@ -1092,10 +1517,239 @@ class NaslServer {
                 }
             }
         }
+        // 加上对实体属性存储类型的校验规则
+        if (fileNode instanceof concepts_1.Entity) {
+            const entity = fileNode;
+            const dbType = entity.dataSource.dataSourceSqlType;
+            const { origin, properties } = entity || {};
+            if (dbType && !['excel', 'table'].includes(origin) && Array.isArray(properties) && properties.length) {
+                properties.forEach((property) => {
+                    if (property) {
+                        const { typeAnnotation, databaseTypeAnnotation, rules } = property;
+                        const { typeName } = typeAnnotation || {};
+                        const rulesMap = {};
+                        if (Array.isArray(rules)) {
+                            rules.forEach((rule) => {
+                                const match = rule.match(/^([^()]+)\(([\d\-.]+)\)$/);
+                                if (match) {
+                                    const [, key, value] = match;
+                                    rulesMap[key] = value;
+                                }
+                            });
+                        }
+                        const diagnostic = {
+                            node: property,
+                            severity: 'error',
+                            message: '',
+                        };
+                        const dataBaseTyp = property.currentDataBaseType;
+                        typeAnnotation.tsErrorDetail = null;
+                        if (!dataBaseTyp && databaseTypeAnnotation) {
+                            const { typeName: databaseTypeName } = databaseTypeAnnotation;
+                            const errorMsg = `平台目前暂不支持${dbType}数据库的${databaseTypeName}存储类型`;
+                            diagnostic.message = errorMsg;
+                            const tsErrorDetail = {
+                                severity: 'error',
+                                errorPos: {
+                                    typeName: errorMsg,
+                                },
+                            };
+                            databaseTypeAnnotation.tsErrorDetail = tsErrorDetail;
+                        }
+                        else {
+                            const { options } = dataBaseTyp || {};
+                            if (options) {
+                                if (databaseTypeAnnotation) {
+                                    databaseTypeAnnotation.tsErrorDetail = null;
+                                    const databaseTypeAnnotationErrorDetail = {
+                                        severity: 'error',
+                                        errorPos: {},
+                                    };
+                                    for (const key in options) {
+                                        const option = options[key];
+                                        const { comment, require, min, max } = option || {};
+                                        const databaseTypeArg = databaseTypeAnnotation.arguments?.[key];
+                                        // 如果必填的值没有填，报错
+                                        if (require && !databaseTypeArg && key !== 'scale') {
+                                            diagnostic.message = `${comment}不能为空`;
+                                            databaseTypeAnnotationErrorDetail.errorPos[key] = `${comment}不能为空`;
+                                        }
+                                        else if (min && +min > +databaseTypeArg) {
+                                            diagnostic.message = `${comment}不能小于最小值${min}`;
+                                            databaseTypeAnnotationErrorDetail.errorPos[key] = `${comment}不能小于最小值${min}`;
+                                        }
+                                        else if (max && +max < +databaseTypeArg) {
+                                            diagnostic.message = `${comment}不能大于最大值${max}`;
+                                            databaseTypeAnnotationErrorDetail.errorPos[key] = `${comment}不能大于最大值${max}`;
+                                        }
+                                        if (Object.keys(databaseTypeAnnotationErrorDetail.errorPos).length) {
+                                            databaseTypeAnnotation.tsErrorDetail = databaseTypeAnnotationErrorDetail;
+                                        }
+                                    }
+                                }
+                                const typeAnnotationErrorDetail = {
+                                    severity: 'warning',
+                                    errorPos: {},
+                                };
+                                const precisionOption = options?.precision;
+                                const { default: defaultVal } = precisionOption || {};
+                                const precision = databaseTypeAnnotation ? databaseTypeAnnotation.arguments?.precision : defaultVal;
+                                const ruleScale = typeAnnotation?.ruleMap?.scale;
+                                const scale = ruleScale !== undefined ? ruleScale + '' : '';
+                                let ensureScale = true;
+                                switch (typeName) {
+                                    case 'String': {
+                                        const defaultVal = options.length?.default;
+                                        const length = databaseTypeAnnotation ? databaseTypeAnnotation.arguments?.length : defaultVal;
+                                        if (length) {
+                                            [
+                                                {
+                                                    key: 'minLength',
+                                                    text: '小',
+                                                },
+                                                {
+                                                    key: 'maxLength',
+                                                    text: '大',
+                                                },
+                                            ].forEach(({ key, text }) => {
+                                                const curLength = rulesMap[key];
+                                                if (+curLength > +length) {
+                                                    const errorMsg = `最${text}长度超出存储长度`;
+                                                    const diag = {
+                                                        node: property,
+                                                        severity: 'warning',
+                                                        message: errorMsg,
+                                                    };
+                                                    diagnostics.push(diag);
+                                                    typeAnnotationErrorDetail.errorPos[key] = errorMsg;
+                                                }
+                                            });
+                                        }
+                                    }
+                                    case 'Long': {
+                                        const { min: ruleMin, max: ruleMax } = dataBaseTyp;
+                                        const minVal = rulesMap.min;
+                                        const maxVal = rulesMap.max;
+                                        // 最大最小值都要校验存储上下限
+                                        [
+                                            {
+                                                key: 'min',
+                                                name: '最小值',
+                                                value: minVal,
+                                            },
+                                            {
+                                                key: 'max',
+                                                name: '最大值',
+                                                value: maxVal,
+                                            },
+                                        ].forEach(({ key, name, value }) => {
+                                            if (ruleMin && value && new decimal_js_1.Decimal(ruleMin).greaterThan(new decimal_js_1.Decimal(value))) { // 超出存储下限
+                                                const diag = {
+                                                    node: property,
+                                                    severity: 'warning',
+                                                    message: `${name}超出存储下限${ruleMin}`,
+                                                };
+                                                diagnostics.push(diag);
+                                                typeAnnotationErrorDetail.errorPos[key] = `${name}超出存储下限`;
+                                            }
+                                            if (ruleMax && value && new decimal_js_1.Decimal(ruleMax).lessThan(new decimal_js_1.Decimal(value))) { // 超出存储上限
+                                                const diag = {
+                                                    node: property,
+                                                    severity: 'warning',
+                                                    message: `${name}超出存储上限${ruleMax}`,
+                                                };
+                                                diagnostics.push(diag);
+                                                typeAnnotationErrorDetail.errorPos[key] = `${name}超出存储上限`;
+                                            }
+                                        });
+                                        break;
+                                    }
+                                    case 'Decimal': {
+                                        if (precisionOption) {
+                                            if (+precision < +scale) {
+                                                const diag = {
+                                                    node: property,
+                                                    severity: 'error',
+                                                    message: '',
+                                                };
+                                                const errorMsg = `小数位数必须小于或等于精度${precision}`;
+                                                diag.message = errorMsg;
+                                                diagnostics.push(diag);
+                                                ensureScale = false;
+                                                typeAnnotationErrorDetail.errorPos.scale = errorMsg;
+                                            }
+                                        }
+                                        break;
+                                    }
+                                }
+                                const minVal = rulesMap.min;
+                                const maxVal = rulesMap.max;
+                                // 最 大/小 值不能 大/于 由精度和小数位数 确定的范围
+                                if (precisionOption && ensureScale) {
+                                    const memoryStr = '9'.repeat(+precision);
+                                    // 储存整数部分
+                                    const memoryIntAbsStr = memoryStr.slice(0, +precision - +(scale || '0')) || '0';
+                                    // 储存小数部分
+                                    const memoryScaleStr = memoryStr.slice(0, +(scale || '0'));
+                                    // 储存绝对值
+                                    const memoryAbsVal = memoryIntAbsStr + (memoryScaleStr ? '.' + memoryScaleStr : '');
+                                    const decimalMemoryAbsVal = new decimal_js_1.Decimal(memoryAbsVal);
+                                    [
+                                        {
+                                            key: 'min',
+                                            text: '小',
+                                            val: minVal,
+                                        },
+                                        {
+                                            key: 'max',
+                                            text: '大',
+                                            val: maxVal,
+                                        },
+                                    ].forEach(({ key, text, val }) => {
+                                        if (val) {
+                                            const decimalVal = new decimal_js_1.Decimal(val);
+                                            // 是否是负数
+                                            const isNegative = decimalVal.isNegative();
+                                            // 填入的值的绝对值是否大于存储绝对值
+                                            if (decimalMemoryAbsVal.lessThan(decimalVal.abs())) {
+                                                const errorMsg = `最${text}值不得${isNegative ? '小' : '大'}于${isNegative ? '-' : ''}${memoryAbsVal}`;
+                                                const diag = {
+                                                    node: property,
+                                                    severity: 'warning',
+                                                    message: errorMsg,
+                                                };
+                                                diagnostics.push(diag);
+                                                typeAnnotationErrorDetail.errorPos[key] = errorMsg;
+                                            }
+                                        }
+                                    });
+                                }
+                                if (['Long', 'Decimal'].includes(typeName) && !typeAnnotationErrorDetail.errorPos.min) {
+                                    if (minVal && maxVal && new decimal_js_1.Decimal(maxVal).lessThan(minVal)) {
+                                        const errorMsg = '最小值不得大于最大值';
+                                        const diag = {
+                                            node: property,
+                                            severity: 'warning',
+                                            message: errorMsg,
+                                        };
+                                        diagnostics.push(diag);
+                                        typeAnnotationErrorDetail.errorPos.min = errorMsg;
+                                    }
+                                }
+                                if (Object.keys(typeAnnotationErrorDetail.errorPos).length) {
+                                    typeAnnotation.tsErrorDetail = typeAnnotationErrorDetail;
+                                }
+                            }
+                        }
+                        if (diagnostic.message) {
+                            property.__showAdvanced = true;
+                            diagnostics.push(diagnostic);
+                        }
+                    }
+                });
+            }
+        }
         if (fileNode instanceof concepts_1.Logic) {
-            // 判断逻辑是否已经删除
-            if (fileNode.parentNode instanceof concepts_1.App && !fileNode.parentNode.logics.includes(fileNode))
-                return diagnostics;
             fileNode?.sourceMap.forEach((value, node) => {
                 //OQL支持返回复合类型数据了
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
@@ -1108,23 +1762,49 @@ class NaslServer {
                 //     node.tsErrorDetail = diagnostic;
                 //     diagnostics.push(diagnostic);
                 // }
+                if (node instanceof concepts_1.OqlQueryComponent) {
+                    // 自动推导情况
+                    const typeAnnotation = (0, formatTsUtils_1.type2TypeAnnotation)(node.__nodeType);
+                    if (!node.typeAnnotation && typeAnnotation) {
+                        if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
+                            const typeArguments = typeAnnotation.typeArguments;
+                            if (typeArguments.length && typeArguments[0].isComplexType()) {
+                                const diagnostic = {
+                                    node,
+                                    severity: 'error',
+                                    message: `SQL查询：返回类型不支持单个复杂类型 ${typeArguments[0].headTitle}。`,
+                                };
+                                node.tsErrorDetail = diagnostic;
+                                diagnostics.push(diagnostic);
+                            }
+                        }
+                    }
+                }
                 if (node instanceof concepts_1.Return || node instanceof concepts_1.Variable) {
                     if (!node.typeAnnotation && !node.__TypeAnnotation) {
                         const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
                         let used = false;
                         fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
                             if (!used && nodeIn
-                                && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && nodeIn.left?.name))
-                                && nodeIn.toJS().includes(`${node.name} = `)) {
-                                used = true;
-                                if (!nodeIn.tsErrorDetail) {
-                                    const diagnostic = {
-                                        node: nodeIn,
-                                        severity: 'error',
-                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
-                                    };
-                                    nodeIn.tsErrorDetail = diagnostic;
-                                    diagnostics.push(diagnostic);
+                                && (nodeIn instanceof concepts_1.BatchAssignment || (nodeIn instanceof concepts_1.Assignment && nodeIn.left?.name))) {
+                                let jsCode = '';
+                                try {
+                                    jsCode = nodeIn.toJS();
+                                }
+                                catch (err) {
+                                    console.log(err);
+                                }
+                                if (jsCode.includes(`${node.name} = `)) {
+                                    used = true;
+                                    if (!nodeIn.tsErrorDetail) {
+                                        const diagnostic = {
+                                            node: nodeIn,
+                                            severity: 'error',
+                                            message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                        };
+                                        nodeIn.tsErrorDetail = diagnostic;
+                                        diagnostics.push(diagnostic);
+                                    }
                                 }
                             }
                         });
@@ -1195,31 +1875,43 @@ class NaslServer {
                         }
                     });
                 }
+                Object.keys(typeMap).forEach((item) => {
+                    if (typeMap[item].length > 1) {
+                        typeMap[item].forEach((nodeItem) => {
+                            const diagnostic = {
+                                node: nodeItem,
+                                severity: 'error',
+                                message: '匹配：重复添加类型',
+                                titleTip: '重复添加此项',
+                            };
+                            nodeItem.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        });
+                    }
+                });
+            }
+            else if (node.expression) {
+                const diagnostic = {
+                    node: node.expression,
+                    severity: 'error',
+                    message: '类型不匹配，传入类型：void',
+                };
+                node.expression.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
             }
-            Object.keys(typeMap).forEach((item) => {
-                if (typeMap[item].length > 1) {
-                    typeMap[item].forEach((nodeItem) => {
-                        const diagnostic = {
-                            node: nodeItem,
-                            severity: 'error',
-                            message: '匹配：重复添加类型',
-                            titleTip: '重复添加此项',
-                        };
-                        nodeItem.tsErrorDetail = diagnostic;
-                        diagnostics.push(diagnostic);
-                    });
-                }
-            });
         }
-        if (node instanceof concepts_1.MatchCase && node.getAncestor('Match')?.isExpression && node.body.length === 0 && !node.isDisabled) {
-            const diagnostic = {
-                node,
-                severity: 'error',
-                message: '匹配分支：表达式不能为空',
-                titleTip: '表达式不能为空',
-            };
-            node.tsErrorDetail = diagnostic;
-            diagnostics.push(diagnostic);
+        if (node instanceof concepts_1.MatchCase && node.getAncestor('Match')?.isExpression && node.body.length === 0) {
+            // 如果不是其他就标红
+            if ((node?.getIndexOfParent() !== (node.getAncestor('Match')?.cases?.length || 0) - 1)) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配分支：返回内容不能为空',
+                    titleTip: '返回内容不能为空',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
         }
         // 如果节点是match的patterns 里的
         if (node?.parentKey === 'patterns' && node.parentNode instanceof concepts_1.MatchCase) {
@@ -1284,22 +1976,87 @@ class NaslServer {
         }
         /**
          * 如果节点是内置函数
-         * 穷举在线上的情况，不在线上就void报错， calllogic 和 callinterface 因为原来有报错，所以就忽略掉
+         * 穷举在线上的情况，不在线上就void报错， callinterface 因为原来有报错，所以就忽略掉
          * && 他在父级中，不在body
          * && 也不再 if的线上
          * && 也不再 switch的线上consequent
          * && 也不再草稿区域
          * && 不在 parentNode.parentNode（只用处理两层的，超过两层上就需要报错，只用直接是参数位第一层的需要） 是 callfunction 和 callInfterfase中，因为这两本身有强制类型，内置函数或者一些带T的声明那种，
          * && 而且也没有类型，就说明在槽位里，就需要报错
+         *
+         * 如果是内置函数而且也不在线上
+         * 只有下面自己实现的函数才会报错
          */
-        if (node instanceof concepts_1.CallFunction && node.parentKey !== 'body' && node.parentKey !== 'alternate' && node.parentKey !== 'playground' && node.parentKey !== 'consequent' && node.parentNode?.parentNode?.concept !== 'CallLogic' && node.parentNode?.parentNode?.concept !== 'CallInterface' && !node.__TypeAnnotation) {
-            const diagnostic = {
-                node,
-                severity: 'error',
-                message: `类型不匹配，传入类型：void`,
-            };
-            node.tsErrorDetail = diagnostic;
-            diagnostics.push(diagnostic);
+        if (node instanceof concepts_1.CallFunction && node.parentKey !== 'body' && node.parentKey !== 'alternate' && node.parentKey !== 'playground' && node.parentKey !== 'consequent' && node.parentNode?.parentNode?.concept !== 'CallInterface' && !node.__TypeAnnotation) {
+            let showErr = false;
+            if (node.parentNode?.parentNode?.concept === 'CallLogic') {
+                // calllogic 中别的类型会强校验，但是内置函数，不会强制校验，下面这几个其实是走的内置函数的实现，所以需要手动增加一下校验
+                const { calleeNamespace, calleeName } = node.parentNode.parentNode;
+                if ((calleeNamespace === 'nasl.ui' || calleeNamespace === 'nasl.util') && (calleeName === 'showMessage' || calleeName === 'consoleLog' || calleeName === 'jsonSerialize' || calleeName === 'jsonDeserialize')) {
+                    showErr = true;
+                }
+            }
+            else {
+                showErr = true;
+            }
+            if (showErr) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: `类型不匹配，传入类型：void`,
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
+        // newMap key或者value没填都要有报错
+        if (node instanceof concepts_1.NewMap) {
+            // 如果一项没有key 或者没有 value 就报错
+            const findFlag = node.keys?.some((key, index) => !key || !node.values?.[index]);
+            if (findFlag) {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: `新建Map的key和value应该都必填`,
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+            }
+        }
+        // 赋值语句左右list 和 map等可以 必须都一样
+        if (node instanceof concepts_1.Assignment && !node.tsErrorDetail) {
+            const leftType = node.left?.__TypeAnnotation || {};
+            const rightType = node.right?.__TypeAnnotation || {};
+            // 如果左边节点是 泛型，而且 左边泛型的名字 和 右边一样， 而且是list 或者map 就强制报错
+            // 而且右边原来没有报错
+            if (leftType.typeKind === 'generic' && leftType.typeKind === rightType.typeKind && leftType.typeName === rightType.typeName && ['Map', 'List'].includes(leftType.typeName)) {
+                if (!(node.right.tsErrorDetail) && leftType.sortedTypeKey !== rightType.sortedTypeKey) {
+                    const excludeList = [
+                        'nasl.collection.List<nasl.core.String>',
+                        'nasl.collection.List<nasl.core.Email>',
+                        'nasl.collection.Map<nasl.core.String, nasl.core.String>',
+                        'nasl.collection.Map<nasl.core.String, nasl.core.Email>',
+                    ];
+                    const excludeList2 = [
+                        'nasl.collection.List<>',
+                        'nasl.collection.List<T>',
+                    ];
+                    // 先特殊处理等 类型合并后就可以去掉了
+                    if (excludeList.includes(leftType.sortedTypeKey) && excludeList.includes(rightType.sortedTypeKey)) {
+                        return null;
+                    }
+                    else if (excludeList2.includes(leftType.sortedTypeKey) || excludeList2.includes(rightType.sortedTypeKey)) {
+                        return null;
+                    }
+                    const diagnostic = {
+                        node: node.right,
+                        severity: 'error',
+                        message: `左右参数类型不一致！左边类型：${leftType.typeChineseTitle}，右边类型：${rightType.typeChineseTitle}。`,
+                    };
+                    node.right.tsErrorDetail = diagnostic;
+                    diagnostics.push(diagnostic);
+                }
+            }
         }
     }
     /* 接口导入查找 */
@@ -1367,8 +2124,13 @@ class NaslServer {
      */
     _resolveDiagnostic(diagnostic, fileNode, record) {
         // 拓展模块中的翻译先过滤掉，因为有错用户也不能修改
-        if (fileNode.module)
+        if (fileNode.module && !(fileNode instanceof concepts_1.ConfigProperty)) {
             return;
+        }
+        // 过滤掉java依赖库的报错
+        // if ('compilerInfoMap' in fileNode && (fileNode as any).compilerInfoMap?.java) {
+        //     return;
+        // }
         const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
             severity: diagnostic.category === 'error' ? 'error' : 'warning',
@@ -1420,9 +2182,27 @@ class NaslServer {
                 else {
                     // 没有节点 或者 行差比较小比已有的小就可以
                     // 一般出现在一大块上，多半是if for 等等没有参数
-                    if (!minRange || item.range.end.line - item.range.start.line < minRange.item.range.end.line - minRange.item.range.start.line) {
+                    if (!minRange) {
                         minRange = { node, item };
                     }
+                    else if ((0, translator_1.lsp2tspNumber)(item.range.start.line) === diagnostic.start.line && diagnostic.start.offset >= (0, translator_1.lsp2tspNumber)(item.range.start.character)) {
+                        // 如果当前遍历的内容的行和列都 小于之前的， 而且是有效的
+                        // 如果两个内容位置行数是一样的，就比较下找到内容的位置信息
+                        // 找到的内容的开始位置， 要大于申明内容开始的位置，要不就不包含在内了
+                        if (diagnostic.start.offset - item.range.start.character <= diagnostic.start.offset - minRange.item.range.start.character) {
+                            minRange = { node, item };
+                        }
+                        else {
+                            if (diagnostic.start.offset < (0, translator_1.lsp2tspNumber)(minRange.item.range.start.character)) {
+                                minRange = { node, item };
+                            }
+                        }
+                    }
+                    else if (item.range.end.line - item.range.start.line <= minRange.item.range.end.line - minRange.item.range.start.line) {
+                        if (minRange.item.range.start.line !== diagnostic.start.line) {
+                            minRange = { node, item };
+                        }
+                    }
                 }
             }
         }
@@ -1588,6 +2368,114 @@ class NaslServer {
                 refsList = [...methodRefs];
             }
         }
+        if (node instanceof concepts_1.Process) {
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__ProcessIdentification__';
+                let positions = [];
+                let pos = code.indexOf(prefix);
+                while (pos !== -1) {
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                }
+                positions.shift();
+                // 拿到标识下定义的const process = {...}
+                positions = positions.map((position) => code.indexOf('const', position + prefix.length));
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
+        if ((node instanceof concepts_1.Param || node instanceof concepts_1.Return) && node.parentNode instanceof concepts_1.Process) {
+            const { currentSource } = this.getCurrentSource(node.parentNode);
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__ProcessIdentification__';
+                const positions = [];
+                let pos = code.indexOf(prefix);
+                pos = code.indexOf(node.name, pos + prefix.length);
+                // pos === -1：两种情况：
+                // 1、找到最后一个节点了，继续找找不下去了。
+                // 2、创建、删除节点的时候也会找不到（本身这两种操作就不应该进到这个方法）
+                while (pos !== -1) {
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                    pos = pos === -1 ? pos : code.indexOf(node.name, pos + prefix.length);
+                }
+                positions.shift();
+                // 拿到标识下定义的参数名字
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
+        if (node instanceof concepts_1.ProcessElement) {
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__ProcessIdentification__';
+                let positions = [];
+                let pos = code.indexOf(prefix);
+                while (pos !== -1) {
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                }
+                // 拿到标识下定义的const process = {...}
+                positions = positions.map((position) => code.indexOf(`${node.name}:`, position + prefix.length));
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
+        if (node instanceof concepts_1.Return && node.parentNode instanceof concepts_1.ProcessElement) {
+            const { currentSource } = this.getCurrentSource(node.parentNode);
+            if (currentSource) {
+                const code = currentSource.code;
+                const prefix = '__ProcessIdentification__';
+                const positions = [];
+                let pos = code.indexOf(prefix);
+                // 需要再次定位到processelement对象上，避免process上存在同名参数
+                pos = code.indexOf(node.parentNode.name, pos + prefix.length);
+                pos = pos === -1 ? pos : code.indexOf(node.name, pos + prefix.length);
+                // pos === -1：两种情况：
+                // 1、找到最后一个节点了，继续找找不下去了。
+                // 2、创建、删除节点的时候也会找不到（本身这两种操作就不应该进到这个方法）
+                while (pos !== -1) {
+                    positions.push(pos);
+                    pos = code.indexOf(prefix, pos + prefix.length);
+                    // 需要再次定位到processelement对象上，避免process上存在同名参数
+                    pos = pos === -1 ? pos : code.indexOf(node.parentNode.name, pos + node.parentNode.name.length);
+                    pos = pos === -1 ? pos : code.indexOf(node.name, pos + prefix.length);
+                }
+                // 拿到标识下定义的参数名字
+                const promises = positions.map((item) => this.references({
+                    file: fileNode.getEmbeddedFilePath(),
+                    line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
+                    offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character + item),
+                }));
+                const results = await Promise.all(promises);
+                results.forEach((constRefs) => {
+                    refsList = [...refsList, ...constRefs.refs];
+                });
+            }
+        }
         // console.log(refsList, 'refsList');
         return refsList;
     }
@@ -1684,7 +2572,7 @@ class NaslServer {
                     // 因为要用下面的点位信息
                     const name = minRange.node.name;
                     // 如果name不改，那就是要改命名空间
-                    if (newValue === name) {
+                    if (node instanceof concepts_1.Frontend || newValue === name) {
                         const namespace = minRange.node.namespace;
                         // 先看下标位置
                         const lineText = record.lineText;
@@ -1807,6 +2695,24 @@ class NaslServer {
                         minRange.newValue = newTsNameSpace;
                     }
                 }
+                if (node instanceof concepts_1.Frontend && minRange.node instanceof concepts_1.Destination) {
+                    const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                    const tsName = minRange.node.tsName;
+                    const oldValue = tsCalleeNamespace + '.' + tsName;
+                    // 先看下标位置
+                    const lineText = record.lineText;
+                    const index = lineText.indexOf(oldValue);
+                    // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                    const start = record.start.offset - index - 1;
+                    const end = record.end.offset - index - 1;
+                    if (start <= tsCalleeNamespace.length) {
+                        // 新的完整的value
+                        let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                        minRange.setTypeMethods = 'setViewNamespace';
+                        newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
+                        minRange.newValue = newTsNameSpace;
+                    }
+                }
                 // 如果是事件修改
                 // 如果是view也需要加前缀
                 // logic 和 views名称修改 可能会触发bindEvent修改
@@ -2085,6 +2991,31 @@ class NaslServer {
         }
         return result;
     }
+    // 通过当前节点，查找被引用的节点
+    async nodeFindRefNodes(node) {
+        let refsList = await this._isHaveRef(node);
+        // 如果查找引用查到自己里面的引用不展示
+        refsList = refsList.filter((item) => 
+        // 自己引用自己的过滤掉
+        // 删除的时候过滤一把组件删除提示
+        // 展示组件自己屏蔽掉
+        !item.isDefinition && !item.lineText.includes(' = new nasl.ui.'));
+        // 最后返回的结果
+        const result = new Set();
+        try {
+            refsList.forEach((record) => {
+                const fileNode = this.file2NodeMap.get(record.file);
+                if (!fileNode)
+                    return;
+                const minRange = this._findMinRange(record, fileNode);
+                result.add(minRange.node);
+            });
+        }
+        catch (err) {
+            console.log(err);
+        }
+        return [...result];
+    }
     // 获取节点的上层渲染
     _getTreeMap(minRange, fileNode, resMap, nodeMap) {
         const minRangeNode = minRange.node;
@@ -2219,12 +3150,15 @@ class NaslServer {
         // 如果没有sourceMap,就继续向上找 ,或者到module结束
         // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
         // 如果当前节点是view就不要向上查找了
+        // 配置参数的ConfigProperty也不需要向上找
         while (!sourceMap
             && fileNode
             && !(fileNode.parentNode instanceof concepts_1.App)
             && !(fileNode.parentNode instanceof concepts_1.Module)
             && !(fileNode.parentNode instanceof concepts_1.DataSource)
-            && !(fileNode instanceof concepts_1.View)) {
+            && !(fileNode.parentNode instanceof concepts_1.Frontend)
+            && !(fileNode instanceof concepts_1.View)
+            && !(fileNode instanceof concepts_1.ConfigProperty)) {
             fileNode = fileNode.parentNode;
             sourceMap = fileNode?.sourceMap;
         }
@@ -2344,7 +3278,7 @@ class NaslServer {
         if (node instanceof concepts_1.Param) {
             // index在nasl foreach上有脏数据
             if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
-                return concepts_1.TypeAnnotation.createPrimitive('Integer');
+                return concepts_1.TypeAnnotation.createPrimitive('Long');
             }
         }
         if (node instanceof concepts_1.CallQueryComponent || node instanceof concepts_1.SqlQueryComponent || node instanceof concepts_1.OqlQueryComponent) {
@@ -2398,6 +3332,11 @@ class NaslServer {
                 types.set(node, node.typeAnnotation);
                 return;
             }
+            // 如果 入参不是虚拟节点的，就不去请求类型
+            // 只有虚拟节点的入参，才没有类型
+            if (node.concept === 'Param' && node.parentKey !== 'virtualParams') {
+                return;
+            }
             if (![
                 'Identifier',
                 'UnaryExpression',
@@ -2412,6 +3351,10 @@ class NaslServer {
                 'NewComposite',
                 'NewList',
                 'NewMap',
+                'OqlQueryComponent',
+                'QueryFieldExpression',
+                'QueryGroupByExpression',
+                'Param',
             ].includes(node.concept))
                 return;
             // 要去ls那边获取的
@@ -2421,6 +3364,7 @@ class NaslServer {
                 line: (0, translator_1.lsp2tspNumber)(item.range.start.line),
                 offset: (0, translator_1.lsp2tspNumber)(item.range.start.character),
             };
+            // 位置计算偏移
             if (node.concept === 'BinaryExpression'
                 || node.concept === 'CallLogic'
                 || node.concept === 'CallFunction'
@@ -2446,7 +3390,7 @@ class NaslServer {
                 }
                 fileDetail.offset = fileDetail.offset + indexOf;
             }
-            else if (node.concept === 'MemberExpression' || node.concept === 'Identifier') {
+            else if (node.concept === 'MemberExpression' || node.concept === 'Identifier' || node.concept === 'QueryFieldExpression' || node.concept === 'QueryGroupByExpression') {
                 if (item.code.includes('.')) {
                     const codeArr = item.code?.split('.');
                     const lastLen = codeArr?.[codeArr.length - 1]?.length;
@@ -2457,7 +3401,12 @@ class NaslServer {
             }
             else if (node.concept === 'Match') {
                 // 去查return 后面的返回值，变成函数调用
-                fileDetail.line = item.range.end.line - 1;
+                if (item.code?.endsWith(';\n')) {
+                    fileDetail.line = item.range.end.line - 1;
+                }
+                else {
+                    fileDetail.line = item.range.end.line;
+                }
                 const indexOf = item.code.indexOf('return __MatchExpressionFuntion');
                 let newCode = item.code.substring(0, indexOf);
                 newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
@@ -2470,11 +3419,14 @@ class NaslServer {
                 newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
                 fileDetail.offset = newCode.length + 'return '.length;
             }
+            else if (['OqlQueryComponent'].includes(node.concept)) {
+                fileDetail.offset += 10;
+            }
             args.push(fileDetail);
         });
-        console.time('请求');
+        // console.time('请求');
         const resultMap = (await this.getNaslNodeTypeFull(args)).response;
-        console.timeEnd('请求');
+        // console.timeEnd('请求');
         // console.log(resultMap);
         // const result = (await this.getNaslNodeQuickInfoFull(args)).response;
         // console.log(result);
@@ -2487,7 +3439,7 @@ class NaslServer {
             // console.log('方案2：', item?.[0]?.nodeType);
             const nodeTypeAnnotation = (0, formatTsUtils_1.type2TypeAnnotation)(item?.[0]?.nodeType);
             // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
-            types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
+            types.set(newQuickInfoNodes[index].node, Object.freeze(nodeTypeAnnotation));
             newQuickInfoNodes[index].node.__nodeType = Object.freeze(item?.[0]?.nodeType);
             // console.log('方案1：', displayString1);
         });
@@ -2507,8 +3459,8 @@ class NaslServer {
                 // 直接从最后一项的返回值取，有就有没有就没有
                 if (node.body?.length) {
                     const last = node.body[node.body.length - 1];
-                    if (last.__TypeAnnotation) {
-                        types.set(node, last.__TypeAnnotation);
+                    if (types.get(last)) {
+                        types.set(node, types.get(last));
                     }
                 }
             }
@@ -2519,11 +3471,24 @@ class NaslServer {
                 // 因为node可能是经过处理的TypeAnnotation
                 node.__isCorrectTypeAnnotation = true;
                 if (value) {
+                    if (node instanceof concepts_1.OqlQueryComponent) {
+                        // 自动推导情况
+                        const typeAnnotation = value;
+                        if (!node.typeAnnotation && typeAnnotation) {
+                            if (typeAnnotation.typeName === 'List' && typeAnnotation.typeKind === 'generic') {
+                                const typeArguments = typeAnnotation.typeArguments;
+                                if (typeArguments.length && typeArguments[0].isComplexType()) {
+                                    node.__TypeAnnotation = null;
+                                    return;
+                                }
+                            }
+                        }
+                    }
                     if (value instanceof concepts_1.TypeAnnotation) {
-                        node.__TypeAnnotation = Object.freeze(value);
+                        node.__TypeAnnotation = value;
                     }
                     else if (value.typeAnnotation) {
-                        node.__TypeAnnotation = Object.freeze(value.typeAnnotation);
+                        node.__TypeAnnotation = value.typeAnnotation;
                     }
                 }
                 else {
@@ -2533,7 +3498,7 @@ class NaslServer {
             }
             catch (err) {
                 if (globalThis.window) {
-                    console.log(err);
+                    // console.log(err);
                 }
             }
         });
@@ -2588,7 +3553,9 @@ class NaslServer {
     }
     // 全量标注并且返回json
     async getNaslAnnotatedJSON(app, releaseFlag) {
-        console.time('全量标注');
+        if (this.changeStackList?.length) {
+            throw new Error(`当前还有${this.changeStackList.length}个文件还在执行更新操作，请稍后再试！或刷新后重试！`);
+        }
         const nodes = [];
         this.file2NodeMap.forEach((fileNode, filePath) => {
             // 先不排除view，传递给后端的时候，去除views下的标注
@@ -2602,6 +3569,7 @@ class NaslServer {
                 });
             }
         });
+        console.time('全量标注');
         const typesMap = await this.getQuickInfoNodesTypeMap(nodes, true);
         // console.log(typesMap, 'typesMap')
         console.timeEnd('全量标注');
@@ -2613,24 +3581,6 @@ class NaslServer {
         }
         return json;
     }
-    // 加载全量nasl节点标注
-    async createdNaslAnnotatedJSON(app) {
-        // 全量标注
-        const nodes = [];
-        this.file2NodeMap.forEach((fileNode, filePath) => {
-            // 先不排除view，传递给后端的时候，去除views下的标注
-            if (!['Structure', 'DataSource', 'Entity', 'Enum', 'Role'].includes(fileNode.concept)) {
-                fileNode.sourceMap.forEach((item, node) => {
-                    nodes.push({
-                        filePath,
-                        node,
-                        item,
-                    });
-                });
-            }
-        });
-        await this.getQuickInfoNodesTypeMap(nodes, true);
-    }
     // 增量标注
     async IncrementalAnnotationJSON(records) {
         console.time('增量标注');
@@ -2672,7 +3622,7 @@ class NaslServer {
                 }
             }
             // 旧版本数据查询需要确认是匿名数据结构的 ListTotal 类型
-            if (node instanceof concepts_1.CallQueryComponent && node.ideVersion !== '2.11') {
+            if (node instanceof concepts_1.CallQueryComponent && !node.isAutoInfer()) {
                 const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
                 jsonNode.typeAnnotation = {
                     concept: 'TypeAnnotation',
@@ -2706,7 +3656,7 @@ class NaslServer {
                                 concept: 'TypeAnnotation',
                                 typeKind: 'primitive',
                                 typeNamespace: 'nasl.core',
-                                typeName: 'Integer',
+                                typeName: 'Long',
                                 typeArguments: null,
                                 inferred: null,
                             },
@@ -2720,7 +3670,7 @@ class NaslServer {
                 // index在nasl foreach上有脏数据
                 if (node.parentKey === 'index' && node.parentNode instanceof concepts_1.ForEachStatement) {
                     const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
-                    jsonNode.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Integer').toJSON();
+                    jsonNode.typeAnnotation = concepts_1.TypeAnnotation.createPrimitive('Long').toJSON();
                 }
             }
             if (node instanceof concepts_1.Match) {
@@ -2743,6 +3693,10 @@ class NaslServer {
                     jsonNode.typeAnnotation = value.toJSON();
                 }
             }
+            if (node instanceof concepts_1.NewComposite && node.typeAnnotation?.typeKind === 'anonymousStructure') {
+                const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
+                jsonNode.typeAnnotation = value.toJSON();
+            }
         });
     }
     /**
@@ -2752,7 +3706,7 @@ class NaslServer {
      */
     getArgumentTypeAnnotation(node, QuickInfoNodes, types) {
         // 直接复用内部expression的type类型
-        if (node.parentNode instanceof concepts_1.CallLogic && node.parentNode.calleeNamespace.includes('entities') && node.parentNode.calleeNamespace.includes('logics') && node.parentNode.calleeName === 'delete') {
+        if (node.parentNode instanceof concepts_1.CallLogic && node.parentNode.calleeNamespace?.includes('entities') && node.parentNode.calleeNamespace?.includes('logics') && node.parentNode.calleeName === 'delete') {
             const nodeType = node.parentNode?.__nodeType;
             if (nodeType && Array.isArray(nodeType.fnParams)) {
                 const index = node.parentNode.arguments.indexOf(node);
@@ -2770,7 +3724,7 @@ class NaslServer {
         const App = node.app;
         const parent = (node.parentNode);
         // 如果nasl包下的 ，很多声明都含有T啥的先用自己内部的
-        if (!parent.calleeNamespace || parent.calleeNamespace.startsWith('nasl')) {
+        if (!parent.calleeNamespace || parent.calleeNamespace?.startsWith('nasl')) {
             if (types.get(node.expression)) {
                 return {
                     typeAnnotation: types.get(node.expression),
@@ -2883,6 +3837,12 @@ class NaslServer {
         // 如果是要删除的内容，就是当前的file节点，要关闭当前文件，就把内容置为空
         if (fileNode === targetNode) {
             outputFiles = [{ file: filePath, fileContent: '' }];
+            // 去掉原来存储的当前节点的nasl内存的存储,和错误的存储
+            // 已经删除的就不用在去check错误了
+            // check就会去取类型啥的，没有必要
+            this.diagnosticManager.deleteOwn(fileNode.id);
+            // 删除文件同时删除ls存储nasl 的引用
+            this.file2NodeMap.delete(filePath);
         }
         else {
             // 如果是要删除logic一个小内容，要覆盖全部内容
@@ -2891,7 +3851,7 @@ class NaslServer {
         }
         // 更新文件之后
         await this.updateFiles({ outputFiles });
-        newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+        newRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
     }
     /**
      * 除去rename场景下的更新
@@ -2910,13 +3870,17 @@ class NaslServer {
             line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
             offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
         });
-        newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+        const files = new Set();
+        newRefs.refs.forEach((ref) => {
+            this.filesToCheck.add(ref.file);
+            files.add(ref.file);
+        });
         // 唤起建立连接弹框
         // 文件级别的建立连接采取提醒
         if (action === 'create' && targetNode.__init) {
             // 清除临时状态, 完成本次创建
             delete targetNode.__init;
-            if (fileNode === targetNode && filesToCheck.size > 1) {
+            if (fileNode === targetNode && files.size > 1) {
                 const confirmParms = {
                     actionType: 'createEstablishConnection',
                     node: fileNode,
@@ -2950,8 +3914,8 @@ class NaslServer {
                 line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
                 offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
             });
-            oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-            filesToCheck.delete(oldFilePath);
+            oldRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+            this.filesToCheck.delete(oldFilePath);
             // 更新文件之后
             await this.updateFiles({ outputFiles });
             // 查一下新函数名的依赖
@@ -2962,7 +3926,7 @@ class NaslServer {
             });
             const newRefFileList = new Set();
             newRefs.refs.forEach((ref) => {
-                filesToCheck.add(ref.file);
+                this.filesToCheck.add(ref.file);
                 newRefFileList.add(ref.file);
             });
             // 文件级别重命名，有依赖才唤起弹框
@@ -2989,7 +3953,7 @@ class NaslServer {
                 line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
                 offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
             });
-            newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
+            newRefs2.refs.forEach((ref) => this.filesToCheck.add(ref.file));
         }
         else {
             // 查一下当前属性依赖的文件
@@ -3004,7 +3968,7 @@ class NaslServer {
                     line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
                     offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
                 });
-                oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+                oldRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
                 // 更新文件之后
                 await this.updateFiles({ outputFiles });
                 const newRefs2 = await this.references({
@@ -3012,7 +3976,7 @@ class NaslServer {
                     line: (0, translator_1.lsp2tspNumber)(currentSource.range.start.line),
                     offset: (0, translator_1.lsp2tspNumber)(currentSource.range.start.character),
                 });
-                newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
+                newRefs2.refs.forEach((ref) => this.filesToCheck.add(ref.file));
             }
         }
     }
@@ -3027,6 +3991,31 @@ class NaslServer {
      */
     async incidentalAction(action, fileNode, targetNode, oldpath) {
         if ((action === 'create' || action === 'delete' || (action === 'update' && oldpath)) && fileNode === targetNode) {
+            //删除、更改、新增端
+            if (fileNode instanceof concepts_1.Frontend && (fileNode.views?.length || fileNode.variables?.length)) {
+                const fileNodeChildren = [...fileNode.views, ...fileNode.variables];
+                for (let i = 0; i < fileNodeChildren.length; i++) {
+                    const fileNodeItem = fileNodeChildren[i];
+                    const result = fileNodeItem.toEmbeddedTSFile();
+                    fileNodeItem.sourceMap = result.sourceMap;
+                    if (action === 'create') {
+                        await this.handleChange(fileNodeItem, fileNodeItem, result, action);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'delete') {
+                        await this.handleDelete(fileNodeItem, fileNodeItem, result);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    }
+                    else if (action === 'update' && oldpath) {
+                        const parentPath = oldpath.replace('.ts', '/');
+                        const foldName = fileNodeItem.concept === 'View' ? 'views' : 'variables';
+                        const currentOldPath = parentPath + foldName + '/' + fileNodeItem.name + '.ts';
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        await this.handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
+                    }
+                }
+            }
             // 删除或者新增页面
             if (fileNode instanceof concepts_1.View && fileNode.children?.length) {
                 const fileNodeChildren = fileNode.children;
@@ -3101,14 +4090,14 @@ class NaslServer {
         }
     }
     async receiveHandleChange($event) {
-        singleFileChangeIng = true;
+        this.singleFileChangeIng = true;
         // 行为
         const action = $event.action;
         const targetNode = $event.target;
         // 当前操作的文件节点
         const { fileNode } = this.getCurrentSource(targetNode);
         // 如果是导入模块就，就引入对应模块,先不处理module和Configuration，下面的内容会自动创建
-        if (!fileNode || fileNode instanceof concepts_1.Module || fileNode instanceof concepts_1.Configuration) {
+        if (!fileNode || fileNode instanceof concepts_1.Module || fileNode instanceof concepts_1.Configuration || fileNode instanceof concepts_1.Integration) {
             // module单独处理
             if (fileNode instanceof concepts_1.Module) {
                 await this.incidentalAction(action, fileNode, targetNode);
@@ -3148,20 +4137,20 @@ class NaslServer {
         return true;
     }
     changeFileNext() {
-        if (!singleFileChangeIng) {
+        if (!this.singleFileChangeIng) {
             const item = this.changeStackList.shift();
             this.receiveHandleChange(item).catch((err) => {
                 console.log(err, 'receiveHandleChangeErr');
             }).finally(async () => {
                 // 每一个文件与change接触就把状态置为false，让下一个进入
-                singleFileChangeIng = false;
+                this.singleFileChangeIng = false;
                 if (this.changeStackList.length) {
                     this.changeFileNext();
                 }
                 else {
-                    console.log(Array.from(filesToCheck));
-                    await this.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
-                    filesToCheck.clear();
+                    console.info(Array.from(this.filesToCheck));
+                    await this.getDiagnosticRecordsAndPushAll(Array.from(this.filesToCheck));
+                    this.filesToCheck.clear();
                 }
             });
         }