discriminate empty trailing parentheses

Author: tayloraswift

Sources/LinkResolution/UCF.Predicate.swift

@@ -0,0 +1,16 @@
+import UCF 
+
+extension UCF
+{
+    struct Predicate
+    {
+        let suffix:Selector.Suffix?
+        let hasEmptyTrailingParentheses:Bool
+
+        init(suffix:Selector.Suffix?, hasEmptyTrailingParentheses:Bool)
+        {
+            self.suffix = suffix
+            self.hasEmptyTrailingParentheses = hasEmptyTrailingParentheses
+        }
+    }
+}

Sources/LinkResolution/UCF.ResolutionTable.Search.swift

@@ -7,14 +7,14 @@ extension UCF.ResolutionTable
     struct Search
     {
         private
-        let predicate:UCF.Selector.Suffix?
+        let predicate:UCF.Predicate
 
         private
         var selected:[Symbol.Decl: Overload]
         private
         var rejected:[Symbol.Decl: Overload]
 
-        init(matching predicate:UCF.Selector.Suffix?)
+        init(matching predicate:UCF.Predicate)
         {
             self.predicate = predicate
             self.selected = [:]
@@ -29,26 +29,16 @@ extension UCF.ResolutionTable.Search
     {
         //  Because of the way `@_exported` paths are represented in the search tree, it is 
         //  possible to encounter the same overload multiple times, due to namespace inference
-        if  let predicate:UCF.Selector.Suffix = self.predicate
+        for overload:Overload in candidates
         {
-            for overload:Overload in candidates
+            guard self.predicate ~= overload
+            else
             {
-                guard predicate ~= overload
-                else
-                {
-                    self.rejected[overload.id] = overload
-                    continue
-                }
-
-                self.selected[overload.id] = overload
-            }
-        }
-        else
-        {
-            for overload:Overload in candidates
-            {
-                self.selected[overload.id] = overload
+                self.rejected[overload.id] = overload
+                continue
             }
+
+            self.selected[overload.id] = overload
         }
     }
 

Sources/LinkResolution/UCF.ResolutionTable.swift

@@ -99,17 +99,16 @@ extension UCF.ResolutionTable
 extension UCF.ResolutionTable
 {
     public
-    func resolve(qualified path:UCF.Selector.Path,
-        matching suffix:UCF.Selector.Suffix?) -> UCF.Resolution<Overload>
+    func resolve(qualified:UCF.Selector) -> UCF.Resolution<Overload>
     {
-        var search:Search = .init(matching: suffix)
-        return self.resolve(qualified: path, with: &search)
+        var search:Search = .init(matching: qualified.predicate)
+        return self.resolve(qualified: qualified.path, with: &search)
     }
 
     func resolve(_ selector:UCF.Selector,
         in scope:UCF.ResolutionScope) -> UCF.Resolution<Overload>
     {
-        var search:Search = .init(matching: selector.suffix)
+        var search:Search = .init(matching: selector.predicate)
 
         if  case .relative = selector.base
         {

Sources/LinkResolution/UCF.ResolvableOverload.swift

@@ -15,14 +15,43 @@ extension UCF
 }
 extension UCF.ResolvableOverload
 {
-    static func ~= (suffix:UCF.Selector.Suffix, self:Self) -> Bool
+    static func ~= (predicate:UCF.Predicate, self:Self) -> Bool
     {
+        if  predicate.hasEmptyTrailingParentheses
+        {
+            switch self.phylum
+            {
+            case .actor:                    return false
+            case .associatedtype:           return false
+            case .case:                     return false
+            case .class:                    return false
+            case .deinitializer:            return false
+            case .enum:                     return false
+            case .func:                     break
+            case .initializer:              break
+            case .macro:                    break
+            case .operator:                 break
+            case .protocol:                 return false
+            case .struct:                   return false
+            case .subscript:                break
+            case .typealias:                return false
+            case .var:                      return false
+            }
+        }
+
+        guard 
+        let suffix:UCF.Selector.Suffix = predicate.suffix
+        else
+        {
+            return true
+        }
+
         switch suffix
         {
-        case .legacy(let filter, nil):  filter ~= self.phylum
-        case .legacy(_, let hash?):     hash == self.hash
-        case .hash(let hash):           hash == self.hash
-        case .filter(let filter):       filter ~= self.phylum
+        case .legacy(let filter, nil):      return filter ~= self.phylum
+        case .legacy(_, let hash?):         return hash == self.hash
+        case .hash(let hash):               return hash == self.hash
+        case .filter(let filter):           return filter ~= self.phylum
         }
     }
 }

Sources/LinkResolution/UCF.Selector (ext).swift

@@ -1,6 +1,14 @@
 import FNV1
 import UCF
 
+extension UCF.Selector
+{
+    var predicate:UCF.Predicate 
+    {
+        .init(suffix: self.suffix, 
+            hasEmptyTrailingParentheses: self.path.hasEmptyTrailingParentheses)
+    }
+}
 //  TODO: this does not belong in this module
 extension UCF.Selector
 {

Sources/SymbolGraphLinker/Resolution/SSGC.OutlineResolver.swift

@@ -144,13 +144,11 @@ extension SSGC.OutlineResolver
         else
         {
             return nil
-        }
+        } 
 
-        switch self.scopes.causalURLs.resolve(
-            qualified: translatable.path,
-            matching: translatable.suffix)
-        {
-        case .module(let module):
+        switch self.scopes.causalURLs.resolve(qualified: translatable)
+        { 
+        case .module(let module): 
             //  Unidoc linker doesn’t currently support `symbol` outlines that are not
             //  declarations, so for now we just synthesize a normal vertex outline.
             let text:SymbolGraph.OutlineText = .init(path: "\(module)", fragment: nil)

Sources/UCF/Codelinks/UCF.Selector.Path.swift

@@ -9,12 +9,15 @@ extension UCF.Selector
         /// The index of the first visible component in this path.
         public
         var fold:Int
+        public
+        var hasEmptyTrailingParentheses:Bool
 
         @inlinable public
-        init(components:[String] = [], fold:Int = 0)
+        init(components:[String] = [], fold:Int = 0, hasEmptyTrailingParentheses:Bool = false)
         {
             self.components = components
             self.fold = fold
+            self.hasEmptyTrailingParentheses = hasEmptyTrailingParentheses
         }
     }
 }
@@ -114,6 +117,7 @@ extension UCF.Selector.Path
             case k?:
                 //  Special case: ignore empty trailing parentheses
                 self.components.append(String.init(string[i ..< j]))
+                self.hasEmptyTrailingParentheses = true
                 return string.index(after: k)
 
             case let k?:

Sources/UCF/Codelinks/UCF.Selector.swift

@@ -45,6 +45,11 @@ extension UCF.Selector:CustomStringConvertible
             string += component
         }
 
+        if  self.path.hasEmptyTrailingParentheses
+        {
+            string += "()"
+        }
+
         switch self.suffix
         {
         case nil:
@@ -281,8 +286,8 @@ extension UCF.Selector
 }
 extension UCF.Selector
 {
-    @inlinable public static
-    func equivalent(to doclink:Doclink) -> Self?
+    @inlinable public 
+    static func equivalent(to doclink:Doclink) -> Self?
     {
         if  doclink.absolute
         {

Sources/UCFTests/Main.ParseCodelink.swift

@@ -126,6 +126,7 @@ extension Main.ParseCodelink:TestBattery
                 tests.expect(link.base ==? .relative)
                 tests.expect(link.path.components ..? ["Real", "init"])
                 tests.expect(link.path.visible ..? ["Real", "init"])
+                tests.expect(true: link.path.hasEmptyTrailingParentheses)
                 tests.expect(nil: link.suffix)
             }
             if  let tests:TestGroup = tests / "EmptyTrailingComponent",