Refactor initial ad-hoc implementation into formalized relationships.

For the initial version of swift-doc, the relationships between symbols
are determined in the process of generating documentation.
This lack of separation between model and view concerns
leads to unnecessary duplication across multiple tools,
overcomplicated view logic, and other unfortunate consequences.

This commit refactors that original implementation to create
a first-class Relationship object, whose values are constructed
once during module initialization.

Author: mattt

Sources/SwiftDoc/API.swift

@@ -0,0 +1,56 @@
+import SwiftSemantics
+
+public protocol API: Declaration {
+    var attributes: [Attribute] { get }
+    var modifiers: [Modifier] { get }
+    var name: String { get }
+}
+
+// MARK: -
+
+extension API {
+    public var nonAccessModifiers: [Modifier] {
+        return modifiers.filter { modifier in
+            switch modifier.name {
+            case "private", "fileprivate", "internal", "public", "open":
+                return false
+            default:
+                return true
+            }
+        }
+    }
+}
+
+// MARK: -
+
+extension AssociatedType: API {}
+extension Class: API {}
+extension Enumeration: API {}
+extension Enumeration.Case: API {}
+
+extension Function: API {
+    public var name: String {
+        return "\(identifier)(\(signature.input.map { ($0.firstName ?? "_") + ":" }.joined()))"
+    }
+}
+
+extension Initializer: API {
+    public var name: String {
+        return "\(keyword)\(optional ? "?": "")(\(parameters.map { ($0.firstName ?? "_") + ":" }.joined()))"
+    }
+}
+
+extension Operator: API {}
+extension PrecedenceGroup: API {}
+extension Protocol: API {}
+
+extension Structure: API {}
+
+extension Subscript: API {
+    public var name: String {
+        return "\(keyword)(\(indices.map { ($0.firstName ?? "_") + ":" }.joined()))"
+    }
+}
+
+extension Typealias: API {}
+extension Variable: API {}

Sources/SwiftDoc/CompilationCondition.swift

@@ -10,3 +10,15 @@ public struct CompilationCondition: Hashable, Codable {
         self.branch = branch
     }
 }
+
+// MARK: - CustomStringConvertible
+
+extension CompilationCondition: CustomStringConvertible {
+    public var description: String {
+        if let condition = branch.condition {
+            return condition
+        } else {
+            return branch.condition ?? "!(\(block.branches.compactMap { $0.condition }.map { "(\($0))"}.joined(separator: "&&")))"
+        }
+    }
+}

Sources/SwiftDoc/Extensions/Foundation+Extensions.swift

@@ -1,7 +1,18 @@
 import Foundation
 
