Merge pull request #318 from tayloraswift/multiple-origins

Multiple origins

Author: tayloraswift

Sources/SymbolGraphBuilder/SSGC.Compile.swift

@@ -182,6 +182,9 @@ extension SSGC.Compile
         }
         catch let error as SSGC.DocumentationBuildError
         {
+            //  We need to print the error here, otherwise it will be lost.
+            print(error)
+
             switch error
             {
             case .scanning: try status.send(.failedToLoadSymbolGraph)

Sources/SymbolGraphCompiler/Declarations/SSGC.Decl.swift

@@ -44,10 +44,11 @@ extension SSGC
         public internal(set)
         var superforms:Set<Symbol.Decl>
 
-        /// A scalar that has documentation that is relevant, but less specific
-        /// to this scalar.
+        /// Scalars that potentially have documentation that is relevant, but less specific
+        /// to this scalar. Only one will be ultimately used, but the others are kept for
+        /// de-duplication purposes.
         public internal(set)
-        var origin:Symbol.Decl?
+        var origins:Set<Symbol.Decl>
         public internal(set)
         var kinks:Phylum.Decl.Kinks
 
@@ -73,7 +74,7 @@ extension SSGC
             self.requirements = []
             self.inhabitants = []
             self.superforms = []
-            self.origin = nil
+            self.origins = []
 
             self.kinks = kinks
             self.comment = comment

Sources/SymbolGraphCompiler/Declarations/SSGC.DeclObject.swift

@@ -78,16 +78,9 @@ extension SSGC.DeclObject
 extension SSGC.DeclObject
 {
     /// Assigns an origin to this scalar object.
-    func assign(origin:Symbol.Decl) throws
+    func assign(origin:Symbol.Decl)
     {
-        switch self.value.origin
-        {
-        case nil, origin?:
-            self.value.origin = origin
-
-        case let other?:
-            throw SSGC.SemanticError.already(has: .origin(other))
-        }
+        self.value.origins.insert(origin)
     }
     /// Assigns a lexical scope to this scalar object.
     func assign(scope:Symbol.Decl, by relationship:some NestingRelationship) throws
@@ -107,7 +100,7 @@ extension SSGC.DeclObject
         case let existing?:
             if  case .s = self.id.language
             {
-                throw SSGC.SemanticError.already(has: .scope(existing))
+                throw SSGC.LexicalScopeError.multiple(existing, scope)
             }
             else
             {
@@ -122,7 +115,7 @@ extension SSGC.DeclObject
 
         if  let origin:Symbol.Decl = relationship.origin
         {
-            try self.assign(origin: origin)
+            self.assign(origin: origin)
         }
     }
     /// Adds a superform to this scalar object.
@@ -155,7 +148,7 @@ extension SSGC.DeclObject
         }
         if  let origin:Symbol.Decl = relationship.origin
         {
-            try self.assign(origin: origin)
+            self.assign(origin: origin)
         }
     }
     /// Adds a requirement to this scalar object, assuming it is a protocol.

Sources/SymbolGraphCompiler/Declarations/SSGC.Declarations.swift

@@ -150,12 +150,17 @@ extension SSGC.Declarations
             var decl:SSGC.Decl = $1.value
 
             //  Strip duplicated doccomments
-            if  let documentationComment:SSGC.DocumentationComment = decl.comment,
-                let origin:Symbol.Decl = decl.origin,
-                let originComment:SSGC.DocumentationComment = self.decls[origin]?.value.comment,
-                    originComment.text == documentationComment.text
+            if  let documentationComment:SSGC.DocumentationComment = decl.comment
             {
-                decl.comment = nil
+                for origin:Symbol.Decl in decl.origins
+                {
+                    if  let origin:SSGC.Decl = self.decls[origin]?.value,
+                        let originComment:SSGC.DocumentationComment = origin.comment,
+                            originComment.text == documentationComment.text
+                    {
+                        decl.comment = nil
+                    }
+                }
             }
 
             $0[$1.namespace, default: []].append(decl)

Sources/SymbolGraphCompiler/SSGC.TypeChecker.swift

@@ -370,7 +370,7 @@ extension SSGC.TypeChecker
 
             if  let origin:Symbol.Decl = conformance.origin
             {
-                try type.assign(origin: origin)
+                type.assign(origin: origin)
             }
             if  case .protocol = type.value.phylum
             {

Sources/SymbolGraphCompiler/Sema/SSGC.LexicalScopeError.swift

@@ -0,0 +1,23 @@
+import Symbols
+
+extension SSGC
+{
+    enum LexicalScopeError:Error, Sendable
+    {
+        case multiple(Symbol.Decl, Symbol.Decl)
+    }
+}
+extension SSGC.LexicalScopeError:CustomStringConvertible
+{
+    public
+    var description:String
+    {
+        switch self
+        {
+        case .multiple(let existing, let scope):
+            """
+            Scalar already has a lexical scope (\(existing)) and cannot have another (\(scope))
+            """
+        }
+    }
+}

Sources/SymbolGraphCompiler/Sema/SSGC.SemanticError.Counterpart.swift

@@ -5,7 +5,6 @@ extension SSGC
     public
     enum SemanticError:Error, Sendable
     {
-        case already(has:Counterpart)
         case cannot(have:Counterparts, as:Phylum.Decl)
     }
 }
@@ -16,26 +15,20 @@ extension SSGC.SemanticError:CustomStringConvertible
     {
         switch self
         {
-        case .already(has: .origin(let symbol)):
-            "Scalar already has an origin, \(symbol)."
-
-        case .already(has: .scope(let symbol)):
-            "Scalar already has a lexical scope, \(symbol)."
-
         case .cannot(have: .requirements, as: let phylum):
-            "Scalar of phylum '\(phylum)' cannot have requirements."
+            "Scalar of phylum '\(phylum)' cannot have requirements"
 
         case .cannot(have: .inhabitants, as: let phylum):
-            "Scalar of phylum '\(phylum)' cannot have enumeration cases."
+            "Scalar of phylum '\(phylum)' cannot have enumeration cases"
 
         case .cannot(have: .scope, as: let phylum):
-            "Scalar of phylum '\(phylum)' cannot have a lexical scope."
+            "Scalar of phylum '\(phylum)' cannot have a lexical scope"
 
         case .cannot(have: .superforms(besides: nil), as: let phylum):
-            "Scalar of phylum '\(phylum)' cannot have superforms."
+            "Scalar of phylum '\(phylum)' cannot have superforms"
 
         case .cannot(have: .superforms(besides: let type?), as: _):
-            "Scalar already has superforms of type \(type)."
+            "Scalar already has superforms of type \(type)"
         }
     }
 }

Sources/SymbolGraphCompiler/Sema/SSGC.SemanticError.swift

@@ -542,7 +542,9 @@ extension SSGC.Linker
         let requirements:[Int32] = decl.requirements.sorted().map { self.tables.intern($0) }
         let inhabitants:[Int32] = decl.inhabitants.sorted().map { self.tables.intern($0) }
         let superforms:[Int32] = decl.superforms.sorted().map { self.tables.intern($0) }
-        let origin:Int32? = decl.origin.map { self.tables.intern($0) }
+        /// We don’t have a great way to choose which origin to keep, so we just keep the first
+        /// one in alphabetical order.
+        let origin:Int32? = decl.origins.sorted().first.map { self.tables.intern($0) }
 
         let location:SourceLocation<Int32>? = decl.location?.map
         {

Sources/SymbolGraphLinker/SSGC.Linker.swift

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