@lcap/nasl-language-server-core 4.4.0-beta.32 → 4.4.0-beta.34

package/out/typer/dispatch-view.js

@@ -4,6 +4,7 @@ exports.isTagIgnored = exports.isAttrIgnored = exports.singletonValue = exports.
 const nasl_concepts_1 = require("@lcap/nasl-concepts");
 const type_manager_1 = require("./type-manager");
 const type_predicate_1 = require("./type-predicate");
+const component_def_manager_1 = require("./component-def-manager/component-def-manager");
 const assertion_1 = require("../utils/assertion");
 const def_key_helpers_1 = require("../reference-manager/def-key-helpers");
 const reference_manager_1 = require("../reference-manager/reference-manager");
@@ -189,8 +190,21 @@ function* tpBusinessComponent(env, nd) {
     });
     nd.elements.forEach((e) => {
         (0, traverse_util_1.traverseViewElements)(e, (ve) => {
-            const ty = env.unifier.nextFreshTyAnn('free');
-            env.setType(ve, ty);
+            const compResult = env.refMgr?.compDefMgr?.queryByViewElement(ve);
+            if (compResult) {
+                const componentDef = compResult.instantiate(env);
+                const instanceProps = componentDef.getInstanceProps();
+                const veTy = nasl_concepts_1.TypeAnnotation.createTypeAnonymousStructure(instanceProps.map((x) => {
+                    x.id = 'placeholder';
+                    return nasl_concepts_1.StructureProperty.createProtoTypeOnly(x);
+                }), { id: 'placeholder' });
+                env.setType(ve, veTy);
+                ve.__preInstantiatedHelper = componentDef;
+            }
+            else {
+                const ty = env.unifier.nextFreshTyAnn('free');
+                env.setType(ve, ty);
+            }
             const qName = (0, def_key_helpers_1.getGlobalDefKey)(ve);
             (0, assertion_1.assertTrusy)(qName);
             env.allocatedVEQNames.push(qName);
@@ -329,8 +343,26 @@ function* tpView(env, nd, skipSubView = false) {
     });
     nd.elements.forEach((e) => {
         (0, traverse_util_1.traverseViewElements)(e, (ve) => {
-            const ty = env.unifier.nextFreshTyAnn('free');
-            env.setType(ve, ty);
+            // 在 logics 之前提前实例化组件定义，将 VE 的类型设为带有已重命名类型参数的
+            // 实际结构类型（如 { data: List<T'>, page: Integer, ... }）。
+            // 这样 logics 中 elements.xxx.property.data 能获得完整的结构信息，
+            // 并通过 T'（fresh type var）在约束系统中与 ListTransform 等函数的类型参数关联。
+            // tpViewElementFirstPass 会复用此 helper，处理 bindAttrs 以解出 T' 的具体类型。
+            const compResult = env.refMgr?.compDefMgr?.queryByViewElement(ve);
+            if (compResult) {
+                const componentDef = compResult.instantiate(env);
+                const instanceProps = componentDef.getInstanceProps();
+                const veTy = nasl_concepts_1.TypeAnnotation.createTypeAnonymousStructure(instanceProps.map((x) => {
+                    x.id = 'placeholder';
+                    return nasl_concepts_1.StructureProperty.createProtoTypeOnly(x);
+                }), { id: 'placeholder' });
+                env.setType(ve, veTy);
+                ve.__preInstantiatedHelper = componentDef;
+            }
+            else {
+                const ty = env.unifier.nextFreshTyAnn('free');
+                env.setType(ve, ty);
+            }
             const qName = (0, def_key_helpers_1.getGlobalDefKey)(ve);
             (0, assertion_1.assertTrusy)(qName);
             env.allocatedVEQNames.push(qName);
@@ -401,12 +433,21 @@ const excludedViewElementPropNames = new Set([
     'formDesignerBuildInDefaults',
     'formDesignerCalcDefaultsTargetField',
 ]);
-function findAncestorWhichHasTypeParamT(env, nd) {
+/**
+ * 在祖先组件链中，找到拥有自己数据源的 dataItem 类型参数（基于 TypeParamMeta.role，而非名字）。
+ */
+function findAncestorDataItemTypeParam(env, nd) {
     let cur = nd.parentNode;
     while (cur) {
-        const t = env.getDataSourceTyParam(cur)?.find((x) => x.rawName === 'T');
-        if (t) {
-            return t;
+        const wrappers = env.getDataSourceTyParam(cur);
+        if (wrappers) {
+            const match = wrappers.find((w) => {
+                const ancestorComponentDef = env.refMgr?.compDefMgr.queryByViewElement(cur)?.instantiate(env);
+                const meta = ancestorComponentDef?.getTypeParamMeta(w.rawName);
+                return meta?.role === 'dataItem' && meta.hasOwnDataSource;
+            });
+            if (match)
+                return match;
         }
         if ((0, asserts_1.isViewElement)(cur.parentNode)) {
             cur = cur.parentNode;
@@ -442,7 +483,8 @@ function* tpViewElementFirstPass(env, nd) {
     if ((0, file_node_cache_1.checkNodeIsFileModuleInIdeWithCache)(nd)) {
         env.fileNodes.push(nd);
     }
-    const componentDef = env.refMgr.compDefMgr.queryByViewElement(nd)?.instantiate(env);
+    const componentDef = nd.__preInstantiatedHelper
+        ?? env.refMgr.compDefMgr.queryByViewElement(nd)?.instantiate(env);
     yield;
     if (!componentDef) {
         env.addDiagnosticsFor(`${nd.tag} 组件的定义缺失`, nd, 'warning');
@@ -451,9 +493,55 @@ function* tpViewElementFirstPass(env, nd) {
             env.addError(`[DEBUG] ${nd.tag} 组件的定义缺失`);
         }
     }
-    env.setDataSourceTyParam(nd, componentDef?.getRenamedTypeParamWrappers() ?? []);
+    const typeParamWrappers = componentDef?.getRenamedTypeParamWrappers() ?? [];
+    env.setDataSourceTyParam(nd, typeParamWrappers);
+    // 从父组件的 slot 返回类型统一泛型参数（按位置，不按名字）
+    // componentType 可能是 union，resolveComponentTypeForTag 会找到匹配的分支
+    const resolvedParentType = env.componentType?.typeKind === 'union'
+        ? resolveComponentTypeForTag(env.componentType, nd.tag)
+        : (env.componentType?.typeName === component_def_manager_1.ComponentTagUtils.normalizeTag(nd.tag)
+            ? env.componentType
+            : undefined);
+    if (resolvedParentType) {
+        typeParamWrappers.forEach((typeParam, index) => {
+            const pa = resolvedParentType.typeArguments?.[index];
+            if (typeParam?.renamed && pa) {
+                env.unifier.unify(typeParam.renamed, pa);
+            }
+        });
+    }
+    // 对于没有自己数据源但角色是 dataItem 的类型参数，从祖先组件继承
+    if (componentDef) {
+        typeParamWrappers.forEach((w) => {
+            const meta = componentDef.getTypeParamMeta(w.rawName);
+            if (meta?.role === 'dataItem' && !meta.hasOwnDataSource) {
+                const ancestorParam = findAncestorDataItemTypeParam(env, nd);
+                if (ancestorParam) {
+                    env.unifier.unify(w.renamed, ancestorParam.renamed);
+                }
+            }
+        });
+    }
     const initProp = componentDef?.getInitPropsTypeAnnotation();
     const instanceProps = componentDef?.getInstanceProps();
+    // 判断某个类型变元是否在初始化属性里以
+    //   typeParam | String | Boolean | Integer
+    // 这类 union 形式出现，用于在完全无约束的情况下兜底为 String。
+    const isStringishUnionParam = (wrapper) => {
+        const props = initProp?.properties ?? [];
+        return props.some((p) => {
+            const ty = p.typeAnnotation;
+            if (!ty || ty.typeKind !== 'union' || !ty.typeArguments?.length)
+                return false;
+            // 通过类型形状而不是引用相等来识别同一个类型变元
+            const hasThisParam = ty.typeArguments.some((arg) => arg?.typeKind === 'typeParam' && arg.typeName === wrapper.renamed.typeName);
+            if (!hasThisParam)
+                return false;
+            const hasStringLike = ty.typeArguments.some((arg) => arg?.typeNamespace === 'nasl.core' &&
+                (arg.typeName === 'String' || arg.typeName === 'Boolean' || arg.typeName === 'Integer'));
+            return hasThisParam && hasStringLike;
+        });
+    };
     /**
      * 线性复杂度根据name寻找给定的property
      * @param name
@@ -477,49 +565,56 @@ function* tpViewElementFirstPass(env, nd) {
         }
         return prop?.typeAnnotation ?? type_manager_1.naslAnyTy;
     };
-    const typeParamWrappers = componentDef?.getRenamedTypeParamWrappers() ?? [];
+    // 从 slot 返回类型中提取子组件类型（可能是 Array/List 包裹的 union）
+    function extractComponentTypeFromSlotReturn(slotProp) {
+        let ty = slotProp?.typeAnnotation?.returnType?.[0];
+        if (ty?.typeName === 'List' || ty?.typeName === 'Array') {
+            ty = ty?.typeArguments?.[0];
+        }
+        return ty;
+    }
+    // 从一个可能是 union 的类型中，找到与 childTag 匹配的那个分支
+    function resolveComponentTypeForTag(ty, childTag) {
+        if (!ty)
+            return undefined;
+        const normalizedChildTag = component_def_manager_1.ComponentTagUtils.normalizeTag(childTag);
+        // 直接匹配
+        if (ty.typeName === normalizedChildTag)
+            return ty;
+        // union: 遍历 typeArguments 找匹配的分支
+        if (ty.typeKind === 'union' && ty.typeArguments?.length) {
+            return ty.typeArguments.find((alt) => alt && component_def_manager_1.ComponentTagUtils.normalizeTag(alt.typeName ?? '') === normalizedChildTag);
+        }
+        return undefined;
+    }
     function makeCurrentManager(nd) {
-        // currentManager机制分为两部分：
-        // 1. 维护类型变元的约束
-        // 2. current变量的创建和销毁
         if (!componentDef) {
             return;
         }
-        const T1 = typeParamWrappers.find((x) => x.rawName === 'T1');
-        const T = typeParamWrappers.find((x) => x.rawName === 'T');
-        // 以下两个情形，从祖先组件中获取 T
-        if (T1 && T) {
-            // 如果当前组件定义了 T1 和 T，那么就必定从祖先组件中获取T
-            const ancestorTableTypeParam = findAncestorWhichHasTypeParamT(env, nd)?.renamed ?? type_manager_1.naslAnyTy;
-            env.unifier.unify(T.renamed, ancestorTableTypeParam);
-        }
-        // 如果当前组件没有定义 dataSource 且有 T，就需要从祖先组件中获取 T
-        // u-transfer 使用 source 而非 dataSource 作为数据源
-        const hasDataSourceInInitProp = !!componentDef
-            .getInitPropsTypeAnnotation()
-            ?.properties?.some((x) => x.name === 'dataSource' || (nd.tag === 'u-transfer' && x.name === 'source'));
-        const shouldStealAncestorT = !hasDataSourceInInitProp;
-        if (shouldStealAncestorT && T) {
-            const ancestorTableTypeParam = findAncestorWhichHasTypeParamT(env, nd)?.renamed ?? type_manager_1.naslAnyTy;
-            env.unifier.unify(T.renamed, ancestorTableTypeParam);
-        }
+        // 预先解析 default slot 的返回类型，供非 template 直接子组件使用
+        const defaultSlotProp = componentDef.getSlotPropBySlotTarget('default');
+        const defaultSlotComponentType = extractComponentTypeFromSlotReturn(defaultSlotProp);
         return {
             create: (options) => {
-                if (options.templateElement?.tag !== 'template') {
-                    return undefined;
-                }
-                const slotTarget = options.templateElement?.slotTarget ?? 'default';
-                const slotScopeType = componentDef?.getSlotScopeTypeBySlotTarget(slotTarget);
-                // 如果curTy非空，那么才需要引入current变量。否则完全不需要引入。
-                let curTy = slotScopeType?.[0]?.type;
-                if (curTy) {
-                    // 引入变量 current_i: CurTy
-                    const curName = env.unifier.nextFreshCurrent();
-                    const curVar = (0, collectGlobalDefs_1.createVarAndSetParentNode)(curName, curTy, nd);
-                    env.setType(curVar, curTy);
-                    env.addLexicalSym(curVar);
+                const child = options.templateElement;
+                if (child?.tag === 'template') {
+                    // template slot: 创建 current 变量 + 提供 slot 级别的 componentType
+                    const slotTarget = child.slotTarget ?? 'default';
+                    const slotProp = componentDef?.getSlotPropBySlotTarget(slotTarget);
+                    const slotScopeType = slotProp ? componentDef?.getSlotScopeType(slotProp) : null;
+                    const slotComponentType = extractComponentTypeFromSlotReturn(slotProp);
+                    let curTy = slotScopeType?.[0]?.type;
+                    let curName;
+                    let curVar;
+                    if (curTy) {
+                        curName = env.unifier.nextFreshCurrent();
+                        curVar = (0, collectGlobalDefs_1.createVarAndSetParentNode)(curName, curTy, nd);
+                        env.setType(curVar, curTy);
+                        env.addLexicalSym(curVar);
+                    }
                     return {
                         createdVar: curVar,
+                        componentType: slotComponentType,
                         revoke: () => {
                             if (curName) {
                                 env.unifier.decreaseCurrentCounter();
@@ -528,6 +623,17 @@ function* tpViewElementFirstPass(env, nd) {
                         },
                     };
                 }
+                // 非 template 直接子组件：使用 default slot 的返回类型
+                // 从 union 中按 tag 找到对应的分支，从而实现按位置统一泛型
+                const matched = resolveComponentTypeForTag(defaultSlotComponentType, child?.tag ?? '');
+                if (matched) {
+                    return {
+                        createdVar: undefined,
+                        componentType: matched,
+                        revoke: () => { },
+                    };
+                }
+                return undefined;
             },
         };
     }
@@ -559,8 +665,34 @@ function* tpViewElementFirstPass(env, nd) {
             }
         });
     }
-    env.unifier.unify(env.getRawType(nd), veTy);
-    env.typeBindings.set(nd, veTy);
+    // 如果 VE 已经在 tpView 中被预实例化（类型已经是 anonymousStructure），
+    // 跳过 unify 以避免将同一结构的属性类型与自身统一导致自引用约束。
+    // 否则（VE 类型是 freshTyVar），通过 unify 连接 freshTyVar 与实际类型。
+    const existingTy = env.getRawType(nd);
+    if (!existingTy || existingTy.typeKind !== 'anonymousStructure') {
+        env.unifier.unify(existingTy, veTy);
+    }
+    env.setType(nd, veTy);
+    // 在完全求解后，对仍未解出的类型变元做默认兜底：
+    // 1. dataItem 角色（无论是否有自己的数据源）：当数据源未设置且无其他约束能推出具体类型时，兜底为 String
+    // 2. 形状类似 T | String | Boolean | Integer 的 union 参数：兜底为 String
+    if (typeParamWrappers.length) {
+        env.addPostCheckTask(nd, (env, pSubst) => {
+            typeParamWrappers.forEach((w) => {
+                const solved = pSubst(w.renamed);
+                if (!(0, type_predicate_1.isUnResolvedTy)(solved))
+                    return;
+                const meta = componentDef?.getTypeParamMeta(w.rawName);
+                if (meta?.role === 'dataItem') {
+                    env.unifier.unify(w.renamed, meta.defaultWhenUnresolved ?? type_manager_1.naslStringTy);
+                    return;
+                }
+                if (isStringishUnionParam(w)) {
+                    env.unifier.unify(w.renamed, type_manager_1.naslStringTy);
+                }
+            });
+        });
+    }
     const ceTy = nasl_concepts_1.TypeAnnotation.createProtoTypeOnly({
         typeName: 'IElements',
         typeKind: 'anonymousStructure',
@@ -577,7 +709,7 @@ function* tpViewElementFirstPass(env, nd) {
     const elements = (0, collectGlobalDefs_1.createVarAndSetParentNode)('elements', ceTy, nd);
     // env.setType(elements, ceTy);
     // 省点内存
-    env.typeBindings.set(elements, ceTy);
+    env.setType(elements, ceTy);
     env.addLexicalSym(elements);
     const dropList = [];
     dropList.push(elements);
@@ -633,8 +765,11 @@ function* tpViewElementFirstPass(env, nd) {
             dropList.push(popper.createdVar);
             (0, helper_1.createOnPush)(env.allocatedVirtualNodes, env.getCurFileNode(), popper.createdVar);
         }
+        // 存在组件类型
+        env.componentType = popper?.componentType;
         yield* tpViewElementFirstPass(env, e);
         popper?.revoke();
+        env.componentType = undefined;
     });
     /**
      * 特性：部分元素的 V 类型可以由子元素的 V 推导得到。同时又尊重此元素本身引入的 V 约束
@@ -675,22 +810,32 @@ function* tpViewElementFirstPass(env, nd) {
      * 当前ViewElement的children中第一个非template的 BindAttribute[name='value']（若无，则为其他类型为V的字段）的类型
      */
     /**
-     * 如果当前元素没有T1，且当前元素的定义中有类型变元 V，而子级组件也有类似的变元 V'，那么需要unify(V', V)。
-     * 以此将子元素的 V' 约束贡献给当前元素的 V
+     * 如果当前组件有 valueResult 类型变元，且没有自己的额外数据源（role = 'dataItem' 且 hasOwnDataSource 的第二个），
+     * 则子组件同角色的 valueResult 应当贡献到当前组件的 valueResult 上。
+     * 这里通过 role 匹配，而不是看名字是否是 'V' / 'T1'。
      */
-    const vThisLevel = typeParamWrappers.find((x) => x.rawName === 'V')?.renamed;
-    const shouldVThisLevelBeInferred = !typeParamWrappers.find((x) => x.rawName === 'T1') &&
-        // 若当前 V 无任何约束
-        !!vThisLevel &&
-        env.unifier.containsEmptyBounds(vThisLevel);
-    if (shouldVThisLevelBeInferred) {
+    const valueResultWrapper = typeParamWrappers.find((w) => {
+        const m = componentDef?.getTypeParamMeta(w.rawName);
+        return m?.role === 'valueResult';
+    });
+    const hasMultipleDataItems = typeParamWrappers.filter((w) => {
+        const m = componentDef?.getTypeParamMeta(w.rawName);
+        return m?.role === 'dataItem' && m.hasOwnDataSource;
+    }).length > 1;
+    const shouldValueBeInferred = !hasMultipleDataItems &&
+        !!valueResultWrapper &&
+        env.unifier.containsEmptyBounds(valueResultWrapper.renamed);
+    if (shouldValueBeInferred) {
         yield* (0, nasl_utils_1.wrapForEachToGenerator)(nd.children, function* (e) {
-            // HACK: 简单的关联组件判断，后续可以考虑更复杂的判断
-            if (e.tag.startsWith(nd.tag) ||
-                (e.tag === 'el-option' && ['el-select', 'el-form-select'].includes(nd.tag))) {
-                const vChild = env.getDataSourceTyParam(e)?.find((x) => x.rawName === 'V')?.renamed;
+            if (e.tag.startsWith(nd.tag)) {
+                const childWrappers = env.getDataSourceTyParam(e);
+                const vChild = childWrappers?.find((cw) => {
+                    const childDef = env.refMgr?.compDefMgr.queryByViewElement(e)?.instantiate(env);
+                    const cm = childDef?.getTypeParamMeta(cw.rawName);
+                    return cm?.role === 'valueResult';
+                })?.renamed;
                 if (vChild) {
-                    env.unifier.unify(vChild, vThisLevel);
+                    env.unifier.unify(vChild, valueResultWrapper.renamed);
                 }
             }
         });
@@ -703,8 +848,10 @@ function* tpViewElementFirstPass(env, nd) {
     dropList.forEach((x) => {
         env.removeLexicalVarByName(x.name);
     });
-    // el-table-column-dynamic，u-table-view-column-dynamic，T/T1 特殊处理
-    const isColumnDynamic = ['el-table-column-dynamic', 'u-table-view-column-dynamic'].includes(nd?.tag ?? '');
+    /**
+     * 通用的类型变元 fallback 过程：
+     * 完全基于 TypeParamMeta.role 驱动，不依赖任何 rawName 硬编码。
+     */
     const isBindAttrEmptyExpression = (name) => {
         const attr = nd.bindAttrs?.find((attr) => attr.name === name);
         if (!attr) {
@@ -714,98 +861,98 @@ function* tpViewElementFirstPass(env, nd) {
             return attr.type === 'dynamic' && !attr.expression;
         }
     };
-    // 组件语义化的类型变元 fallback 规则
-    typeParamWrappers.forEach((x) => {
-        if (x.rawName === 'T') {
-            // el-list-components 开启表单模式 formMode，会清除 dataSource，T 类型变元会根据表单值 model 推导，因此不需要 fallback 规则
-            if (nd?.tag === 'el-list-components') {
-                const formModeAttr = nd.bindAttrs?.find((attr) => attr.name === 'formMode');
-                if (formModeAttr?.type === 'static' && formModeAttr?.value === true) {
-                    return;
-                }
-            }
-            // ColumnDynamic 场景下，T 类型变元从 table 中推导，不需要 fallback 规则
-            if (isColumnDynamic) {
-                return;
+    const inferTypeFromPropMeta = (cfg, nd) => {
+        const attr = nd.bindAttrs?.find((a) => a.name === cfg.propName);
+        if (!attr) {
+            if (cfg.mode === 'booleanFlag')
+                return nasl_concepts_1.TypeAnnotation.createLiteral(false);
+            return undefined;
+        }
+        if (cfg.mode === 'booleanFlag') {
+            if (['static', 'string'].includes(attr.type ?? '')) {
+                return nasl_concepts_1.TypeAnnotation.createLiteral(!!attr.value);
             }
-            // 如果数据源未定义或为空，则不可能有任何合适的解，回落到 String 类型
-            const isEmpty = isBindAttrEmptyExpression('dataSource');
-            if (isEmpty) {
-                env.unifier.unify(x.renamed, type_manager_1.naslStringTy);
+            return type_manager_1.naslBooleanTy;
+        }
+        if (cfg.mode === 'converterLiteral') {
+            if (['static', 'string'].includes(attr.type ?? '')) {
+                if ([true, 'true'].includes(attr.value)) {
+                    return nasl_concepts_1.TypeAnnotation.createLiteral(true);
+                }
+                if ([false, 'false'].includes(attr.value)) {
+                    return nasl_concepts_1.TypeAnnotation.createLiteral(false);
+                }
+                return nasl_concepts_1.TypeAnnotation.createLiteral(String(attr.value));
             }
+            return nasl_concepts_1.TypeAnnotation.createLiteral('');
         }
-        else if (x.rawName === 'T1') {
-            // ColumnDynamic 场景下，T1 类型变元需要 fallback 规则
-            // 如果数据源未定义或为空，则不可能有任何合适的解，回落到 String 类型
-            if (isColumnDynamic && isBindAttrEmptyExpression('dataSource')) {
-                env.unifier.unify(x.renamed, type_manager_1.naslStringTy);
+        if (cfg.mode === 'stringLiteral') {
+            if (['static', 'string'].includes(attr.type ?? '')) {
+                return nasl_concepts_1.TypeAnnotation.createLiteral(String(attr.value ?? ''));
             }
+            return type_manager_1.naslStringTy;
         }
-        if (env.unifier.containsEmptyBounds(x.renamed)) {
-            if (x.rawName === 'T' || x.rawName === 'V') {
-                // 兼容旧规则: 如果组件的T V类型变元没有约束，那么它就是 String
-                env.unifier.unify(x.renamed, type_manager_1.naslStringTy);
+        return undefined;
+    };
+    typeParamWrappers.forEach((wrapper) => {
+        const meta = componentDef?.getTypeParamMeta(wrapper.rawName);
+        if (!meta) {
+            // 没有 meta 的类型参数（如 u-transfer 的 V，仅出现在事件处理器参数结构体内）
+            // 也需要注册到约束系统中，否则 solver 无法将其兜底为 any，
+            // 导致包含该类型参数的函数类型在 postCheck 中被判为 unresolved 而误报。
+            if (wrapper.renamed?.typeName && env.unifier.containsEmptyBounds(wrapper.renamed)) {
+                env.unifier.unify(wrapper.renamed, type_manager_1.naslAnyTy);
             }
-            else if (x.rawName === 'C') {
-                // 规则引自 ViewElement的toEmbeddedTSRefTree
-                const getConverterDefaultValue = (name) => {
-                    const attr = nd.bindAttrs?.find((attr) => attr.name === name);
-                    if (attr) {
-                        if (['static', 'string'].includes(attr?.type ?? "")) {
-                            if ([true, 'true'].includes(attr.value)) {
-                                return nasl_concepts_1.TypeAnnotation.createLiteral(true);
-                            }
-                            else if ([false, 'false'].includes(attr.value)) {
-                                return nasl_concepts_1.TypeAnnotation.createLiteral(false);
-                            }
-                            else {
-                                return nasl_concepts_1.TypeAnnotation.createLiteral(String(attr.value));
-                            }
-                        }
-                    }
-                    return nasl_concepts_1.TypeAnnotation.createLiteral("");
-                };
-                // 兼容旧规则: 如果组件的C类型变元没有约束，那么它就是...
-                env.unifier.unify(x.renamed, getConverterDefaultValue('converter'));
+            return;
+        }
+        // dataItem 且有自己的数据源：仅在数据源为空且无具体类型约束时回落到默认类型。
+        // 预实例化后逻辑可能已为 T 建立了纯类型参数约束（如 T ≈ T_lt），
+        // 这些不携带具体信息，不应阻止兜底；但 model 等属性提供的具体类型约束应阻止兜底。
+        if (meta.role === 'dataItem' && meta.hasOwnDataSource && meta.dataSourcePropName) {
+            if (isBindAttrEmptyExpression(meta.dataSourcePropName) && meta.defaultWhenUnresolved
+                && env.unifier.hasNoConcreteBounds(wrapper.renamed)) {
+                env.unifier.unify(wrapper.renamed, meta.defaultWhenUnresolved);
             }
-            else if (x.rawName === 'M') {
-                // 规则引自 ViewElement的toEmbeddedTSRefTree
-                const getPropInitialValue = (name) => {
-                    const attr = nd.bindAttrs?.find((attr) => attr.name === name);
-                    if (attr && ['static', 'string'].includes(attr?.type ?? "")) {
-                        return nasl_concepts_1.TypeAnnotation.createLiteral(!!attr.value);
-                    }
-                    return type_manager_1.naslBooleanTy;
-                };
-                // 兼容旧规则: 如果组件的M类型变元没有约束，那么它就是...
-                env.unifier.unify(x.renamed, getPropInitialValue('multiple'));
+            return;
+        }
+        // dataItem 但没有自己的数据源（从祖先继承）：祖先的类型参数 bound 是有意义的约束，
+        // 必须用 containsEmptyBounds（而非 hasNoConcreteBounds）来防止覆盖祖先传播的类型。
+        if (meta.role === 'dataItem' && !meta.hasOwnDataSource) {
+            if (meta.defaultWhenUnresolved && env.unifier.containsEmptyBounds(wrapper.renamed)) {
+                env.unifier.unify(wrapper.renamed, meta.defaultWhenUnresolved);
             }
-            else if (x.rawName === 'P') {
-                // 规则引自 ViewElement的toEmbeddedTSRefTree
-                const getPropInitialValue = (name) => {
-                    const attr = nd.bindAttrs?.find((attr) => attr.name === name);
-                    if (attr && ['static', 'string'].includes(attr?.type ?? "")) {
-                        return nasl_concepts_1.TypeAnnotation.createLiteral(!!attr.value);
-                    }
-                    return type_manager_1.naslBooleanTy;
-                };
-                // 兼容旧规则: 如果组件的P类型变元没有约束，那么它就是...
-                env.unifier.unify(x.renamed, getPropInitialValue('pageable'));
+            return;
+        }
+        // booleanFlag / converterLiteral 等：优先根据属性值推导类型
+        if (meta.defaultFromProp && env.unifier.hasNoConcreteBounds(wrapper.renamed)) {
+            const ty = inferTypeFromPropMeta(meta.defaultFromProp, nd);
+            if (ty) {
+                env.unifier.unify(wrapper.renamed, ty);
             }
         }
+        // 非 dataItem 的参数：若仍无具体类型约束，使用默认类型
+        if (meta.defaultWhenUnresolved && env.unifier.hasNoConcreteBounds(wrapper.renamed)) {
+            env.unifier.unify(wrapper.renamed, meta.defaultWhenUnresolved);
+        }
     });
     env.addPostCheckTask(nd, (_, pSubst) => {
-        nd.__ViewElementTV = typeParamWrappers.map((w) => ({
-            rawName: w.rawName,
-            renamed: pSubst(w.renamed),
-        }));
+        const meta = (rawName) => componentDef?.getTypeParamMeta(rawName);
+        nd.__ViewElementTV = typeParamWrappers.map((w) => {
+            const m = meta(w.rawName);
+            return {
+                rawName: w.rawName,
+                renamed: pSubst(w.renamed),
+                role: m?.role,
+                hasOwnDataSource: m?.hasOwnDataSource,
+            };
+        });
     });
     // 在 postCheck 中设置事件类型，使用求解完成后的类型信息
     if (componentDef) {
         env.addPostCheckTask(nd, (env, pSubst) => {
             const initProp = componentDef.getInitPropsTypeAnnotation();
             if (initProp?.properties) {
-                initProp.properties.forEach(prop => {
+                initProp.properties.forEach((prop) => {
                     if (prop.name.startsWith('on') && prop.typeAnnotation?.typeKind === 'function') {
                         // eventName 形如 "onBlurValid"
                         const eventName = prop.name;
@@ -926,7 +1073,16 @@ function* tpViewElementFirstPass(env, nd) {
             }
         }
         else if (tgtTy.typeKind !== 'function') {
-            env.unifier.unify(type_manager_1.naslStringTy, tgtTy);
+            // 类型参数带 extends（如 DT extends 'date' | 'datetime'）时，应用字面量约束而非 String，
+            // 否则 unify(naslStringTy, DT) 会把 DT 的界弄成宽 String，丢失字面量判别。
+            let subTy = type_manager_1.naslStringTy;
+            if ((0, type_predicate_1.isTyAnnTyParam)(tgtTy) && tgtTy.constraints) {
+                const litTy = (0, bind_expression_hack_1.inferStaticValueTypeAsLiteral)(prop.value);
+                subTy = (0, type_predicate_1.isAnyTy)(litTy)
+                    ? nasl_concepts_1.TypeAnnotation.createLiteral(String(prop.value ?? ''))
+                    : litTy;
+            }
+            env.unifier.unify(subTy, tgtTy);
         }
     }
     function collectTypeConstraints(prop) {
@@ -1024,20 +1180,48 @@ function* tpViewElementFirstPass(env, nd) {
             }
             const args = (0, nasl_type_manipulation_1.extractArgPairsFromFnTy)(propTy);
             l.virtualParams = [];
+            // 兜底替换：将所有组件类型参数映射为 any，用于 solver 无法完整求解时的回退。
+            // 例如 u-transfer 的 onChange 事件参数类型为 { source: List<T>, transferValues: List<V> }，
+            // 若 V 无约束且从未进入 cs，solver 会将 ty 整体坍缩为 any。
+            // 此时利用 solver deref 已原地修改的 arg.type（T 已替换）+ fallbackSubst（V→any）
+            // 可以恢复出 { source: List<{...}>, transferValues: List<any> } 这个更精确的类型。
+            const typeParamFallbackSubst = new Map();
+            typeParamWrappers.forEach((w) => {
+                if (w.renamed?.typeName) {
+                    typeParamFallbackSubst.set(w.renamed.typeName, type_manager_1.naslAnyTy);
+                }
+            });
             args?.forEach((arg) => {
                 // pointToSymbol机制要求类型必须是类型变元才会被替换
                 const ty = env.unifier.nextFreshTyAnn('bound');
                 env.unifier.unify(ty, arg.type);
+                // 直接使用 arg.type（如匿名结构 { value: V }）作为虚参的类型标注，
+                // 而非使用 fresh type var ty。这样事件体内对 event.value 的成员访问
+                // 能直接在结构上找到 V，从而让 event.value = true 把 Boolean 约束回 V。
+                const paramTyAnn = arg.type ?? ty;
                 const newParam = nasl_concepts_1.Param.createProtoTypeOnly({
                     name: arg.name,
-                    typeAnnotation: ty
+                    typeAnnotation: paramTyAnn
                 });
                 // 必须设置好，不然 IDE 展示有问题
                 newParam.parentNode = l;
                 newParam.parentKey = 'virtualParams';
                 l.virtualParams.push(newParam);
-                env.queryManager.asyncQuery(l).typeLevelEvaluationOf(ty).then(x => {
-                    if ((0, type_predicate_1.isUnResolvedTy)(x)) {
+                env.queryManager.asyncQuery(l).typeLevelEvaluationOf(ty).then((x) => {
+                    if ((0, type_predicate_1.isUnResolvedTy)(x) || (0, type_predicate_1.isAnyTy)(x)) {
+                        // ty 被 solver 坍缩为 any（常见原因：UB 中的匿名结构含有未进入 cs 的类型参数）。
+                        // arg.type 可能已被 solver 的 deref 原地修改（已求解的类型参数已替换）。
+                        // 通过 substTyAnn + typeParamFallbackSubst 将剩余类型参数替换为 any，
+                        // 保留已求解部分，得到更精确的兜底类型。
+                        const inPlaceType = newParam.typeAnnotation;
+                        if (inPlaceType && !(0, type_predicate_1.isAnyTy)(inPlaceType) && inPlaceType !== ty) {
+                            const resolved = (0, subster_1.substTyAnn)(env, typeParamFallbackSubst)(inPlaceType);
+                            if (!(0, type_predicate_1.isAnyTy)(resolved) && !(0, type_predicate_1.isUnResolvedTy)(resolved)) {
+                                env.setType(newParam, resolved);
+                                newParam.typeAnnotation = resolved;
+                                return;
+                            }
+                        }
                         env.setType(newParam, undefined);
                         newParam.typeAnnotation = undefined;
                     }
@@ -1197,7 +1381,7 @@ const skipCheckDataBase = {
 };
 function isAttrIgnored(options) {
     if (options.attrName === 'value') {
-        if (options.tag === 'el-option') {
+        if (['u-radios', 'van-option'].includes(options.tag)) {
             // HACK: 仅允许它贡献到父组件上
             return false;
         }