Validate that no child contains the substring 'Identifier'

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/GenericNodes.swift

@@ -18,15 +18,17 @@ public let GENERIC_NODES: [Node] = [
     nameForDiagnostics: "conformance requirement",
     children: [
       Child(
-        name: "LeftTypeIdentifier",
+        name: "LeftType",
+        deprecatedName: "LeftTypeIdentifier",
         kind: .node(kind: .type)
       ),
       Child(
         name: "Colon",
         kind: .token(choices: [.token(tokenKind: "ColonToken")])
       ),
       Child(
-        name: "RightTypeIdentifier",
+        name: "RightType",
+        deprecatedName: "RightTypeIdentifier",
         kind: .node(kind: .type)
       ),
     ]
@@ -193,7 +195,8 @@ public let GENERIC_NODES: [Node] = [
     nameForDiagnostics: "layout requirement",
     children: [
       Child(
-        name: "TypeIdentifier",
+        name: "Type",
+        deprecatedName: "TypeIdentifier",
         kind: .node(kind: .type),
         nameForDiagnostics: "constrained type"
       ),
@@ -303,7 +306,8 @@ public let GENERIC_NODES: [Node] = [
     nameForDiagnostics: "same type requirement",
     children: [
       Child(
-        name: "LeftTypeIdentifier",
+        name: "LeftType",
+        deprecatedName: "LeftTypeIdentifier",
         kind: .node(kind: .type),
         nameForDiagnostics: "left-hand type"
       ),
@@ -313,7 +317,8 @@ public let GENERIC_NODES: [Node] = [
         kind: .token(choices: [.token(tokenKind: "BinaryOperatorToken"), .token(tokenKind: "PrefixOperatorToken"), .token(tokenKind: "PostfixOperatorToken")])
       ),
       Child(
-        name: "RightTypeIdentifier",
+        name: "RightType",
+        deprecatedName: "RightTypeIdentifier",
         kind: .node(kind: .type),
         nameForDiagnostics: "right-hand type"
       ),

CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift

@@ -596,16 +596,16 @@ class ValidateSyntaxNodes: XCTestCase {
   }
 
   /// Identifier is a wonderful ambiguous term. Almost always, 'name' or something similar is more expressive
-  func testNoChildIsNamedIdentifier() {
+  func testNoChildContainsIdentifier() {
     var failures: [ValidationFailure] = []
 
     for node in SYNTAX_NODES.compactMap(\.layoutNode) {
-      for child in node.children {
-        if child.name == "Identifier" {
+      for child in node.nonUnexpectedChildren {
+        if child.name.contains("Identifier") {
           failures.append(
             ValidationFailure(
               node: node.kind,
-              message: "children should generally not be named 'Identifier'"
+              message: "child '\(child.name)' should generally not contain 'Identifier'"
             )
           )
         }
@@ -616,8 +616,8 @@ class ValidateSyntaxNodes: XCTestCase {
       failures,
       expectedFailures: [
         // The identifier expr / pattern nodes do actually have a child that’s the identifier
-        ValidationFailure(node: .identifierExpr, message: "children should generally not be named 'Identifier'"),
-        ValidationFailure(node: .identifierPattern, message: "children should generally not be named 'Identifier'"),
+        ValidationFailure(node: .identifierExpr, message: "child 'Identifier' should generally not contain 'Identifier'"),
+        ValidationFailure(node: .identifierPattern, message: "child 'Identifier' should generally not contain 'Identifier'"),
       ]
     )
   }

Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift

@@ -222,7 +222,7 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "value"
   case \LabeledStmtSyntax.label:
     return "label name"
-  case \LayoutRequirementSyntax.typeIdentifier:
+  case \LayoutRequirementSyntax.type:
     return "constrained type"
   case \LayoutRequirementSyntax.size:
     return "size"
@@ -302,9 +302,9 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "condition"
   case \ReturnClauseSyntax.returnType:
     return "return type"
-  case \SameTypeRequirementSyntax.leftTypeIdentifier:
+  case \SameTypeRequirementSyntax.leftType:
     return "left-hand type"
-  case \SameTypeRequirementSyntax.rightTypeIdentifier:
+  case \SameTypeRequirementSyntax.rightType:
     return "right-hand type"
   case \StructDeclSyntax.attributes:
     return "attributes"

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -749,20 +749,20 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "trailingComma"
   case \ConditionElementSyntax.unexpectedAfterTrailingComma:
     return "unexpectedAfterTrailingComma"
-  case \ConformanceRequirementSyntax.unexpectedBeforeLeftTypeIdentifier:
-    return "unexpectedBeforeLeftTypeIdentifier"
-  case \ConformanceRequirementSyntax.leftTypeIdentifier:
-    return "leftTypeIdentifier"
-  case \ConformanceRequirementSyntax.unexpectedBetweenLeftTypeIdentifierAndColon:
-    return "unexpectedBetweenLeftTypeIdentifierAndColon"
+  case \ConformanceRequirementSyntax.unexpectedBeforeLeftType:
+    return "unexpectedBeforeLeftType"
+  case \ConformanceRequirementSyntax.leftType:
+    return "leftType"
+  case \ConformanceRequirementSyntax.unexpectedBetweenLeftTypeAndColon:
+    return "unexpectedBetweenLeftTypeAndColon"
   case \ConformanceRequirementSyntax.colon:
     return "colon"
-  case \ConformanceRequirementSyntax.unexpectedBetweenColonAndRightTypeIdentifier:
-    return "unexpectedBetweenColonAndRightTypeIdentifier"
-  case \ConformanceRequirementSyntax.rightTypeIdentifier:
-    return "rightTypeIdentifier"
-  case \ConformanceRequirementSyntax.unexpectedAfterRightTypeIdentifier:
-    return "unexpectedAfterRightTypeIdentifier"
+  case \ConformanceRequirementSyntax.unexpectedBetweenColonAndRightType:
+    return "unexpectedBetweenColonAndRightType"
+  case \ConformanceRequirementSyntax.rightType:
+    return "rightType"
+  case \ConformanceRequirementSyntax.unexpectedAfterRightType:
+    return "unexpectedAfterRightType"
   case \ConstrainedSugarTypeSyntax.unexpectedBeforeSomeOrAnySpecifier:
     return "unexpectedBeforeSomeOrAnySpecifier"
   case \ConstrainedSugarTypeSyntax.someOrAnySpecifier:
@@ -2005,12 +2005,12 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "statement"
   case \LabeledStmtSyntax.unexpectedAfterStatement:
     return "unexpectedAfterStatement"
-  case \LayoutRequirementSyntax.unexpectedBeforeTypeIdentifier:
-    return "unexpectedBeforeTypeIdentifier"
-  case \LayoutRequirementSyntax.typeIdentifier:
-    return "typeIdentifier"
-  case \LayoutRequirementSyntax.unexpectedBetweenTypeIdentifierAndColon:
-    return "unexpectedBetweenTypeIdentifierAndColon"
+  case \LayoutRequirementSyntax.unexpectedBeforeType:
+    return "unexpectedBeforeType"
+  case \LayoutRequirementSyntax.type:
+    return "type"
+  case \LayoutRequirementSyntax.unexpectedBetweenTypeAndColon:
+    return "unexpectedBetweenTypeAndColon"
   case \LayoutRequirementSyntax.colon:
     return "colon"
   case \LayoutRequirementSyntax.unexpectedBetweenColonAndLayoutConstraint:
@@ -2813,20 +2813,20 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "expression"
   case \ReturnStmtSyntax.unexpectedAfterExpression:
     return "unexpectedAfterExpression"
-  case \SameTypeRequirementSyntax.unexpectedBeforeLeftTypeIdentifier:
-    return "unexpectedBeforeLeftTypeIdentifier"
-  case \SameTypeRequirementSyntax.leftTypeIdentifier:
-    return "leftTypeIdentifier"
-  case \SameTypeRequirementSyntax.unexpectedBetweenLeftTypeIdentifierAndEqual:
-    return "unexpectedBetweenLeftTypeIdentifierAndEqual"
+  case \SameTypeRequirementSyntax.unexpectedBeforeLeftType:
+    return "unexpectedBeforeLeftType"
+  case \SameTypeRequirementSyntax.leftType:
+    return "leftType"
+  case \SameTypeRequirementSyntax.unexpectedBetweenLeftTypeAndEqual:
+    return "unexpectedBetweenLeftTypeAndEqual"
   case \SameTypeRequirementSyntax.equal:
     return "equal"
-  case \SameTypeRequirementSyntax.unexpectedBetweenEqualAndRightTypeIdentifier:
-    return "unexpectedBetweenEqualAndRightTypeIdentifier"
-  case \SameTypeRequirementSyntax.rightTypeIdentifier:
-    return "rightTypeIdentifier"
-  case \SameTypeRequirementSyntax.unexpectedAfterRightTypeIdentifier:
-    return "unexpectedAfterRightTypeIdentifier"
+  case \SameTypeRequirementSyntax.unexpectedBetweenEqualAndRightType:
+    return "unexpectedBetweenEqualAndRightType"
+  case \SameTypeRequirementSyntax.rightType:
+    return "rightType"
+  case \SameTypeRequirementSyntax.unexpectedAfterRightType:
+    return "unexpectedAfterRightType"
   case \SequenceExprSyntax.unexpectedBeforeElements:
     return "unexpectedBeforeElements"
   case \SequenceExprSyntax.elements: