@lcap/nasl-language-server-core 4.1.0-rc.8 → 4.1.0-rc.9

package/out/typer/dispatch-expr.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRightByLine = exports.removeErrTys = exports.tpEntityLogic = exports.tpMatch = exports.tpSolvingExpr = exports.extractNameTyPair = exports.tpCallConnector = exports.tpCallMicroserviceInterface = exports.tpCallAuthInterface = exports.tpCallInterface = exports.tpCallFunction = exports.changeArgTyToParamTy = exports.determineCallLogicFnTy = exports.tpCallLogic = exports.dispatchExpr = void 0;
+exports.getRightByLine = 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");
@@ -11,7 +11,6 @@ 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 service_1 = require("@lcap/nasl-concepts/service");
@@ -19,15 +18,13 @@ 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 dispatch_process_1 = require("./dispatch-process");
 const dispatch_view_1 = require("./dispatch-view");
 const subster_2 = require("./subster");
-const parseTsClassType_1 = require("../utils/parseTsClassType");
 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");
+const dispatch_call_1 = require("./dispatch-call");
 // speed consideration
 function dispatchExpr(env, nd, tgtTy) {
     if (!nd) {
@@ -46,15 +43,16 @@ function dispatchExpr(env, nd, tgtTy) {
             case 'NullLiteral': return tpNullLiteral(env, nd, tgtTy);
             case 'Function': return tpFunction(env, nd, tgtTy); // 历史兼容
             case 'DefaultValue': return tpDefaultValue(env, nd, tgtTy);
-            case 'CallLogic': return tpCallLogic(env, nd, tgtTy);
-            case 'CallFunction': return tpCallFunction(env, nd, tgtTy);
+            case 'CallLogic': return (0, dispatch_call_1.tpCallLogic)(env, nd, tgtTy);
+            case 'CallFunction': return (0, dispatch_call_1.tpCallFunction)(env, nd, tgtTy);
             case 'CallEvent': return (0, dispatch_view_1.tpCallEvent)(env, nd, tgtTy);
-            case 'CallInterface': return tpCallInterface(env, nd, tgtTy);
-            case 'CallMicroserviceInterface': return (0, exports.tpCallMicroserviceInterface)(env, nd, tgtTy);
-            case 'CallAuthInterface': return (0, exports.tpCallAuthInterface)(env, nd, tgtTy);
+            case 'CallInterface':
+            case 'CallAuthInterface':
+            case 'CallMicroserviceInterface':
+            case 'CallGatewayInterface': return (0, dispatch_call_1.tpCallInterface)(env, nd, tgtTy);
             case 'CallQueryComponent': return tpCallQueryComponent(env, nd, tgtTy);
             // @ts-ignore
-            case 'CallConnector': return (0, exports.tpCallConnector)(env, nd, tgtTy);
+            case 'CallConnector': return (0, dispatch_call_1.tpCallLogic)(env, nd, tgtTy);
             case 'Argument': return tpArgument(env, nd, tgtTy);
             case 'ValidationRule': return (0, dispatch_view_1.tpViewValidationRule)(env, nd);
             case 'NewComposite': return tpNewComposite(env, nd, tgtTy);
@@ -62,8 +60,8 @@ function dispatchExpr(env, nd, tgtTy) {
             case 'NewMap': return tpNewMap(env, nd, tgtTy);
             case 'Match': return tpMatch(env, nd, tgtTy);
             case 'StringInterpolation': return tpStringInterpolation(env, nd, tgtTy);
-            case 'AnonymousFunction': return tpAnonymousFunction(env, nd, tgtTy);
-            case 'SubLogic': return tpSubLogic(env, nd, tgtTy);
+            case 'AnonymousFunction': return (0, exports.tpAnonymousFunction)(env, nd, tgtTy);
+            case 'SubLogic': return (0, exports.tpSubLogic)(env, nd, tgtTy);
             case 'Unparsed': return tpUnparsed(env, nd, tgtTy);
             case 'QueryFieldExpression': return fakeTpQueryFieldExpression(env, nd, tgtTy);
             case 'Paginate': return tpPaginate(env, nd, tgtTy);
@@ -155,7 +153,7 @@ function tpNumericLiteral(env, nd, tgtTy) {
 function tpStringInterpolation(env, nd, tgtTy) {
     nd.expressions.forEach((expr) => {
         // HACK: 动态拖入一个表达式的时候，在 expressions 数组中是 proxied
-        return dispatchExpr(env, toRaw(expr), undefined);
+        return dispatchExpr(env, (0, dispatch_stmt_1.toRaw)(expr), undefined);
     });
     env.setType(nd, type_manager_1.naslStringTy);
     env.unifier.unify(type_manager_1.naslStringTy, tgtTy);
@@ -637,7 +635,7 @@ const tpBinaryOrderExpr = (env, nd, tgtTy) => {
         if (!ty) {
             return false;
         }
-        if ((0, type_predicate_2.isPrimitiveTy)(ty) && orderableTyNames.includes(ty.typeName)) {
+        if ((0, type_predicate_2.isPrimitiveTy)(ty) && orderableTyNames.includes(ty.typeName) || (0, type_predicate_2.isNullTy)(ty) || (0, type_predicate_2.isAnyTy)(ty)) {
             return true;
         }
         // 支持Union类型：如果所有成员都是可排序类型，则Union类型也是可排序的
@@ -688,474 +686,7 @@ function tpUnaryExpression(env, nd, tgtTy) {
         return env.getRawType(nd);
     }
 }
-function isEntityLogic(nsp) {
-    return nsp.startsWith('app.dataSources.') && nsp.endsWith('logics') && /\.entities\./.test(nsp);
-}
-function isLoggingLogic(nsp) {
-    return nsp === 'nasl.logging';
-}
-function tpCallLogic(env, nd, tgtTy) {
-    if (!nd.calleeName) {
-        return undefined;
-    }
-    // 特殊处理咯 ad hoc treatment for entity logics
-    if (isEntityLogic(nd.calleeNamespace)) {
-        return tpEntityLogic(env, nd, tgtTy);
-    }
-    // 特殊处理咯，你自己看看你的 Call 的 NASL 和定义能对得上一毫米吗？
-    if (isLoggingLogic(nd.calleeNamespace)) {
-        // Use a different approach to avoid the parameter issues
-        for (const arg of nd.arguments) {
-            dispatchExpr(env, arg, type_manager_1.naslAnyTy);
-        }
-        env.setType(nd, type_manager_1.naslVoidTy);
-        return env.getRawType(nd);
-    }
-    let def;
-    if (nd.calleeNamespace !== 'nasl.util') {
-        def = env.resolveRef(nd);
-    }
-    else {
-        // 'nasl.util' 时 是 json 序列化
-        def = env.quickGetLibDef(nd, nd.calleeName, undefined);
-    }
-    // 处理调用处的验证规则
-    if (nd.validation?.rules && nd.validation.rules.length > 0 && def) {
-        def.params.forEach(param => (0, dispatch_def_1.dispatchDef)(env, param));
-        nd.validation?.rules?.forEach(rule => (0, dispatch_stmt_1.dispatchStmt)(env, rule));
-        def.params.forEach(env.removeVar);
-    }
-    if ((0, symbol_type_1.isProcessLogicCall)(nd.calleeNamespace) && (0, symbol_type_1.isSpecialProcessLogic)(nd.calleeName)) {
-        return (0, dispatch_process_1.tpSpecialProcessLogicCall)(env, nd, tgtTy);
-    }
-    // 余下的流程逻辑比较正常，就走正常的 CallLogic 处理流程好了
-    let fnTy = determineCallLogicFnTy(env, nd, def);
-    if (!fnTy) {
-        // TODO fnTy 可能为undefined 或 typeKind!=function, 需要考虑
-        env.addError(`无法找到逻辑 ${nd.calleeName}`);
-        return;
-    }
-    if (fnTy.typeParams?.length) {
-        fnTy = renameAndMakePartialTyApp(env, fnTy, nd);
-    }
-    // typing arguments
-    for (const [idx, parTy] of fnTy.typeArguments.entries()) {
-        // 先获取 param，因为 spread 属性在 param 上，而不是在 parTy 上
-        let param = def ? def.params?.[idx] : undefined;
-        if (param?.spread) {
-            // 按照约定，spread为true时，其上TypeAnnotation就已经是List<T>中的T。
-            // CallFunction因为大都是从TS parse出来，原样写入List<T>，因此可以看到tpCallFunction中仍然获取了List中的T
-            // TODO 修正 spread 相关的 TS parse，让两边一致
-            const elemTy = parTy;
-            // 余下的一并处理
-            for (let i = idx; i < nd.arguments.length; ++i) {
-                const arg = nd.arguments[i];
-                if (arg?.expression) {
-                    dispatchExpr(env, arg, elemTy);
-                    changeArgTyToParamTy(env, arg, elemTy);
-                }
-                else {
-                    env.setType(arg, type_manager_1.naslAnyTy);
-                }
-            }
-            break; // spread 参数处理完毕，跳出循环
-        }
-        else {
-            // TODO: json序列化等没有 def，导致 param 直接 undefined
-            const arg = nd.arguments[idx];
-            if (!arg) {
-                env.setType(nd, type_manager_1.naslAnyTy);
-                continue;
-            }
-            if (arg?.expression) {
-                dispatchExpr(env, arg, parTy);
-                changeArgTyToParamTy(env, arg, parTy);
-            }
-            else if (param) {
-                if (param.optional || parTy.optional) { // 组件逻辑等现在没有 def，用 type 判断
-                    env.setType(arg, parTy);
-                }
-                else if (param.defaultValue?.expression) {
-                    env.setType(arg, parTy);
-                }
-                else {
-                    // 报错：泛型逻辑调用，最后的 callInfo 里有 type variables，会被判定为 unresolved，目前不检查 arg 会缺少报错
-                    // env.addError(`调用逻辑：参数不能为空`, env.getCurFileNode(), arg);
-                    env.setType(arg, type_manager_1.naslAnyTy);
-                }
-            }
-            else {
-                // 报错
-                env.setType(arg, type_manager_1.naslAnyTy);
-            }
-        }
-    }
-    let finalRetTy = fnTy.returnType?.[0];
-    // CallConnector 不支持 handleError 错误处理参数
-    if (nd.concept !== 'CallConnector') {
-        if (nd.handleError === true) {
-            dispatchExpr(env, nd.errorMessage, undefined);
-        }
-        else {
-            // 做了手动处理 Error 需求后，需要 remove Error types from return types
-            finalRetTy = (0, exports.removeErrTys)(env, nd, fnTy?.returnType?.[0]);
-        }
-    }
-    env.unifier.unify(finalRetTy, tgtTy);
-    env.setType(nd, finalRetTy);
-    // 给 checker 报错用，都给吧，CallLogic 也有要处理 Error | T 返回类型的复杂情形，checker 直接拿结果就行不用重复处理
-    // TODO: 前端的部分组件逻辑好像指飞了（env.resoleRef 和 env.resolvedCallInfo 结果不一样）……先用 !env.isView 判断一下
-    if (!env.isView || nd.calleeNamespace === 'nasl.util') { // json 序列化 - similarly add param info for nasl.util
-        const callInfo = (0, type_manager_1.createFunctionDef)(fnTy.typeArguments, finalRetTy, def, fnTy.typeParams);
-        env.resolvedCallInfo.set(nd, callInfo);
-    }
-    if (fnTy.typeParams?.length) {
-        env.addPostCheckTask(nd, (e, pSubst) => {
-            // 写入 __TypeArguments 字段，调用泛型依赖库时，代码生成要用。
-            const typeArgs = fnTy?.typeParams
-                ?.map((x) => {
-                return e.getType(pSubst(x));
-            })
-                .filter(types_1.isNotNil) ?? [];
-            // 写入来自：_getQuickInfoNodesTypeMapWithGenerator
-            nd.__TypeArguments = typeArgs;
-        });
-    }
-    return finalRetTy;
-}
-exports.tpCallLogic = tpCallLogic;
-function determineCallLogicFnTy(env, nd, def) {
-    if (def && (0, service_1.isCallableNaslLogic)(def)) {
-        // TODO zzr 需要用个 cache 加快速度吗
-        return env.getRawType(def);
-    }
-    else {
-        const qName = (0, get_q_name_1.getTokenQualifiedName)(nd);
-        if (!qName) {
-            return undefined;
-        }
-        const placeholderFnTy = createAndSetForwardReferencePlaceholder(env, nd);
-        // @ts-expect-error
-        if (def?.concept === 'TypeAnnotation') {
-            // 令根据根据本次 Call 计算得出的类型为 placeholderFnTy
-            // 所有出现 placeholderFnTy 的地方，都可以被 def 替换，因此 def 为 placeholderFnTy 的子类型
-            env.unifier.unify(def, placeholderFnTy);
-        }
-        else {
-            if (env.isDebugMode) {
-                // FIXME wudengke 修复use before def的问题，debug模式下先报出来。
-                env.addDiagnosticsFor(`[DEBUG] determineCallLogicFnTy: 可能出现了use before def。 ${qName}`, nd);
-            }
-        }
-        return placeholderFnTy;
-    }
-}
-exports.determineCallLogicFnTy = determineCallLogicFnTy;
-function changeArgTyToParamTy(env, nd, parTy) {
-    // 初始时， nd.type === nd.expression.type
-    // FIXME: 例如后端需要 argument.type 与 argument.expression.type 不一样做 long -> decimal 的强制转换
-    // 这里有个问题，JSON 序列化不是 CallFunction 是 CallLogic，所以会走到这里
-    // 但是它 的 paramTy 是 NASL 不存在的类型 Any，炸裂还是得用 argTy
-    if (!(0, type_predicate_2.isAnyTy)(parTy)) {
-        env.setType(nd, parTy);
-    }
-    // Magic！
-    nd.paramTypeAnnotation = parTy;
-}
-exports.changeArgTyToParamTy = changeArgTyToParamTy;
-function renameAndMakePartialTyApp(env, fnTy, nd) {
-    // 先 rename bound type variables
-    if ((0, type_predicate_1.isUnResolvedTy)(fnTy)) {
-        fnTy = (0, type_manager_1.copyTyAnn)(fnTy);
-        env.unifier.inPlaceRenameTy(fnTy);
-    }
-    // 再做 type arguments partial application
-    // 用户选定部分 type params，这一块 Java 依赖库好像还有特殊处理，估计之后要大改
-    // 事实证明 Add 这种函数 nd.typeArguments 是 null 不是空数组 []
-    if (nd.typeArguments && nd.typeArguments.length > 0) {
-        if (fnTy.typeParams) {
-            const subst = new Map();
-            nd.typeArguments.forEach((ty, idx) => {
-                if (ty.typeName && ty.typeKind) {
-                    fnTy.typeParams[idx] && subst.set(fnTy.typeParams[idx].typeName, ty);
-                }
-            });
-            fnTy.typeParams = fnTy.typeParams.map((0, subster_1.substTyAnn)(env, subst));
-            fnTy = (0, subster_1.substTyAnn)(env, subst)(fnTy);
-        }
-    }
-    return fnTy;
-}
-function tpCallFunction(env, nd, tgtTy) {
-    let calleeName = nd.calleeName;
-    if (!calleeName) {
-        env.addError('没有函数名，无法进行调用');
-        return undefined;
-    }
-    // 处理 enum 函数
-    if (parseTsClassType_1.enumBuiltinFns.includes(calleeName)) {
-        return handleEnumFn(env, nd, tgtTy);
-    }
-    // 前端全局类型推导 + 重载函数几乎无法做任何类型推导，只能做后置验证。后端可以推导，但简单起见，不区分前后端了。
-    // 总结：全局类型推导 + 重载 = 灾难
-    if (parseTsClassType_1.overloadedFns.includes(calleeName)) {
-        return handleOverloadedFunction(env, nd, tgtTy, calleeName);
-    }
-    const fnDef = env.quickGetLibDef(nd, calleeName, env.ctxCQC?.dataSourceSqlType);
-    let fnTy = fnDef?.__TypeAnnotation;
-    if (!fnTy) {
-        env.addError('无法找到函数定义（类型）');
-        return;
-    }
-    if (fnTy.typeParams?.length) {
-        fnTy = renameAndMakePartialTyApp(env, fnTy, nd);
-    }
-    for (const [idx, parTy] of fnTy.typeArguments.entries()) {
-        if (parTy.spread) { // 抽取 Array<T> 中的 T
-            const elemTy = parTy.typeArguments[0];
-            // 余下的一并处理
-            for (let i = idx; i < nd.arguments.length; ++i) {
-                /**
-                  * 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 {
-            dispatchExpr(env, nd.arguments[idx], parTy);
-        }
-    }
-    const finalRetTy = fnTy.returnType?.[0] ?? tgtTy;
-    env.unifier.unify(finalRetTy, tgtTy);
-    // TODO:处理可选参数必填选填问题
-    env.setType(nd, finalRetTy); // 似乎不可能为空
-    const callInfo = (0, type_manager_1.createFunctionDef)(fnTy.typeArguments, finalRetTy, fnDef, // 内置函数
-    fnTy.typeParams);
-    env.resolvedCallInfo.set(nd, callInfo);
-    return finalRetTy;
-    function handleEnumFn(env, nd, tgtTy) {
-        const createAnonymousRetTy = (ty) => (0, type_manager_1.createAnonymousTyAnn)(['text', 'value'], [type_manager_1.naslStringTy, ty]);
-        let res = undefined;
-        let tyParam = undefined; // <T>. 但是是实例化后的
-        let paramTy = undefined; // (T)
-        let def = env.resolveRef(nd);
-        switch (nd.calleeName) {
-            // 暂时不合并代码了，也不是特别长
-            case 'EnumToList': {
-                if (!nd.typeArguments?.[0]) {
-                    // 报错 缺参数
-                    return;
-                }
-                tyParam = nd.typeArguments[0];
-                const enumDef = env.resolveRef(nd.typeArguments[0]);
-                if (enumDef?.concept === 'Enum') {
-                    const ty = enumDef.valueType ?? type_manager_1.naslStringTy; // FIXME:还能是空的，服了
-                    res = (0, type_manager_1.createListTyAnn)(createAnonymousRetTy(ty));
-                }
-                else {
-                    env.addError((0, sem_diag_1.mkIncompatibleTyErr)(env, tyParam || type_manager_1.naslAnyTy, '枚举'), env.getCurFileNode(), nd);
-                }
-                break;
-            }
-            case 'ToEnumItem': {
-                if (!nd.typeArguments?.[0]) {
-                    // 报错 缺参数
-                    return;
-                }
-                tyParam = nd.typeArguments[0];
-                const enumDef = env.resolveRef(tyParam);
-                if (enumDef?.concept === 'Enum') {
-                    const exprTy = dispatchExpr(env, nd.arguments[0], enumDef.valueType ?? type_manager_1.naslStringTy);
-                    res = env.getRawType(enumDef);
-                    paramTy = exprTy;
-                }
-                else {
-                    env.addError((0, sem_diag_1.mkIncompatibleTyErr)(env, tyParam || type_manager_1.naslAnyTy, '枚举'), env.getCurFileNode(), nd);
-                }
-                break;
-            }
-            case 'EnumItemToStructure': {
-                if (!nd.arguments?.[0]) {
-                    // 报错 缺参数
-                    return;
-                }
-                const exprTy = dispatchExpr(env, nd.arguments[0], undefined);
-                if (!exprTy) {
-                    return;
-                }
-                paramTy = exprTy;
-                const enumValueTy = (0, type_operator_1.createValueTypeForAssumedEnumTy)(exprTy);
-                const postChk = (fileNode, severity, exprTy) => (env, pSubst) => {
-                    const ty = (0, subster_1.normalizeWithSubst)(env, pSubst, exprTy);
-                    // 断言: 它是枚举类型
-                    if (!(0, type_predicate_1.isEnumTy)(ty)) {
-                        const errMsg = (0, sem_diag_1.mkIncompatibleTyErr)(env, ty || type_manager_1.naslAnyTy, '枚举');
-                        env.addError(errMsg, fileNode, nd, severity);
-                    }
-                };
-                env.addPostCheckTask(env.errBoundary, postChk(env.getCurFileNode(), env.errSeverity, exprTy));
-                res = createAnonymousRetTy(enumValueTy);
-                break;
-            }
-            case 'EnumItemToText': {
-                const exprTy = dispatchExpr(env, nd.arguments[0], undefined);
-                // 如果不是枚举类型就报错，稍后建立 List、Map、Enums 等通用检测机制
-                // FIXME zzr exprTy可能包含类型变元，此时无法立刻判断求解
-                paramTy = exprTy;
-                res = type_manager_1.naslStringTy;
-                const postChk = (fileNode, severity, exprTy) => (env, pSubst) => {
-                    const ty = (0, subster_1.normalizeWithSubst)(env, pSubst, exprTy);
-                    if (!(0, type_predicate_1.isEnumTy)(ty)) {
-                        const errMsg = (0, sem_diag_1.mkIncompatibleTyErr)(env, ty || type_manager_1.naslAnyTy, '枚举');
-                        env.addError(errMsg, fileNode, nd, severity);
-                    }
-                };
-                env.addPostCheckTask(env.errBoundary, postChk(env.getCurFileNode(), env.errSeverity, exprTy));
-                break;
-            }
-            default: {
-                throw new Error(`未实现的 enum 枚举内置函数，函数名 ${nd.calleeName}`);
-            }
-        }
-        env.unifier.unify(res, tgtTy);
-        const retTy = res ?? tgtTy;
-        env.setType(nd, retTy);
-        const callInfo = (0, type_manager_1.createFunctionDef)(paramTy ? [paramTy] : [], type_manager_1.naslBooleanTy, def, tyParam ? [tyParam] : []);
-        env.resolvedCallInfo.set(nd, callInfo);
-        return retTy;
-    }
-}
-exports.tpCallFunction = tpCallFunction;
-/**
- * 处理重载函数的调用
- * @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 {
-            retTy = type_manager_1.naslAnyTy;
-        }
-    }
-    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, get_q_name_1.getTokenQualifiedName)(nd);
-    if (!qName) {
-        env.setType(nd, type_manager_1.naslAnyTy);
-        return type_manager_1.naslAnyTy;
-    }
-    const def = env.refMgr.gQNameDefs.get(qName);
-    if (!def) {
-        env.setType(nd, type_manager_1.naslAnyTy);
-        return type_manager_1.naslAnyTy;
-    }
-    // 说起来你可能不信，但是事实令人震惊，参数与形参的顺序是乱的，仅能通过 keyword 来匹配
-    for (const param of def.params) {
-        dispatchExpr(env, nd.arguments.find(p => p.keyword === param.name), param.typeAnnotation);
-    }
-    const retTy = def.returns?.[0]?.typeAnnotation;
-    const finalRetTy = nd?.handleError === true
-        ? (retTy ? (0, type_manager_1.createUnionTyAnn)([retTy, type_manager_1.naslInterfaceError]) : type_manager_1.naslInterfaceError)
-        : (retTy ?? tgtTy);
-    env.setType(nd, finalRetTy);
-    env.unifier.unify(finalRetTy, tgtTy);
-    if (!env.isView) {
-        const callInfo = (0, type_manager_1.createFunctionDef)(def.params.map(p => p.typeAnnotation), finalRetTy, def, undefined);
-        env.resolvedCallInfo.set(nd, callInfo);
-    }
-    return finalRetTy;
-}
-exports.tpCallInterface = tpCallInterface;
-exports.tpCallAuthInterface = tpCallInterface;
-exports.tpCallMicroserviceInterface = tpCallInterface;
-exports.tpCallConnector = tpCallLogic;
-function tpAnonymousFunction(env, nd, tgtTy, isListSort = false) {
+const 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));
@@ -1164,8 +695,9 @@ function tpAnonymousFunction(env, nd, tgtTy, isListSort = false) {
     (0, assertion_1.assertTrusy)(tgtTy);
     const paramsArr = [];
     // TODO: 通过 default value 生成 constraints
+    env.refMgr.setLocalSymBindings(nd, nd.params);
     nd.params.forEach((param, idx) => {
-        (0, helper_1.createOnPush)(env.nameBindings, param.name, param); // param name to mem addr
+        env.addLexicalSym(param); // param name to mem addr
         paramsArr.push(param);
         const ctxParTy = tgtTy.typeArguments[idx];
         ctxParTy && env.setType(param, ctxParTy);
@@ -1173,16 +705,18 @@ function tpAnonymousFunction(env, nd, tgtTy, isListSort = false) {
     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));
+    paramsArr.forEach(p => env.removeLexicalSym(p));
     const ndTy = env.getRawType(nd);
     !isListSort && env.unifier.unify(ndTy, tgtTy);
     return ndTy;
-}
-function tpSubLogic(env, nd, tgtTy, isListSort = false) {
+};
+exports.tpAnonymousFunction = tpAnonymousFunction;
+const 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];
+    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) {
@@ -1199,13 +733,14 @@ function tpSubLogic(env, nd, tgtTy, isListSort = false) {
     }
     (0, dispatch_stmt_2.tpSolvingStmts)(env, nd.body);
     (0, dispatch_stmt_1.tpSolvingPlayground)(env, nd.playground);
-    subLogicVars.forEach(env.removeVar);
+    subLogicVars.forEach(env.removeLexicalSym);
     const ndTy = (0, type_manager_1.createRefTyAnnFromDef)(nd, env);
     env.setType(nd, ndTy);
     env.unifier.cs = csCopy;
     !isListSort && env.unifier.unify(ndTy, tgtTy); // 这里需要额外的 unify，否则 SubLogic 算出来的类型不能与外侧进来时的约束产生关系
     return ndTy;
-}
+};
+exports.tpSubLogic = tpSubLogic;
 function tpArgument(env, nd, tgtTy) {
     // TODO CallConnector 硬塞了一个特殊的 Argument Content_Type，这个 Argument 没有 expression
     if (nd.expression) {
@@ -1221,13 +756,14 @@ function tpArgument(env, nd, tgtTy) {
 }
 // 一个实体逻辑，浪费一整天，LJ。
 function tpFunction(env, nd, tgtTy) {
+    env.refMgr.setLocalSymBindings(nd, nd.params);
     // 历史兼容，似乎只有 实体逻辑的 filter 是这个东西
     if (!(0, type_predicate_2.isFuncTy)(tgtTy)) {
         throw new Error('In Function__.ts, Function Typing 传入的参数不是函数类型');
     }
     const paramsArr = [];
     nd.params.forEach((param, idx) => {
-        (0, helper_1.createOnPush)(env.nameBindings, param.name, param); // param name to mem addr
+        env.addLexicalSym(param); // param name to mem addr
         paramsArr.push(param);
         if (tgtTy) {
             const ctxParTy = tgtTy.typeArguments?.[idx];
@@ -1239,7 +775,7 @@ function tpFunction(env, nd, tgtTy) {
     env.setType(nd.returns[0], retTy);
     // FIXME: 强行一致，现在标的不是函数类型，标的是函数的返回类型
     env.setType(nd, retTy);
-    paramsArr.forEach(p => env.removeVar(p));
+    paramsArr.forEach(p => env.removeLexicalSym(p));
     return env.getRawType(nd);
 }
 function tpCallQueryComponent(env, nd, tgtTy) {
@@ -1292,8 +828,8 @@ function tpCallQueryComponent(env, nd, tgtTy) {
     env.ctxTpQFE = undefined;
     env.ctxCQC = undefined;
     createdVars.forEach(v => {
-        const varNode = (0, helper_1.getLastOne)(env.nameBindings, v);
-        (0, helper_1.removeLastOne)(env.nameBindings, v);
+        const varNode = env.getLexicalSym(v);
+        env.removeLexicalVarByName(v);
         env.typeBindings.delete(varNode);
     });
     return env.getRawType(nd);
@@ -1525,14 +1061,14 @@ function tpCallQueryComponent(env, nd, tgtTy) {
         aggrAsNames.forEach((ty, name) => {
             // 反正现在是这样的
             const v = nasl_concepts_1.Variable.createProtoTypeOnly({ name: `inner.${name}` });
-            (0, helper_1.createOnPush)(env.nameBindings, v.name, v);
+            env.addLexicalSym(v);
             env.setType(v, ty);
             variables.push(v.name);
         });
         groupByAsNames.forEach((ty, name) => {
             // 反正现在是这样的
             const v = nasl_concepts_1.Variable.createProtoTypeOnly({ name: `inner.${name}` });
-            (0, helper_1.createOnPush)(env.nameBindings, v.name, v);
+            env.addLexicalSym(v);
             env.setType(v, ty);
             variables.push(v.name);
         });
@@ -1572,8 +1108,8 @@ function tpNewComposite(env, nd, tgtTy) {
     // 参考：【rg3】+ saas + 批量赋值时，将同一变量（三层变量）同时赋值给两个不同的变量有报错,、New 等自动连线功能失效
     // http://projectmanage.netease-official.lcap.163yun.com/dashboard/BugDetail?id=3148436628556032
     nd.rights.forEach(selMem => {
-        dispatchExpr(env, toRaw(selMem.expression), undefined);
-        selMem.members.forEach(mem => dispatchExpr(env, toRaw(mem), undefined));
+        dispatchExpr(env, (0, dispatch_stmt_1.toRaw)(selMem.expression), undefined);
+        selMem.members.forEach(mem => dispatchExpr(env, (0, dispatch_stmt_1.toRaw)(mem), undefined));
     });
     const lNameTyPair = (0, exports.extractNameTyPair)(env, nd.typeAnnotation);
     if (!lNameTyPair) {
@@ -1603,11 +1139,12 @@ function tpNewComposite(env, nd, tgtTy) {
         }
         env.unifier.unifyWithBoundary(rTy, lPropTyAnn, right);
     });
+    const properties = toRaws(nd.properties);
     // 没连线的左边的元素们。其实无所谓，但要跟现在保持一致。
-    nd.properties.forEach((pIdent, _) => {
+    properties.forEach((pIdent) => {
         if (!env.typeBindings.get(pIdent)) {
             let lPropTyAnn = lNameTyPair.find(([name, _]) => name === pIdent.name)?.[1];
-            // setType 应该够了，直接 dispatchExpr 会因为 pIdent 没有加到 env.nameBindings 里，导致找不到而报错
+            // setType 应该够了，直接 dispatchExpr 会因为 pIdent 没有加到 env.lexicalVarStacks 里，导致找不到而报错
             if (!lPropTyAnn) {
                 if (nd.typeAnnotation?.typeKind === 'anonymousStructure') {
                     lPropTyAnn = type_manager_1.naslStringTy;
@@ -1624,7 +1161,7 @@ function tpNewComposite(env, nd, tgtTy) {
         const propNames = new Array();
         const propTys = new Array();
         // ty.properties 与 nd.properties 顺序不一样，有一个被排序过，神坑！！！
-        nd.properties.forEach((pIdent, _) => {
+        properties.forEach((pIdent) => {
             propNames.push(pIdent.name);
             propTys.push(env.getRawType(pIdent) ?? env.unifier.nextFreshTyAnn('free'));
         });
@@ -1758,35 +1295,43 @@ function tpMatch(env, nd, tgtTy) {
     const exprTy = nd.isExpression ?
         dispatchExpr(env, nd.expression, undefined) :
         tpSolvingExpr(env, nd.expression, undefined);
-    const tpMatchTypeRefineCase = (nd, tgtTy, exprTy) => (mc) => {
-        let exprRefinedTy = exprTy ?? type_manager_1.naslAnyTy;
-        if (mc.patterns.length > 0) {
-            // type patterns must be type annotations
-            exprRefinedTy = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, mc.patterns.map(inferTy));
-            // TODO wudengke 求解完成之后，报错
-        }
-        else { // '其他' 分支或 空模式的分支
+    const tpMatchTypeRefineCase = (nd, exprTy) => (mc) => {
+        let exprRefinedTy = exprTy;
+        // mc.patterns 中可能包含类型模式和值模式，分别对应类型匹配和值匹配。
+        // 产品上要求：当被Match的表达式为Union类型时，只能使用类型匹配；否则只能使用值模式匹配。mc.patterns 中值模式和类型模式不会同时出现。
+        // 因此： mc.pattern 中一旦出现非类型的项，就可以判定为这是值模式匹配。值模式匹配时，无需对匹配项的类型做精化。
+        if (mc.patterns.length > 0 && mc.patterns.every((x) => (0, type_predicate_1.isTypeAnnotation)(x))) {
+            // 模式非空且类型模式匹配
+            exprRefinedTy = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, mc.patterns.map(getPatTy).filter(types_1.isNotNil));
+            env.addPostCheckTask(mc, (env, pSubst) => {
+                const resolvedSub = pSubst(exprRefinedTy);
+                const resolvedSup = pSubst(exprTy);
+                if (!(0, type_predicate_1.isSubTy)(env, resolvedSub, resolvedSup)) {
+                    env.addError((0, sem_diag_1.mkIncompatibleTyErr)(env, resolvedSub, resolvedSup), undefined, mc);
+                }
+            });
+        }
+        else {
+            // 类型模式匹配('其他' 分支或 空模式的分支) 或者 值模式匹配的分支
             // 对其他所有 case 的所有类型取关于全集 exprTy 的补集
             const prevCases = nd.cases.filter((c) => c !== mc); // mem addr compare
-            const prevPatterns = prevCases.flatMap(pc => pc.patterns);
+            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 => {
-                    return (0, type_predicate_1.isEqualTy)(env, t1, t2);
-                })) : [];
+                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) {
-                    // TODO 报错
-                    exprRefinedTy = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, caseRefinedTys);
+                    exprRefinedTy = (0, type_manager_1.createUnionTyAnnIfNecessary)(env, caseRefinedTys); // TODO 报错
                 }
             }
         }
         const allocatedVars = new Set();
         const itVar = nasl_concepts_1.Variable.createProtoTypeOnly({ name: 'it', typeAnnotation: exprRefinedTy }); // 新加的每个分支里的 'it' 变量
         allocatedVars.add(itVar);
-        const isRefined = shouldRefine(nd.expression);
         let matchedVarName = undefined;
+        const isRefined = shouldRefineType(nd.expression, exprTy);
         if (isRefined) {
             matchedVarName = (0, get_q_name_1.getTokenQualifiedNameForMatchedExpr)(env, nd.expression);
             const freshMatchedVar = nasl_concepts_1.Variable.createProtoTypeOnly({
@@ -1809,33 +1354,27 @@ function tpMatch(env, nd, tgtTy) {
         // setType(mc, env.getRawType(getListLast(mc.body))) // Not really useful but to keep the same as the current behaviour
         allocatedVars.forEach(v => {
             // recover un-refined type. Note that `delete` is not proper here.Should use removeLastOne
-            (0, helper_1.removeLastOne)(env.nameBindings, v.name);
+            env.removeLexicalVarByName(v.name);
             env.typeBindings.delete(v);
         });
         if (isRefined) {
             env.matchedVars.delete(matchedVarName);
         }
     };
-    function handleMatchingAgainstTypes(unionTy) {
-        const tpMcTyRefineCase = tpMatchTypeRefineCase(nd, tgtTy, unionTy);
-        nd.cases.forEach(tpMcTyRefineCase);
-    }
-    function inferTy(x) {
-        if ((0, type_predicate_1.isTypeAnnotation)(x)) {
-            return x;
-        }
-        return dispatchExpr(env, x, undefined);
-    }
-    function inferUnionTyFromMatchCases(mcs) {
-        // 从已有的 match cases 的类型构造出 union-like type
-        const patTys = mcs.flatMap(c => c.patterns).map(inferTy).filter(types_1.isNotNil);
-        patTys.push(exprTy);
-        return (0, type_manager_1.createUnionTyAnnIfNecessary)(env, patTys);
-    }
     if (exprTy) {
+        for (const cs of nd.cases) {
+            for (const p of cs.patterns) {
+                dispatchExpr(env, p, undefined);
+            }
+        }
         if ((0, type_predicate_2.isTyAnnTyParam)(exprTy)) {
-            const unionLikeTy = inferUnionTyFromMatchCases(nd.cases);
-            handleMatchingAgainstTypes(unionLikeTy);
+            // 从已有的 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 {
             handleMatchingAgainstTypes(exprTy);
@@ -1854,8 +1393,22 @@ function tpMatch(env, nd, tgtTy) {
         env.setType(nd, type_manager_1.naslVoidTy);
     }
     return env.getRawType(nd);
-    function shouldRefine(nd) {
-        return nd.concept === 'Identifier' || nd.concept === 'MemberExpression';
+    function handleMatchingAgainstTypes(unionTy) {
+        nd.cases.forEach(tpMatchTypeRefineCase(nd, unionTy));
+    }
+    function getPatTy(x) {
+        if ((0, type_predicate_1.isTypeAnnotation)(x)) {
+            return x;
+        }
+        return env.getRawType(x);
+        // 这不仅引人深思：为什么 1 的类型就不能随着上下文变化呢，而要 argument: Decimal argument.expr : Long
+        // 那好了，match 这里其实是又要特殊处理的
+    }
+    function shouldRefineType(nd, exprRefinedTy) {
+        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;
     }
 }
 exports.tpMatch = tpMatch;
@@ -1865,167 +1418,10 @@ function tpUnparsed(env, nd, tgtTy) {
     env.setType(nd, type_manager_1.naslNullTy);
     return type_manager_1.naslNullTy;
 }
-// 看不懂？一看 NASL 便知
-function tpEntityLogic(env, nd, tgtTy) {
-    const def = env.resolveRef(nd);
-    if (!def) {
-        env.setType(nd, type_manager_1.naslAnyTy);
-        return type_manager_1.naslAnyTy;
-    }
-    // 例如 app.dataSources.${dbName}.entities.${entityName}
-    // 从 'a.b.c.logics.e' 中提取 'a.b.c'
-    const getEntityQName = (ctxCallLogic) => {
-        const qualifiedNames = (0, get_q_name_1.getTokenQualifiedName)(ctxCallLogic);
-        const parts = qualifiedNames.split('.');
-        return parts.slice(0, parts.length - 2).join('.');
-    };
-    const calleeName = nd.calleeName;
-    const entityDef = env.refMgr.gQNameDefs.get(getEntityQName(nd));
-    const entityPrimaryKeys = entityDef?.properties.filter(p => p.primaryKey) ?? [];
-    const entityRefTy = entityDef ? (0, type_manager_1.createRefTyAnnFromDef)(entityDef, env) ?? type_manager_1.naslAnyTy : type_manager_1.naslAnyTy;
-    const entityOrErrTy = entityRefTy ? (0, type_manager_1.createUnionTyAnn)([entityRefTy, type_manager_1.naslDatabaseDuplicateKeyError]) : undefined;
-    const listEntityRefTy = (0, type_manager_1.createListTyAnn)(entityRefTy);
-    // pre-determined type of arguments[0]
-    const getArg0TgtTy = () => {
-        const fstPrimaryKeyTy = entityDef?.properties.find(p => p.primaryKey)?.typeAnnotation;
-        switch (calleeName) {
-            case 'get': return fstPrimaryKeyTy; // 主键类型
-            case 'create': return entityRefTy;
-            case 'delete': return fstPrimaryKeyTy; // 主键类型
-            case 'update': return entityRefTy;
-            case 'createOrUpdate': return entityRefTy;
-            case 'updateBy': return (0, type_manager_1.createFnTyFromTyAnns)([entityRefTy ?? type_manager_1.naslAnyTy], type_manager_1.naslBooleanTy);
-            case 'deleteBy': return (0, type_manager_1.createFnTyFromTyAnns)([entityRefTy ?? type_manager_1.naslAnyTy], type_manager_1.naslBooleanTy);
-            case 'batchCreate': return listEntityRefTy;
-            case 'batchUpdate': return listEntityRefTy;
-            case 'batchDelete': return (0, type_manager_1.createListTyAnn)(fstPrimaryKeyTy ?? type_manager_1.naslAnyTy); // 主键类型
-            case 'import': return type_manager_1.naslBinaryTy;
-        }
-    };
-    const paramTys = new Array();
-    const arg0TgtTy = getArg0TgtTy();
-    paramTys.push(arg0TgtTy ?? type_manager_1.naslAnyTy);
-    env.ctxTpEntityTy = entityRefTy;
-    nd.arguments[0] && dispatchExpr(env, nd.arguments[0], arg0TgtTy);
-    if (calleeName === 'updateBy' || calleeName === 'deleteBy') {
-        const arg1TgtTy = entityRefTy;
-        if (nd.arguments[1]) {
-            const arg1Ty = dispatchExpr(env, nd.arguments[1], arg1TgtTy);
-            paramTys.push(arg1Ty ?? arg1TgtTy ?? type_manager_1.naslAnyTy);
-        }
-        // 这里不能直接 dispatchExpr(callee.arguments[2])，因为里面藏了个非标准的 NewList，元素因为没有公共父类型而会报错，下同
-        const fnDef = nd.arguments[2]?.expression;
-        // NASL 实在是太 🐂🍺 拉，到处都是 NewList，人间处处皆学问！
-        const fnBody = fnDef?.body;
-        if (fnBody?.items) {
-            const paramItem = fnDef?.params?.[0];
-            checkItemMemExprTy(paramItem, fnBody?.items);
-            // FIXME: 只能说是强行保持一致
-            env.setType(nd.arguments[2], type_manager_1.naslStringTy);
-            paramTys.push(type_manager_1.naslStringTy);
-            const itemTys = fnBody?.items?.map(item => env.getRawType(item) ?? type_manager_1.naslAnyTy);
-            const bodyListUnionTy = (0, type_manager_1.createListTyAnn)((0, type_manager_1.createUnionTyAnnIfNecessary)(env, itemTys));
-            env.setType(fnBody, bodyListUnionTy);
-        }
-    }
-    else if (calleeName === 'update' || calleeName === 'batchUpdate') {
-        const fnDef = nd.arguments[1]?.expression;
-        const fnBody = fnDef?.body;
-        if (fnBody?.items) {
-            const paramItem = fnDef?.params?.[0];
-            checkItemMemExprTy(paramItem, fnBody?.items);
-            // FIXME: 只能说是强行保持一致
-            env.setType(nd.arguments[1], type_manager_1.naslStringTy);
-            paramTys.push(type_manager_1.naslStringTy);
-            const itemTys = fnBody?.items?.map(item => env.getRawType(item) ?? type_manager_1.naslAnyTy);
-            const bodyListUnionTy = (0, type_manager_1.createListTyAnn)((0, type_manager_1.createUnionTyAnnIfNecessary)(env, itemTys));
-            env.setType(fnBody, bodyListUnionTy);
-        }
-    }
-    else if ((calleeName === 'get' || calleeName === 'delete') && entityPrimaryKeys.length > 1) {
-        // 处理多主键
-        for (let i = 1; i < entityPrimaryKeys.length; i++) {
-            const argTgtTy = entityPrimaryKeys[i].typeAnnotation;
-            if (nd.arguments[i]) {
-                dispatchExpr(env, nd.arguments[i], argTgtTy);
-                paramTys.push(argTgtTy ?? type_manager_1.naslAnyTy);
-            }
-        }
-    }
-    env.ctxTpEntityTy = undefined;
-    const retTy = getRetTy();
-    const finalRetTy = nd.handleError === true
-        ? retTy
-        // 做了手动处理 Error 需求后，需要 remove Error types from return types
-        : (0, exports.removeErrTys)(env, nd, retTy);
-    nd.handleError === true && dispatchExpr(env, nd.errorMessage, undefined);
-    env.setType(nd, finalRetTy);
-    env.unifier.unify(finalRetTy, tgtTy);
-    // Create a mock definition for entity logics
-    const mockDef = { params: paramTys.map(() => ({ optional: false })) };
-    const callInfo = (0, type_manager_1.createFunctionDef)(paramTys, finalRetTy, mockDef, undefined);
-    env.resolvedCallInfo.set(nd, callInfo);
-    return finalRetTy;
-    function getRetTy() {
-        switch (calleeName) {
-            case 'get': return entityRefTy;
-            case 'create': return entityOrErrTy; // 带个 Error 类型
-            case 'delete': return type_manager_1.naslLongTy; // 现在如此
-            case 'update': return entityRefTy;
-            case 'createOrUpdate': return entityOrErrTy; // 带个 Error 类型
-            case 'updateBy': return type_manager_1.naslLongTy;
-            case 'deleteBy': return type_manager_1.naslLongTy;
-            case 'batchCreate': return listEntityRefTy;
-            case 'batchUpdate': return listEntityRefTy;
-            case 'batchDelete': return type_manager_1.naslLongTy;
-            case 'import': return type_manager_1.naslStringTy;
-        }
-    }
-    function checkItemMemExprTy(paramItem, itemMemExprs) {
-        // createOnPush(env.nameBindings, 'item', paramItem);
-        // FIXME
-        (0, dispatch_def_1.dispatchDef)(env, paramItem);
-        itemMemExprs.forEach(expr => dispatchExpr(env, expr, undefined));
-        env.removeVar(paramItem);
-    }
-}
-exports.tpEntityLogic = tpEntityLogic;
 function tpAnchor(env, nd, tgtTy) {
     return dispatchExpr(env, nd.expression, tgtTy);
 }
-// 特性：支持 forward reference (处理一个尚未读到定义的 Callee)
-// 尝试创建一个函数类型placeholderFnTy，并和qName关联起来。
-// 1. 之后遇到callee定义的时候再进行检查
-// 2. 如果在一个批次检查后这个callee仍然没有定义，那么报错
-/**
- * 创建前向引用占位符(简单的函数类型)
- */
-function createAndSetForwardReferencePlaceholder(env, nd) {
-    // 为每个参数创建一个新的类型变量
-    const paramTypes = nd.arguments.map(() => env.unifier.nextFreshTyAnn('free'));
-    // 为返回值创建一个新的类型变量
-    const returnType = env.unifier.nextFreshTyAnn('free');
-    const placeholderFnTy = (0, type_manager_1.createFnTyFromTyAnns)(paramTypes, returnType);
-    return placeholderFnTy;
-}
-// @ts-expect-error
-const toRaw = (nd) => nd?.__v_raw ?? nd;
-const toRaws = (nds) => nds.map(toRaw);
-/**
- * 处理函数返回类型，过滤错误类型并设置节点类型
- */
-const removeErrTys = (env, nd, retTy) => {
-    let finalRetTy = retTy;
-    if (finalRetTy && finalRetTy.typeKind === 'union') {
-        finalRetTy = (0, fp_macros_1.IfBind)(finalRetTy.typeArguments?.filter(ty => !((0, type_predicate_2.isErrorTy)(ty))))(filteredRetTys => (0, type_manager_1.createUnionTyAnnIfNecessary)(env, filteredRetTys))((0, fp_macros_1.feed)(finalRetTy));
-    }
-    // @ts-ignore
-    if ((0, type_predicate_1.isUnionTy)(finalRetTy) && !finalRetTy.typeArguments?.length) {
-        return type_manager_1.naslVoidTy; // createUnionTyAnnIfNecessary 得到 Union<> 时表示无返回类型
-    }
-    return finalRetTy;
-};
-exports.removeErrTys = removeErrTys;
+const toRaws = (nds) => nds.map(dispatch_stmt_1.toRaw);
 const tpNewStructure = (env, nd, tgtTy) => {
     const ndTy = (0, type_manager_1.createAnonymousTyAnn)(nd.properties.map((p) => p.name), nd.properties.map((p) => {
         // p.name可能有两个取值：format和title。其中：
@@ -2050,10 +1446,10 @@ const tpNewStructure = (env, nd, tgtTy) => {
 // 一个通用的方法，获取各种连线右侧的逻辑项
 const getRightByLine = (nd, itemIdx, memIdx) => {
     if (memIdx !== undefined) {
-        return toRaw(nd.rights[itemIdx].members[memIdx]);
+        return (0, dispatch_stmt_1.toRaw)(nd.rights[itemIdx].members[memIdx]);
     }
     else {
-        return toRaw(nd.rights[itemIdx].expression);
+        return (0, dispatch_stmt_1.toRaw)(nd.rights[itemIdx].expression);
     }
 };
 exports.getRightByLine = getRightByLine;