Remove value that is optional

Author: kimdv

Sources/SwiftParser/Declarations.swift

@@ -192,7 +192,7 @@ extension Parser {
             lastElement.unexpectedBeforeDecl,
             decl: lastElement.decl,
             lastElement.unexpectedBetweenDeclAndSemicolon,
-            semicolon: parser.missingToken(.semicolon, text: nil),
+            semicolon: parser.missingToken(.semicolon),
             lastElement.unexpectedAfterSemicolon,
             arena: parser.arena
           )
@@ -835,7 +835,7 @@ extension Parser {
             lastItem.unexpectedBeforeDecl,
             decl: lastItem.decl,
             lastItem.unexpectedBetweenDeclAndSemicolon,
-            semicolon: self.missingToken(.semicolon, text: nil),
+            semicolon: self.missingToken(.semicolon),
             lastItem.unexpectedAfterSemicolon,
             arena: self.arena
           )
@@ -1575,7 +1575,7 @@ extension Parser {
               typeAnnotationUnwrapped.unexpectedBetweenColonAndType,
               arena: self.arena
             ),
-            equal: missingToken(.equal, text: nil),
+            equal: missingToken(.equal),
             value: initExpr,
             arena: self.arena
           )
@@ -1742,7 +1742,7 @@ extension Parser {
     let lbrace: RawTokenSyntax
     if self.at(anyIn: AccessorKind.self) != nil {
       unexpectedBeforeLBrace = nil
-      lbrace = missingToken(.leftBrace, text: nil)
+      lbrace = missingToken(.leftBrace)
     } else {
       (unexpectedBeforeLBrace, lbrace) = self.expect(.leftBrace)
     }
@@ -1837,7 +1837,7 @@ extension Parser {
     let equal: RawTokenSyntax
     if let colon = self.consume(if: .colon) {
       unexpectedBeforeEqual = RawUnexpectedNodesSyntax(elements: [RawSyntax(colon)], arena: self.arena)
-      equal = missingToken(.equal, text: nil)
+      equal = missingToken(.equal)
     } else {
       (unexpectedBeforeEqual, equal) = self.expect(.equal)
     }
@@ -1901,7 +1901,7 @@ extension Parser {
       } else {
         unexpectedBeforeName = nil
       }
-      name = missingToken(.binaryOperator, text: nil)
+      name = missingToken(.binaryOperator)
     }
 
     // Eat any subsequent tokens that are not separated to the operator by trivia.

Sources/SwiftParser/Expressions.swift

@@ -2331,7 +2331,7 @@ extension Parser {
                       RawCaseItemSyntax(
                         pattern: RawPatternSyntax(
                           RawIdentifierPatternSyntax(
-                            identifier: missingToken(.identifier, text: nil),
+                            identifier: missingToken(.identifier),
                             arena: self.arena
                           )
                         ),
@@ -2342,7 +2342,7 @@ extension Parser {
                     ],
                     arena: self.arena
                   ),
-                  colon: missingToken(.colon, text: nil),
+                  colon: missingToken(.colon),
                   arena: self.arena
                 )
               ),

Sources/SwiftParser/Names.swift

