Revert "RegExp: Add the ability to switch flags on and off within the regexp"

This reverts commit 68212c80.

Reason for revert: https://build.chromium.org/p/client.v8/builders/V8%20Linux%20-%20noi18n%20-%20debug/builds/17200

Original change's description:
> RegExp: Add the ability to switch flags on and off within the regexp
> 
> R=​yangguo@chromium.org
> 
> This is a reupload of https://chromium-review.googlesource.com/c/v8/v8/+/571746
> with a different user, since the other one was not allowed to commit to V8 any
> more.
> 
> Bug: 
> Change-Id: I6171afd44e514f6c934390faab6f9bee3953ac77
> Reviewed-on: https://chromium-review.googlesource.com/752522
> Commit-Queue: Jakob Gruber <jgruber@chromium.org>
> Reviewed-by: Jakob Gruber <jgruber@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#49098}

TBR=erik.corry@gmail.com,yangguo@chromium.org,erikcorry@chromium.org,jgruber@chromium.org

Change-Id: I651c5618f09f43104af50cb1319ab7b49011573e
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/752802Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
Commit-Queue: Benedikt Meurer <bmeurer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#49099}

src/flag-definitions.h

@@ -959,7 +959,6 @@ DEFINE_BOOL(serialization_statistics, false,
 
 // Regexp
 DEFINE_BOOL(regexp_optimization, true, "generate optimized regexp code")
-DEFINE_BOOL(regexp_mode_modifiers, false, "enable inline flags in regexp.")
 
 // Testing flags test/cctest/test-{flags,api,serialization}.cc
 DEFINE_BOOL(testing_bool_flag, true, "testing_bool_flag")

src/regexp/jsregexp.h

@@ -21,36 +21,6 @@ class RegExpNode;
 class RegExpTree;
 class BoyerMooreLookahead;
 
-inline bool IgnoreCase(JSRegExp::Flags flags) {
-  return (flags & JSRegExp::kIgnoreCase) != 0;
-}
-
-inline bool IsUnicode(JSRegExp::Flags flags) {
-  return (flags & JSRegExp::kUnicode) != 0;
-}
-
-inline bool IsSticky(JSRegExp::Flags flags) {
-  return (flags & JSRegExp::kSticky) != 0;
-}
-
-inline bool IsGlobal(JSRegExp::Flags flags) {
-  return (flags & JSRegExp::kGlobal) != 0;
-}
-
-inline bool DotAll(JSRegExp::Flags flags) {
-  return (flags & JSRegExp::kDotAll) != 0;
-}
-
-inline bool Multiline(JSRegExp::Flags flags) {
-  return (flags & JSRegExp::kMultiline) != 0;
-}
-
-inline bool NeedsUnicodeCaseEquivalents(JSRegExp::Flags flags) {
-  // Both unicode and ignore_case flags are set. We need to use ICU to find
-  // the closure over case equivalents.
-  return IsUnicode(flags) && IgnoreCase(flags);
-}
-
 class RegExpImpl {
  public:
   // Whether V8 is compiled with native regexp support or not.
@@ -525,7 +495,9 @@ class RegExpNode: public ZoneObject {
   // If we know that the input is one-byte then there are some nodes that can
   // never match.  This method returns a node that can be substituted for
   // itself, or nullptr if the node can never match.
-  virtual RegExpNode* FilterOneByte(int depth) { return this; }
+  virtual RegExpNode* FilterOneByte(int depth, bool ignore_case) {
+    return this;
+  }
   // Helper for FilterOneByte.
   RegExpNode* replacement() {
     DCHECK(info()->replacement_calculated);
@@ -597,7 +569,7 @@ class SeqRegExpNode: public RegExpNode {
       : RegExpNode(on_success->zone()), on_success_(on_success) { }
   RegExpNode* on_success() { return on_success_; }
   void set_on_success(RegExpNode* node) { on_success_ = node; }
-  virtual RegExpNode* FilterOneByte(int depth);
+  virtual RegExpNode* FilterOneByte(int depth, bool ignore_case);
   virtual void FillInBMInfo(Isolate* isolate, int offset, int budget,
                             BoyerMooreLookahead* bm, bool not_at_start) {
     on_success_->FillInBMInfo(isolate, offset, budget - 1, bm, not_at_start);
@@ -605,7 +577,7 @@ class SeqRegExpNode: public RegExpNode {
   }
 
  protected:
-  RegExpNode* FilterSuccessor(int depth);
+  RegExpNode* FilterSuccessor(int depth, bool ignore_case);
 
  private:
   RegExpNode* on_success_;
@@ -710,15 +682,13 @@ class TextNode: public SeqRegExpNode {
   static TextNode* CreateForCharacterRanges(Zone* zone,
                                             ZoneList<CharacterRange>* ranges,
                                             bool read_backward,
-                                            RegExpNode* on_success,
-                                            JSRegExp::Flags flags);
+                                            RegExpNode* on_success);
   // Create TextNode for a surrogate pair with a range given for the
   // lead and the trail surrogate each.
   static TextNode* CreateForSurrogatePair(Zone* zone, CharacterRange lead,
                                           CharacterRange trail,
                                           bool read_backward,
-                                          RegExpNode* on_success,
-                                          JSRegExp::Flags flags);
+                                          RegExpNode* on_success);
   virtual void Accept(NodeVisitor* visitor);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
   virtual int EatsAtLeast(int still_to_find, int budget, bool not_at_start);
@@ -735,7 +705,7 @@ class TextNode: public SeqRegExpNode {
   virtual void FillInBMInfo(Isolate* isolate, int offset, int budget,
                             BoyerMooreLookahead* bm, bool not_at_start);
   void CalculateOffsets();
-  virtual RegExpNode* FilterOneByte(int depth);
+  virtual RegExpNode* FilterOneByte(int depth, bool ignore_case);
 
  private:
   enum TextEmitPassType {
@@ -745,7 +715,7 @@ class TextNode: public SeqRegExpNode {
     CASE_CHARACTER_MATCH,        // Case-independent single character check.
     CHARACTER_CLASS_MATCH        // Character class.
   };
-  static bool SkipPass(TextEmitPassType pass, bool ignore_case);
+  static bool SkipPass(int pass, bool ignore_case);
   static const int kFirstRealPass = SIMPLE_CHARACTER_MATCH;
   static const int kLastPass = CHARACTER_CLASS_MATCH;
   void TextEmitPass(RegExpCompiler* compiler,
@@ -809,12 +779,11 @@ class AssertionNode: public SeqRegExpNode {
 
 class BackReferenceNode: public SeqRegExpNode {
  public:
-  BackReferenceNode(int start_reg, int end_reg, JSRegExp::Flags flags,
-                    bool read_backward, RegExpNode* on_success)
+  BackReferenceNode(int start_reg, int end_reg, bool read_backward,
+                    RegExpNode* on_success)
       : SeqRegExpNode(on_success),
         start_reg_(start_reg),
         end_reg_(end_reg),
-        flags_(flags),
         read_backward_(read_backward) {}
   virtual void Accept(NodeVisitor* visitor);
   int start_register() { return start_reg_; }
@@ -836,7 +805,6 @@ class BackReferenceNode: public SeqRegExpNode {
  private:
   int start_reg_;
   int end_reg_;
-  JSRegExp::Flags flags_;
   bool read_backward_;
 };
 
@@ -961,7 +929,7 @@ class ChoiceNode: public RegExpNode {
   virtual bool try_to_emit_quick_check_for_alternative(bool is_first) {
     return true;
   }
-  virtual RegExpNode* FilterOneByte(int depth);
+  virtual RegExpNode* FilterOneByte(int depth, bool ignore_case);
   virtual bool read_backward() { return false; }
 
  protected:
@@ -1033,7 +1001,7 @@ class NegativeLookaroundChoiceNode : public ChoiceNode {
   virtual bool try_to_emit_quick_check_for_alternative(bool is_first) {
     return !is_first;
   }
-  virtual RegExpNode* FilterOneByte(int depth);
+  virtual RegExpNode* FilterOneByte(int depth, bool ignore_case);
 };
 
 
@@ -1060,7 +1028,7 @@ class LoopChoiceNode: public ChoiceNode {
   bool body_can_be_zero_length() { return body_can_be_zero_length_; }
   virtual bool read_backward() { return read_backward_; }
   virtual void Accept(NodeVisitor* visitor);
-  virtual RegExpNode* FilterOneByte(int depth);
+  virtual RegExpNode* FilterOneByte(int depth, bool ignore_case);
 
  private:
   // AddAlternative is made private for loop nodes because alternatives
@@ -1467,8 +1435,11 @@ FOR_EACH_NODE_TYPE(DECLARE_VISIT)
 //   +-------+        +------------+
 class Analysis: public NodeVisitor {
  public:
-  Analysis(Isolate* isolate, bool is_one_byte)
-      : isolate_(isolate), is_one_byte_(is_one_byte), error_message_(nullptr) {}
+  Analysis(Isolate* isolate, JSRegExp::Flags flags, bool is_one_byte)
+      : isolate_(isolate),
+        flags_(flags),
+        is_one_byte_(is_one_byte),
+        error_message_(nullptr) {}
   void EnsureAnalyzed(RegExpNode* node);
 
 #define DECLARE_VISIT(Type)                                          \
@@ -1488,8 +1459,12 @@ FOR_EACH_NODE_TYPE(DECLARE_VISIT)
 
   Isolate* isolate() const { return isolate_; }
 
+  bool ignore_case() const { return (flags_ & JSRegExp::kIgnoreCase) != 0; }
+  bool unicode() const { return (flags_ & JSRegExp::kUnicode) != 0; }
+
  private:
   Isolate* isolate_;
+  JSRegExp::Flags flags_;
   bool is_one_byte_;
   const char* error_message_;
 

src/regexp/regexp-ast.h

@@ -6,7 +6,6 @@
 #define V8_REGEXP_REGEXP_AST_H_
 
 #include "src/objects.h"
-#include "src/objects/js-regexp.h"
 #include "src/objects/string.h"
 #include "src/utils.h"
 #include "src/zone/zone-containers.h"
@@ -145,7 +144,7 @@ class CharacterSet final BASE_EMBEDDED {
   explicit CharacterSet(ZoneList<CharacterRange>* ranges)
       : ranges_(ranges), standard_set_type_(0) {}
   ZoneList<CharacterRange>* ranges(Zone* zone);
-  uc16 standard_set_type() const { return standard_set_type_; }
+  uc16 standard_set_type() { return standard_set_type_; }
   void set_standard_set_type(uc16 special_set_type) {
     standard_set_type_ = special_set_type;
   }
@@ -275,8 +274,7 @@ class RegExpAssertion final : public RegExpTree {
     BOUNDARY,
     NON_BOUNDARY
   };
-  RegExpAssertion(AssertionType type, JSRegExp::Flags flags)
-      : assertion_type_(type), flags_(flags) {}
+  explicit RegExpAssertion(AssertionType type) : assertion_type_(type) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpAssertion* AsAssertion() override;
@@ -288,8 +286,7 @@ class RegExpAssertion final : public RegExpTree {
   AssertionType assertion_type() { return assertion_type_; }
 
  private:
-  const AssertionType assertion_type_;
-  const JSRegExp::Flags flags_;
+  AssertionType assertion_type_;
 };
 
 
@@ -303,18 +300,12 @@ class RegExpCharacterClass final : public RegExpTree {
     NEGATED = 1 << 0,
     CONTAINS_SPLIT_SURROGATE = 1 << 1,
   };
-  typedef base::Flags<Flag> CharacterClassFlags;
-
-  RegExpCharacterClass(
-      ZoneList<CharacterRange>* ranges, JSRegExp::Flags flags,
-      CharacterClassFlags character_class_flags = CharacterClassFlags())
-      : set_(ranges),
-        flags_(flags),
-        character_class_flags_(character_class_flags) {}
-  RegExpCharacterClass(uc16 type, JSRegExp::Flags flags)
-      : set_(type),
-        flags_(flags),
-        character_class_flags_(CharacterClassFlags()) {}
+  typedef base::Flags<Flag> Flags;
+
+  explicit RegExpCharacterClass(ZoneList<CharacterRange>* ranges,
+                                Flags flags = Flags())
+      : set_(ranges), flags_(flags) {}
+  explicit RegExpCharacterClass(uc16 type) : set_(type), flags_(0) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpCharacterClass* AsCharacterClass() override;
@@ -341,25 +332,22 @@ class RegExpCharacterClass final : public RegExpTree {
   // D : non-ASCII digit
   // . : non-newline
   // * : All characters, for advancing unanchored regexp
-  uc16 standard_type() const { return set_.standard_set_type(); }
+  uc16 standard_type() { return set_.standard_set_type(); }
   ZoneList<CharacterRange>* ranges(Zone* zone) { return set_.ranges(zone); }
-  bool is_negated() const { return (character_class_flags_ & NEGATED) != 0; }
-  JSRegExp::Flags flags() const { return flags_; }
+  bool is_negated() const { return (flags_ & NEGATED) != 0; }
   bool contains_split_surrogate() const {
-    return (character_class_flags_ & CONTAINS_SPLIT_SURROGATE) != 0;
+    return (flags_ & CONTAINS_SPLIT_SURROGATE) != 0;
   }
 
  private:
   CharacterSet set_;
-  const JSRegExp::Flags flags_;
-  const CharacterClassFlags character_class_flags_;
+  const Flags flags_;
 };
 
 
 class RegExpAtom final : public RegExpTree {
  public:
-  explicit RegExpAtom(Vector<const uc16> data, JSRegExp::Flags flags)
-      : data_(data), flags_(flags) {}
+  explicit RegExpAtom(Vector<const uc16> data) : data_(data) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpAtom* AsAtom() override;
@@ -370,12 +358,9 @@ class RegExpAtom final : public RegExpTree {
   void AppendToText(RegExpText* text, Zone* zone) override;
   Vector<const uc16> data() { return data_; }
   int length() { return data_.length(); }
-  JSRegExp::Flags flags() const { return flags_; }
-  bool ignore_case() const { return (flags_ & JSRegExp::kIgnoreCase) != 0; }
 
  private:
   Vector<const uc16> data_;
-  const JSRegExp::Flags flags_;
 };
 
 
@@ -547,10 +532,9 @@ class RegExpLookaround final : public RegExpTree {
 
 class RegExpBackReference final : public RegExpTree {
  public:
-  explicit RegExpBackReference(JSRegExp::Flags flags)
-      : capture_(nullptr), name_(nullptr), flags_(flags) {}
-  RegExpBackReference(RegExpCapture* capture, JSRegExp::Flags flags)
-      : capture_(capture), name_(nullptr), flags_(flags) {}
+  RegExpBackReference() : capture_(nullptr), name_(nullptr) {}
+  explicit RegExpBackReference(RegExpCapture* capture)
+      : capture_(capture), name_(nullptr) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpBackReference* AsBackReference() override;
@@ -568,7 +552,6 @@ class RegExpBackReference final : public RegExpTree {
  private:
   RegExpCapture* capture_;
   const ZoneVector<uc16>* name_;
-  const JSRegExp::Flags flags_;
 };
 
 

src/regexp/regexp-parser.h

@@ -99,7 +99,7 @@ class BufferedZoneList {
 // Accumulates RegExp atoms and assertions into lists of terms and alternatives.
 class RegExpBuilder : public ZoneObject {
  public:
-  RegExpBuilder(Zone* zone, JSRegExp::Flags flags);
+  RegExpBuilder(Zone* zone, bool ignore_case, bool unicode);
   void AddCharacter(uc16 character);
   void AddUnicodeCharacter(uc32 character);
   void AddEscapedUnicodeCharacter(uc32 character);
@@ -114,14 +114,7 @@ class RegExpBuilder : public ZoneObject {
   void NewAlternative();  // '|'
   bool AddQuantifierToAtom(int min, int max,
                            RegExpQuantifier::QuantifierType type);
-  void FlushText();
   RegExpTree* ToRegExp();
-  JSRegExp::Flags flags() const { return flags_; }
-  void set_flags(JSRegExp::Flags flags) { flags_ = flags; }
-
-  bool ignore_case() const { return (flags_ & JSRegExp::kIgnoreCase) != 0; }
-  bool multiline() const { return (flags_ & JSRegExp::kMultiline) != 0; }
-  bool dotall() const { return (flags_ & JSRegExp::kDotAll) != 0; }
 
  private:
   static const uc16 kNoPendingSurrogate = 0;
@@ -129,15 +122,18 @@ class RegExpBuilder : public ZoneObject {
   void AddTrailSurrogate(uc16 trail_surrogate);
   void FlushPendingSurrogate();
   void FlushCharacters();
+  void FlushText();
   void FlushTerms();
   bool NeedsDesugaringForUnicode(RegExpCharacterClass* cc);
   bool NeedsDesugaringForIgnoreCase(uc32 c);
   Zone* zone() const { return zone_; }
-  bool unicode() const { return (flags_ & JSRegExp::kUnicode) != 0; }
+  bool ignore_case() const { return ignore_case_; }
+  bool unicode() const { return unicode_; }
 
   Zone* zone_;
   bool pending_empty_;
-  JSRegExp::Flags flags_;
+  bool ignore_case_;
+  bool unicode_;
   ZoneList<uc16>* characters_;
   uc16 pending_surrogate_;
   BufferedZoneList<RegExpTree, 2> terms_;
@@ -163,6 +159,7 @@ class RegExpParser BASE_EMBEDDED {
   RegExpTree* ParsePattern();
   RegExpTree* ParseDisjunction();
   RegExpTree* ParseGroup();
+  RegExpTree* ParseCharacterClass();
 
   // Parses a {...,...} quantifier and stores the range in the given
   // out parameters.
@@ -178,7 +175,6 @@ class RegExpParser BASE_EMBEDDED {
   bool ParseUnicodeEscape(uc32* value);
   bool ParseUnlimitedLengthHexNumber(int max_value, uc32* value);
   bool ParsePropertyClass(ZoneList<CharacterRange>* result, bool negate);
-  RegExpTree* ParseCharacterClass(const RegExpBuilder* state);
 
   uc32 ParseOctalLiteral();
 
@@ -209,9 +205,10 @@ class RegExpParser BASE_EMBEDDED {
   int captures_started() { return captures_started_; }
   int position() { return next_pos_ - 1; }
   bool failed() { return failed_; }
-  // The Unicode flag can't be changed using in-regexp syntax, so it's OK to
-  // just read the initial flag value here.
-  bool unicode() const { return (top_level_flags_ & JSRegExp::kUnicode) != 0; }
+  bool dotall() const { return dotall_; }
+  bool ignore_case() const { return ignore_case_; }
+  bool multiline() const { return multiline_; }
+  bool unicode() const { return unicode_; }
 
   static bool IsSyntaxCharacterOrSlash(uc32 c);
 
@@ -229,35 +226,34 @@ class RegExpParser BASE_EMBEDDED {
 
   class RegExpParserState : public ZoneObject {
    public:
-    // Push a state on the stack.
     RegExpParserState(RegExpParserState* previous_state,
                       SubexpressionType group_type,
                       RegExpLookaround::Type lookaround_type,
                       int disjunction_capture_index,
-                      const ZoneVector<uc16>* capture_name,
-                      JSRegExp::Flags flags, Zone* zone)
+                      const ZoneVector<uc16>* capture_name, bool ignore_case,
+                      bool unicode, Zone* zone)
         : previous_state_(previous_state),
-          builder_(new (zone) RegExpBuilder(zone, flags)),
+          builder_(new (zone) RegExpBuilder(zone, ignore_case, unicode)),
           group_type_(group_type),
           lookaround_type_(lookaround_type),
           disjunction_capture_index_(disjunction_capture_index),
           capture_name_(capture_name) {}
     // Parser state of containing expression, if any.
-    RegExpParserState* previous_state() const { return previous_state_; }
+    RegExpParserState* previous_state() { return previous_state_; }
     bool IsSubexpression() { return previous_state_ != nullptr; }
     // RegExpBuilder building this regexp's AST.
-    RegExpBuilder* builder() const { return builder_; }
+    RegExpBuilder* builder() { return builder_; }
     // Type of regexp being parsed (parenthesized group or entire regexp).
-    SubexpressionType group_type() const { return group_type_; }
+    SubexpressionType group_type() { return group_type_; }
     // Lookahead or Lookbehind.
-    RegExpLookaround::Type lookaround_type() const { return lookaround_type_; }
+    RegExpLookaround::Type lookaround_type() { return lookaround_type_; }
     // Index in captures array of first capture in this sub-expression, if any.
     // Also the capture index of this sub-expression itself, if group_type
     // is CAPTURE.
-    int capture_index() const { return disjunction_capture_index_; }
+    int capture_index() { return disjunction_capture_index_; }
     // The name of the current sub-expression, if group_type is CAPTURE. Only
     // used for named captures.
-    const ZoneVector<uc16>* capture_name() const { return capture_name_; }
+    const ZoneVector<uc16>* capture_name() { return capture_name_; }
 
     bool IsNamedCapture() const { return capture_name_ != nullptr; }
 
@@ -268,17 +264,17 @@ class RegExpParser BASE_EMBEDDED {
 
    private:
     // Linked list implementation of stack of states.
-    RegExpParserState* const previous_state_;
+    RegExpParserState* previous_state_;
     // Builder for the stored disjunction.
-    RegExpBuilder* const builder_;
+    RegExpBuilder* builder_;
     // Stored disjunction type (capture, look-ahead or grouping), if any.
-    const SubexpressionType group_type_;
+    SubexpressionType group_type_;
     // Stored read direction.
-    const RegExpLookaround::Type lookaround_type_;
+    RegExpLookaround::Type lookaround_type_;
     // Stored disjunction's capture index (if any).
-    const int disjunction_capture_index_;
+    int disjunction_capture_index_;
     // Stored capture name (if any).
-    const ZoneVector<uc16>* const capture_name_;
+    const ZoneVector<uc16>* capture_name_;
   };
 
   // Return the 1-indexed RegExpCapture object, allocate if necessary.
@@ -295,7 +291,6 @@ class RegExpParser BASE_EMBEDDED {
 
   bool ParseNamedBackReference(RegExpBuilder* builder,
                                RegExpParserState* state);
-  RegExpParserState* ParseOpenParenthesis(RegExpParserState* state);
 
   // After the initial parsing pass, patch corresponding RegExpCapture objects
   // into all RegExpBackReferences. This is done after initial parsing in order
@@ -328,10 +323,10 @@ class RegExpParser BASE_EMBEDDED {
   ZoneList<RegExpBackReference*>* named_back_references_;
   FlatStringReader* in_;
   uc32 current_;
-  // These are the flags specified outside the regexp syntax ie after the
-  // terminating '/' or in the second argument to the constructor.  The current
-  // flags are stored on the RegExpBuilder.
-  JSRegExp::Flags top_level_flags_;
+  bool dotall_;
+  bool ignore_case_;
+  bool multiline_;
+  bool unicode_;
   int next_pos_;
   int captures_started_;
   int capture_count_;  // Only valid after we have scanned for captures.

test/mjsunit/regexp-modifiers-autogenerated.js

-// Copyright 2017 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Flags: --regexp-mode-modifiers --harmony-regexp-property
-
-// These regexps are just grepped out of the other tests we already have
-// and the syntax changed from out-of-line i flag to inline i flag.
-
-assertFalse(/(?i)x(...)\1/.test("x\u03a3\u03c2\u03c3\u03c2\u03c3"));
-assertTrue(/(?i)\u03a3((?:))\1\1x/.test("\u03c2x"), "backref-UC16-empty");
-assertTrue(/(?i)x(?:...|(...))\1x/.test("x\u03a3\u03c2\u03c3x"));
-assertTrue(/(?i)x(?:...|(...))\1x/.test("x\u03c2\u03c3\u039b\u03a3\u03c2\u03bbx"));
-assertFalse(/(?i)\xc1/.test('fooA'), "quickcheck-uc16-pattern-ascii-subject");
-assertFalse(/(?i)x(...)\1/.test("xaaaaa"), "backref-ASCII-short");
-assertTrue(/(?i)x((?:))\1\1x/.test("xx"), "backref-ASCII-empty");
-assertTrue(/(?i)x(?:...|(...))\1x/.test("xabcx"), "backref-ASCII-uncaptured");
-assertTrue(/(?i)x(?:...|(...))\1x/.test("xabcABCx"), "backref-ASCII-backtrack");
-assertFalse(/(?i)f/.test('b'));
-assertFalse(/(?i)[abc]f/.test('x'));
-assertFalse(/(?i)[abc]f/.test('xa'));
-assertFalse(/(?i)[abc]</.test('x'));
-assertFalse(/(?i)[abc]</.test('xa'));
-assertFalse(/(?i)f[abc]/.test('x'));
-assertFalse(/(?i)f[abc]/.test('xa'));
-assertFalse(/(?i)<[abc]/.test('x'));
-assertFalse(/(?i)<[abc]/.test('xa'));
-assertFalse(/(?i)[\u00e5]/.test("\u212b"));
-assertFalse(/(?i)[\u212b]/.test("\u00e5\u1234"));
-assertFalse(/(?i)[\u212b]/.test("\u00e5"));
-assertTrue(/(?i)\u00e5/u.test("\u00c5"));
-assertTrue(/(?i)\u00e5/u.test("\u00e5"));
-assertTrue(/(?i)\u00c5/u.test("\u00e5"));
-assertTrue(/(?i)\u00c5/u.test("\u00c5"));
-assertTrue(/(?i)\u212b/u.test("\u212b"));
-assertFalse(/(?i)\u{10400}/.test("\u{10428}"));
-assertFalse(/(?i)\u00df/u.test("SS"));
-assertFalse(/(?i)\u1f8d/u.test("\u1f05\u03b9"));
-assertTrue(/(?i)\u1f6b/u.test("\u1f63"));
-assertFalse(/(?i)[\u00e5]/.test("\u212b"));
-assertFalse(/(?i)[\u212b]/.test("\u00e5\u1234"));
-assertFalse(/(?i)[\u212b]/.test("\u00e5"));
-assertTrue(/(?i)\u00e5/u.test("\u212b"));
-assertTrue(/(?i)\u00e5/u.test("\u00c5"));
-assertTrue(/(?i)\u00e5/u.test("\u00e5"));
-assertTrue(/(?i)\u00e5/u.test("\u212b"));
-assertTrue(/(?i)\u00c5/u.test("\u00e5"));
-assertTrue(/(?i)\u00c5/u.test("\u212b"));
-assertTrue(/(?i)\u00c5/u.test("\u00c5"));
-assertTrue(/(?i)\u212b/u.test("\u00c5"));
-assertTrue(/(?i)\u212b/u.test("\u00e5"));
-assertTrue(/(?i)\u212b/u.test("\u212b"));
-assertFalse(/(?i)\u{10400}/.test("\u{10428}"));
-assertTrue(/(?i)\u{10400}/u.test("\u{10428}"));
-assertTrue(/(?i)\ud801\udc00/u.test("\u{10428}"));
-assertTrue(/(?i)[\u{10428}]/u.test("\u{10400}"));
-assertTrue(/(?i)[\ud801\udc28]/u.test("\u{10400}"));
-assertFalse(/(?i)\u00df/u.test("SS"));
-assertFalse(/(?i)\u1f8d/u.test("\u1f05\u03b9"));
-assertTrue(/(?i)\u1f8d/u.test("\u1f85"));
-assertTrue(/(?i)\u1f6b/u.test("\u1f63"));
-assertTrue(/(?i)\u00e5\u00e5\u00e5/u.test("\u212b\u00e5\u00c5"));
-assertTrue(/(?i)AB\u{10400}/u.test("ab\u{10428}"));
-assertTrue(/(?i)\w/u.test('\u017F'));
-assertTrue(/(?i)\w/u.test('\u212A'));
-assertFalse(/(?i)\W/u.test('\u017F'));
-assertFalse(/(?i)\W/u.test('\u212A'));
-assertFalse(/(?i)\W/u.test('s'));
-assertFalse(/(?i)\W/u.test('S'));
-assertFalse(/(?i)\W/u.test('K'));
-assertFalse(/(?i)\W/u.test('k'));
-assertTrue(/(?i)[\w]/u.test('\u017F'));
-assertTrue(/(?i)[\w]/u.test('\u212A'));
-assertFalse(/(?i)[\W]/u.test('\u017F'));
-assertFalse(/(?i)[\W]/u.test('\u212A'));
-assertFalse(/(?i)[\W]/u.test('s'));
-assertFalse(/(?i)[\W]/u.test('S'));
-assertFalse(/(?i)[\W]/u.test('K'));
-assertFalse(/(?i)[\W]/u.test('k'));
-assertTrue(/(?i)\b/u.test('\u017F'));
-assertTrue(/(?i)\b/u.test('\u212A'));
-assertTrue(/(?i)\b/u.test('s'));
-assertTrue(/(?i)\b/u.test('S'));
-assertFalse(/(?i)\B/u.test('\u017F'));
-assertFalse(/(?i)\B/u.test('\u212A'));
-assertFalse(/(?i)\B/u.test('s'));
-assertFalse(/(?i)\B/u.test('S'));
-assertFalse(/(?i)\B/u.test('K'));
-assertFalse(/(?i)\B/u.test('k'));
-assertTrue(/(?i)\p{Ll}/u.test("a"));
-assertTrue(/(?i)\p{Ll}/u.test("\u{118D4}"));
-assertTrue(/(?i)\p{Ll}/u.test("A"));
-assertTrue(/(?i)\p{Ll}/u.test("\u{118B4}"));
-assertTrue(/(?i)\P{Ll}/u.test("a"));
-assertTrue(/(?i)\P{Ll}/u.test("\u{118D4}"));
-assertTrue(/(?i)\P{Ll}/u.test("A"));
-assertTrue(/(?i)\P{Ll}/u.test("\u{118B4}"));
-assertTrue(/(?i)\p{Lu}/u.test("a"));
-assertTrue(/(?i)\p{Lu}/u.test("\u{118D4}"));
-assertTrue(/(?i)\p{Lu}/u.test("A"));
-assertTrue(/(?i)\p{Lu}/u.test("\u{118B4}"));
-assertTrue(/(?i)\P{Lu}/u.test("a"));
-assertTrue(/(?i)\P{Lu}/u.test("\u{118D4}"));
-assertTrue(/(?i)\P{Lu}/u.test("A"));
-assertTrue(/(?i)\P{Lu}/u.test("\u{118B4}"));
-assertTrue(/(?i)[@-A]/.test("a"));
-assertTrue(/(?i)[@-A]/.test("A"));
-assertTrue(/(?i)[@-A]/.test("@"));
-assertFalse(/(?i)[¿-À]/.test('¾'));
-assertTrue(/(?i)[¿-À]/.test('¿'));
-assertTrue(/(?i)[¿-À]/.test('À'));
-assertTrue(/(?i)[¿-À]/.test('à'));
-assertFalse(/(?i)[¿-À]/.test('á'));
-assertFalse(/(?i)[¿-À]/.test('Á'));
-assertFalse(/(?i)[¿-À]/.test('Á'));
-assertFalse(/(?i)[Ö-×]/.test('Õ'));
-assertTrue(/(?i)[Ö-×]/.test('Ö'));
-assertTrue(/(?i)[Ö-×]/.test('ö'));
-assertTrue(/(?i)[Ö-×]/.test('×'));
-assertFalse(/(?i)[Ö-×]/.test('Ø'));
-assertTrue(/(?i)(a[\u1000A])+/.test('aa'));
-assertTrue(/(?i)\u0178/.test('\u00ff'));
-assertTrue(/(?i)\u039c/.test('\u00b5'));
-assertTrue(/(?i)\u039c/.test('\u03bc'));
-assertTrue(/(?i)\u00b5/.test('\u03bc'));
-assertTrue(/(?i)[\u039b-\u039d]/.test('\u00b5'));
-assertFalse(/(?i)[^\u039b-\u039d]/.test('\u00b5'));
-
-assertTrue(/(?m)^bar/.test("bar"));
-assertTrue(/(?m)^bar/.test("bar\nfoo"));
-assertTrue(/(?m)^bar/.test("foo\nbar"));
-assertTrue(/(?m)bar$/.test("bar"));
-assertTrue(/(?m)bar$/.test("bar\nfoo"));
-assertTrue(/(?m)bar$/.test("foo\nbar"));
-assertFalse(/(?m)^bxr/.test("bar"));
-assertFalse(/(?m)^bxr/.test("bar\nfoo"));
-assertFalse(/(?m)^bxr/.test("foo\nbar"));
-assertFalse(/(?m)bxr$/.test("bar"));
-assertFalse(/(?m)bxr$/.test("bar\nfoo"));
-assertFalse(/(?m)bxr$/.test("foo\nbar"));
-assertTrue(/(?m)^.*$/.test("\n"));
-assertTrue(/(?m)^([()]|.)*$/.test("()\n()"));
-assertTrue(/(?m)^([()]|.)*$/.test("()\n"));
-assertTrue(/(?m)^[()]*$/.test("()\n."));

test/mjsunit/regexp-modifiers-dotall.js

-// Copyright 2017 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Flags: --regexp-mode-modifiers --harmony-regexp-dotall
-
-// S flag switches dotall mode on and off.  Combine with i flag changes to test
-// the parser.
-test(/.(?s).(?i-s).a(?-i)a/);
-test(/.(?s:.)(?i:.a)a/);
-test(/.(?s).(?i-s).a(?-i)a/u);
-test(/.(?s:.)(?i:.a)a/u);
-
-// m flag makes no difference
-test(/.(?sm).(?i-s).a(?-i)a/);
-test(/.(?s:.)(?i:.a)a/);
-test(/.(?sm).(?im-s).a(?m-i)a/u);
-test(/.(?s:.)(?i:.a)a/u);
-
-function test(re) {
-  assertTrue(re.test("...aa"));
-  assertTrue(re.test(".\n.aa"));
-  assertTrue(re.test(".\n.Aa"));
-  assertFalse(re.test("\n\n.Aa"));
-  assertFalse(re.test(".\n\nAa"));
-  assertFalse(re.test(".\n.AA"));
-}

test/mjsunit/regexp-modifiers.js

-// Copyright 2017 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Flags: --regexp-mode-modifiers
-
-aa(/(a)(?i)\1/);
-aa(/([az])(?i)\1/);
-aa(/(a)(?i)\1/u);
-aa(/([az])(?i)\1/u);
-
-function aa(re) {
-  assertTrue(re.test("aa"));
-  assertTrue(re.test("aA"));
-  assertFalse(re.test("Aa"));
-  assertFalse(re.test("AA"));
-}
-
-aai(/(a)(?-i)\1/i);
-aai(/([az])(?-i)\1/i);
-aai(/(a)(?-i)\1/iu);
-aai(/([az])(?-i)\1/iu);
-
-function aai(re) {
-  assertTrue(re.test("aa"));
-  assertFalse(re.test("aA"));
-  assertFalse(re.test("Aa"));
-  assertTrue(re.test("AA"));
-}
-
-abcd(/a(b(?i)c)d/);
-abcd(/[aw]([bx](?i)[cy])[dz]/);
-abcd(/a(b(?i)c)d/u);
-abcd(/[aw]([bx](?i)[cy])[dz]/u);
-
-function abcd(re) {
-  assertTrue(re.test("abcd"));
-  assertFalse(re.test("abcD"));
-  assertTrue(re.test("abCd"));
-  assertFalse(re.test("abCD"));
-  assertFalse(re.test("aBcd"));
-  assertFalse(re.test("aBcD"));
-  assertFalse(re.test("aBCd"));
-  assertFalse(re.test("aBCD"));
-  assertFalse(re.test("Abcd"));
-  assertFalse(re.test("AbcD"));
-  assertFalse(re.test("AbCd"));
-  assertFalse(re.test("AbCD"));
-  assertFalse(re.test("ABcd"));
-  assertFalse(re.test("ABcD"));
-  assertFalse(re.test("ABCd"));
-  assertFalse(re.test("ABCD"));
-}
-
-abcdei(/a(b(?-i)c)d/i);
-abcdei(/[aw]([bx](?-i)[cy])[dz]/i);
-abcdei(/a(b(?-i)c)d/iu);
-abcdei(/[aw]([bx](?-i)[cy])[dz]/iu);
-
-function abcdei(re) {
-  assertTrue(re.test("abcd"));
-  assertTrue(re.test("abcD"));
-  assertFalse(re.test("abCd"));
-  assertFalse(re.test("abCD"));
-  assertTrue(re.test("aBcd"));
-  assertTrue(re.test("aBcD"));
-  assertFalse(re.test("aBCd"));
-  assertFalse(re.test("aBCD"));
-  assertTrue(re.test("Abcd"));
-  assertTrue(re.test("AbcD"));
-  assertFalse(re.test("AbCd"));
-  assertFalse(re.test("AbCD"));
-  assertTrue(re.test("ABcd"));
-  assertTrue(re.test("ABcD"));
-  assertFalse(re.test("ABCd"));
-  assertFalse(re.test("ABCD"));
-}
-
-abc(/a(?i:b)c/);
-abc(/[ax](?i:[by])[cz]/);
-abc(/a(?i:b)c/u);
-abc(/[ax](?i:[by])[cz]/u);
-
-function abc(re) {
-  assertTrue(re.test("abc"));
-  assertFalse(re.test("abC"));
-  assertTrue(re.test("aBc"));
-  assertFalse(re.test("aBC"));
-  assertFalse(re.test("Abc"));
-  assertFalse(re.test("AbC"));
-  assertFalse(re.test("ABc"));
-  assertFalse(re.test("ABC"));
-}
-
-abci(/a(?-i:b)c/i);
-abci(/[ax](?-i:[by])[cz]/i);
-abci(/a(?-i:b)c/iu);
-abci(/[ax](?-i:[by])[cz]/iu);
-
-function abci(re) {
-  assertTrue(re.test("abc"));
-  assertTrue(re.test("abC"));
-  assertFalse(re.test("aBc"));
-  assertFalse(re.test("aBC"));
-  assertTrue(re.test("Abc"));
-  assertTrue(re.test("AbC"));
-  assertFalse(re.test("ABc"));
-  assertFalse(re.test("ABC"));
-}
-
-assertThrows(() => new RegExp("foo(?i:"));
-assertThrows(() => new RegExp("foo(?--i)"));
-assertThrows(() => new RegExp("foo(?i-i)"));
-
-assertThrows(() => new RegExp("foo(?m:"));
-assertThrows(() => new RegExp("foo(?--m)"));
-assertThrows(() => new RegExp("foo(?m-m)"));
-
-
-// The following tests are taken from test/mjsunit/es7/regexp-ui-word.js but
-// using inline syntax instead of the global /i flag.
-assertTrue(/(?i)\w/u.test('\u017F'));
-assertTrue(/(?i)\w/u.test('\u212A'));
-assertFalse(/(?i)\W/u.test('\u017F'));
-assertFalse(/(?i)\W/u.test('\u212A'));
-assertFalse(/(?i)\W/u.test('s'));
-assertFalse(/(?i)\W/u.test('S'));
-assertFalse(/(?i)\W/u.test('K'));
-assertFalse(/(?i)\W/u.test('k'));
-
-assertTrue(/(?i)[\w]/u.test('\u017F'));
-assertTrue(/(?i)[\w]/u.test('\u212A'));
-assertFalse(/(?i)[\W]/u.test('\u017F'));
-assertFalse(/(?i)[\W]/u.test('\u212A'));
-assertFalse(/(?i)[\W]/u.test('s'));
-assertFalse(/(?i)[\W]/u.test('S'));
-assertFalse(/(?i)[\W]/u.test('K'));
-assertFalse(/(?i)[\W]/u.test('k'));
-
-assertTrue(/(?i)\b/u.test('\u017F'));
-assertFalse(/(?i:)\b/u.test('\u017F'));
-assertTrue(/(?i)\b/u.test('\u212A'));
-assertFalse(/(?i:)\b/u.test('\u212A'));
-assertTrue(/(?i)\b/u.test('s'));
-assertTrue(/(?i)\b/u.test('S'));
-assertFalse(/(?i)\B/u.test('\u017F'));
-assertFalse(/(?i)\B/u.test('\u212A'));
-assertFalse(/(?i)\B/u.test('s'));
-assertFalse(/(?i)\B/u.test('S'));
-assertFalse(/(?i)\B/u.test('K'));
-assertFalse(/(?i)\B/u.test('k'));
-
-var re = /^\s(?m)^.$\s(?-m)$/;
-assertTrue(re.test("\n.\n"));
-assertFalse(re.test(" .\n"));
-assertFalse(re.test("\n. "));
-assertFalse(re.test(" . "));
-assertFalse(re.test("_\n.\n"));
-assertFalse(re.test("\n.\n_"));
-assertFalse(re.test("_\n.\n_"));
-
-assertEquals(["abcd", "d"], /a.*?(.)(?i)\b/.exec('abcd\u017F cd'));
-assertEquals(["abcd", "d"], /a.*?(.)(?i)\b/.exec('abcd\u212A cd'));
-assertEquals(["abcd\u017F", "\u017F"], /a.*?(.)(?i)\b/u.exec('abcd\u017F cd'));
-assertEquals(["abcd\u212A", "\u212A"], /a.*?(.)(?i)\b/u.exec('abcd\u212A cd'));
-
-assertEquals(["a\u017F ", " "], /a.*?(?i)\B(.)/.exec('a\u017F '));
-assertEquals(["a\u212A ", " "], /a.*?(?i)\B(.)/.exec('a\u212A '));
-assertEquals(["a\u017F", "\u017F"], /a.*?(?i:\B)(.)/u.exec('a\u017F '));
-assertEquals(["a\u212A", "\u212A"], /a.*?(?i:\B)(.)/u.exec('a\u212A '));
-
-// Nested flags.
-var res = [
-  /^a(?i:b(?-i:c(?i:d)e)f)g$/,
-  /^a(?i:b(?-i)c(?i)d(?-i)e(?i)f)g$/,
-  /^(?-i:a(?i:b(?-i:c(?i:d)e)f)g)$/i,
-  /^(?-i:a(?i:b(?-i)c(?i)d(?-i)e(?i)f)g)$/i,
-];
-
-for (var idx = 0; idx < res.length; idx++) {
-  var re = res[idx];
-  for (var i = 0; i < 128; i++) {
-    var s = (i & 1) ? "A" : "a";
-    s += (i & 2) ? "B" : "b";
-    s += (i & 4) ? "C" : "c";
-    s += (i & 8) ? "D" : "d";
-    s += (i & 16) ? "E" : "e";
-    s += (i & 32) ? "F" : "f";
-    s += (i & 64) ? "G" : "g";
-    if ((i & (1 | 4 | 16 | 64)) != 0) {
-      assertFalse(re.test(s), s);
-    } else {
-      assertTrue(re.test(s), s);
-    }
-  }
-}