Diagnose if a number is used in place of an identifier

ahoppen · ahoppen · commit 214a4bb32761 · 2022-10-13T19:18:20.000+02:00
diff --git a/Sources/SwiftParser/Diagnostics/MissingNodesError.swift b/Sources/SwiftParser/Diagnostics/MissingNodesError.swift
@@ -37,14 +37,12 @@ fileprivate enum NodesDescriptionPart {
       }
       return "'\(tokenContents.trimmingWhitespace())'"
     case .tokenWithoutDefaultText(let token):
-      if let parent = token.parent,
-         let childName = parent.childNameForDiagnostics(token.index) {
+      if let childName = token.childNameInParent {
         return childName
       }
       return token.tokenKind.decomposeToRaw().rawKind.nameForDiagnostics
     case .node(let node):
-      if let parent = node.parent,
-         let childName = parent.childNameForDiagnostics(node.index) {
+      if let childName = node.childNameInParent {
         return childName
       } else {
         return node.nodeTypeNameForDiagnostics(allowBlockNames: true)
diff --git a/Sources/SwiftParser/Diagnostics/ParseDiagnosticsGenerator.swift b/Sources/SwiftParser/Diagnostics/ParseDiagnosticsGenerator.swift
@@ -194,7 +194,12 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
           fixIts = []
         }
 
-        addDiagnostic(invalidIdentifier, InvalidIdentifierError(invalidIdentifier: invalidIdentifier), fixIts: fixIts, handledNodes: [previousParent.id])
+        addDiagnostic(
+          invalidIdentifier,
+          InvalidIdentifierError(invalidIdentifier: invalidIdentifier, missingIdentifier: node),
+          fixIts: fixIts,
+          handledNodes: [previousParent.id]
+        )
       } else {
         return handleMissingSyntax(node)
       }
diff --git a/Sources/SwiftParser/Diagnostics/ParserDiagnosticMessages.swift b/Sources/SwiftParser/Diagnostics/ParserDiagnosticMessages.swift
@@ -122,11 +122,15 @@ public struct IdentifierNotAllowedInOperatorName: ParserError {
 
 public struct InvalidIdentifierError: ParserError {
   public let invalidIdentifier: TokenSyntax
+  public let missingIdentifier: TokenSyntax
 
   public var message: String {
     switch invalidIdentifier.tokenKind {
+    case .floatingLiteral(let text), .integerLiteral(let text):
+      fallthrough
     case .unknown(let text) where text.first?.isNumber == true:
-      return "identifier can only start with a letter or underscore, not a number"
+      let name = missingIdentifier.childNameInParent ?? "identifier"
+      return "\(name) can only start with a letter or underscore, not a number"
     case .wildcardKeyword:
       return "'\(invalidIdentifier.text)' cannot be used as an identifier here"
     case let tokenKind where tokenKind.isKeyword:
diff --git a/Sources/SwiftParser/Parser.swift b/Sources/SwiftParser/Parser.swift
@@ -387,7 +387,12 @@ extension Parser {
         self.missingToken(.identifier, text: nil)
       )
     }
-    if keywordRecovery, self.currentToken.tokenKind.isKeyword, !self.currentToken.isAtStartOfLine {
+    if let number = self.consume(ifAny: [.integerLiteral, .floatingLiteral]) {
+      return (
+        RawUnexpectedNodesSyntax(elements: [RawSyntax(number)], arena: self.arena),
+        self.missingToken(.identifier, text: nil)
+      )
+    } else if keywordRecovery, self.currentToken.tokenKind.isKeyword, !self.currentToken.isAtStartOfLine {
       let keyword = self.consumeAnyToken()
       return (
         RawUnexpectedNodesSyntax(elements: [RawSyntax(keyword)], arena: self.arena),
diff --git a/Sources/SwiftSyntax/Syntax.swift b/Sources/SwiftSyntax/Syntax.swift
@@ -134,9 +134,23 @@ public protocol SyntaxProtocol: CustomStringConvertible,
 
   /// Return a name with which the child at the given `index` can be referred to
   /// in diagnostics.
+  /// Typically, you want to use `childNameInParent` on the child instead of
+  /// calling this method on the parent.
   func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String?
 }
 
+public extension SyntaxProtocol {
+  /// If the parent has a dedicated "name for diagnostics" for this node, return it.
+  /// Otherwise, return `nil`.
+  var childNameInParent: String? {
+    if let parent = self.parent, let childName = parent.childNameForDiagnostics(self.index) {
+      return childName
+    } else {
+      return nil
+    }
+  }
+}
+
 extension SyntaxProtocol {
   var data: SyntaxData {
     return _syntaxNode.data
diff --git a/Tests/SwiftParserTest/Declarations.swift b/Tests/SwiftParserTest/Declarations.swift
@@ -690,8 +690,8 @@ final class DeclarationTests: XCTestCase {
       }
       """,
       diagnostics: [
-        DiagnosticSpec(locationMarker: "1️⃣", message: "identifier can only start with a letter or underscore, not a number"),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "identifier can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -1023,7 +1023,7 @@ final class DeclarationTests: XCTestCase {
     AssertParse(
       "associatedtype 1️⃣5s",
       diagnostics: [
-        DiagnosticSpec(message: "identifier can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
diff --git a/Tests/SwiftParserTest/translated/EnumTests.swift b/Tests/SwiftParserTest/translated/EnumTests.swift
@@ -259,13 +259,13 @@ final class EnumTests: XCTestCase {
     AssertParse(
       """
       enum SwitchEnvy {
-        case 1️⃣0:
+        case 1️⃣02️⃣:
       }
       """,
       diagnostics: [
         // TODO: Old parser expected error on line 2: 'case' label can only appear inside a 'switch' statement
-        DiagnosticSpec(message: "expected name in enum case"),
-        DiagnosticSpec(message: "unexpected code '0:' in enum"),
+        DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code ':' in enum"),
       ]
     )
   }
diff --git a/Tests/SwiftParserTest/translated/NumberIdentifierErrorsTests.swift b/Tests/SwiftParserTest/translated/NumberIdentifierErrorsTests.swift
@@ -13,27 +13,40 @@ final class NumberIdentifierErrorsTests: XCTestCase {
     )
   }
 
-  func testNumberIdentifierErrors2() {
+  func testNumberIdentifierErrors2a() {
     AssertParse(
       """
       func 1️⃣1() {}
-      func 2️⃣2.0() {}
-      func 3️⃣3func() {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: function name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected name in function"),
-        DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code '1' before parameter clause"),
-        // TODO: Old parser expected error on line 2: function name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in function"),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '2.0' before parameter clause"),
-        // TODO: Old parser expected error on line 3: function name can only start with a letter or underscore, not a number
-        // TODO: Old parser expected error on line 3: 'f' is not a valid digit in integer literal
-        DiagnosticSpec(locationMarker: "3️⃣", message: "identifier can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
 
+  func testNumberIdentifierErrors2b() {
+    AssertParse(
+      """
+      func 1️⃣2.0() {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
+      ]
+    )
+  }
+
+  func testNumberIdentifierErrors2c() {
+    AssertParse(
+      """
+      func 1️⃣3func() {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
+      ]
+    )
+  }
+
+
   func testNumberIdentifierErrors3a() {
     AssertParse(
       """
@@ -42,10 +55,8 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       }
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: protocol name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected name and member block in protocol"),
-        // TODO: Old parser expected error on line 2: associatedtype name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in associatedtype declaration"),
+        DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -58,10 +69,8 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       }
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: protocol name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected name and member block in protocol"),
-        // TODO: Old parser expected error on line 2: associatedtype name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in associatedtype declaration"),
+        DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -74,34 +83,42 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       }
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: protocol name can only start with a letter or underscore, not a number
-        // TODO: Old parser expected error on line 1: 'p' is not a valid digit in integer literal
-        DiagnosticSpec(locationMarker: "1️⃣", message: "identifier can only start with a letter or underscore, not a number"),
-        // TODO: Old parser expected error on line 2: associatedtype name can only start with a letter or underscore, not a number
-        // TODO: Old parser expected error on line 2: 'a' is not a valid digit in integer literal
-        DiagnosticSpec(locationMarker: "2️⃣", message: "identifier can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
 
 
-  func testNumberIdentifierErrors4() {
+  func testNumberIdentifierErrors4a() {
     AssertParse(
       """
       typealias 1️⃣10 = Int
-      typealias 2️⃣11.0 = Int
-      typealias 3️⃣12typealias = Int
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: typealias name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected name in typealias declaration"),
-        DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code '10' in typealias declaration"),
-        // TODO: Old parser expected error on line 2: typealias name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in typealias declaration"),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '11.0' in typealias declaration"),
-        // TODO: Old parser expected error on line 3: typealias name can only start with a letter or underscore, not a number
-        // TODO: Old parser expected error on line 3: 't' is not a valid digit in integer literal
-        DiagnosticSpec(locationMarker: "3️⃣", message: "identifier can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
+      ]
+    )
+  }
+
+  func testNumberIdentifierErrors4b() {
+    AssertParse(
+      """
+      typealias 1️⃣11.0 = Int
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
+      ]
+    )
+  }
+
+  func testNumberIdentifierErrors4c() {
+    AssertParse(
+      """
+      typealias 1️⃣12typealias = Int
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -112,8 +129,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       struct 1️⃣13 {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: struct name can only start with a letter or underscore, not a number
-        DiagnosticSpec(message: "expected name and member block in struct"),
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -124,8 +140,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       struct 1️⃣14.0 {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: struct name can only start with a letter or underscore, not a number
-        DiagnosticSpec(message: "expected name and member block in struct"),
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -136,9 +151,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       struct 1️⃣15struct {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: struct name can only start with a letter or underscore, not a number
-        // TODO: Old parser expected error on line 1: 's' is not a valid digit in integer literal
-        DiagnosticSpec(message: "identifier can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -149,8 +162,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       enum 1️⃣16 {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: enum name can only start with a letter or underscore, not a number
-        DiagnosticSpec(message: "expected name and member block in enum"),
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -161,8 +173,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       enum 1️⃣17.0 {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: enum name can only start with a letter or underscore, not a number
-        DiagnosticSpec(message: "expected name and member block in enum"),
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -173,9 +184,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       enum 1️⃣18enum {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: enum name can only start with a letter or underscore, not a number
-        // TODO: Old parser expected error on line 1: 'n' is not a valid digit in floating point exponent
-        DiagnosticSpec(message: "identifier can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -188,11 +197,8 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       }
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: class name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected name and member block in class"),
-        // TODO: Old parser expected error on line 2: function name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in function"),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '20' before parameter clause"),
+        DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -205,11 +211,8 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       }
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: class name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected name and member block in class"),
-        // TODO: Old parser expected error on line 2: function name can only start with a letter or underscore, not a number
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in function"),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '22.0' before parameter clause"),
+        DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }
@@ -223,12 +226,8 @@ final class NumberIdentifierErrorsTests: XCTestCase {
       }
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: class name can only start with a letter or underscore, not a number
-        // TODO: Old parser expected error on line 1: 'c' is not a valid digit in integer literal
-        DiagnosticSpec(locationMarker: "1️⃣", message: "identifier can only start with a letter or underscore, not a number"),
-        // TODO: Old parser expected error on line 2: function name can only start with a letter or underscore, not a number
-        // TODO: Old parser expected error on line 2: 'm' is not a valid digit in integer literal
-        DiagnosticSpec(locationMarker: "2️⃣", message: "identifier can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),
       ]
     )
   }

Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,12 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {`
`194`	`194`	`fixIts = []`
`195`	`195`	`}`
`196`	`196`
`197`		`- addDiagnostic(invalidIdentifier, InvalidIdentifierError(invalidIdentifier: invalidIdentifier), fixIts: fixIts, handledNodes: [previousParent.id])`
	`197`	`+ addDiagnostic(`
	`198`	`+ invalidIdentifier,`
	`199`	`+ InvalidIdentifierError(invalidIdentifier: invalidIdentifier, missingIdentifier: node),`
	`200`	`+ fixIts: fixIts,`
	`201`	`+ handledNodes: [previousParent.id]`
	`202`	`+ )`
`198`	`203`	`} else {`
`199`	`204`	`return handleMissingSyntax(node)`
`200`	`205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -387,7 +387,12 @@ extension Parser {`
`387`	`387`	`self.missingToken(.identifier, text: nil)`
`388`	`388`	`)`
`389`	`389`	`}`
`390`		`- if keywordRecovery, self.currentToken.tokenKind.isKeyword, !self.currentToken.isAtStartOfLine {`
	`390`	`+ if let number = self.consume(ifAny: [.integerLiteral, .floatingLiteral]) {`
	`391`	`+ return (`
	`392`	`+ RawUnexpectedNodesSyntax(elements: [RawSyntax(number)], arena: self.arena),`
	`393`	`+ self.missingToken(.identifier, text: nil)`
	`394`	`+ )`
	`395`	`+ } else if keywordRecovery, self.currentToken.tokenKind.isKeyword, !self.currentToken.isAtStartOfLine {`
`391`	`396`	`let keyword = self.consumeAnyToken()`
`392`	`397`	`return (`
`393`	`398`	`RawUnexpectedNodesSyntax(elements: [RawSyntax(keyword)], arena: self.arena),`
Original file line number	Diff line number	Diff line change
`@@ -690,8 +690,8 @@ final class DeclarationTests: XCTestCase {`
`690`	`690`	`}`
`691`	`691`	`""",`
`692`	`692`	`diagnostics: [`
`693`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "identifier can only start with a letter or underscore, not a number"),`
`694`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "identifier can only start with a letter or underscore, not a number"),`
	`693`	`+ DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),`
	`694`	`+ DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),`
`695`	`695`	`]`
`696`	`696`	`)`
`697`	`697`	`}`
`@@ -1023,7 +1023,7 @@ final class DeclarationTests: XCTestCase {`
`1023`	`1023`	`AssertParse(`
`1024`	`1024`	`"associatedtype 1️⃣5s",`
`1025`	`1025`	`diagnostics: [`
`1026`		`- DiagnosticSpec(message: "identifier can only start with a letter or underscore, not a number"),`
	`1026`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
`1027`	`1027`	`]`
`1028`	`1028`	`)`
`1029`	`1029`	`}`
Original file line number	Diff line number	Diff line change
`@@ -259,13 +259,13 @@ final class EnumTests: XCTestCase {`
`259`	`259`	`AssertParse(`
`260`	`260`	`"""`
`261`	`261`	`enum SwitchEnvy {`
`262`		`- case 1️⃣0:`
	`262`	`+ case 1️⃣02️⃣:`
`263`	`263`	`}`
`264`	`264`	`""",`
`265`	`265`	`diagnostics: [`
`266`	`266`	`// TODO: Old parser expected error on line 2: 'case' label can only appear inside a 'switch' statement`
`267`		`- DiagnosticSpec(message: "expected name in enum case"),`
`268`		`- DiagnosticSpec(message: "unexpected code '0:' in enum"),`
	`267`	`+ DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),`
	`268`	`+ DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code ':' in enum"),`
`269`	`269`	`]`
`270`	`270`	`)`
`271`	`271`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,27 +13,40 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`13`	`13`	`)`
`14`	`14`	`}`
`15`	`15`
`16`		`- func testNumberIdentifierErrors2() {`
	`16`	`+ func testNumberIdentifierErrors2a() {`
`17`	`17`	`AssertParse(`
`18`	`18`	`"""`
`19`	`19`	`func 1️⃣1() {}`
`20`		`- func 2️⃣2.0() {}`
`21`		`- func 3️⃣3func() {}`
`22`	`20`	`""",`
`23`	`21`	`diagnostics: [`
`24`		`- // TODO: Old parser expected error on line 1: function name can only start with a letter or underscore, not a number`
`25`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "expected name in function"),`
`26`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code '1' before parameter clause"),`
`27`		`- // TODO: Old parser expected error on line 2: function name can only start with a letter or underscore, not a number`
`28`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in function"),`
`29`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '2.0' before parameter clause"),`
`30`		`- // TODO: Old parser expected error on line 3: function name can only start with a letter or underscore, not a number`
`31`		`- // TODO: Old parser expected error on line 3: 'f' is not a valid digit in integer literal`
`32`		`- DiagnosticSpec(locationMarker: "3️⃣", message: "identifier can only start with a letter or underscore, not a number"),`
	`22`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
`33`	`23`	`]`
`34`	`24`	`)`
`35`	`25`	`}`
`36`	`26`
	`27`	`+ func testNumberIdentifierErrors2b() {`
	`28`	`+ AssertParse(`
	`29`	`+ """`
	`30`	`+ func 1️⃣2.0() {}`
	`31`	`+ """,`
	`32`	`+ diagnostics: [`
	`33`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
	`34`	`+ ]`
	`35`	`+ )`
	`36`	`+ }`
	`37`	`+`
	`38`	`+ func testNumberIdentifierErrors2c() {`
	`39`	`+ AssertParse(`
	`40`	`+ """`
	`41`	`+ func 1️⃣3func() {}`
	`42`	`+ """,`
	`43`	`+ diagnostics: [`
	`44`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
	`45`	`+ ]`
	`46`	`+ )`
	`47`	`+ }`
	`48`	`+`
	`49`	`+`
`37`	`50`	`func testNumberIdentifierErrors3a() {`
`38`	`51`	`AssertParse(`
`39`	`52`	`"""`
`@@ -42,10 +55,8 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`42`	`55`	`}`
`43`	`56`	`""",`
`44`	`57`	`diagnostics: [`
`45`		`- // TODO: Old parser expected error on line 1: protocol name can only start with a letter or underscore, not a number`
`46`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "expected name and member block in protocol"),`
`47`		`- // TODO: Old parser expected error on line 2: associatedtype name can only start with a letter or underscore, not a number`
`48`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in associatedtype declaration"),`
	`58`	`+ DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),`
	`59`	`+ DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),`
`49`	`60`	`]`
`50`	`61`	`)`
`51`	`62`	`}`
`@@ -58,10 +69,8 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`58`	`69`	`}`
`59`	`70`	`""",`
`60`	`71`	`diagnostics: [`
`61`		`- // TODO: Old parser expected error on line 1: protocol name can only start with a letter or underscore, not a number`
`62`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "expected name and member block in protocol"),`
`63`		`- // TODO: Old parser expected error on line 2: associatedtype name can only start with a letter or underscore, not a number`
`64`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in associatedtype declaration"),`
	`72`	`+ DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),`
	`73`	`+ DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),`
`65`	`74`	`]`
`66`	`75`	`)`
`67`	`76`	`}`
`@@ -74,34 +83,42 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`74`	`83`	`}`
`75`	`84`	`""",`
`76`	`85`	`diagnostics: [`
`77`		`- // TODO: Old parser expected error on line 1: protocol name can only start with a letter or underscore, not a number`
`78`		`- // TODO: Old parser expected error on line 1: 'p' is not a valid digit in integer literal`
`79`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "identifier can only start with a letter or underscore, not a number"),`
`80`		`- // TODO: Old parser expected error on line 2: associatedtype name can only start with a letter or underscore, not a number`
`81`		`- // TODO: Old parser expected error on line 2: 'a' is not a valid digit in integer literal`
`82`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "identifier can only start with a letter or underscore, not a number"),`
	`86`	`+ DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),`
	`87`	`+ DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),`
`83`	`88`	`]`
`84`	`89`	`)`
`85`	`90`	`}`
`86`	`91`
`87`	`92`
`88`		`- func testNumberIdentifierErrors4() {`
	`93`	`+ func testNumberIdentifierErrors4a() {`
`89`	`94`	`AssertParse(`
`90`	`95`	`"""`
`91`	`96`	`typealias 1️⃣10 = Int`
`92`		`- typealias 2️⃣11.0 = Int`
`93`		`- typealias 3️⃣12typealias = Int`
`94`	`97`	`""",`
`95`	`98`	`diagnostics: [`
`96`		`- // TODO: Old parser expected error on line 1: typealias name can only start with a letter or underscore, not a number`
`97`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "expected name in typealias declaration"),`
`98`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code '10' in typealias declaration"),`
`99`		`- // TODO: Old parser expected error on line 2: typealias name can only start with a letter or underscore, not a number`
`100`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in typealias declaration"),`
`101`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '11.0' in typealias declaration"),`
`102`		`- // TODO: Old parser expected error on line 3: typealias name can only start with a letter or underscore, not a number`
`103`		`- // TODO: Old parser expected error on line 3: 't' is not a valid digit in integer literal`
`104`		`- DiagnosticSpec(locationMarker: "3️⃣", message: "identifier can only start with a letter or underscore, not a number"),`
	`99`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
	`100`	`+ ]`
	`101`	`+ )`
	`102`	`+ }`
	`103`	`+`
	`104`	`+ func testNumberIdentifierErrors4b() {`
	`105`	`+ AssertParse(`
	`106`	`+ """`
	`107`	`+ typealias 1️⃣11.0 = Int`
	`108`	`+ """,`
	`109`	`+ diagnostics: [`
	`110`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
	`111`	`+ ]`
	`112`	`+ )`
	`113`	`+ }`
	`114`	`+`
	`115`	`+ func testNumberIdentifierErrors4c() {`
	`116`	`+ AssertParse(`
	`117`	`+ """`
	`118`	`+ typealias 1️⃣12typealias = Int`
	`119`	`+ """,`
	`120`	`+ diagnostics: [`
	`121`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
`105`	`122`	`]`
`106`	`123`	`)`
`107`	`124`	`}`
`@@ -112,8 +129,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`112`	`129`	`struct 1️⃣13 {}`
`113`	`130`	`""",`
`114`	`131`	`diagnostics: [`
`115`		`- // TODO: Old parser expected error on line 1: struct name can only start with a letter or underscore, not a number`
`116`		`- DiagnosticSpec(message: "expected name and member block in struct"),`
	`132`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
`117`	`133`	`]`
`118`	`134`	`)`
`119`	`135`	`}`
`@@ -124,8 +140,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`124`	`140`	`struct 1️⃣14.0 {}`
`125`	`141`	`""",`
`126`	`142`	`diagnostics: [`
`127`		`- // TODO: Old parser expected error on line 1: struct name can only start with a letter or underscore, not a number`
`128`		`- DiagnosticSpec(message: "expected name and member block in struct"),`
	`143`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
`129`	`144`	`]`
`130`	`145`	`)`
`131`	`146`	`}`
`@@ -136,9 +151,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`136`	`151`	`struct 1️⃣15struct {}`
`137`	`152`	`""",`
`138`	`153`	`diagnostics: [`
`139`		`- // TODO: Old parser expected error on line 1: struct name can only start with a letter or underscore, not a number`
`140`		`- // TODO: Old parser expected error on line 1: 's' is not a valid digit in integer literal`
`141`		`- DiagnosticSpec(message: "identifier can only start with a letter or underscore, not a number"),`
	`154`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
`142`	`155`	`]`
`143`	`156`	`)`
`144`	`157`	`}`
`@@ -149,8 +162,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`149`	`162`	`enum 1️⃣16 {}`
`150`	`163`	`""",`
`151`	`164`	`diagnostics: [`
`152`		`- // TODO: Old parser expected error on line 1: enum name can only start with a letter or underscore, not a number`
`153`		`- DiagnosticSpec(message: "expected name and member block in enum"),`
	`165`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
`154`	`166`	`]`
`155`	`167`	`)`
`156`	`168`	`}`
`@@ -161,8 +173,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`161`	`173`	`enum 1️⃣17.0 {}`
`162`	`174`	`""",`
`163`	`175`	`diagnostics: [`
`164`		`- // TODO: Old parser expected error on line 1: enum name can only start with a letter or underscore, not a number`
`165`		`- DiagnosticSpec(message: "expected name and member block in enum"),`
	`176`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
`166`	`177`	`]`
`167`	`178`	`)`
`168`	`179`	`}`
`@@ -173,9 +184,7 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`173`	`184`	`enum 1️⃣18enum {}`
`174`	`185`	`""",`
`175`	`186`	`diagnostics: [`
`176`		`- // TODO: Old parser expected error on line 1: enum name can only start with a letter or underscore, not a number`
`177`		`- // TODO: Old parser expected error on line 1: 'n' is not a valid digit in floating point exponent`
`178`		`- DiagnosticSpec(message: "identifier can only start with a letter or underscore, not a number"),`
	`187`	`+ DiagnosticSpec(message: "name can only start with a letter or underscore, not a number"),`
`179`	`188`	`]`
`180`	`189`	`)`
`181`	`190`	`}`
`@@ -188,11 +197,8 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`188`	`197`	`}`
`189`	`198`	`""",`
`190`	`199`	`diagnostics: [`
`191`		`- // TODO: Old parser expected error on line 1: class name can only start with a letter or underscore, not a number`
`192`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "expected name and member block in class"),`
`193`		`- // TODO: Old parser expected error on line 2: function name can only start with a letter or underscore, not a number`
`194`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in function"),`
`195`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '20' before parameter clause"),`
	`200`	`+ DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),`
	`201`	`+ DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),`
`196`	`202`	`]`
`197`	`203`	`)`
`198`	`204`	`}`
`@@ -205,11 +211,8 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`205`	`211`	`}`
`206`	`212`	`""",`
`207`	`213`	`diagnostics: [`
`208`		`- // TODO: Old parser expected error on line 1: class name can only start with a letter or underscore, not a number`
`209`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "expected name and member block in class"),`
`210`		`- // TODO: Old parser expected error on line 2: function name can only start with a letter or underscore, not a number`
`211`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "expected name in function"),`
`212`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '22.0' before parameter clause"),`
	`214`	`+ DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),`
	`215`	`+ DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),`
`213`	`216`	`]`
`214`	`217`	`)`
`215`	`218`	`}`
`@@ -223,12 +226,8 @@ final class NumberIdentifierErrorsTests: XCTestCase {`
`223`	`226`	`}`
`224`	`227`	`""",`
`225`	`228`	`diagnostics: [`
`226`		`- // TODO: Old parser expected error on line 1: class name can only start with a letter or underscore, not a number`
`227`		`- // TODO: Old parser expected error on line 1: 'c' is not a valid digit in integer literal`
`228`		`- DiagnosticSpec(locationMarker: "1️⃣", message: "identifier can only start with a letter or underscore, not a number"),`
`229`		`- // TODO: Old parser expected error on line 2: function name can only start with a letter or underscore, not a number`
`230`		`- // TODO: Old parser expected error on line 2: 'm' is not a valid digit in integer literal`
`231`		`- DiagnosticSpec(locationMarker: "2️⃣", message: "identifier can only start with a letter or underscore, not a number"),`
	`229`	`+ DiagnosticSpec(locationMarker: "1️⃣", message: "name can only start with a letter or underscore, not a number"),`
	`230`	`+ DiagnosticSpec(locationMarker: "2️⃣", message: "name can only start with a letter or underscore, not a number"),`
`232`	`231`	`]`
`233`	`232`	`)`
`234`	`233`	`}`