@lcap/nasl 2.18.0-beta.3 → 2.18.0-beta.5

package/src/concepts/Variable__.ts

@@ -291,7 +291,7 @@ export class Variable extends BaseNode {
         return code;
     }
     isEnum() {
-        return this.typeAnnotation?.typeNamespace.endsWith('.enums');
+        return this.typeAnnotation?.typeNamespace?.endsWith('.enums');
     }
     getNamespace() {
         if (this.parentNode && (this.parentNode as Namespace).getNamespace) {

package/src/concepts/ViewElement__.ts

@@ -1071,7 +1071,7 @@ export class ViewElement extends BaseNode {
     }
 
 
-
+    
 
     /**
     * 删除元素绑定属性

package/src/concepts/View__.ts

@@ -2106,14 +2106,14 @@ export class View extends BaseNode {
         // 调用接口，参数替换成 null
         if (rightNode instanceof CallInterface) {
             const { _interface } = rightNode.getModuleInterface();
-            return `${rightNode.tsCalleeKey}(${_interface.params.map(() => 'null').join(',')})`;
+            return _interface ? `${rightNode.tsCalleeKey}(${_interface.params.map(() => 'null').join(',')})` : null;
         }
 
         // 调用全局逻辑，参数替换成 null
         if (rightNode instanceof CallLogic && rightNode.calleeNamespace === 'app.logics') {
             const calleeName = rightNode?.calleeName;
             const calleeLogic = this.app.logics.find((l) => l.name === calleeName);
-            return `app.logics.${calleeName}(${calleeLogic.params.map(() => 'null').join(',')})`;
+            return calleeLogic ? `app.logics.${calleeName}(${calleeLogic.params.map(() => 'null').join(',')})` : null;
         }
 
         // view 局部变量，申明提升前增加判断，使用 logic 内的 result 直接替换成对应 logic，logic 内部变量替换成 null

package/src/generator/genReleaseBody.ts

@@ -59,7 +59,7 @@ export async function genReleaseBody(app: App, {
     const jsonString = JSON.stringify(NaslAnnotatedJSON);
 
     // 打印传给服务端的nasl,为了服务端排查问题方便
-    // console.warn(NaslAnnotatedJSON, '标注后的nasl');
+    console.log(NaslAnnotatedJSON, '标注后的nasl');
     files.push({ name: 'nasl-annotated.json', content: jsonString });
 
     body.files = files;

package/src/server/naslServer.ts

@@ -614,6 +614,48 @@ export class NaslServer {
         }
         return '';
     }
+    async getDataSchemaStructureOrTypeAnnotation(node: ViewElement) {
+        if (!(node instanceof ViewElement)) return;
+
+        const { currentSource, fileNode } = this.getCurrentSource(node);
+        const quickInfo = await this._getTypeQuickinfo({
+            file: (fileNode as FileNode).getEmbeddedFilePath(),
+            line: lsp2tspNumber(currentSource.range.start.line),
+            offset: lsp2tspNumber(currentSource.range.start.character) + `new nasl.ui.`.length,
+        });
+        if (quickInfo.responseRequired) {
+            const displayString = quickInfo?.response?.displayString || '';
+            const flag = displayString.includes('<') && displayString.includes('>');
+            if(!flag) return;
+
+            const types = /\<([^()]+)\>/g.exec(displayString);
+            let typeStr = types && types[1];
+            const app = node.app;
+            if (typeStr.includes('__name: "AStructure_')) {
+                const properties: StructureProperty[] = [];
+                typeStr
+                    .replace(/([^:\s]+):\s+([^;]+);/g, ($1, name, typeKey) => {
+                        if(name === '__name') return;
+
+                        typeKey = `app.${typeKey}`;
+                        const keys = typeKey.split('.');
+                        const typeName = keys.pop();
+                        const typeNamespace = keys.join('.');
+                        properties.push(StructureProperty.from({
+                            name,
+                            typeAnnotation: TypeAnnotation.from({
+                                typeKind: 'reference',
+                                typeName,
+                                typeNamespace,
+                            })
+                        }))
+                        return '';
+                    });
+                return TypeAnnotation.createTypeAnonymousStructure(properties);
+            } else if(typeStr.startsWith('structures'))
+                return app.findNodeByCompleteName(`app.${typeStr}`);
+        }
+    }
 
     /**
      * ts的 quickInfo方法，查询指定位置的详情
@@ -997,40 +1039,37 @@ export class NaslServer {
                                 const jsCode = nodeIn.toJS();
                                 if (!jsCode.includes(`${node.name} = `))
                                     return;
-                                // 逻辑内局部变量、输出参数、输入参数过滤
-                                if (nodeIn.logic?.variables.find((lVar) => jsCode.includes(`${lVar.name} = `))
-                                    || nodeIn.logic?.returns.find((lRet) => jsCode.includes(`${lRet.name} = `))
-                                    || nodeIn.logic?.params.find((lPar) => jsCode.includes(`${lPar.name} = `))
-                                    || nodeIn.logic?.virtualParams.find((vParam) => jsCode.includes(`${vParam.name} = `)))
-                                    return;
-                                if (node instanceof Variable
-                                    && node.parentNode instanceof View
-                                    && (nodeIn.logic?.params.find((param) => jsCode.includes(param.name))
-                                        || nodeIn.logic?.virtualParams.find((vParam) => jsCode.includes(vParam.name))
-                                        || nodeIn.logic?.variables.find((variable) => jsCode.includes(variable.name)))) {
+                                // 页面局部变量
+                                if (node instanceof Variable && node.parentNode instanceof View) {
+                                    // 跟页面局部变量无关的赋值过滤
+                                    if (!jsCode.includes(`this.${node.name} = `))
+                                        return;
                                     // 直接赋值 logic 内局部变量、输入参数直接提示系统无法推断类型
-                                    if (!nodeIn.tsErrorDetail) {
-                                        const diagnostic = {
-                                            node: nodeIn,
-                                            severity: 'error',
-                                            message: `页面${nodeTypeName} ${node.name} 赋值页面逻辑内局部变量或输入参数时，系统无法推导类型。`,
-                                        };
-                                        nodeIn.tsErrorDetail = diagnostic;
-                                        diagnostics.push(diagnostic);
-                                    }
-                                    msg = '系统无法推断类型。';
-                                } else {
-                                    if (!nodeIn.tsErrorDetail) {
-                                        const diagnostic = {
-                                            node: nodeIn,
-                                            severity: 'error',
-                                            message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
-                                        };
-                                        nodeIn.tsErrorDetail = diagnostic;
-                                        diagnostics.push(diagnostic);
+                                    if (nodeIn.logic?.params.find((param) => jsCode.includes(param.name))
+                                        || nodeIn.logic?.virtualParams.find((vParam) => jsCode.includes(vParam.name))
+                                        || nodeIn.logic?.variables.find((variable) => jsCode.includes(variable.name))) {
+                                        if (!nodeIn.tsErrorDetail) {
+                                            const diagnostic = {
+                                                node: nodeIn,
+                                                severity: 'error',
+                                                message: `页面${nodeTypeName} ${node.name} 赋值页面逻辑内局部变量或输入参数时，系统无法推导类型。`,
+                                            };
+                                            nodeIn.tsErrorDetail = diagnostic;
+                                            diagnostics.push(diagnostic);
+                                        }
+                                        msg = '系统无法推断类型。';
                                     }
-                                    msg = '必须赋值有返回值的内容。';
                                 }
+                                if (!nodeIn.tsErrorDetail) {
+                                    const diagnostic = {
+                                        node: nodeIn,
+                                        severity: 'error',
+                                        message: `${nodeIn.label}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                                    };
+                                    nodeIn.tsErrorDetail = diagnostic;
+                                    diagnostics.push(diagnostic);
+                                }
+                                msg = '必须赋值有返回值的内容。';
                             }
                         });
                         if (!msg)
@@ -2330,7 +2369,6 @@ export class NaslServer {
             const nodeTypeAnnotation = this.getCurrentNodeKnownTypeAnnotation(node);
             if (nodeTypeAnnotation) {
                 types.set(node, nodeTypeAnnotation);
-                node.__TypeAnnotation = nodeTypeAnnotation;
                 return;
             }
             // 要通过自己或者依赖关系拿的，二次遍历
@@ -2344,8 +2382,8 @@ export class NaslServer {
             if ([
                 'Return',
                 'Variable',
-            ].includes(node.concept) && (node as Return | Variable).typeAnnotation) {
-                node.__TypeAnnotation = (node as Return | Variable).typeAnnotation;
+            ].includes(node.concept) && (node as Variable).typeAnnotation) {
+                types.set(node, (node as Variable).typeAnnotation);
                 return;
             }
             if (![
@@ -2408,7 +2446,9 @@ export class NaslServer {
             }
             args.push(fileDetail);
         });
+        console.time('请求')
         const resultMap: any = (await this.getNaslNodeTypeFull(args)).response;
+        console.timeEnd('请求')
 
         // console.log(resultMap);
 
@@ -2424,8 +2464,7 @@ export class NaslServer {
             const nodeTypeAnnotation = type2TypeAnnotation(item?.[0]?.nodeType);
             // console.log(newQuickInfoNodes[index].node, nodeTypeAnnotation, nodeTypeAnnotation?.typeKey);
             types.set(newQuickInfoNodes[index].node, nodeTypeAnnotation);
-            newQuickInfoNodes[index].node.__TypeAnnotation = nodeTypeAnnotation;
-            (newQuickInfoNodes[index].node as any).__nodeType = item?.[0]?.nodeType;
+            (newQuickInfoNodes[index].node as any).__nodeType = Object.freeze(item?.[0]?.nodeType);
 
             // console.log('方案1：', displayString1);
         });
@@ -2433,13 +2472,11 @@ export class NaslServer {
             if (node instanceof Assignment) {
                 if (!types.get(node.left)) {
                     types.set(node.left, types.get(node.right));
-                    node.left.__TypeAnnotation = (types.get(node.right) as TypeAnnotation);
                 }
             } else if (node instanceof Argument) {
                 // 如果Argument，但是没可以用的类型，就用原来logic的参数类型
                 const argType = this.getArgumentTypeAnnotation(node, newQuickInfoNodes, (types as any));
                 types.set(node, argType);
-                node.__TypeAnnotation = argType.typeAnnotation;
             } else if (node instanceof MatchCase) {
                 // matchCase的类型
                 // 直接从最后一项的返回值取，有就有没有就没有
@@ -2447,15 +2484,26 @@ export class NaslServer {
                     const last = node.body[node.body.length - 1];
                     if (last.__TypeAnnotation) {
                         types.set(node, last.__TypeAnnotation);
-                        node.__TypeAnnotation = last.__TypeAnnotation;
                     }
                 }
             }
         });
 
-        // 重置类型状态
+        // 重置类型状态, 并且赋值
         types.forEach((value, node) => {
-            node.__isCorrectTypeAnnotation = true;
+            try {
+                // 因为node可能是经过处理的TypeAnnotation
+                node.__isCorrectTypeAnnotation = true;
+                if (value) {
+                    if (value instanceof TypeAnnotation) {
+                        node.__TypeAnnotation = (Object.freeze(value) as TypeAnnotation);
+                    } else if (value.typeAnnotation) {
+                        node.__TypeAnnotation = (Object.freeze(value.typeAnnotation) as TypeAnnotation);
+                    }
+                }
+            } catch (err) {
+                console.log(err);
+            }
         });
         // newQuickInfoNodes.forEach((itemDetail, index) => {
         //     const { node, filePath } = itemDetail;
@@ -2561,6 +2609,7 @@ export class NaslServer {
 
     // 增量标注
     async IncrementalAnnotationJSON(records: DiagnosticRecord[]) {
+        console.time('增量标注');
         const nodes: QuickInfoNodes = [];
         records.forEach((record) => {
             const fileNode = this.file2NodeMap.get(record.filePath);
@@ -2580,6 +2629,7 @@ export class NaslServer {
         });
 
         await this.getQuickInfoNodesTypeMap(nodes);
+        console.timeEnd('增量标注');
     }
 
     annotationToJson(typesMap: Map<BaseNode, TypeAnnotation | {

package/src/templator/genQueryComponent.ts

@@ -1,5 +1,5 @@
 import * as utils from '../utils';
-import { App, Module, Namespace, Entity, Structure, QueryJoinExpression, CallQueryComponent, StructureProperty, DataSource } from '../concepts';
+import { App, Module, Namespace, Entity, Structure, QueryJoinExpression, CallQueryComponent, StructureProperty, DataSource, TypeAnnotation } from '../concepts';
 import { NameGroup, NaslCoreTypeAnnotation, NaslCollectionTypeAnnotation, NaslTypeAnnotation, NaslQueryExpression, NaslLogicItem, NaslNode } from './utils';
 
 export function genQueryStructure(allEntities: Array<Entity>, nameGroup: NameGroup) {
@@ -205,7 +205,7 @@ export function genQueryLogic(allEntities: Array<Entity>, nameGroup: NameGroup,
     return logic;
 }
 
-export async function joinEntity(callQueryComponent: CallQueryComponent, entity: Entity, recordStructure: Structure) {
+export async function joinEntity(callQueryComponent: CallQueryComponent, entity: Entity, recordStructure: Structure | TypeAnnotation) {
     const dataSource = entity.parentNode as DataSource;
     const from = callQueryComponent.from;
     let joinInfo;
@@ -276,7 +276,12 @@ export async function joinEntity(callQueryComponent: CallQueryComponent, entity:
             typeName: entity.name,
         }),
     }), recordStructure, 'properties');
-    recordStructure.addProperty(structureProperty);
+    
+    if(recordStructure instanceof Structure)
+        recordStructure.addProperty(structureProperty);
+    else if(recordStructure instanceof TypeAnnotation)
+        recordStructure.properties.push(structureProperty);
+
     const newJoinPartLogicItem = QueryJoinExpression.from(queryJoinExpression, callQueryComponent, 'joinParts');
     from.addJoinPart(newJoinPartLogicItem);
     callQueryComponent.saveStructure();

package/ts-worker/lib/cancellationToken.js

@@ -0,0 +1,67 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+"use strict";
+var fs = require("fs");
+function pipeExists(name) {
+    return fs.existsSync(name);
+}
+function createCancellationToken(args) {
+    var cancellationPipeName;
+    for (var i = 0; i < args.length - 1; i++) {
+        if (args[i] === "--cancellationPipeName") {
+            cancellationPipeName = args[i + 1];
+            break;
+        }
+    }
+    if (!cancellationPipeName) {
+        return {
+            isCancellationRequested: function () { return false; },
+            setRequest: function (_requestId) { return void 0; },
+            resetRequest: function (_requestId) { return void 0; }
+        };
+    }
+    if (cancellationPipeName.charAt(cancellationPipeName.length - 1) === "*") {
+        var namePrefix_1 = cancellationPipeName.slice(0, -1);
+        if (namePrefix_1.length === 0 || namePrefix_1.indexOf("*") >= 0) {
+            throw new Error("Invalid name for template cancellation pipe: it should have length greater than 2 characters and contain only one '*'.");
+        }
+        var perRequestPipeName_1;
+        var currentRequestId_1;
+        return {
+            isCancellationRequested: function () { return perRequestPipeName_1 !== undefined && pipeExists(perRequestPipeName_1); },
+            setRequest: function (requestId) {
+                currentRequestId_1 = requestId;
+                perRequestPipeName_1 = namePrefix_1 + requestId;
+            },
+            resetRequest: function (requestId) {
+                if (currentRequestId_1 !== requestId) {
+                    throw new Error("Mismatched request id, expected ".concat(currentRequestId_1, ", actual ").concat(requestId));
+                }
+                perRequestPipeName_1 = undefined;
+            }
+        };
+    }
+    else {
+        return {
+            isCancellationRequested: function () { return pipeExists(cancellationPipeName); },
+            setRequest: function (_requestId) { return void 0; },
+            resetRequest: function (_requestId) { return void 0; }
+        };
+    }
+}
+module.exports = createCancellationToken;
+//# sourceMappingURL=cancellationToken.js.map

package/ts-worker/lib/harness.js

@@ -1,4 +1,4 @@
-const ts = require('typescript/lib/tsserver');
+const ts = require('../lib/tsserver');
 
 'use strict';
 const __generator = (this && this.__generator) || function (thisArg, body) {

package/ts-worker/src/start.js

@@ -1,4 +1,4 @@
-const ts = require('typescript/lib/tsserver');
+const ts = require('../lib/tsserver');
 require('../lib/harness');
 
 const tsconfig = require('../../sandbox/tsconfig.json');

package/ts-worker/webpack.config.js

@@ -27,10 +27,12 @@ module.exports = {
         // DISABLE Webpack's built-in process and Buffer polyfills!
         fallback: {
             fs: false,
+            os: false,
+            inspector: false,
             // fs: 'browserfs/dist/shims/fs.js',
             crypto: require.resolve('crypto-browserify'),
             stream: require.resolve('stream-browserify'),
-            // path: require.resolve('path-browserify'),
+            path: require.resolve('path-browserify'),
             // processGlobal: 'browserfs/dist/shims/process.js',
             // bufferGlobal: 'browserfs/dist/shims/bufferGlobal.js',
             // bfsGlobal: require.resolve('browserfs'),