fix a number of bugs in the dynamic link resolver, and add regression tests to UnidocQueryTests

Author: tayloraswift

Package.swift

@@ -450,6 +450,7 @@ let package:Package = .init(
 
         .target(name: "Symbols",
             dependencies: [
+                .target(name: "FNV1"),
                 .target(name: "Sources"),
             ]),
 

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

@@ -235,7 +235,7 @@ extension Swiftinit.Docs.DeclPage:Swiftinit.VertexPage
                 {
                     $0[.code]
                     {
-                        let hash:FNV24 = .init(hashing: "\(self.vertex.symbol)")
+                        let hash:FNV24 = .init(truncating: .decl(self.vertex.symbol))
                         $0 += "FNV24: ["
                         $0[.span] { $0.class = "fnv24" } = "\(hash)"
                         $0 += "]"

Sources/SymbolGraphLinker/Resolution/SSGC.Outliner.swift

@@ -153,32 +153,32 @@ extension SSGC.Outliner
     private mutating
     func outline(translating link:Markdown.SourceString, to url:Substring) -> Int?
     {
-        self.cache.append(outline: .unresolved(.init(
-            link: String.init(url),
-            type: .web,
-            location: link.source.start)))
+        self.cache.append(outline: .unresolved(web: String.init(url),
+            location: link.source.start))
     }
 
     private mutating
     func outline(link:Markdown.SourceString, code:Bool) -> Int?
     {
         self.cache(link.string)
         {
-            var type:SymbolGraph.Outline.Unresolved.LinkType? = nil
+            resolution:
             if  code
             {
-                if  let codelink:Codelink = .init(link.string)
+                guard
+                let codelink:Codelink = .init(link.string)
+                else
                 {
-                    if  let outline:SymbolGraph.Outline = self.resolver.outline(codelink,
-                            at: link.source)
-                    {
-                        return outline
-                    }
-                    else
-                    {
-                        type = .ucf
-                    }
+                    break resolution
                 }
+
+                if  let outline:SymbolGraph.Outline = self.resolver.outline(codelink,
+                        at: link.source)
+                {
+                    return outline
+                }
+
+                return .unresolved(ucf: link.string, location: link.source.start)
             }
             else if let doclink:Doclink = .init(doc: link.string[...])
             {
@@ -195,29 +195,17 @@ extension SSGC.Outliner
                 {
                     return outline
                 }
-                else
-                {
-                    self.resolver.diagnostics[link.source] =
-                        Warning.doclinkNotStaticallyResolvable(doclink)
-
-                    type = .doc
-                }
-            }
 
-            if  let type:SymbolGraph.Outline.Unresolved.LinkType
-            {
-                return .unresolved(.init(
-                    link: link.string,
-                    type: type,
-                    location: link.source.start))
-            }
-            else
-            {
                 self.resolver.diagnostics[link.source] =
-                    InvalidAutolinkError<SSGC.Symbolicator>.init(link)
+                    Warning.doclinkNotStaticallyResolvable(doclink)
 
-                return nil
+                return .unresolved(doc: link.string, location: link.source.start)
             }
+
+            self.resolver.diagnostics[link.source] =
+                InvalidAutolinkError<SSGC.Symbolicator>.init(link)
+
+            return nil
         }
     }
 }

Sources/SymbolGraphLinker/SSGC.Linker.swift

@@ -169,7 +169,7 @@ extension SSGC.Linker
                     self.symbolizer.graph.namespaces[destination.index]
                 for (scalar, decl) in zip(destination.range, source.decls)
                 {
-                    let hash:FNV24 = .init(hashing: "\(decl.id)")
+                    let hash:FNV24 = .init(truncating: .decl(decl.id))
                     //  Make the decl visible to codelink resolution.
                     self.tables.codelinks[qualifier, decl.path].overload(with: .init(
                         target: .scalar(scalar),
@@ -353,7 +353,7 @@ extension SSGC.Linker
             self.tables.codelinks[namespace].overload(with: .init(
                 target: .scalar(n * .module),
                 phylum: nil,
-                hash: .init(hashing: "\(namespace)")))
+                hash: .init(truncating: .module(namespace))))
         }
 
         return articles

Sources/SymbolGraphLinkerTests/Main.LinkResolution.swift

@@ -133,8 +133,8 @@ extension Main.LinkResolution:TestBattery
                     tests.expect(value: $0.outline(reference: .code(_string("A.c"))))
 
                     tests.expect($0.outlines() ..? [
-                        .unresolved(.init(link: "A.b", type: .ucf, location: nil)),
-                        .unresolved(.init(link: "A.c", type: .ucf, location: nil))
+                        .unresolved(ucf: "A.b", location: nil),
+                        .unresolved(ucf: "A.c", location: nil)
                     ])
                 }
             }