+// MARK: - FileHandle
+
+extension FileHandle: TextOutputStream {
+    public func write(_ string: String) {
+        guard let data = string.data(using: .utf8) else { return }
+        write(data)
+    }
+}
+
+// MARK: - URL
+
 extension URL {
-    func path(relativeTo another: URL) -> String {
+    public func path(relativeTo another: URL) -> String {
         let pathComponents = self.pathComponents, otherPathComponents = another.pathComponents
         guard pathComponents.starts(with: otherPathComponents) else { return path }
         return pathComponents.suffix(pathComponents.count - otherPathComponents.count).joined(separator: "/")

Sources/SwiftDoc/Extensions/SwiftSemantics+Extensions.swift

@@ -1,157 +1,17 @@
 import SwiftSemantics
 
-public protocol API: Declaration {
-    var attributes: [Attribute] { get }
-    var keyword: String { get }
-    var context: String? { get }
-    var name: String { get }
-    var isPublic: Bool { get }
+public protocol Generic {
+    var genericParameters: [GenericParameter] { get }
+    var genericRequirements: [GenericRequirement] { get }
 }
 
-extension API {
-    public var qualifiedName: String {
-        guard let context = context else { return name }
-        return "\(context).\(name)"
-    }
-
-    public func hash(into hasher: inout Hasher) {
-        switch self {
-        case let api as AssociatedType:
-            hasher.combine(api)
-        case let api as Class:
-            hasher.combine(api)
-        case let api as Enumeration:
-            hasher.combine(api)
-        case let api as Enumeration.Case:
-            hasher.combine(api)
-        case let api as Function:
-            hasher.combine(api)
-        case let api as Initializer:
-            hasher.combine(api)
-        case let api as Operator:
-            hasher.combine(api)
-        case let api as PrecedenceGroup:
-            hasher.combine(api)
-        case let api as Protocol:
-            hasher.combine(api)
-        case let api as Structure:
-            hasher.combine(api)
-        case let api as Subscript:
-            hasher.combine(api)
-        case let api as Typealias:
-            hasher.combine(api)
-        case let api as Variable:
-            hasher.combine(api)
-        default:
-            assertionFailure("unhandled type: \(self)")
-            return
-        }
-    }
-}
-
-public func ==(lhs: API, rhs: API) -> Bool {
-    switch (lhs, rhs) {
-    case let (lhs, rhs) as (AssociatedType, AssociatedType):
-        return lhs == rhs
-    case let (lhs, rhs) as (Class, Class):
-        return lhs == rhs
-    case let (lhs, rhs) as (Enumeration, Enumeration):
-        return lhs == rhs
-    case let (lhs, rhs) as (Enumeration.Case, Enumeration.Case):
-        return lhs == rhs
-    case let (lhs, rhs) as (Function, Function):
-        return lhs == rhs
-    case let (lhs, rhs) as (Initializer, Initializer):
-        return lhs == rhs
-    case let (lhs, rhs) as (Operator, Operator):
-        return lhs == rhs
-    case let (lhs, rhs) as (PrecedenceGroup, PrecedenceGroup):
-        return lhs == rhs
-    case let (lhs, rhs) as (Protocol, Protocol):
-        return lhs == rhs
-    case let (lhs, rhs) as (Structure, Structure):
-        return lhs == rhs
-    case let (lhs, rhs) as (Subscript, Subscript):
-        return lhs == rhs
-    case let (lhs, rhs) as (Typealias, Typealias):
-        return lhs == rhs
-    case let (lhs, rhs) as (Variable, Variable):
-        return lhs == rhs
-    default:
-        return false
-    }
-}
-
-extension AssociatedType: API {}
-
-extension Class: API {}
-
-extension Enumeration: API {}
-
-extension Enumeration.Case: API {
-    public var isPublic: Bool { return true }
-}
-
-extension Function: API {
-    public var name: String {
-        "\(identifier)(\(signature.input.map { ($0.firstName ?? "_") + ":" }.joined()))"
-    }
-}
-
-extension Initializer: API {
-    public var name: String {
-        "\(keyword)\(optional ? "?": "")(\(parameters.map { ($0.firstName ?? "_") + ":" }.joined()))"
-    }
-}
-
-extension Operator: API {
-    public var isPublic: Bool { return true }
-}
-
-extension PrecedenceGroup: API {
-    public var context: String? { return nil }
-}
-
-extension Protocol: API {
-    public var context: String? { return nil }
-}
-
-extension Structure: API {}
-
-extension Subscript: API {
-    public var name: String {
-        "\(keyword)(\(indices.map { ($0.firstName ?? "_") + ":" }.joined()))"
-    }
-}
-
-extension Typealias: API {}
-
-extension Variable: API {}
-
-// MARK: -
-
-public protocol Modifiable: Declaration {
-    var modifiers: [Modifier] { get }
-}
-
-extension AssociatedType: Modifiable {}
-extension Class: Modifiable {}
-extension Enumeration: Modifiable {}
-extension Extension: Modifiable {}
-extension Function: Modifiable {}
-extension Initializer: Modifiable {}
-extension PrecedenceGroup: Modifiable {}
-extension Protocol: Modifiable {}
-extension Structure: Modifiable {}
-extension Subscript: Modifiable {}
-extension Typealias: Modifiable {}
-extension Variable: Modifiable {}
-
-extension Modifiable {
-    public var isPublic: Bool {
-        return modifiers.contains { $0.name == "public" || $0.name == "open" }
-    }
-}
+extension Class: Generic {}
+extension Enumeration: Generic {}
+extension Function: Generic {}
+extension Initializer: Generic {}
+extension Structure: Generic {}
+extension Subscript: Generic {}
+extension Typealias: Generic {}
 
 // MARK: -
 
@@ -164,3 +24,6 @@ extension Class: Type {}
 extension Enumeration: Type {}
 extension Protocol: Type {}
 extension Structure: Type {}
+extension Unknown: Type {
+    public var inheritance: [String] { return [] }
+}

Sources/SwiftDoc/Identifier.swift

@@ -0,0 +1,16 @@
+public struct Identifier: Hashable {
+    public let pathComponents: [String]
+    public let name: String
+
+    public func matches(_ string: String) -> Bool {
+        (pathComponents + CollectionOfOne(name)).reversed().starts(with: string.split(separator: ".").map { String($0) }.reversed())
+    }
+}
+
+// MARK: - CustomStringConvertible
+
+extension Identifier: CustomStringConvertible {
+    public var description: String {
+        (pathComponents + CollectionOfOne(name)).joined(separator: ".")
+    }
+}