Add diagnostic if self. is missing in front of init call

Author: ahoppen

Sources/SwiftParser/Declarations.swift

@@ -31,6 +31,7 @@ extension DeclarationModifier {
 extension TokenConsumer {
   func atStartOfDeclaration(
     isAtTopLevel: Bool = false,
+    allowInitDecl: Bool = true,
     allowRecovery: Bool = false
   ) -> Bool {
     if self.at(anyIn: PoundDeclarationStart.self) != nil {
@@ -93,17 +94,19 @@ extension TokenConsumer {
       var lookahead = subparser.lookahead()
       repeat {
         lookahead.consumeAnyToken()
-      } while lookahead.atStartOfDeclaration()
+      } while lookahead.atStartOfDeclaration(allowInitDecl: allowInitDecl)
       return lookahead.at(.identifier)
     case .caseKeyword:
       // When 'case' appears inside a function, it's probably a switch
       // case, not an enum case declaration.
       return false
+    case .initKeyword:
+      return allowInitDecl
     case nil:
       if subparser.at(anyIn: ContextualDeclKeyword.self)?.0 != nil {
         subparser.consumeAnyToken()
         return subparser.atStartOfDeclaration(
-          isAtTopLevel: isAtTopLevel, allowRecovery: allowRecovery)
+          isAtTopLevel: isAtTopLevel, allowInitDecl: allowInitDecl, allowRecovery: allowRecovery)
       }
       return false
     default: return true
@@ -1283,7 +1286,7 @@ extension Parser {
       whereClause = nil
     }
 
-    let items = self.parseOptionalCodeBlock()
+    let items = self.parseOptionalCodeBlock(allowInitDecl: false)
 
     return RawInitializerDeclSyntax(
       attributes: attrs.attributes,

Sources/SwiftParser/Diagnostics/MissingNodesError.swift

@@ -216,12 +216,15 @@ public struct MissingNodesError: ParserError {
   /// If applicable, returns a string that describes the node in which the missing nodes are expected.
   private func parentContextClause(anchor: Syntax?) -> String? {
     // anchorParent is the first parent that has a type name for diagnostics.
-    guard let anchorParent = anchor?.ancestorOrSelf(where: {
-      $0.nodeTypeNameForDiagnostics(allowBlockNames: false) != nil
+    guard let (anchorParent, anchorTypeName) = anchor?.ancestorOrSelf(mapping: { (node: Syntax) -> (Syntax, String)? in
+      if let name = node.nodeTypeNameForDiagnostics(allowBlockNames: false) {
+        return (node, name)
+      } else {
+        return nil
+      }
     }) else {
       return nil
     }
-    let anchorTypeName = anchorParent.nodeTypeNameForDiagnostics(allowBlockNames: false)!
     if anchorParent.is(SourceFileSyntax.self) {
       return nil
     }

Sources/SwiftParser/Diagnostics/ParseDiagnosticsGenerator.swift

@@ -529,6 +529,41 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: MemberAccessExprSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+    if let base = node.base?.as(IdentifierExprSyntax.self)?.identifier,
+       base.presence == .missing,
+       base.tokenKind == .selfKeyword,
+       node.dot.presence == .missing,
+       node.name.tokenKind == .identifier("init") {
+      var replacement = PresentMaker().visit(base).as(TokenSyntax.self)!
+      replacement.leadingTrivia = node.name.leadingTrivia
+
+      var addSuper = false
+      if let initDecl = node.ancestorOrSelf(mapping: { $0.as(InitializerDeclSyntax.self )}),
+         initDecl.parent?.ancestorOrSelf(mapping: { $0.as(DeclSyntax.self) })?.is(ClassDeclSyntax.self) ?? false,
+         !(initDecl.modifiers?.contains(where: { $0.name.tokenKind == .contextualKeyword("convenience") }) ?? false) {
+        addSuper = true
+        replacement = TokenSyntax(
+          .superKeyword,
+          leadingTrivia: replacement.leadingTrivia,
+          trailingTrivia: replacement.trailingTrivia,
+          presence: .present
+        )
+      }
+
+      addDiagnostic(node.name, addSuper ? .missingSuperInInitializerInvocation : .missingSelfInInitializerInvocation, fixIts: [
+        FixIt(message: InsertTokenFixIt(missingNodes: [Syntax(replacement), Syntax(node.dot)]), changes: [
+          [.replace(oldNode: Syntax(base), newNode: Syntax(replacement)), .replaceLeadingTrivia(token: node.name, newTrivia: [])],
+          .makePresent(node.dot),
+        ])
+      ], handledNodes: [base.id, node.dot.id])
+    }
+    return .visitChildren
+  }
+
   public override func visit(_ node: PrecedenceGroupAssignmentSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParser/Diagnostics/ParserDiagnosticMessages.swift

@@ -134,6 +134,12 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var missingColonInTernaryExpr: Self {
     .init("expected ':' after '? ...' in ternary expression")
   }
+  public static var missingSelfInInitializerInvocation: Self {
+    .init("missing 'self.' at initializer invocation")
+  }
+  public static var missingSuperInInitializerInvocation: Self {
+    .init("missing 'super.' at initializer invocation")
+  }
   public static var operatorShouldBeDeclaredWithoutBody: Self {
     .init("operator should not be declared with body")
   }
@@ -221,10 +227,10 @@ public struct SpaceSeparatedIdentifiersError: ParserError {
   public let additionalTokens: [TokenSyntax]
 
   public var message: String {
-    if let anchorParent = firstToken.parent?.ancestorOrSelf(where: {
-      $0.nodeTypeNameForDiagnostics(allowBlockNames: false) != nil
+    if let name = firstToken.parent?.ancestorOrSelf(mapping: {
+      $0.nodeTypeNameForDiagnostics(allowBlockNames: false)
     }) {
-      return "found an unexpected second identifier in \(anchorParent.nodeTypeNameForDiagnostics(allowBlockNames: false)!)"
+      return "found an unexpected second identifier in \(name)"
     } else {
       return "found an unexpected second identifier"
     }
@@ -263,7 +269,7 @@ public struct UnexpectedNodesError: ParserError {
     if let parent = unexpectedNodes.parent {
       if let parentTypeName = parent.nodeTypeNameForDiagnostics(allowBlockNames: false), parent.children(viewMode: .sourceAccurate).first?.id == unexpectedNodes.id {
         message += " before \(parentTypeName)"
-      } else if let parentTypeName = parent.ancestorOrSelf(where: { $0.nodeTypeNameForDiagnostics(allowBlockNames: false) != nil })?.nodeTypeNameForDiagnostics(allowBlockNames: false) {
+      } else if let parentTypeName = parent.ancestorOrSelf(mapping: { $0.nodeTypeNameForDiagnostics(allowBlockNames: false) }) {
         message += " in \(parentTypeName)"
       }
     }

Sources/SwiftParser/Diagnostics/SyntaxExtensions.swift

@@ -92,10 +92,15 @@ extension SyntaxProtocol {
 
   /// Returns this node or the first ancestor that satisfies `condition`.
   func ancestorOrSelf(where condition: (Syntax) -> Bool) -> Syntax? {
+    return ancestorOrSelf(mapping: { condition($0) ? $0 : nil })
+  }
+
+  /// Returns this node or the first ancestor that satisfies `condition`.
+  func ancestorOrSelf<T>(mapping map: (Syntax) -> T?) -> T? {
     var walk: Syntax? = Syntax(self)
     while let unwrappedParent = walk {
-      if condition(unwrappedParent) {
-        return walk
+      if let mapped = map(unwrappedParent) {
+        return mapped
       }
       walk = unwrappedParent.parent
     }

Sources/SwiftParser/Expressions.swift

@@ -13,7 +13,7 @@
 @_spi(RawSyntax) import SwiftSyntax
 
 extension TokenConsumer {
-  func atStartOfExpression() -> Bool {
+  func atStartOfExpression(allowRecovery: Bool = false) -> Bool {
     switch self.at(anyIn: ExpressionStart.self) {
     case (.awaitTryMove, let handle)?:
       var backtrack = self.lookahead()
@@ -38,6 +38,10 @@ extension TokenConsumer {
         return true
       }
     }
+    if allowRecovery && self.at(.initKeyword) {
+      // The developer forgot to write `self.` or `super.` in front of an `init` call.
+      return true
+    }
     return false
   }
 }
@@ -513,12 +517,13 @@ extension Parser {
 
   @_spi(RawSyntax)
   public mutating func parseDottedExpressionSuffix() -> (
-      period: RawTokenSyntax, name: RawTokenSyntax,
-      declNameArgs: RawDeclNameArgumentsSyntax?,
-      generics: RawGenericArgumentClauseSyntax?
+    unexpectedBeforePeriod: RawUnexpectedNodesSyntax?,
+    period: RawTokenSyntax,
+    name: RawTokenSyntax,
+    declNameArgs: RawDeclNameArgumentsSyntax?,
+    generics: RawGenericArgumentClauseSyntax?
   ) {
-    assert(self.at(any: [.period, .prefixPeriod]))
-    let period = self.consumeAnyToken(remapping: .period)
+    let (unexpectedBeforePeriod, period) = self.expectAny([.period, .prefixPeriod], default: .period)
 
     // Parse the name portion.
     let name: RawTokenSyntax
@@ -545,15 +550,15 @@ extension Parser {
       generics = nil
     }
 
-    return (period, name, declNameArgs, generics)
+    return (unexpectedBeforePeriod, period, name, declNameArgs, generics)
   }
 
   @_spi(RawSyntax)
   public mutating func parseDottedExpressionSuffix(_ start: RawExprSyntax?) -> RawExprSyntax {
-    let (period, name, declNameArgs, generics) = parseDottedExpressionSuffix()
+    let (unexpectedBeforePeriod, period, name, declNameArgs, generics) = parseDottedExpressionSuffix()
 
     let memberAccess = RawMemberAccessExprSyntax(
-      base: start, dot: period, name: name, declNameArguments: declNameArgs,
+      base: start, unexpectedBeforePeriod, dot: period, name: name, declNameArguments: declNameArgs,
       arena: self.arena)
 
     guard let generics = generics else {
@@ -933,8 +938,9 @@ extension Parser {
 
       // Check for a .name or .1 suffix.
       if self.at(any: [.period, .prefixPeriod]) {
-        let (period, name, declNameArgs, generics) = parseDottedExpressionSuffix()
+        let (unexpectedBeforePeriod, period, name, declNameArgs, generics) = parseDottedExpressionSuffix()
         components.append(RawKeyPathComponentSyntax(
+          unexpectedBeforePeriod,
           period: period,
           component: RawSyntax(RawKeyPathPropertyComponentSyntax(
             identifier: name, declNameArguments: declNameArgs,
@@ -1148,6 +1154,13 @@ extension Parser {
     case (.leftSquareBracket, _)?:
       return self.parseCollectionLiteral()
 
+    case (.initKeyword, _)?:
+      let synthesizedBase = RawExprSyntax(RawIdentifierExprSyntax(
+        identifier: missingToken(.selfKeyword, text: nil),
+        declNameArguments: nil,
+        arena: self.arena
+      ))
+      return parseDottedExpressionSuffix(synthesizedBase)
     case nil:
       return RawExprSyntax(RawMissingExprSyntax(arena: self.arena))
     }

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -731,6 +731,7 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
   case falseKeyword
   case floatingLiteral
   case identifier
+  case initKeyword // For recovery if the user forgot `self.`
   case integerLiteral
   case leftBrace
   case leftParen
@@ -771,6 +772,7 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
     case .falseKeyword: self = .falseKeyword
     case .floatingLiteral: self = .floatingLiteral
     case .identifier: self = .identifier
+    case .initKeyword: self = .initKeyword
     case .integerLiteral: self = .integerLiteral
     case .leftBrace: self = .leftBrace
     case .leftParen: self = .leftParen
@@ -814,6 +816,7 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
     case .falseKeyword: return .falseKeyword
     case .floatingLiteral: return .floatingLiteral
     case .identifier: return .identifier
+    case .initKeyword: return .initKeyword
     case .integerLiteral: return .integerLiteral
     case .leftBrace: return .leftBrace
     case .leftParen: return .leftParen

Sources/SwiftParser/TopLevel.swift

@@ -37,12 +37,12 @@ extension Parser {
 }
 
 extension Parser {
-  mutating func parseCodeBlockItemList(isAtTopLevel: Bool, stopCondition: (inout Parser) -> Bool) -> RawCodeBlockItemListSyntax {
+  mutating func parseCodeBlockItemList(isAtTopLevel: Bool, allowInitDecl: Bool = true, stopCondition: (inout Parser) -> Bool) -> RawCodeBlockItemListSyntax {
     var elements = [RawCodeBlockItemSyntax]()
     var loopProgress = LoopProgressCondition()
     while !stopCondition(&self), loopProgress.evaluate(currentToken) {
       let newItemAtStartOfLine = self.currentToken.isAtStartOfLine
-      guard let newElement = self.parseCodeBlockItem(isAtTopLevel: isAtTopLevel) else {
+      guard let newElement = self.parseCodeBlockItem(isAtTopLevel: isAtTopLevel, allowInitDecl: allowInitDecl) else {
         break
       }
       if let lastItem = elements.last, lastItem.semicolon == nil && !newItemAtStartOfLine {
@@ -68,11 +68,11 @@ extension Parser {
   ///
   /// This function is used when parsing places where function bodies are
   /// optional - like the function requirements in protocol declarations.
-  mutating func parseOptionalCodeBlock() -> RawCodeBlockSyntax? {
+  mutating func parseOptionalCodeBlock(allowInitDecl: Bool = true) -> RawCodeBlockSyntax? {
     guard self.at(.leftBrace) else {
       return nil
     }
-    return self.parseCodeBlock()
+    return self.parseCodeBlock(allowInitDecl: allowInitDecl)
   }
 
   /// Parse a code block.
@@ -85,9 +85,9 @@ extension Parser {
   /// `introducer` is the `while`, `if`, ... keyword that is the cause that the code block is being parsed.
   /// If the left brace is missing, its indentation will be used to judge whether a following `}` was
   /// indented to close this code block or a surrounding context. See `expectRightBrace`.
-  mutating func parseCodeBlock(introducer: RawTokenSyntax? = nil) -> RawCodeBlockSyntax {
+  mutating func parseCodeBlock(introducer: RawTokenSyntax? = nil, allowInitDecl: Bool = true) -> RawCodeBlockSyntax {
     let (unexpectedBeforeLBrace, lbrace) = self.expect(.leftBrace)
-    let itemList = parseCodeBlockItemList(isAtTopLevel: false, stopCondition: { $0.at(.rightBrace) })
+    let itemList = parseCodeBlockItemList(isAtTopLevel: false, allowInitDecl: allowInitDecl, stopCondition: { $0.at(.rightBrace) })
     let (unexpectedBeforeRBrace, rbrace) = self.expectRightBrace(leftBrace: lbrace, introducer: introducer)
 
     return .init(
@@ -118,7 +118,7 @@ extension Parser {
   ///     statement → compiler-control-statement
   ///     statements → statement statements?
   @_spi(RawSyntax)
-  public mutating func parseCodeBlockItem(isAtTopLevel: Bool = false) -> RawCodeBlockItemSyntax? {
+  public mutating func parseCodeBlockItem(isAtTopLevel: Bool = false, allowInitDecl: Bool = true) -> RawCodeBlockItemSyntax? {
     if self.at(any: [.caseKeyword, .defaultKeyword]) {
       // 'case' and 'default' are invalid in code block items.
       // Parse them and put them in their own CodeBlockItem but as an unexpected node.
@@ -134,7 +134,7 @@ extension Parser {
 
     // FIXME: It is unfortunate that the Swift book refers to these as
     // "statements" and not "items".
-    let item = self.parseItem(isAtTopLevel: isAtTopLevel)
+    let item = self.parseItem(isAtTopLevel: isAtTopLevel, allowInitDecl: allowInitDecl)
     let semi = self.consume(if: .semicolon)
     var trailingSemis: [RawTokenSyntax] = []
     while let trailingSemi = self.consume(if: .semicolon) {
@@ -158,7 +158,7 @@ extension Parser {
   /// closing braces while trying to recover to the next item.
   /// If we are not at the top level, such a closing brace should close the
   /// wrapping declaration instead of being consumed by lookeahead.
-  private mutating func parseItem(isAtTopLevel: Bool = false) -> RawSyntax {
+  private mutating func parseItem(isAtTopLevel: Bool = false, allowInitDecl: Bool = true) -> RawSyntax {
     if self.at(.poundIfKeyword) {
       let directive = self.parsePoundIfDirective {
         $0.parseCodeBlockItem()
@@ -176,16 +176,18 @@ extension Parser {
       return RawSyntax(self.parsePoundLineDirective())
     } else if self.at(.poundSourceLocationKeyword) {
       return RawSyntax(self.parsePoundSourceLocationDirective())
-    } else if self.atStartOfDeclaration() {
+    } else if self.atStartOfDeclaration(allowInitDecl: allowInitDecl) {
       return RawSyntax(self.parseDeclaration())
     } else if self.atStartOfStatement() {
       return RawSyntax(self.parseStatement())
     } else if self.atStartOfExpression() {
       return RawSyntax(self.parseExpression())
-    } else if self.atStartOfDeclaration(isAtTopLevel: isAtTopLevel, allowRecovery: true) {
+    } else if self.atStartOfDeclaration(isAtTopLevel: isAtTopLevel, allowInitDecl: allowInitDecl, allowRecovery: true) {
       return RawSyntax(self.parseDeclaration())
     } else if self.atStartOfStatement(allowRecovery: true) {
       return RawSyntax(self.parseStatement())
+    } else if self.atStartOfExpression(allowRecovery: true) {
+      return RawSyntax(self.parseExpression())
     } else {
       return RawSyntax(RawMissingExprSyntax(arena: self.arena))
     }