add support for protocol composition types in the type signature disambiguation syntax

Author: tayloraswift

Sources/UCF/Codelinks/Grammar/UCF.NominalPatternRule.swift

@@ -2,22 +2,27 @@ import Grammar
 
 extension UCF
 {
-    /// NominalPattern ::= PathComponent ( '.' PathComponent ) *
+    /// NominalPattern ::= PathComponents ( '&' PathComponents ) *
+    /// PathComponents ::= PathComponent ( '.' PathComponent ) *
     enum NominalPatternRule:ParsingRule
     {
         typealias Location = String.Index
         typealias Terminal = Unicode.Scalar
 
-        typealias Construction = [(Range<Location>, [UCF.TypePattern])]
+        typealias Construction = [[(Range<Location>, [UCF.TypePattern])]]
 
         static func parse<Diagnostics>(
             _ input:inout ParsingInput<Diagnostics>) throws -> Construction where
             Diagnostics:ParsingDiagnostics,
             Diagnostics.Source.Element == Terminal,
             Diagnostics.Source.Index == Location
         {
-            try input.parse(as: Pattern.Join<PathComponent,
-                UnicodeEncoding<Location, Terminal>.Period,
+            try input.parse(as: Pattern.Join<Pattern.Join<PathComponent,
+                    UnicodeEncoding<Location, Terminal>.Period,
+                    Construction.Element>,
+                Pattern.Pad<
+                    UnicodeEncoding<Location, Terminal>.Ampersand,
+                    UnicodeEncoding<Location, Terminal>.Space>,
                 Construction>.self)
         }
     }

Sources/UCF/Codelinks/Grammar/UCF.TypeOperand.swift

@@ -4,7 +4,7 @@ extension UCF
     {
         case bracket(TypePattern, TypePattern?)
         case closure([TypePattern], TypePattern)
-        case nominal([(Range<String.Index>, [TypePattern])])
+        case nominal([[(Range<String.Index>, [TypePattern])]])
         /// A single parenthesized type, or nil if the type is a placeholder (`_`).
         case single(TypePattern?)
         /// A tuple containing either zero or two or more types.

Sources/UCF/Codelinks/Grammar/UCF.TypePattern.swift

@@ -90,42 +90,55 @@ extension UCF.TypePattern
             string.append(")->")
             output.format(source: source, into: &string)
 
-        case .nominal(let path):
+        case .nominal(let composition):
             var first:Bool = true
-            for (component, generics):(Range<String.Index>, [UCF.TypePattern]) in path
+            for path:[(Range<String.Index>, [UCF.TypePattern])] in composition
             {
                 if  first
                 {
                     first = false
                 }
                 else
                 {
-                    string.append(".")
+                    string.append("&")
                 }
 
-                string += source[component]
-
-                if  generics.isEmpty
-                {
-                    continue
-                }
-
-                string.append("<")
                 var first:Bool = true
-                for type:UCF.TypePattern in generics
+                for (component, generics):(Range<String.Index>, [UCF.TypePattern]) in path
                 {
                     if  first
                     {
                         first = false
                     }
                     else
                     {
-                        string.append(",")
+                        string.append(".")
+                    }
+
+                    string += source[component]
+
+                    if  generics.isEmpty
+                    {
+                        continue
                     }
 
-                    type.format(source: source, into: &string)
+                    string.append("<")
+                    var first:Bool = true
+                    for type:UCF.TypePattern in generics
+                    {
+                        if  first
+                        {
+                            first = false
+                        }
+                        else
+                        {
+                            string.append(",")
+                        }
+
+                        type.format(source: source, into: &string)
+                    }
+                    string.append(">")
                 }
-                string.append(">")
             }
 
         case .single(let type?):

Sources/UCF/Codelinks/Grammar/UCF.TypePatternRule.PostfixOperand.swift

@@ -14,10 +14,12 @@ extension UCF.TypePatternRule
             Diagnostics.Source.Element == Terminal,
             Diagnostics.Source.Index == Location
         {
-            if  let path:[(Range<Location>, [UCF.TypePattern])] = input.parse(
+            if  let composition:[[(Range<Location>, [UCF.TypePattern])]] = input.parse(
                     as: UCF.NominalPatternRule?.self)
             {
-                if  let (range, generics):(Range<Location>, [UCF.TypePattern]) = path.first,
+                if  let path:[(Range<Location>, [UCF.TypePattern])] = composition.first,
+                    composition.count == 1,
+                    let (range, generics):(Range<Location>, [UCF.TypePattern]) = path.first,
                     generics.isEmpty,
                     path.count == 1,
                     input.source.index(after: range.lowerBound) == range.upperBound,
@@ -26,7 +28,7 @@ extension UCF.TypePatternRule
                     return .single(nil)
                 }
 
-                return .nominal(path)
+                return .nominal(composition)
             }
             else if
                 let (first, value):(UCF.TypePattern, UCF.TypePattern?) = input.parse(

Sources/UCFTests/CodelinkDisambiguators.swift

@@ -106,6 +106,22 @@ struct CodelinkDisambiguators:ParsingSuite
             signature: .returns(["Set<String>"]))))
     }
     @Test
+    static func SignatureProtocolComposition() throws
+    {
+        let link:UCF.Selector = try Self.roundtrip("""
+            Foo.bar(_:_:) (StringProtocol & Error, [Sendable & RandomAccessCollection<UInt8>])
+            """)
+        #expect(link.base == .relative)
+        #expect(link.path.components == ["Foo", "bar(_:_:)"])
+        #expect(link.path.hasTrailingParentheses)
+        #expect(link.suffix == .unidoc(.init(
+            conditions: [],
+            signature: .function([
+                "StringProtocol&Error",
+                "[Sendable&RandomAccessCollection<UInt8>]"
+            ]))))
+    }
+    @Test
     static func All() throws
     {
         let link:UCF.Selector = try Self.roundtrip("""