Add diagnostic for wrong inheritance

Author: kimdv

Sources/SwiftParser/Nominals.swift

@@ -240,7 +240,7 @@ extension Parser {
     }
 
     let inheritance: RawTypeInheritanceClauseSyntax?
-    if self.at(.colon) {
+    if self.at(.colon) || self.isAtPythonStyleInheritanceClause() {
       inheritance = self.parseInheritance()
     } else {
       inheritance = nil
@@ -273,7 +273,18 @@ extension Parser {
   /// Parse an inheritance clause.
   @_spi(RawSyntax)
   public mutating func parseInheritance() -> RawTypeInheritanceClauseSyntax {
-    let (unexpectedBeforeColon, colon) = self.expect(.colon)
+    let unexpectedBeforeColon: RawUnexpectedNodesSyntax?
+    let colon: RawTokenSyntax
+
+    // Parse python style inheritance clause and replace parentheses with a colon
+    if let leftParen = self.consume(if: .leftParen) {
+      unexpectedBeforeColon = RawUnexpectedNodesSyntax([leftParen], arena: self.arena)
+      colon = missingToken(.colon)
+    } else {
+        unexpectedBeforeColon = nil
+        colon = self.consume(if: .colon) ?? missingToken(.colon)
+    }
+
     var elements = [RawInheritedTypeSyntax]()
     do {
       var keepGoing: RawTokenSyntax? = nil
@@ -306,10 +317,22 @@ extension Parser {
         )
       } while keepGoing != nil && loopProgress.evaluate(currentToken)
     }
+
+    let unexpectedAfterInheritedTypeCollection: RawUnexpectedNodesSyntax?
+
+    // If it contains a left paren, then it might be a python style inheritance clause.
+    // Left paren have been replaced with colon
+    if unexpectedBeforeColon?.containsToken(where: { $0.tokenKind == .leftParen }) == true, let rightBrace = self.consume(if: .rightParen) {
+      unexpectedAfterInheritedTypeCollection = RawUnexpectedNodesSyntax(elements: [RawSyntax(rightBrace)], arena: self.arena)
+    } else {
+      unexpectedAfterInheritedTypeCollection = nil
+    }
+
     return RawTypeInheritanceClauseSyntax(
       unexpectedBeforeColon,
       colon: colon,
       inheritedTypeCollection: RawInheritedTypeListSyntax(elements: elements, arena: self.arena),
+      unexpectedAfterInheritedTypeCollection,
       arena: self.arena
     )
   }
@@ -352,3 +375,14 @@ extension Parser {
     )
   }
 }
+
+extension Parser {
+    private mutating func isAtPythonStyleInheritanceClause() -> Bool {
+        guard self.at(.leftParen) else { return false }
+        return self.withLookahead {
+            $0.consume(if: .leftParen)
+            guard $0.canParseType() else { return false }
+            return $0.at(.rightParen, .keyword(.where), .leftBrace) || $0.at(.eof)
+        }
+    }
+}

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -1269,6 +1269,53 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return handleEffectSpecifiers(node)
   }
 
