@lcap/nasl-language-server-core 4.0.1-rc.1 → 4.1.0-beta.10

package/out/typer/dispatch-expr.js

@@ -9,15 +9,16 @@ const helper_1 = require("./helper");
 const dispatch_stmt_1 = require("./dispatch-stmt");
 const dispatch_stmt_2 = require("./dispatch-stmt");
 const dispatch_def_1 = require("./dispatch-def");
+const get_q_name_1 = require("../reference-manager/get-q-name");
 const reference_manager_1 = require("../reference-manager/reference-manager");
 const symbol_type_1 = require("../reference-manager/symbol-type");
+const string_1 = require("../utils/string");
 const assertion_1 = require("../utils/assertion");
 const nasl_predicate_1 = require("./nasl-predicate");
 const asserts_1 = require("@lcap/nasl-concepts/asserts");
 const type_manager_1 = require("./type-manager");
 const type_predicate_1 = require("./type-predicate");
 const type_predicate_2 = require("./type-predicate");
-const sem_diag_2 = require("./sem-diag");
 const dispatch_process_1 = require("./dispatch-process");
 const dispatch_view_1 = require("./dispatch-view");
 const subster_2 = require("./subster");
@@ -26,6 +27,7 @@ const error_boundary_1 = require("../utils/error-boundary");
 const types_1 = require("../utils/types");
 const type_operator_1 = require("../utils/type-operator");
 const nasl_type_manipulation_1 = require("../utils/nasl-type-manipulation");
