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

package/out/typer/dispatch-expr.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRightByLine = exports.tpMatch = exports.tpSolvingExpr = exports.extractNameTyPair = exports.tpSubLogic = exports.tpAnonymousFunction = exports.dispatchExpr = void 0;
+exports.getRightByLine = exports.tpIfExpression = exports.tpMatch = exports.tpSolvingExpr = exports.extractNameTyPair = exports.tpSubLogic = exports.tpAnonymousFunction = exports.dispatchExpr = void 0;
 const nasl_concepts_1 = require("@lcap/nasl-concepts");
 const fp_macros_1 = require("../utils/fp-macros");
 const sem_diag_1 = require("./sem-diag");
@@ -9,10 +9,11 @@ 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 def_key_helpers_1 = require("../reference-manager/def-key-helpers");
 const reference_manager_1 = require("../reference-manager/reference-manager");
 const string_1 = require("../utils/string");
 const assertion_1 = require("../utils/assertion");
+const typer_1 = require("./typer");
 const service_1 = require("@lcap/nasl-concepts/service");
 const asserts_1 = require("@lcap/nasl-concepts/asserts");
 const type_manager_1 = require("./type-manager");
@@ -61,6 +62,7 @@ function dispatchExpr(env, nd, tgtTy) {
             case 'NewList': return tpNewList(env, nd, tgtTy);
             case 'NewMap': return tpNewMap(env, nd, tgtTy);
             case 'Match': return tpMatch(env, nd, tgtTy);
+            case 'IfExpression': return tpIfExpression(env, nd, tgtTy);
             case 'StringInterpolation': return tpStringInterpolation(env, nd, tgtTy);
             case 'AnonymousFunction': return (0, exports.tpAnonymousFunction)(env, nd, tgtTy);
             case 'SubLogic': return (0, exports.tpSubLogic)(env, nd, tgtTy);
@@ -165,9 +167,7 @@ function tpBooleanLiteral(env, nd, tgtTy) {
     if (nd.value !== 'true' && nd.value !== 'false') {
         env.addError((0, sem_diag_1.mkSyntaxErr)('布尔值'));
     }
-    if ((0, type_predicate_2.isTyAnnTyParam)(tgtTy)) {
-        env.unifier.unify(type_manager_1.naslBooleanTy, tgtTy);
-    }
+    env.unifier.unify(type_manager_1.naslBooleanTy, tgtTy);
     env.setType(nd, type_manager_1.naslBooleanTy);
     return env.getRawType(nd);
 }
@@ -206,10 +206,19 @@ function tpIdentifier(env, nd, tgtTy) {
     // a.b.c 中的 b 和 c 不应指向局部变量、不收集草稿区的推导
     if (!env.isInMemberExpr && (0, service_1.isTypeInferConcept)(def)) {
         env.idToVar.set(nd, def);
-        !env.isPlayground && env.allRefsInPlayground.delete(def);
+        // 如果 Identifier 在草稿区，将它加入到 Set 中
+        if (env.isPlayground) {
+            env.allRefsInPlayground.add(nd);
+        }
+        else {
+            // 如果不在草稿区，确保从 Set 中删除（可能之前添加过）
+            env.allRefsInPlayground.delete(nd);
+        }
     }
     else {
         env.idToVar.delete(nd);
+        // 从 idToVar 中删除时，也要从 allRefsInPlayground 中删除
+        env.allRefsInPlayground.delete(nd);
     }
     env.unifier.unify(ndTy, tgtTy);
     return ndTy;
@@ -309,7 +318,7 @@ function tpMemberExpression(env, nd, tgtTy) {
     let ndTy = env.getRawType(nd.property) ?? type_manager_1.naslAnyTy;
     // 为了 match！マッチのために
     {
-        const specialName = (0, get_q_name_1.getTokenQualifiedNameForMatchedExpr)(env, nd);
+        const specialName = (0, def_key_helpers_1.getGlobalDefKeyForMatchedExpr)(env, nd);
         if (env.matchedVars.has(specialName)) {
             const ty = env.matchedVars.get(specialName);
             ndTy = ty;
@@ -327,6 +336,18 @@ const processRefProp = (env, nd, objTyAnn) => {
         env.setType(nd.property, type_manager_1.naslAnyTy);
         return;
     }
+    if (objTyAnn.typeKind === 'generic' && vRefTyDef.concept === 'Structure') {
+        const propertyType = (0, typer_1.findPropertyTypeFromGeneric)(env, objTyAnn, vRefTyDef, nd.property.name);
+        if (propertyType) {
+            env.setType(nd.property, propertyType);
+        }
+        else {
+            // 找不到属性时设置错误，与非 generic 分支保持一致
+            env.addError((0, sem_diag_1.mkMemNotFoundErr)(objTyAnn, nd.property.name));
+            env.setType(nd.property, type_manager_1.naslAnyTy);
+        }
+        return;
+    }
     let prop = reference_manager_1.ReferenceManager.getProp(vRefTyDef, nd.property.name);
     if (!prop) {
         if (nd.object.name === 'processSystem') {
@@ -357,50 +378,31 @@ function createIndexedAccessType(env, nd, simplifiedObjectType) {
     env.setType(nd.property, indexedTy);
 }
 function tpBinaryArithExpr(env, nd, tgtTy) {
-    let leftTy = dispatchExpr(env, nd.left, undefined);
-    let rightTy = dispatchExpr(env, nd.right, undefined);
+    // 注意：此函数只处理 -, *, /, % 操作符，+ 操作符在 tpBinaryExpression 中单独处理
+    let leftTy = dispatchExpr(env, nd.left, type_manager_1.naslDecimalTy);
+    let rightTy = dispatchExpr(env, nd.right, type_manager_1.naslDecimalTy);
     let ndTy;
     // 启发式，兼容老程序就行了。速度至上。
     if ((0, type_predicate_2.isTyAnnTyParam)(leftTy) && !(0, type_predicate_2.isTyAnnTyParam)(rightTy)) {
-        if ((0, type_predicate_2.isDecimalTy)(rightTy)) {
-            env.unifier.unify(leftTy, type_manager_1.naslDecimalTy);
-        }
-        else if ((0, type_predicate_2.isIntegerTy)(rightTy)) {
-            env.unifier.unify(type_manager_1.naslLongTy, leftTy);
-        }
+        env.unifier.unify(type_manager_1.naslLongTy, leftTy);
     }
     else if (!(0, type_predicate_2.isTyAnnTyParam)(leftTy) && (0, type_predicate_2.isTyAnnTyParam)(rightTy)) {
-        if ((0, type_predicate_2.isDecimalTy)(leftTy)) {
-            env.unifier.unify(rightTy, type_manager_1.naslDecimalTy);
-        }
-        else if ((0, type_predicate_2.isIntegerTy)(leftTy)) {
-            env.unifier.unify(type_manager_1.naslLongTy, rightTy);
-        }
+        env.unifier.unify(type_manager_1.naslLongTy, rightTy);
     }
     // 人肉 solve
-    const hasString = (0, type_predicate_2.isStringTy)(leftTy) || (0, type_predicate_2.isStringTy)(rightTy);
-    const hasDecimal = (0, type_predicate_2.isDecimalTy)(leftTy) || (0, type_predicate_2.isDecimalTy)(rightTy);
-    const hasLong = (0, type_predicate_2.isIntegerTy)(leftTy) || (0, type_predicate_2.isIntegerTy)(rightTy);
-    if (nd.operator === '+' && hasString) {
-        ndTy = type_manager_1.naslStringTy;
-    }
-    else if (nd.operator === '/') {
+    if (nd.operator === '/') { // 除法运算，结果必须是 decimal
         // 必须是 decimal
         ndTy = type_manager_1.naslDecimalTy;
     }
     else {
-        if (hasDecimal) {
-            ndTy = type_manager_1.naslDecimalTy;
-        }
-        else if (hasLong) {
-            ndTy = type_manager_1.naslLongTy;
-        }
-        else {
-            // 较大的类型
-            ndTy = env.unifier.nextFreshTyAnn('free');
-            env.unifier.unify(leftTy, ndTy);
-            env.unifier.unify(rightTy, ndTy);
-        }
+        // 较大的类型
+        ndTy = env.unifier.nextFreshTyAnn('free');
+        // 约束 ndTy 的上界为 Decimal
+        env.unifier.unify(ndTy, type_manager_1.naslDecimalTy);
+        // 约束 ndTy 的下界为 Long
+        env.unifier.unify(type_manager_1.naslLongTy, ndTy);
+        env.unifier.unify(leftTy, ndTy);
+        env.unifier.unify(rightTy, ndTy);
     }
     env.setType(nd, ndTy);
     env.unifier.unify(ndTy, tgtTy);
@@ -435,7 +437,7 @@ function tpBinaryExpression(env, nd, tgtTy) {
                         return ty;
                     if ((0, type_predicate_2.isMetadataType)(ty)) {
                         // 使用typeAlias来查找元数据类型的底层类型
-                        const qName = (0, get_q_name_1.getTokenQualifiedName)(ty);
+                        const qName = (0, def_key_helpers_1.getGlobalDefKey)(ty);
                         if (qName && env.typeAlias.has(qName)) {
                             return env.typeAlias.get(qName);
                         }
@@ -506,10 +508,9 @@ function tpBinaryExpression(env, nd, tgtTy) {
         }
         case 'in': {
             const leftTy = dispatchExpr(env, nd.left, undefined);
-            const rightTy = dispatchExpr(env, nd.right, undefined);
+            dispatchExpr(env, nd.right, (0, type_manager_1.createListTyAnn)(leftTy ?? type_manager_1.naslAnyTy));
             // T in List<T>
             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;
         }
@@ -644,7 +645,7 @@ const tpBinaryOrderExpr = (env, nd, tgtTy) => {
         if ((0, type_predicate_1.isUnionTy)(ty)) {
             return ty.typeArguments?.every(memberTy => isValidTy(memberTy)) ?? false;
         }
-        const qName = (0, get_q_name_1.getTokenQualifiedName)(ty);
+        const qName = (0, def_key_helpers_1.getGlobalDefKey)(ty);
         return !!qName && env.typeAlias.has(qName);
     };
     // 不调用 solver 则无法判断，调用则影响速度，所以报错后移了
@@ -779,63 +780,92 @@ const tpAnonymousFunction = (env, nd, _tgtTy, isListSort = false) => {
 };
 exports.tpAnonymousFunction = tpAnonymousFunction;
 const tpSubLogic = (env, nd, tgtTy, isListSort = false) => {
-    const subLogicVars = [...nd.params, ...nd.returns, ...nd.variables];
-    env.refMgr.setLocalSymBindings(nd, subLogicVars);
-    subLogicVars.forEach(v => (0, dispatch_def_1.dispatchDef)(env, v));
-    // 处理 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);
-    }
-    // 如果有 tgtTy 且是函数类型，则进行 unification
-    if (tgtTy && (0, type_predicate_2.isFuncTy)(tgtTy)) {
-        // TODO: 通过 default value 生成 constraints
-        nd.params.forEach((param, idx) => {
-            // v4.1 AI 相关需求要求它也能推
-            const paramTy = env.getRawType(param);
-            env.unifier.unifyContravariant(paramTy, tgtTy.typeArguments[idx], param); // contravariant
-        });
-    }
-    // 若非前端，则 shallow copy，因为内部会触发 solve，会把进来前的约束清掉；
-    // 若是前端，则无需 copy
-    const csCopy = env.isView ? env.unifier.cs : new Map(env.unifier.cs);
-    // 直接用 Solver 求解约束，并仅把求解结果代回到 SubLogic 的 params（避免 traverseSubstRunCheck 对 Identifier 的假设）
-    if (!env.isView) {
-        // 使用局部 Solver
-        const localSolver = new solver_1.Solver(env);
-        const subst = localSolver.simpleSolveConstraints();
-        // 只替换 nd.params 上的类型变元
-        const pSubst = (0, subster_1.inPlaceSubstTyAnn)(env, subst);
-        for (const param of nd.params) {
-            const rawTy = env.getRawType(param);
-            if (rawTy) {
-                const replaced = pSubst(rawTy);
-                env.setType(param, replaced);
-            }
+    return env.withPostCheckScope(() => {
+        // 保持与 tpAnonymousFunction 一致：先展开 expected function type 中的 tuple spread
+        const expectedTy = tgtTy ? desugarTupleSpreadInArgsOfFunctionType(tgtTy) : undefined;
+        // 仅对"表达式中的临时 SubLogic"（TS arrow-function block 解析产物）做参数类型的"预填充"：
+        // - 让 tpParam 直接用 expected type，而不是先生成 free type var
+        // - 保证闭包捕获变量（如外层 record 参数）具备正确成员类型，避免 Any 化
+        if (expectedTy && (0, type_predicate_2.isFuncTy)(expectedTy) && typeof nd.name === 'string' && nd.name.startsWith('$anon$')) {
+            nd.params.forEach((param, idx) => {
+                const exp = expectedTy.typeArguments?.[idx];
+                if (!exp)
+                    return;
+                if (!param.typeAnnotation) {
+                    param.typeAnnotation = (0, type_manager_1.copyTyAnn)(exp);
+                }
+            });
         }
-        // 运行后置校验并把 postChecks 触发
-        const normalizedSemTyMap = (0, subster_1.traverseAndSubst)(env)(nd, subst);
-        const errs = localSolver.postCheckSolution(subst, localSolver.cs, normalizedSemTyMap) || [];
-        if (errs.length > 0) {
-            for (const err of errs) {
-                env.addError(err.message, env.getCurFileNode(), err.errBoundary, err.fromPlayground ? 'warning' : 'error');
-            }
+        const subLogicVars = [...nd.params, ...nd.returns, ...nd.variables];
+        env.refMgr.setLocalSymBindings(nd, subLogicVars);
+        subLogicVars.forEach(v => (0, dispatch_def_1.dispatchDef)(env, v));
+        // 处理 tgtTy 缺失的情况
+        if (expectedTy && !(0, type_predicate_2.isTyAnnTyParam)(expectedTy) && !(0, type_predicate_2.isFuncTy)(expectedTy) && !isListSort) {
+            env.setType(nd, type_manager_1.naslAnyTy);
+            env.addError((0, sem_diag_1.mkIncompatibleTyErr)(env, '函数', expectedTy));
+            return (0, type_manager_1.createFnTyFromTyAnns)([], type_manager_1.naslAnyTy);
+        }
+        // 如果有 tgtTy 且是函数类型，则进行 unification
+        if (expectedTy && (0, type_predicate_2.isFuncTy)(expectedTy)) {
+            // 对于“作为表达式出现的 SubLogic”（例如由 TS arrow-function block 生成），通常没有显式参数类型。
+            // 只做 contravariant unify 很难把参数类型从 expected type 传播进来，进而导致闭包捕获变量上的成员访问类型变成 Any。
+            // 因此：当参数未声明类型（或当前是 Any/未解），先用 expected param type 填充。
+            nd.params.forEach((param, idx) => {
+                const expected = expectedTy.typeArguments?.[idx];
+                if (!expected)
+                    return;
+                const cur = env.getRawType(param);
+                if (!param.typeAnnotation && (!cur || (0, type_predicate_2.isAnyTy)(cur) || (0, type_predicate_1.isUnResolvedTy)(cur))) {
+                    env.setType(param, expected);
+                }
+            });
+            // TODO: 通过 default value 生成 constraints
+            nd.params.forEach((param, idx) => {
+                // v4.1 AI 相关需求要求它也能推
+                const paramTy = env.getRawType(param);
+                env.unifier.unifyContravariant(paramTy, expectedTy.typeArguments[idx], param); // contravariant
+            });
         }
-        env.runPostChecks(subst);
-    }
-    (0, dispatch_stmt_2.tpSolvingStmts)(env, nd.body);
-    (0, dispatch_stmt_1.tpSolvingPlayground)(env, nd.playground);
-    subLogicVars.forEach(env.removeLexicalSym);
-    const ndTy = (0, type_manager_1.createRefTyAnnFromDef)(nd, env);
-    if (tgtTy && ndTy.typeKind === 'function') {
-        // 从 expected type 上 copy sync 字段，保证 SubLogic 的函数类型和 Param 处声明的字段一致
-        ndTy.sync = tgtTy.sync;
-    }
-    env.setType(nd, ndTy);
-    env.unifier.cs = csCopy;
-    !isListSort && env.unifier.unify(ndTy, tgtTy); // 这里需要额外的 unify，否则 SubLogic 算出来的类型不能与外侧进来时的约束产生关系
-    return ndTy;
+        // 若非前端，则 shallow copy，因为内部会触发 solve，会把进来前的约束清掉；
+        // 若是前端，则无需 copy
+        const csCopy = env.isView ? env.unifier.cs : new Map(env.unifier.cs);
+        // 直接用 Solver 求解约束，并仅把求解结果代回到 SubLogic 的 params（避免 traverseSubstRunCheck 对 Identifier 的假设）
+        if (!env.isView) {
+            // 使用局部 Solver
+            const localSolver = new solver_1.Solver(env);
+            const subst = localSolver.simpleSolveConstraints();
+            // 只替换 nd.params 上的类型变元
+            const pSubst = (0, subster_1.inPlaceSubstTyAnn)(env, subst);
+            for (const param of nd.params) {
+                const rawTy = env.getRawType(param);
+                if (rawTy) {
+                    const replaced = pSubst(rawTy);
+                    env.setType(param, replaced);
+                }
+            }
+            // 运行后置校验并把 postChecks 触发
+            const normalizedSemTyMap = (0, subster_1.traverseAndSubst)(env)(nd, subst);
+            const errs = localSolver.postCheckSolution(subst, localSolver.cs, normalizedSemTyMap) || [];
+            if (!env.isErrorReportingDisabled() && !env.hasErrorDelegatee) {
+                for (const err of errs) {
+                    env.addError(err.message, env.getCurFileNode(), err.errBoundary, err.fromPlayground ? 'warning' : 'error');
+                }
+            }
+            env.runPostChecks(subst);
+        }
+        (0, dispatch_stmt_2.tpSolvingStmts)(env, nd.body);
+        (0, dispatch_stmt_1.tpSolvingPlayground)(env, nd.playground);
+        subLogicVars.forEach(env.removeLexicalSym);
+        const ndTy = (0, type_manager_1.createRefTyAnnFromDef)(nd, env);
+        if (expectedTy && ndTy.typeKind === 'function') {
+            // 从 expected type 上 copy sync 字段，保证 SubLogic 的函数类型和 Param 处声明的字段一致
+            ndTy.sync = expectedTy.sync;
+        }
+        env.setType(nd, ndTy);
+        env.unifier.cs = csCopy;
+        !isListSort && env.unifier.unify(ndTy, expectedTy); // 这里需要额外的 unify，否则 SubLogic 算出来的类型不能与外侧进来时的约束产生关系
+        return ndTy;
+    });
 };
 exports.tpSubLogic = tpSubLogic;
 function tpArgument(env, nd, tgtTy) {
@@ -918,8 +948,9 @@ function tpCallQueryComponent(env, nd, tgtTy) {
     };
     env.ctxCQC = nd;
     env.ctxTpQFE = makeTpQueryFieldExpr;
+    const hasJoin = nd.from?.joinParts?.length > 0;
     // typing expressions in nd.from.joinsParts
-    if (nd.from?.joinParts.length > 0) {
+    if (hasJoin) {
         tpJoinParts(env, nd.from.joinParts);
     }
     // this will also set aggrAsNames, groupByAsNames
@@ -1061,7 +1092,13 @@ function tpCallQueryComponent(env, nd, tgtTy) {
                     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(string_1.lowercaseFirstChar), tys));
+            // 如果没有 join 且只有一个实体，直接返回该实体的类型，不包匿名结构
+            if (nd.simplifyType && !hasJoin && selShortNames.length === 1) {
+                retTy = (0, type_manager_1.createListTyAnn)(tys?.[0] || type_manager_1.naslAnyTy);
+            }
+            else {
+                retTy = (0, type_manager_1.createListTyAnn)((0, type_manager_1.createAnonymousTyAnn)(selShortNames.map(string_1.lowercaseFirstChar), tys));
+            }
         }
         // 2.11 之前才有，升级脚本也没管，需要特殊处理
         if (nd.limit) {
@@ -1138,6 +1175,7 @@ function tpCallQueryComponent(env, nd, tgtTy) {
             case 'COUNTD':
                 return type_manager_1.naslLongTy;
             case 'AVG':
+                env.unifier.unify(propTy, type_manager_1.naslDecimalOrLongTy);
                 return type_manager_1.naslDecimalTy;
             default:
                 return propTy;
@@ -1197,15 +1235,26 @@ function tpOqlQueryComponent(env, nd, tgtTy) {
         }
         const logicNd = parser.parseInLogicContext(`const $queryResult$ = ${code};`, '$queryResult$');
         if (logicNd) {
-            logicNd.name = 'test';
-            env.suppressErrorReporting();
+            logicNd.parentNode = nd;
+            logicNd.name = 'oqlTempLogic';
+            env.setErrorDelegatee(nd);
             const oldCS = env.unifier.cs;
             // 对 dispatchDef 的调用，会修改 env.unifier.cs。因此需要给他一个全新的cs，避免污染正常的cs
             const newCS = new Map();
             env.unifier.cs = newCS;
-            (0, dispatch_def_1.dispatchDef)(env, logicNd);
-            env.unifier.cs = oldCS;
-            env.enableErrorReporting();
+            try {
+                (0, dispatch_def_1.tpLogic)(env, logicNd);
+            }
+            catch (err) {
+                // 打印下错误，便于排查
+                env.logger?.fatal?.('[tpOqlQueryComponent] error:', err);
+            }
+            finally {
+                // @ts-expect-error
+                logicNd.parentNode = null;
+                env.unifier.cs = oldCS;
+                env.resetErrorDelegatee();
+            }
             if (nd.typeAnnotation) {
                 // 有类型标注，直接用
                 env.setType(nd, nd.typeAnnotation);
@@ -1286,17 +1335,19 @@ function tpNewComposite(env, nd, tgtTy) {
         if (right && (0, nasl_type_manipulation_1.isEnumIdentifier)(right)) {
             env.addError(`新建表达式中 ${right.toNaturalTS()} 枚举类不能直接使用，请取它的枚举项`, undefined, right);
         }
-        env.unifier.unifyWithBoundary(rTy, lPropTyAnn, right);
+        // 传递当前这条连线，以便在错误报告中记录是哪条连线导致的错误
+        const context = { assignmentLine: line };
+        env.unifier.unifyWithBoundary(rTy, lPropTyAnn, right, context);
     });
     const properties = toRaws(nd.properties);
     // 没连线的左边的元素们。其实无所谓，但要跟现在保持一致。
     properties.forEach((pIdent) => {
         if (!env.typeBindings.get(pIdent)) {
             let lPropTyAnn = lNameTyPair.find(([name, _]) => name === pIdent.name)?.[1];
-            // setType 应该够了，直接 dispatchExpr 会因为 pIdent 没有加到 env.lexicalVarStacks 里，导致找不到而报错
+            // setType 应该够了，直接 dispatchExpr 会因为 pIdent 没有加到 env.localDefStacks 里，导致找不到而报错
             if (!lPropTyAnn) {
                 if (nd.typeAnnotation?.typeKind === 'anonymousStructure') {
-                    lPropTyAnn = type_manager_1.naslStringTy;
+                    lPropTyAnn = tgtTy?.properties?.find((p) => p.name === pIdent.name)?.typeAnnotation ?? type_manager_1.naslStringTy;
                 }
                 else {
                     lPropTyAnn = env.unifier.nextFreshTyAnn('free');
@@ -1330,7 +1381,7 @@ const extractNameTyPair = (env, ty) => {
         return ty.properties.map((p, _) => [p.name, p.typeAnnotation]);
     }
     else if (ty) {
-        return (0, fp_macros_1.IfBind)((0, get_q_name_1.getTokenQualifiedName)(ty))(qName => env.refMgr.gQNameDefs.get(qName)
+        return (0, fp_macros_1.IfBind)((0, def_key_helpers_1.getGlobalDefKey)(ty))(qName => env.refMgr.gQNameDefs.get(qName)
             ?.properties
             .map((p, _) => [p.name, p.typeAnnotation ?? null]))((0, fp_macros_1.feed)([]));
     }
@@ -1354,11 +1405,17 @@ function tpNewList(env, nd, tgtTy) {
         env.setType(nd, nd.typeAnnotation);
     }
     else {
-        const itemTys = toRaws(nd.items).map(item => dispatchExpr(env, item, undefined)).filter(Boolean);
-        const itemUnionTy = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, itemTys);
+        const isTgtTyLegal = (0, type_predicate_2.isListTy)(tgtTy);
+        const itemTys = toRaws(nd.items).map(item => dispatchExpr(env, item, undefined)).filter((ty) => {
+            if (!ty)
+                return false;
+            return !isTgtTyLegal || !(0, type_predicate_2.isAnyTy)(ty);
+        });
+        // 页面下是延迟求解的，此处如果加上合法性判断，会导致从左到右的推导失效
+        const itemUnionTy = !itemTys.length ? env.unifier.nextFreshTyAnn('free') : (0, type_manager_1.createUnionTyAnnIfNecessary)(env, itemTys);
         const listTy = (0, type_manager_1.createListTyAnn)(itemUnionTy);
         // TODO: 不精确的检查，如果 tgtTy 是 A | List<T>，则会走到下一个分支，就没要求 invariance 了，以后再修吧
-        if ((0, type_predicate_2.isListTy)(tgtTy)) {
+        if (isTgtTyLegal) {
             const tgtItemTy = tgtTy.typeArguments?.[0];
             env.unifier.unifyEq(itemUnionTy, tgtItemTy);
         }
@@ -1409,18 +1466,36 @@ function tpNewMap(env, nd, tgtTy) {
         return nd.typeAnnotation;
     }
     else {
-        const valFv = env.unifier.nextFreshTyAnn('free');
+        const isTgtTyLegal = (0, type_predicate_2.isMapTy)(tgtTy);
+        let tgtKeyTy = undefined;
+        let tgtValTy = undefined;
+        if (isTgtTyLegal) {
+            tgtKeyTy = tgtTy?.typeArguments?.[0];
+            tgtValTy = tgtTy?.typeArguments?.[1];
+        }
         const keys = toRaws(nd.keys);
         const firstKeyTy = dispatchExpr(env, keys[0], undefined);
+        const hasFirstKeyTy = firstKeyTy && !(0, type_predicate_2.isAnyTy)(firstKeyTy);
+        // 页面下是延迟求解的，如果没有推导出 key 类型，使用 fresh type variable
+        const keyTy = hasFirstKeyTy ? firstKeyTy : tgtKeyTy ?? env.unifier.nextFreshTyAnn('free');
         for (let i = 1; i < keys.length; i++) {
-            dispatchExpr(env, keys[i], firstKeyTy); // 内部会产生类型不匹配的报错
+            dispatchExpr(env, keys[i], keyTy); // 内部会产生类型不匹配的报错
         }
         // 规定：key 类型不能是 union。仅 value 类型可以是 union。
-        const valTys = toRaws(nd.values).map(value => dispatchExpr(env, value, undefined)).filter(Boolean);
-        const valUnionTys = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, valTys);
+        const valTys = toRaws(nd.values).map(value => dispatchExpr(env, value, undefined)).filter((ty) => {
+            if (!ty)
+                return false;
+            return !isTgtTyLegal || !(0, type_predicate_2.isAnyTy)(ty);
+        });
+        const hasValTy = valTys.length > 0;
+        const valUnionTys = hasValTy ? (0, type_manager_1.createUnionTyAnnIfNecessary)(env, valTys) : tgtValTy ?? type_manager_1.naslAnyTy;
+        // 都是“indexedAccess”的情况，需要用 fresh 类型去约束
+        const valFv = env.unifier.nextFreshTyAnn('free');
         env.unifier.unify(valUnionTys, valFv);
-        const mapTy = (0, type_manager_1.createMapTyAnn)(firstKeyTy ?? type_manager_1.naslAnyTy, valFv);
-        env.unifier.unify(mapTy, tgtTy);
+        const mapTy = (0, type_manager_1.createMapTyAnn)(keyTy, valFv);
+        if (hasFirstKeyTy || hasValTy) {
+            env.unifier.unify(mapTy, tgtTy);
+        }
         env.setType(nd, mapTy);
         return mapTy;
     }
@@ -1446,6 +1521,8 @@ function tpMatch(env, nd, tgtTy) {
     const exprTy = nd.isExpression ?
         dispatchExpr(env, nd.expression, undefined) :
         tpSolvingExpr(env, nd.expression, undefined);
+    // 类型匹配，必须加上isTypeMatch 判断，否则值匹配时会错误地用值的类型去约束未解析类型，类型细化也将基于错误的类型
+    const isTypeMatch = nd.cases.some(caseItem => caseItem.patterns.length > 0 && caseItem.patterns.every((p) => (0, type_predicate_1.isTypeAnnotation)(p)));
     const tpMatchTypeRefineCase = (nd, exprTy) => (mc) => {
         let exprRefinedTy = exprTy;
         // mc.patterns 中可能包含类型模式和值模式，分别对应类型匹配和值匹配。
@@ -1469,14 +1546,32 @@ function tpMatch(env, nd, tgtTy) {
             const prevPatterns = prevCases.flatMap((pc) => pc.patterns);
             const pureTys = prevPatterns.filter((x) => (0, type_predicate_1.isTypeAnnotation)(x));
             // 确保我们在处理纯类型的匹配。值匹配不用任何精化。
-            if (pureTys.length === prevPatterns.length) {
-                const caseRefinedTys = (0, type_predicate_1.isUnionTy)(exprTy)
-                    ? exprTy?.typeArguments?.filter((t1) => !pureTys.find((t2) => (0, type_predicate_1.isEqualTy)(env, t1, t2)))
-                    : [];
-                if (caseRefinedTys?.length) {
-                    exprRefinedTy = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, caseRefinedTys); // TODO 报错
+            if (pureTys.length === prevPatterns.length && pureTys.length > 0) {
+                if ((0, type_predicate_1.isUnionTy)(exprTy)) {
+                    // exprTy 是 union 类型，直接计算差集
+                    const caseRefinedTys = exprTy?.typeArguments?.filter((t1) => !pureTys.find((t2) => (0, type_predicate_1.isEqualTy)(env, t1, t2)));
+                    if (caseRefinedTys?.length) {
+                        exprRefinedTy = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, caseRefinedTys);
+                    }
+                }
+                else {
+                    // exprTy 不是 union 类型（可能是类型参数），创建 Exclude 代类型延迟求解
+                    const excludedUnion = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, pureTys);
+                    exprRefinedTy = nasl_concepts_1.TypeAnnotation.createProtoTypeOnly({
+                        typeKind: 'generic',
+                        typeName: 'Exclude',
+                        typeArguments: [exprTy, excludedUnion],
+                    });
                 }
             }
+            // 值匹配
+            if (!isTypeMatch) {
+                toRaws(mc.patterns).forEach(pattern => {
+                    env.withPostCheckScope(() => {
+                        tpSolvingExpr(env, pattern, exprRefinedTy);
+                    });
+                });
+            }
         }
         const allocatedVars = new Set();
         const itVar = nasl_concepts_1.Variable.createProtoTypeOnly({
@@ -1486,9 +1581,9 @@ function tpMatch(env, nd, tgtTy) {
         }); // 新加的每个分支里的 'it' 变量
         allocatedVars.add(itVar);
         let matchedVarName = undefined;
-        const isRefined = shouldRefineType(nd.expression, exprTy);
+        const isRefined = shouldRefineType(nd.expression, isTypeMatch);
         if (isRefined) {
-            matchedVarName = (0, get_q_name_1.getTokenQualifiedNameForMatchedExpr)(env, nd.expression);
+            matchedVarName = (0, def_key_helpers_1.getGlobalDefKeyForMatchedExpr)(env, nd.expression);
             const freshMatchedVar = nasl_concepts_1.Variable.createProtoTypeOnly({
                 name: matchedVarName,
                 typeAnnotation: exprRefinedTy,
@@ -1521,30 +1616,7 @@ function tpMatch(env, nd, tgtTy) {
         }
     };
     if (exprTy) {
-        for (const cs of nd.cases) {
-            for (const p of cs.patterns) {
-                if (!(0, type_predicate_1.isTypeAnnotation)(p)) {
-                    dispatchExpr(env, p, undefined);
-                }
-            }
-        }
-        // 类型匹配，必须加上isTypeMatch 判断，否则值匹配时会错误地用值的类型去约束未解析类型，类型细化也将基于错误的类型
-        const isTypeMatch = nd.cases.some((caseItem) => {
-            return caseItem.patterns.length > 0 && caseItem.patterns.every((p) => (0, type_predicate_1.isTypeAnnotation)(p));
-        });
-        // 只有当 exprTy 是未解析的类型（typeParam 或 indexedAccess）时，才需要从 patterns 构造 union 类型来约束它
-        if (isTypeMatch && ((0, type_predicate_2.isTyAnnTyParam)(exprTy) || (0, type_predicate_1.isIndexedType)(exprTy))) {
-            // 从已有的 match cases 的类型构造出 union-like type
-            const patTys = nd.cases.flatMap(c => c.patterns).map(getPatTy).filter(types_1.isNotNil);
-            for (const pTy of patTys) {
-                env.unifier.unify(pTy, exprTy); // 各个分支的类型的 union <: 类型变元
-            }
-            const unionTy = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, patTys);
-            handleMatchingAgainstTypes(unionTy);
-        }
-        else { // 如果 exprTy 已经是确定的类型（包括 union 类型），直接使用 exprTy 即可
-            handleMatchingAgainstTypes(exprTy);
-        }
+        handleMatchingAgainstTypes(exprTy);
     }
     // mark the type of the whole match construct
     if (nd.isExpression) {
@@ -1559,8 +1631,8 @@ function tpMatch(env, nd, tgtTy) {
         env.setType(nd, type_manager_1.naslVoidTy);
     }
     return env.getRawType(nd);
-    function handleMatchingAgainstTypes(unionTy) {
-        nd.cases.forEach(tpMatchTypeRefineCase(nd, unionTy));
+    function handleMatchingAgainstTypes(exprTy) {
+        nd.cases.forEach(tpMatchTypeRefineCase(nd, exprTy));
     }
     function getPatTy(x) {
         if ((0, type_predicate_1.isTypeAnnotation)(x)) {
@@ -1570,14 +1642,23 @@ function tpMatch(env, nd, tgtTy) {
         // 这不仅引人深思：为什么 1 的类型就不能随着上下文变化呢，而要 argument: Decimal argument.expr : Long
         // 那好了，match 这里其实是又要特殊处理的
     }
-    function shouldRefineType(nd, exprRefinedTy) {
+    function shouldRefineType(nd, isTypeMatch) {
         const validExpr = nd.concept === 'Identifier' || nd.concept === 'MemberExpression';
-        // 仅当输入是 union 类型或可以实例化为 union 类型的类型变元才进行 type refinement
-        const validTy = (0, type_predicate_1.isUnionTy)(exprRefinedTy) || (0, type_predicate_2.isTyAnnTyParam)(exprRefinedTy);
-        return validExpr && validTy;
+        return validExpr && isTypeMatch;
     }
 }
 exports.tpMatch = tpMatch;
+function tpIfExpression(env, nd, tgtTy) {
+    const conditionTy = dispatchExpr(env, nd.condition, type_manager_1.naslBooleanTy);
+    env.unifier.unify(conditionTy, type_manager_1.naslBooleanTy);
+    const consequentTy = dispatchExpr(env, nd.consequent, undefined);
+    const alternateTy = dispatchExpr(env, nd.alternate, undefined);
+    const ifTy = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, [consequentTy, alternateTy].filter(e => Boolean(e) && !(0, type_predicate_2.isAnyTy)(e)));
+    env.setType(nd, ifTy);
+    env.unifier.unify(ifTy, tgtTy);
+    return ifTy;
+}
+exports.tpIfExpression = tpIfExpression;
 function tpUnparsed(env, nd, tgtTy) {
     // should be bottom type，但是现在没有 bottom type 怎么办？
     // 按后端设成 string 的话前端各种骚用法会报错什么 [1, 2, 3] 这种，难道你要我 typeof eval(nd)?
@@ -1634,7 +1715,7 @@ function desugarAsCalling(env, originNd, qName, args) {
     const copied = (0, type_manager_1.copyTyAnn)(funcTy);
     // 首先展开函数类型，将spread参数转换为具体的参数列表
     const expandedFuncTy = expandFunctionTypeWithSpread(copied, args.length);
-    const expandedParams = extractParamsFromFunctionType(expandedFuncTy);
+    const expandedParams = (0, dispatch_call_1.extractParamsFromFunctionType)(expandedFuncTy);
     if (!expandedParams) {
         // 预期不会走到这里
         return;
@@ -1681,7 +1762,7 @@ function desugarAsCalling(env, originNd, qName, args) {
         if (!funcTy || funcTy.typeKind !== 'function') {
             return funcTy;
         }
-        const params = extractParamsFromFunctionType(funcTy);
+        const params = (0, dispatch_call_1.extractParamsFromFunctionType)(funcTy);
         if (!params) {
             return funcTy;
         }
@@ -1729,46 +1810,6 @@ function desugarAsCalling(env, originNd, qName, args) {
         }
         return expandedFuncTy;
     }
-    // TODO 考虑和dispatch-call里面的同名函数合并一下
-    /**
-     * 从函数类型中提取参数定义信息
-     *
-     * 这个函数解决了局部变量方法调用时无法获取参数定义（def）的问题。
-     * 通过分析函数类型的fnArgs和typeArguments，重构出Param对象，
-     * 使得可以正确判断参数是否为spread类型。
-     *
-     * @param fnTy 函数类型
-     * @returns 参数定义数组，包含name、typeAnnotation、spread等信息
-     */
-    function extractParamsFromFunctionType(fnTy) {
-        if (!(0, type_predicate_2.isFuncTy)(fnTy)) {
-            return undefined;
-        }
-        const params = [];
-        // 优先从fnArgs中提取参数信息，因为它包含参数名
-        if (fnTy.fnArgs && fnTy.fnArgs.length > 0) {
-            fnTy.fnArgs.forEach((arg, index) => {
-                const param = nasl_concepts_1.Param.createProtoTypeOnly({
-                    name: arg.name || `param${index + 1}`,
-                    typeAnnotation: arg.type,
-                    spread: arg.spread,
-                });
-                params.push(param);
-            });
-        }
-        else if (fnTy.typeArguments && fnTy.typeArguments.length > 0) {
-            // 如果没有fnArgs，从typeArguments中提取
-            fnTy.typeArguments.forEach((argType, index) => {
-                const param = nasl_concepts_1.Param.createProtoTypeOnly({
-                    name: `param${index + 1}`, // 默认参数名
-                    typeAnnotation: argType,
-                    spread: argType.spread
-                });
-                params.push(param);
-            });
-        }
-        return params;
-    }
 }
 function tpNewRegex(env, nd, tgtTy) {
     // 我们将对NewRegex的类型检查归约为对nasl.util.NewRegex(nd.pattern, nd.flags)的类型检查