comments

Author: wickwirew

Sources/Compiler/Diagnostics.swift

@@ -36,23 +36,6 @@ public struct Diagnostics {
         copy.merge(diagnostics)
         return copy
     }
-    
-    public mutating func throwing(_ diagnostic: Diagnostic) throws {
-        elements.append(diagnostic)
-        throw diagnostic
-    }
-    
-    public mutating func trying<Output>(
-        _ action: () throws -> Output,
-        at location: SourceLocation
-    ) -> Output? {
-        do {
-            return try action()
-        } catch {
-            add(.init("\(error)", at: location))
-            return nil
-        }
-    }
 }
 
 extension Diagnostics: Sequence {

Sources/Compiler/Schema.swift

@@ -42,10 +42,15 @@ extension Columns {
     }
 }
 
+/// A table within the database schema
 public struct Table: Sendable {
+    /// The name of the table
     public var name: Substring
+    /// The columns of the table
     public var columns: Columns
+    /// The columns that make up the primary key
     public let primaryKey: [Substring]
+    /// What kind of table it is (FTS/CTE...)
     public let kind: Kind
 
     public enum Kind: Sendable {
@@ -60,6 +65,7 @@ public struct Table: Sendable {
     }
 }
 
+/// A trigger to be run on certain SQL operations
 public struct Trigger {
     /// The name of the trigger
     public let name: Substring
@@ -69,7 +75,10 @@ public struct Trigger {
     public let usedTables: Set<Substring>
 }
 
+/// An index created within the schema
 public struct Index {
+    /// The name given too the index
     public let name: Substring
+    /// The name of the table the index was created for.
     public let table: Substring
 }

Sources/Compiler/Sema/ExprTypeChecker.swift

@@ -98,7 +98,6 @@ extension ExprTypeChecker: ExprSyntaxVisitor {
                 return inferenceState.errorType(for: expr)
             }
 
-            // TODO: Maybe put this in the scheme instantiation?
             if result.isAmbiguous {
                 diagnostics.add(.ambiguous(tableName.value, at: tableName.location))
             }
@@ -146,7 +145,6 @@ extension ExprTypeChecker: ExprSyntaxVisitor {
                     return inferenceState.errorType(for: expr)
                 }
 
-                // TODO: Maybe put this in the scheme instantiation?
                 if result.isAmbiguous {
                     diagnostics.add(.ambiguous(column.value, at: column.location))
                 }
@@ -192,7 +190,11 @@ extension ExprTypeChecker: ExprSyntaxVisitor {
 
         let tv = inferenceState.freshTyVar(for: expr)
         let fnType = inferenceState.instantiate(scheme)
-        inferenceState.unify(fnType, with: .fn(params: [inferenceState.solution(for: lTy), rTy], ret: tv), at: expr.location)
+        inferenceState.unify(
+            fnType,
+            with: .fn(params: [inferenceState.solution(for: lTy), rTy], ret: tv),
+            at: expr.location
+        )
         return inferenceState.solution(for: tv)
     }
 

Sources/Compiler/Sema/StmtTypeChecker.swift

@@ -708,16 +708,28 @@ extension StmtTypeChecker {
         }
     }
 
+    /// Type checks a `WHERE` expression
     private mutating func typeCheck(where expr: ExpressionSyntax) {
         let (type, _) = typeCheck(expr)
+        // Needs to return an `INTEGER` e.g. boolean
         inferenceState.unify(type, with: .integer, at: expr.location)
     }
 
+    /// Type checks and calculates the returned columns from a `SELECT` stmt.
+    ///
+    /// Note: This is going to do a little extra than just infer the column names
+    /// and types. It will try to chunk them out by table. So if the user does
+    /// a query like `SELECT foo.*, bar.*` we can embed the fact that they
+    /// selected all columns from foo and bar so the table structs can be embded
+    /// within the output type.
     private mutating func typeCheck(resultColumns: [ResultColumnSyntax]) -> ResultColumns {
         var columns: OrderedDictionary<Substring, Type> = [:]
         var table: Substring?
+        // Each chunk is either a list of specifically listed columns
+        // or a select all of a table.
         var chunks: [ResultColumns.Chunk] = []
 
+        // Breaks off the current columns into a chunk then starts a new one.
         func breakOffCurrentChunkIfNeeded() {
             guard !columns.isEmpty else { return }
 

Sources/Compiler/Sema/Type.swift

@@ -187,10 +187,13 @@ public struct TypeVariable: Hashable, CustomStringConvertible, ExpressibleByInte
     /// What kind or group this type variable belongs too.
     let kind: Kind
 
-    /// There are different type of type variables.
+    /// There are different types of type variables.
     /// Each are spawned from different usages.
+    ///
+    /// Having a kind with a type variable allows us to delay unification
+    /// with a concrete type till we have more info.
     enum Kind: Int, Equatable, Comparable {
-        /// `general` is any type variable that does not fall into the above
+        /// `general` is any type variable that does not fall into the below
         case general = 0
         /// `integer` is any type variable from an integer literal e.g. `0`
         case integer = 1