Merge pull request #665 from glu-lang/sema-simplify

[Sema] Feature: CS Simplify

Author: Snowy1803

include/Sema/ConstraintSystem.hpp

@@ -225,8 +225,22 @@ class ConstraintSystem {
     /// splitting of the constraint system, and before mapping types back to the
     /// AST.
     /// @param result The solution result to populate with found solutions.
+    /// @param initialState The initial state with early unification bindings.
     /// @return True if a solution was found, false otherwise.
-    bool solveLocalConstraints(SolutionResult &result);
+    bool solveLocalConstraints(
+        SolutionResult &result, SystemState const &initialState
+    );
+
+    /// @brief Simplifies the constraint system before solving.
+    ///
+    /// This method performs various optimizations on the constraint set:
+    /// - Eliminates redundant constraints
+    /// - Pre-filters impossible overload choices
+    /// - Reorders constraints for optimal evaluation
+    /// - Performs early unification where possible
+    ///
+    /// @return Initial SystemState with early unification bindings applied.
+    SystemState simplifyConstraints();
 
     /// @brief Solves all constraints and applies mappings.
     ///
@@ -428,6 +442,10 @@ class ConstraintSystem {
 
     /// @brief Print all constraints in a ConstraintSystem for debugging.
     void print();
+
+private:
+    // Constraint simplification passes
+    void reorderConstraintsByPriority();
 };
 
 /// @brief Print all constraints in a ConstraintSystem for debugging.

lib/Sema/CMakeLists.txt

@@ -21,6 +21,7 @@ target_sources(Sema
         ConstraintSystem/ConstraintPrinter.cpp
         ConstraintSystem/ConstraintSystem.cpp
         ConstraintSystem/ConversionVisitor.cpp
+        ConstraintSystem/CSSimplify.cpp
         ConstraintSystem/LocalCSWalker.cpp
         ConstraintSystem/OccursCheckVisitor.cpp
         ConstraintSystem/Solver.cpp

lib/Sema/ConstraintSystem/CSSimplify.cpp

@@ -0,0 +1,71 @@
+#include "ConstraintSystem.hpp"
+
+#include "AST/Expr/CallExpr.hpp"
+#include "AST/Expr/RefExpr.hpp"
+#include "AST/Types/FunctionTy.hpp"
+#include "AST/Types/TypeVariableTy.hpp"
+
+#include <algorithm>
+
+namespace glu::sema {
+
+SystemState ConstraintSystem::simplifyConstraints()
+{
+    // Create initial state for simplification
+    SystemState initialState(_context);
+
+    reorderConstraintsByPriority();
+
+    return initialState;
+}
+
+enum class ConstraintPriority : unsigned {
+    // Priority 0: Immediate - simple deterministic bindings
+    Immediate = 0,
+    // Priority 1: Normal constraints
+    Normal = 1,
+    // Priority 2: Deferred constraints (like StructInitialiser)
+    Deferred = 2,
+    // Priority 3: Defaultable constraints (last resort)
+    Defaultable = 3,
+    // Priority 4: Type property constraints (checks only)
+    TypeProperty = 4
+};
+
+static ConstraintPriority getPriority(Constraint *constraint)
+{
+    ConstraintKind kind = constraint->getKind();
+
+    if (kind == ConstraintKind::Bind || kind == ConstraintKind::Equal
+        || kind == ConstraintKind::BindToPointerType) {
+        return ConstraintPriority::Immediate;
+    }
+
+    if (kind == ConstraintKind::StructInitialiser) {
+        return ConstraintPriority::Deferred;
+    }
+
+    if (kind == ConstraintKind::Defaultable) {
+        return ConstraintPriority::Defaultable;
+    }
+
+    if (constraint->isTypePropertyConstraint()) {
+        return ConstraintPriority::TypeProperty;
+    }
+
+    return ConstraintPriority::Normal;
+}
+
+void ConstraintSystem::reorderConstraintsByPriority()
+{
+    // Reorder constraints by priority - lower priority number = processed first
+    // This eliminates the need for multiple passes in solveLocalConstraints
+    std::stable_sort(
+        _constraints.begin(), _constraints.end(),
+        [](Constraint *a, Constraint *b) {
+            return getPriority(a) < getPriority(b);
+        }
+    );
+}
+
+} // namespace glu::sema

lib/Sema/ConstraintSystem/ConstraintSystem.cpp

@@ -145,84 +145,32 @@ void ConstraintSystem::mapImplicitConversions(Solution *solution)
     }
 }
 
