Merge pull request #646 from allevato/new-trivia-behavior

Remove the legacy trivia workaround.

Author: allevato

Sources/SwiftFormat/Core/LegacyTriviaBehavior.swift

@@ -63,8 +63,7 @@ func parseAndEmitDiagnostics(
   guard !hasErrors else {
     throw SwiftFormatError.fileContainsInvalidSyntax
   }
-
-  return restoringLegacyTriviaBehavior(sourceFile)
+  return sourceFile
 }
 
 // Wraps a `DiagnosticMessage` but forces its severity to be that of a warning instead of an error.

Sources/SwiftFormat/Core/Parsing.swift

@@ -29,6 +29,22 @@ public protocol Rule {
   init(context: Context)
 }
 
+/// The part of a node where an emitted finding should be anchored.
+@_spi(Rules)
+public enum FindingAnchor {
+  /// The finding is anchored at the beginning of the node's actual content, skipping any leading
+  /// trivia.
+  case start
+
+  /// The finding is anchored at the beginning of the trivia piece at the given index in the node's
+  /// leading trivia.
+  case leadingTrivia(Trivia.Index)
+
+  /// The finding is anchored at the beginning of the trivia piece at the given index in the node's
+  /// trailing trivia.
+  case trailingTrivia(Trivia.Index)
+}
+
 extension Rule {
   /// By default, the `ruleName` is just the name of the implementing rule class.
   public static var ruleName: String { String("\(self)".split(separator: ".").last!) }
@@ -40,30 +56,37 @@ extension Rule {
   ///   - node: The syntax node to which the finding should be attached. The finding's location will
   ///     be set to the start of the node (excluding leading trivia, unless `leadingTriviaIndex` is
   ///     provided).
-  ///   - leadingTriviaIndex: If non-nil, the index of a trivia piece in the node's leading trivia
-  ///     that should be used to determine the location of the finding. Otherwise, the finding's
-  ///     location will be the start of the node after any leading trivia.
+  ///   - anchor: The part of the node where the finding should be anchored. Defaults to the start
+  ///     of the node's content (after any leading trivia).
   ///   - notes: An array of notes that provide additional detail about the finding.
   public func diagnose<SyntaxType: SyntaxProtocol>(
     _ message: Finding.Message,
     on node: SyntaxType?,
     severity: Finding.Severity? = nil,
-    leadingTriviaIndex: Trivia.Index? = nil,
+    anchor: FindingAnchor = .start,
     notes: [Finding.Note] = []
   ) {
     let syntaxLocation: SourceLocation?
-    if let leadingTriviaIndex = leadingTriviaIndex {
-      syntaxLocation = node?.startLocation(
-        ofLeadingTriviaAt: leadingTriviaIndex, converter: context.sourceLocationConverter)
+    if let node = node {
+      switch anchor {
+      case .start:
+        syntaxLocation = node.startLocation(converter: context.sourceLocationConverter)
+      case .leadingTrivia(let index):
+        syntaxLocation = node.startLocation(
+          ofLeadingTriviaAt: index, converter: context.sourceLocationConverter)
+      case .trailingTrivia(let index):
+        syntaxLocation = node.startLocation(
+          ofTrailingTriviaAt: index, converter: context.sourceLocationConverter)
+      }
     } else {
-      syntaxLocation = node?.startLocation(converter: context.sourceLocationConverter)
+      syntaxLocation = nil
     }
 
     let category = RuleBasedFindingCategory(ruleType: type(of: self), severity: severity)
     context.findingEmitter.emit(
-        message,
-        category: category,
-        location: syntaxLocation.flatMap(Finding.Location.init),
-        notes: notes)
+      message,
+      category: category,
+      location: syntaxLocation.flatMap(Finding.Location.init),
+      notes: notes)
   }
 }

Sources/SwiftFormat/Core/Rule.swift

@@ -36,6 +36,29 @@ extension SyntaxProtocol {
     return self.position + offset
   }
 
+  /// Returns the absolute position of the trivia piece at the given index in the receiver's
+  /// trailing trivia collection.
+  ///
+  /// If the trivia piece spans multiple characters, the value returned is the position of the first
+  /// character.
+  ///
+  /// - Precondition: `index` is a valid index in the receiver's trailing trivia collection.
+  ///
+  /// - Parameter index: The index of the trivia piece in the trailing trivia whose position should
+  ///   be returned.
+  /// - Returns: The absolute position of the trivia piece.
+  func position(ofTrailingTriviaAt index: Trivia.Index) -> AbsolutePosition {
+    guard trailingTrivia.indices.contains(index) else {
+      preconditionFailure("Index was out of bounds in the node's trailing trivia.")
+    }
+
+    var offset = SourceLength.zero
+    for currentIndex in trailingTrivia.startIndex..<index {
+      offset += trailingTrivia[currentIndex].sourceLength
+    }
+    return self.endPositionBeforeTrailingTrivia + offset
+  }
+
   /// Returns the source location of the trivia piece at the given index in the receiver's leading
   /// trivia collection.
   ///
@@ -56,6 +79,76 @@ extension SyntaxProtocol {
   ) -> SourceLocation {
     return converter.location(for: position(ofLeadingTriviaAt: index))
   }
+
+  /// Returns the source location of the trivia piece at the given index in the receiver's trailing
+  /// trivia collection.
+  ///
+  /// If the trivia piece spans multiple characters, the value returned is the location of the first
+  /// character.
+  ///
+  /// - Precondition: `index` is a valid index in the receiver's trailing trivia collection.
+  ///
+  /// - Parameters:
+  ///   - index: The index of the trivia piece in the trailing trivia whose location should be
+  ///     returned.
+  ///   - converter: The `SourceLocationConverter` that was previously initialized using the root
+  ///     tree of this node.
+  /// - Returns: The source location of the trivia piece.
+  func startLocation(
+    ofTrailingTriviaAt index: Trivia.Index,
+    converter: SourceLocationConverter
+  ) -> SourceLocation {
+    return converter.location(for: position(ofTrailingTriviaAt: index))
+  }
+
+  /// The collection of all contiguous trivia preceding this node; that is, the trailing trivia of
+  /// the node before it and the leading trivia of the node itself.
+  var allPrecedingTrivia: Trivia {
+    var result: Trivia
+    if let previousTrailingTrivia = previousToken(viewMode: .sourceAccurate)?.trailingTrivia {
+      result = previousTrailingTrivia
+    } else {
+      result = Trivia()
+    }
+    result += leadingTrivia
+    return result
+  }
+
+  /// The collection of all contiguous trivia following this node; that is, the trailing trivia of
+  /// the node and the leading trivia of the node after it.
+  var allFollowingTrivia: Trivia {
+    var result = trailingTrivia
+    if let nextLeadingTrivia = nextToken(viewMode: .sourceAccurate)?.leadingTrivia {
+      result += nextLeadingTrivia
+    }
+    return result
+  }
+
+  /// Indicates whether the node has any preceding line comments.
+  ///
+  /// Due to the way trivia is parsed, a preceding comment might be in either the leading trivia of
+  /// the node or the trailing trivia of the previous token.
+  var hasPrecedingLineComment: Bool {
+    if let previousTrailingTrivia = previousToken(viewMode: .sourceAccurate)?.trailingTrivia,
+      previousTrailingTrivia.hasLineComment
+    {
+      return true
+    }
+    return leadingTrivia.hasLineComment
+  }
+
+  /// Indicates whether the node has any preceding comments of any kind.
+  ///
+  /// Due to the way trivia is parsed, a preceding comment might be in either the leading trivia of
+  /// the node or the trailing trivia of the previous token.
+  var hasAnyPrecedingComment: Bool {
+    if let previousTrailingTrivia = previousToken(viewMode: .sourceAccurate)?.trailingTrivia,
+      previousTrailingTrivia.hasAnyComments
+    {
+      return true
+    }
+    return leadingTrivia.hasAnyComments
+  }
 }
 
 extension SyntaxCollection {

Sources/SwiftFormat/Core/SyntaxProtocol+Convenience.swift

@@ -34,12 +34,14 @@ extension Trivia {
 
   /// Returns this set of trivia, without any leading spaces.
   func withoutLeadingSpaces() -> Trivia {
-    return Trivia(
-      pieces: Array(drop {
-        if case .spaces = $0 { return false }
-        if case .tabs = $0 { return false }
-        return true
-      }))
+    return Trivia(pieces: self.pieces.drop(while: \.isSpaceOrTab))
+  }
+
+  func withoutTrailingSpaces() -> Trivia {
+    guard let lastNonSpaceIndex = self.pieces.lastIndex(where: \.isSpaceOrTab) else {
+      return self
+    }
+    return Trivia(pieces: self[..<lastNonSpaceIndex])
   }
 
   /// Returns this trivia, excluding the last newline and anything following it.