Remove severity

Instead of making the severity configurable,
this patch removes severity all together and treats
every finding as an error.

Issue: #879

Author: bkolb

.gitignore

@@ -2,4 +2,4 @@
 .swiftpm/
 swift-format.xcodeproj/
 Package.resolved
-
+.index-build

Documentation/RuleDocumentation.md

@@ -4,7 +4,7 @@
 
 Use the rules below in the `rules` block of your `.swift-format`
 configuration file, as described in
-[Configuration](Configuration.md). All of these rules can be
+[Configuration](Documentation/Configuration.md). All of these rules can be
 applied in the linter, but only some of them can format your source code
 automatically.
 

Package.swift

@@ -113,6 +113,7 @@ var targets: [Target] = [
     dependencies: [
       "SwiftFormat",
       "_SwiftFormatTestSupport",
+      "swift-format",
       .product(name: "Markdown", package: "swift-markdown"),
     ] + swiftSyntaxDependencies(["SwiftOperators", "SwiftParser", "SwiftSyntax", "SwiftSyntaxBuilder"])
   ),

Sources/SwiftFormat/API/Finding.swift

@@ -12,13 +12,6 @@
 
 /// A problem with the style or syntax of the source code discovered during linting or formatting.
 public struct Finding {
-  /// The severity of a finding.
-  public enum Severity {
-    case warning
-    case error
-    case refactoring
-    case convention
-  }
 
   /// The file path and location in that file where a finding was encountered.
   public struct Location {
@@ -83,27 +76,22 @@ public struct Finding {
   /// The finding's message.
   public let message: Message
 
-  /// The severity of the finding.
-  public let severity: Severity
-
   /// The optional location of the finding.
   public let location: Location?
 
   /// Notes that provide additional detail about the finding.
   public let notes: [Note]
 
-  /// Creates a new finding with the given category, message, severity, optional location, and
+  /// Creates a new finding with the given category, message, optional location, and
   /// notes.
   init(
     category: FindingCategorizing,
     message: Message,
-    severity: Finding.Severity,
     location: Location? = nil,
     notes: [Note] = []
   ) {
     self.category = category
     self.message = message
-    self.severity = severity
     self.location = location
     self.notes = notes
   }

Sources/SwiftFormat/API/FindingCategorizing.swift

@@ -17,13 +17,5 @@
 /// to be displayed as part of the diagnostic message when the finding is presented to the user.
 /// For example, the category `Indentation` in the message `[Indentation] Indent by 2 spaces`.
 public protocol FindingCategorizing: CustomStringConvertible {
-  /// The default severity of findings emitted in this category.
-  ///
-  /// By default, all findings are warnings. Individual categories may choose to override this to
-  /// make the findings in those categories more severe.
-  var defaultSeverity: Finding.Severity { get }
-}
 
-extension FindingCategorizing {
-  public var defaultSeverity: Finding.Severity { .warning }
 }

Sources/SwiftFormat/Core/FindingEmitter.swift

@@ -48,13 +48,10 @@ final class FindingEmitter {
   ) {
     guard let consumer = self.consumer else { return }
 
-    // TODO: Provide a way via the formatter configuration for users to customize the severity of
-    // findings based on their category, falling back to the default if it isn't overridden.
     consumer(
       Finding(
         category: category,
         message: message,
-        severity: category.defaultSeverity,
         location: location,
         notes: notes
       )

Sources/SwiftFormat/Core/Parsing.swift

@@ -65,9 +65,7 @@ func parseAndEmitDiagnostics(
 
       // Downgrade editor placeholders to warnings, because it is useful to support formatting
       // in-progress files that contain those.
-      if diagnostic.diagnosticID == StaticTokenError.editorPlaceholder.diagnosticID {
-        parsingDiagnosticHandler(downgradedToWarning(diagnostic), location)
-      } else {
+      if diagnostic.diagnosticID != StaticTokenError.editorPlaceholder.diagnosticID {
         parsingDiagnosticHandler(diagnostic, location)
         hasErrors = true
       }
@@ -79,29 +77,3 @@ func parseAndEmitDiagnostics(
   }
   return sourceFile
 }
-
-// Wraps a `DiagnosticMessage` but forces its severity to be that of a warning instead of an error.
-struct DowngradedDiagnosticMessage: DiagnosticMessage {
-  var originalDiagnostic: DiagnosticMessage
-
-  var message: String { originalDiagnostic.message }
-
-  var diagnosticID: SwiftDiagnostics.MessageID { originalDiagnostic.diagnosticID }
-
-  var severity: DiagnosticSeverity { .warning }
-}
-
-/// Returns a new `Diagnostic` that is identical to the given diagnostic, except that its severity
-/// has been downgraded to a warning.
-func downgradedToWarning(_ diagnostic: Diagnostic) -> Diagnostic {
-  // `Diagnostic` is immutable, so create a new one with the same values except for the
-  // severity-downgraded message.
-  return Diagnostic(
-    node: diagnostic.node,
-    position: diagnostic.position,
-    message: DowngradedDiagnosticMessage(originalDiagnostic: diagnostic.diagMessage),
-    highlights: diagnostic.highlights,
-    notes: diagnostic.notes,
-    fixIts: diagnostic.fixIts
-  )
-}

Sources/SwiftFormat/Core/Rule.swift

@@ -62,7 +62,6 @@ extension Rule {
   public func diagnose<SyntaxType: SyntaxProtocol>(
     _ message: Finding.Message,
     on node: SyntaxType?,
-    severity: Finding.Severity? = nil,
     anchor: FindingAnchor = .start,
     notes: [Finding.Note] = []
   ) {
@@ -86,7 +85,7 @@ extension Rule {
       syntaxLocation = nil
     }
 
-    let category = RuleBasedFindingCategory(ruleType: type(of: self), severity: severity)
+    let category = RuleBasedFindingCategory(ruleType: type(of: self))
     context.findingEmitter.emit(
       message,
       category: category,

Sources/SwiftFormat/Core/RuleBasedFindingCategory.swift

@@ -22,11 +22,8 @@ struct RuleBasedFindingCategory: FindingCategorizing {
 
   var description: String { ruleType.ruleName }
 
-  var severity: Finding.Severity?
-
   /// Creates a finding category that wraps the given rule type.
-  init(ruleType: Rule.Type, severity: Finding.Severity? = nil) {
+  init(ruleType: Rule.Type) {
     self.ruleType = ruleType
-    self.severity = severity
   }
 }

Sources/SwiftFormat/Core/RuleRegistry+Generated.swift

@@ -57,5 +57,14 @@
     "UseTripleSlashForDocumentationComments": true,
     "UseWhereClausesInForLoops": false,
     "ValidateDocumentationComments": false,
+    "AddLines": true,
+    "EndOfLineComment": true,
+    "Indentation": true,
+    "LineLength": true,
+    "RemoveLine": true,
+    "Spacing": true,
+    "SpacingCharacter": true,
+    "TrailingComma": true,
+    "TrailingWhitespace": true,
   ]
 }

Sources/SwiftFormat/Rules/OmitExplicitReturns.swift

@@ -34,7 +34,7 @@ public final class OmitExplicitReturns: SyntaxFormatRule {
     }
 
     funcDecl.body?.statements = rewrapReturnedExpression(returnStmt)
-    diagnose(.omitReturnStatement, on: returnStmt, severity: .refactoring)
+    diagnose(.omitReturnStatement, on: returnStmt)
     return DeclSyntax(funcDecl)
   }
 
@@ -78,7 +78,7 @@ public final class OmitExplicitReturns: SyntaxFormatRule {
     }
 
     closureExpr.statements = rewrapReturnedExpression(returnStmt)
-    diagnose(.omitReturnStatement, on: returnStmt, severity: .refactoring)
+    diagnose(.omitReturnStatement, on: returnStmt)
     return ExprSyntax(closureExpr)
   }
 
@@ -111,7 +111,7 @@ public final class OmitExplicitReturns: SyntaxFormatRule {
 
       getter.body?.statements = rewrapReturnedExpression(returnStmt)
 
-      diagnose(.omitReturnStatement, on: returnStmt, severity: .refactoring)
+      diagnose(.omitReturnStatement, on: returnStmt)
 
       accessors[getterAt] = getter
       var newBlock = accessorBlock
@@ -123,7 +123,7 @@ public final class OmitExplicitReturns: SyntaxFormatRule {
         return nil
       }
 
-      diagnose(.omitReturnStatement, on: returnStmt, severity: .refactoring)
+      diagnose(.omitReturnStatement, on: returnStmt)
 
       var newBlock = accessorBlock
       newBlock.accessors = .getter(rewrapReturnedExpression(returnStmt))

Sources/SwiftFormat/Rules/TypeNamesShouldBeCapitalized.swift

@@ -61,7 +61,7 @@ public final class TypeNamesShouldBeCapitalized: SyntaxLintRule {
     if let firstChar = name.text[leadingUnderscores.endIndex...].first,
       firstChar.uppercased() != String(firstChar)
     {
-      diagnose(.capitalizeTypeName(name: name.text, kind: kind), on: name, severity: .convention)
+      diagnose(.capitalizeTypeName(name: name.text, kind: kind), on: name)
     }
   }
 }

Sources/_SwiftFormatTestSupport/Configuration+Testing.swift

@@ -44,4 +44,24 @@ extension Configuration {
     config.indentBlankLines = false
     return config
   }
+
+  public static func forTesting(enabledRule: String) -> Configuration {
+    var config = Configuration.forTesting.disableAllRules()
+    config.rules[enabledRule] = true
+    return config
+  }
+}
+
+extension Configuration {
+  public func disableAllRules() -> Self {
+    var config = self
+    config.rules = config.rules.mapValues({ _ in false })
+    return config
+  }
+
+  public func enable(_ rule: String, enabled: Bool) -> Self {
+    var config = self
+    config.rules[rule] = enabled
+    return config
+  }
 }

Sources/generate-swift-format/PrettyPrintCollector.swift

@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Foundation
+@_spi(Rules) import SwiftFormat
+import SwiftParser
+import SwiftSyntax
+
+/// Collects information about rules in the formatter code base.
+final class PrettyPrintCollector {
+
+  /// A list of all the format-only pretty-print categories found in the code base.
+  var allPrettyPrinterCategories = Set<String>()
+
+  /// Populates the internal collections with rules in the given directory.
+  ///
+  /// - Parameter url: The file system URL that should be scanned for rules.
+  func collect(from url: URL) throws {
+    // For each file in the Rules directory, find types that either conform to SyntaxLintRule or
+    // inherit from SyntaxFormatRule.
+    let fm = FileManager.default
+    guard let rulesEnumerator = fm.enumerator(atPath: url.path) else {
+      fatalError("Could not list the directory \(url.path)")
+    }
+
+    for baseName in rulesEnumerator {
+      // Ignore files that aren't Swift source files.
+      guard let baseName = baseName as? String, baseName.hasSuffix(".swift") else { continue }
+
+      let fileURL = url.appendingPathComponent(baseName)
+      let fileInput = try String(contentsOf: fileURL)
+      let sourceFile = Parser.parse(source: fileInput)
+
+      for statement in sourceFile.statements {
+        let pp = self.detectPrettyPrintCategories(at: statement)
+        allPrettyPrinterCategories.formUnion(pp)
+      }
+    }
+  }
+
+  private func detectPrettyPrintCategories(at statement: CodeBlockItemSyntax) -> [String] {
+    guard let enumDecl = statement.item.as(EnumDeclSyntax.self) else {
+      return []
+    }
+
+    if enumDecl.name.text == "PrettyPrintFindingCategory" {
+      print("HIT")
+    }
+
+    // Make sure it has an inheritance clause.
+    guard let inheritanceClause = enumDecl.inheritanceClause else {
+      return []
+    }
+
+    // Scan through the inheritance clause to find one of the protocols/types we're interested in.
+    for inheritance in inheritanceClause.inheritedTypes {
+      guard let identifier = inheritance.type.as(IdentifierTypeSyntax.self) else {
+        continue
+      }
+
+      if identifier.name.text != "FindingCategorizing" {
+        // Keep looking at the other inheritances.
+        continue
+      }
+
+      // Now that we know it's a pretty printing category, collect the `description` method and extract the name.
+      for member in enumDecl.memberBlock.members {
+        guard let varDecl = member.decl.as(VariableDeclSyntax.self) else { continue }
+        guard
+          let descriptionDecl = varDecl.bindings
+            .first(where: {
+              $0.pattern.as(IdentifierPatternSyntax.self)?.identifier.text == "description"
+            })
+        else { continue }
+        let pp = PrettyPrintCategoryVisitor(viewMode: .sourceAccurate)
+        _ = pp.walk(descriptionDecl)
+        return pp.prettyPrintCategories
+      }
+    }
+
+    return []
+  }
+}
+
+final class PrettyPrintCategoryVisitor: SyntaxVisitor {
+
+  var prettyPrintCategories: [String] = []
+
+  override func visit(_ node: StringSegmentSyntax) -> SyntaxVisitorContinueKind {
+    prettyPrintCategories.append(node.content.text)
+    return .skipChildren
+  }
+}

Sources/generate-swift-format/RuleRegistryGenerator.swift

@@ -18,9 +18,13 @@ final class RuleRegistryGenerator: FileGenerator {
   /// The rules collected by scanning the formatter source code.
   let ruleCollector: RuleCollector
 
+  /// The pretty-printing categories collected by scanning the formatter source code.
+  let prettyPrintCollector: PrettyPrintCollector
+
   /// Creates a new rule registry generator.
-  init(ruleCollector: RuleCollector) {
+  init(ruleCollector: RuleCollector, prettyPrintCollector: PrettyPrintCollector) {
     self.ruleCollector = ruleCollector
+    self.prettyPrintCollector = prettyPrintCollector
   }
 
   func write(into handle: FileHandle) throws {
@@ -49,6 +53,10 @@ final class RuleRegistryGenerator: FileGenerator {
     for detectedRule in ruleCollector.allLinters.sorted(by: { $0.typeName < $1.typeName }) {
       handle.write("    \"\(detectedRule.typeName)\": \(!detectedRule.isOptIn),\n")
     }
+
+    for ppCategory in prettyPrintCollector.allPrettyPrinterCategories.sorted(by: { $0 < $1 }) {
+      handle.write("    \"\(ppCategory)\": true,\n")
+    }
     handle.write("  ]\n}\n")
   }
 }