-bool ConstraintSystem::solveLocalConstraints(SolutionResult &result)
+bool ConstraintSystem::solveLocalConstraints(
+    SolutionResult &result, SystemState const &initialState
+)
 {
-    /// The initial system state used to begin constraint solving.
-    std::vector<SystemState> worklist;
-    worklist.emplace_back(_context); // Start from an empty state
+    /// The initial system state with early unification bindings applied
+    std::vector<std::pair<SystemState, size_t>> worklist;
+    worklist.push_back({ initialState, 0 }); // Start from the simplified state
 
     while (!worklist.empty()) {
-        SystemState current = std::move(worklist.back());
+        SystemState current = std::move(worklist.back().first);
+        size_t index = worklist.back().second;
         worklist.pop_back();
 
-        /// Apply non-defaultable constraints first
-        for (Constraint *constraint : _constraints) {
-            // Skip disabled constraints
-            if (constraint->isDisabled())
-                continue;
-
-            // Skip defaultable constraints in first pass
-            if (constraint->getKind() == ConstraintKind::Defaultable
-                || constraint->isTypePropertyConstraint()
-                || constraint->getKind() == ConstraintKind::StructInitialiser) {
-                continue;
-            }
-
-            /// Apply the constraint and check the result.
-            ConstraintResult result = apply(constraint, current, worklist);
-            markConstraint(result, constraint);
-            if (result == ConstraintResult::Failed) {
-                goto failed;
-            }
-            // Continue if Satisfied or Applied
-        }
-
-        for (Constraint *constraint : _constraints) {
-            if (constraint->isDisabled())
-                continue;
-            if (constraint->getKind() != ConstraintKind::StructInitialiser)
-                continue;
-            /// Apply the constraint and check the result.
-            ConstraintResult result = apply(constraint, current, worklist);
-            markConstraint(result, constraint);
-            if (result == ConstraintResult::Failed) {
-                goto failed;
-            }
-        }
+        while (index < _constraints.size()) {
+            Constraint *constraint = _constraints[index++];
 
-        /// Apply defaultable constraints only if non-defaultable
-        /// constraints succeed
-        for (Constraint *constraint : _constraints) {
             // Skip disabled constraints
             if (constraint->isDisabled())
                 continue;
 
-            // Only process defaultable constraints in second pass
-            if (constraint->getKind() != ConstraintKind::Defaultable)
-                continue;
-
             /// Apply the constraint and check the result.
-            ConstraintResult result = apply(constraint, current, worklist);
-            markConstraint(result, constraint);
-            if (result == ConstraintResult::Failed) {
-                goto failed;
+            std::vector<SystemState> newStates;
+            ConstraintResult result = apply(constraint, current, newStates);
+            for (auto &newState : newStates) {
+                worklist.push_back({ std::move(newState), index });
             }
-            // Continue if Satisfied or Applied
-        }
-
-        /// Apply ExpressibleByLiterals constraints only if other
-        /// constraints succeed
-        for (Constraint *constraint : _constraints) {
-            // Skip disabled constraints
-            if (constraint->isDisabled())
-                continue;
-
-            // Only process ExpressibleByLiterals constraints in third pass
-            if (!constraint->isTypePropertyConstraint())
-                continue;
-
-            /// Apply the constraint and check the result.
-            ConstraintResult result = apply(constraint, current, worklist);
             markConstraint(result, constraint);
             if (result == ConstraintResult::Failed) {
                 goto failed;
@@ -253,6 +201,10 @@ bool ConstraintSystem::solveLocalConstraints(SolutionResult &result)
 
 bool ConstraintSystem::solveConstraints()
 {
+    // Simplify constraints before solving and get initial state with early
+    // bindings
+    SystemState initialState = simplifyConstraints();
+
     // color the constraints based on which type variables they contain
     // map of color => set of used type variables
     std::vector<llvm::DenseSet<glu::types::TypeVariableTy *>> colors;
@@ -294,14 +246,16 @@ bool ConstraintSystem::solveConstraints()
         }
     } while (changed);
     // solve each color separately
-    SystemState finalSolution(_context);
+    // Start with the initial state from simplification
+    SystemState finalSolution = initialState;
+
     for (std::size_t i = 0; i < colors.size(); ++i) {
         // Disable all constraints not in this color
         for (auto *constraint : _constraints) {
             constraint->setEnabled(colorConstraints[i].count(constraint));
         }
         SolutionResult result;
-        if (!solveLocalConstraints(result)) {
+        if (!solveLocalConstraints(result, initialState)) {
             return false;
         }
         result.getBestSolution()->mergeInto(finalSolution);

lib/Sema/ConstraintSystem/TypeVariableCollector.cpp

@@ -68,6 +68,13 @@ void collectTypeVariables(
         && constraint->getKind() != ConstraintKind::BindOverload
         && constraint->getKind() != ConstraintKind::StructInitialiser)
         collector.visit(constraint->getSecondType());
+    if (constraint->getKind() == ConstraintKind::StructInitialiser) {
+        for (auto &field :
+             llvm::cast<ast::StructInitializerExpr>(constraint->getLocator())
+                 ->getFields()) {
+            collector.visit(field->getType());
+        }
+    }
 }
 
 } // namespace glu::sema