Small fixes for regular expression literals.

Two small fixes for regular expression literals:
* A regular expression literal cannot end in a space or a tab
* A regular expression literal might show up as the name of a function,
where it should be an operator. Treat it as an operator.

Author: DougGregor

Sources/SwiftParser/Declarations.swift

@@ -1406,6 +1406,29 @@ extension Parser {
 }
 
 extension Parser {
+  /// Are we at a regular expression literal that could act as an operator?
+  private func atRegexLiteralThatCouldBeAnOperator() -> Bool {
+    guard self.at(.regexLiteral) else {
+      return false
+    }
+
+    /// Try to re-lex at regex literal as an operator. If it succeeds and
+    /// consumes the entire regex literal, we're done.
+    return self.currentToken.tokenText.withBuffer {
+        (buffer: UnsafeBufferPointer<UInt8>) -> Bool in
+      var cursor = Lexer.Cursor(input: buffer, previous: 0)
+      guard buffer[0] == UInt8(ascii: "/") else { return false }
+
+      switch (cursor.lexOperatorIdentifier(cursor, cursor)) {
+      case (.unknown, _):
+        return false
+
+      default:
+        return cursor.input.isEmpty
+      }
+    }
+  }
+
   @_spi(RawSyntax)
   public mutating func parseFuncDeclaration(
     _ attrs: DeclAttributes,
@@ -1414,7 +1437,10 @@ extension Parser {
     let (unexpectedBeforeFuncKeyword, funcKeyword) = self.eat(handle)
     let unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax?
     let identifier: RawTokenSyntax
-    if self.at(anyIn: Operator.self) != nil || self.at(any: [.exclamationMark, .prefixAmpersand]) {
+    if self.at(anyIn: Operator.self) != nil ||
+        self.at(any: [.exclamationMark, .prefixAmpersand]) ||
+        self.atRegexLiteralThatCouldBeAnOperator()
+    {
       var name = self.currentToken.tokenText
       if name.count > 1 && name.hasSuffix("<") && self.peek().tokenKind == .identifier {
         name = SyntaxText(rebasing: name.dropLast())

Sources/SwiftParser/Lexer.swift

@@ -2078,6 +2078,7 @@ extension Lexer.Cursor {
     DELIMITLOOP: while true {
       defer { escaped = false }
 
+      let previousByte = Tmp.previous
       switch Tmp.advance() {
       case nil:
         return nil
@@ -2095,6 +2096,14 @@ extension Lexer.Cursor {
             continue DELIMITLOOP
           }
         }
+
+        // A regex literal may not end in a space or tab.
+        if !isMultiline && poundCount == 0 &&
+          (previousByte == UInt8(ascii: " ") ||
+           previousByte == UInt8(ascii: "\t")) {
+          return nil
+        }
+
         Tmp = EndLex
         break DELIMITLOOP
       case let .some(next) where !Unicode.Scalar(next).isASCII:

Tests/SwiftParserTest/Declarations.swift

@@ -42,6 +42,18 @@ final class DeclarationTests: XCTestCase {
                   DiagnosticSpec(locationMarker: "DIAG1", message: "expected argument list in function declaration"),
                   DiagnosticSpec(locationMarker: "DIAG2", message: "expected '=' and right-hand type in same type requirement"),
                 ])
+
+    AssertParse("func /^/ (lhs: Int, rhs: Int) -> Int { 1 / 2 }")
+
+    AssertParse(
+      "func #^DIAG^#/^notoperator^/ (lhs: Int, rhs: Int) -> Int { 1 / 2 }",
+      diagnostics: [
+        DiagnosticSpec(message: "expected identifier in function"),
+        DiagnosticSpec(message: "unexpected text '/^notoperator^/' before parameter clause")
+      ]
+    )
+
+    AssertParse("func /^ (lhs: Int, rhs: Int) -> Int { 1 / 2 }")
   }
 
   func testFuncAfterUnbalancedClosingBrace() {