draft logic for computing conforming types

Author: tayloraswift

Sources/SwiftinitPages/Sections/GroupSections.swift

@@ -106,8 +106,8 @@ extension GroupSections
                     .third($0.symbol.package)
                 } ?? .first
 
-                let genericness:Genericness = group.conditions.isEmpty ?
-                    .unconstrained : generics.count(substituting: group.conditions) > 0 ?
+                let genericness:Genericness = group.constraints.isEmpty ?
+                    .unconstrained : generics.count(substituting: group.constraints) > 0 ?
                     .constrained :
                     .concretized
 
@@ -193,7 +193,7 @@ extension GroupSections
         return .init(self.context,
             display: display,
             culture: `extension`.culture,
-            where: `extension`.conditions)
+            where: `extension`.constraints)
     }
 
     private

Sources/SwiftinitPages/Surfaces/Vertices/Swiftinit.Docs.DeclPage.swift

@@ -236,7 +236,7 @@ extension Swiftinit.Docs.DeclPage:Swiftinit.VertexPage
             }
 
             if  let containing:Unidoc.Group.Extension = self.groups.containing,
-                let list:ConstraintsList = self.context.constraints(containing.conditions)
+                let list:ConstraintsList = self.context.constraints(containing.constraints)
             {
                 $0[.details, { $0.open = true }]
                 {

Sources/UnidocLinker/Sema/DroppedPassagesError.swift

@@ -3,7 +3,7 @@ import UnidocDiagnostics
 
 enum DroppedPassagesError:Equatable, Error
 {
-    case fromExtension(Unidoc.Group.ID, of:Unidoc.Scalar)
+    case fromExtension(Unidoc.Linker.Extension.ID, of:Unidoc.Scalar)
 }
 extension DroppedPassagesError:Diagnostic
 {

Sources/UnidocLinker/Sema/ProtocolConformance.swift

@@ -3,28 +3,25 @@ import SymbolGraphs
 import Unidoc
 import UnidocDiagnostics
 
-/// Describes a single type’s protocol conformances. Depending on how the type is being used,
-/// the lists may or may not be exhaustive.
-struct ProtocolConformances<Culture>
+/// Describes a single type’s protocol conformances. Depending on how this structure is being
+/// used, the lists may or may not be exhaustive.
+struct ProtocolConformances:Sendable
 {
     private
-    var table:[Unidoc.Scalar: [ProtocolConformance<Culture>]]
+    var table:[Unidoc.Scalar: [Unidoc.Linker.ExtensionConditions]]
 
     private
-    init(table:[Unidoc.Scalar: [ProtocolConformance<Culture>]])
+    init(table:[Unidoc.Scalar: [Unidoc.Linker.ExtensionConditions]])
     {
         self.table = table
     }
 }
-extension ProtocolConformances:Sendable where Culture:Sendable
-{
-}
 extension ProtocolConformances
 {
     /// Yields all known conformances to the specified protocol. This subscript returns an empty
     /// list if no conformances are known to exist. It can also return more than one conformance
     /// if multiple modules declare conformances to the same protocol.
-    subscript(to protocol:Unidoc.Scalar) -> [ProtocolConformance<Culture>]
+    subscript(to protocol:Unidoc.Scalar) -> [Unidoc.Linker.ExtensionConditions]
     {
         _read
         {
@@ -38,7 +35,8 @@ extension ProtocolConformances
 }
 extension ProtocolConformances:Sequence
 {
-    func makeIterator() -> Dictionary<Unidoc.Scalar, [ProtocolConformance<Culture>]>.Iterator
+    func makeIterator()
+        -> Dictionary<Unidoc.Scalar, [Unidoc.Linker.ExtensionConditions]>.Iterator
     {
         self.table.makeIterator()
     }
@@ -50,35 +48,36 @@ extension ProtocolConformances:ExpressibleByDictionaryLiteral
         self.init(table: [:])
     }
 }
-extension ProtocolConformances<Int>
+extension ProtocolConformances
 {
     init(of subject:Unidoc.Scalar,
-        signatures:borrowing [Unidoc.Linker.ExtensionSignature],
+        conditions:borrowing [Unidoc.Linker.ExtensionConditions],
         extensions:borrowing [SymbolGraph.Extension],
         modules:borrowing [SymbolGraph.ModuleContext],
         context:inout Unidoc.Linker)
     {
         self = [:]
 
-        for (`extension`, signature):(SymbolGraph.Extension, Unidoc.Linker.ExtensionSignature)
-            in zip(extensions, signatures)
+        for (conditions, `extension`):
+            (Unidoc.Linker.ExtensionConditions, SymbolGraph.Extension) in zip(
+            conditions,
+            extensions)
         {
-            let module:SymbolGraph.ModuleContext = modules[`extension`.culture]
+            let module:SymbolGraph.ModuleContext = modules[conditions.culture]
             for p:Int32 in `extension`.conformances
             {
                 //  Only track conformances that were declared by modules in
                 //  the current package.
                 if  let p:Unidoc.Scalar = context.current.scalars.decls[p],
                     case false = module.already(conforms: subject, to: p)
                 {
-                    self[to: p].append(.init(
-                        conditions: signature.conditions,
-                        culture: `extension`.culture))
+                    self[to: p].append(conditions)
                 }
             }
         }
 
-        for i:Dictionary<Unidoc.Scalar, [ProtocolConformance<Int>]>.Index in self.table.indices
+        for i:Dictionary<Unidoc.Scalar, [Unidoc.Linker.ExtensionConditions]>.Index
+            in self.table.indices
         {
             let `protocol`:Unidoc.Scalar = self.table.keys[i]
             context.simplify(conformances: &self.table.values[i],

Sources/UnidocLinker/Sema/ProtocolConformances.swift

@@ -0,0 +1,17 @@
+extension Unidoc.Linker.Extension
+{
+    struct ID:Equatable, Hashable, Sendable
+    {
+        let index:Int
+
+        init(index:Int)
+        {
+            self.index = index
+        }
+    }
+}
+extension Unidoc.Linker.Extension.ID:Comparable
+{
+    static
+    func < (a:Self, b:Self) -> Bool { a.index < b.index }
+}

Sources/UnidocLinker/Sema/Unidoc.Linker.Extension.ID.swift

@@ -5,7 +5,7 @@ extension Unidoc.Linker
 {
     struct Extension:Identifiable, Equatable, Sendable
     {
-        let id:Unidoc.Group.ID
+        let id:ID
 
         var conformances:[Unidoc.Scalar]
         var features:[Unidoc.Scalar]
@@ -15,7 +15,7 @@ extension Unidoc.Linker
         var overview:Unidoc.Passage?
         var details:Unidoc.Passage?
 
-        init(id:Unidoc.Group.ID,
+        init(id:ID,
             conformances:[Unidoc.Scalar] = [],
             features:[Unidoc.Scalar] = [],
             nested:[Unidoc.Scalar] = [],

Sources/UnidocLinker/Sema/Unidoc.Linker.Extension.swift

@@ -0,0 +1,17 @@
+import Signatures
+import Unidoc
+
+extension Unidoc.Linker
+{
+    struct ExtensionConditions:Equatable, Hashable, Sendable
+    {
+        let constraints:[GenericConstraint<Unidoc.Scalar?>]
+        let culture:Int
+
+        init(constraints:[GenericConstraint<Unidoc.Scalar?>], culture:Int)
+        {
+            self.constraints = constraints
+            self.culture = culture
+        }
+    }
+}

Sources/UnidocLinker/Sema/Unidoc.Linker.ExtensionConditions.swift

@@ -5,17 +5,25 @@ extension Unidoc.Linker
 {
     struct ExtensionSignature:Equatable, Hashable, Sendable
     {
-        let conditions:[GenericConstraint<Unidoc.Scalar?>]
-        let culture:Int
-        let extends:Unidoc.Scalar
+        let conditions:ExtensionConditions
+        let extendee:Unidoc.Scalar
 
-        init(conditions:[GenericConstraint<Unidoc.Scalar?>],
-            culture:Int,
-            extends:Unidoc.Scalar)
+        private
+        init(conditions:ExtensionConditions, extendee:Unidoc.Scalar)
         {
             self.conditions = conditions
-            self.culture = culture
-            self.extends = extends
+            self.extendee = extendee
         }
     }
 }
+extension Unidoc.Linker.ExtensionSignature
+{
+    static
+    func extends(_ extendee:consuming Unidoc.Scalar,
+        where conditions:consuming Unidoc.Linker.ExtensionConditions) -> Self
+    {
+        .init(conditions: conditions, extendee: extendee)
+    }
+
+    var culture:Int { self.conditions.culture }
+}