@lcap/nasl-language-server-core 4.4.0-beta.3 → 4.4.0-beta.31

package/out/typer/oql-checker/ts-parser.js

@@ -54,13 +54,16 @@ class TypeScriptNASLParser {
         const returns = [];
         const body = [];
         const syntaxKinds = []; // 收集所有遇到的SyntaxKind
+        const self = this;
+        let anonSubLogicCounter = 0;
         // 如果指定了returnName，直接创建Return节点
         if (returnName) {
             const returnNode = nasl_concepts_1.Return.createProtoTypeOnly({ name: returnName });
             returnNode.parentNode = fn;
             returns.push(returnNode);
         }
-        const interpret = (node) => {
+        // 内部实现函数：包含所有解析逻辑
+        function interpretImpl(node) {
             // 记录遇到的node的Syntax类型
             const syntaxKind = ts.SyntaxKind[node.kind];
             syntaxKinds.push(syntaxKind); // 添加到数组中
@@ -85,13 +88,20 @@ class TypeScriptNASLParser {
                 }
                 if (obj.name === returnName) {
                     // returnName对应的Return节点已经在方法开始时创建，这里只需要创建Assignment
-                    body.push(new nasl_concepts_1.Assignment({
+                    const assignment = new nasl_concepts_1.Assignment({
                         left: nasl_concepts_1.Identifier.createProtoTypeOnly({ name: returnName }),
                         right: obj.defaultValue?.expression,
-                    }));
+                    });
+                    assignment.parentNode = fn;
+                    if (assignment.left)
+                        assignment.left.parentNode = assignment;
+                    if (assignment.right)
+                        assignment.right.parentNode = assignment;
+                    body.push(assignment);
                 }
                 else {
                     const v = nasl_concepts_1.Variable.createProtoTypeOnly(obj);
+                    v.parentNode = fn;
                     if (v.defaultValue) {
                         v.defaultValue.parentNode = v;
                     }
@@ -100,7 +110,7 @@ class TypeScriptNASLParser {
                 return;
             }
             else if (ts.isCallExpression(node)) {
-                const { namespace, name } = this.parseExpressionNamespace(node.expression);
+                const { namespace, name } = self.parseExpressionNamespace(node.expression);
                 const call = new nasl_concepts_1.CallLogic();
                 // 设置调用信息
                 call.calleeName = name;
@@ -118,6 +128,7 @@ class TypeScriptNASLParser {
                             call.calleeName = 'GET_LIST';
                         }
                         call.arguments = [];
+                        // Note: parentNode will be set when this call is used as an expression
                         return call;
                     }
                     else if (name === 'FROM') {
@@ -142,7 +153,7 @@ class TypeScriptNASLParser {
                     const typeArgs = [];
                     node.typeArguments.forEach((typeArg) => {
                         // 使用interpretType函数解析类型参数
-                        const typeAnnotation = this.interpretType(typeArg);
+                        const typeAnnotation = self.interpretType(typeArg);
                         if (typeAnnotation) {
                             typeArgs.push(typeAnnotation);
                         }
@@ -168,55 +179,148 @@ class TypeScriptNASLParser {
             }
             else if (ts.isArrowFunction(node)) {
                 // ArrowFunction - 箭头函数
-                const func = new nasl_concepts_1.AnonymousFunction();
-                // 处理参数
-                const params = [];
-                node.parameters.forEach((param) => {
-                    if (ts.isParameter(param) && ts.isIdentifier(param.name)) {
-                        const p = new nasl_concepts_1.Param({ name: param.name.text });
-                        p.typeAnnotation = undefined;
-                        p.parentNode = func;
-                        params.push(p);
-                    }
-                    else {
-                        throw new Error('ArrowFunction parameter must be identifier');
+                //
+                // 重要：chain-call-transformer 为了拆 nested chain call，可能把表达式体箭头函数重写成 block：
+                //   () => { const $temp$1 = ...; return ...; }
+                // 这时若仍用 AnonymousFunction（只支持单个 body 表达式）会丢失局部变量作用域，从而产生自由变量错误。
+                // 因此：block 体的箭头函数解析成 SubLogic（支持 params/variables/body/returns）。
+                // 先解析形参
+                const parseParams = (parent) => {
+                    const params = [];
+                    node.parameters.forEach((param) => {
+                        if (ts.isParameter(param) && ts.isIdentifier(param.name)) {
+                            const p = new nasl_concepts_1.Param({ name: param.name.text });
+                            p.typeAnnotation = undefined;
+                            p.parentNode = parent;
+                            params.push(p);
+                        }
+                        else {
+                            throw new Error('ArrowFunction parameter must be identifier');
+                        }
+                    });
+                    return params;
+                };
+                if (ts.isBlock(node.body)) {
+                    const sub = new nasl_concepts_1.SubLogic();
+                    sub.name = `$anon$${++anonSubLogicCounter}`;
+                    sub.params = parseParams(sub);
+                    const localVars = [];
+                    const localBody = [];
+                    const retName = `$return$${anonSubLogicCounter}`;
+                    const ret = nasl_concepts_1.Return.createProtoTypeOnly({ name: retName });
+                    ret.parentNode = sub;
+                    sub.returns = [ret];
+                    const addLocalVariableDecl = (decl) => {
+                        if (!ts.isIdentifier(decl.name) || !decl.name.escapedText) {
+                            return;
+                        }
+                        const v = nasl_concepts_1.Variable.createProtoTypeOnly({
+                            name: decl.name.escapedText,
+                        });
+                        v.parentNode = sub;
+                        if (decl.initializer) {
+                            const initExpr = interpret(decl.initializer);
+                            if (initExpr) {
+                                const defaultValue = nasl_concepts_1.DefaultValue.createProtoTypeOnly({
+                                    expression: initExpr,
+                                    playground: [],
+                                });
+                                defaultValue.parentNode = v;
+                                initExpr.parentNode = defaultValue;
+                                v.defaultValue = defaultValue;
+                            }
+                        }
+                        if (v.defaultValue) {
+                            v.defaultValue.parentNode = v;
+                        }
+                        localVars.push(v);
+                    };
+                    for (const st of node.body.statements) {
+                        // 支持：const x = ...;
+                        if (ts.isVariableStatement(st)) {
+                            st.declarationList.declarations.forEach(addLocalVariableDecl);
+                            continue;
+                        }
+                        // 支持：return <expr>;
+                        if (ts.isReturnStatement(st)) {
+                            const retExpr = st.expression ? interpret(st.expression) : undefined;
+                            const assignment = new nasl_concepts_1.Assignment({
+                                left: nasl_concepts_1.Identifier.createProtoTypeOnly({ name: retName }),
+                                right: retExpr,
+                            });
+                            assignment.parentNode = sub;
+                            if (assignment.left)
+                                assignment.left.parentNode = assignment;
+                            if (assignment.right)
+                                assignment.right.parentNode = assignment;
+                            localBody.push(assignment);
+                            continue;
+                        }
+                        // 兼容：表达式语句（不常见，但尽量不丢）
+                        if (ts.isExpressionStatement(st)) {
+                            const expr = interpret(st.expression);
+                            if (expr) {
+                                expr.parentNode = sub;
+                                localBody.push(expr);
+                            }
+                            continue;
+                        }
+                        // 兼容空语句
+                        if (ts.isEmptyStatement(st)) {
+                            continue;
+                        }
+                        // 其他 statement 暂不支持（当前 transformer 只会生成上面几类）
+                        const kind = ts.tokenToString(st.kind) || ts.SyntaxKind[st.kind];
+                        throw new Error(`ArrowFunction block statement not implemented: ${kind}`);
                     }
-                });
-                func.params = params;
+                    sub.variables = localVars;
+                    sub.body = localBody;
+                    sub.playground = [];
+                    // Note: parentNode will be set when this sub is used as an expression
+                    return sub;
+                }
+                // 表达式体箭头函数：保持原行为（AnonymousFunction）
+                const func = new nasl_concepts_1.AnonymousFunction();
+                func.params = parseParams(func);
                 const bodyNode = interpret(node.body);
                 if (bodyNode) {
                     func.body = bodyNode;
                     bodyNode.parentNode = func;
                 }
                 else {
-                    // 报错
                     throw new Error('ArrowFunction body must be non empty');
                 }
+                // Note: parentNode will be set when this func is used as an expression
                 return func;
             }
             else if (node.kind === ts.SyntaxKind.TrueKeyword) {
                 // TrueKeyword - true 字面量
+                // Note: parentNode will be set when this literal is used as an expression
                 return new nasl_concepts_1.BooleanLiteral({ value: 'true' });
             }
             else if (node.kind === ts.SyntaxKind.FalseKeyword) {
                 // FalseKeyword - false 字面量
+                // Note: parentNode will be set when this literal is used as an expression
                 return new nasl_concepts_1.BooleanLiteral({ value: 'false' });
             }
             else if (ts.isNumericLiteral(node)) {
                 const literal = node;
+                // Note: parentNode will be set when this literal is used as an expression
                 return new nasl_concepts_1.NumericLiteral({ value: literal.text });
             }
             else if (ts.isStringLiteral(node)) {
                 // StringLiteral - 字符串字面量
+                // Note: parentNode will be set when this literal is used as an expression
                 return new nasl_concepts_1.StringLiteral({ value: node.text });
             }
             else if (ts.isIdentifier(node)) {
                 // Identifier - 标识符
+                // Note: parentNode will be set when this identifier is used as an expression
                 return nasl_concepts_1.Identifier.createProtoTypeOnly({ name: node.text });
             }
             else if (ts.isNewExpression(node)) {
                 // NewExpression - new 表达式
-                const { namespace, name } = this.parseExpressionNamespace(node.expression);
+                const { namespace, name } = self.parseExpressionNamespace(node.expression);
                 // 检查是否是 nasl.core 命名空间下的基本类型构造函数
                 if (namespace === 'nasl.core' && node.arguments && node.arguments.length === 1) {
                     const firstArg = node.arguments[0];
@@ -225,10 +329,12 @@ class TypeScriptNASLParser {
                         case 'Integer':
                             // 数值类型构造函数，转换为 NumericLiteral
                             if (ts.isNumericLiteral(firstArg)) {
+                                // Note: parentNode will be set when this literal is used as an expression
                                 return new nasl_concepts_1.NumericLiteral({ value: firstArg.text });
                             }
                             else if (ts.isStringLiteral(firstArg)) {
                                 // 支持字符串形式的数值
+                                // Note: parentNode will be set when this literal is used as an expression
                                 return new nasl_concepts_1.NumericLiteral({ value: firstArg.text });
                             }
                             break;
@@ -240,36 +346,43 @@ class TypeScriptNASLParser {
                                 const originalText = firstArg.getText();
                                 // 如果是整数形式（如 "0"），转换为小数形式（如 "0.0"）以确保类型推断为 Decimal
                                 const value = originalText.includes('.') ? originalText : `${originalText}.0`;
+                                // Note: parentNode will be set when this literal is used as an expression
                                 return new nasl_concepts_1.NumericLiteral({ value });
                             }
                             else if (ts.isStringLiteral(firstArg)) {
                                 // 支持字符串形式的数值
                                 const value = firstArg.text.includes('.') ? firstArg.text : `${firstArg.text}.0`;
+                                // Note: parentNode will be set when this literal is used as an expression
                                 return new nasl_concepts_1.NumericLiteral({ value });
                             }
                             break;
                         case 'String':
                             // 字符串类型构造函数，转换为 StringLiteral
                             if (ts.isStringLiteral(firstArg)) {
+                                // Note: parentNode will be set when this literal is used as an expression
                                 return new nasl_concepts_1.StringLiteral({ value: firstArg.text });
                             }
                             else if (ts.isNumericLiteral(firstArg)) {
                                 // 支持数值转字符串
+                                // Note: parentNode will be set when this literal is used as an expression
                                 return new nasl_concepts_1.StringLiteral({ value: firstArg.text });
                             }
                             break;
                         case 'Boolean':
                             // 布尔类型构造函数，转换为 BooleanLiteral
                             if (firstArg.kind === ts.SyntaxKind.TrueKeyword) {
+                                // Note: parentNode will be set when this literal is used as an expression
                                 return new nasl_concepts_1.BooleanLiteral({ value: 'true' });
                             }
                             else if (firstArg.kind === ts.SyntaxKind.FalseKeyword) {
+                                // Note: parentNode will be set when this literal is used as an expression
                                 return new nasl_concepts_1.BooleanLiteral({ value: 'false' });
                             }
                             else if (ts.isStringLiteral(firstArg)) {
                                 // 支持字符串形式的布尔值
                                 const value = firstArg.text.toLowerCase();
                                 if (value === 'true' || value === 'false') {
+                                    // Note: parentNode will be set when this literal is used as an expression
                                     return new nasl_concepts_1.BooleanLiteral({ value });
                                 }
                             }
@@ -277,6 +390,7 @@ class TypeScriptNASLParser {
                     }
                 }
                 else if (namespace === 'nasl.oql' && name === 'Query') {
+                    // Note: parentNode will be set when this composite is used as an expression
                     return new nasl_concepts_1.NewComposite({
                         typeAnnotation: nasl_concepts_1.TypeAnnotation.createProtoTypeOnly({
                             typeKind: 'reference',
@@ -294,6 +408,7 @@ class TypeScriptNASLParser {
                     });
                 }
                 // 如果不是特殊构造函数，按普通 NewComposite 处理
+                // Note: parentNode will be set when this composite is used as an expression
                 return new nasl_concepts_1.NewComposite({
                     typeAnnotation: nasl_concepts_1.TypeAnnotation.createReference(name, {
                         typeNamespace: namespace,
@@ -332,17 +447,23 @@ class TypeScriptNASLParser {
                         propertyName = `property${index}`;
                     }
                     const identifier = nasl_concepts_1.Identifier.createProtoTypeOnly({ name: propertyName });
+                    identifier.parentNode = composite;
                     const propertyIndex = composite.properties.length;
                     composite.properties.push(identifier);
                     const valueExpression = interpret(property.initializer);
                     if (valueExpression) {
                         const selectMembers = new nasl_concepts_1.SelectMembers();
                         selectMembers.expression = valueExpression;
+                        selectMembers.parentNode = composite;
+                        if (valueExpression) {
+                            valueExpression.parentNode = selectMembers;
+                        }
                         const rightIndex = composite.rights.length;
                         composite.rights.push(selectMembers);
                         const assignmentLine = new nasl_concepts_1.AssignmentLine();
                         assignmentLine.leftIndex = [0, propertyIndex];
                         assignmentLine.rightIndex = [rightIndex];
+                        assignmentLine.parentNode = composite;
                         composite.assignmentLines.push(assignmentLine);
                     }
                 };
@@ -352,13 +473,19 @@ class TypeScriptNASLParser {
                     if (ts.isSpreadAssignment(property)) {
                         // 如果有未完成的 composite，先添加它
                         if (currentComposite && currentComposite.properties.length > 0) {
-                            args.push(nasl_concepts_1.Argument.createProtoTypeOnly({ expression: currentComposite }));
+                            const arg = nasl_concepts_1.Argument.createProtoTypeOnly({ expression: currentComposite });
+                            currentComposite.parentNode = arg;
+                            args.push(arg);
                             currentComposite = null;
                         }
                         // 添加展开表达式
                         const spreadExpression = interpret(property.expression);
                         if (spreadExpression) {
-                            args.push(nasl_concepts_1.Argument.createProtoTypeOnly({ expression: spreadExpression }));
+                            const arg = nasl_concepts_1.Argument.createProtoTypeOnly({ expression: spreadExpression });
+                            if (spreadExpression) {
+                                spreadExpression.parentNode = arg;
+                            }
+                            args.push(arg);
                         }
                     }
                     else if (ts.isPropertyAssignment(property)) {
@@ -376,8 +503,12 @@ class TypeScriptNASLParser {
                 // 根据是否有展开操作决定返回类型
                 if (hasSpread) {
                     // 如果最后还有未完成的 composite，添加它
+                    // TypeScript 的控制流分析可能无法正确推断 currentComposite 的类型，使用类型断言
                     if (currentComposite && currentComposite.properties.length > 0) {
-                        args.push(nasl_concepts_1.Argument.createProtoTypeOnly({ expression: currentComposite }));
+                        const composite = currentComposite;
+                        const arg = nasl_concepts_1.Argument.createProtoTypeOnly({ expression: composite });
+                        composite.parentNode = arg;
+                        args.push(arg);
                     }
                     // 递归辅助函数：将多个参数转换为嵌套的二元 $InternalMerge 调用
                     const buildNestedMerge = (args) => {
@@ -419,6 +550,7 @@ class TypeScriptNASLParser {
                                 expression: firstMerge,
                             });
                             firstMerge.parentNode = firstMergeArg;
+                            // Note: firstMergeArg.parentNode will be set by the parent CallLogic
                             const newArgs = [firstMergeArg, ...remainingArgs];
                             return buildNestedMerge(newArgs);
                         }
@@ -428,6 +560,7 @@ class TypeScriptNASLParser {
                 }
                 else {
                     // 没有展开操作，返回单个 composite
+                    // Note: parentNode will be set when this composite is used as an expression
                     return currentComposite || makeEmptyAnonymousStructure();
                 }
             }
@@ -444,9 +577,59 @@ class TypeScriptNASLParser {
             }
             else if (ts.isPropertyAccessExpression(node)) {
                 // PropertyAccessExpression - 属性访问表达式
+                const full = self.parseExpressionNamespace(node);
+                // 特判：把 `app.enums.<EnumName>` 解析为带 namespace 的 Identifier
+                // 这样 `app.enums.IntEnum['0']` 的左值就不会依赖运行时变量 `app`
+                if (full.namespace === 'app.enums') {
+                    // Note: parentNode will be set when this identifier is used as an expression
+                    return nasl_concepts_1.Identifier.createProtoTypeOnly({ namespace: 'app.enums', name: full.name });
+                }
                 const memberExpr = new nasl_concepts_1.MemberExpression();
-                memberExpr.object = interpret(node.expression);
-                memberExpr.property = nasl_concepts_1.Identifier.createProtoTypeOnly({ name: node.name.text });
+                // 特判：把 `app.backend.variables.<var>` 解析为带 namespace 的 Identifier
+                // 例如：app.backend.variables.currentUser
+                if (full.namespace === 'app.backend.variables') {
+                    // Note: parentNode will be set when this identifier is used as an expression
+                    return nasl_concepts_1.Identifier.createProtoTypeOnly({ namespace: 'app.backend.variables', name: full.name });
+                }
+                // 特判：把 `app.enums.<EnumName>.<EnumItem>` 压缩为 Enum 标识符 + 成员访问
+                // 避免 `app` 在当前逻辑上下文里被当成普通变量，从而导致类型未知的成员访问错误
+                if (full.namespace?.startsWith('app.enums.')) {
+                    const nsParts = full.namespace.split('.');
+                    if (nsParts.length === 3) {
+                        const enumName = nsParts[2];
+                        const objId = nasl_concepts_1.Identifier.createProtoTypeOnly({ namespace: 'app.enums', name: enumName });
+                        const propId = nasl_concepts_1.Identifier.createProtoTypeOnly({ name: full.name });
+                        objId.parentNode = memberExpr;
+                        propId.parentNode = memberExpr;
+                        memberExpr.object = objId;
+                        memberExpr.property = propId;
+                        // Note: parentNode will be set when this memberExpr is used as an expression
+                        return memberExpr;
+                    }
+                }
+                // 特判：把 `app.backend.variables.<var>.<prop>` 压缩为 backend variable 标识符 + 成员访问
+                // 例如：app.backend.variables.currentUser.userId
+                if (full.namespace?.startsWith('app.backend.variables.')) {
+                    const nsParts = full.namespace.split('.');
+                    if (nsParts.length === 4) {
+                        const varName = nsParts[3];
+                        const objId = nasl_concepts_1.Identifier.createProtoTypeOnly({ namespace: 'app.backend.variables', name: varName });
+                        const propId = nasl_concepts_1.Identifier.createProtoTypeOnly({ name: full.name });
+                        objId.parentNode = memberExpr;
+                        propId.parentNode = memberExpr;
+                        memberExpr.object = objId;
+                        memberExpr.property = propId;
+                        // Note: parentNode will be set when this memberExpr is used as an expression
+                        return memberExpr;
+                    }
+                }
+                const obj = interpret(node.expression);
+                const prop = nasl_concepts_1.Identifier.createProtoTypeOnly({ name: node.name.text });
+                obj.parentNode = memberExpr;
+                prop.parentNode = memberExpr;
+                memberExpr.object = obj;
+                memberExpr.property = prop;
+                // Note: parentNode will be set when this memberExpr is used as an expression
                 return memberExpr;
             }
             else if (ts.isSpreadAssignment(node)) {
@@ -472,12 +655,15 @@ class TypeScriptNASLParser {
                     const expression = interpret(element);
                     const argument = nasl_concepts_1.Argument.createProtoTypeOnly({ keyword, expression });
                     argument.parentNode = call;
-                    expression && (expression.parentNode = argument);
+                    if (expression) {
+                        expression.parentNode = argument;
+                    }
                     return argument;
                 }) || [];
                 call.calleeName = `$InternalTuple${args.length}`;
                 call.calleeNamespace = 'nasl.core';
                 call.arguments = args;
+                // Note: parentNode will be set when this call is used as an expression
                 return call;
             }
             else if (ts.isParenthesizedExpression(node)) {
@@ -488,37 +674,66 @@ class TypeScriptNASLParser {
             }
             else if (ts.isBinaryExpression(node)) {
                 const result = new nasl_concepts_1.BinaryExpression();
-                result.left = interpret(node.left);
-                result.right = interpret(node.right);
+                const left = interpret(node.left);
+                const right = interpret(node.right);
+                if (left)
+                    left.parentNode = result;
+                if (right)
+                    right.parentNode = result;
+                result.left = left;
+                result.right = right;
                 result.operator = node.operatorToken.getText();
+                // Note: parentNode will be set when this expression is used as an expression
                 return result;
             }
             else if (ts.isElementAccessExpression(node)) {
                 const result = new nasl_concepts_1.CallFunction();
+                const expr = interpret(node.expression);
+                const argExpr = interpret(node.argumentExpression);
+                const arg1 = nasl_concepts_1.Argument.createProtoTypeOnly({ expression: expr });
+                const arg2 = nasl_concepts_1.Argument.createProtoTypeOnly({ expression: argExpr });
+                if (expr)
+                    expr.parentNode = arg1;
+                if (argExpr)
+                    argExpr.parentNode = arg2;
+                arg1.parentNode = result;
+                arg2.parentNode = result;
                 result.calleeName = 'Get';
                 result.calleeNamespace = 'nasl.util';
-                result.arguments = [
-                    interpret(node.expression),
-                    interpret(node.argumentExpression),
-                ];
+                result.arguments = [arg1, arg2];
+                // Note: parentNode will be set when this call is used as an expression
                 return result;
             }
             else if (ts.SyntaxKind.NullKeyword === node.kind) {
-                const result = new nasl_concepts_1.NullLiteral();
-                return result;
+                // Note: parentNode will be set when this literal is used as an expression
+                return new nasl_concepts_1.NullLiteral();
             }
             else if (ts.isSourceFile(node)) {
                 // SourceFile 节点不需要处理
             }
+            else if (ts.isEmptyStatement(node)) {
+                // EmptyStatement 不需要处理，直接跳过
+                return undefined;
+            }
             else {
                 // 收集未支持的表达式类型
                 const kind = ts.tokenToString(node.kind) || ts.SyntaxKind[node.kind];
-                this.unsupportedTypes.add(kind);
+                self.unsupportedTypes.add(kind);
                 throw new Error(`未支持的表达式类型: ${kind}`);
             }
             ts.visitEachChild(node, visitor, undefined);
             return undefined;
-        };
+        }
+        ;
+        /**
+         * 解析TypeScript节点为NASL节点
+         * @param node TypeScript节点
+         * @returns NASL节点
+         */
+        function interpret(node) {
+            return interpretImpl(node);
+        }
+        ;
         // 创建visitor函数来遍历AST节点
         const visitor = (node) => {
             interpret(node);