Sources/SymbolGraphs/Articles/SymbolGraph.Outline.Unresolved.LinkType.swift

@@ -3,7 +3,8 @@ extension SymbolGraph.Outline.Unresolved
     @frozen public
     enum LinkType:Equatable, Hashable, Sendable
     {
-        /// The associated text is an unresolved doclink.
+        /// The associated text is an unresolved doclink. The string does **not** include the
+        /// `doc:` scheme.
         case doc
         /// The associated text is an untranslated web URL. The string does **not** include a
         /// scheme.

Sources/SymbolGraphs/Articles/SymbolGraph.Outline.Unresolved.swift

@@ -12,7 +12,7 @@ extension SymbolGraph.Outline
         public
         let location:SourceLocation<Int32>?
 
-        @inlinable public
+        @inlinable
         init(link:String, type:LinkType, location:SourceLocation<Int32>?)
         {
             self.link = link

Sources/SymbolGraphs/Articles/SymbolGraph.Outline.swift

@@ -12,6 +12,27 @@ extension SymbolGraph
         case unresolved(Unresolved)
     }
 }
+//  These are only here to make it obvious these links do not contain a scheme.
+extension SymbolGraph.Outline
+{
+    @inlinable public static
+    func unresolved(doc link:String, location:SourceLocation<Int32>?) -> Self
+    {
+        .unresolved(.init(link: link, type: .doc, location: location))
+    }
+
+    @inlinable public static
+    func unresolved(web link:String, location:SourceLocation<Int32>?) -> Self
+    {
+        .unresolved(.init(link: link, type: .web, location: location))
+    }
+
+    @inlinable public static
+    func unresolved(ucf link:String, location:SourceLocation<Int32>?) -> Self
+    {
+        .unresolved(.init(link: link, type: .ucf, location: location))
+    }
+}
 extension SymbolGraph.Outline
 {
     public

Sources/SymbolGraphs/Grouping/SymbolGraph.Extension.swift

@@ -8,6 +8,11 @@ extension SymbolGraph
     {
         public
         let conditions:[GenericConstraint<Int32>]
+        /// The index of the namespace in which the extended type is declared. For extensions
+        /// that extend types declared in the **same package**, this is the same index as the
+        /// one you would obtaine by iterating cultural namespaces, and is therefore redundant.
+        /// For extensions that extend types declared in **other packages**, this is the
+        /// **only** way to know what namespace the extended type is declared in.
         public
         let namespace:Int
         public

Sources/Symbols/Identifiers/FNV24.Extended (ext).swift

@@ -0,0 +1,28 @@
+import FNV1
+
+extension FNV24.Extended
+{
+    @inlinable public static
+    func decl(_ symbol:Symbol.Decl.Vector) -> Self
+    {
+        .init(hashing: "\(symbol)")
+    }
+    @inlinable public static
+    func decl(_ symbol:Symbol.Decl) -> Self
+    {
+        //  No added prefix, as ``Symbol.Decl.description`` already includes a `s:` prefix.
+        .init(hashing: "\(symbol)")
+    }
+
+    @inlinable public static
+    func module(_ symbol:Symbol.Module) -> Self
+    {
+        .init(hashing: "s:m:\(symbol)")
+    }
+    @inlinable public static
+    func product(_ name:String) -> Self
+    {
+        //  Not the ``Symbol.Product``!
+        .init(hashing: "s:p:\(name)")
+    }
+}