+const overload_helper_1 = require("./overload-helper");
 // speed consideration
 function dispatchExpr(env, nd, tgtTy) {
     if (!nd) {
@@ -36,6 +38,7 @@ function dispatchExpr(env, nd, tgtTy) {
             case 'Identifier': return tpIdentifier(env, nd, tgtTy);
             case 'MemberExpression': return tpMemberExpression(env, nd, tgtTy);
             case 'BinaryExpression': return tpBinaryExpression(env, nd, tgtTy);
+            case 'VariadicExpression': return tpVariadicExpression(env, nd, tgtTy);
             case 'UnaryExpression': return tpUnaryExpression(env, nd, tgtTy);
             case 'StringLiteral': return tpStringLiteral(env, nd, tgtTy);
             case 'NumericLiteral': return tpNumericLiteral(env, nd, tgtTy);
@@ -70,6 +73,8 @@ function dispatchExpr(env, nd, tgtTy) {
             case 'Anchor': return tpAnchor(env, nd, tgtTy);
             case 'JSBlock': return;
             case 'NewStructure': return tpNewStructure(env, nd, tgtTy);
+            case 'Break': return undefined;
+            case 'Continue': return undefined;
             default: {
                 // 不要 throw，草稿区或者脏数据经常有莫名其妙的东西进来，如 break continue 等
                 console.log(`未知的 LogicItem ${nd.concept}，先忽略`);
@@ -223,7 +228,7 @@ function tpMemberExpression(env, nd, tgtTy) {
         rawObjTyAnn = dispatchExpr(env, nd.object, undefined);
     }
     if (!rawObjTyAnn) {
-        env.addError((0, sem_diag_2.mkTypeNotFoundErr)(nd.object.name ?? ' '));
+        env.addError((0, sem_diag_1.mkTypeNotFoundErr)(nd.object.name ?? ' '));
         env.setType(nd.object, type_manager_1.naslAnyTy);
         env.setType(nd, type_manager_1.naslAnyTy);
         return type_manager_1.naslAnyTy;
@@ -304,7 +309,7 @@ function tpMemberExpression(env, nd, tgtTy) {
     let ndTy = env.getRawType(nd.property) ?? type_manager_1.naslAnyTy;
     // 为了 match！マッチのために
     {
-        const specialName = (0, reference_manager_1.getTokenQualifiedNameForMatchedExpr)(env, nd);
+        const specialName = (0, get_q_name_1.getTokenQualifiedNameForMatchedExpr)(env, nd);
         if (env.matchedVars.has(specialName)) {
             const ty = env.matchedVars.get(specialName);
             ndTy = ty;
@@ -318,7 +323,7 @@ function tpMemberExpression(env, nd, tgtTy) {
 const processRefProp = (env, nd, objTyAnn) => {
     const vRefTyDef = env.refMgr.findOrCreateTypeDef(objTyAnn);
     if (!vRefTyDef) {
-        env.addError((0, sem_diag_2.mkDefNotFoundErr)(objTyAnn, nd.property.name ?? ''));
+        env.addError((0, sem_diag_1.mkDefNotFoundErr)(objTyAnn, nd.property.name ?? ''));
         env.setType(nd.property, type_manager_1.naslAnyTy);
         return;
     }
@@ -329,7 +334,7 @@ const processRefProp = (env, nd, objTyAnn) => {
             env.setType(nd.property, type_manager_1.processSystemCommonTy);
         }
         else {
-            env.addError((0, sem_diag_2.mkMemNotFoundErr)(objTyAnn, nd.property.name));
+            env.addError((0, sem_diag_1.mkMemNotFoundErr)(objTyAnn, nd.property.name));
             env.setType(nd.property, type_manager_1.naslAnyTy);
         }
         return;
@@ -430,7 +435,7 @@ function tpBinaryExpression(env, nd, tgtTy) {
                         return ty;
                     if ((0, type_predicate_2.isMetadataType)(ty)) {
                         // 使用typeAlias来查找元数据类型的底层类型
-                        const qName = (0, reference_manager_1.getTokenQualifiedName)(ty);
+                        const qName = (0, get_q_name_1.getTokenQualifiedName)(ty);
                         if (qName && env.typeAlias.has(qName)) {
                             return env.typeAlias.get(qName);
                         }
@@ -458,7 +463,8 @@ function tpBinaryExpression(env, nd, tgtTy) {
                 const isStringOperationValid = (0, type_predicate_2.isStringTy)(baseLeftTy) || (0, type_predicate_2.isStringTy)(baseRightTy) || (0, type_predicate_2.isAnyTy)(baseLeftTy) || (0, type_predicate_2.isAnyTy)(baseRightTy);
                 const isNumericOperationValid = isUnionNumericTy(baseLeftTy) && isUnionNumericTy(baseRightTy);
                 if (!isStringOperationValid && !isNumericOperationValid && baseLeftTy && baseRightTy) {
-                    env.addError((0, sem_diag_1.mkIncompatibleTyErr)(env, leftTy || type_manager_1.naslAnyTy, rightTy || type_manager_1.naslAnyTy), fileNode, errBoundary, severity);
+                    // 对于不支持的操作，使用更清晰的错误消息
+                    env.addError((0, sem_diag_1.mkUnsupportedBinaryOperationErr)(nd.operator, baseLeftTy, baseRightTy), fileNode, errBoundary, severity);
                 }
             };
             env.addPostCheckTask(nd, postChk(env.getCurFileNode(), nd, env.errSeverity));
@@ -484,6 +490,7 @@ function tpBinaryExpression(env, nd, tgtTy) {
                 dispatchExpr(env, nd.left, type_manager_1.naslBooleanTy);
                 dispatchExpr(env, nd.right, type_manager_1.naslBooleanTy);
                 env.setType(nd, type_manager_1.naslBooleanTy);
+                env.unifier.unify(type_manager_1.naslBooleanTy, tgtTy);
                 return type_manager_1.naslBooleanTy;
             }
             ;
@@ -494,19 +501,30 @@ function tpBinaryExpression(env, nd, tgtTy) {
             dispatchExpr(env, nd.left, type_manager_1.naslStringTy);
             dispatchExpr(env, nd.right, type_manager_1.naslStringTy);
             env.setType(nd, type_manager_1.naslBooleanTy);
+            env.unifier.unify(type_manager_1.naslBooleanTy, tgtTy);
             return type_manager_1.naslBooleanTy;
         }
         case 'in': {
             const leftTy = dispatchExpr(env, nd.left, undefined);
             const rightTy = dispatchExpr(env, nd.right, undefined);
             // T in List<T>
-            env.unifier.unify((0, type_manager_1.createListTyAnn)(leftTy ?? type_manager_1.naslAnyTy), rightTy);
             env.setType(nd, type_manager_1.naslBooleanTy);
+            env.unifier.unify((0, type_manager_1.createListTyAnn)(leftTy ?? type_manager_1.naslAnyTy), rightTy);
+            env.unifier.unify(type_manager_1.naslBooleanTy, tgtTy);
             return type_manager_1.naslBooleanTy;
         }
         default: return undefined;
     }
 }
+const tpVariadicExpression = (env, nd, tgtTy) => {
+    // 根据经验，带数组的经常会被 proxy 动态污染，防患于未然先 toRaws
+    for (const expr of toRaws(nd.expressions)) {
+        dispatchExpr(env, expr, type_manager_1.naslBooleanTy);
+    }
+    env.setType(nd, type_manager_1.naslBooleanTy);
+    env.unifier.unify(type_manager_1.naslBooleanTy, tgtTy);
+    return type_manager_1.naslBooleanTy;
+};
 /*
 // 备份一下，未来可能有用
 function tpPlusExpression(env: SemEnv, nd: BinaryExpression, tgtTy: TypeAnnotation | undefined) {
@@ -626,7 +644,7 @@ const tpBinaryOrderExpr = (env, nd, tgtTy) => {
         if ((0, type_predicate_1.isUnionTy)(ty)) {
             return ty.typeArguments?.every(memberTy => isValidTy(memberTy)) ?? false;
         }
-        const qName = (0, reference_manager_1.getTokenQualifiedName)(ty);
+        const qName = (0, get_q_name_1.getTokenQualifiedName)(ty);
         return !!qName && env.typeAlias.has(qName);
     };
     // 不调用 solver 则无法判断，调用则影响速度，所以报错后移了
@@ -699,7 +717,7 @@ function tpCallLogic(env, nd, tgtTy) {
     }
     else {
         // 'nasl.util' 时 是 json 序列化
-        def = env.quickGetLibDef(nd);
+        def = env.quickGetLibDef(nd, nd.calleeName, undefined);
     }
     // 处理调用处的验证规则
     if (nd.validation?.rules && nd.validation.rules.length > 0 && def) {
@@ -791,7 +809,7 @@ function determineCallLogicFnTy(env, nd, def) {
         return env.getRawType(def);
     }
     else {
-        const qName = (0, reference_manager_1.getTokenQualifiedName)(nd);
+        const qName = (0, get_q_name_1.getTokenQualifiedName)(nd);
         if (!qName) {
             return undefined;
         }
@@ -857,34 +875,12 @@ function tpCallFunction(env, nd, tgtTy) {
     if (parseTsClassType_1.enumBuiltinFns.includes(calleeName)) {
         return handleEnumFn(env, nd, tgtTy);
     }
-    if (calleeName === 'Convert' || calleeName === 'Length') {
-        return tpLengthAndConvertCall(env, nd, tgtTy);
-    }
-    else if (parseTsClassType_1.overloadedFns.includes(calleeName)) {
-        const argTys = [];
-        for (const arg of nd.arguments) {
-            argTys.push(dispatchExpr(env, arg, undefined) ?? type_manager_1.naslAnyTy);
-        }
-        let argTy = argTys[(0, parseTsClassType_1.getOvParamIdx)(calleeName)];
-        if (calleeName === 'CAST') {
-            const litTy = nasl_concepts_1.TypeAnnotation.createProtoTypeOnly({
-                typeKind: 'literal',
-                typeNamespace: 'nasl.core',
-                typeName: 'String',
-                literal: nd.arguments?.[(0, parseTsClassType_1.getOvParamIdx)(calleeName)]?.expression?.value ?? ''
-            });
-            argTy = litTy;
-        }
-        const mangledCalleeName = (0, parseTsClassType_1.mangleOvFnName)(calleeName, argTy);
-        const fnDef = env.quickGetLibDef(nd, mangledCalleeName);
-        const fnTy = fnDef?.__TypeAnnotation;
-        (0, helper_1.zipWith_)(env.unifier.unify, argTys, fnTy?.typeArguments);
-        env.setType(nd, fnTy?.returnType?.[0] ?? type_manager_1.naslAnyTy); // 似乎不可能为空
-        const callInfo = (0, type_manager_1.createFunctionDef)(argTys, fnTy?.returnType?.[0] ?? type_manager_1.naslAnyTy, fnDef, undefined);
-        env.resolvedCallInfo.set(nd, callInfo);
-        return env.getRawType(nd);
+    // 前端全局类型推导 + 重载函数几乎无法做任何类型推导，只能做后置验证。后端可以推导，但简单起见，不区分前后端了。
+    // 总结：全局类型推导 + 重载 = 灾难
+    if (parseTsClassType_1.overloadedFns.includes(calleeName)) {
+        return handleOverloadedFunction(env, nd, tgtTy, calleeName);
     }
-    const fnDef = env.quickGetLibDef(nd);
+    const fnDef = env.quickGetLibDef(nd, calleeName, env.ctxCQC?.dataSourceSqlType);
     let fnTy = fnDef?.__TypeAnnotation;
     if (!fnTy) {
         env.addError('无法找到函数定义（类型）');
@@ -898,7 +894,34 @@ function tpCallFunction(env, nd, tgtTy) {
             const elemTy = parTy.typeArguments[0];
             // 余下的一并处理
             for (let i = idx; i < nd.arguments.length; ++i) {
-                dispatchExpr(env, nd.arguments[i], elemTy);
+                /**
+                  * ListSort 只能特殊处理了。
+                  * nasl.util 里定义为 { asc: Boolean, by: Long | Decimal | ... } 的话会有匿名数据类型不匹配报错（invariance）
+                  * 如果定义为泛型 T2 extends Long | Decimal | ... 且  { asc: Boolean, by: T2 } 的话 T2 不支持实例化成 Union
+                  * （页面是全局求解，暂时不好区分 T2 的约束是来自多个赋值还是一个赋值，如果是多个则报错，如果是一个则使用 Union 作为解这种复杂的机制
+                  */
+                if (calleeName === 'ListSort' || calleeName === 'ListSortAsync') {
+                    const expr = nd.arguments[i].expression;
+                    // 抠出函数类型的参数和返回类型
+                    if (!(0, type_predicate_2.isFuncTy)(elemTy)) {
+                        continue; // 干不了了
+                    }
+                    const parTy = elemTy.typeArguments?.[0];
+                    const retTy = elemTy.returnType?.[0];
+                    // 留给 checker.ts 去做后置检查吧
+                    if (expr?.concept === 'AnonymousFunction') {
+                        tpAnonymousFunction(env, expr, (0, type_manager_1.createFnTyFromTyAnns)([parTy], undefined), true);
+                        // dispatchExpr(env, expr.params[0], parTy);
+                        // dispatchExpr(env, expr.body, retTy);
+                    }
+                    else if (expr?.concept === 'SubLogic') {
+                        tpSubLogic(env, expr, (0, type_manager_1.createFnTyFromTyAnns)([parTy], undefined), true);
+                    }
+                }
+                else {
+                    // 正常处理
+                    dispatchExpr(env, nd.arguments[i], elemTy);
+                }
             }
         }
         else {
@@ -1006,60 +1029,82 @@ function tpCallFunction(env, nd, tgtTy) {
     }
 }
 exports.tpCallFunction = tpCallFunction;
-// 目前只有 CallFunction 支持重载
-function tpLengthAndConvertCall(env, nd, tgtTy) {
-    // 处理重载函数，重载函数不能用 unify(paramTy, argTy) 只能 dispatchExpr(arg, undefined)
-    // 且部分情况 type arguments 还需要推
-    // Ensure we don't have undefined values in our argTys array
-    const argTys = nd.arguments.map(arg => dispatchExpr(env, arg, undefined) ?? type_manager_1.naslAnyTy);
-    let calleeName = nd.calleeName;
-    if (calleeName === 'Length') {
-        env.unifier.unify(type_manager_1.naslLongTy, tgtTy); // 返回类型确定
-        env.setType(nd, type_manager_1.naslLongTy);
-        // For Length function, the parameter is required
-        // Create a mock definition for the Length function
-        const mockLengthDef = {
-            params: [{ name: 'collection', optional: false }]
-        };
-        const callInfo = (0, type_manager_1.createFunctionDef)(argTys, type_manager_1.naslLongTy, mockLengthDef, undefined);
-        env.resolvedCallInfo.set(nd, callInfo); // 存储函数定义（含参数和返回类型）
-        return type_manager_1.naslLongTy;
-    }
-    if (calleeName === 'Convert') {
-        const arg0Ty = env.getRawType(nd.arguments?.[0]);
-        const normaliseArg0Ty = (ty) => {
-            switch (ty.typeKind) {
-                case 'primitive':
-                    return ty;
-                default:
-                    return type_manager_1.naslAnyTy;
-            }
-        };
-        const qName = (0, reference_manager_1.getTokenQualifiedName)(nd);
-        const mangledQName = (0, parseTsClassType_1.mangleOvFnName)(qName, normaliseArg0Ty(arg0Ty ?? type_manager_1.naslAnyTy));
-        // 检查 ConvertTo 的类型是否符合要求
-        const tyParam0 = env.refMgr.qNameDefs.get(mangledQName)?.__TypeAnnotation.typeParams?.[0];
-        const paramTys = env.refMgr.qNameDefs.get(mangledQName)?.__TypeAnnotation.typeArguments;
-        // 简单点
-        if ((0, type_predicate_2.isValidNaslTy)(nd.typeArguments?.[0])) { // @ts-expect-error
-            env.unifier.unify(nd.typeArguments[0], tyParam0?.constraints); // @ts-expect-error
-            tgtTy && env.unifier.unify(nd.typeArguments[0], tgtTy); // @ts-expect-error
-            env.setType(nd, nd.typeArguments[0]);
+/**
+ * 处理重载函数的调用
+ * @param env 语义环境
+ * @param nd 函数调用节点
+ * @param tgtTy 目标类型
+ * @param calleeName 被调用函数名
+ * @returns 处理后的类型注解
+ */
+const handleOverloadedFunction = (env, nd, tgtTy, calleeName) => {
+    const ovParamIdx = (0, overload_helper_1.getOvParamIdx)(calleeName);
+    const argTys = [];
+    for (const arg of nd.arguments) {
+        argTys.push(dispatchExpr(env, arg, undefined) ?? type_manager_1.naslAnyTy);
+    }
+    if (calleeName === 'CAST') {
+        argTys[ovParamIdx] = (0, overload_helper_1.createCastLiteralType)(nd.arguments?.[ovParamIdx]?.expression?.value ?? '');
+    }
+    // Convert, Length, CAST 的返回类型可以从用户选择的类型（通过 type picker）拿到
+    // 其他重载函数都在 SQL 里，都在服务端逻辑里，可以立即从参数类型获得，没有页面全局类型推导的问题
+    let retTy = (0, overload_helper_1.getOverloadFuncRetTy)(nd, argTys[ovParamIdx]);
+    if (!retTy) {
+        if (!env.isView) {
+            const mangledCalleeName = (0, overload_helper_1.mangleOvFnName)(calleeName, argTys[ovParamIdx]);
+            const fnDef = env.quickGetLibDef(nd, mangledCalleeName, env.ctxCQC?.dataSourceSqlType);
+            const fnTy = fnDef?.__TypeAnnotation;
+            retTy = fnTy?.returnType?.[0];
         }
         else {
-            env.setType(nd, tgtTy);
+            retTy = type_manager_1.naslAnyTy;
         }
-        // Create a mock definition for parameters
-        const mockConvertDef = {
-            params: paramTys?.map(() => ({ optional: false })) || []
-        };
-        const callInfo = (0, type_manager_1.createFunctionDef)(argTys, env.getRawType(nd), mockConvertDef, undefined);
-        env.resolvedCallInfo.set(nd, callInfo);
-        return env.getRawType(nd);
     }
-}
+    env.unifier.unify(retTy, tgtTy);
+    const callInfo = (0, type_manager_1.createFunctionDef)(argTys, retTy, undefined, undefined);
+    env.resolvedCallInfo.set(nd, callInfo);
+    const capturedDbSqlType = env.ctxCQC?.dataSourceSqlType;
+    // 剩下的需要后置处理
+    const postChk = (fileNode, errBoundary, severity) => (env) => {
+        const argTys = nd.arguments.map((arg) => env.getType(arg.expression));
+        if (calleeName === 'CAST') {
+            argTys[ovParamIdx] = (0, overload_helper_1.createCastLiteralType)(nd.arguments?.[ovParamIdx]?.expression?.value ?? '');
+        }
+        const ovArgTy = argTys[ovParamIdx];
+        const mangledCalleeName = (0, overload_helper_1.mangleOvFnName)(calleeName, ovArgTy);
+        let fnDef = mangledCalleeName ? env.quickGetLibDef(nd, mangledCalleeName, capturedDbSqlType) : undefined;
+        let fnTy = fnDef?.__TypeAnnotation;
+        // If no matching overload found, validate and report error
+        if (!fnDef || !fnTy) {
+            // Create fallback definition to prevent further errors
+            const fallbackDef = (0, overload_helper_1.createFallbackOverloadDef)(calleeName, nd.calleeNamespace, nd.arguments.length);
+            fnDef = fallbackDef;
+            fnTy = fallbackDef.__TypeAnnotation;
+            // Convert 允许接收任何类型，跳过报错（mangled name convertList convertMap 等查不到定义会产生额外错误）
+            if (calleeName !== 'Convert') {
+                const possibleTypes = (0, overload_helper_1.getOverloadParameterTypes)(env, nd, capturedDbSqlType);
+                if (possibleTypes.length > 0) {
+                    const errorMsg = (0, sem_diag_1.createOverloadTypeError)(calleeName, ovArgTy, possibleTypes);
+                    // precise error boundary nd.arguments[i]! is not working here, why?
+                    env.addError(errorMsg, fileNode, errBoundary, severity);
+                }
+            }
+        }
+        // 后置类型校验，暂时都不需要，不可能报错
+        // for (let i = 0; i < argTys.length && i < (fnTy?.typeArguments?.length ?? 0); ++i) {
+        //   const sub = argTys[i];
+        //   const sup = fnTy!.typeArguments![i];
+        //   if (!isSubTy(env, sub, sup)) { // precise error boundary nd.arguments[i]! is not working here, why?
+        //     env.addError(mkIncompatibleTyErr(env, sub, sup), fileNode, errBoundary, severity);
+        //   }
+        // }
+    };
+    env.addPostCheckTask(nd, postChk(env.getCurFileNode(), nd, env.errSeverity));
+    env.setType(nd, retTy); // 似乎不可能为空
+    return env.getRawType(nd);
+};
 function tpCallInterface(env, nd, tgtTy) {
-    const qName = (0, reference_manager_1.getTokenQualifiedName)(nd);
+    const qName = (0, get_q_name_1.getTokenQualifiedName)(nd);
     if (!qName) {
         env.setType(nd, type_manager_1.naslAnyTy);
         return type_manager_1.naslAnyTy;
@@ -1089,7 +1134,7 @@ exports.tpCallInterface = tpCallInterface;
 exports.tpCallAuthInterface = tpCallInterface;
 exports.tpCallMicroserviceInterface = tpCallInterface;
 exports.tpCallConnector = tpCallLogic;
-function tpAnonymousFunction(env, nd, tgtTy) {
+function tpAnonymousFunction(env, nd, tgtTy, isListSort = false) {
     if (!tgtTy || !(0, type_predicate_2.isFuncTy)(tgtTy)) {
         env.setType(nd, type_manager_1.naslAnyTy);
         env.addError((0, sem_diag_1.mkIncompatibleTyErr)(env, '函数', tgtTy || type_manager_1.naslAnyTy));
@@ -1104,22 +1149,22 @@ function tpAnonymousFunction(env, nd, tgtTy) {
         const ctxParTy = tgtTy.typeArguments[idx];
         ctxParTy && env.setType(param, ctxParTy);
     });
-    dispatchExpr(env, nd.body, tgtTy?.returnType?.[0]);
+    dispatchExpr(env, nd.body, isListSort ? undefined : tgtTy?.returnType?.[0]);
     env.setType(nd, (0, type_manager_1.createFnTyFromTyAnns)(// @ts-expect-error
     nd.params.map(env.getRawType), env.getRawType(nd.body) ?? type_manager_1.naslAnyTy));
     paramsArr.forEach(p => env.removeVar(p));
     const ndTy = env.getRawType(nd);
-    env.unifier.unify(ndTy, tgtTy);
+    !isListSort && env.unifier.unify(ndTy, tgtTy);
     return ndTy;
 }
-function tpSubLogic(env, nd, tgtTy) {
+function tpSubLogic(env, nd, tgtTy, isListSort = false) {
     // 若非前端，则 shallow copy，因为内部会触发 solve，会把进来前的约束清掉；
     // 若是前端，则无需 copy
     const csCopy = env.isView ? env.unifier.cs : new Map(env.unifier.cs);
     const subLogicVars = [...nd.params, ...nd.returns, ...nd.variables];
     subLogicVars.forEach(v => (0, dispatch_def_1.dispatchDef)(env, v));
     // 处理 tgtTy 缺失的情况
-    if (tgtTy && !(0, type_predicate_2.isFuncTy)(tgtTy)) {
+    if (tgtTy && !(0, type_predicate_2.isFuncTy)(tgtTy) && !isListSort) {
         env.setType(nd, type_manager_1.naslAnyTy);
         env.addError((0, sem_diag_1.mkIncompatibleTyErr)(env, '函数', tgtTy));
         return (0, type_manager_1.createFnTyFromTyAnns)([], type_manager_1.naslAnyTy);
@@ -1137,7 +1182,7 @@ function tpSubLogic(env, nd, tgtTy) {
     const ndTy = (0, type_manager_1.createRefTyAnnFromDef)(nd, env);
     env.setType(nd, ndTy);
     env.unifier.cs = csCopy;
-    env.unifier.unify(ndTy, tgtTy); // 这里需要额外的 unify，否则 SubLogic 算出来的类型不能与外侧进来时的约束产生关系
+    !isListSort && env.unifier.unify(ndTy, tgtTy); // 这里需要额外的 unify，否则 SubLogic 算出来的类型不能与外侧进来时的约束产生关系
     return ndTy;
 }
 function tpArgument(env, nd, tgtTy) {
@@ -1197,7 +1242,7 @@ function tpCallQueryComponent(env, nd, tgtTy) {
                     env.setType(nd, prop.typeAnnotation);
                     env.unifier.unify(env.getRawType(nd), tgtTy);
                     // @ts-expect-error
-                    nd.$propQName = (0, reference_manager_1.getPropQName)(entityQName, prop.name, 'Entity');
+                    nd.$propQName = (0, string_1.getPropQName)(entityQName, prop.name, 'Entity');
                 }
             }
         }
@@ -1259,7 +1304,7 @@ function tpCallQueryComponent(env, nd, tgtTy) {
                 if (!entityQName) {
                     continue;
                 }
-                const aggrTy = calcAggrTy((0, reference_manager_1.getPropQName)(entityQName, aggrPar.propertyName, 'Entity'), se.aggregateName);
+                const aggrTy = calcAggrTy((0, string_1.getPropQName)(entityQName, aggrPar.propertyName, 'Entity'), se.aggregateName);
                 env.setType(aggrPar, aggrTy);
                 env.setType(se, aggrTy);
                 se.asName && aggrAsNames.set(se.asName, aggrTy);
@@ -1285,7 +1330,7 @@ function tpCallQueryComponent(env, nd, tgtTy) {
             // 选了几个属性，每个属性都是一个独立的 QueryFieldExpression
             if (qfe.propertyName?.length > 0) {
                 !hasAggr && (0, helper_1.createOnPush)(selMap, entityQName, qfe.propertyName);
-                seTy = (0, fp_macros_1.IfBind)(env.refMgr.qNameDefs.get((0, reference_manager_1.getPropQName)(entityQName, qfe.propertyName, 'Entity')))(prop => prop.typeAnnotation)((0, fp_macros_1.feed)(undefined));
+                seTy = (0, fp_macros_1.IfBind)(env.refMgr.qNameDefs.get((0, string_1.getPropQName)(entityQName, qfe.propertyName, 'Entity')))(prop => prop.typeAnnotation)((0, fp_macros_1.feed)(undefined));
             }
             else { // 全选时 seTy 为 Entity 类型
                 seTy = (0, fp_macros_1.IfBind)(env.refMgr.qNameDefs.get(`${entityQName}`))(def => env.getRawType(def))((0, fp_macros_1.feed)(undefined));
@@ -1322,12 +1367,12 @@ function tpCallQueryComponent(env, nd, tgtTy) {
             // const len = nd.groupBy.length + aggrAsNames.size;
             const allKeys = Array.from(groupByAsNames.keys()).concat(Array.from(aggrAsNames.keys()));
             const allTys = Array.from(groupByAsNames.values()).concat(Array.from(aggrAsNames.values()));
-            retTy = (0, type_manager_1.createListTyAnn)((0, type_manager_1.createAnonymousTyAnnIfNecessary)(allKeys.map(reference_manager_1.lowercaseFirstChar), allTys) ?? type_manager_1.naslAnyTy);
+            retTy = (0, type_manager_1.createListTyAnn)((0, type_manager_1.createAnonymousTyAnnIfNecessary)(allKeys.map(string_1.lowercaseFirstChar), allTys) ?? type_manager_1.naslAnyTy);
         }
         else if (!hasGroupBy && hasAggr) {
             const aggrKeys = Array.from(aggrAsNames.keys());
             const aggrTys = Array.from(aggrAsNames.values());
-            retTy = (0, type_manager_1.createAnonymousTyAnnIfNecessary)(aggrKeys.map(reference_manager_1.lowercaseFirstChar), aggrTys);
+            retTy = (0, type_manager_1.createAnonymousTyAnnIfNecessary)(aggrKeys.map(string_1.lowercaseFirstChar), aggrTys);
         }
         else {
             // 太乱了，之后重构
@@ -1345,13 +1390,13 @@ function tpCallQueryComponent(env, nd, tgtTy) {
                 }
                 else {
                     const tyAnns = selProps.map(prop => {
-                        const qName = (0, reference_manager_1.getPropQName)(entityQName, prop, 'Entity');
+                        const qName = (0, string_1.getPropQName)(entityQName, prop, 'Entity');
                         return env.refMgr.qNameDefs.get(qName)?.typeAnnotation ?? type_manager_1.naslAnyTy;
                     });
-                    return (0, type_manager_1.createAnonymousTyAnn)(selProps.map(reference_manager_1.lowercaseFirstChar), tyAnns);
+                    return (0, type_manager_1.createAnonymousTyAnn)(selProps.map(string_1.lowercaseFirstChar), tyAnns);
                 }
             });
-            retTy = (0, type_manager_1.createListTyAnn)((0, type_manager_1.createAnonymousTyAnn)(selShortNames.map(reference_manager_1.lowercaseFirstChar), tys));
+            retTy = (0, type_manager_1.createListTyAnn)((0, type_manager_1.createAnonymousTyAnn)(selShortNames.map(string_1.lowercaseFirstChar), tys));
         }
         // 2.11 之前才有，升级脚本也没管，需要特殊处理
         if (nd.limit) {
@@ -1578,7 +1623,7 @@ const extractNameTyPair = (env, ty) => {
         return ty.properties.map((p, _) => [p.name, p.typeAnnotation]);
     }
     else if (ty) {
-        return (0, fp_macros_1.IfBind)((0, reference_manager_1.getTokenQualifiedName)(ty))(qName => env.refMgr.qNameDefs.get(qName)
+        return (0, fp_macros_1.IfBind)((0, get_q_name_1.getTokenQualifiedName)(ty))(qName => env.refMgr.qNameDefs.get(qName)
             ?.properties
             .map((p, _) => [p.name, p.typeAnnotation ?? null]))((0, fp_macros_1.feed)([]));
     }
@@ -1722,7 +1767,7 @@ function tpMatch(env, nd, tgtTy) {
         const isRefined = shouldRefine(nd.expression);
         let matchedVarName = undefined;
         if (isRefined) {
-            matchedVarName = (0, reference_manager_1.getTokenQualifiedNameForMatchedExpr)(env, nd.expression);
+            matchedVarName = (0, get_q_name_1.getTokenQualifiedNameForMatchedExpr)(env, nd.expression);
             const freshMatchedVar = nasl_concepts_1.Variable.createProtoTypeOnly({
                 name: matchedVarName,
                 typeAnnotation: exprRefinedTy
@@ -1809,7 +1854,7 @@ function tpEntityLogic(env, nd, tgtTy) {
     // 例如 app.dataSources.${dbName}.entities.${entityName}
     // 从 'a.b.c.logics.e' 中提取 'a.b.c'
     const getEntityQName = (ctxCallLogic) => {
-        const qualifiedNames = (0, reference_manager_1.getTokenQualifiedName)(ctxCallLogic);
+        const qualifiedNames = (0, get_q_name_1.getTokenQualifiedName)(ctxCallLogic);
         const parts = qualifiedNames.split('.');
         return parts.slice(0, parts.length - 2).join('.');
     };
@@ -1982,7 +2027,6 @@ const tpNewStructure = (env, nd, tgtTy) => {
     return ndTy;
 };
 // 一个通用的方法，获取各种连线右侧的逻辑项
-// calculate type of the right-hand side of each assignment line
 const getRightByLine = (nd, itemIdx, memIdx) => {
     if (memIdx !== undefined) {
         return toRaw(nd.rights[itemIdx].members[memIdx]);