use procedural implementation for typeIdentifier fragment mapping instead of state machine + add test for case with module prefix

Author: theMomax

Sources/SwiftDocC/Model/Rendering/DocumentationContentRenderer.swift

@@ -484,9 +484,6 @@ extension DocumentationContentRenderer {
         /// Applies Swift symbol navigator titles rules to a title.
         /// Will strip the typeIdentifier's precise identifier.
         static func navigatorTitle(for tokens: [DeclarationRenderSection.Token], symbolTitle: String) -> [DeclarationRenderSection.Token] {
-            // Replace kind "typeIdentifier" with "identifier" if the title matches the pattern:
-            // [keyword=class,protocol,enum,typealias,etc.][ ]([typeIdentifier=ancestor(Self)][.])*[typeIdentifier=Self]
-            
             return tokens.mapNameFragmentsToIdentifierKind(matching: symbolTitle)
         }
 
@@ -498,8 +495,7 @@ extension DocumentationContentRenderer {
         static func subHeading(for tokens: [DeclarationRenderSection.Token], symbolTitle: String, symbolKind: String) -> [DeclarationRenderSection.Token] {
             var tokens = tokens
 
-            // 1. Replace kind "typeIdentifier" with "identifier" if the title matches the pattern:
-            // [keyword=class,protocol,enum,typealias,etc.][ ]([typeIdentifier=ancestor(Self)][.])*[typeIdentifier=Self]
+            // 1. Map typeIdenifier tokens to identifier tokens where applicable
             tokens = tokens.mapNameFragmentsToIdentifierKind(matching: symbolTitle)
 
 
@@ -518,79 +514,46 @@ extension DocumentationContentRenderer {
 
 private extension Array where Element == DeclarationRenderSection.Token {
     // Replaces kind "typeIdentifier" with "identifier" if the fragments matches the pattern:
-    // [keyword=class,protocol,enum,typealias,etc.][ ]([typeIdentifier=x_i)][.])*[typeIdentifier=x_i],
-    // where the x_i joined with separator "." equal the `symbolTitle`
+    // [keyword=_] [text=" "] [(typeIdentifier|identifier)=Name_0] ( [text="."] [typeIdentifier=Name_i] )*
+    // where the Name_i from typeIdentifier tokens joined with separator "." equal the `symbolTitle`
     func mapNameFragmentsToIdentifierKind(matching symbolTitle: String) -> Self {
-        let (includesTypeOrExtensionDeclaration, nameRange) = self.typeOrExtensionDeclaration()
-        
-        if includesTypeOrExtensionDeclaration
-            && self[nameRange].map(\.text).joined() == symbolTitle {
-            return self.enumerated().map { (index, token) -> DeclarationRenderSection.Token in
-                
-                if nameRange.contains(index) && token.kind == .typeIdentifier {
-                    return DeclarationRenderSection.Token(
-                        text: token.text,
-                        kind: .identifier,
-                        preciseIdentifier: token.preciseIdentifier
-                    )
-                }
-                
-                return token
-            }
+        // Check that the first 3 tokens are: [keyword=_] [text=" "] [(typeIdentifier|identifier)=_]
+        guard count >= 3,
+              self[0].kind == .keyword,
+              self[1].kind == .text, self[1].text == " ",
+              self[2].kind == .typeIdentifier || self[2].kind == .identifier
+        else { return self }
+        
+        // If the first named token belongs to an identifier, this is a module prefix.
+        // We store it for later comparison with the `combinedName`
+        let modulePrefix = self[2].kind == .identifier ? self[2].text + "." : ""
+        
+        var combinedName = self[2].text
+        
+        var finalTypeIdentifierIndex = 2
+        var remainder = self.dropFirst(3)
+        // Continue checking for pairs of "." text tokens and typeIdentifier tokens: ( [text="."] [typeIdentifier=Name_i] )*
+        while remainder.count >= 2 {
+            let separator = remainder.removeFirst()
+            guard separator.kind == .text, separator.text == "." else { break }
+            let next = remainder.removeFirst()
+            guard next.kind == .typeIdentifier else { break }
+            
+            finalTypeIdentifierIndex += 2
+            combinedName += "." + next.text
         }
 
-        return self
-    }
-}
-
-private extension Collection where Element == DeclarationRenderSection.Token, Index == Int {
-    func typeOrExtensionDeclaration() -> (includesTypeOrExtensionDeclaration: Bool, name: Range<Index>) {
-        self.reduce(into: TypeOrExtensionDeclarationNameExtractionSM(), { sm, token in sm.consume(token) }).result()
-    }
-}
-
-private enum TypeOrExtensionDeclarationNameExtractionSM {
-    case initial
-    case illegal
-    case foundKeyword
-    case foundIdentifier(Int)
-    case expectIdentifier(Int)
-    case done(Range<Int>)
-    
-    init() {
-        self = .initial
-    }
-    
-    static let expectedNameStartIndex = 2
-    
-    mutating func consume(_ token: DeclarationRenderSection.Token) {
-        switch (self, token.kind, token.text) {
-        case (.initial, .keyword, _):
-            self = .foundKeyword
-        case (.foundKeyword, .text, " "):
-            self = .expectIdentifier(Self.expectedNameStartIndex)
-        case let (.expectIdentifier(index), .identifier, _),
-             let (.expectIdentifier(index), .typeIdentifier, _):
-            self = .foundIdentifier(index+1)
-        case let (.foundIdentifier(index), .text, "."):
-            self = .expectIdentifier(index+1)
-        case let (.foundIdentifier(index), .text, _):
-            self = .done(.init(uncheckedBounds: (Self.expectedNameStartIndex, index)))
-        case let (.done(namerange), _, _):
-            self = .done(namerange)
-        default:
-            self = .illegal
-        }
-    }
-    
-    func result() -> (includesTypeOrExtensionDeclaration: Bool, name: Range<Int>) {
-        switch self {
-        case let .done(range):
-            return (true, range)
-        case let .foundIdentifier(index):
-            return (true, .init(uncheckedBounds: (Self.expectedNameStartIndex, index)))
-        default:
-            return (false, .init(uncheckedBounds: (0, 0)))
+        guard combinedName == modulePrefix + symbolTitle else { return self }
+        
+        var mapped = self
+        for index in stride(from: 2, to: finalTypeIdentifierIndex+1, by: 2) {
+            let token = self[index]
+            mapped[index] = DeclarationRenderSection.Token(
+                text: token.text,
+                kind: .identifier,
+                preciseIdentifier: token.preciseIdentifier
+            )
         }
+        return mapped
     }
 }

Tests/SwiftDocCTests/Rendering/DocumentationContentRenderer+SwiftTests.swift

@@ -23,6 +23,18 @@ class DocumentationContentRenderer_SwiftTests: XCTestCase {
         .init(text: "Object", kind: .typeIdentifier),
     ]
 
+    // Tokens where the type name is incorrectly identified as "typeIdentifier", which
+    // are additionally prefixed by a module name
+    let typeIdentifierTokensWithModule: [DeclarationRenderSection.Token] = [
+        .init(text: "class", kind: .keyword),
+        .init(text: " ", kind: .text),
+        .init(text: "MyModule", kind: .identifier),
+        .init(text: ".", kind: .text),
+        .init(text: "Test", kind: .typeIdentifier),
+        .init(text: " : ", kind: .text),
+        .init(text: "Object", kind: .typeIdentifier),
+    ]
+    
     // Tokens where the type name is correctly identified as "identifier"
     let identifierTokens: [DeclarationRenderSection.Token] = [
         .init(text: "class", kind: .keyword),
@@ -49,6 +61,15 @@ class DocumentationContentRenderer_SwiftTests: XCTestCase {
             XCTAssertEqual(mapped.map { $0.kind }, [.keyword, .text, .identifier, .text, .typeIdentifier])
             XCTAssertEqual(mapped.map { $0.text }, ["class", " ", "Test", " : ", "Object"])
         }
+        
+        do {
+            // Verify that the type's own name is mapped from "typeIdentifier" to "identifier" kind even when prefixed with
+            // a module "identifier".
+            let mapped = DocumentationContentRenderer.Swift.navigatorTitle(for: typeIdentifierTokensWithModule, symbolTitle: "Test")
+            
+            XCTAssertEqual(mapped.map { $0.kind }, [.keyword, .text, .identifier, .text, .identifier, .text, .typeIdentifier])
+            XCTAssertEqual(mapped.map { $0.text }, ["class", " ", "MyModule", ".", "Test", " : ", "Object"])
+        }
     }
 
     /// Test whether we map to "identifier" if we find an unexpected "typeIdentifier" token kind
@@ -68,6 +89,15 @@ class DocumentationContentRenderer_SwiftTests: XCTestCase {
             XCTAssertEqual(mapped.map { $0.kind }, [.keyword, .text, .identifier, .text, .typeIdentifier])
             XCTAssertEqual(mapped.map { $0.text }, ["class", " ", "Test", " : ", "Object"])
         }
+        
+        do {
+            // Verify that the type's own name is mapped from "typeIdentifier" to "identifier" kind even when prefixed with
+            // a module "identifier".
+            let mapped = DocumentationContentRenderer.Swift.subHeading(for: typeIdentifierTokensWithModule, symbolTitle: "Test", symbolKind: "swift.class")
+            
+            XCTAssertEqual(mapped.map { $0.kind }, [.keyword, .text, .identifier, .text, .identifier, .text, .typeIdentifier])
+            XCTAssertEqual(mapped.map { $0.text }, ["class", " ", "MyModule", ".", "Test", " : ", "Object"])
+        }
     }
 
     // Tokens for an "init" symbol