Merge pull request #330 from tayloraswift/linker-lite

lightweight dynamic linker optimized for SGABI ≥ 0.10

Author: tayloraswift

Sources/SymbolGraphCompiler/Declarations/SSGC.DeclObject.swift

@@ -27,7 +27,8 @@ extension SSGC
         ///
         /// In the example above, the second conformance likely originated from a
         /// `Foo<T>:Hashable where T:Hashable` conformance.
-        var conformances:[Symbol.Decl: Set<Set<GenericConstraint<Symbol.Decl>>>]
+        var conformanceStatements:[Symbol.Decl: Set<Set<GenericConstraint<Symbol.Decl>>>]
+        var conformances:[Symbol.Decl: Set<GenericConstraint<Symbol.Decl>>]
 
         /// The type of the superforms tracked by ``\.value.superforms``.
         var superforms:(any SuperformRelationship.Type)?
@@ -54,6 +55,7 @@ extension SSGC
             self.culture = culture
             self.access = access
 
+            self.conformanceStatements = [:]
             self.conformances = [:]
             self.superforms = nil
             self.scopes = []
@@ -62,6 +64,14 @@ extension SSGC
         }
     }
 }
+extension SSGC.DeclObject:Equatable
+{
+    static func == (a:SSGC.DeclObject, b:SSGC.DeclObject) -> Bool { a === b }
+}
+extension SSGC.DeclObject:Hashable
+{
+    func hash(into hasher:inout Hasher) { hasher.combine(ObjectIdentifier.init(self)) }
+}
 extension SSGC.DeclObject
 {
     var id:Symbol.Decl

Sources/SymbolGraphCompiler/SSGC.TypeChecker.swift

@@ -138,26 +138,42 @@ extension SSGC.TypeChecker
         }
 
         //  Pass II. Populate protocol conformance tables and nesting relationships.
-        for part:SSGC.SymbolDump in culture.symbols
+        let typesConformed:Set<SSGC.DeclObject> = try culture.symbols.reduce(into: [])
         {
-            for conformance:Symbol.ConformanceRelationship in part.conformances
+            for conformance:Symbol.ConformanceRelationship in $1.conformances
             {
-                try conformance.do { try self.insert($0, by: id) }
+                let typeConformed:SSGC.DeclObject? = try conformance.do
+                {
+                    try self.collectConformance($0, by: id)
+                }
+                if  let typeConformed:SSGC.DeclObject
+                {
+                    $0.insert(typeConformed)
+                }
             }
-            for inheritance:Symbol.InheritanceRelationship in part.inheritances
+
+            for inheritance:Symbol.InheritanceRelationship in $1.inheritances
             {
                 try inheritance.do { try self.insert($0, by: id) }
             }
 
-            for nesting:Symbol.RequirementRelationship in part.requirements
+            for nesting:Symbol.RequirementRelationship in $1.requirements
             {
                 try nesting.do { try self.assign($0) }
             }
-            for nesting:Symbol.MemberRelationship in part.memberships
+            for nesting:Symbol.MemberRelationship in $1.memberships
             {
                 try nesting.do { try self.assign($0, by: id) }
             }
         }
+
+        //  This uses information about the superforms of a type to simplify the constraints,
+        //  which is why it is done after the inheritance relationships are recorded.
+        for type:SSGC.DeclObject in typesConformed
+        {
+            try self.computeConformances(of: type, by: id)
+        }
+
         //  lib/SymbolGraphGen fails to emit a `memberOf` edge if the member is a default
         //  implementation of a protocol requirement. Because the requirement might be a
         //  requirement from a different protocol than the protocol containing the default
