Rename TokenKind.floatingLiteral -> floatLiteral

ahoppen · ahoppen · commit a2cf2dff0356 · 2023-08-03T11:04:30.000-07:00
This is consistent with `FloatLiteralExprSyntax`
diff --git a/CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift b/CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift
@@ -770,7 +770,7 @@ public let EXPR_NODES: [Node] = [
       Child(
         name: "Literal",
         deprecatedName: "FloatingDigits",
-        kind: .token(choices: [.token(tokenKind: "FloatingLiteralToken")])
+        kind: .token(choices: [.token(tokenKind: "FloatLiteralToken")])
       )
     ]
   ),
diff --git a/CodeGeneration/Sources/SyntaxSupport/TokenSpec.swift b/CodeGeneration/Sources/SyntaxSupport/TokenSpec.swift
@@ -79,7 +79,7 @@ public let SYNTAX_TOKENS: [TokenSpec] = [
   .other(name: "endOfFile", nameForDiagnostics: "end of file", text: ""),
   .punctuator(name: "equal", text: "="),
   .punctuator(name: "exclamationMark", text: "!"),
-  .other(name: "floatingLiteral", nameForDiagnostics: "floating literal"),
+  .other(name: "floatLiteral", nameForDiagnostics: "float literal"),
   .other(name: "identifier", nameForDiagnostics: "identifier"),
   .punctuator(name: "infixQuestionMark", text: "?"),
   .other(name: "integerLiteral", nameForDiagnostics: "integer literal"),
diff --git a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift
@@ -178,7 +178,7 @@ class ValidateSyntaxNodes: XCTestCase {
         }
       }
 
-    case .token(tokenKind: "IdentifierToken"), .token(tokenKind: "IntegerLiteralToken"), .token(tokenKind: "FloatingLiteralToken"):
+    case .token(tokenKind: "IdentifierToken"), .token(tokenKind: "IntegerLiteralToken"), .token(tokenKind: "FloatLiteralToken"):
       // We allow arbitrary naming of identifiers and literals
       break
     case .token(tokenKind: "CommaToken"):
