Replaced constraints with ty var kinds

Author: wickwirew

Sources/Compiler/Context.swift

@@ -5,11 +5,10 @@
 //  Created by Wes Wickwire on 2/23/25.
 //
 
-
-
 struct Context {
     private(set) var schema = Schema()
-    private var types: [SyntaxId: Type] = [:]
 
+    private var types: [SyntaxId: Type] = [:]
 
+    private var signatures: [SyntaxId: Signature] = [:]
 }

Sources/Compiler/Diagnostic.swift

@@ -151,4 +151,12 @@ extension Diagnostic {
     ) -> Diagnostic {
         return Diagnostic("Table '\(table)' already has a primary key", at: range)
     }
+    
+    static func unableToUnify(
+        _ t1: Type,
+        with t2: Type,
+        at range: Range<Substring.Index>
+    ) -> Diagnostic {
+        return Diagnostic("Unable to unify types '\(t1)' and '\(t2)'", at: range)
+    }
 }

Sources/Compiler/Sema/Type.swift

@@ -7,12 +7,23 @@
 
 import OrderedCollections
 
+/// A type, these are not just the types define in the tables
+/// but rather any value or function that can exist within
+/// an expression/statement.
 public enum Type: Equatable, CustomStringConvertible, Sendable {
+    /// A named type, these are the values defined in the columns.
     case nominal(Substring)
+    /// A placeholder for a type that needs to be solved for
     case `var`(TypeVariable)
+    /// A function
     indirect case fn(params: [Type], ret: Type)
+    /// A row is a value from a `SELECT` statement or a group `(?, ?, ?)`
     case row(Row)
+    /// A type that might be null.
     indirect case optional(Type)
+    /// A type that has been aliased. These are not in SQL by default
+    /// but are from the layer on top that we are adding so a user
+    /// can replace a `INTEGER` with a `Bool`
     indirect case alias(Type, Substring)
     /// There was an error somewhere in the analysis. We can just return
     /// an `error` type and continue the analysis. So if the user makes up
@@ -31,7 +42,10 @@ public enum Type: Equatable, CustomStringConvertible, Sendable {
     /// a FROM or JOIN. Unnamed would be from a subquery or
     /// a row expression `(?, ?, ?)`.
     public enum Row: Equatable, Sendable, ExpressibleByArrayLiteral {
+        /// A row that has names for each value
         case named(OrderedDictionary<Substring, Type>)
+        /// A row that does not have names. These can come from
+        /// using `VALUES (1, 2, 3)`.
         case unnamed([Type])
         /// This is a special row that we don't know the inner types of.
         /// It assumes that all types in it are the same type and of an
@@ -157,6 +171,30 @@ public enum Type: Equatable, CustomStringConvertible, Sendable {
         case (.error, _), (_, .error):
             // Already had an upstream error so no need to emit any more diagnostics
             return [:]
+        case let (.var(tv1), .var(tv2)):
+            // Unify to type variables.
+            // We need to prioritize what gets substituded for what
+            // by its kind.
+            // So if we get an `integer` and `float`, we want to promote
+            // the `integer` to a `float`, so we sub the int for the float
+            switch (tv1.kind, tv2.kind) {
+            case (.general, _):
+                // General can always be substitued out
+                return [tv1: other]
+            case (_, .general):
+                // General can always be substitued out
+                return [tv2: self]
+            case (.float, .integer):
+                // self: float, other: int
+                // substitute other for self
+                return [tv2: self]
+            case (.integer, .float):
+                // self: int, other: float
+                // substitute self for other
+                return [tv1: other]
+            default:
+                return [tv1: other]
+            }
         case let (.var(tv), ty):
             return [tv: ty]
         case let (ty, .var(tv)):
@@ -167,7 +205,7 @@ public enum Type: Equatable, CustomStringConvertible, Sendable {
             return [:]
         case (.nominal, .nominal):
             guard self != other else { return [:] }
-            diagnostics.add(.init("Unable to unify types '\(self)' and '\(other)'", at: range))
+            diagnostics.add(.unableToUnify(self, with: other, at: range))
             return [:]
         case let (.optional(t1), t2):
             return t1.unify(with: t2, at: range, diagnostics: &diagnostics)
@@ -187,22 +225,22 @@ public enum Type: Equatable, CustomStringConvertible, Sendable {
             if row.count == 1, let first = row.first {
                 return first.unify(with: t, at: range, diagnostics: &diagnostics)
             } else {
-                diagnostics.add(.init("Unable to unify types '\(self)' and '\(other)'", at: range))
+                diagnostics.add(.unableToUnify(self, with: other, at: range))
                 return [:]
             }
         case let (t, .row(row)):
             if row.count == 1, let first = row.first {
                 return first.unify(with: t, at: range, diagnostics: &diagnostics)
             } else {
-                diagnostics.add(.init("Unable to unify types '\(self)' and '\(other)'", at: range))
+                diagnostics.add(.unableToUnify(self, with: other, at: range))
                 return [:]
             }
-        case let (.alias(t1, a), t2):
+        case let (.alias(t1, _), t2):
             return t1.unify(with: t2, at: range, diagnostics: &diagnostics)
-        case let (t1, .alias(t2, a)):
+        case let (t1, .alias(t2, _)):
             return t2.unify(with: t1, at: range, diagnostics: &diagnostics)
         default:
-            diagnostics.add(.init("Unable to unify types '\(self)' and '\(other)'", at: range))
+            diagnostics.add(.unableToUnify(self, with: other, at: range))
             return [:]
         }
     }
@@ -247,39 +285,73 @@ public enum Type: Equatable, CustomStringConvertible, Sendable {
 
         return sub
     }
+    
+    private func validateCanUnify(
+        with tvKind: TypeVariable.Kind,
+        diagnostics: inout Diagnostics,
+        at range: Range<Substring.Index>
+    ) {
+        switch tvKind {
+        case .general:
+            return
+        case .integer:
+            switch self {
+            case .int, .integer, .real: return
+            default: diagnostics.add(.unableToUnify(self, with: .integer, at: range))
+            }
+        case .float:
+            switch self {
+            case .int, .integer, .real: return
+            default: diagnostics.add(.unableToUnify(self, with: .real, at: range))
+            }
+        }
+    }
 }
 
+/// A type variable is a type placeholder for an expression who's type we need to solve.
 public struct TypeVariable: Hashable, CustomStringConvertible, ExpressibleByIntegerLiteral, Sendable {
+    /// The unique integer associated with the variable.
+    /// These are just incremented as they are created.
     let n: Int
+    /// What kind or group this type variable belongs too.
+    let kind: Kind
 
-    init(_ n: Int) {
+    /// There are different type of type variables.
+    /// Each are spawned from different usages.
+    enum Kind {
+        /// `integer` is any type variable from an integer literal e.g. `0`
+        case integer
+        /// `float` is any type variable from an float literal e.g. `0.0`
+        case float
+        /// `general` is any type variable that does not fall into the above
+        case general
+    }
+    
+    init(_ n: Int, kind: Kind) {
         self.n = n
+        self.kind = kind
     }
 
     public init(integerLiteral value: Int) {
         self.n = value
+        self.kind = .general
     }
 
-    public var description: String {
-        return "τ\(n)"
+    /// The type to use for an expression if no concrete type was
+    /// found in the solution.
+    ///
+    /// e.g. `1 + 1`, each literal is not bound to a concrete type
+    /// like a column. So each would still be a variable after the
+    /// substitution is applied. In which a default is needed.
+    var defaultType: Type {
+        return switch kind {
+        case .general: .any
+        case .integer: .integer
+        case .float: .real
+        }
     }
-}
-
-// TODO: Need a better name for this. TypeConstraints vs Constraints is confusing
-typealias Constraints = [TypeVariable: TypeConstraints]
-
-/// Any type constraints that may exist on the type variable.
-/// SQL is not a full language and users cannot create their
-/// own interfaces so a simple option set will do since it is
-/// a finite number.
-struct TypeConstraints: OptionSet, Hashable {
-    let rawValue: UInt8
 
-    static let numeric = TypeConstraints(rawValue: 1 << 0)
-}
-
-extension Constraints {
-    func merging(_ other: Constraints) -> Constraints {
-        return merging(other, uniquingKeysWith: { $0.union($1) })
+    public var description: String {
+        return "τ\(n)"
     }
 }

Sources/Compiler/Sema/TypeChecker.swift

@@ -7,6 +7,10 @@
 
 import OrderedCollections
 
+struct InferenceContext {
+    
+}
+
 struct TypeChecker {
     /// The environment in which the query executes. Any joined in tables
     /// will be added to this.
@@ -22,10 +26,6 @@ struct TypeChecker {
     /// the final type. The overall substitution will have to be applied
     /// to the type.
     private var parameterTypes: [BindParameterSyntax.Index: Type] = [:]
-    /// Any constraints over a type. These are not constraints as in a
-    /// constraint based inference algorithm but rather constraints on a type
-    /// like type classes, protocols, or interfaces.
-    private var constraints: Constraints = [:]
     /// We are not only inferring types but potential names for the parameters.
     /// Any result will be added here
     private var parameterNames: [BindParameterSyntax.Index: Substring] = [:]
@@ -62,15 +62,12 @@ struct TypeChecker {
         sub: Substitution,
         outputCardinality: Signature.Cardinality
     ) -> Signature {
-        let constraints = finalizeConstraints(with: sub)
-        
         return Signature(
             parameters: parameterTypes.reduce(into: [:]) { params, value in
                 params[value.key] = Signature.Parameter(
                     type: finalType(
                         for: value.value,
-                        substitution: sub,
-                        constraints: constraints
+                        substitution: sub
                     ),
                     index: value.key,
                     name: parameterNames[value.key]
@@ -79,8 +76,7 @@ struct TypeChecker {
             output: ty.map { ty in
                 finalType(
                     for: ty.apply(sub),
-                    substitution: sub,
-                    constraints: constraints
+                    substitution: sub
                 )
             },
             outputCardinality: outputCardinality
@@ -92,59 +88,35 @@ struct TypeChecker {
     /// found one will be guessed from the constraints.
     private func finalType(
         for ty: Type,
-        substitution: Substitution,
-        constraints: Constraints
+        substitution: Substitution
     ) -> Type {
         let ty = ty.apply(substitution)
 
         switch ty.apply(substitution) {
         case let .var(tv):
-            // The type variable was never bound to a concrete type.
-            // Check if the constraints gives any clues about a default type
-            // if none just assume `ANY`
-            if let constraints = constraints[tv], constraints.contains(.numeric) {
-                return .integer
-            }
-            return .any
+            // Was never bound to a concrete type. Try to guess
+            // based of the ty var kind
+            return tv.defaultType
         case let .row(tys):
             // Finalize all of the inner types in the row.
             return .row(tys.mapTypes {
                 finalType(
                     for: $0,
-                    substitution: substitution,
-                    constraints: constraints
+                    substitution: substitution
                 )
             })
         default:
             return ty
         }
     }
 
-    /// Applies the substitution to the overall constraints
-    /// so it is the final type to in the map
-    private mutating func finalizeConstraints(
-        with substitution: Substitution
-    ) -> Constraints {
-        var result: [TypeVariable: TypeConstraints] = [:]
-        
-        for (tv, constraints) in constraints {
-            let ty = Type.var(tv).apply(substitution)
-            
-            if case let .var(tv) = ty {
-                result[tv] = constraints
-            } else {
-                // TODO: If it is a non type variable we need to validate
-                // the type meets the constraints requirements.
-            }
-        }
-        
-        return result
-    }
-    
     /// Creates a fresh new unique type variable
-    private mutating func freshTyVar(for param: BindParameterSyntax? = nil) -> TypeVariable {
+    private mutating func freshTyVar(
+        for param: BindParameterSyntax? = nil,
+        kind: TypeVariable.Kind = .general
+    ) -> TypeVariable {
         defer { tyVarCounter += 1 }
-        let ty = TypeVariable(tyVarCounter)
+        let ty = TypeVariable(tyVarCounter, kind: kind)
         if let param {
             parameterTypes[param.index] = .var(ty)
         }
@@ -230,7 +202,6 @@ struct TypeChecker {
         diagnostics = inferrer.diagnostics
         tyVarCounter = inferrer.tyVarCounter
         parameterTypes = inferrer.parameterTypes
-        constraints = inferrer.constraints
         return result
     }
 }
@@ -240,8 +211,7 @@ extension TypeChecker: ExprSyntaxVisitor {
         switch expr.kind {
         case let .numeric(_, isInt):
             if isInt {
-                let tv = freshTyVar()
-                constraints[tv] = .numeric
+                let tv = freshTyVar(kind: isInt ? .integer : .float)
                 return (.var(tv), [:], .none)
             } else {
                 return (.real, [:], .none)

Tests/CompilerTests/TypeCheckerTests.swift

@@ -171,7 +171,7 @@ class TypeCheckerTests: XCTestCase {
 
     func scope(table: String, schema: String) throws -> Environment {
         var compiler = SchemaCompiler()
-        compiler.compile(schema)
+        _ = compiler.compile(schema)
         guard let table = compiler.schema[table[...]] else { fatalError("'table' provided not in 'schema'") }
         var env = Environment()
         env.upsert(table.name, ty: table.type)