+  public override func visit(_ node: TypeInheritanceClauseSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    if let unexpected = node.unexpectedBeforeColon,
+      let leftParen = unexpected.tokens(satisfying: { $0.tokenKind == .leftParen }).first
+      {
+        
+        var handledNodes: [SyntaxIdentifier] = [
+            leftParen.id, node.colon.id,
+        ]
+        
+        var changes: [FixIt.MultiNodeChange] = [
+            .makePresent(node.colon, trailingTrivia: .space),
+            .makeMissing(unexpected),
+        ]
+        
+        var replaceTokens = [leftParen]
+        
+        if let rightParen = node.unexpectedAfterInheritedTypeCollection?.tokens(satisfying: { $0.tokenKind == .rightParen }).first,
+           let lastToken = node.inheritedTypeCollection.lastToken(viewMode: .sourceAccurate)
+        {
+            handledNodes += [rightParen.id]
+            changes += [
+                .makeMissing(rightParen),
+                FixIt.MultiNodeChange(.replaceTrailingTrivia(token: lastToken, newTrivia: .space)),
+            ]
+            
+            replaceTokens += [rightParen]
+        }
+        
+        addDiagnostic(
+            unexpected,
+            .expectedColonClass,
+            fixIts: [
+                FixIt(
+                    message: ReplaceTokensFixIt(replaceTokens: replaceTokens, replacements: [.colonToken()]),
+                    changes: changes
+                )
+            ],
+            handledNodes: handledNodes
+        )
+    }
+    return .visitChildren
+  }
+
   public override func visit(_ node: TypeInitializerClauseSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -125,6 +125,9 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var escapedNewlineAtLatlineOfMultiLineStringLiteralNotAllowed: Self {
     .init("escaped newline at the last line of a multi-line string literal is not allowed")
   }
+  public static var expectedColonClass: Self {
+    .init("expected ':' to begin inheritance clause")
+  }
   public static var expectedExpressionAfterTry: Self {
     .init("expected expression after 'try'")
   }

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -118,12 +118,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \ActorDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ActorDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \ActorDeclSyntax.members:
-    return "members"
-  case \ActorDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \ActorDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ActorDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \ActorDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \ArrayElementSyntax.unexpectedBeforeExpression:
     return "unexpectedBeforeExpression"
   case \ArrayElementSyntax.expression:
@@ -468,12 +468,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \ClassDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ClassDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \ClassDeclSyntax.members:
-    return "members"
-  case \ClassDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \ClassDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ClassDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \ClassDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \ClassRestrictionTypeSyntax.unexpectedBeforeClassKeyword:
     return "unexpectedBeforeClassKeyword"
   case \ClassRestrictionTypeSyntax.classKeyword:
@@ -1168,12 +1168,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \EnumDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \EnumDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \EnumDeclSyntax.members:
-    return "members"
-  case \EnumDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \EnumDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \EnumDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \EnumDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \ExposeAttributeArgumentsSyntax.unexpectedBeforeLanguage:
     return "unexpectedBeforeLanguage"
   case \ExposeAttributeArgumentsSyntax.language:
@@ -1246,12 +1246,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \ExtensionDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ExtensionDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \ExtensionDeclSyntax.members:
-    return "members"
-  case \ExtensionDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \ExtensionDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ExtensionDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \ExtensionDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \FallthroughStmtSyntax.unexpectedBeforeFallthroughKeyword:
     return "unexpectedBeforeFallthroughKeyword"
   case \FallthroughStmtSyntax.fallthroughKeyword:
@@ -2586,12 +2586,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \ProtocolDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ProtocolDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \ProtocolDeclSyntax.members:
-    return "members"
-  case \ProtocolDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \ProtocolDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ProtocolDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \ProtocolDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \QualifiedDeclNameSyntax.unexpectedBeforeBaseType:
     return "unexpectedBeforeBaseType"
   case \QualifiedDeclNameSyntax.baseType:
@@ -2776,12 +2776,12 @@ internal func childName(_ keyPath: AnyKeyPath) -> String? {
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
   case \StructDeclSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \StructDeclSyntax.unexpectedBetweenGenericWhereClauseAndMembers:
-    return "unexpectedBetweenGenericWhereClauseAndMembers"
-  case \StructDeclSyntax.members:
-    return "members"
-  case \StructDeclSyntax.unexpectedAfterMembers:
-    return "unexpectedAfterMembers"
+  case \StructDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
+    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \StructDeclSyntax.memberBlock:
+    return "memberBlock"
+  case \StructDeclSyntax.unexpectedAfterMemberBlock:
+    return "unexpectedAfterMemberBlock"
   case \SubscriptDeclSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
   case \SubscriptDeclSyntax.attributes:

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -791,7 +791,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)]))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier), .keyword("set")]))
+    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)]))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)]))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))

Tests/SwiftParserTest/translated/RecoveryTests.swift

@@ -1570,9 +1570,12 @@ final class RecoveryTests: XCTestCase {
       class WrongInheritanceClause11️⃣(Int) {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: expected ':' to begin inheritance clause, Fix-It replacements: 30 - 31 = ': ', 34 - 35 = ''
-        DiagnosticSpec(message: "unexpected code '(Int)' in class")
-      ]
+        DiagnosticSpec(message: "expected ':' to begin inheritance clause",
+                       fixIts: ["replace '()' with ':'"])
+      ],
+      fixedSource: """
+        class WrongInheritanceClause1: Int {}
+        """
     )
   }
 
@@ -1582,9 +1585,12 @@ final class RecoveryTests: XCTestCase {
       class WrongInheritanceClause21️⃣(Base2<Int>) {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: expected ':' to begin inheritance clause, Fix-It replacements: 30 - 31 = ': ', 41 - 42 = ''
-        DiagnosticSpec(message: "unexpected code '(Base2<Int>)' in class")
-      ]
+        DiagnosticSpec(message: "expected ':' to begin inheritance clause",
+                       fixIts: ["replace '()' with ':'"])
+      ],
+      fixedSource: """
+        class WrongInheritanceClause2: Base2<Int> {}
+        """
     )
   }
 