diff --git a/Sources/SwiftIDEUtils/SyntaxClassification.swift b/Sources/SwiftIDEUtils/SyntaxClassification.swift
@@ -28,7 +28,7 @@ public enum SyntaxClassification {
   /// An editor placeholder of the form `<#content#>`
   case editorPlaceholder
   /// A floating point literal.
-  case floatingLiteral
+  case floatLiteral
   /// A generic identifier.
   case identifier
   /// An integer literal.
@@ -51,6 +51,11 @@ public enum SyntaxClassification {
   case stringLiteral
   /// An identifier referring to a type.
   case typeIdentifier
+
+  @available(*, deprecated, renamed: "floatLiteral")
+  public static var floatingLiteral: Self {
+    return .floatLiteral
+  }
 }
 
 extension SyntaxClassification {
@@ -124,8 +129,8 @@ extension RawTokenKind {
       return .none
     case .exclamationMark:
       return .none
-    case .floatingLiteral:
-      return .floatingLiteral
+    case .floatLiteral:
+      return .floatLiteral
     case .identifier:
       return .identifier
     case .infixQuestionMark:
diff --git a/Sources/SwiftParser/Availability.swift b/Sources/SwiftParser/Availability.swift
@@ -210,7 +210,7 @@ extension Parser {
     }
 
     let version: RawVersionTupleSyntax?
-    if self.at(.integerLiteral, .floatingLiteral) {
+    if self.at(.integerLiteral, .floatLiteral) {
       version = self.parseVersionTuple(maxComponentCount: 3)
     } else {
       version = nil
@@ -237,7 +237,7 @@ extension Parser {
     return self.consumeAnyToken()
   }
 
-  /// Consume the unexpected version token(e.g. integerLiteral, floatingLiteral, identifier) until the period no longer appears.
+  /// Consume the unexpected version token(e.g. integerLiteral, floatLiteral, identifier) until the period no longer appears.
   private mutating func parseUnexpectedVersionTokens() -> RawUnexpectedNodesSyntax? {
     var unexpectedTokens: [RawTokenSyntax] = []
     var keepGoing: RawTokenSyntax? = nil
@@ -246,7 +246,7 @@ extension Parser {
       if let keepGoing {
         unexpectedTokens.append(keepGoing)
       }
-      if let unexpectedVersion = self.consume(if: .integerLiteral, .floatingLiteral, .identifier) {
+      if let unexpectedVersion = self.consume(if: .integerLiteral, .floatLiteral, .identifier) {
         unexpectedTokens.append(unexpectedVersion)
       }
       keepGoing = self.consume(if: .period)
@@ -256,7 +256,7 @@ extension Parser {
 
   /// Parse a dot-separated list of version numbers.
   mutating func parseVersionTuple(maxComponentCount: Int) -> RawVersionTupleSyntax {
-    if self.at(.floatingLiteral),
+    if self.at(.floatLiteral),
       let periodIndex = self.currentToken.tokenText.firstIndex(of: UInt8(ascii: ".")),
       self.currentToken.tokenText[0..<periodIndex].allSatisfy({ Unicode.Scalar($0).isDigit })
     {
diff --git a/Sources/SwiftParser/Expressions.swift b/Sources/SwiftParser/Expressions.swift
@@ -1097,7 +1097,7 @@ extension Parser {
           arena: self.arena
         )
       )
-    case (.floatingLiteral, let handle)?:
+    case (.floatLiteral, let handle)?:
       let literal = self.eat(handle)
       return RawExprSyntax(
         RawFloatLiteralExprSyntax(
@@ -1186,7 +1186,7 @@ extension Parser {
         return RawExprSyntax(
           RawFloatLiteralExprSyntax(
             literal: RawTokenSyntax(
-              missing: .floatingLiteral,
+              missing: .floatLiteral,
               text: text,
               arena: self.arena
             ),
diff --git a/Sources/SwiftParser/Lexer/Cursor.swift b/Sources/SwiftParser/Lexer/Cursor.swift
@@ -1407,7 +1407,7 @@ extension Lexer.Cursor {
         let errorPos = tmp
         self.advance(while: { $0.isValidIdentifierContinuationCodePoint })
         return Lexer.Result(
-          .floatingLiteral,
+          .floatLiteral,
           error: LexingDiagnostic(errorKind, position: errorPos)
         )
       }
@@ -1419,13 +1419,13 @@ extension Lexer.Cursor {
         let errorPos = tmp
         self.advance(while: { $0.isValidIdentifierContinuationCodePoint })
         return Lexer.Result(
-          .floatingLiteral,
+          .floatLiteral,
           error: LexingDiagnostic(.invalidFloatingPointExponentDigit, position: errorPos)
         )
       }
     }
 
-    return Lexer.Result(.floatingLiteral)
+    return Lexer.Result(.floatLiteral)
   }
 
   mutating func lexHexNumber() -> Lexer.Result {
@@ -1529,7 +1529,7 @@ extension Lexer.Cursor {
       let errorPos = tmp
       self.advance(while: { $0.isValidIdentifierContinuationCodePoint })
       return Lexer.Result(
-        .floatingLiteral,
+        .floatLiteral,
         error: LexingDiagnostic(errorKind, position: errorPos)
       )
     }
@@ -1541,11 +1541,11 @@ extension Lexer.Cursor {
       let errorPos = tmp
       self.advance(while: { $0.isValidIdentifierContinuationCodePoint })
       return Lexer.Result(
-        .floatingLiteral,
+        .floatLiteral,
         error: LexingDiagnostic(.invalidFloatingPointExponentDigit, position: errorPos)
       )
     }
-    return Lexer.Result(.floatingLiteral)
+    return Lexer.Result(.floatLiteral)
   }
 }
 
diff --git a/Sources/SwiftParser/Lexer/RegexLiteralLexer.swift b/Sources/SwiftParser/Lexer/RegexLiteralLexer.swift
@@ -640,7 +640,7 @@ extension Lexer.Cursor {
       return false
 
     // Literals are themselves expressions and therefore don't sequence expressions.
-    case .floatingLiteral, .integerLiteral:
+    case .floatLiteral, .integerLiteral:
       return false
 
     // Pound keywords that do not generally sequence expressions.
diff --git a/Sources/SwiftParser/Parser.swift b/Sources/SwiftParser/Parser.swift
@@ -524,7 +524,7 @@ extension Parser {
         self.missingToken(.identifier)
       )
     }
-    if let number = self.consume(if: .integerLiteral, .floatingLiteral, .dollarIdentifier) {
+    if let number = self.consume(if: .integerLiteral, .floatLiteral, .dollarIdentifier) {
       return (
         RawUnexpectedNodesSyntax(elements: [RawSyntax(number)], arena: self.arena),
         self.missingToken(.identifier)
diff --git a/Sources/SwiftParser/TokenPrecedence.swift b/Sources/SwiftParser/TokenPrecedence.swift
@@ -117,7 +117,7 @@ enum TokenPrecedence: Comparable {
       self = .unknownToken
     // MARK: Identifier like
     case  // Literals
-    .floatingLiteral, .integerLiteral,
+    .floatLiteral, .integerLiteral,
       // Pound literals
       .poundAvailable, .poundSourceLocation, .poundUnavailable,
       // Identifiers
diff --git a/Sources/SwiftParser/TokenSpec.swift b/Sources/SwiftParser/TokenSpec.swift
@@ -172,7 +172,7 @@ public struct TokenSpec {
     switch rawTokenKind {
     case .binaryOperator: return .binaryOperator("+")
     case .dollarIdentifier: return .dollarIdentifier("$0")
-    case .floatingLiteral: return .floatingLiteral("1.0")
+    case .floatLiteral: return .floatLiteral("1.0")
     case .identifier: return .identifier("myIdent")
     case .integerLiteral: return .integerLiteral("1")
     case .keyword: return .keyword(keyword!)
diff --git a/Sources/SwiftParser/TokenSpecSet.swift b/Sources/SwiftParser/TokenSpecSet.swift
@@ -774,7 +774,7 @@ enum PrimaryExpressionStart: TokenSpecSet {
   case `Self`
   case dollarIdentifier
   case `false`
-  case floatingLiteral
+  case floatLiteral
   case identifier
   case `init`
   case integerLiteral
@@ -804,7 +804,7 @@ enum PrimaryExpressionStart: TokenSpecSet {
     case TokenSpec(.Self): self = .Self
     case TokenSpec(.dollarIdentifier): self = .dollarIdentifier
     case TokenSpec(.false): self = .false
-    case TokenSpec(.floatingLiteral): self = .floatingLiteral
+    case TokenSpec(.floatLiteral): self = .floatLiteral
     case TokenSpec(.identifier): self = .identifier
     case TokenSpec(.`init`): self = .`init`
     case TokenSpec(.integerLiteral): self = .integerLiteral
@@ -837,7 +837,7 @@ enum PrimaryExpressionStart: TokenSpecSet {
     case .Self: return .keyword(.Self)
     case .dollarIdentifier: return .dollarIdentifier
     case .false: return .keyword(.false)
-    case .floatingLiteral: return .floatingLiteral
+    case .floatLiteral: return .floatLiteral
     case .identifier: return .identifier
     case .`init`: return .keyword(.`init`)
     case .integerLiteral: return .integerLiteral
diff --git a/Sources/SwiftParser/generated/TokenSpecStaticMembers.swift b/Sources/SwiftParser/generated/TokenSpecStaticMembers.swift
@@ -63,8 +63,8 @@ extension TokenSpec {
     return TokenSpec(.exclamationMark)
   }
   
-  static var floatingLiteral: TokenSpec {
-    return TokenSpec(.floatingLiteral)
+  static var floatLiteral: TokenSpec {
+    return TokenSpec(.floatLiteral)
   }
   
   static var identifier: TokenSpec {
diff --git a/Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift b/Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift
@@ -355,7 +355,7 @@ public struct InvalidIdentifierError: ParserError {
 
   public var message: String {
     switch invalidIdentifier.tokenKind {
-    case .floatingLiteral(let text), .integerLiteral(let text):
+    case .floatLiteral(let text), .integerLiteral(let text):
       fallthrough
     case .unknown(let text) where text.first?.isNumber == true:
       let name = missingIdentifier.childNameInParent ?? "identifier"
diff --git a/Sources/SwiftParserDiagnostics/generated/TokenNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/TokenNameForDiagnostics.swift
@@ -41,8 +41,8 @@ extension TokenKind {
       return "="
     case .exclamationMark:
       return "!"
-    case .floatingLiteral:
-      return "floating literal"
+    case .floatLiteral:
+      return "float literal"
     case .identifier:
       return "identifier"
     case .infixQuestionMark:
diff --git a/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift b/Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift
@@ -135,6 +135,11 @@ public extension TokenKind {
     return .regexPoundDelimiter(text)
   }
 
+  @available(*, deprecated, renamed: "floatLiteral")
+  static func floatingLiteral(_ text: String) -> TokenKind {
+    return .floatLiteral(text)
+  }
+
   @available(*, deprecated, renamed: "leftSquare")
   static var leftSquareBracket: TokenKind {
     return .leftSquare
@@ -205,6 +210,21 @@ public extension TokenSyntax {
     )
   }
 
+  @available(*, deprecated, renamed: "floatLiteral")
+  static func floatingLiteral(
+    _ text: String,
+    leadingTrivia: Trivia = [],
+    trailingTrivia: Trivia = [],
+    presence: SourcePresence = .present
+  ) -> TokenSyntax {
+    return floatLiteral(
+      text,
+      leadingTrivia: leadingTrivia,
+      trailingTrivia: trailingTrivia,
+      presence: presence
+    )
+  }
+
   @available(*, deprecated, renamed: "leftSquareToken")
   static func leftSquareBracketToken(
     leadingTrivia: Trivia = [],
diff --git a/Sources/SwiftSyntax/generated/TokenKind.swift b/Sources/SwiftSyntax/generated/TokenKind.swift
@@ -26,7 +26,7 @@ public enum TokenKind: Hashable {
   case endOfFile
   case equal
   case exclamationMark
-  case floatingLiteral(String)
+  case floatLiteral(String)
   case identifier(String)
   case infixQuestionMark
   case integerLiteral(String)
@@ -92,7 +92,7 @@ public enum TokenKind: Hashable {
       return #"="#
     case .exclamationMark:
       return #"!"#
-    case .floatingLiteral(let text):
+    case .floatLiteral(let text):
       return text
     case .identifier(let text):
       return text
@@ -283,7 +283,7 @@ public enum TokenKind: Hashable {
       return true
     case .exclamationMark:
       return true
-    case .floatingLiteral:
+    case .floatLiteral:
       return false
     case .identifier:
       return false
@@ -388,7 +388,7 @@ extension TokenKind: Equatable {
       return true
     case (.exclamationMark, .exclamationMark):
       return true
-    case (.floatingLiteral(let lhsText), .floatingLiteral(let rhsText)):
+    case (.floatLiteral(let lhsText), .floatLiteral(let rhsText)):
       return lhsText == rhsText
     case (.identifier(let lhsText), .identifier(let rhsText)):
       return lhsText == rhsText
@@ -487,7 +487,7 @@ public enum RawTokenKind: UInt8, Equatable, Hashable {
   case endOfFile
   case equal
   case exclamationMark
-  case floatingLiteral
+  case floatLiteral
   case identifier
   case infixQuestionMark
   case integerLiteral
@@ -636,7 +636,7 @@ public enum RawTokenKind: UInt8, Equatable, Hashable {
       return true
     case .exclamationMark:
       return true
-    case .floatingLiteral:
+    case .floatLiteral:
       return false
     case .identifier:
       return false
@@ -753,8 +753,8 @@ extension TokenKind {
     case .exclamationMark:
       precondition(text.isEmpty || rawKind.defaultText.map(String.init) == text)
       return .exclamationMark
-    case .floatingLiteral:
-      return .floatingLiteral(text)
+    case .floatLiteral:
+      return .floatLiteral(text)
     case .identifier:
       return .identifier(text)
     case .infixQuestionMark:
@@ -888,8 +888,8 @@ extension TokenKind {
       return (.equal, nil)
     case .exclamationMark:
       return (.exclamationMark, nil)
-    case .floatingLiteral(let str):
-      return (.floatingLiteral, str)
+    case .floatLiteral(let str):
+      return (.floatLiteral, str)
     case .identifier(let str):
       return (.identifier, str)
     case .infixQuestionMark:
diff --git a/Sources/SwiftSyntax/generated/Tokens.swift b/Sources/SwiftSyntax/generated/Tokens.swift
@@ -185,15 +185,15 @@ extension TokenSyntax {
     )
   }
   
-  public static func floatingLiteral(
+  public static func floatLiteral(
     _ text: String,
     leadingTrivia: Trivia = [],
     trailingTrivia: Trivia = [],
     presence: SourcePresence = .present
     
   ) -> TokenSyntax {
     return TokenSyntax(
-      .floatingLiteral(text),
+      .floatLiteral(text),
       leadingTrivia: leadingTrivia,
       trailingTrivia: trailingTrivia,
       presence: presence
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
@@ -1175,7 +1175,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
   case .floatLiteralExpr:
     assert(layout.count == 3)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.floatingLiteral)]))
+    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.floatLiteral)]))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
   case .forStmt:
     assert(layout.count == 21)
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxExprNodes.swift
diff --git a/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift b/Sources/SwiftSyntaxBuilder/ConvenienceInitializers.swift
diff --git a/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift b/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift
diff --git a/Sources/lit-test-helper/ClassifiedSyntaxTreePrinter.swift b/Sources/lit-test-helper/ClassifiedSyntaxTreePrinter.swift
diff --git a/Tests/SwiftParserTest/LexerTests.swift b/Tests/SwiftParserTest/LexerTests.swift
diff --git a/Tests/SwiftParserTest/translated/IfconfigExprTests.swift b/Tests/SwiftParserTest/translated/IfconfigExprTests.swift
diff --git a/Tests/SwiftSyntaxBuilderTest/FloatLiteralTests.swift b/Tests/SwiftSyntaxBuilderTest/FloatLiteralTests.swift

Original file line number	Diff line number	Diff line change
`@@ -770,7 +770,7 @@ public let EXPR_NODES: [Node] = [`
`770`	`770`	`Child(`
`771`	`771`	`name: "Literal",`
`772`	`772`	`deprecatedName: "FloatingDigits",`
`773`		`- kind: .token(choices: [.token(tokenKind: "FloatingLiteralToken")])`
	`773`	`+ kind: .token(choices: [.token(tokenKind: "FloatLiteralToken")])`
`774`	`774`	`)`
`775`	`775`	`]`
`776`	`776`	`),`
Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ class ValidateSyntaxNodes: XCTestCase {`
`178`	`178`	`}`
`179`	`179`	`}`
`180`	`180`
`181`		`- case .token(tokenKind: "IdentifierToken"), .token(tokenKind: "IntegerLiteralToken"), .token(tokenKind: "FloatingLiteralToken"):`
	`181`	`+ case .token(tokenKind: "IdentifierToken"), .token(tokenKind: "IntegerLiteralToken"), .token(tokenKind: "FloatLiteralToken"):`
`182`	`182`	`// We allow arbitrary naming of identifiers and literals`
`183`	`183`	`break`
`184`	`184`	`case .token(tokenKind: "CommaToken"):`
Original file line number	Diff line number	Diff line change
`@@ -1407,7 +1407,7 @@ extension Lexer.Cursor {`
`1407`	`1407`	`let errorPos = tmp`
`1408`	`1408`	`self.advance(while: { $0.isValidIdentifierContinuationCodePoint })`
`1409`	`1409`	`return Lexer.Result(`
`1410`		`- .floatingLiteral,`
	`1410`	`+ .floatLiteral,`
`1411`	`1411`	`error: LexingDiagnostic(errorKind, position: errorPos)`
`1412`	`1412`	`)`
`1413`	`1413`	`}`
`@@ -1419,13 +1419,13 @@ extension Lexer.Cursor {`
`1419`	`1419`	`let errorPos = tmp`
`1420`	`1420`	`self.advance(while: { $0.isValidIdentifierContinuationCodePoint })`
`1421`	`1421`	`return Lexer.Result(`
`1422`		`- .floatingLiteral,`
	`1422`	`+ .floatLiteral,`
`1423`	`1423`	`error: LexingDiagnostic(.invalidFloatingPointExponentDigit, position: errorPos)`
`1424`	`1424`	`)`
`1425`	`1425`	`}`
`1426`	`1426`	`}`
`1427`	`1427`
`1428`		`- return Lexer.Result(.floatingLiteral)`
	`1428`	`+ return Lexer.Result(.floatLiteral)`
`1429`	`1429`	`}`
`1430`	`1430`
`1431`	`1431`	`mutating func lexHexNumber() -> Lexer.Result {`
`@@ -1529,7 +1529,7 @@ extension Lexer.Cursor {`
`1529`	`1529`	`let errorPos = tmp`
`1530`	`1530`	`self.advance(while: { $0.isValidIdentifierContinuationCodePoint })`
`1531`	`1531`	`return Lexer.Result(`
`1532`		`- .floatingLiteral,`
	`1532`	`+ .floatLiteral,`
`1533`	`1533`	`error: LexingDiagnostic(errorKind, position: errorPos)`
`1534`	`1534`	`)`
`1535`	`1535`	`}`
`@@ -1541,11 +1541,11 @@ extension Lexer.Cursor {`
`1541`	`1541`	`let errorPos = tmp`
`1542`	`1542`	`self.advance(while: { $0.isValidIdentifierContinuationCodePoint })`
`1543`	`1543`	`return Lexer.Result(`
`1544`		`- .floatingLiteral,`
	`1544`	`+ .floatLiteral,`
`1545`	`1545`	`error: LexingDiagnostic(.invalidFloatingPointExponentDigit, position: errorPos)`
`1546`	`1546`	`)`
`1547`	`1547`	`}`
`1548`		`- return Lexer.Result(.floatingLiteral)`
	`1548`	`+ return Lexer.Result(.floatLiteral)`
`1549`	`1549`	`}`
`1550`	`1550`	`}`
`1551`	`1551`
Original file line number	Diff line number	Diff line change
`@@ -524,7 +524,7 @@ extension Parser {`
`524`	`524`	`self.missingToken(.identifier)`
`525`	`525`	`)`
`526`	`526`	`}`
`527`		`- if let number = self.consume(if: .integerLiteral, .floatingLiteral, .dollarIdentifier) {`
	`527`	`+ if let number = self.consume(if: .integerLiteral, .floatLiteral, .dollarIdentifier) {`
`528`	`528`	`return (`
`529`	`529`	`RawUnexpectedNodesSyntax(elements: [RawSyntax(number)], arena: self.arena),`
`530`	`530`	`self.missingToken(.identifier)`