Merge pull request #40367 from hamishknight/pitter-patter

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
   //===--------------------------------------------------------------------===//