@@ -1594,9 +1600,12 @@ final class RecoveryTests: XCTestCase {
       class WrongInheritanceClause3<T>1️⃣(SubModule.Base1) where T:AnyObject {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: expected ':' to begin inheritance clause, Fix-It replacements: 33 - 34 = ': ', 49 - 50 = ''
-        DiagnosticSpec(message: "unexpected code '(SubModule.Base1) where T:AnyObject' in class")
-      ]
+        DiagnosticSpec(message: "expected ':' to begin inheritance clause",
+                       fixIts: ["replace '()' with ':'"])
+      ],
+      fixedSource: """
+        class WrongInheritanceClause3<T>: SubModule.Base1 where T:AnyObject {}
+        """
     )
   }
 
@@ -1606,9 +1615,12 @@ final class RecoveryTests: XCTestCase {
       class WrongInheritanceClause41️⃣(SubModule.Base2<Int>) {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: expected ':' to begin inheritance clause, Fix-It replacements: 30 - 31 = ': ', 51 - 52 = ''
-        DiagnosticSpec(message: "unexpected code '(SubModule.Base2<Int>)' in class")
-      ]
+        DiagnosticSpec(message: "expected ':' to begin inheritance clause",
+                       fixIts: ["replace '()' with ':'"])
+      ],
+      fixedSource: """
+        class WrongInheritanceClause4: SubModule.Base2<Int> {}
+        """
     )
   }
 
@@ -1618,47 +1630,49 @@ final class RecoveryTests: XCTestCase {
       class WrongInheritanceClause5<T>1️⃣(SubModule.Base2<Int>) where T:AnyObject {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: expected ':' to begin inheritance clause, Fix-It replacements: 33 - 34 = ': ', 54 - 55 = ''
-        DiagnosticSpec(message: "unexpected code '(SubModule.Base2<Int>) where T:AnyObject' in class")
-      ]
+        DiagnosticSpec(message: "expected ':' to begin inheritance clause",
+                      fixIts: ["replace '()' with ':'"])
+      ],
+      fixedSource: """
+        class WrongInheritanceClause5<T>: SubModule.Base2<Int> where T:AnyObject {}
+        """
     )
   }
 
   func testRecovery130() {
     assertParse(
       """
-      class WrongInheritanceClause61️⃣(Int 2️⃣{}3️⃣
+      class WrongInheritanceClause61️⃣(Int {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: expected ':' to begin inheritance clause, Fix-It replacements: 30 - 31 = ': '
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected '{' in class", fixIts: ["insert '{'"]),
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected 'var' in variable", fixIts: ["insert 'var'"]),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected ')' to end tuple pattern", fixIts: ["insert ')'"]),
-        DiagnosticSpec(locationMarker: "3️⃣", message: "expected '}' to end class", fixIts: ["insert '}'"]),
-      ]
+        DiagnosticSpec(message: "expected ':' to begin inheritance clause",
+                       fixIts: ["replace '(' with ':'"])
+      ],
+      fixedSource: """
+        class WrongInheritanceClause6: Int {}
+        """
     )
   }
 
   func testRecovery131() {
     assertParse(
       """
-      class WrongInheritanceClause7<T>1️⃣(Int 2️⃣where T:AnyObject {}
+      class WrongInheritanceClause7<T>1️⃣(Int where T:AnyObject {}
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 1: expected ':' to begin inheritance clause, Fix-It replacements: 33 - 34 = ': '
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected '{' in class", fixIts: ["insert '{'"]),
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected 'var' in variable", fixIts: ["insert 'var'"]),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected ')' to end tuple pattern", fixIts: ["insert ')'"]),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected '}' to end class", fixIts: ["insert '}'"]),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "extraneous code 'where T:AnyObject {}' at top level"),
-      ]
+        DiagnosticSpec(message: "expected ':' to begin inheritance clause",
+                       fixIts: ["replace '(' with ':'"])
+      ],
+      fixedSource: """
+        class WrongInheritanceClause7<T>: Int where T:AnyObject {}
+        """
     )
   }
 
   func testRecovery132() {
+    // <rdar://problem/18502220> [swift-crashes 078] parser crash on invalid cast in sequence expr
     assertParse(
       """
-      // <rdar://problem/18502220> [swift-crashes 078] parser crash on invalid cast in sequence expr
       Base=1 as Base=1
       """
     )