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

package/out/typer/dispatch-call.js

@@ -0,0 +1,637 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeErrTys = exports.tpEntityLogic = exports.tpCallInterface = exports.changeArgTyToParamTy = exports.determineCallLogicFnTy = exports.tpCallLogic = exports.tpCallFunction = void 0;
+const fp_macros_1 = require("../utils/fp-macros");
+const sem_diag_1 = require("./sem-diag");
+const subster_1 = require("./subster");
+const dispatch_stmt_1 = require("./dispatch-stmt");
+const dispatch_def_1 = require("./dispatch-def");
+const get_q_name_1 = require("../reference-manager/get-q-name");
+const symbol_type_1 = require("../reference-manager/symbol-type");
+const service_1 = require("@lcap/nasl-concepts/service");
+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 parseTsClassType_1 = require("../utils/parseTsClassType");
+const types_1 = require("../utils/types");
+const type_operator_1 = require("../utils/type-operator");
+const overload_helper_1 = require("./overload-helper");
+const dispatch_expr_1 = require("./dispatch-expr");
+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') {
+                        (0, dispatch_expr_1.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') {
+                        (0, dispatch_expr_1.tpSubLogic)(env, expr, (0, type_manager_1.createFnTyFromTyAnns)([parTy], undefined), true);
+                    }
+                }
+                else {
+                    // 正常处理
+                    (0, dispatch_expr_1.dispatchExpr)(env, nd.arguments[i], elemTy);
+                }
+            }
+        }
+        else {
+            (0, dispatch_expr_1.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 ?? type_manager_1.naslVoidTy;
+    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 = (0, dispatch_expr_1.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 = (0, dispatch_expr_1.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 = (0, dispatch_expr_1.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;
+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) {
+            (0, dispatch_expr_1.dispatchExpr)(env, arg, type_manager_1.naslAnyTy);
+        }
+        env.setType(nd, type_manager_1.naslVoidTy);
+        return type_manager_1.naslVoidTy;
+    }
+    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.removeLexicalSym);
+    }
+    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) {
+                    (0, dispatch_expr_1.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) {
+                (0, dispatch_expr_1.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) {
+            (0, dispatch_expr_1.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 ?? type_manager_1.naslVoidTy;
+}
+exports.tpCallLogic = tpCallLogic;
+// sharedApp.appshare.dataSources.defaultDS.entities.EntityShare1.logics
+const sharedEntityLogicReg = /sharedApp\.[^.]+\.dataSources\.[^.]+\.entities\.[^.]+\.logics/;
+function isEntityLogic(nsp) {
+    return nsp.startsWith('app.dataSources.') && nsp.endsWith('logics') && /\.entities\./.test(nsp)
+        || sharedEntityLogicReg.test(nsp);
+}
+function isLoggingLogic(nsp) {
+    return nsp === 'nasl.logging';
+}
+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;
+}
+/**
+ * 处理重载函数的调用
+ * @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((0, dispatch_expr_1.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 def = env.resolveRef(nd);
+    if (!def) {
+        env.setType(nd, type_manager_1.naslAnyTy);
+        return type_manager_1.naslAnyTy;
+    }
+    // 说起来你可能不信，但是事实令人震惊，参数与形参的顺序是乱的，仅能通过 keyword 来匹配
+    for (const param of def.params) {
+        (0, dispatch_expr_1.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 ?? type_manager_1.naslVoidTy;
+}
+exports.tpCallInterface = tpCallInterface;
+// 一看 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] && (0, dispatch_expr_1.dispatchExpr)(env, nd.arguments[0], arg0TgtTy);
+    if (calleeName === 'updateBy' || calleeName === 'deleteBy') {
+        const arg1TgtTy = entityRefTy;
+        if (nd.arguments[1]) {
+            const arg1Ty = (0, dispatch_expr_1.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]) {
+                (0, dispatch_expr_1.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 && (0, dispatch_expr_1.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 ?? type_manager_1.naslVoidTy;
+    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) {
+        // FIXME
+        (0, dispatch_def_1.dispatchDef)(env, paramItem);
+        itemMemExprs.forEach(expr => (0, dispatch_expr_1.dispatchExpr)(env, expr, undefined));
+        env.removeLexicalSym(paramItem);
+    }
+}
+exports.tpEntityLogic = tpEntityLogic;
+// 特性：支持 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;
+}
+/**
+ * 处理函数返回类型，过滤错误类型并设置节点类型
+ */
+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;
+//# sourceMappingURL=dispatch-call.js.map