[regexp] simplify unanchored advance for unicode regexps.

src/regexp/jsregexp.cc

 // Copyright 2012 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.
 
 #include "src/regexp/jsregexp.h"
 
 #include "src/ast/ast.h"
 #include "src/base/platform/platform.h"
 #include "src/compilation-cache.h"
 #include "src/compiler.h"
@@ skipping 5067 matching lines @@
         compiler, trail_surrogates, lead_surrogates, on_success, true);
   } else {
     // Reading forward. Assert that reading backward, there is no lead
     // surrogate, and then forward match the trail surrogate.
     match = NegativeLookaroundAgainstReadDirectionAndMatch(
         compiler, lead_surrogates, trail_surrogates, on_success, false);
   }
   result->AddAlternative(GuardedAlternative(match));
 }
 
-
-void AddUnanchoredAdvance(RegExpCompiler* compiler, ChoiceNode* result,
-                          RegExpNode* on_success) {
+RegExpNode* UnanchoredAdvance(RegExpCompiler* compiler,
+                              RegExpNode* on_success) {
   // This implements ES2015 21.2.5.2.3, AdvanceStringIndex.
   DCHECK(!compiler->read_backward());
   Zone* zone = compiler->zone();
-  // Advancing can either consume a BMP character or a trail surrogate.
-  ZoneList<CharacterRange>* bmp_and_trail =
-      new (zone) ZoneList<CharacterRange>(2, zone);
-  bmp_and_trail->Add(CharacterRange::Range(0, kLeadSurrogateStart - 1), zone);
-  bmp_and_trail->Add(
-      CharacterRange::Range(kLeadSurrogateEnd + 1, kNonBmpStart - 1), zone);
-  result->AddAlternative(GuardedAlternative(TextNode::CreateForCharacterRanges(
-      zone, bmp_and_trail, false, on_success)));
-
-  // Or it could consume a lead optionally followed by a trail surrogate.
-  ZoneList<CharacterRange>* lead_surrogates = CharacterRange::List(
-      zone, CharacterRange::Range(kLeadSurrogateStart, kLeadSurrogateEnd));
-  ZoneList<CharacterRange>* trail_surrogates = CharacterRange::List(
-      zone, CharacterRange::Range(kTrailSurrogateStart, kTrailSurrogateEnd));
-  ChoiceNode* optional_trail = new (zone) ChoiceNode(2, zone);
-  optional_trail->AddAlternative(
-      GuardedAlternative(TextNode::CreateForCharacterRanges(
-          zone, trail_surrogates, false, on_success)));
-  optional_trail->AddAlternative(GuardedAlternative(on_success));
-  RegExpNode* optional_pair = TextNode::CreateForCharacterRanges(
-      zone, lead_surrogates, false, optional_trail);
-  result->AddAlternative(GuardedAlternative(optional_pair));
+  // Advance any character. If the character happens to be a lead surrogate and
+  // we advanced into the middle of a surrogate pair, it will work out, as
+  // nothing will match from there. We will have to advance again, consuming
+  // the associated trail surrogate.
+  ZoneList<CharacterRange>* range = CharacterRange::List(
+      zone, CharacterRange::Range(0, String::kMaxUtf16CodeUnit));
+  return TextNode::CreateForCharacterRanges(zone, range, false, on_success);
 }
 
 
 void AddUnicodeCaseEquivalents(RegExpCompiler* compiler,
                                ZoneList<CharacterRange>* ranges) {
 #ifdef V8_I18N_SUPPORT
   // Use ICU to compute the case fold closure over the ranges.
   DCHECK(compiler->unicode());
   DCHECK(compiler->ignore_case());
   USet* set = uset_openEmpty();
@@ skipping 41 matching lines @@
     if (is_negated()) {
       ZoneList<CharacterRange>* negated =
           new (zone) ZoneList<CharacterRange>(2, zone);
       CharacterRange::Negate(ranges, negated, zone);
       ranges = negated;
     }
     if (ranges->length() == 0) {
       // No matches possible.
       return new (zone) EndNode(EndNode::BACKTRACK, zone);
     }
-    ChoiceNode* result = new (zone) ChoiceNode(2, zone);
     if (standard_type() == '*') {
-      AddUnanchoredAdvance(compiler, result, on_success);
+      return UnanchoredAdvance(compiler, on_success);
     } else {
+      ChoiceNode* result = new (zone) ChoiceNode(2, zone);
       UnicodeRangeSplitter splitter(zone, ranges);
       AddBmpCharacters(compiler, result, on_success, &splitter);
       AddNonBmpSurrogatePairs(compiler, result, on_success, &splitter);
       AddLoneLeadSurrogates(compiler, result, on_success, &splitter);
       AddLoneTrailSurrogates(compiler, result, on_success, &splitter);
+      return result;
     }
-    return result;
   } else {
     return new (zone) TextNode(this, compiler->read_backward(), on_success);
   }
 }
 
 
 int CompareFirstChar(RegExpTree* const* a, RegExpTree* const* b) {
   RegExpAtom* atom1 = (*a)->AsAtom();
   RegExpAtom* atom2 = (*b)->AsAtom();
   uc16 character1 = atom1->data().at(0);
@@ skipping 1677 matching lines @@
 
 
 void RegExpResultsCache::Clear(FixedArray* cache) {
   for (int i = 0; i < kRegExpResultsCacheSize; i++) {
     cache->set(i, Smi::FromInt(0));
   }
 }
 
 }  // namespace internal
 }  // namespace v8