@@ -28,7 +28,7 @@ extension Parser {
     if let dollarIdent = self.consume(if: .dollarIdentifier) {
       return (
         RawUnexpectedNodesSyntax(elements: [RawSyntax(dollarIdent)], arena: self.arena),
-        self.missingToken(.identifier, text: nil)
+        self.missingToken(.identifier)
       )
     } else {
       if let wildcardToken = self.consume(if: .wildcard) {

Sources/SwiftParser/Parser.swift

@@ -439,7 +439,7 @@ extension Parser {
     if let number = self.consume(if: .integerLiteral, .floatingLiteral, .dollarIdentifier) {
       return (
         RawUnexpectedNodesSyntax(elements: [RawSyntax(number)], arena: self.arena),
-        self.missingToken(.identifier, text: nil)
+        self.missingToken(.identifier)
       )
     } else if keywordRecovery,
       (self.currentToken.isLexerClassifiedKeyword || self.currentToken.rawTokenKind == .wildcard),
@@ -448,7 +448,7 @@ extension Parser {
       let keyword = self.consumeAnyToken()
       return (
         RawUnexpectedNodesSyntax(elements: [RawSyntax(keyword)], arena: self.arena),
-        self.missingToken(.identifier, text: nil)
+        self.missingToken(.identifier)
       )
     }
     return (
@@ -505,21 +505,21 @@ extension Parser {
     var lookahead = self.lookahead()
     guard let recoveryHandle = lookahead.canRecoverTo(.rightBrace) else {
       // We can't recover to '}'. Synthesize it.
-      return (nil, self.missingToken(.rightBrace, text: nil))
+      return (nil, self.missingToken(.rightBrace))
     }
 
     // We can recover to a '}'. Decide whether we want to eat it based on its indentation.
     let rightBraceTrivia = self.arena.parseTrivia(source: lookahead.currentToken.leadingTriviaText, position: .leading)
     switch (indentation(introducer.leadingTriviaPieces), indentation(rightBraceTrivia)) {
     // Catch cases where the brace has known indentation that is less than that of `introducer`, in which case we don't want to consume it.
     case (.spaces(let introducerSpaces), .spaces(let rightBraceSpaces)) where rightBraceSpaces < introducerSpaces:
-      return (nil, self.missingToken(.rightBrace, text: nil))
+      return (nil, self.missingToken(.rightBrace))
     case (.tabs(let introducerTabs), .tabs(let rightBraceTabs)) where rightBraceTabs < introducerTabs:
-      return (nil, self.missingToken(.rightBrace, text: nil))
+      return (nil, self.missingToken(.rightBrace))
     case (.spaces, .tabs(0)):
-      return (nil, self.missingToken(.rightBrace, text: nil))
+      return (nil, self.missingToken(.rightBrace))
     case (.tabs, .spaces(0)):
-      return (nil, self.missingToken(.rightBrace, text: nil))
+      return (nil, self.missingToken(.rightBrace))
     default:
       return self.eat(recoveryHandle)
     }

Sources/SwiftParser/Patterns.swift

@@ -141,7 +141,7 @@ extension Parser {
         return RawPatternSyntax(
           RawIdentifierPatternSyntax(
             RawUnexpectedNodesSyntax([keyword], arena: self.arena),
-            identifier: missingToken(.identifier, text: nil),
+            identifier: missingToken(.identifier),
             arena: self.arena
           )
         )
@@ -178,7 +178,7 @@ extension Parser {
       // Recovery if the user forgot to add ':'
       let result = self.parseResultType()
       type = RawTypeAnnotationSyntax(
-        colon: self.missingToken(.colon, text: nil),
+        colon: self.missingToken(.colon),
         type: result,
         arena: self.arena
       )

Sources/SwiftParser/TokenConsumer.swift

@@ -224,15 +224,15 @@ extension TokenConsumer {
     if let (_, handle) = self.at(anyIn: IdentifierTokens.self) {
       return self.eat(handle)
     }
-    return missingToken(.identifier, text: nil)
+    return missingToken(.identifier)
   }
 
   @inline(__always)
   mutating func expectIdentifierOrRethrowsWithoutRecovery() -> Token {
     if let (_, handle) = self.at(anyIn: IdentifierOrRethrowsTokens.self) {
       return self.eat(handle)
     }
-    return missingToken(.identifier, text: nil)
+    return missingToken(.identifier)
   }
 
   var canHaveParameterSpecifier: Bool {

Sources/SwiftParser/TopLevel.swift

@@ -72,7 +72,7 @@ extension Parser {
           lastItem.unexpectedBeforeItem,
           item: .init(lastItem.item)!,
           lastItem.unexpectedBetweenItemAndSemicolon,
-          semicolon: self.missingToken(.semicolon, text: nil),
+          semicolon: self.missingToken(.semicolon),
           lastItem.unexpectedAfterSemicolon,
           arena: self.arena
         )
@@ -236,7 +236,7 @@ extension Parser {
             lastElement.unexpectedBeforeItem,
             item: .init(lastElement.item)!,
             lastElement.unexpectedBetweenItemAndSemicolon,
-            semicolon: parser.missingToken(.semicolon, text: nil),
+            semicolon: parser.missingToken(.semicolon),
             lastElement.unexpectedAfterSemicolon,
             arena: parser.arena
           )