@@ -306,19 +322,18 @@ extension SSGC.TypeChecker
 extension SSGC.TypeChecker
 {
     private mutating
-    func insert(_ conformance:Symbol.ConformanceRelationship, by culture:Symbol.Module) throws
+    func collectConformance(_ conformance:Symbol.ConformanceRelationship,
+        by culture:Symbol.Module) throws -> SSGC.DeclObject?
     {
         guard
         let target:SSGC.DeclObject = self.declarations[visible: conformance.target]
         else
         {
-            return
+            return nil
         }
 
         let conditions:Set<GenericConstraint<Symbol.Decl>> = .init(conformance.conditions)
-
-        let typeExtension:SSGC.ExtensionObject
-        let typeConformed:SSGC.DeclObject
+        let conformer:SSGC.DeclObject
 
         switch conformance.source
         {
@@ -331,7 +346,7 @@ extension SSGC.TypeChecker
             let type:SSGC.DeclObject = self.declarations[visible: symbol]
             else
             {
-                return
+                return nil
             }
 
             if  let origin:Symbol.Decl = conformance.origin
@@ -346,35 +361,33 @@ extension SSGC.TypeChecker
                 try type.add(superform: Symbol.InheritanceRelationship.init(
                     by: type.id,
                     of: target.id))
-                return
+                return nil
             }
-            //  Generate an implicit, internal extension for this conformance,
-            //  if one does not already exist.
-            typeExtension = self.extensions[extending: type, where: conditions]
-            typeConformed = type
+
+            conformer = type
 
         case .block(let symbol):
             //  Look up the extension associated with this block name.
-            typeExtension = try self.extensions[named: symbol]
+            let named:SSGC.ExtensionObject = try self.extensions[named: symbol]
 
             guard
-            let type:SSGC.DeclObject = self.declarations[visible: typeExtension.extendee]
+            let type:SSGC.DeclObject = self.declarations[visible: named.extendee]
             else
             {
-                return
+                return nil
             }
 
-            typeConformed = type
+            conformer = type
 
-            guard typeExtension.conditions == conditions
+            guard named.conditions == conditions
             else
             {
-                throw SSGC.ExtensionSignatureError.init(expected: typeExtension.signature)
+                throw SSGC.ExtensionSignatureError.init(expected: named.signature)
             }
         }
 
-        typeConformed.conformances[target.id, default: []].insert(conditions)
-        typeExtension.add(conformance: target.id, by: culture)
+        conformer.conformanceStatements[target.id, default: []].insert(conditions)
+        return conformer
     }
 
     private mutating
@@ -397,7 +410,86 @@ extension SSGC.TypeChecker
             superform.kinks[is: .implemented] = true
         }
     }
