@lcap/nasl-language-server-core 4.0.1-rc.0 → 4.0.1-rc.1

package/out/typer/solver.js

@@ -2,28 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printBounds = exports.Solver = void 0;
 const index_1 = require("./index");
-const types_1 = require("../utils/types");
+const typer_1 = require("./typer");
+const sem_diag_1 = require("./sem-diag");
 const helper_1 = require("./helper");
 const subster_1 = require("./subster");
 const type_predicate_1 = require("./type-predicate");
 const type_manager_1 = require("./type-manager");
 const type_predicate_2 = require("./type-predicate");
-const type_predicate_3 = require("./type-predicate");
 function collectCandidateBounds(bounds) {
     const allBounds = [...bounds.lb, ...bounds.ub];
     return allBounds.filter(x => {
         // @ts-expect-error FIXME
-        return !x.ignored;
-    });
+        return !x.bound.ignored;
+    }).map(x => x.bound);
 }
 class Solver {
     constructor(env) {
         // 没有子类型，除了数值外几乎都是 equal 就行，似乎不需要使用 SCC 这种找依赖链路的复杂求解了……
         this.simpleSolveConstraints = (cs0 = this.cs) => {
             const subst = new Map();
+            // topoSort 会做浅拷贝
             const cs = this.topoSortTyVars(cs0);
             let newInfo = false;
-            // Stage 1: 首先从下界和上界寻找非 union 和非 any 的具体类型，优先处理数值类型
+            // Stage 1: 首先从下界和上界寻找非 any 的具体类型，优先处理数值类型
             const targetTV = "";
             const stop = targetTV
                 ? (x) => {
@@ -36,41 +37,39 @@ class Solver {
                     const str = (0, helper_1.showConstraints)(cs);
                     console.log(str);
                 }
-                for (let [tyVar, rawBounds] of cs.entries()) {
+                for (const [tyVar, rawBounds] of cs.entries()) {
                     const deref = (subst, bounds) => {
                         const pSubst = (0, subster_1.inPlaceSubstTyAnn)(this.env, subst);
                         for (let i = 0; i < bounds.lb.length; i++) {
-                            bounds.lb[i] = pSubst(bounds.lb[i]);
+                            bounds.lb[i] = { bound: pSubst(bounds.lb[i].bound), boundary: bounds.lb[i].boundary, fromPlayground: bounds.lb[i].fromPlayground };
                         }
                         for (let i = 0; i < bounds.ub.length; i++) {
-                            bounds.ub[i] = pSubst(bounds.ub[i]);
+                            bounds.ub[i] = { bound: pSubst(bounds.ub[i].bound), boundary: bounds.ub[i].boundary, fromPlayground: bounds.ub[i].fromPlayground };
                         }
                         return bounds;
                     };
                     if (stop(tyVar)) {
                         printBounds(rawBounds);
                     }
-                    function keepValidCondidateInBounds(bounds) {
+                    function keepValidCandidateInBounds(bounds) {
                         return new index_1.Bounds(bounds.lb.filter((x) => {
                             // @ts-expect-error
-                            return !x.ignored;
+                            return !x.bound.ignored;
                         }), bounds.ub.filter((x) => {
                             // @ts-expect-error
-                            return !x.ignored;
+                            return !x.bound.ignored;
                         }));
                     }
-                    const validBounds = keepValidCondidateInBounds(rawBounds);
+                    const validBounds = keepValidCandidateInBounds(rawBounds);
                     const derefedBounds = deref(subst, validBounds);
                     if (stop(tyVar)) {
                         printBounds(derefedBounds);
                         debugger;
                     }
                     // FIXME wudengke 这里hack了一下，需要justify。
-                    // 之所以对current变量直接使用下界和上界，是因为它上下界中那些预期被选中的候选因为包含有类型变元而被getConcreteTysFromBoundsPriority1排除
-                    const rawConcreteTys = tyVar.startsWith('Tp_current_of')
-                        ? [...derefedBounds.lb, ...derefedBounds.ub]
-                        : this.getConcreteTysFromBoundsPriority1(derefedBounds, subst) ?? [];
-                    const concreteTys = rawConcreteTys;
+                    // 之所以对current变量直接使用下界和上界，是因为它上下界中那些预期被选中的候选因为包含有类型变元而被getConcreteTysFromBoundsPriority排除
+                    // HACK: 下界优先选 union，上界优先选非 union
+                    const concreteTys = this.getConcreteTys(derefedBounds, subst, tyVar.startsWith('Tp_current_of')) ?? [];
                     concreteTys.forEach((concreteTy) => {
                         const res = this.addToSubstAndCheck(tyVar, concreteTy, subst);
                         if (stop(tyVar)) {
@@ -98,31 +97,6 @@ class Solver {
                     newInfo = false;
                 }
             } while (newInfo);
-            // Stage 2: 从所有界寻找包括 union 和 any 的类型
-            do {
-                let oldSize = subst.size;
-                for (let [tyVar, bounds] of cs.entries()) {
-                    const concreteTys = this.getConcreteTysFromBoundsPriority2(bounds, subst);
-                    concreteTys?.forEach(concreteTy => {
-                        const res = this.addToSubstAndCheck(tyVar, concreteTy, subst);
-                        if (stop(tyVar)) {
-                            const msg = res ? `stage 2, addToSubstAndCheck: 更新 ${(0, type_manager_1.showType)(concreteTy)}` : `stage 2, addToSubstAndCheck: 未更新 ${(0, type_manager_1.showType)(concreteTy)}`;
-                            this.env.unifier.trace(targetTV, msg);
-                        }
-                    });
-                    // @ts-expect-error
-                    if (concreteTys?.length || concreteTys?.size) {
-                        cs.delete(tyVar);
-                    }
-                }
-                if (subst.size > oldSize) {
-                    this.inPlaceSubstConstraints(subst, cs);
-                    newInfo = true;
-                }
-                else {
-                    newInfo = false;
-                }
-            } while (newInfo);
             // TODO FIXME: zirun  紧急fix：对 subst 再代换一次，解决大部分问题，但是速度受影响，尽早修复
             this.substSubst(subst);
             this.subst = subst;
@@ -141,7 +115,7 @@ class Solver {
                 return true;
             }
             // old bound and new bound both cannot be type variables
-            if ((0, type_predicate_3.isNullTy)(newBound)) {
+            if ((0, type_predicate_2.isNullTy)(newBound)) {
                 return false;
             }
             if ((0, index_1.isAnyTy)(newBound)) {
@@ -154,11 +128,6 @@ class Solver {
             if ((0, type_predicate_1.isStructuralSubTy)(this.env, oldBound, newBound)) { // 用老的就行，不用报错。比如老的是 A 而新的是  A | B，其实也是兼容的
                 return true;
             }
-            // @ts-expect-error FIXME wudengke 确认这里是否要ignore
-            if (!(0, type_predicate_2.isUnResolvedTy)(newBound) && !(0, type_predicate_2.isUnResolvedTy)(oldBound) && !newBound.ignored && !oldBound.ignored) {
-                // 先屏蔽掉好了
-                //   this.env.addError(mkIncompatibleBounds(oldBound, newBound));
-            }
             return false;
         };
         // in-place substitution
@@ -166,333 +135,176 @@ class Solver {
             const pSubst = (0, subster_1.inPlaceSubstTyAnn)(this.env, subst);
             for (let i = 0; i < constraints.length; i++) {
                 const [tyVar, bounds] = constraints[i];
-                const newLb = bounds.lb.map(pSubst);
-                const newUb = bounds.ub.map(pSubst);
+                const newLb = bounds.lb.map(b => ({ bound: pSubst(b.bound), boundary: b.boundary, fromPlayground: b.fromPlayground }));
+                const newUb = bounds.ub.map(b => ({ bound: pSubst(b.bound), boundary: b.boundary, fromPlayground: b.fromPlayground }));
                 const newBounds = new index_1.Bounds(newLb, newUb);
                 constraints[i] = [tyVar, newBounds];
             }
         };
-        this.inPlaceSubstConstraints = (subst, constraints) => {
+        this.inPlaceSubstConstraints = (subst, cs) => {
             const pSubst = (0, subster_1.inPlaceSubstTyAnn)(this.env, subst);
-            for (let [tyVar, bounds] of constraints.entries()) {
+            for (const [tyVar, bounds] of cs.entries()) {
                 for (let i = 0; i < bounds.lb.length; i++) {
-                    bounds.lb[i] = pSubst(bounds.lb[i]);
+                    bounds.lb[i] = { bound: pSubst(bounds.lb[i].bound), boundary: bounds.lb[i].boundary, fromPlayground: bounds.lb[i].fromPlayground };
                 }
                 for (let i = 0; i < bounds.ub.length; i++) {
-                    bounds.ub[i] = pSubst(bounds.ub[i]);
+                    bounds.ub[i] = { bound: pSubst(bounds.ub[i].bound), boundary: bounds.ub[i].boundary, fromPlayground: bounds.ub[i].fromPlayground };
                 }
             }
         };
-        // exclude type variables that are being resolved
-        this.getUsefulTyFromBounds = (bounds, subst) => {
-            let lbUsefulTys = new Array(); // 等到单例做好后再用 set
-            let lbHasLong = false;
-            let lbHasDecimal = false;
-            let lbHasNum = false;
-            bounds.lb.forEach(ty => {
-                if (hasNaslTyParamAnn(ty, subst)) {
-                    return;
-                }
-                else if (lbUsefulTys.find(ty2 => (0, type_predicate_1.isSameRefTy)(ty, ty2))) {
-                    return;
-                }
-                if ((0, type_predicate_1.isSameRefTy)(ty, index_1.naslLongTy)) {
-                    lbHasLong = true;
-                }
-                if ((0, type_predicate_1.isSameRefTy)(ty, index_1.naslDecimalTy)) {
-                    lbHasDecimal = true;
-                }
-                if ((0, type_predicate_1.isSameRefTy)(ty, index_1.naslNumTy)) {
-                    lbHasNum = true;
-                }
-                lbUsefulTys.push(ty);
-            });
-            // danger
-            if (lbHasDecimal) {
-                return [index_1.naslDecimalTy];
-            }
-            else if (lbHasLong) {
-                return [index_1.naslLongTy];
-            }
-            else if (lbUsefulTys.length === 1 && lbUsefulTys[0].typeName !== 'Number') {
-                return Array.from(lbUsefulTys);
-            }
-            let ubUsefulTys = new Array();
-            let ubHasLong = false;
-            let ubHasDecimal = false;
-            let ubHasNum = false;
-            bounds.ub.forEach(ty => {
-                if (hasNaslTyParamAnn(ty, subst)) {
-                    return;
-                }
-                else if (ubUsefulTys.find(ty2 => (0, type_predicate_1.isSameRefTy)(ty, ty2))) {
-                    return;
-                }
-                else if ((0, type_predicate_1.isSameRefTy)(ty, index_1.naslLongTy)) {
-                    ubHasLong = true;
-                }
-                else if ((0, type_predicate_1.isSameRefTy)(ty, index_1.naslDecimalTy)) {
-                    ubHasDecimal = true;
+        // Normalize constraints in place after substitution
+        this.normalizeConstraintsInPlace = (cs) => {
+            for (const [tyVar, bounds] of cs.entries()) {
+                for (let i = 0; i < bounds.lb.length; i++) {
+                    bounds.lb[i] = { bound: (0, typer_1.normalize)(this.env, bounds.lb[i].bound), boundary: bounds.lb[i].boundary, fromPlayground: bounds.lb[i].fromPlayground };
                 }
-                else if ((0, type_predicate_1.isSameRefTy)(ty, index_1.naslNumTy)) {
-                    ubHasNum = true;
+                for (let i = 0; i < bounds.ub.length; i++) {
+                    bounds.ub[i] = { bound: (0, typer_1.normalize)(this.env, bounds.ub[i].bound), boundary: bounds.ub[i].boundary, fromPlayground: bounds.ub[i].fromPlayground };
                 }
-                ubUsefulTys.push(ty);
-            });
-            // danger
-            if (ubHasLong) {
-                return [index_1.naslLongTy];
             }
-            else if (ubHasDecimal) {
-                return [index_1.naslDecimalTy];
+        };
+        /**
+         * 通用的类型获取策略函数，为不同类型的变量调度合适的策略
+         * @param bounds - 类型边界
+         * @param subst - 类型替换映射
+         * @param incTyVars - pick 时是否包含类型变元
+         */
+        this.getConcreteTys = (bounds, subst, incTyVars) => {
+            // 处理下界
+            const lowerBoundResult = this.processSingleBounds(bounds.lb, subst, incTyVars, true);
+            if (lowerBoundResult && lowerBoundResult.length > 0) {
+                return lowerBoundResult;
             }
-            else if (ubUsefulTys.length === 1 && ubUsefulTys[0].typeName !== 'Number') {
-                return Array.from(ubUsefulTys);
+            // 处理上界
+            const upperBoundResult = this.processSingleBounds(bounds.ub, subst, incTyVars, false);
+            if (upperBoundResult && upperBoundResult.length > 0) {
+                return upperBoundResult;
             }
-            if (lbHasNum || ubHasNum) {
-                return [index_1.naslLongTy];
+            // 特殊处理：若上界只有一个 any 约束且下界为空
+            if (bounds.ub.length === 1 && bounds.lb.length === 0 && bounds.ub[0].bound === index_1.naslAnyTy) {
+                return [bounds.ub[0].bound];
             }
-            // console.log('ub usefulTys', ubUsefulTys.length);
-            // ubUsefulTys.forEach(printType);
-            // throw new Error('getUsefulTyFromBounds: unsolvable constraints');
             return undefined;
         };
-        // 同时从下界和上界寻找非 union 和非 any 的具体类型，特别处理数值类型的情况
         /**
-         *
-         * 1. 下界含有 Decimal：选择 Decimal
-         * 2. 下界只有 Number，上界含有 Decimal：选择 Decimal
-         * 3. 下界只有 Number，上界没有 Decimal：选择 Long （2、3 合并：下界 Number 上界任意数值类型）
-         * 4. 下界含有 Long 且上界有 Decimal：选择 Long
-         * 5. 下界含有 Long 且上界没有 Decimal：选择 Long  （1、2、4、5合并后：下界没有 Decimal，有 Long，而是上界任意数值类型）
-         * 6. 下界和上界都只有 Number：选择 Long
+         * 处理特定边界（下界或上界）的类型：@warning decimal 和 long 的处理被 AI 破坏，现在是只处理单个 lb 或 ub，之后修复 Zirun
+         * 1. 下界含有 union：选择 union
+         * 2. 下界含有 Decimal：选择 Decimal
+         * 3. 下界只有 Number，上界含有 Decimal：选择 Decimal
+         * 4. 下界只有 Number，上界没有 Decimal：选择 Long （2、3 合并：下界 Number 上界任意数值类型）
+         * 5. 下界含有 Long 且上界有 Decimal：选择 Long
+         * 6. 下界含有 Long 且上界没有 Decimal：选择 Long  （1、2、4、5合并后：下界没有 Decimal，有 Long，而是上界任意数值类型）
          * 7. 下界和上界都只有 Number：选择 Long
+         * 8. 下界和上界都只有 Number：选择 Long
          */
-        this.getConcreteTysFromBoundsPriority1 = (bounds, subst) => {
-            // 先快速检查所有数值类型
-            let lbHasDecimal = false;
-            let lbHasLong = false;
-            let lbHasNumber = false;
-            let ubHasDecimal = false;
-            let ubHasLong = false;
-            let ubHasNumber = false;
-            // 快速扫描数值类型，减少多次遍历
-            for (const ty of bounds.lb) {
-                if (ty.typeName === 'Decimal') {
-                    lbHasDecimal = true;
-                }
-                else if (ty.typeName === 'Long') {
-                    lbHasLong = true;
+        this.processSingleBounds = (boundEntries, subst, incTyVars, preferUnion) => {
+            // 首先考虑 union 类型优先级
+            if (preferUnion) {
+                // 下界策略：优先选择 union 类型
+                const unionTypes = [];
+                for (const boundEntry of boundEntries) {
+                    const ty = boundEntry.bound;
+                    const shouldInclude = !(0, index_1.isAnyTy)(ty) && (incTyVars || !hasNaslTyParamAnn(ty, subst));
+                    if (shouldInclude && (0, index_1.isUnionTy)(ty)) {
+                        if (!unionTypes.includes(ty)) {
+                            unionTypes.push(ty);
+                        }
+                    }
                 }
-                else if (ty.typeName === 'Number') {
-                    lbHasNumber = true;
+                // 如果找到 union 类型，优先返回
+                if (unionTypes.length > 0) {
+                    return unionTypes;
                 }
             }
-            for (const ty of bounds.ub) {
+            // 如果没有优先 union 或没找到 union 类型，检查数值类型
+            let hasDecimal = false;
+            let hasLong = false;
+            let hasNumber = false;
+            for (const boundEntry of boundEntries) {
+                const ty = boundEntry.bound;
                 if (ty.typeName === 'Decimal') {
-                    ubHasDecimal = true;
+                    hasDecimal = true;
                 }
                 else if (ty.typeName === 'Long') {
-                    ubHasLong = true;
+                    hasLong = true;
                 }
                 else if (ty.typeName === 'Number') {
-                    ubHasNumber = true;
+                    hasNumber = true;
                 }
             }
-            // 快速处理数值类型的场景，按照规则选择正确的类型
-            // 1. 下界含有 Decimal：选择 Decimal
-            if (lbHasDecimal) {
+            // 数值类型优先级：Decimal > Long/Number
+            if (hasDecimal) {
                 return [index_1.naslDecimalTy];
             }
-            // 2. 下界只有 Number，上界含有 Decimal：选择 Decimal
-            if (lbHasNumber && !lbHasLong && ubHasDecimal) {
-                return [index_1.naslDecimalTy];
-            }
-            // 3. 下界只有 Number，上界没有 Decimal：选择 Long
-            // 4. 下界含有 Long 且上界有 Decimal：选择 Long (类型冲突，Long更具体)
-            // 5. 下界含有 Long 且上界没有 Decimal：选择 Long
-            // 6. 下界和上界都只有 Number：选择 Long
-            // 7. 下界和上界都只有 Number：选择 Long
-            if (lbHasLong || lbHasNumber || ubHasNumber) {
+            if (hasLong || hasNumber) {
                 return [index_1.naslLongTy];
             }
-            // 如果没有数值类型，继续处理其他类型
-            const lbRes = [];
-            const ubRes = [];
-            // 收集下界的非数值类型
-            for (const ty of bounds.lb) {
-                if (!lbRes.includes(ty) && !(0, index_1.isUnionTy)(ty) && !(0, index_1.isAnyTy)(ty) && !hasNaslTyParamAnn(ty, subst)) {
-                    lbRes.push(ty);
-                }
-            }
-            // 如果下界有非数值的类型，优先使用
-            if (lbRes.length > 0) {
-                return lbRes;
-            }
-            // 收集上界的非数值类型
-            for (const ty of bounds.ub) {
-                if (!ubRes.includes(ty) && !(0, index_1.isUnionTy)(ty) && !(0, index_1.isAnyTy)(ty) && !hasNaslTyParamAnn(ty, subst)) {
-                    ubRes.push(ty);
+            // 处理其他非数值类型
+            const result = [];
+            for (const boundEntry of boundEntries) {
+                const ty = boundEntry.bound;
+                const shouldInclude = !(0, index_1.isAnyTy)(ty) && (incTyVars || !hasNaslTyParamAnn(ty, subst));
+                if (shouldInclude && !result.includes(ty)) {
+                    result.push(ty);
                 }
             }
-            // 如果上界有非数值的类型，使用上界
-            if (ubRes.length > 0) {
-                return ubRes;
+            if (result.length > 0) {
+                return result;
             }
-            /**
-             * 若这个变元的整个上界就只有这个约束且为 any ，那么它必定选上。
-             * 可以通过往一个变元的上界添加 naslAnyTy，而令下界留空来迫使它走这个分支。
-             * 主要用在前端类型变元求解上，参考 {@link Unifier#initBoundsFor}
-             */
-            if (bounds.ub.length === 1 && bounds.lb.length === 0 && bounds.ub[0] === index_1.naslAnyTy) {
-                return bounds.ub;
-            }
-            // 如果没有找到任何合适的类型
             return undefined;
         };
-        // 从所有界寻找包括 union 和 any 的类型（合并了Lower和Upper的逻辑）
-        this.getConcreteTysFromBoundsPriority2 = (bounds, subst) => {
-            const res = new Set();
-            // 首先检查下界（优先）
-            for (const ty of bounds.lb) {
-                if (!res.has(ty) && !hasNaslTyParamAnn(ty, subst)) {
-                    res.add(ty);
-                }
-            }
-            // 然后检查上界
-            for (const ty of bounds.ub) {
-                if (!res.has(ty) && !hasNaslTyParamAnn(ty, subst)) {
-                    res.add(ty);
-                }
-            }
-            if (res.size === 0) {
-                return undefined;
-            }
-            else {
-                return refineUnionAnyTy(res);
-            }
-            function refineUnionAnyTy(tys) {
-                let hasAny = false;
-                let hasUnion = false;
-                // weak test
-                tys.forEach(ty => {
-                    if (ty.typeName === 'any') {
-                        hasAny = true;
-                    }
-                    else if ((0, index_1.isUnionTy)(ty)) {
-                        hasUnion = true;
-                    }
-                });
-                const result = [];
-                if (hasUnion) {
-                    if (tys.size > 1) {
-                        for (const ty of tys) {
-                            if ((0, index_1.isUnionTy)(ty)) {
-                                result.push(ty);
-                            }
-                        }
-                        return result;
-                    }
-                    else {
-                        return tys;
-                    }
-                }
-                else if (hasAny) {
-                    return [index_1.naslAnyTy];
-                }
-                else {
-                    return tys;
-                }
-            }
-            ;
-        };
-        // strongly connected components
-        this.findSCCs = (cs0) => {
-            const depG = new Map();
-            let index = 0;
-            const indices = new Map();
-            const lowLinks = new Map();
-            const onStack = new Set();
-            const stack = [];
-            // Build the graph
-            for (const [tyVar, bounds] of cs0) {
-                depG.set(tyVar, new Set());
-                for (const lb of bounds.lb.map(index_1.extractTyParamAnns)) {
-                    for (const dep of (lb.map(getTyName))) {
-                        if (dep !== tyVar && dep) {
-                            depG.get(tyVar).add(dep);
-                        }
-                    }
-                }
-                for (const ub of bounds.ub.map(index_1.extractTyParamAnns)) {
-                    for (const dep of (ub.map(getTyName))) {
-                        if (dep !== tyVar && dep) {
-                            depG.get(tyVar).add(dep);
-                        }
-                    }
-                }
-            }
-            const res = [];
-            // Tarjan's algorithm
-            function strongConnect(v) {
-                indices.set(v, index);
-                lowLinks.set(v, index);
-                index++;
-                stack.push(v);
-                onStack.add(v);
-                if (depG.has(v)) {
-                    for (const w of depG.get(v)) {
-                        if (!indices.has(w)) {
-                            strongConnect(w);
-                            lowLinks.set(v, Math.min(lowLinks.get(v), lowLinks.get(w)));
-                        }
-                        else if (onStack.has(w)) {
-                            lowLinks.set(v, Math.min(lowLinks.get(v), indices.get(w)));
-                        }
-                    }
-                }
-                if (lowLinks.get(v) === indices.get(v)) {
-                    const comp = [];
-                    let w;
-                    do {
-                        w = stack.pop();
-                        onStack.delete(w);
-                        comp.push(w);
-                    } while (w !== v);
-                    res.push(comp);
-                }
-            }
-            for (const v of cs0.keys()) {
-                if (!indices.has(v)) {
-                    strongConnect(v);
-                }
-            }
-            return res;
-        };
         this.topoSortTyVars = (cs) => {
             const sortedCs = new Map();
             const visited = new Set();
             let index = 0;
             let indexMap = new Map();
-            const addToMap = (tyVar, bounds) => {
+            // Phase 1: Use only lower bounds for dependency resolution
+            const addToMapPhase1 = (tyVar, bounds) => {
                 if (visited.has(tyVar)) {
                     return;
                 }
                 visited.add(tyVar);
+                // Only consider lower bounds in phase 1
+                const lbCandidates = bounds.lb.filter((x) => {
+                    // @ts-expect-error
+                    return !x.bound.ignored;
+                }).map(x => x.bound);
+                for (const ty of lbCandidates) {
+                    const tyParams = (0, index_1.extractTyParamAnns)(ty);
+                    for (const param of tyParams) {
+                        const name = getTyName(param);
+                        if (name && cs.has(name)) {
+                            addToMapPhase1(name, cs.get(name));
+                        }
+                    }
+                }
+                indexMap.set(index++, tyVar);
+            };
+            // Phase 2: Use upper bounds for remaining unvisited type variables
+            const addToMapPhase2 = (tyVar, bounds) => {
+                if (visited.has(tyVar)) {
+                    return;
+                }
+                visited.add(tyVar);
+                // Consider both lower and upper bounds in phase 2
                 for (const ty of collectCandidateBounds(bounds)) {
                     const tyParams = (0, index_1.extractTyParamAnns)(ty);
                     for (const param of tyParams) {
                         const name = getTyName(param);
                         if (name && cs.has(name)) {
-                            addToMap(name, cs.get(name));
+                            addToMapPhase2(name, cs.get(name));
                         }
                     }
                 }
                 indexMap.set(index++, tyVar);
             };
-            // Add all constraints to map
+            // Phase 1: Process all constraints using only lower bounds
+            for (const [tyVar, bounds] of cs.entries()) {
+                addToMapPhase1(tyVar, bounds);
+            }
+            // Phase 2: Process any remaining unvisited constraints using all bounds
             for (const [tyVar, bounds] of cs.entries()) {
-                addToMap(tyVar, bounds);
+                addToMapPhase2(tyVar, bounds);
             }
             for (let i = 0; i < cs.size; i++) {
                 const name = indexMap.get(i);
@@ -500,124 +312,91 @@ class Solver {
             }
             return sortedCs;
         };
-        // All the non-cyclic dependencies form the second kind of groups.
-        // Sort each group topologically according to the type variables in the bounds.
-        // For example, if A depends on B, B depends on C, and C depends on D, then the order should be D, C, B, A.
-        this.topoSortConstraints = (cs) => {
-            // const [tvDepDegree, cachedTC] = this.buildTyVarDepDegree(cs);
-            const sccs = this.findSCCs(cs);
-            // console.log('original cs')
-            // printConstraints(cs);
-            // 因为有环，SCC 和依赖度只能分两次算
-            const depDegreeG = this.calcDepDegree(cs, sccs);
-            console.log('depDegreeG');
-            console.log(depDegreeG);
-            // 环上的点，dep degree 不一定都相同
-            //
-            // A <--> B <-- C  dep degree 为 A:0 B:0 C:1，先解环
-            //
-            // A <--> B --> C  dep degree 为 A:0 B:1 C:0，先解非环 C
-            //
-            // A1, A2 <---> B1, B2 --> C dep degree 为 A1:0,  A2:0,  B1:1,  B2:1,  C:0， 先解 C
-            this.reorderSCCs(depDegreeG, cs);
-            console.log('reordered depDegreeG');
-            console.log(depDegreeG);
-            const res = new Array();
-            for (const scc of depDegreeG) {
-                for (const { tv, depDeg, tyCounts } of scc) {
-                    res.push([tv, cs.get(tv)]);
-                }
+        // 紧急fix：对 subst 再代换一次，解决大部分问题
+        this.substSubst = (subst) => {
+            for (const [from, to] of subst.entries()) {
+                subst.set(from, (0, subster_1.inPlaceSubstTyAnn)(this.env, subst)(to));
             }
-            return res;
-        };
-        this.reorderSCCs = (sccs, cs) => {
-            sccs.forEach(scc => this.reorderSCC(scc, cs));
-            sccs.sort((scc1, scc2) => {
-                if (scc1.length === 1) {
-                    return -1; // 无依赖，可优先解决
-                }
-                else if (scc2.length === 1) {
-                    return 1;
-                }
-                else {
-                    return 0; // return scc1[0][1] - scc2[0][1];
-                }
-            }); // according to the first element
-            return sccs;
         };
-        // in-place reordering
-        this.reorderSCC = (scc, cs) => {
-            scc.sort((a, b) => {
-                if (a.tyCounts > 0) {
-                    return -1;
-                }
-                else if (b.tyCounts > 0) {
-                    return 1;
-                }
-                else if (a.depDeg < b.depDeg) {
-                    return -1;
-                }
-                else if (a.depDeg > b.depDeg) {
-                    return 1;
-                }
-                else {
-                    return 0;
-                    // const bounds1 = cs.get(a.tv);
-                    // const tyVars1 = [...bounds1.lb.flatMap(extractTyParamAnns).map(getTyName),
-                    //                 ...bounds1.ub.flatMap(extractTyParamAnns).map(getTyName)];
-                    // const len1 = bounds1.lb.length + bounds1.ub.length - tyVars1.length;
-                    // const bounds2 = cs.get(b.tv);
-                    // const tyVars2 = [...bounds2.lb.flatMap(extractTyParamAnns).map(getTyName),
-                    //                 ...bounds2.ub.flatMap(extractTyParamAnns).map(getTyName)];
-                    // const len2 = bounds2.lb.length + bounds2.ub.length - tyVars2.length;
-                    // return len2 - len1;
+        /**
+         * Post-check if a solution (substitution) is valid by testing if it satisfies all bounds.
+         * For each type variable in the substitution:
+         * - The solution should be a supertype of all lower bounds (lb ⊆ solution)
+         * - The solution should be a subtype of all upper bounds (solution ⊆ ub)
+         *
+         * @param subst The substitution to validate (defaults to this.subst)
+         * @param cs The constraints to check against (defaults to this.cs)
+         * @returns Object with validation result and any violations found
+         */
+        // Post-check solution using consistent normalization approach as traversal
+        this.postCheckSolution = (subst, cs0, normalizedSemTyMap) => {
+            // 对 cs 做浅拷贝，并使用与 traversal 一致的 normalizeWithSubst 方法
+            const cs = new Map(cs0);
+            // this.inPlaceSubstConstraintsWithNormalization(cs, pNormalizedSubst);
+            const violations = [];
+            const pSubst = (0, index_1.substTyAnn)(this.env, subst);
+            // Check each type variable that has a solution
+            for (const [tyVar, __actual] of subst.entries()) {
+                const actual = normalizedSemTyMap.get(__actual) ?? (0, subster_1.normalizeWithSubst)(this.env, pSubst, __actual);
+                const bounds = cs.get(tyVar);
+                if (!bounds) {
+                    // No constraints for this type variable, skip
+                    continue;
+                }
+                // Check lower bounds: solution should be a supertype of each lower bound
+                // i.e., for each lb: lb ⊆ solution (or isSubTy(lb, solution))
+                for (const lbEntry of bounds.lb) {
+                    const __expect = lbEntry.bound;
+                    const expect = normalizedSemTyMap.get(__expect) ?? (0, subster_1.normalizeWithSubst)(this.env, pSubst, __expect);
+                    // Fixme: wudengke 这里之后需要看下为什么父亲 ViewElement 引入了 true 但是 bindAttr 引入了 false 导致报错
+                    if (actual.typeKind === 'literal' && expect.typeKind === 'literal') {
+                        continue;
+                    }
+                    if (!(0, index_1.isSubTy)(this.env, expect, actual)) {
+                        violations.push({
+                            expect,
+                            actual,
+                            errBoundary: lbEntry.boundary,
+                            message: (0, sem_diag_1.mkIncompatibleTyErr)(this.env, expect, actual),
+                            fromPlayground: lbEntry.fromPlayground ?? false
+                        });
+                    }
                 }
-            });
-            return scc;
-        };
-        // dependency degrees regarding the SCC, and the count of non--type-variable bounds.
-        this.calcDepDegree = (cs, scc) => {
-            const depDegree = new Array();
-            for (const comp of scc) {
-                const subRes = new Array();
-                for (const tyVar of comp) {
-                    const bounds = cs.get(tyVar);
-                    const tyVars = [...bounds.lb.flatMap(index_1.extractTyParamAnns).map(getTyName),
-                        ...bounds.ub.flatMap(index_1.extractTyParamAnns).map(getTyName)].filter(types_1.isNotNil);
-                    const len = new Set(tyVars.filter(tv => !comp.includes(tv))).size;
-                    subRes.push({ tv: tyVar,
-                        depDeg: len,
-                        tyCounts: bounds.lb.length + bounds.ub.length - tyVars.length });
+                // Check upper bounds: solution should be a subtype of each upper bound
+                // i.e., for each ub: solution ⊆ ub (or isSubTy(solution, ub))
+                for (const ubEntry of bounds.ub) {
+                    const __expect = ubEntry.bound;
+                    // HACK wudengke 这里额外处理了generic 和dataSource，动机都是通过type desctrutor添加反向约束。这里应当统一一下处理方式。
+                    if (this.env.typeHintManager.isDataSourceTy(__expect)) {
+                        continue;
+                    }
+                    const expect = normalizedSemTyMap.get(__expect) ?? (0, subster_1.normalizeWithSubst)(this.env, pSubst, __expect);
+                    // Fixme: wudengke 这里之后需要看下为什么父亲 ViewElement 引入了 true 但是 bindAttr 引入了 false 导致报错
+                    if (actual.typeKind === 'literal' && expect.typeKind === 'literal') {
+                        continue;
+                    }
+                    if (!(0, index_1.isSubTy)(this.env, actual, expect)) {
+                        violations.push({
+                            expect,
+                            actual,
+                            errBoundary: ubEntry.boundary,
+                            message: (0, sem_diag_1.mkIncompatibleTyErr)(this.env, actual, expect),
+                            fromPlayground: ubEntry.fromPlayground ?? false
+                        });
+                    }
                 }
-                depDegree.push(subRes);
             }
-            return depDegree;
+            return violations;
         };
-        this.normaliseConstraints = (cs = this.cs) => {
-            // remove duplicate bounds
-            // remove self-referencing bounds
-            // remove some numeric constraints 是无效的，因为代换后会有新的数值类型出现
-            // const newCs = new Map();
-            cs.forEach((bounds, tyVar) => {
-                const lbHasLongOrDecimal = bounds.lb.find(ty => (0, type_predicate_1.isSameRefTy)(ty, index_1.naslLongTy)) ||
-                    bounds.lb.find(ty => (0, type_predicate_1.isSameRefTy)(ty, index_1.naslDecimalTy));
-                // console.log('lb has long or decimal', lbHasLongOrDecimal);
-                if (lbHasLongOrDecimal) {
-                    bounds.lb = bounds.lb.filter(ty => !(0, type_predicate_1.isSameRefTy)(ty, index_1.naslNumTy));
+        // Apply normalization to constraints using the same approach as traversal
+        this.inPlaceSubstConstraintsWithNormalization = (cs, pNormalizedSubst) => {
+            for (const [tyVar, bounds] of cs.entries()) {
+                for (let i = 0; i < bounds.lb.length; i++) {
+                    bounds.lb[i] = { bound: (0, typer_1.normalize)(this.env, pNormalizedSubst(bounds.lb[i].bound)), boundary: bounds.lb[i].boundary, fromPlayground: bounds.lb[i].fromPlayground };
                 }
-                const ubHasLongOrDecimal = bounds.ub.find(ty => (0, type_predicate_1.isSameRefTy)(ty, index_1.naslLongTy)) ||
-                    bounds.ub.find(ty => (0, type_predicate_1.isSameRefTy)(ty, index_1.naslDecimalTy));
-                // console.log('ub has long or decimal', ubHasLongOrDecimal);
-                if (ubHasLongOrDecimal) {
-                    bounds.ub = bounds.ub.filter(ty => !(0, type_predicate_1.isSameRefTy)(ty, index_1.naslNumTy));
+                for (let i = 0; i < bounds.ub.length; i++) {
+                    bounds.ub[i] = { bound: (0, typer_1.normalize)(this.env, pNormalizedSubst(bounds.ub[i].bound)), boundary: bounds.ub[i].boundary, fromPlayground: bounds.ub[i].fromPlayground };
                 }
-            });
-            return cs;
-        };
-        // 紧急fix：对 subst 再代换一次，解决大部分问题
-        this.substSubst = (subst) => {
-            for (const [from, to] of subst.entries()) {
-                subst.set(from, (0, subster_1.inPlaceSubstTyAnn)(this.env, subst)(to));
             }
         };
         // substTyEnv = (m: TyVarSolution, env: TypingEnv) => {
@@ -687,8 +466,8 @@ const hasNaslTyParamAnn = (ty, subst) => {
     return false;
 };
 function printBounds(b) {
-    console.log("上界:\n", b.ub.map(type_manager_1.showType).join('\n '));
-    console.log("下界:\n", b.lb.map(type_manager_1.showType).join('\n '));
+    console.log("上界:\n", b.ub.map(bound => (0, type_manager_1.showType)(bound.bound)).join('\n '));
+    console.log("下界:\n", b.lb.map(bound => (0, type_manager_1.showType)(bound.bound)).join('\n '));
 }
 exports.printBounds = printBounds;
 //# sourceMappingURL=solver.js.map