Produce meaningful diagnostic for "#elif" typo

Author: TiagoMaiaL

Sources/SwiftParser/Directives.swift

@@ -16,18 +16,21 @@ extension Parser {
   private enum IfConfigContinuationClauseStartKeyword: TokenSpecSet {
     case poundElseifKeyword
     case poundElseKeyword
+    case pound
 
     var spec: TokenSpec {
       switch self {
       case .poundElseifKeyword: return .poundElseifKeyword
       case .poundElseKeyword: return .poundElseKeyword
+      case .pound: return TokenSpec(.pound, recoveryPrecedence: .openingPoundIf)
       }
     }
 
     init?(lexeme: Lexer.Lexeme) {
       switch PrepareForKeywordMatch(lexeme) {
       case TokenSpec(.poundElseifKeyword): self = .poundElseifKeyword
       case TokenSpec(.poundElseKeyword): self = .poundElseKeyword
+      case TokenSpec(.pound): self = .pound
       default: return nil
       }
     }
@@ -106,29 +109,54 @@ extension Parser {
       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.
+        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)
+        }
+
+        if atElifTypo {
+          (unexpectedBeforePound, pound) = self.eat(poundIfHandle)
+          guard let identifier = self.consume(if: TokenSpec(.identifier, allowAtStartOfLine: false)) else {
+            preconditionFailure("The current token should be an identifier, guaranteed by the previous if statement")
+          }
+          unexpectedBeforePound = RawUnexpectedNodesSyntax(combining: unexpectedBeforePound, pound, identifier, arena: self.arena)
+          pound = self.missingToken(.poundElseifKeyword)
           condition = RawExprSyntax(self.parseSequenceExpression(.basic, forDirective: true))
-        case .poundElseKeyword:
-          if let ifToken = self.consume(if: .init(.if, allowAtStartOfLine: false)) {
-            unexpectedBeforePoundIf = RawUnexpectedNodesSyntax(combining: unexpectedBeforePoundIf, poundIf, ifToken, arena: self.arena)
-            poundIf = self.missingToken(.poundElseifKeyword)
+        } else {
+          (unexpectedBeforePound, pound) = self.eat(poundIfHandle)
+          firstIteration = false
+          switch pound.tokenKind {
+          case .poundIfKeyword, .poundElseifKeyword:
             condition = RawExprSyntax(self.parseSequenceExpression(.basic, forDirective: true))
-          } else {
-            condition = nil
+          case .poundElseKeyword:
+            if let ifToken = self.consume(if: .init(.if, allowAtStartOfLine: false)) {
+              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")
           }
-        default:
-          preconditionFailure("The loop condition should guarantee that we are at one of these tokens")
         }
 
         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 +170,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

@@ -678,10 +678,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, replacement: clause.poundKeyword),

Tests/SwiftParserTest/translated/IfconfigExprTests.swift

@@ -455,6 +455,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(
       """