Add resolution for nested types through typealiases

Refactor implementation of ID

Author: mattt

Sources/SwiftDoc/Identifier.swift

@@ -1,16 +1,41 @@
 public struct Identifier: Hashable {
-    public let pathComponents: [String]
+    public let context: [String]
     public let name: String
+    public let pathComponents: [String]
+
+    public init(context: [String], name: String) {
+        self.context = context
+        self.name = name
+        self.pathComponents = context + CollectionOfOne(name)
+    }
 
     public func matches(_ string: String) -> Bool {
-        (pathComponents + CollectionOfOne(name)).reversed().starts(with: string.split(separator: ".").map { String($0) }.reversed())
+        return matches(string.split(separator: "."))
+    }
+
+    public func matches(_ pathComponents: [Substring]) -> Bool {
+        return matches(pathComponents.map(String.init))
+    }
+
+    public func matches(_ pathComponents: [String]) -> Bool {
+        return self.pathComponents.ends(with: pathComponents)
     }
 }
 
 // MARK: - CustomStringConvertible
 
 extension Identifier: CustomStringConvertible {
     public var description: String {
-        (pathComponents + CollectionOfOne(name)).joined(separator: ".")
+        pathComponents.joined(separator: ".")
+    }
+}
+
+fileprivate extension Array {
+    func ends<PossibleSuffix>(with possibleSuffix: PossibleSuffix) -> Bool
+        where PossibleSuffix : Sequence,
+              Self.Element == PossibleSuffix.Element,
+              Self.Element: Equatable
+    {
+        reversed().starts(with: possibleSuffix)
     }
 }

Sources/SwiftDoc/Interface.swift

@@ -163,20 +163,33 @@ public final class Interface {
     // MARK: -
 
     public func symbols(named name: String, resolvingTypealiases: Bool) -> [Symbol] {
+        symbolsGroupedByIdentifier.named(name, resolvingTypealiases: resolvingTypealiases)
+    }
+}
+
+fileprivate extension Dictionary where Key == Identifier, Value == [Symbol] {
+    func named(_ name: String, resolvingTypealiases: Bool) -> [Symbol] {
         var pathComponents: [String] = []
         for component in name.split(separator: ".") {
             pathComponents.append("\(component)")
             guard resolvingTypealiases else { continue }
 
-            if let symbols = symbolsGroupedByQualifiedName[pathComponents.joined(separator: ".")],
+            if let symbols = first(where: { $0.key.pathComponents == pathComponents })?.value,
                let symbol = symbols.first(where: { $0.api is Typealias }),
                let `typealias` = symbol.api as? Typealias,
                let initializedType = `typealias`.initializedType
             {
-                pathComponents = (symbol.context.compactMap { ($0 as? Symbol)?.name ?? ($0 as? Extension)?.extendedType }) + [initializedType]
+                let initializedTypePathComponents = initializedType.split(separator: ".")
+                let candidates = keys.filter { $0.matches(initializedTypePathComponents) }
+
+                if let id = candidates.max(by: { $0.pathComponents.count > $1.pathComponents.count }) {
+                    pathComponents = id.pathComponents
+                } else {
+                    return []
+                }
             }
         }
 
-        return symbolsGroupedByQualifiedName[pathComponents.joined(separator: ".")] ?? []
+        return first(where: { $0.key.pathComponents == pathComponents })?.value ?? []
     }
 }

Sources/SwiftDoc/Symbol.swift

@@ -6,6 +6,7 @@ import struct Highlighter.Token
 public final class Symbol {
     public typealias ID = Identifier
 
+    public let id: ID
     public let api: API
     public let context: [Contextual]
     public let declaration: [Token]
@@ -19,6 +20,9 @@ public final class Symbol {
     public private(set) lazy var conditions: [CompilationCondition] = context.compactMap { $0 as? CompilationCondition }
 
     init(api: API, context: [Contextual], declaration: [Token], documentation: Documentation?, sourceRange: SourceRange?) {
+        self.id = Identifier(context: context.compactMap {
+            ($0 as? Symbol)?.name ?? ($0 as? Extension)?.extendedType
+        }, name: api.name)
         self.api = api
         self.context = context
         self.declaration = declaration
@@ -30,12 +34,6 @@ public final class Symbol {
         return api.name
     }
 
-    public private(set) lazy var id: ID = {
-        Identifier(pathComponents: context.compactMap {
-            ($0 as? Symbol)?.name ?? ($0 as? Extension)?.extendedType
-        }, name: name)
-    }()
-
     public var isPublic: Bool {
         if api is Unknown {
             return true

Tests/SwiftDocTests/InterfaceTypeTests.swift

@@ -282,6 +282,10 @@ final class InterfaceTypeTests: XCTestCase {
          }
                       
          public typealias MyClass = SomeClass
+
+         public class AnotherClass {
+             typealias PublicClass = SomeClass
+         }
                      
          public typealias ExternalClass = UIGestureRecognizer
          """#
@@ -306,6 +310,12 @@ final class InterfaceTypeTests: XCTestCase {
         XCTAssertEqual(module.interface.symbols(named: "MyClass.InnerObject", resolvingTypealiases: true).first?.name, "InnerObject")
         XCTAssertNil(module.interface.symbols(named: "MyClass.InnerObject", resolvingTypealiases: false).first)
 
+        XCTAssertEqual(module.interface.symbols(named: "AnotherClass.PublicClass", resolvingTypealiases: true).first?.name, "SomeClass")
+        XCTAssertTrue(module.interface.symbols(named: "AnotherClass.PublicClass", resolvingTypealiases: false).first?.api is Typealias)
+
+        XCTAssertEqual(module.interface.symbols(named: "AnotherClass.PublicClass.ActuallyInternal", resolvingTypealiases: true).first?.name, "InnerStruct")
+        XCTAssertNil(module.interface.symbols(named: "AnotherClass.PublicClass.ActuallyInternal", resolvingTypealiases: false).first)
+
         XCTAssertNil(module.interface.symbols(named: "ExternalClass", resolvingTypealiases: true).first)
         XCTAssertTrue(module.interface.symbols(named: "ExternalClass", resolvingTypealiases: false).first?.api is Typealias)