@lcap/nasl 1.0.1 → 1.0.2

package/src/server/getScope.ts

@@ -5,6 +5,7 @@ type wordScope = {
     Return?: string[]
     Variable?: string[]
     Constant?: string[]
+    Logic?: string[]
 }
 
 export function getLogicScopeWords(logic: Logic): wordScope {
@@ -13,6 +14,7 @@ export function getLogicScopeWords(logic: Logic): wordScope {
         Return: logic.returns.map((p) => p.name),
         Variable: logic.variables.map((p) => p.name),
         Constant: [],
+        Logic: []
     };
     return scope;
 }
@@ -23,6 +25,7 @@ export function getViewScopeWords(view: View): wordScope {
         Variable: view.variables.map((p) => p.name),
         Return: [],
         Constant: [],
+        Logic: view.logics.map(l => l.name),
     };
     return scope;
 }
@@ -34,6 +37,7 @@ export function getProcessScopeWords(process: Process): wordScope {
         Return: process.returns.map((p) => `${processName}.${p.name}`),
         Constant: process.constants.map((p) => `${processName}.${p.name}`),
         Variable: [],
+        Logic: []
     };
 
     process.elements.forEach((el) => {
@@ -57,6 +61,7 @@ export function combineScope(a: wordScope, b: wordScope) : wordScope {
         Return: [...a.Return, ...b.Return],
         Constant: [...a.Constant, ...b.Constant],
         Variable: [...a.Variable, ...b.Variable],
+        Logic: [...a.Logic, ...b.Logic],
     };
     return scope;
 }

package/src/server/index.ts

@@ -12,6 +12,7 @@ import {
     getSelectNextCompletionData,
 } from './getMemberIdentifier';
 import naslServer from './naslServer';
+import './extendBaseNode';
 
 const server: any = {
     ...naslServer,

package/src/server/naslServer.ts

@@ -23,6 +23,7 @@ import {
     QueryFromExpression,
     QueryJoinExpression,
     QueryFieldExpression,
+    QueryGroupByExpression,
     Identifier,
     CallLogic,
     EnumItem,
@@ -43,6 +44,7 @@ import {
     Namespace,
     Theme,
     Variable,
+    Assignee,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem, embeddedTSEmitter } from '../translator';
 import axios from '../service/storage';
@@ -51,6 +53,7 @@ import { EventPayload, invokeCommand, registerCommand } from '../common';
 import { DiagnosticRecord, Diagnostic, default as diagnosticManager } from '../manager/diagnostic';
 import formatUiTs from './createUiTs';
 import { primitiveTypeList } from '../concepts/basics/types/coreTypeList';
+import { traverse } from '../utils';
 
 const EmbeddedTSFileLineMap: { [name: string]: number } = {
     Entity: 3,
@@ -58,7 +61,7 @@ const EmbeddedTSFileLineMap: { [name: string]: number } = {
 // 要Check的文件
 const filesToCheck: Set<string> = new Set();
 
-interface FileNode extends BaseNode {
+export interface FileNode extends BaseNode {
     getEmbeddedFilePath(name?: string): string;
     toEmbeddedTSFile(): {
         code: string;
@@ -86,7 +89,7 @@ const messager = new Messager({
     },
 });
 
-interface reNameMinRange extends MinRange {
+interface RenameMinRange extends MinRange {
     newValue?: any;
     setTypeMethods?: string;
 }
@@ -377,28 +380,34 @@ const naslServer = {
              * fileNode
              */
             const { currentSource, fileNode } = naslServer.getCurrentSource(callFunction);
-            const quickInfo = await naslServer._getTypeQuickinfo({
-                file: (fileNode as FileNode).getEmbeddedFilePath(),
-                line: lsp2tspNumber(currentSource.range.start.line),
-                offset: lsp2tspNumber(currentSource.range.start.character) + `nasl.util.C`.length,
-            });
-            if (quickInfo.responseRequired) {
-                const displayString = quickInfo?.response?.displayString || '';
-                const typeList = naslServer.getDisplayString2Type(displayString);
-                let res: Array<TypeAnnotation> = [];
-                typeList.forEach((type) => {
-                    const typeAnnotation = primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
-                    if (typeAnnotation) {
-                        res.push(typeAnnotation);
-                    } else if (type === 'unknown' || type === 'never') {
-                        return null;
-                    }
+            try {
+                const quickInfo = await naslServer._getTypeQuickinfo({
+                    file: (fileNode as FileNode).getEmbeddedFilePath(),
+                    line: lsp2tspNumber(currentSource.range.start.line),
+                    offset: lsp2tspNumber(currentSource.range.start.character) + `nasl.util.C`.length,
                 });
-                if (!res.length) {
-                    return [];
-                } else {
-                    return [{ title: '基础类型', children: res }];
+                if (quickInfo.responseRequired) {
+                    const displayString = quickInfo?.response?.displayString || '';
+                    const typeList = naslServer.getDisplayString2Type(displayString);
+                    const res: Array<TypeAnnotation> = [];
+                    typeList.forEach((type) => {
+                        const typeAnnotation = primitiveTypeList.find((typeAnnotation) => typeAnnotation.typeName === type);
+                        if (typeAnnotation) {
+                            res.push(typeAnnotation);
+                        } else if (type === 'unknown' || type === 'never') {
+                            return null;
+                        }
+                    });
+                    if (!res.length) {
+                        return [];
+                    } else {
+                        return [{ title: '基础类型', children: res }];
+                    }
                 }
+            } catch (err) {
+                console.log(err);
+                // 如果有异常就先放开全部可选，兜底逻辑
+                return [];
             }
         } else {
             // 字符串 和 inter
@@ -477,6 +486,7 @@ const naslServer = {
             record.semanticDiagnostics = record.semanticDiagnostics
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode))
                 .filter((diag) => !!diag);
+            record.semanticDiagnostics.push(...this._attachDiagnostics(node));
 
             // 建议诊断
             // 实体下的建议不用展示，因为都是平台自己写的逻辑
@@ -499,6 +509,29 @@ const naslServer = {
         });
         return records;
     },
+    _attachDiagnostics(fileNode: BaseNode): Diagnostic[] {
+        const diagnostics: Diagnostic[] = [];
+        if (fileNode instanceof View) {
+            traverse((current) => {
+                if (current.node.tag) {
+                    current.node.bindAttrs.forEach((bindAttr) => {
+                        if ((bindAttr.model || bindAttr.sync)
+                            && bindAttr.expression && bindAttr.expression.concept !== 'Identifier' && bindAttr.expression.concept !== 'MemberExpression') {
+                            const diagnostic = {
+                                node: bindAttr,
+                                severity: 'error',
+                                message: '页面元素双向绑定：只允许绑定可赋值的变量和字段。',
+                            };
+                            bindAttr.tsErrorDetail = diagnostic;
+                            diagnostics.push(diagnostic);
+                        }
+                    });
+                }
+            }, { node: { children: fileNode.elements } as ViewElement });
+        }
+
+        return diagnostics;
+    },
     _resolveDiagnostic(diagnostic: tsProtocol.DiagnosticWithFileName, fileNode: FileNode): Diagnostic {
         const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
@@ -698,7 +731,7 @@ const naslServer = {
                 const fileNode = this.file2NodeMap.get(record.file);
                 if (!fileNode)
                     return null;
-                const minRange: reNameMinRange = this._findMinRange(record, fileNode as FileNode);
+                const minRange: RenameMinRange = this._findMinRange(record, fileNode as FileNode);
                 if (minRange) {
                     // 如果节点是TypeAnnotation类型,
                     // 很复杂，可能是多级嵌套结构
@@ -950,6 +983,9 @@ const naslServer = {
                     if (minRange.node instanceof QueryFieldExpression && node instanceof Entity) {
                         minRange.setTypeMethods = 'setEntityAsName';
                     }
+                    if (minRange.node instanceof QueryGroupByExpression && node instanceof Entity) {
+                        minRange.setTypeMethods = 'setEntityAsName';
+                    }
 
                     if ((minRange.node instanceof QueryFromExpression || minRange.node instanceof QueryJoinExpression) && node instanceof Entity) {
                         minRange.setTypeMethods = 'setEntityName';
@@ -957,6 +993,9 @@ const naslServer = {
                     if (minRange.node instanceof QueryFieldExpression && node instanceof EntityProperty) {
                         minRange.setTypeMethods = 'setPropertyName';
                     }
+                    if (minRange.node instanceof QueryGroupByExpression && node instanceof EntityProperty) {
+                        minRange.setTypeMethods = 'setPropertyName';
+                    }
 
                     // 如果跳转链接或者页面变量同一个param和TypeAnnotation 有两个过滤掉一个
                     if ((minRange.node instanceof Param || minRange.node instanceof Variable || minRange.node instanceof Return) && (node instanceof Entity || node instanceof Enum || node instanceof Structure)) {
@@ -965,6 +1004,9 @@ const naslServer = {
                     if (minRange.node instanceof Destination && (node instanceof Process || node instanceof ProcessElement)) {
                         return null;
                     }
+                    if (minRange.node instanceof Assignee && (node instanceof Process || node instanceof ProcessElement)) {
+                        return null;
+                    }
                     // 枚举修改枚举名，比较特殊
                     if (minRange.node instanceof EnumItem && node instanceof Enum) {
                         // 什么都不做，用来跳过修改
@@ -1026,18 +1068,9 @@ const naslServer = {
         console.log(result);
         return result;
     },
-    _addParamsPrepare(node: BaseNode, refsList: any[]) {
-        const App = node.rootNode;
-        const parantNode = node.parentNode as Logic | View;
-        // 收集修改
-        App.emit('collect:start', {
-            actionMsg: '增加逻辑参数',
-        });
-        node.create({
-            index: 0,
-            parentNode: parantNode,
-            parentKey: node.parentKey,
-        });
+    // 增加参数的副作用，用于更新logic和view
+    _addParamsEffect(refsList: any[], node: Param) {
+        const parantNode = node?.parentNode as Logic | View;
         refsList.forEach((record) => {
             const fileNode = this.file2NodeMap.get(record.file);
             if (!fileNode)
@@ -1054,19 +1087,37 @@ const naslServer = {
                 }
             }
         });
-        // 结束修改 ，批量操作
-        App.emit('collect:end');
+    },
+    _addParamsPrepare(node: BaseNode, refsList: any[], needAdd: boolean) {
+        if (needAdd) {
+            const App = node?.rootNode;
+            const parantNode = node?.parentNode as Logic | View;
+            // 收集修改
+            App.emit('collect:start', {
+                actionMsg: '增加逻辑参数',
+            });
+            node.create({
+                index: 0,
+                parentNode: parantNode,
+                parentKey: node.parentKey,
+            });
+            naslServer._addParamsEffect(refsList, (node) as Param);
+            // 结束修改 ，批量操作
+            App.emit('collect:end');
+            return node;
+        }
+        naslServer._addParamsEffect(refsList, (node) as Param);
+        return node;
     },
     // 查找引用
     async findReferences(node: BaseNode) {
         let refsList = await naslServer._isHaveRef(node);
         // 如果查找引用查到自己里面的引用不展示
-        refsList = refsList.filter((item) => {
+        refsList = refsList.filter((item) =>
             // 自己引用自己的过滤掉
             // 删除的时候过滤一把组件删除提示
             // 展示组件自己屏蔽掉
-            return !item.isDefinition && !(item.lineText.includes(' = new nasl.ui.'));
-        });
+            !item.isDefinition && !(item.lineText.includes(' = new nasl.ui.')));
         // 最后返回的结果
         let result = new Map();
         // 树的构造，key： 一个file的node， 值是 [[logic, params],[logic, returns]]
@@ -1098,14 +1149,15 @@ const naslServer = {
     // 获取节点的上层渲染
     _getTreeMap(minRange: MinRange, fileNode: BaseNode, resMap: Map<BaseNode, Array<Array<QuoteNode>>>, nodeMap: Map<BaseNode, QuoteNode>) {
         const minRangeNode = minRange.node;
-        let parantNode = minRangeNode;
+        let currentNode = minRangeNode;
+        let parantNode = currentNode.parentNode;
         // 顺序队列
         const queue: any[] = [];
         // 先插入自己,如果没有在往上找,
         // 一直到file节点的父级
         while (!(parantNode instanceof App)) {
             // 找到上一级 在map对象中构造出他的子集
-            const currentNode = parantNode;
+            currentNode = parantNode;
             parantNode = parantNode.parentNode;
             // 如果第一次就塞入子集和父节点，以后就只用父节点了
             // 因为部分节点没有name，先过滤掉
@@ -1153,11 +1205,11 @@ const naslServer = {
         }
 
         // 一个logic 或者 view可能会有多个顺序队列
-        if (resMap.get(fileNode)) {
+        if (resMap.get(currentNode)) {
             // 是否展示两个内容全等，但是两个queue的node可能不一样，但是只需要展示一个
-            resMap.get(fileNode).push(queue);
+            resMap.get(currentNode).push(queue);
         } else {
-            resMap.set(fileNode, [queue]);
+            resMap.set(currentNode, [queue]);
         }
     },
     handleTreeMap(resMap: Map<BaseNode, Array<Array<QuoteNode>>>) {
@@ -1297,313 +1349,6 @@ async function handleDelete(fileNode: BaseNode, targetNode: BaseNode, result: Re
 
     newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
 }
-BaseNode.prototype.findReadOnlyLogicUsage = function () {
-    let targetNode;
-
-    if (this.parentNode.concept === 'Namespace' || this.parentNode.parentNode.concept === 'Namespace') {
-        const sourceMap = this.parentNode.concept === 'Namespace' ? this.parentNode.parentNode.sourceMap : this.parentNode.parentNode.parentNode.sourceMap;
-        for (const item of sourceMap) {
-            const logic = item[0] as Logic;
-            if (this.concept === 'Logic') {
-                if (logic instanceof Logic)
-                    if (logic.calleewholeKey === (this as Logic).calleewholeKey) {
-                        targetNode = logic;
-                        break;
-                    }
-            } else {
-                if (logic instanceof Logic)
-                    if (logic.calleewholeKey === (this.parentNode as Logic).calleewholeKey) {
-                        targetNode = logic;
-                        break;
-                    }
-            }
-        }
-    } else if (this.parentNode.concept === 'Module') {
-        // 父级是模块的还是用它本身去查找引用
-        targetNode = this;
-    } else {
-        const sourceMap = this.parentNode.sourceMap;
-        for (const item of sourceMap) {
-            const logic = item[0] as Logic;
-            if (logic.getNamespace && logic.getNamespace() === (this as Logic).getNamespace()) {
-                targetNode = logic;
-                break;
-            }
-        }
-    }
-
-    try {
-        return naslServer.findReferences(targetNode);
-    } catch (err) {
-        console.log(err);
-    }
-};
-// 查找引用
-BaseNode.prototype.findUsage = function findUsage() {
-    try {
-        return naslServer.findReferences(this);
-    } catch (err) {
-        console.log(err);
-    }
-};
-BaseNode.prototype.changeName = async function changeName(newValue: string, updateAll: boolean = false) {
-    console.log(newValue);
-    console.log(this);
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const refsList = await naslServer._isHaveRef(this);
-        // 是不是有引用有的话，就返回
-        /**
-         * @param this 当前重命名的节点
-         * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
-         * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
-         * @returns 找到的引用
-         */
-        const res = naslServer._renamePrepare(this, refsList, newValue);
-        if (res.length <= 1) {
-            (this as SetNameNode).setName(newValue);
-        } else {
-            const callback = (value: boolean) => {
-                if (value) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '重命名并更新引用',
-                    });
-                    res.forEach((item) => {
-                        const itemNode = item.node as SetNameNode;
-                        if (item.newValue) {
-                            // 如果有指定的修改方法，就用那个，没有就修改名字
-                            item.setTypeMethods ? itemNode[item.setTypeMethods](item.newValue) : itemNode.setName?.(item.newValue);
-                        } else {
-                            item.setTypeMethods ? itemNode[item.setTypeMethods](newValue) : itemNode.setName?.(newValue);
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                } else {
-                    (this as SetNameNode).setName(newValue);
-                }
-            };
-            const confirmParms = {
-                actionType: 'rename',
-                node: this,
-                newValue,
-            };
-            /**
-             * nasl和vue的通信，回退，要触发vue的watch。
-             * 因为如果没修改的话nasl不会修改view，就不会通知到页面改成旧值
-             * 先修改之
-             */
-            const closeCallBack = () => {
-                if (this.concept === 'EnumItem') {
-                    const oldValue = (this as EnumItem).value;
-                    (this as EnumItem).value = oldValue + ' ';
-                    setTimeout(() => {
-                        (this as EnumItem).value = oldValue;
-                    }, 0);
-                } else {
-                    const oldValue = this.name;
-                    this.name = oldValue + ' ';
-                    setTimeout(() => {
-                        this.name = oldValue;
-                    }, 0);
-                }
-            };
-            updateAll ? callback(true) : invokeCommand('tsConfirm.open', confirmParms, callback, closeCallBack);
-
-            return;
-        }
-    } catch (err) {
-        console.log(err);
-    }
-};
-
-/**
- * 准备删除
- */
-BaseNode.prototype.prepareDelete = async function prepareDelete() {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const node = this;
-        let refsList = await naslServer._isHaveRef(node);
-        // 删除的时候过滤一把组件删除提示
-        refsList = refsList.filter((item) => {
-            // 因为ui组件本身会多渲染一次,就先过滤一个 
-            return !(item.lineText.includes(': nasl.ui.'));
-        });
-        // 删除参数单独处理
-        if (node instanceof Param) {
-            const methodRefs: tsProtocol.ReferencesResponseItem[] = [];
-            refsList.forEach((item) => {
-                // 入参查找引用,查到logic 和自己,内容完全一样,就保留一个
-                const find = methodRefs.find((findItem) => item.lineText === findItem.lineText);
-                if (!find) {
-                    methodRefs.push(item);
-                }
-            });
-            refsList = methodRefs;
-        }
-
-        // delete的弹框展示
-        const confirmParms = {
-            actionType: 'delete',
-            tipFlag: false,
-            node,
-            icon: 'warning',
-        };
-        let callback = null;
-        if (refsList.length <= 1) {
-            // 页面组件直接删除然后return
-            if (node instanceof ViewElement) {
-                this.delete();
-                return;
-            }
-            callback = () => {
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof Structure || node instanceof Interface) {
-                    (this as any).deleteLogincAndModule();
-                } else {
-                    this.delete();
-                }
-            };
-        } else {
-            // 如果有依赖就有一个查找引用提示
-            confirmParms.tipFlag = true;
-            const node = this;
-
-            // 删除页面或者流程
-            if (node instanceof View || node instanceof Process) {
-                /**
-                 * 查找这个页面是不是有依赖
-                 */
-                let viewPath = (this as FileNode).getEmbeddedFilePath();
-                viewPath = viewPath.slice(0, viewPath.length - 3);
-                const find = refsList.find((record) => !record.file.includes(viewPath));
-                // 如果没有别的文件的依赖，就直接delete
-                if (!find) {
-                    this.delete();
-                    return;
-                }
-            }
-            callback = () => {
-                // removeParam
-                // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
-                if (node instanceof Param) {
-                    const App = this.rootNode;
-                    const parentNode = this.parentNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除参数',
-                    });
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof CallLogic) {
-                                minRange.node.setCalleeArgName(parentNode as Logic);
-                            }
-                            if (minRange.node instanceof Destination) {
-                                minRange.node.setViewArgument(parentNode as View);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除logic节点，如果有对应的interface要一起删除
-                if (node instanceof Logic) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除逻辑并删除导出的接口',
-                    });
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof Interface) {
-                                minRange.node.delete();
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-                // 删除权限节点
-                if (node instanceof Role) {
-                    const App = this.rootNode;
-                    // 收集修改
-                    App.emit('collect:start', {
-                        actionMsg: '删除权限',
-                    });
-                    this.delete();
-                    refsList.forEach((record) => {
-                        const fileNode = naslServer.file2NodeMap.get(record.file);
-                        if (!fileNode)
-                            return null;
-                        const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode);
-                        if (minRange) {
-                            if (minRange.node instanceof View || minRange.node instanceof ViewElement) {
-                                // oldName旧的节点存的值
-                                // newValue用户输入值
-                                // node.bindRoles 存的
-                                const str = minRange.node.bindRoles.toString().replace(this.name, '');
-                                const newBindRoles = str.split(',').filter((item) => !!item);
-                                minRange.node.setBindRoles(newBindRoles);
-                            }
-                        }
-                    });
-                    // 结束修改 ，批量操作
-                    App.emit('collect:end');
-                    return;
-                }
-
-                // 删除页面或者流程,如果上一步没有return 就说明他是有别的引用的，会有引用弹框
-                if (node instanceof View || node instanceof Process) {
-                    this.delete();
-                }
-                // 其余的都直接调用删除
-                // Structure 和 Interface是内部有delete方法
-                if (node instanceof Structure || node instanceof Interface) {
-                    (this as any).deleteLogincAndModule();
-                } else {
-                    this.delete();
-                }
-            };
-        }
-        invokeCommand('tsConfirm.open', confirmParms, callback);
-    } catch (err) {
-        console.log(err);
-    }
-};
-
-/**
- * 如果添加需要触发查找引用并且在之后，对内容产生影响
- */
-BaseNode.prototype.addParamsPrepare = async function addParamsPrepare() {
-    try {
-        /**
-         * 查找这个节点是不是有依赖
-         */
-        const refsList = await naslServer._isHaveRef(this);
-        return naslServer._addParamsPrepare(this, refsList);
-    } catch (err) {
-        console.log(err);
-    }
-};
 
 /**
  * 除去rename场景下的更新
@@ -1750,7 +1495,7 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
                     await handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
                     await incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
                 }
-            };
+            }
         }
         // 删除或新增模块
         // 需要把下面的哦内容全部都更新一遍
@@ -1766,7 +1511,7 @@ async function incidentalAction(action: string, fileNode: BaseNode, targetNode:
                 } else {
                     await handleDelete(node, node, result);
                 }
-            };
+            }
 
             // 删除模块通知更新列表
             if (action === 'delete') {
@@ -1841,7 +1586,7 @@ embeddedTSEmitter.on('change', ($event: EventPayload) => {
     // 异步状态机,一个完成了在执行下一个
     function next() {
         const item = stackList.shift();
-        receiveHandleChange(item).then(async() => {
+        receiveHandleChange(item).then(async () => {
             if (stackList.length) {
                 next();
             } else {

package/src/server/translator.ts

@@ -401,7 +401,9 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
             // 变量type的报错放到内部
             node = node.parentNode;
             let str = tsErrorDetail.message;
-            str = (node as any).constructor.nodeTitle + '：' + str;
+            if (node) {
+                str = (node as any).constructor.nodeTitle + '：' + str;
+            }
             tsErrorDetail.message = str;
         }
     }