Produce meaningful diagnostic for "#elif" typo

Author: TiagoMaiaL

Sources/SwiftParser/Directives.swift

@@ -13,21 +13,27 @@
 @_spi(RawSyntax) import SwiftSyntax
 
 extension Parser {
-  private enum IfConfigContinuationClauseStartKeyword: TokenSpecSet {
+  private enum PoundIfDirectiveKeywords: TokenSpecSet {
+    case poundIfKeyword
     case poundElseifKeyword
     case poundElseKeyword
+    case pound
 
     var spec: TokenSpec {
       switch self {
+      case .poundIfKeyword: return .poundIfKeyword
       case .poundElseifKeyword: return .poundElseifKeyword
       case .poundElseKeyword: return .poundElseKeyword
+      case .pound: return TokenSpec(.pound, recoveryPrecedence: .openingPoundIf)
       }
     }
 
     init?(lexeme: Lexer.Lexeme) {
       switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.poundIfKeyword): self = .poundIfKeyword
       case TokenSpec(.poundElseifKeyword): self = .poundElseifKeyword
       case TokenSpec(.poundElseKeyword): self = .poundElseKeyword
+      case TokenSpec(.pound): self = .pound
       default: return nil
       }
     }
@@ -103,32 +109,62 @@ extension Parser {
     do {
       var firstIteration = true
       var loopProgress = LoopProgressCondition()
-      while let poundIfHandle = firstIteration ? self.canRecoverTo(.poundIfKeyword) : self.canRecoverTo(anyIn: IfConfigContinuationClauseStartKeyword.self)?.handle,
-        loopProgress.evaluate(self.currentToken)
-      {
-        var (unexpectedBeforePoundIf, poundIf) = self.eat(poundIfHandle)
-        firstIteration = false
-        // Parse the condition.
+      LOOP: while let (match, handle) = self.canRecoverTo(anyIn: PoundIfDirectiveKeywords.self), loopProgress.evaluate(self.currentToken) {
+        var unexpectedBeforePound: RawUnexpectedNodesSyntax?
+        var pound: RawTokenSyntax
         let condition: RawExprSyntax?
-        switch poundIf.tokenKind {
-        case .poundIfKeyword, .poundElseifKeyword:
+        var atElifTypo: Bool {
+          guard self.at(TokenSpec(.pound)), self.currentToken.trailingTriviaText.isEmpty else {
+            return false
+          }
+          let identifierSpec = TokenSpec(.identifier, allowAtStartOfLine: false)
+          var lookahead = self.lookahead()
+          lookahead.consumeAnyToken()
+          guard lookahead.at(identifierSpec), lookahead.currentToken.tokenText == "elif", lookahead.currentToken.leadingTriviaText.isEmpty else {
+            return false
+          }
+          lookahead.consumeAnyToken()
+          return lookahead.at(identifierSpec)
+        }
+
+        switch match {
+        case .poundIfKeyword:
+          if !firstIteration {
+            break LOOP
+          }
+          firstIteration = false
+          (unexpectedBeforePound, pound) = self.eat(handle)
+          condition = RawExprSyntax(self.parseSequenceExpression(.basic, forDirective: true))
+        case .poundElseifKeyword:
+          (unexpectedBeforePound, pound) = self.eat(handle)
           condition = RawExprSyntax(self.parseSequenceExpression(.basic, forDirective: true))
         case .poundElseKeyword:
+          (unexpectedBeforePound, pound) = self.eat(handle)
           if let ifToken = self.consume(if: .init(.if, allowAtStartOfLine: false)) {
-            unexpectedBeforePoundIf = RawUnexpectedNodesSyntax(combining: unexpectedBeforePoundIf, poundIf, ifToken, arena: self.arena)
-            poundIf = self.missingToken(.poundElseifKeyword)
+            unexpectedBeforePound = RawUnexpectedNodesSyntax(combining: unexpectedBeforePound, pound, ifToken, arena: self.arena)
+            pound = self.missingToken(.poundElseifKeyword)
             condition = RawExprSyntax(self.parseSequenceExpression(.basic, forDirective: true))
           } else {
             condition = nil
           }
-        default:
-          preconditionFailure("The loop condition should guarantee that we are at one of these tokens")
+        case .pound:
+          if atElifTypo {
+            (unexpectedBeforePound, pound) = self.eat(handle)
+            guard let identifier = self.consume(if: TokenSpec(.identifier, allowAtStartOfLine: false)) else {
+              preconditionFailure("The current token should be an identifier, guaranteed by the `atElifTypo` check.")
+            }
+            unexpectedBeforePound = RawUnexpectedNodesSyntax(combining: unexpectedBeforePound, pound, identifier, arena: self.arena)
+            pound = self.missingToken(.poundElseifKeyword)
+            condition = RawExprSyntax(self.parseSequenceExpression(.basic, forDirective: true))
+          } else {
+            break LOOP
+          }
         }
 
         var elements = [Element]()
         do {
           var elementsProgress = LoopProgressCondition()
-          while !self.at(.eof) && !self.at(.poundElseKeyword, .poundElseifKeyword, .poundEndifKeyword) && elementsProgress.evaluate(currentToken) {
+          while !self.at(.eof) && !self.at(.poundElseKeyword, .poundElseifKeyword, .poundEndifKeyword) && !atElifTypo && elementsProgress.evaluate(currentToken) {
             let newItemAtStartOfLine = self.currentToken.isAtStartOfLine
             guard let element = parseElement(&self, elements.isEmpty), !element.isEmpty else {
               break
@@ -142,8 +178,8 @@ extension Parser {
 
         clauses.append(
           RawIfConfigClauseSyntax(
-            unexpectedBeforePoundIf,
-            poundKeyword: poundIf,
+            unexpectedBeforePound,
+            poundKeyword: pound,
             condition: condition,
             elements: syntax(&self, elements),
             arena: self.arena

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -839,10 +839,18 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
           unexpectedBeforePoundKeyword
           .suffix(2)
           .compactMap { $0.as(TokenSyntax.self) }
+        var diagnosticMessage: DiagnosticMessage?
+
         if unexpectedTokens.map(\.tokenKind) == [.poundElseKeyword, .keyword(.if)] {
+          diagnosticMessage = StaticParserError.unexpectedPoundElseSpaceIf
+        } else if unexpectedTokens.first?.tokenKind == .pound, unexpectedTokens.last?.text == "elif" {
+          diagnosticMessage = UnknownDirectiveError(unexpected: unexpectedBeforePoundKeyword)
+        }
+
+        if let diagnosticMessage = diagnosticMessage {
           addDiagnostic(
             unexpectedBeforePoundKeyword,
-            StaticParserError.unexpectedPoundElseSpaceIf,
+            diagnosticMessage,
             fixIts: [
               FixIt(
                 message: ReplaceTokensFixIt(replaceTokens: unexpectedTokens, replacements: [clause.poundKeyword]),

Tests/SwiftParserTest/translated/IfconfigExprTests.swift

@@ -465,6 +465,68 @@ final class IfconfigExprTests: XCTestCase {
     )
   }
 
+  func testIfConfigExpr32() {
+    assertParse(
+      """
+      #if arch(x86_64)
+        debugPrint("x86_64")
+      1️⃣#elif arch(arm64)
+        debugPrint("arm64")
+      #else
+        debugPrint("Some other architecture.")
+      #endif
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          message: "use of unknown directive '#elif'",
+          fixIts: ["replace '#elif' with '#elseif'"]
+        )
+      ],
+      fixedSource: """
+        #if arch(x86_64)
+          debugPrint("x86_64")
+        #elseif arch(arm64)
+          debugPrint("arm64")
+        #else
+          debugPrint("Some other architecture.")
+        #endif
+        """
+    )
+  }
+
+  func testIfConfigExpr33() {
+    assertParse(
+      """
+      #if arch(x86_64)
+      #line
+      #endif
+      """
+    )
+  }
+
+  // FIXME: Parsing should generate diagnostics - https://github.com/apple/swift-syntax/issues/1395
+  func testIfConfigExpr34() {
+    assertParse(
+      """
+      #if MY_FLAG
+      #
+      elif
+      #endif
+      """
+    )
+  }
+
+  // FIXME: Parsing should generate diagnostics - https://github.com/apple/swift-syntax/issues/1395
+  func testIfConfigExpr35() {
+    assertParse(
+      """
+      #if MY_FLAG
+      # elif
+      #endif
+      """
+    )
+  }
+
   func testUnknownPlatform1() {
     assertParse(
       """