+}
+extension SSGC.TypeChecker
+{
+    private
+    func computeConformance(where conditions:Set<Set<GenericConstraint<Symbol.Decl>>>,
+        to target:Symbol.Decl,
+        of type:SSGC.DeclObject) throws -> Set<GenericConstraint<Symbol.Decl>>
+    {
+        do
+        {
+            return try conditions.simplified(with: self.declarations)
+        }
+        catch SSGC.ConstraintReductionError.chimaeric(let reduced, from: let lists)
+        {
+            throw AssertionError.init(message: """
+                Failed to simplify constraints for conditional conformance \
+                (\(target)) of '\(type.value.path)' because multiple conflicting \
+                conformances unify to a heterogeneous set of constraints
+
+                Declared constraints: \(lists)
+                Simplified constraints: \(reduced)
+                """)
+        }
+        catch SSGC.ConstraintReductionError.redundant(let reduced, from: let lists)
+        {
+            throw AssertionError.init(message: """
+                Failed to simplify constraints for conditional conformance \
+                (\(target)) of '\(type.value.path)' because at least one of the \
+                constraint lists had redundancies within itself
+
+                Declared constraints: \(lists)
+                Simplified constraints: \(reduced)
+                """)
+        }
+    }
+    private mutating
+    func computeConformances(of type:SSGC.DeclObject, by culture:Symbol.Module) throws
+    {
+        for (target, overlapping):(Symbol.Decl, Set<Set<GenericConstraint<Symbol.Decl>>>)
+            in type.conformanceStatements
+        {
+            try
+            {
+                //  A Swift type may only conform to a protocol once, even with different
+                //  conditional constraints.
+                //
+                //  Exiting here not only prevents us from doing unnecessary simplification
+                //  work, but also prevents us from accidentally capturing another module’s
+                //  conformances as our own.
+                //
+                //  For example: `Foundation` conforms `Array` to `Sequence` where `Element`
+                //  is `UInt8`. Because the constraints are different (and tighter) than the
+                //  original conformance, our regular de-duplication logic would not flag this
+                //  as a duplicate were it not for this guard.
+                guard case nil = $0
+                else
+                {
+                    return
+                }
+
+                let canonical:Set<GenericConstraint<Symbol.Decl>> = try self.computeConformance(
+                    where: overlapping,
+                    to: target,
+                    of: type)
+
+                //  Generate an implicit, internal extension for this conformance,
+                //  if one does not already exist.
+                self.extensions[extending: type, where: canonical].add(conformance: target,
+                    by: culture)
+                $0 = canonical
+
+            } (&type.conformances[target])
+        }
 
+        //  We don’t need this table anymore.
+        type.conformanceStatements = [:]
+    }
+}
+extension SSGC.TypeChecker
+{
     private mutating
     func insert(_ relationship:Symbol.FeatureRelationship, by culture:Symbol.Module) throws
     {
@@ -454,37 +546,8 @@ extension SSGC.TypeChecker
                     """)
             }
 
-            let conditions:Set<GenericConstraint<Symbol.Decl>>?
-            do
-            {
-                conditions = try heir.conformances[conformance]?.simplify(
-                    with: self.declarations)
-            }
-            catch SSGC.ConstraintReductionError.chimaeric(let reduced, from: let lists)
-            {
-                throw AssertionError.init(message: """
-                    Failed to simplify constraints for conditional conformance \
-                    (\(conformance)) of '\(heir.value.path)' because multiple conflicting \
-                    conformances unify to a heterogeneous set of constraints
-
-                    Declared constraints: \(lists)
-                    Simplified constraints: \(reduced)
-                    """)
-            }
-            catch SSGC.ConstraintReductionError.redundant(let reduced, from: let lists)
-            {
-                throw AssertionError.init(message: """
-                    Failed to simplify constraints for conditional conformance \
-                    (\(conformance)) of '\(heir.value.path)' because at least one of the \
-                    constraint lists had redundancies within itself
-
-                    Declared constraints: \(lists)
-                    Simplified constraints: \(reduced)
-                    """)
-            }
-
             guard
-            let conditions:Set<GenericConstraint<Symbol.Decl>>
+            let conditions:Set<GenericConstraint<Symbol.Decl>> = heir.conformances[conformance]
             else
             {
                 throw AssertionError.init(message: """

Sources/SymbolGraphCompiler/Set (ext).swift

@@ -3,32 +3,6 @@ import Symbols
 
 extension Set<Set<GenericConstraint<Symbol.Decl>>>
 {
-    mutating
-    func simplify(
-        with declarations:SSGC.Declarations) throws -> Set<GenericConstraint<Symbol.Decl>>
-    {
-        guard
-        var first:Set<GenericConstraint<Symbol.Decl>> = self.first
-        else
-        {
-            return []
-        }
-
-        if  self.count == 1
-        {
-            return first
-        }
-        else
-        {
-            first = try self.simplified(with: declarations)
-        }
-
-        //  Cache the simplified constraints so that the next query is faster.
-        self = [first]
-        return first
-    }
-
-    private
     func simplified(
         with declarations:SSGC.Declarations) throws -> Set<GenericConstraint<Symbol.Decl>>
     {

Sources/SymbolGraphCompiler/SymbolRelationship (ext).swift

@@ -2,11 +2,11 @@ import SymbolGraphParts
 
 extension SymbolRelationship
 {
-    func `do`(_ body:(Self) throws -> Void) rethrows
+    func `do`<T>(_ body:(Self) throws -> T) rethrows -> T
     {
         do
         {
-            try body(self)
+            return try body(self)
         }
         catch let error
         {

Sources/SymbolGraphs/SymbolGraphABI.swift

@@ -3,5 +3,5 @@ import SemanticVersions
 @frozen public
 enum SymbolGraphABI
 {
-    @inlinable public static var version:PatchVersion { .v(0, 10, 3) }
+    @inlinable public static var version:PatchVersion { .v(0, 11, 0) }
 }