Eliminate special lexing and parsing of #warning and #error

Author: DougGregor

Sources/SwiftParser/Declarations.swift

@@ -202,8 +202,6 @@ extension Parser {
         return .decls(RawMemberDeclListSyntax(elements: elements, arena: parser.arena))
       }
       return RawDeclSyntax(directive)
-    case (.poundWarningKeyword, _)?, (.poundErrorKeyword, _)?:
-      return self.parsePoundDiagnosticDeclaration()
     case (.pound, _)?:
       // FIXME: If we can have attributes for macro expansions, handle this
       // via DeclarationStart.
@@ -2062,76 +2060,6 @@ extension Parser {
 }
 
 extension Parser {
-  enum PoundDiagnosticKind {
-    case error(poundError: RawTokenSyntax)
-    case warning(poundWarning: RawTokenSyntax)
-  }
-
-  @_spi(RawSyntax)
-  public mutating func parsePoundDiagnosticDeclaration() -> RawDeclSyntax {
-    enum ExpectedTokenKind: RawTokenKindSubset {
-      case poundErrorKeyword
-      case poundWarningKeyword
-
-      init?(lexeme: Lexer.Lexeme) {
-        switch lexeme.rawTokenKind {
-        case .poundErrorKeyword: self = .poundErrorKeyword
-        case .poundWarningKeyword: self = .poundWarningKeyword
-        default: return nil
-        }
-      }
-
-      var rawTokenKind: RawTokenKind {
-        switch self {
-        case .poundErrorKeyword: return .poundErrorKeyword
-        case .poundWarningKeyword: return .poundWarningKeyword
-        }
-      }
-    }
-
-    let directive: PoundDiagnosticKind
-
-    switch self.at(anyIn: ExpectedTokenKind.self) {
-    case (.poundErrorKeyword, let handle)?:
-      directive = .error(poundError: self.eat(handle))
-    case (.poundWarningKeyword, let handle)?:
-      directive = .warning(poundWarning: self.eat(handle))
-    case nil:
-      directive = .error(poundError: RawTokenSyntax(missing: .poundErrorKeyword, arena: self.arena))
-    }
-
-    let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
-    let stringLiteral = self.parseStringLiteral()
-    let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
-
-    switch directive {
-    case .error(let tok):
-      return RawDeclSyntax(
-        RawPoundErrorDeclSyntax(
-          poundError: tok,
-          unexpectedBeforeLeftParen,
-          leftParen: leftParen,
-          message: stringLiteral,
-          unexpectedBeforeRightParen,
-          rightParen: rightParen,
-          arena: self.arena
-        )
-      )
-    case .warning(let tok):
-      return RawDeclSyntax(
-        RawPoundWarningDeclSyntax(
-          poundWarning: tok,
-          unexpectedBeforeLeftParen,
-          leftParen: leftParen,
-          message: stringLiteral,
-          unexpectedBeforeRightParen,
-          rightParen: rightParen,
-          arena: self.arena
-        )
-      )
-    }
-  }
-
   /// Parse a macro declaration.
   mutating func parseMacroDeclaration(
     attrs: DeclAttributes,

Sources/SwiftParser/Lexer/Cursor.swift

@@ -1459,8 +1459,6 @@ extension Lexer.Cursor {
     let kind: RawTokenKind
     switch literal {
     case "sourceLocation": kind = .poundSourceLocationKeyword
-    case "warning": kind = .poundWarningKeyword
-    case "error": kind = .poundErrorKeyword
     case "if": kind = .poundIfKeyword
     case "else": kind = .poundElseKeyword
     case "elseif": kind = .poundElseifKeyword

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -471,15 +471,11 @@ enum OperatorLike: RawTokenKindSubset {
 
 enum PoundDeclarationStart: RawTokenKindSubset {
   case poundIfKeyword
-  case poundWarningKeyword
-  case poundErrorKeyword
   case pound
 
   init?(lexeme: Lexer.Lexeme) {
     switch lexeme.rawTokenKind {
     case .poundIfKeyword: self = .poundIfKeyword
-    case .poundWarningKeyword: self = .poundWarningKeyword
-    case .poundErrorKeyword: self = .poundErrorKeyword
     case .pound: self = .pound
     default: return nil
     }
@@ -488,8 +484,6 @@ enum PoundDeclarationStart: RawTokenKindSubset {
   var rawTokenKind: RawTokenKind {
     switch self {
     case .poundIfKeyword: return .poundIfKeyword
-    case .poundWarningKeyword: return .poundWarningKeyword
-    case .poundErrorKeyword: return .poundErrorKeyword
     case .pound: return .pound
     }
   }

Sources/SwiftParser/Statements.swift

@@ -985,8 +985,8 @@ extension Parser {
     let expr: RawExprSyntax?
     if !self.at(any: [
       .rightBrace, .keyword(.case), .keyword(.default), .semicolon, .eof,
-      .poundIfKeyword, .poundErrorKeyword, .poundWarningKeyword,
-      .poundEndifKeyword, .poundElseKeyword, .poundElseifKeyword,
+      .poundIfKeyword, .poundEndifKeyword, .poundElseKeyword,
+      .poundElseifKeyword,
     ])
       && !self.atStartOfStatement() && !self.atStartOfDeclaration(preferPoundAsExpression: true)
     {

Tests/SwiftParserTest/translated/MultilinePoundDiagnosticArgRdar41154797Tests.swift

@@ -22,7 +22,7 @@ final class MultilinePoundDiagnosticArgRdar41154797Tests: XCTestCase {
       """##,
       diagnostics: [
         DiagnosticSpec(message: #"expected '"""' to end string literal"#),
-        DiagnosticSpec(message: "expected ')' to end '#error' directive"),
+        DiagnosticSpec(message: "expected ')' to end pound literal declaration"),
       ]
     )
   }