Prototype regex literal AST and emission

With `-enable-experimental-string-processing`,
start lexing `'` delimiters as regex literals (this
is just a placeholder delimiter for now). The
contents of which gets passed to the libswift
library, which can return an error string to be
emitted, or null for success.

The libswift side isn't yet hooked up to the Swift
regex parser, so for now just emit a dummy
diagnostic for regexes starting with quantifiers.

If successful, build an AST node which will be
emitted as an implicit call to an
`init(_regexString:)` initializer of an in-scope
`Regex` decl (which will eventually be a known
stdlib decl).

Author: hamishknight

include/swift/AST/DiagnosticsParse.def

@@ -91,6 +91,9 @@ ERROR(forbidden_interpolated_string,none,
 ERROR(forbidden_extended_escaping_string,none,
       "%0 cannot be an extended escaping string literal", (StringRef))
 
+ERROR(regex_literal_parsing_error,none,
+      "%0", (StringRef))
+
 //------------------------------------------------------------------------------
 // MARK: Lexer diagnostics
 //------------------------------------------------------------------------------
@@ -108,9 +111,6 @@ ERROR(lex_unprintable_ascii_character,none,
 ERROR(lex_invalid_utf8,none,
       "invalid UTF-8 found in source file", ())
 
-NOTE(lex_experimental_regex_strawperson,none,
-     "'%0'", (StringRef))
-
 ERROR(lex_single_quote_string,none,
       "single-quoted string literal found, use '\"'", ())
 ERROR(lex_invalid_curly_quote,none,
@@ -140,6 +140,9 @@ ERROR(lex_invalid_escape_delimiter,none,
 ERROR(lex_invalid_closing_delimiter,none,
       "too many '#' characters in closing delimiter", ())
 
+ERROR(lex_unterminated_regex,none,
+      "unterminated regex literal", ())
+
 ERROR(lex_invalid_unicode_scalar,none,
       "invalid unicode scalar", ())
 ERROR(lex_unicode_escape_braces,none,

include/swift/AST/DiagnosticsSema.def

@@ -3668,6 +3668,9 @@ ERROR(builtin_string_literal_broken_proto,none,
 ERROR(string_literal_broken_proto,none,
       "protocol 'ExpressibleByStringLiteral' is broken", ())
 
+ERROR(regex_decl_broken,none,
+      "cannot find 'Regex' type in scope", ())
+
 // Array literals
 ERROR(should_use_dictionary_literal,none,
       "dictionary of type %0 cannot be %select{used|initialized}1 "

include/swift/AST/Expr.h

@@ -961,7 +961,38 @@ class InterpolatedStringLiteralExpr : public LiteralExpr {
     return E->getKind() == ExprKind::InterpolatedStringLiteral;
   }
 };
-  
+
+/// A regular expression literal e.g '(a|c)*'.
+class RegexLiteralExpr : public LiteralExpr {
+  SourceLoc Loc;
+  StringRef RegexText;
+  Expr *SemanticExpr;
+
+  RegexLiteralExpr(SourceLoc loc, StringRef regexText, Expr *semanticExpr,
+                   bool isImplicit)
+      : LiteralExpr(ExprKind::RegexLiteral, isImplicit), Loc(loc),
+        RegexText(regexText), SemanticExpr(semanticExpr) {}
+
+public:
+  static RegexLiteralExpr *createParsed(ASTContext &ctx, SourceLoc loc,
+                                        StringRef regexText,
+                                        Expr *semanticExpr);
+
+  /// Retrieve the raw regex text.
+  StringRef getRegexText() const { return RegexText; }
+
+  /// Retrieve the semantic expression that the regex will be type-checked and
+  /// emitted as.
+  Expr *getSemanticExpr() const { return SemanticExpr; }
+  void setSemanticExpr(Expr *expr) { SemanticExpr = expr; }
+
+  SourceRange getSourceRange() const { return Loc; }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::RegexLiteral;
+  }
+};
+
 /// MagicIdentifierLiteralExpr - A magic identifier like #file which expands
 /// out to a literal at SILGen time.
 class MagicIdentifierLiteralExpr : public BuiltinLiteralExpr {

include/swift/AST/ExprNodes.def

@@ -78,6 +78,7 @@ ABSTRACT_EXPR(Literal, Expr)
     LITERAL_EXPR(MagicIdentifierLiteral, BuiltinLiteralExpr)
     EXPR_RANGE(BuiltinLiteral, BooleanLiteral, MagicIdentifierLiteral)
   LITERAL_EXPR(InterpolatedStringLiteral, LiteralExpr)
+  LITERAL_EXPR(RegexLiteral, LiteralExpr)
   LITERAL_EXPR(ObjectLiteral, LiteralExpr)
   EXPR_RANGE(Literal, NilLiteral, ObjectLiteral)
 EXPR(DiscardAssignment, Expr)

include/swift/AST/KnownIdentifiers.def

@@ -250,6 +250,10 @@ IDENTIFIER(pullback)
 IDENTIFIER(TangentVector)
 IDENTIFIER(zero)
 
+// Regex literals
+IDENTIFIER(Regex)
+IDENTIFIER(_regexString)
+
 // Distributed actors
 IDENTIFIER(transport)
 IDENTIFIER(using)

include/swift/Parse/ExperimentalRegexBridging.h

@@ -8,6 +8,7 @@ extern "C" {
 typedef const char *(* ParseRegexStrawperson)(const char *);
 
 void Parser_registerParseRegexStrawperson(ParseRegexStrawperson fn);
+bool Parser_hasParseRegexStrawperson();
 
 #ifdef __cplusplus
 } // extern "C"

include/swift/Parse/Lexer.h

@@ -595,6 +595,8 @@ class Lexer {
   void lexStringLiteral(unsigned CustomDelimiterLen = 0);
   void lexEscapedIdentifier();
 
+  void lexRegexLiteral(const char *TokStart);
+
   void tryLexEditorPlaceholder();
   const char *findEndOfCurlyQuoteStringLiteral(const char *,
                                                bool EmitDiagnostics);

include/swift/Parse/Parser.h

@@ -1579,6 +1579,7 @@ class Parser {
   ParserResult<Expr> parseExprSelector();
   ParserResult<Expr> parseExprSuper();
   ParserResult<Expr> parseExprStringLiteral();
+  ParserResult<Expr> parseExprRegexLiteral();
 
   StringRef copyAndStripUnderscores(StringRef text);
 

lib/AST/ASTDumper.cpp

@@ -1907,6 +1907,11 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     E->getInitializer().dump(OS);
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
+  void visitRegexLiteralExpr(RegexLiteralExpr *E) {
+    printCommon(E, "regex_literal_expr");
+    printRec(E->getSemanticExpr());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
 
   void visitObjectLiteralExpr(ObjectLiteralExpr *E) {
     printCommon(E, "object_literal") 

lib/AST/ASTWalker.cpp

@@ -1152,6 +1152,15 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     return E;
   }
 
+  Expr *visitRegexLiteralExpr(RegexLiteralExpr *E) {
+    if (auto *newExpr = doIt(E->getSemanticExpr())) {
+      E->setSemanticExpr(newExpr);
+    } else {
+      return nullptr;
+    }
+    return E;
+  }
+
   //===--------------------------------------------------------------------===//
   //                           Everything Else
   //===--------------------------------------------------------------------===//