Basic constraints added back

Author: LPeter1997

src/Draco.Compiler/Internal/Solver/ConstraintSolver.cs

@@ -68,7 +68,7 @@ public Argument Arg(SyntaxNode? syntax, BindingTask<BoundLvalue> lvalue, Diagnos
     /// <param name="diagnostics">The bag to report diagnostics to.</param>
     public void Solve(DiagnosticBag diagnostics)
     {
-        while (this.ApplyRulesOnce()) { }
+        while (this.ApplyRulesOnce(diagnostics)) { }
 
         // Check for uninferred locals
         this.CheckForUninferredLocals(diagnostics);

src/Draco.Compiler/Internal/Solver/ConstraintSolver_Rules.cs

@@ -1,4 +1,7 @@
 using System;
+using Draco.Compiler.Internal.Diagnostics;
+using Draco.Compiler.Internal.Solver.Constraints;
+using Draco.Compiler.Internal.Symbols;
 
 namespace Draco.Compiler.Internal.Solver;
 
@@ -8,9 +11,39 @@ internal sealed partial class ConstraintSolver
     /// Tries to apply a rule to the current set of constraints.
     /// This is a fixpoint iteration method. Once it returns false, no more rules can be applied.
     /// </summary>
+    /// <param name="diagnostics">The diagnostics to report to.</param>
     /// <returns>True, if a change was made, false otherwise.</returns>
-    private bool ApplyRulesOnce()
+    private bool ApplyRulesOnce(DiagnosticBag diagnostics)
     {
+        // Trivial same-type constraint, unify all
+        if (this.constraintStore.TryRemove<Same>(out var same))
+        {
+            for (var i = 1; i < same.Types.Length; ++i)
+            {
+                if (Unify(same.Types[0], same.Types[i])) continue;
+                // Type-mismatch
+                same.ReportDiagnostic(diagnostics, builder => builder
+                    .WithFormatArgs(same.Types[0].Substitution, same.Types[i].Substitution));
+                break;
+            }
+            return true;
+        }
+
+        // Assignable can be resolved directly, if both types are ground-types
+        if (this.constraintStore.TryRemove<Assignable>(out var assignable, assignable => assignable.TargetType.IsGroundType
+                                                                                      && assignable.AssignedType.IsGroundType))
+        {
+            var targetType = assignable.TargetType;
+            var assignedType = assignable.AssignedType;
+            if (!SymbolEqualityComparer.Default.IsBaseOf(targetType, assignedType))
+            {
+                // Error
+                assignable.ReportDiagnostic(diagnostics, diag => diag
+                    .WithFormatArgs(targetType, assignedType));
+            }
+            return true;
+        }
+
         return false;
     }
 

src/Draco.Compiler/Internal/Solver/ConstraintStore.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using Draco.Compiler.Internal.Solver.Constraints;
 
 namespace Draco.Compiler.Internal.Solver;
 
@@ -14,13 +16,13 @@ internal sealed class ConstraintStore
     /// </summary>
     public int Count => this.constraints.Values.Sum(list => list.Count);
 
-    private readonly Dictionary<Type, List<Constraints.Constraint>> constraints = [];
+    private readonly Dictionary<Type, List<Constraint>> constraints = [];
 
     /// <summary>
     /// Adds a constraint to the store.
     /// </summary>
     /// <param name="constraint">The constraint to add.</param>
-    public void Add(Constraints.Constraint constraint)
+    public void Add(Constraint constraint)
     {
         if (!this.constraints.TryGetValue(constraint.GetType(), out var list))
         {
@@ -29,4 +31,38 @@ public void Add(Constraints.Constraint constraint)
         }
         list.Add(constraint);
     }
+
+    /// <summary>
+    /// Removes the first constraint of a given type.
+    /// </summary>
+    /// <typeparam name="TConstraint">The type of the constraint to remove.</typeparam>
+    /// <param name="predicate">The predicate to match the constraint.</param>
+    /// <param name="constraint">The constraint removed.</param>
+    /// <returns>True if the constraint was found and removed, false otherwise.</returns>
+    public bool TryRemove<TConstraint>([MaybeNullWhen(false)] out TConstraint constraint, Func<TConstraint, bool>? predicate = null)
+        where TConstraint : Constraint
+    {
+        if (!this.constraints.TryGetValue(typeof(TConstraint), out var list))
+        {
+            constraint = null;
+            return false;
+        }
+        if (list.Count == 0)
+        {
+            constraint = null;
+            return false;
+        }
+        predicate ??= _ => true;
+        for (var i = list.Count - 1; i >= 0; --i)
+        {
+            var constraintAtI = (TConstraint)list[i];
+            if (!predicate(constraintAtI)) continue;
+
+            list.RemoveAt(i);
+            constraint = constraintAtI;
+            return true;
+        }
+        constraint = null;
+        return false;
+    }
 }