Clean up dead code

I didn't touch any public or codegen'd declarations, only internal or
lower declarations that weren't used in anywhere in this project,
including tests.

These unused declarations were found using a SwiftLint rule that's still
in development.

Author: jpsim

Sources/SwiftBasicFormat/Utils.swift

@@ -227,10 +227,6 @@ extension Lexer {
       return self.pointer.distance(to: other.pointer)
     }
 
-    func absoluteDistance(to other: Self) -> AbsolutePosition {
-      return AbsolutePosition(utf8Offset: self.distance(to: other))
-    }
-
     func peek(at offset: Int = 0) -> UInt8 {
       assert(!self.isAtEndOfFile)
       assert(offset >= 0)

Sources/SwiftParser/Lexer.swift

@@ -244,51 +244,6 @@ extension Parser.Lookahead {
 
 // MARK: Lookahead
 
-extension Parser.Lookahead {
-  private static let declAttributeNames: [SyntaxText] = [
-    "autoclosure",
-    "convention",
-    "noescape",
-    "escaping",
-    "differentiable",
-    "noDerivative",
-    "async",
-    "Sendable",
-    "unchecked",
-    "_local",
-    "block_storage",
-    "box",
-    "dynamic_self",
-    "sil_weak",
-    "sil_unowned",
-    "sil_unmanaged",
-    "error",
-    "out",
-    "in",
-    "inout",
-    "inout_aliasable",
-    "in_guaranteed",
-    "in_constant",
-    "owned",
-    "unowned_inner_pointer",
-    "guaranteed",
-    "autoreleased",
-    "callee_owned",
-    "callee_guaranteed",
-    "objc_metatype",
-    "opened",
-    "pseudogeneric",
-    "yields",
-    "yield_once",
-    "yield_many",
-    "captures_generics",
-    "thin",
-    "thick",
-    "_opaqueReturnTypeOf",
-  ]
-
-}
-
 extension Parser.Lookahead {
   func isStartOfGetSetAccessor() -> Bool {
     assert(self.at(.leftBrace), "not checking a brace?")

Sources/SwiftParser/Lookahead.swift

@@ -107,12 +107,6 @@ extension Parser {
     )
   }
 
-  mutating func parseSingleArgumentModifier() -> RawDeclModifierSyntax {
-    let keyword = self.consumeAnyToken(remapping: .contextualKeyword)
-    let detail = self.parseModifierDetail()
-    return RawDeclModifierSyntax(name: keyword, detail: detail, arena: self.arena)
-  }
-
   mutating func parseUnownedModifier() -> RawDeclModifierSyntax {
     let (unexpectedBeforeKeyword, keyword) = self.expectContextualKeyword("unowned")
 

Sources/SwiftParser/Modifiers.swift

@@ -325,18 +325,6 @@ extension Parser.Lookahead {
     return self.consume(if: .rightParen) != nil
   }
 
-  ///  typed-pattern ::= pattern (':' type)?
-  mutating func canParseTypedPattern() -> Bool {
-    guard self.canParsePattern() else {
-      return false
-    }
-
-    if self.consume(if: .colon) != nil {
-      return self.canParseType()
-    }
-    return true
-  }
-
   /// Determine whether we are at the start of a parameter name when
   /// parsing a parameter.
   /// If `allowMisplacedSpecifierRecovery` is `true`, then this will skip over any type

Sources/SwiftParser/Patterns.swift

@@ -107,105 +107,6 @@ enum BinaryOperator: RawTokenKindSubset {
   }
 }
 
-enum CanBeDeclaratinStart: RawTokenKindSubset {
-  case associatedtypeKeyword
-  case atSign
-  case caseKeyword
-  case classKeyword
-  case deinitKeyword
-  case enumKeyword
-  case extensionKeyword
-  case fileprivateKeyword
-  case funcKeyword
-  case identifier
-  case importKeyword
-  case initKeyword
-  case internalKeyword
-  case letKeyword
-  case operatorKeyword
-  case poundErrorKeyword
-  case poundIfKeyword
-  case poundSourceLocationKeyword
-  case poundWarningKeyword
-  case precedencegroupKeyword
-  case privateKeyword
-  case protocolKeyword
-  case publicKeyword
-  case staticKeyword
-  case structKeyword
-  case subscriptKeyword
-  case typealiasKeyword
-  case varKeyword
-
-  init?(lexeme: Lexer.Lexeme) {
-    switch lexeme.tokenKind {
-    case .associatedtypeKeyword: self = .associatedtypeKeyword
-    case .atSign: self = .atSign
-    case .caseKeyword: self = .caseKeyword
-    case .classKeyword: self = .classKeyword
-    case .deinitKeyword: self = .deinitKeyword
-    case .enumKeyword: self = .enumKeyword
-    case .extensionKeyword: self = .extensionKeyword
-    case .fileprivateKeyword: self = .fileprivateKeyword
-    case .funcKeyword: self = .funcKeyword
-    case .identifier: self = .identifier
-    case .importKeyword: self = .importKeyword
-    case .initKeyword: self = .initKeyword
-    case .internalKeyword: self = .internalKeyword
-    case .letKeyword: self = .letKeyword
-    case .operatorKeyword: self = .operatorKeyword
-    case .poundErrorKeyword: self = .poundErrorKeyword
-    case .poundIfKeyword: self = .poundIfKeyword
-    case .poundSourceLocationKeyword: self = .poundSourceLocationKeyword
-    case .poundWarningKeyword: self = .poundWarningKeyword
-    case .precedencegroupKeyword: self = .precedencegroupKeyword
-    case .privateKeyword: self = .privateKeyword
-    case .protocolKeyword: self = .protocolKeyword
-    case .publicKeyword: self = .publicKeyword
-    case .staticKeyword: self = .staticKeyword
-    case .structKeyword: self = .structKeyword
-    case .subscriptKeyword: self = .subscriptKeyword
-    case .typealiasKeyword: self = .typealiasKeyword
-    case .varKeyword: self = .varKeyword
-    default: return nil
-    }
-  }
-
-  var rawTokenKind: RawTokenKind {
-    switch self {
-    case .associatedtypeKeyword: return .associatedtypeKeyword
-    case .atSign: return .atSign
-    case .caseKeyword: return .caseKeyword
-    case .classKeyword: return .classKeyword
-    case .deinitKeyword: return .deinitKeyword
-    case .enumKeyword: return .enumKeyword
-    case .extensionKeyword: return .extensionKeyword
-    case .fileprivateKeyword: return .fileprivateKeyword
-    case .funcKeyword: return .funcKeyword
-    case .identifier: return .identifier
-    case .importKeyword: return .importKeyword
-    case .initKeyword: return .initKeyword
-    case .internalKeyword: return .internalKeyword
-    case .letKeyword: return .letKeyword
-    case .operatorKeyword: return .operatorKeyword
-    case .poundErrorKeyword: return .poundErrorKeyword
-    case .poundIfKeyword: return .poundIfKeyword
-    case .poundSourceLocationKeyword: return .poundSourceLocationKeyword
-    case .poundWarningKeyword: return .poundWarningKeyword
-    case .precedencegroupKeyword: return .precedencegroupKeyword
-    case .privateKeyword: return .privateKeyword
-    case .protocolKeyword: return .protocolKeyword
-    case .publicKeyword: return .publicKeyword
-    case .staticKeyword: return .staticKeyword
-    case .structKeyword: return .structKeyword
-    case .subscriptKeyword: return .subscriptKeyword
-    case .typealiasKeyword: return .typealiasKeyword
-    case .varKeyword: return .varKeyword
-    }
-  }
-
-}
-
 enum CanBeStatementStart: RawTokenKindSubset {
   case breakKeyword
   case continueKeyword

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -1214,11 +1214,6 @@ extension Parser.Lookahead {
     }
   }
 
-  func isBooleanExpr() -> Bool {
-    var lookahead = self.lookahead()
-    return !lookahead.canParseTypedPattern() || !lookahead.at(.equal)
-  }
-
   /// Returns whether the parser's current position is the start of a switch case,
   /// given that we're in the middle of a switch already.
   func isAtStartOfSwitchCase(allowRecovery: Bool = false) -> Bool {

Sources/SwiftParser/Statements.swift

@@ -21,11 +21,6 @@ extension UnexpectedNodesSyntax {
     return self.tokens(satisfying: { $0.tokenKind == kind })
   }
 
-  /// If this only contains a single item that is a token, return that token, otherwise return `nil`.
-  var onlyToken: TokenSyntax? {
-    return onlyToken(where: { _ in true })
-  }
-
   /// If this only contains a single item, which is a token satisfying `condition`, return that token, otherwise return `nil`.
   func onlyToken(where condition: (TokenSyntax) -> Bool) -> TokenSyntax? {
     if self.count == 1, let token = self.first?.as(TokenSyntax.self), condition(token) {
@@ -94,11 +89,6 @@ extension SyntaxProtocol {
     }
   }
 
-  /// Returns this node or the first ancestor that satisfies `condition`.
-  func ancestorOrSelf(where condition: (Syntax) -> Bool) -> Syntax? {
-    return ancestorOrSelf(mapping: { condition($0) ? $0 : nil })
-  }
-
   /// Returns this node or the first ancestor that satisfies `condition`.
   func ancestorOrSelf<T>(mapping map: (Syntax) -> T?) -> T? {
     var walk: Syntax? = Syntax(self)

Sources/SwiftParserDiagnostics/SyntaxExtensions.swift

@@ -11,18 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 extension String {
-  /// Remove any leading or trailing spaces.
-  /// This is necessary to avoid depending SwiftParser on Foundation.
-  func trimmingWhitespace() -> String {
-    let charactersToDrop: [Character] = [" ", "\t", "\n", "\r"]
-    var result: Substring = Substring(self)
-    result = result.drop(while: { charactersToDrop.contains($0) })
-    while let lastCharacter = result.last, charactersToDrop.contains(lastCharacter) {
-      result = result.dropLast(1)
-    }
-    return String(result)
-  }
-
   func withFirstLetterUppercased() -> String {
     if let firstLetter = self.first {
       return firstLetter.uppercased() + self.dropFirst()

Sources/SwiftParserDiagnostics/Utils.swift

@@ -156,16 +156,6 @@ extension RawSyntax {
     kind == .token
   }
 
-  /// Whether or not this node is a collection one.
-  var isCollection: Bool {
-    kind.isSyntaxCollection
-  }
-
-  /// Whether or not this node is an unknown one.
-  var isUnknown: Bool {
-    kind.isUnknown
-  }
-
   var recursiveFlags: RecursiveRawSyntaxFlags {
     switch view {
     case .token(let tokenView):

Sources/SwiftSyntax/Raw/RawSyntax.swift

@@ -142,14 +142,6 @@ public struct RawSyntaxTokenView {
     return Trivia(pieces: trailingRawTriviaPieces.map({ TriviaPiece(raw: $0) }))
   }
 
-  /// Calls `body` with the token text. The token text value must not escape the closure.
-  @_spi(RawSyntax)
-  public func withUnsafeTokenText<Result>(
-    _ body: (SyntaxText?) -> Result
-  ) -> Result {
-    body(rawText)
-  }
-
   /// Returns a `RawSyntax` node with the same source text but with the token
   /// kind changed to `newValue`.
   @_spi(RawSyntax)

Sources/SwiftSyntax/Raw/RawSyntaxTokenView.swift

@@ -295,17 +295,6 @@ public extension SyntaxProtocol {
     return data.indexInParent
   }
 
-  /// Whether or not this node has a parent.
-  var hasParent: Bool {
-    return parent != nil
-  }
-
-  /// Recursively walks through the tree to find the token semantically before
-  /// this node.
-  var previousToken: TokenSyntax? {
-    return self.previousToken(viewMode: .sourceAccurate)
-  }
-
   /// Recursively walks through the tree to find the token semantically before
   /// this node.
   func previousToken(viewMode: SyntaxTreeViewMode) -> TokenSyntax? {
@@ -326,12 +315,6 @@ public extension SyntaxProtocol {
     return parent.previousToken(viewMode: viewMode)
   }
 
-  /// Recursively walks through the tree to find the next token semantically
-  /// after this node.
-  var nextToken: TokenSyntax? {
-    return self.nextToken(viewMode: .sourceAccurate)
-  }
-
   /// Recursively walks through the tree to find the next token semantically
   /// after this node.
   func nextToken(viewMode: SyntaxTreeViewMode) -> TokenSyntax? {
@@ -370,11 +353,6 @@ public extension SyntaxProtocol {
     return nil
   }
 
-  /// Returns the last token node that is part of this syntax node.
-  var lastToken: TokenSyntax? {
-    return self.lastToken(viewMode: .sourceAccurate)
-  }
-
   /// Returns the last token node that is part of this syntax node.
   func lastToken(viewMode: SyntaxTreeViewMode) -> TokenSyntax? {
     guard viewMode.shouldTraverse(node: raw) else { return nil }
@@ -472,16 +450,6 @@ public extension SyntaxProtocol {
     }
   }
 
-  /// The length this node's leading trivia takes up spelled out in source.
-  var leadingTriviaLength: SourceLength {
-    return raw.leadingTriviaLength
-  }
-
-  /// The length this node's trailing trivia takes up spelled out in source.
-  var trailingTriviaLength: SourceLength {
-    return raw.trailingTriviaLength
-  }
-
   /// Returns a new syntax node with its leading trivia replaced
   /// by the provided trivia.
   func withLeadingTrivia(_ leadingTrivia: Trivia) -> Self {
@@ -504,11 +472,6 @@ public extension SyntaxProtocol {
     return withTrailingTrivia([])
   }
 
-  /// Returns a new syntax node with all trivia removed.
-  func withoutTrivia() -> Self {
-    return withoutLeadingTrivia().withoutTrailingTrivia()
-  }
-
   /// The length of this node including all of its trivia.
   var totalLength: SourceLength {
     return raw.totalLength