Added DeclComments, updated tests

Author: khvorost-dish

Sources/SwiftDocCoverage/AccessLevel.swift

@@ -48,6 +48,11 @@ public enum AccessLevel: Int {
 
   init(modifiers: DeclModifierListSyntax) {
     for modifier in modifiers {
+      // Skip private(set) etc.
+      guard modifier.detail == nil else {
+        continue
+      }
+      
       if let accessLevel = AccessLevel(token: modifier.name) {
         self = accessLevel
         return

Sources/SwiftDocCoverage/DeclComments.swift

@@ -0,0 +1,83 @@
+//  DeclComment.swift
+//
+//  Created by Iurii Khvorost <iurii.khvorost@gmail.com> on 11.02.2024.
+//  Copyright © 2022 Iurii Khvorost. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+
+import SwiftSyntax
+
+
+struct DeclComment {
+  let piece: TriviaPiece
+  
+  var text: String {
+    switch piece {
+      case .lineComment(let text): return text
+      case .blockComment(let text): return text
+      case .docLineComment(let text): return text
+      case .docBlockComment(let text): return text
+      default: return ""
+    }
+  }
+  
+  var isDoc: Bool {
+    switch piece {
+      case .docLineComment:
+        fallthrough
+      case .docBlockComment:
+        return true
+      default:
+        return true
+    }
+  }
+  
+  init(piece: TriviaPiece) {
+    self.piece = piece
+  }
+}
+
+struct DeclComments {
+  private let pieces: [DeclComment]
+  
+  var count: Int { pieces.count }
+  
+  var documented: Bool {
+    pieces.first { $0.isDoc } != nil
+  }
+  
+  subscript(index: Int) -> DeclComment { pieces[index] }
+  
+  init(trivia: Trivia) {
+    pieces = trivia.compactMap {
+      switch $0 {
+        case .lineComment:
+          fallthrough
+        case .blockComment:
+          fallthrough
+        case .docLineComment:
+          fallthrough
+        case .docBlockComment:
+          return DeclComment(piece: $0)
+        default:
+          return nil
+      }
+    }
+  }
+}

Sources/SwiftDocCoverage/DeclKeyword.swift

@@ -65,7 +65,7 @@ enum DeclKeyword: String {
       case .`init`: self = .`init`
       case .let: self = .let
       case .macro: self = .macro
-      case .operator: self = .operator
+      //case .operator:
       case .precedencegroup: self = .precedencegroup
       case .protocol: self = .protocol
       case .struct: self = .struct

Sources/SwiftDocCoverage/DeclProtocol.swift

@@ -24,71 +24,26 @@
 import SwiftSyntax
 
 
-struct Comment {
-  enum Kind {
-    case line
-    case block
-    case docLine
-    case docBlock
-  }
-  
-  let kind: Kind
-  let text: String
-  
-  var isDoc: Bool { kind == .docLine || kind == .docBlock }
-}
-
 protocol DeclProtocol: SyntaxProtocol {
 
   // var attributes: AttributeListSyntax
   var modifiers: DeclModifierListSyntax { get }
   var keyword: DeclKeyword { get }
   var name: TokenSyntax { get }
+  
   var genericParameterClause: GenericParameterClauseSyntax? { get }
   var inheritanceClause: InheritanceClauseSyntax? { get }
   var funcSignature: FunctionSignatureSyntax? { get }
-  //var genericWhereClause: GenericWhereClauseSyntax? { get }
-
-  var id: String { get }
+  var genericWhereClause: GenericWhereClauseSyntax? { get }
 }
 
 extension DeclProtocol {
-  
   var genericParameterClause: GenericParameterClauseSyntax? { nil }
   var inheritanceClause: InheritanceClauseSyntax? { nil }
   var funcSignature: FunctionSignatureSyntax? { nil }
+  var genericWhereClause: GenericWhereClauseSyntax? { nil }
 
-  var id: String {
-    
-    let generic = genericParameterClause?.trimmedDescription ?? ""
-    let base = "\(keyword.rawValue) \(name.trimmedDescription)\(generic)"
-    
-    if let inheritance = inheritanceClause?.trimmedDescription {
-      return "\(base): \(inheritance)"
-    }
-    else if let funcSignature = funcSignature?.trimmedDescription {
-      return "\(base)\(funcSignature)"
-    }
-    return base
-  }
-
-  var comments: [Comment] {
-    return leadingTrivia.compactMap {
-      switch $0 {
-        case let .lineComment(text):
-          return Comment(kind: .line, text: text)
-        case let .blockComment(text):
-          return Comment(kind: .block, text: text)
-        case let .docLineComment(text):
-          return Comment(kind: .docLine, text: text)
-        case let .docBlockComment(text):
-          return Comment(kind: .docBlock, text: text)
-        default:
-          return nil
-      }
-    }
-  }
-  
+  var comments: DeclComments { DeclComments(trivia: leadingTrivia) }
   var accessLevel: AccessLevel { AccessLevel(modifiers: modifiers) }
 }
 
@@ -133,15 +88,21 @@ extension InitializerDeclSyntax: DeclProtocol {
 
   var name: TokenSyntax {
     let optionalMark = optionalMark?.trimmedDescription ?? ""
-    return TokenSyntax(.identifier(optionalMark), presence: .present)
+    return TokenSyntax(.identifier("init\(optionalMark)"), presence: .present)
   }
+  
+  var funcSignature: FunctionSignatureSyntax? { signature }
 }
 
 extension SubscriptDeclSyntax: DeclProtocol {
   var keyword: DeclKeyword { .subscript }
 
   var name: TokenSyntax {
-    TokenSyntax(.identifier("\(parameterClause.trimmedDescription) \(returnClause.trimmedDescription)"), presence: .present)
+    TokenSyntax(.identifier("subscript"), presence: .present)
+  }
+  
+  var funcSignature: FunctionSignatureSyntax? {
+    FunctionSignatureSyntax(parameterClause: parameterClause, effectSpecifiers: nil, returnClause: returnClause)
   }
 }
 

Sources/SwiftDocCoverage/Declaration.swift

@@ -21,36 +21,54 @@
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 
-import Foundation
 import SwiftSyntax
 
-fileprivate extension String {
-  
-  static let regexNewLine = try! NSRegularExpression(pattern: #"\n\s*"#, options: [])
+
+@resultBuilder
+fileprivate struct StringBuilder {
+  static func buildBlock(_ parts: String...) -> String {
+    parts.joined()
+  }
 
-  func refine() -> String {
-    let range = NSRange(startIndex..., in: self)
-    return Self.regexNewLine.stringByReplacingMatches(in: self, options: [], range: range, withTemplate: "")
+  static func buildOptional(_ component: String?) -> String {
+    component ?? ""
   }
 }
 
-
 class Declaration {
-  let decl: DeclProtocol
-  let context: [DeclProtocol]
+  private let decl: DeclProtocol
+  private let context: [DeclProtocol]
+  
   let line: Int
   let column: Int
 
-  lazy var accessLevel: AccessLevel = { decl.accessLevel }()
-  
-  lazy var comments: [Comment] = { decl.comments }()
-  lazy var hasDoc: Bool = { comments.contains { $0.isDoc } }()
+  private(set) lazy var accessLevel: AccessLevel = { decl.accessLevel }()
+  private(set) lazy var comments: DeclComments = { decl.comments }()
 
-  lazy var name: String = {
-    let name = decl.id.refine()
-    let parent = context.map { $0.id }.joined(separator: ".")
-    return parent.isEmpty ? name : "\(parent).\(name)"
-  }()
+  private(set) lazy var name: String = { buildName() }()
+
+  @StringBuilder
+  private func buildName() -> String {
+    if decl.keyword != .`init`, decl.keyword != .subscript {
+      decl.keyword.rawValue
+      " "
+    }
+    
+    if context.count > 0 {
+      context.map { $0.name.trimmedDescription }.joined(separator: ".")
+      "."
+    }
+    
+    decl.name.trimmedDescription
+    decl.genericParameterClause?.trimmedDescription ?? ""
+    decl.inheritanceClause?.trimmedDescription ?? ""
+    decl.funcSignature?.trimmedDescription ?? ""
+    
+    if let genericWhere = decl.genericWhereClause?.trimmedDescription {
+      " "
+      genericWhere
+    }
+  }
 
   init(decl: DeclProtocol, context: [DeclProtocol], location: SourceLocation) {
     self.decl = decl

Sources/SwiftDocCoverage/Source.swift

@@ -182,7 +182,7 @@ struct Source {
   let declarations: [Declaration]
 
   var undocumented: [Declaration] {
-    declarations.filter { $0.hasDoc == false }
+    declarations.filter { $0.comments.documented == false }
   }
 
   private init(_ sourceFile: SourceFileSyntax, minAccessLevel: AccessLevel) throws {