diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9d28400..21265c1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,32 +1,3 @@
-## 2.3.0-dev.XX.0
-(Add new changes here, and they will be copied to the change section for the
- next dev version)
-
-### Core library changes
-
-#### `dart:core`
-
-* **Breaking change**: The `RegExp` interface has been extended with two new
-  constructor named parameters:
-
-  * `unicode:` (`bool`, default: `false`), for Unicode patterns , and
-  * `dotAll:` (`bool`, default: `false`), to change the matching behavior of
-    '.' to also match line terminating characters.
-
-  Appropriate properties for these named parameters have also been added so
-  their use can be detected after construction.
-
-  In addition, `RegExp` methods that originally returned `Match` objects
-  now return a more specific subtype, `RegExpMatch`, which adds two features:
-
-  * `Iterable<String> groupNames`, a property that contains the names of all
-    named capture groups, and
-  * `String namedGroup(String name)`: a method that retrieves the match for
-    the given named capture group
-
-  This change only affects implementers of the `RegExp` interface; current
-  code using Dart regular expressions will not be affected.
-
 ## 2.3.0
 
 The focus in this release is on the new "UI-as-code" language features which
diff --git a/DEPS b/DEPS
index 6e37b9b..0ad497f 100644
--- a/DEPS
+++ b/DEPS
@@ -91,7 +91,6 @@
   "http_retry_tag": "0.1.1",
   "http_tag" : "0.12.0+2",
   "http_throttle_tag" : "1.0.2",
-  "icu_rev" : "c56c671998902fcc4fc9ace88c83daa99f980793",
   "idl_parser_rev": "5fb1ebf49d235b5a70c9f49047e83b0654031eb7",
   "intl_tag": "0.15.7",
   "jinja2_rev": "2222b31554f03e62600cd7e383376a7c187967a1",
@@ -211,10 +210,6 @@
       Var("chromium_git") + "/chromium/src/third_party/ply.git" +
       "@" + Var("ply_rev"),
 
-  Var("dart_root") + "/third_party/icu":
-      Var("chromium_git") + "/chromium/deps/icu.git" +
-      "@" + Var("icu_rev"),
-
   Var("dart_root") + "/tools/idl_parser":
       Var("chromium_git") + "/chromium/src/tools/idl_parser.git" +
       "@" + Var("idl_parser_rev"),
diff --git a/build/config/android/config.gni b/build/config/android/config.gni
index c61d41a..38e3f8e 100644
--- a/build/config/android/config.gni
+++ b/build/config/android/config.gni
@@ -15,9 +15,6 @@
     android_sdk_root = default_android_sdk_root
     android_sdk_version = default_android_sdk_version
     android_sdk_build_tools_version = default_android_sdk_build_tools_version
-
-    # Unused by Dart. Required for GN files in the third_party package ICU.
-    enable_java_templates = false
   }
 
   # Host stuff -----------------------------------------------------------------
diff --git a/build/config/android/rules.gni b/build/config/android/rules.gni
deleted file mode 100644
index f22ba84..0000000
--- a/build/config/android/rules.gni
+++ /dev/null
@@ -1,10 +0,0 @@
-# Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
-# for details. All rights reserved. Use of this source code is governed by a
-# BSD-style license that can be found in the LICENSE file.
-
-# A trivial rules file that allows for the Chromium third_party ICU to
-# be built successfully.
-
-import("//build/config/android/config.gni")
-
-assert(is_android)
diff --git a/build/config/host_byteorder.gni b/build/config/host_byteorder.gni
deleted file mode 100644
index 50ea94b..0000000
--- a/build/config/host_byteorder.gni
+++ /dev/null
@@ -1,30 +0,0 @@
-# Copyright (c) 2017 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-# Originally from v8, included in our repository as the ICU third party
-# import depends on it for building.
-
-# This header file defines the "host_byteorder" variable.
-# Not that this is currently used only for building v8.
-# The chromium code generally assumes little-endianness.
-declare_args() {
-  host_byteorder = "undefined"
-}
-
-# Detect host byteorder
-# ppc64 can be either BE or LE
-if (host_cpu == "ppc64") {
-  if (current_os == "aix") {
-    host_byteorder = "big"
-  } else {
-    # Only use the script when absolutely necessary
-    host_byteorder =
-        exec_script("//build/config/get_host_byteorder.py", [], "trim string")
-  }
-} else if (host_cpu == "ppc" || host_cpu == "s390" || host_cpu == "s390x" ||
-           host_cpu == "mips" || host_cpu == "mips64") {
-  host_byteorder = "big"
-} else {
-  host_byteorder = "little"
-}
diff --git a/pkg/dev_compiler/tool/input_sdk/patch/core_patch.dart b/pkg/dev_compiler/tool/input_sdk/patch/core_patch.dart
index da07a3c..192b5f6 100644
--- a/pkg/dev_compiler/tool/input_sdk/patch/core_patch.dart
+++ b/pkg/dev_compiler/tool/input_sdk/patch/core_patch.dart
@@ -547,15 +547,9 @@
 class RegExp {
   @patch
   factory RegExp(String source,
-          {bool multiLine = false,
-          bool caseSensitive = true,
-          bool unicode = false,
-          bool dotAll = false}) =>
+          {bool multiLine = false, bool caseSensitive = true}) =>
       JSSyntaxRegExp(source,
-          multiLine: multiLine,
-          caseSensitive: caseSensitive,
-          unicode: unicode,
-          dotAll: dotAll);
+          multiLine: multiLine, caseSensitive: caseSensitive);
 
   @patch
   static String escape(String text) => quoteStringForRegExp(text);
diff --git a/pkg/dev_compiler/tool/input_sdk/private/regexp_helper.dart b/pkg/dev_compiler/tool/input_sdk/private/regexp_helper.dart
index 744effc..9206685 100644
--- a/pkg/dev_compiler/tool/input_sdk/private/regexp_helper.dart
+++ b/pkg/dev_compiler/tool/input_sdk/private/regexp_helper.dart
@@ -47,22 +47,18 @@
   var _nativeGlobalRegExp;
   var _nativeAnchoredRegExp;
 
-  String toString() =>
-      'RegExp/$pattern/' + JS('String', '#.flags', _nativeRegExp);
+  String toString() => "RegExp/$pattern/";
 
   JSSyntaxRegExp(String source,
-      {bool multiLine = false,
-      bool caseSensitive = true,
-      bool unicode = false,
-      bool dotAll = false})
+      {bool multiLine = false, bool caseSensitive = true})
       : this.pattern = source,
-        this._nativeRegExp = makeNative(
-            source, multiLine, caseSensitive, unicode, dotAll, false);
+        this._nativeRegExp =
+            makeNative(source, multiLine, caseSensitive, false);
 
   get _nativeGlobalVersion {
     if (_nativeGlobalRegExp != null) return _nativeGlobalRegExp;
-    return _nativeGlobalRegExp = makeNative(
-        pattern, _isMultiLine, _isCaseSensitive, _isUnicode, _isDotAll, true);
+    return _nativeGlobalRegExp =
+        makeNative(pattern, _isMultiLine, _isCaseSensitive, true);
   }
 
   get _nativeAnchoredVersion {
@@ -72,21 +68,17 @@
     // that it tries, and you can see if the original regexp matched, or it
     // was the added zero-width match that matched, by looking at the last
     // capture. If it is a String, the match participated, otherwise it didn't.
-    return _nativeAnchoredRegExp = makeNative("$pattern|()", _isMultiLine,
-        _isCaseSensitive, _isUnicode, _isDotAll, true);
+    return _nativeAnchoredRegExp =
+        makeNative("$pattern|()", _isMultiLine, _isCaseSensitive, true);
   }
 
   bool get _isMultiLine => JS("bool", "#.multiline", _nativeRegExp);
   bool get _isCaseSensitive => JS("bool", "!#.ignoreCase", _nativeRegExp);
-  bool get _isUnicode => JS("bool", "#.unicode", _nativeRegExp);
-  bool get _isDotAll => JS("bool", "#.dotAll", _nativeRegExp);
 
   static makeNative(@nullCheck String source, bool multiLine,
-      bool caseSensitive, bool unicode, bool dotAll, bool global) {
+      bool caseSensitive, bool global) {
     String m = multiLine ? 'm' : '';
     String i = caseSensitive ? '' : 'i';
-    String u = unicode ? 'u' : '';
-    String s = dotAll ? 's' : '';
     String g = global ? 'g' : '';
     // We're using the JavaScript's try catch instead of the Dart one
     // to avoid dragging in Dart runtime support just because of using
@@ -95,7 +87,7 @@
         '',
         '(function() {'
         'try {'
-        'return new RegExp(#, # + # + # + # + #);'
+        'return new RegExp(#, # + # + #);'
         '} catch (e) {'
         'return e;'
         '}'
@@ -103,8 +95,6 @@
         source,
         m,
         i,
-        u,
-        s,
         g);
     if (JS('bool', '# instanceof RegExp', regexp)) return regexp;
     // The returned value is the JavaScript exception. Turn it into a
@@ -113,7 +103,7 @@
     throw FormatException("Illegal RegExp pattern: $source, $errorMessage");
   }
 
-  RegExpMatch firstMatch(@nullCheck String string) {
+  Match firstMatch(@nullCheck String string) {
     List m = JS('JSExtendableArray|Null', r'#.exec(#)', _nativeRegExp, string);
     if (m == null) return null;
     return _MatchImplementation(this, JSArray<String>.of(m));
@@ -130,7 +120,7 @@
     return null;
   }
 
-  Iterable<RegExpMatch> allMatches(@nullCheck String string,
+  Iterable<Match> allMatches(@nullCheck String string,
       [@nullCheck int start = 0]) {
     if (start < 0 || start > string.length) {
       throw RangeError.range(start, 0, string.length);
@@ -138,7 +128,7 @@
     return _AllMatchesIterable(this, string, start);
   }
 
-  RegExpMatch _execGlobal(String string, int start) {
+  Match _execGlobal(String string, int start) {
     Object regexp = _nativeGlobalVersion;
     JS("void", "#.lastIndex = #", regexp, start);
     List match = JS("JSExtendableArray|Null", "#.exec(#)", regexp, string);
@@ -146,7 +136,7 @@
     return _MatchImplementation(this, JSArray<String>.of(match));
   }
 
-  RegExpMatch _execAnchored(String string, int start) {
+  Match _execAnchored(String string, int start) {
     Object regexp = _nativeAnchoredVersion;
     JS("void", "#.lastIndex = #", regexp, start);
     List match = JS("JSExtendableArray|Null", "#.exec(#)", regexp, string);
@@ -158,7 +148,7 @@
     return _MatchImplementation(this, JSArray<String>.of(match));
   }
 
-  RegExpMatch matchAsPrefix(String string, [int start = 0]) {
+  Match matchAsPrefix(String string, [int start = 0]) {
     if (start < 0 || start > string.length) {
       throw RangeError.range(start, 0, string.length);
     }
@@ -167,8 +157,6 @@
 
   bool get isMultiLine => _isMultiLine;
   bool get isCaseSensitive => _isCaseSensitive;
-  bool get isUnicode => _isUnicode;
-  bool get isDotAll => _isDotAll;
 }
 
 class _MatchImplementation implements RegExpMatch {
@@ -219,34 +207,25 @@
   }
 }
 
-class _AllMatchesIterable extends IterableBase<RegExpMatch> {
+class _AllMatchesIterable extends IterableBase<Match> {
   final JSSyntaxRegExp _re;
   final String _string;
   final int _start;
 
   _AllMatchesIterable(this._re, this._string, this._start);
 
-  Iterator<RegExpMatch> get iterator =>
-      _AllMatchesIterator(_re, _string, _start);
+  Iterator<Match> get iterator => _AllMatchesIterator(_re, _string, _start);
 }
 
-class _AllMatchesIterator implements Iterator<RegExpMatch> {
+class _AllMatchesIterator implements Iterator<Match> {
   final JSSyntaxRegExp _regExp;
   String _string;
   int _nextIndex;
-  RegExpMatch _current;
+  Match _current;
 
   _AllMatchesIterator(this._regExp, this._string, this._nextIndex);
 
-  RegExpMatch get current => _current;
-
-  static bool _isLeadSurrogate(int c) {
-    return c >= 0xd800 && c <= 0xdbff;
-  }
-
-  static bool _isTrailSurrogate(int c) {
-    return c >= 0xdc00 && c <= 0xdfff;
-  }
+  Match get current => _current;
 
   bool moveNext() {
     if (_string == null) return false;
@@ -256,15 +235,6 @@
         _current = match;
         int nextIndex = match.end;
         if (match.start == nextIndex) {
-          // Zero-width match. Advance by one more, unless the regexp
-          // is in unicode mode and it would put us within a surrogate
-          // pair. In that case, advance past the code point as a whole.
-          if (_regExp.isUnicode &&
-              _nextIndex + 1 < _string.length &&
-              _isLeadSurrogate(_string.codeUnitAt(_nextIndex)) &&
-              _isTrailSurrogate(_string.codeUnitAt(_nextIndex + 1))) {
-            nextIndex++;
-          }
           nextIndex++;
         }
         _nextIndex = nextIndex;
@@ -278,6 +248,6 @@
 }
 
 /** Find the first match of [regExp] in [string] at or after [start]. */
-RegExpMatch firstMatchAfter(JSSyntaxRegExp regExp, String string, int start) {
+Match firstMatchAfter(JSSyntaxRegExp regExp, String string, int start) {
   return regExp._execGlobal(string, start);
 }
diff --git a/runtime/lib/regexp.cc b/runtime/lib/regexp.cc
index eb4237c..4dba76e 100644
--- a/runtime/lib/regexp.cc
+++ b/runtime/lib/regexp.cc
@@ -14,7 +14,7 @@
 
 namespace dart {
 
-DEFINE_NATIVE_ENTRY(RegExp_factory, 0, 6) {
+DEFINE_NATIVE_ENTRY(RegExp_factory, 0, 4) {
   ASSERT(
       TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)).IsNull());
   GET_NON_NULL_NATIVE_ARGUMENT(String, pattern, arguments->NativeArgAt(1));
@@ -22,30 +22,17 @@
                                arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, handle_case_sensitive,
                                arguments->NativeArgAt(3));
-  GET_NON_NULL_NATIVE_ARGUMENT(Instance, handle_unicode,
-                               arguments->NativeArgAt(4));
-  GET_NON_NULL_NATIVE_ARGUMENT(Instance, handle_dot_all,
-                               arguments->NativeArgAt(5));
   bool ignore_case = handle_case_sensitive.raw() != Bool::True().raw();
   bool multi_line = handle_multi_line.raw() == Bool::True().raw();
-  bool unicode = handle_unicode.raw() == Bool::True().raw();
-  bool dot_all = handle_dot_all.raw() == Bool::True().raw();
-
-  RegExpFlags flags;
-
-  if (ignore_case) flags.SetIgnoreCase();
-  if (multi_line) flags.SetMultiLine();
-  if (unicode) flags.SetUnicode();
-  if (dot_all) flags.SetDotAll();
 
   // Parse the pattern once in order to throw any format exceptions within
   // the factory constructor. It is parsed again upon compilation.
   RegExpCompileData compileData;
   // Throws an exception on parsing failure.
-  RegExpParser::ParseRegExp(pattern, flags, &compileData);
+  RegExpParser::ParseRegExp(pattern, multi_line, &compileData);
 
   // Create a RegExp object containing only the initial parameters.
-  return RegExpEngine::CreateRegExp(thread, pattern, flags);
+  return RegExpEngine::CreateRegExp(thread, pattern, multi_line, ignore_case);
 }
 
 DEFINE_NATIVE_ENTRY(RegExp_getPattern, 0, 1) {
@@ -57,25 +44,13 @@
 DEFINE_NATIVE_ENTRY(RegExp_getIsMultiLine, 0, 1) {
   const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
   ASSERT(!regexp.IsNull());
-  return Bool::Get(regexp.flags().IsMultiLine()).raw();
-}
-
-DEFINE_NATIVE_ENTRY(RegExp_getIsUnicode, 0, 1) {
-  const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
-  ASSERT(!regexp.IsNull());
-  return Bool::Get(regexp.flags().IsUnicode()).raw();
-}
-
-DEFINE_NATIVE_ENTRY(RegExp_getIsDotAll, 0, 1) {
-  const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
-  ASSERT(!regexp.IsNull());
-  return Bool::Get(regexp.flags().IsDotAll()).raw();
+  return Bool::Get(regexp.is_multi_line()).raw();
 }
 
 DEFINE_NATIVE_ENTRY(RegExp_getIsCaseSensitive, 0, 1) {
   const RegExp& regexp = RegExp::CheckedHandle(zone, arguments->NativeArgAt(0));
   ASSERT(!regexp.IsNull());
-  return Bool::Get(!regexp.flags().IgnoreCase()).raw();
+  return Bool::Get(!regexp.is_ignore_case()).raw();
 }
 
 DEFINE_NATIVE_ENTRY(RegExp_getGroupCount, 0, 1) {
diff --git a/runtime/lib/regexp_patch.dart b/runtime/lib/regexp_patch.dart
index 35a13b1..4eac446 100644
--- a/runtime/lib/regexp_patch.dart
+++ b/runtime/lib/regexp_patch.dart
@@ -8,12 +8,8 @@
 class RegExp {
   @patch
   factory RegExp(String source,
-      {bool multiLine: false,
-      bool caseSensitive: true,
-      bool unicode: false,
-      bool dotAll: false}) {
-    _RegExpHashKey key =
-        new _RegExpHashKey(source, multiLine, caseSensitive, unicode, dotAll);
+      {bool multiLine: false, bool caseSensitive: true}) {
+    _RegExpHashKey key = new _RegExpHashKey(source, multiLine, caseSensitive);
     _RegExpHashValue value = _cache[key];
 
     if (value == null) {
@@ -25,10 +21,7 @@
 
       value = new _RegExpHashValue(
           new _RegExp(source,
-              multiLine: multiLine,
-              caseSensitive: caseSensitive,
-              unicode: unicode,
-              dotAll: dotAll),
+              multiLine: multiLine, caseSensitive: caseSensitive),
           key);
       _cache[key] = value;
     } else {
@@ -121,20 +114,15 @@
   final String pattern;
   final bool multiLine;
   final bool caseSensitive;
-  final bool unicode;
-  final bool dotAll;
 
-  _RegExpHashKey(this.pattern, this.multiLine, this.caseSensitive, this.unicode,
-      this.dotAll);
+  _RegExpHashKey(this.pattern, this.multiLine, this.caseSensitive);
 
   int get hashCode => pattern.hashCode;
   bool operator ==(that) {
     return (that is _RegExpHashKey) &&
         (this.pattern == that.pattern) &&
         (this.multiLine == that.multiLine) &&
-        (this.caseSensitive == that.caseSensitive) &&
-        (this.unicode == that.unicode) &&
-        (this.dotAll == that.dotAll);
+        (this.caseSensitive == that.caseSensitive);
   }
 }
 
@@ -212,11 +200,9 @@
 class _RegExp implements RegExp {
   factory _RegExp(String pattern,
       {bool multiLine: false,
-      bool caseSensitive: true,
-      bool unicode: false,
-      bool dotAll: false}) native "RegExp_factory";
+      bool caseSensitive: true}) native "RegExp_factory";
 
-  RegExpMatch firstMatch(String str) {
+  Match firstMatch(String str) {
     if (str is! String) throw new ArgumentError(str);
     List match = _ExecuteMatch(str, 0);
     if (match == null) {
@@ -225,7 +211,7 @@
     return new _RegExpMatch(this, str, match);
   }
 
-  Iterable<RegExpMatch> allMatches(String string, [int start = 0]) {
+  Iterable<Match> allMatches(String string, [int start = 0]) {
     if (string is! String) throw new ArgumentError(string);
     if (start is! int) throw new ArgumentError(start);
     if (0 > start || start > string.length) {
@@ -234,7 +220,7 @@
     return new _AllMatchesIterable(this, string, start);
   }
 
-  RegExpMatch matchAsPrefix(String string, [int start = 0]) {
+  Match matchAsPrefix(String string, [int start = 0]) {
     if (string is! String) throw new ArgumentError(string);
     if (start is! int) throw new ArgumentError(start);
     if (start < 0 || start > string.length) {
@@ -266,10 +252,6 @@
 
   bool get isCaseSensitive native "RegExp_getIsCaseSensitive";
 
-  bool get isUnicode native "RegExp_getIsUnicode";
-
-  bool get isDotAll native "RegExp_getIsDotAll";
-
   int get _groupCount native "RegExp_getGroupCount";
 
   // Returns a List [String, int, String, int, ...] where each
@@ -345,34 +327,25 @@
       native "RegExp_ExecuteMatchSticky";
 }
 
-class _AllMatchesIterable extends IterableBase<RegExpMatch> {
+class _AllMatchesIterable extends IterableBase<Match> {
   final _RegExp _re;
   final String _str;
   final int _start;
 
   _AllMatchesIterable(this._re, this._str, this._start);
 
-  Iterator<RegExpMatch> get iterator =>
-      new _AllMatchesIterator(_re, _str, _start);
+  Iterator<Match> get iterator => new _AllMatchesIterator(_re, _str, _start);
 }
 
-class _AllMatchesIterator implements Iterator<RegExpMatch> {
+class _AllMatchesIterator implements Iterator<Match> {
   final String _str;
   int _nextIndex;
   _RegExp _re;
-  RegExpMatch _current;
+  Match _current;
 
   _AllMatchesIterator(this._re, this._str, this._nextIndex);
 
-  RegExpMatch get current => _current;
-
-  static bool _isLeadSurrogate(int c) {
-    return c >= 0xd800 && c <= 0xdbff;
-  }
-
-  static bool _isTrailSurrogate(int c) {
-    return c >= 0xdc00 && c <= 0xdfff;
-  }
+  Match get current => _current;
 
   bool moveNext() {
     if (_re == null) return false; // Cleared after a failed match.
@@ -382,15 +355,7 @@
         _current = new _RegExpMatch(_re, _str, match);
         _nextIndex = _current.end;
         if (_nextIndex == _current.start) {
-          // Zero-width match. Advance by one more, unless the regexp
-          // is in unicode mode and it would put us within a surrogate
-          // pair. In that case, advance past the code point as a whole.
-          if (_re.isUnicode &&
-              _nextIndex + 1 < _str.length &&
-              _isLeadSurrogate(_str.codeUnitAt(_nextIndex)) &&
-              _isTrailSurrogate(_str.codeUnitAt(_nextIndex + 1))) {
-            _nextIndex++;
-          }
+          // Zero-width match. Advance by one more.
           _nextIndex++;
         }
         return true;
diff --git a/runtime/platform/splay-tree-inl.h b/runtime/platform/splay-tree-inl.h
deleted file mode 100644
index 7322a56..0000000
--- a/runtime/platform/splay-tree-inl.h
+++ /dev/null
@@ -1,273 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.
-// Copyright 2010 the V8 project authors.
-// Please see the AUTHORS file for details. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// The original file can be found at:
-// https://github.com/v8/v8/blob/master/src/splay-tree-inl.h
-
-#ifndef RUNTIME_PLATFORM_SPLAY_TREE_INL_H_
-#define RUNTIME_PLATFORM_SPLAY_TREE_INL_H_
-
-#include <vector>
-
-#include "platform/splay-tree.h"
-
-namespace dart {
-
-template <typename Config, class B, class Allocator>
-SplayTree<Config, B, Allocator>::~SplayTree() {
-  NodeDeleter deleter;
-  ForEachNode(&deleter);
-}
-
-template <typename Config, class B, class Allocator>
-bool SplayTree<Config, B, Allocator>::Insert(const Key& key, Locator* locator) {
-  if (is_empty()) {
-    // If the tree is empty, insert the new node.
-    root_ = new (allocator_) Node(key, Config::NoValue());
-  } else {
-    // Splay on the key to move the last node on the search path
-    // for the key to the root of the tree.
-    Splay(key);
-    // Ignore repeated insertions with the same key.
-    int cmp = Config::Compare(key, root_->key_);
-    if (cmp == 0) {
-      locator->bind(root_);
-      return false;
-    }
-    // Insert the new node.
-    Node* node = new (allocator_) Node(key, Config::NoValue());
-    InsertInternal(cmp, node);
-  }
-  locator->bind(root_);
-  return true;
-}
-
-template <typename Config, class B, class Allocator>
-void SplayTree<Config, B, Allocator>::InsertInternal(int cmp, Node* node) {
-  if (cmp > 0) {
-    node->left_ = root_;
-    node->right_ = root_->right_;
-    root_->right_ = nullptr;
-  } else {
-    node->right_ = root_;
-    node->left_ = root_->left_;
-    root_->left_ = nullptr;
-  }
-  root_ = node;
-}
-
-template <typename Config, class B, class Allocator>
-bool SplayTree<Config, B, Allocator>::FindInternal(const Key& key) {
-  if (is_empty()) return false;
-  Splay(key);
-  return Config::Compare(key, root_->key_) == 0;
-}
-
-template <typename Config, class B, class Allocator>
-bool SplayTree<Config, B, Allocator>::Contains(const Key& key) {
-  return FindInternal(key);
-}
-
-template <typename Config, class B, class Allocator>
-bool SplayTree<Config, B, Allocator>::Find(const Key& key, Locator* locator) {
-  if (FindInternal(key)) {
-    locator->bind(root_);
-    return true;
-  } else {
-    return false;
-  }
-}
-
-template <typename Config, class B, class Allocator>
-bool SplayTree<Config, B, Allocator>::FindGreatestLessThan(const Key& key,
-                                                           Locator* locator) {
-  if (is_empty()) return false;
-  // Splay on the key to move the node with the given key or the last
-  // node on the search path to the top of the tree.
-  Splay(key);
-  // Now the result is either the root node or the greatest node in
-  // the left subtree.
-  int cmp = Config::Compare(root_->key_, key);
-  if (cmp <= 0) {
-    locator->bind(root_);
-    return true;
-  } else {
-    Node* temp = root_;
-    root_ = root_->left_;
-    bool result = FindGreatest(locator);
-    root_ = temp;
-    return result;
-  }
-}
-
-template <typename Config, class B, class Allocator>
-bool SplayTree<Config, B, Allocator>::FindLeastGreaterThan(const Key& key,
-                                                           Locator* locator) {
-  if (is_empty()) return false;
-  // Splay on the key to move the node with the given key or the last
-  // node on the search path to the top of the tree.
-  Splay(key);
-  // Now the result is either the root node or the least node in
-  // the right subtree.
-  int cmp = Config::Compare(root_->key_, key);
-  if (cmp >= 0) {
-    locator->bind(root_);
-    return true;
-  } else {
-    Node* temp = root_;
-    root_ = root_->right_;
-    bool result = FindLeast(locator);
-    root_ = temp;
-    return result;
-  }
-}
-
-template <typename Config, class B, class Allocator>
-bool SplayTree<Config, B, Allocator>::FindGreatest(Locator* locator) {
-  if (is_empty()) return false;
-  Node* current = root_;
-  while (current->right_ != nullptr)
-    current = current->right_;
-  locator->bind(current);
-  return true;
-}
-
-template <typename Config, class B, class Allocator>
-bool SplayTree<Config, B, Allocator>::FindLeast(Locator* locator) {
-  if (is_empty()) return false;
-  Node* current = root_;
-  while (current->left_ != nullptr)
-    current = current->left_;
-  locator->bind(current);
-  return true;
-}
-
-template <typename Config, class B, class Allocator>
-bool SplayTree<Config, B, Allocator>::Move(const Key& old_key,
-                                           const Key& new_key) {
-  if (!FindInternal(old_key)) return false;
-  Node* node_to_move = root_;
-  RemoveRootNode(old_key);
-  Splay(new_key);
-  int cmp = Config::Compare(new_key, root_->key_);
-  if (cmp == 0) {
-    // A node with the target key already exists.
-    delete node_to_move;
-    return false;
-  }
-  node_to_move->key_ = new_key;
-  InsertInternal(cmp, node_to_move);
-  return true;
-}
-
-template <typename Config, class B, class Allocator>
-bool SplayTree<Config, B, Allocator>::Remove(const Key& key) {
-  if (!FindInternal(key)) return false;
-  Node* node_to_remove = root_;
-  RemoveRootNode(key);
-  delete node_to_remove;
-  return true;
-}
-
-template <typename Config, class B, class Allocator>
-void SplayTree<Config, B, Allocator>::RemoveRootNode(const Key& key) {
-  if (root_->left_ == nullptr) {
-    // No left child, so the new tree is just the right child.
-    root_ = root_->right_;
-  } else {
-    // Left child exists.
-    Node* right = root_->right_;
-    // Make the original left child the new root.
-    root_ = root_->left_;
-    // Splay to make sure that the new root has an empty right child.
-    Splay(key);
-    // Insert the original right child as the right child of the new
-    // root.
-    root_->right_ = right;
-  }
-}
-
-template <typename Config, class B, class Allocator>
-void SplayTree<Config, B, Allocator>::Splay(const Key& key) {
-  if (is_empty()) return;
-  Node dummy_node(Config::kNoKey, Config::NoValue());
-  // Create a dummy node.  The use of the dummy node is a bit
-  // counter-intuitive: The right child of the dummy node will hold
-  // the L tree of the algorithm.  The left child of the dummy node
-  // will hold the R tree of the algorithm.  Using a dummy node, left
-  // and right will always be nodes and we avoid special cases.
-  Node* dummy = &dummy_node;
-  Node* left = dummy;
-  Node* right = dummy;
-  Node* current = root_;
-  while (true) {
-    int cmp = Config::Compare(key, current->key_);
-    if (cmp < 0) {
-      if (current->left_ == nullptr) break;
-      if (Config::Compare(key, current->left_->key_) < 0) {
-        // Rotate right.
-        Node* temp = current->left_;
-        current->left_ = temp->right_;
-        temp->right_ = current;
-        current = temp;
-        if (current->left_ == nullptr) break;
-      }
-      // Link right.
-      right->left_ = current;
-      right = current;
-      current = current->left_;
-    } else if (cmp > 0) {
-      if (current->right_ == nullptr) break;
-      if (Config::Compare(key, current->right_->key_) > 0) {
-        // Rotate left.
-        Node* temp = current->right_;
-        current->right_ = temp->left_;
-        temp->left_ = current;
-        current = temp;
-        if (current->right_ == nullptr) break;
-      }
-      // Link left.
-      left->right_ = current;
-      left = current;
-      current = current->right_;
-    } else {
-      break;
-    }
-  }
-  // Assemble.
-  left->right_ = current->left_;
-  right->left_ = current->right_;
-  current->left_ = dummy->right_;
-  current->right_ = dummy->left_;
-  root_ = current;
-}
-
-template <typename Config, class B, class Allocator>
-template <class Callback>
-void SplayTree<Config, B, Allocator>::ForEach(Callback* callback) {
-  NodeToPairAdaptor<Callback> callback_adaptor(callback);
-  ForEachNode(&callback_adaptor);
-}
-
-template <typename Config, class B, class Allocator>
-template <class Callback>
-void SplayTree<Config, B, Allocator>::ForEachNode(Callback* callback) {
-  if (root_ == nullptr) return;
-  // Pre-allocate some space for tiny trees.
-  std::vector<Node*> nodes_to_visit;
-  nodes_to_visit.push_back(root_);
-  size_t pos = 0;
-  while (pos < nodes_to_visit.size()) {
-    Node* node = nodes_to_visit[pos++];
-    if (node->left() != nullptr) nodes_to_visit.push_back(node->left());
-    if (node->right() != nullptr) nodes_to_visit.push_back(node->right());
-    callback->Call(node);
-  }
-}
-
-}  // namespace dart
-
-#endif  // RUNTIME_PLATFORM_SPLAY_TREE_INL_H_
diff --git a/runtime/platform/splay-tree.h b/runtime/platform/splay-tree.h
deleted file mode 100644
index a85488b..0000000
--- a/runtime/platform/splay-tree.h
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.
-// Copyright 2010 the V8 project authors.
-// Please see the AUTHORS file for details. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// The original file can be found at:
-// https://github.com/v8/v8/blob/master/src/splay-tree.h
-
-#ifndef RUNTIME_PLATFORM_SPLAY_TREE_H_
-#define RUNTIME_PLATFORM_SPLAY_TREE_H_
-
-#include "platform/allocation.h"
-
-namespace dart {
-
-// A splay tree.  The config type parameter encapsulates the different
-// configurations of a concrete splay tree:
-//
-//   typedef Key: the key type
-//   typedef Value: the value type
-//   static const Key kNoKey: the dummy key used when no key is set
-//   static Value kNoValue(): the dummy value used to initialize nodes
-//   static int (Compare)(Key& a, Key& b) -> {-1, 0, 1}: comparison function
-//
-// The tree is also parameterized by an allocation policy
-// (Allocator). The policy is used for allocating lists in the C free
-// store or the zone; see zone.h.
-
-template <typename Config, class B, class Allocator>
-class SplayTree : public B {
- public:
-  typedef typename Config::Key Key;
-  typedef typename Config::Value Value;
-
-  class Locator;
-
-  explicit SplayTree(Allocator* allocator)
-      : root_(nullptr), allocator_(allocator) {}
-  ~SplayTree();
-
-  Allocator* allocator() { return allocator_; }
-
-  // Checks if there is a mapping for the key.
-  bool Contains(const Key& key);
-
-  // Inserts the given key in this tree with the given value.  Returns
-  // true if a node was inserted, otherwise false.  If found the locator
-  // is enabled and provides access to the mapping for the key.
-  bool Insert(const Key& key, Locator* locator);
-
-  // Looks up the key in this tree and returns true if it was found,
-  // otherwise false.  If the node is found the locator is enabled and
-  // provides access to the mapping for the key.
-  bool Find(const Key& key, Locator* locator);
-
-  // Finds the mapping with the greatest key less than or equal to the
-  // given key.
-  bool FindGreatestLessThan(const Key& key, Locator* locator);
-
-  // Find the mapping with the greatest key in this tree.
-  bool FindGreatest(Locator* locator);
-
-  // Finds the mapping with the least key greater than or equal to the
-  // given key.
-  bool FindLeastGreaterThan(const Key& key, Locator* locator);
-
-  // Find the mapping with the least key in this tree.
-  bool FindLeast(Locator* locator);
-
-  // Move the node from one key to another.
-  bool Move(const Key& old_key, const Key& new_key);
-
-  // Remove the node with the given key from the tree.
-  bool Remove(const Key& key);
-
-  // Remove all keys from the tree.
-  void Clear() { ResetRoot(); }
-
-  bool is_empty() { return root_ == nullptr; }
-
-  // Perform the splay operation for the given key. Moves the node with
-  // the given key to the top of the tree.  If no node has the given
-  // key, the last node on the search path is moved to the top of the
-  // tree.
-  void Splay(const Key& key);
-
-  class Node : public B {
-   public:
-    Node(const Key& key, const Value& value)
-        : key_(key), value_(value), left_(nullptr), right_(nullptr) {}
-
-    Key key() { return key_; }
-    Value value() { return value_; }
-    Node* left() { return left_; }
-    Node* right() { return right_; }
-
-   private:
-    friend class SplayTree;
-    friend class Locator;
-    Key key_;
-    Value value_;
-    Node* left_;
-    Node* right_;
-  };
-
-  // A locator provides access to a node in the tree without actually
-  // exposing the node.
-  class Locator : public B {
-   public:
-    explicit Locator(Node* node) : node_(node) {}
-    Locator() : node_(nullptr) {}
-    const Key& key() { return node_->key_; }
-    Value& value() { return node_->value_; }
-    void set_value(const Value& value) { node_->value_ = value; }
-    inline void bind(Node* node) { node_ = node; }
-
-   private:
-    Node* node_;
-  };
-
-  template <class Callback>
-  void ForEach(Callback* callback);
-
- protected:
-  // Resets tree root. Existing nodes become unreachable.
-  void ResetRoot() { root_ = nullptr; }
-
- private:
-  // Search for a node with a given key. If found, root_ points
-  // to the node.
-  bool FindInternal(const Key& key);
-
-  // Inserts a node assuming that root_ is already set up.
-  void InsertInternal(int cmp, Node* node);
-
-  // Removes root_ node.
-  void RemoveRootNode(const Key& key);
-
-  template <class Callback>
-  class NodeToPairAdaptor : public B {
-   public:
-    explicit NodeToPairAdaptor(Callback* callback) : callback_(callback) {}
-    void Call(Node* node) { callback_->Call(node->key(), node->value()); }
-
-   private:
-    Callback* callback_;
-
-    DISALLOW_COPY_AND_ASSIGN(NodeToPairAdaptor);
-  };
-
-  class NodeDeleter : public B {
-   public:
-    NodeDeleter() = default;
-    void Call(Node* node) { delete node; }
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(NodeDeleter);
-  };
-
-  template <class Callback>
-  void ForEachNode(Callback* callback);
-
-  Node* root_;
-  Allocator* allocator_;
-
-  DISALLOW_COPY_AND_ASSIGN(SplayTree);
-};
-
-}  // namespace dart
-
-#endif  // RUNTIME_PLATFORM_SPLAY_TREE_H_
diff --git a/runtime/platform/unicode.h b/runtime/platform/unicode.h
index b784823..f3c0778 100644
--- a/runtime/platform/unicode.h
+++ b/runtime/platform/unicode.h
@@ -15,7 +15,6 @@
 class Utf : AllStatic {
  public:
   static const int32_t kMaxCodePoint = 0x10FFFF;
-  static const int32_t kInvalidChar = 0xFFFFFFFF;
 
   static bool IsLatin1(int32_t code_point) {
     return (code_point >= 0) && (code_point <= 0xFF);
@@ -30,7 +29,7 @@
   }
 
   // Returns true if the code point value is above Plane 17.
-  static bool IsOutOfRange(int32_t code_point) {
+  static bool IsOutOfRange(intptr_t code_point) {
     return (code_point < 0) || (code_point > kMaxCodePoint);
   }
 };
@@ -57,11 +56,11 @@
   static intptr_t Length(const String& str);
 
   static intptr_t Encode(int32_t ch, char* dst);
-  static intptr_t Encode(const String& src, char* dst, intptr_t len);
 
   static intptr_t Decode(const uint8_t* utf8_array,
                          intptr_t array_len,
                          int32_t* ch);
+  static intptr_t Encode(const String& src, char* dst, intptr_t len);
 
   static bool DecodeToLatin1(const uint8_t* utf8_array,
                              intptr_t array_len,
@@ -153,10 +152,6 @@
   static void Encode(int32_t codepoint, uint16_t* dst);
 
   static const int32_t kMaxCodeUnit = 0xFFFF;
-  static const int32_t kLeadSurrogateStart = 0xD800;
-  static const int32_t kLeadSurrogateEnd = 0xDBFF;
-  static const int32_t kTrailSurrogateStart = 0xDC00;
-  static const int32_t kTrailSurrogateEnd = 0xDFFF;
 
  private:
   static const int32_t kLeadSurrogateOffset = (0xD800 - (0x10000 >> 10));
@@ -192,11 +187,11 @@
 
   // The size of the stage 1 index.
   // TODO(cshapiro): improve indexing so this value is unnecessary.
-  static const intptr_t kStage1Size = 261;
+  static const int kStage1Size = 261;
 
   // The size of a stage 2 block in bytes.
-  static const intptr_t kBlockSizeLog2 = 8;
-  static const intptr_t kBlockSize = 1 << kBlockSizeLog2;
+  static const int kBlockSizeLog2 = 8;
+  static const int kBlockSize = 1 << kBlockSizeLog2;
 
   static int32_t Convert(int32_t ch, int32_t mapping) {
     if (Utf::IsLatin1(ch)) {
@@ -227,25 +222,6 @@
   static const int32_t stage2_exception_[][2];
 };
 
-class Latin1 {
- public:
-  static const int32_t kMaxChar = 0xff;
-  // Convert the character to Latin-1 case equivalent if possible.
-  static inline uint16_t TryConvertToLatin1(uint16_t c) {
-    switch (c) {
-      // This are equivalent characters in unicode.
-      case 0x39c:
-      case 0x3bc:
-        return 0xb5;
-      // This is an uppercase of a Latin-1 character
-      // outside of Latin-1.
-      case 0x178:
-        return 0xff;
-    }
-    return c;
-  }
-};
-
 }  // namespace dart
 
 #endif  // RUNTIME_PLATFORM_UNICODE_H_
diff --git a/runtime/platform/utils.h b/runtime/platform/utils.h
index 993ff26..9f72205 100644
--- a/runtime/platform/utils.h
+++ b/runtime/platform/utils.h
@@ -203,14 +203,7 @@
     return (static_cast<int64_t>(high) << 32) | (low & 0x0ffffffffLL);
   }
 
-  static inline constexpr bool IsAlphaNumeric(uint32_t c) {
-    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
-           IsDecimalDigit(c);
-  }
-
-  static inline constexpr bool IsDecimalDigit(uint32_t c) {
-    return ('0' <= c) && (c <= '9');
-  }
+  static bool IsDecimalDigit(char c) { return ('0' <= c) && (c <= '9'); }
 
   static bool IsHexDigit(char c) {
     return IsDecimalDigit(c) || (('A' <= c) && (c <= 'F')) ||
diff --git a/runtime/vm/BUILD.gn b/runtime/vm/BUILD.gn
index f2737c9..680ab84 100644
--- a/runtime/vm/BUILD.gn
+++ b/runtime/vm/BUILD.gn
@@ -60,9 +60,8 @@
 
 library_for_all_configs("libdart_vm") {
   target_type = "source_set"
-  extra_deps = [ "//third_party/icu" ]
   if (is_fuchsia) {
-    extra_deps += [
+    extra_deps = [
       # TODO(US-399): Remove time_service specific code when it is no longer
       # necessary.
       "//sdk/lib/sys/cpp",
diff --git a/runtime/vm/bootstrap_natives.h b/runtime/vm/bootstrap_natives.h
index 34cfbc4..da1dc36 100644
--- a/runtime/vm/bootstrap_natives.h
+++ b/runtime/vm/bootstrap_natives.h
@@ -98,12 +98,10 @@
   V(Double_toStringAsExponential, 2)                                           \
   V(Double_toStringAsPrecision, 2)                                             \
   V(Double_flipSignBit, 1)                                                     \
-  V(RegExp_factory, 6)                                                         \
+  V(RegExp_factory, 4)                                                         \
   V(RegExp_getPattern, 1)                                                      \
   V(RegExp_getIsMultiLine, 1)                                                  \
   V(RegExp_getIsCaseSensitive, 1)                                              \
-  V(RegExp_getIsUnicode, 1)                                                    \
-  V(RegExp_getIsDotAll, 1)                                                     \
   V(RegExp_getGroupCount, 1)                                                   \
   V(RegExp_getGroupNameMap, 1)                                                 \
   V(RegExp_ExecuteMatch, 3)                                                    \
diff --git a/runtime/vm/clustered_snapshot.cc b/runtime/vm/clustered_snapshot.cc
index 033ffbc..4f66027 100644
--- a/runtime/vm/clustered_snapshot.cc
+++ b/runtime/vm/clustered_snapshot.cc
@@ -3630,8 +3630,7 @@
       RawRegExp* regexp = objects_[i];
       AutoTraceObject(regexp);
       WriteFromTo(regexp);
-      s->Write<int32_t>(regexp->ptr()->num_one_byte_registers_);
-      s->Write<int32_t>(regexp->ptr()->num_two_byte_registers_);
+      s->Write<int32_t>(regexp->ptr()->num_registers_);
       s->Write<int8_t>(regexp->ptr()->type_flags_);
     }
   }
@@ -3662,8 +3661,7 @@
       Deserializer::InitializeHeader(regexp, kRegExpCid,
                                      RegExp::InstanceSize());
       ReadFromTo(regexp);
-      regexp->ptr()->num_one_byte_registers_ = d->Read<int32_t>();
-      regexp->ptr()->num_two_byte_registers_ = d->Read<int32_t>();
+      regexp->ptr()->num_registers_ = d->Read<int32_t>();
       regexp->ptr()->type_flags_ = d->Read<int8_t>();
     }
   }
diff --git a/runtime/vm/compiler/backend/constant_propagator.cc b/runtime/vm/compiler/backend/constant_propagator.cc
index acf4f9c..d27b6e2 100644
--- a/runtime/vm/compiler/backend/constant_propagator.cc
+++ b/runtime/vm/compiler/backend/constant_propagator.cc
@@ -1272,8 +1272,8 @@
   }
 }
 
-void ConstantPropagator::VisitCaseInsensitiveCompare(
-    CaseInsensitiveCompareInstr* instr) {
+void ConstantPropagator::VisitCaseInsensitiveCompareUC16(
+    CaseInsensitiveCompareUC16Instr* instr) {
   SetValue(instr, non_constant_);
 }
 
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index dda6e01..4ee0e27 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -5161,6 +5161,10 @@
   return "";
 }
 
+const RuntimeEntry& CaseInsensitiveCompareUC16Instr::TargetFunction() const {
+  return kCaseInsensitiveCompareUC16RuntimeEntry;
+}
+
 TruncDivModInstr::TruncDivModInstr(Value* lhs, Value* rhs, intptr_t deopt_id)
     : TemplateDefinition(deopt_id) {
   SetInputAt(0, lhs);
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
index 4c22692..c5997de 100644
--- a/runtime/vm/compiler/backend/il.h
+++ b/runtime/vm/compiler/backend/il.h
@@ -18,7 +18,6 @@
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/parser.h"
-#include "vm/runtime_entry.h"
 #include "vm/static_type_exactness_state.h"
 #include "vm/token_position.h"
 
@@ -423,7 +422,7 @@
   M(Unbox, kNoGC)                                                              \
   M(BoxInt64, _)                                                               \
   M(UnboxInt64, kNoGC)                                                         \
-  M(CaseInsensitiveCompare, _)                                                 \
+  M(CaseInsensitiveCompareUC16, _)                                             \
   M(BinaryInt64Op, kNoGC)                                                      \
   M(ShiftInt64Op, kNoGC)                                                       \
   M(SpeculativeShiftInt64Op, kNoGC)                                            \
@@ -5955,18 +5954,18 @@
 // Calls into the runtime and performs a case-insensitive comparison of the
 // UTF16 strings (i.e. TwoByteString or ExternalTwoByteString) located at
 // str[lhs_index:lhs_index + length] and str[rhs_index:rhs_index + length].
-// Depending on the runtime entry passed, we will treat the strings as either
-// UCS2 (no surrogate handling) or UTF16 (surrogates handled appropriately).
-class CaseInsensitiveCompareInstr
+//
+// TODO(zerny): Remove this once (if) functions inherited from unibrow
+// are moved to dart code.
+class CaseInsensitiveCompareUC16Instr
     : public TemplateDefinition<4, NoThrow, Pure> {
  public:
-  CaseInsensitiveCompareInstr(Value* str,
-                              Value* lhs_index,
-                              Value* rhs_index,
-                              Value* length,
-                              const RuntimeEntry& entry,
-                              intptr_t cid)
-      : entry_(entry), cid_(cid) {
+  CaseInsensitiveCompareUC16Instr(Value* str,
+                                  Value* lhs_index,
+                                  Value* rhs_index,
+                                  Value* length,
+                                  intptr_t cid)
+      : cid_(cid) {
     ASSERT(cid == kTwoByteStringCid || cid == kExternalTwoByteStringCid);
     ASSERT(index_scale() == 2);
     SetInputAt(0, str);
@@ -5980,7 +5979,7 @@
   Value* rhs_index() const { return inputs_[2]; }
   Value* length() const { return inputs_[3]; }
 
-  const RuntimeEntry& TargetFunction() const { return entry_; }
+  const RuntimeEntry& TargetFunction() const;
   bool IsExternal() const { return cid_ == kExternalTwoByteStringCid; }
   intptr_t class_id() const { return cid_; }
   intptr_t index_scale() const { return Instance::ElementSizeFor(cid_); }
@@ -5989,18 +5988,17 @@
 
   virtual Representation representation() const { return kTagged; }
 
-  DECLARE_INSTRUCTION(CaseInsensitiveCompare)
+  DECLARE_INSTRUCTION(CaseInsensitiveCompareUC16)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
-    return other->AsCaseInsensitiveCompare()->cid_ == cid_;
+    return other->AsCaseInsensitiveCompareUC16()->cid_ == cid_;
   }
 
  private:
-  const RuntimeEntry& entry_;
   const intptr_t cid_;
 
-  DISALLOW_COPY_AND_ASSIGN(CaseInsensitiveCompareInstr);
+  DISALLOW_COPY_AND_ASSIGN(CaseInsensitiveCompareUC16Instr);
 };
 
 // Represents Math's static min and max functions.
diff --git a/runtime/vm/compiler/backend/il_arm.cc b/runtime/vm/compiler/backend/il_arm.cc
index d2c6d25..c7ce0c0 100644
--- a/runtime/vm/compiler/backend/il_arm.cc
+++ b/runtime/vm/compiler/backend/il_arm.cc
@@ -5137,7 +5137,7 @@
   }
 }
 
-LocationSummary* CaseInsensitiveCompareInstr::MakeLocationSummary(
+LocationSummary* CaseInsensitiveCompareUC16Instr::MakeLocationSummary(
     Zone* zone,
     bool opt) const {
   const intptr_t kNumTemps = 0;
@@ -5151,7 +5151,8 @@
   return summary;
 }
 
-void CaseInsensitiveCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CaseInsensitiveCompareUC16Instr::EmitNativeCode(
+    FlowGraphCompiler* compiler) {
   // Call the function.
   __ CallRuntime(TargetFunction(), TargetFunction().argument_count());
 }
diff --git a/runtime/vm/compiler/backend/il_arm64.cc b/runtime/vm/compiler/backend/il_arm64.cc
index f1ac89a..949490b 100644
--- a/runtime/vm/compiler/backend/il_arm64.cc
+++ b/runtime/vm/compiler/backend/il_arm64.cc
@@ -4361,7 +4361,7 @@
   }
 }
 
-LocationSummary* CaseInsensitiveCompareInstr::MakeLocationSummary(
+LocationSummary* CaseInsensitiveCompareUC16Instr::MakeLocationSummary(
     Zone* zone,
     bool opt) const {
   const intptr_t kNumTemps = 0;
@@ -4375,7 +4375,8 @@
   return summary;
 }
 
-void CaseInsensitiveCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CaseInsensitiveCompareUC16Instr::EmitNativeCode(
+    FlowGraphCompiler* compiler) {
   // Call the function.
   __ CallRuntime(TargetFunction(), TargetFunction().argument_count());
 }
diff --git a/runtime/vm/compiler/backend/il_dbc.cc b/runtime/vm/compiler/backend/il_dbc.cc
index dedc848..14d5596 100644
--- a/runtime/vm/compiler/backend/il_dbc.cc
+++ b/runtime/vm/compiler/backend/il_dbc.cc
@@ -55,7 +55,7 @@
 // - Optimized RegExps,
 // - Precompilation.
 #define FOR_EACH_UNREACHABLE_INSTRUCTION(M)                                    \
-  M(CaseInsensitiveCompare)                                                    \
+  M(CaseInsensitiveCompareUC16)                                                \
   M(GenericCheckBound)                                                         \
   M(IndirectGoto)                                                              \
   M(Int64ToDouble)                                                             \
diff --git a/runtime/vm/compiler/backend/il_ia32.cc b/runtime/vm/compiler/backend/il_ia32.cc
index 933a52d..6b8c380 100644
--- a/runtime/vm/compiler/backend/il_ia32.cc
+++ b/runtime/vm/compiler/backend/il_ia32.cc
@@ -4459,7 +4459,7 @@
   }
 }
 
-LocationSummary* CaseInsensitiveCompareInstr::MakeLocationSummary(
+LocationSummary* CaseInsensitiveCompareUC16Instr::MakeLocationSummary(
     Zone* zone,
     bool opt) const {
   const intptr_t kNumTemps = 0;
@@ -4473,7 +4473,8 @@
   return summary;
 }
 
-void CaseInsensitiveCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CaseInsensitiveCompareUC16Instr::EmitNativeCode(
+    FlowGraphCompiler* compiler) {
   // Save ESP. EDI is chosen because it is callee saved so we do not need to
   // back it up before calling into the runtime.
   static const Register kSavedSPReg = EDI;
@@ -4488,7 +4489,7 @@
   // Call the function.
   __ CallRuntime(TargetFunction(), TargetFunction().argument_count());
 
-  // Restore ESP and pop the old value off the stack.
+  // Restore ESP.
   __ movl(ESP, kSavedSPReg);
 }
 
diff --git a/runtime/vm/compiler/backend/il_x64.cc b/runtime/vm/compiler/backend/il_x64.cc
index 2e055a0..2ff2880 100644
--- a/runtime/vm/compiler/backend/il_x64.cc
+++ b/runtime/vm/compiler/backend/il_x64.cc
@@ -4511,7 +4511,7 @@
   }
 }
 
-LocationSummary* CaseInsensitiveCompareInstr::MakeLocationSummary(
+LocationSummary* CaseInsensitiveCompareUC16Instr::MakeLocationSummary(
     Zone* zone,
     bool opt) const {
   const intptr_t kNumTemps = 0;
@@ -4525,7 +4525,8 @@
   return summary;
 }
 
-void CaseInsensitiveCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CaseInsensitiveCompareUC16Instr::EmitNativeCode(
+    FlowGraphCompiler* compiler) {
   // Save RSP. R13 is chosen because it is callee saved so we do not need to
   // back it up before calling into the runtime.
   static const Register kSavedSPReg = R13;
diff --git a/runtime/vm/compiler/backend/type_propagator.cc b/runtime/vm/compiler/backend/type_propagator.cc
index 0352767..0dec0c9 100644
--- a/runtime/vm/compiler/backend/type_propagator.cc
+++ b/runtime/vm/compiler/backend/type_propagator.cc
@@ -1515,7 +1515,7 @@
   return CompileType::FromCid(result_cid_);
 }
 
-CompileType CaseInsensitiveCompareInstr::ComputeType() const {
+CompileType CaseInsensitiveCompareUC16Instr::ComputeType() const {
   return CompileType::FromCid(kBoolCid);
 }
 
diff --git a/runtime/vm/compiler/jit/compiler.cc b/runtime/vm/compiler/jit/compiler.cc
index d334330..db5a703 100644
--- a/runtime/vm/compiler/jit/compiler.cc
+++ b/runtime/vm/compiler/jit/compiler.cc
@@ -166,10 +166,11 @@
   RegExp& regexp = RegExp::Handle(parsed_function->function().regexp());
 
   const String& pattern = String::Handle(regexp.pattern());
+  const bool multiline = regexp.is_multi_line();
 
   RegExpCompileData* compile_data = new (zone) RegExpCompileData();
   // Parsing failures are handled in the RegExp factory constructor.
-  RegExpParser::ParseRegExp(pattern, regexp.flags(), compile_data);
+  RegExpParser::ParseRegExp(pattern, multiline, compile_data);
 
   regexp.set_num_bracket_expressions(compile_data->capture_count);
   regexp.set_capture_name_map(compile_data->capture_name_map);
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index e25bf06..9804f69 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -21751,45 +21751,23 @@
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.set_type(kUninitialized);
-    result.set_flags(RegExpFlags());
-    result.set_num_registers(/*is_one_byte=*/false, -1);
-    result.set_num_registers(/*is_one_byte=*/true, -1);
+    result.set_flags(0);
+    result.set_num_registers(-1);
   }
   return result.raw();
 }
 
-const char* RegExpFlags::ToCString() const {
-  switch (value_ & ~kGlobal) {
-    case kIgnoreCase | kMultiLine | kDotAll | kUnicode:
-      return "imsu";
-    case kIgnoreCase | kMultiLine | kDotAll:
-      return "ims";
-    case kIgnoreCase | kMultiLine | kUnicode:
-      return "imu";
-    case kIgnoreCase | kUnicode | kDotAll:
-      return "ius";
-    case kMultiLine | kDotAll | kUnicode:
-      return "msu";
+const char* RegExp::Flags() const {
+  switch (flags()) {
+    case kGlobal | kIgnoreCase | kMultiLine:
     case kIgnoreCase | kMultiLine:
       return "im";
-    case kIgnoreCase | kDotAll:
-      return "is";
-    case kIgnoreCase | kUnicode:
-      return "iu";
-    case kMultiLine | kDotAll:
-      return "ms";
-    case kMultiLine | kUnicode:
-      return "mu";
-    case kDotAll | kUnicode:
-      return "su";
+    case kGlobal | kIgnoreCase:
     case kIgnoreCase:
       return "i";
+    case kGlobal | kMultiLine:
     case kMultiLine:
       return "m";
-    case kDotAll:
-      return "s";
-    case kUnicode:
-      return "u";
     default:
       break;
   }
@@ -21811,7 +21789,9 @@
     return false;
   }
   // Match the flags.
-  if (flags() != other_js.flags()) {
+  if ((is_global() != other_js.is_global()) ||
+      (is_ignore_case() != other_js.is_ignore_case()) ||
+      (is_multi_line() != other_js.is_multi_line())) {
     return false;
   }
   return true;
@@ -21820,7 +21800,7 @@
 const char* RegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   return OS::SCreate(Thread::Current()->zone(), "RegExp: pattern=%s flags=%s",
-                     str.ToCString(), flags().ToCString());
+                     str.ToCString(), Flags());
 }
 
 RawWeakProperty* WeakProperty::New(Heap::Space space) {
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index f0040cf..5b0bd63 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -9105,55 +9105,6 @@
   friend class Debugger;
 };
 
-class RegExpFlags {
- public:
-  // Flags are passed to a regex object as follows:
-  // 'i': ignore case, 'g': do global matches, 'm': pattern is multi line,
-  // 'u': pattern is full Unicode, not just BMP, 's': '.' in pattern matches
-  // all characters including line terminators.
-  enum Flags {
-    kNone = 0,
-    kGlobal = 1,
-    kIgnoreCase = 2,
-    kMultiLine = 4,
-    kUnicode = 8,
-    kDotAll = 16,
-  };
-
-  static const int kDefaultFlags = 0;
-
-  RegExpFlags() : value_(kDefaultFlags) {}
-  explicit RegExpFlags(int value) : value_(value) {}
-
-  inline bool IsGlobal() const { return (value_ & kGlobal) != 0; }
-  inline bool IgnoreCase() const { return (value_ & kIgnoreCase) != 0; }
-  inline bool IsMultiLine() const { return (value_ & kMultiLine) != 0; }
-  inline bool IsUnicode() const { return (value_ & kUnicode) != 0; }
-  inline bool IsDotAll() const { return (value_ & kDotAll) != 0; }
-
-  inline bool NeedsUnicodeCaseEquivalents() {
-    // Both unicode and ignore_case flags are set. We need to use ICU to find
-    // the closure over case equivalents.
-    return IsUnicode() && IgnoreCase();
-  }
-
-  void SetGlobal() { value_ |= kGlobal; }
-  void SetIgnoreCase() { value_ |= kIgnoreCase; }
-  void SetMultiLine() { value_ |= kMultiLine; }
-  void SetUnicode() { value_ |= kUnicode; }
-  void SetDotAll() { value_ |= kDotAll; }
-
-  const char* ToCString() const;
-
-  int value() const { return value_; }
-
-  bool operator==(const RegExpFlags& other) { return value_ == other.value_; }
-  bool operator!=(const RegExpFlags& other) { return value_ != other.value_; }
-
- private:
-  int value_;
-};
-
 // Internal JavaScript regular expression object.
 class RegExp : public Instance {
  public:
@@ -9167,11 +9118,20 @@
     kComplex = 2,
   };
 
+  // Flags are passed to a regex object as follows:
+  // 'i': ignore case, 'g': do global matches, 'm': pattern is multi line.
+  enum Flags {
+    kNone = 0,
+    kGlobal = 1,
+    kIgnoreCase = 2,
+    kMultiLine = 4,
+  };
+
   enum {
     kTypePos = 0,
     kTypeSize = 2,
     kFlagsPos = 2,
-    kFlagsSize = 5,
+    kFlagsSize = 4,
   };
 
   class TypeBits : public BitField<int8_t, RegExType, kTypePos, kTypeSize> {};
@@ -9181,10 +9141,11 @@
   bool is_simple() const { return (type() == kSimple); }
   bool is_complex() const { return (type() == kComplex); }
 
-  intptr_t num_registers(bool is_one_byte) const {
-    return is_one_byte ? raw_ptr()->num_one_byte_registers_
-                       : raw_ptr()->num_two_byte_registers_;
-  }
+  bool is_global() const { return (flags() & kGlobal); }
+  bool is_ignore_case() const { return (flags() & kIgnoreCase); }
+  bool is_multi_line() const { return (flags() & kMultiLine); }
+
+  intptr_t num_registers() const { return raw_ptr()->num_registers_; }
 
   RawString* pattern() const { return raw_ptr()->pattern_; }
   RawSmi* num_bracket_expressions() const {
@@ -9248,48 +9209,15 @@
 
   void set_num_bracket_expressions(intptr_t value) const;
   void set_capture_name_map(const Array& array) const;
-  void set_is_global() const {
-    RegExpFlags f = flags();
-    f.SetGlobal();
-    set_flags(f);
-  }
-  void set_is_ignore_case() const {
-    RegExpFlags f = flags();
-    f.SetIgnoreCase();
-    set_flags(f);
-  }
-  void set_is_multi_line() const {
-    RegExpFlags f = flags();
-    f.SetMultiLine();
-    set_flags(f);
-  }
-  void set_is_unicode() const {
-    RegExpFlags f = flags();
-    f.SetUnicode();
-    set_flags(f);
-  }
-  void set_is_dot_all() const {
-    RegExpFlags f = flags();
-    f.SetDotAll();
-    set_flags(f);
-  }
+  void set_is_global() const { set_flags(flags() | kGlobal); }
+  void set_is_ignore_case() const { set_flags(flags() | kIgnoreCase); }
+  void set_is_multi_line() const { set_flags(flags() | kMultiLine); }
   void set_is_simple() const { set_type(kSimple); }
   void set_is_complex() const { set_type(kComplex); }
-  void set_num_registers(bool is_one_byte, intptr_t value) const {
-    if (is_one_byte) {
-      StoreNonPointer(&raw_ptr()->num_one_byte_registers_, value);
-    } else {
-      StoreNonPointer(&raw_ptr()->num_two_byte_registers_, value);
-    }
+  void set_num_registers(intptr_t value) const {
+    StoreNonPointer(&raw_ptr()->num_registers_, value);
   }
 
-  RegExpFlags flags() const {
-    return RegExpFlags(FlagsBits::decode(raw_ptr()->type_flags_));
-  }
-  void set_flags(RegExpFlags flags) const {
-    StoreNonPointer(&raw_ptr()->type_flags_,
-                    FlagsBits::update(flags.value(), raw_ptr()->type_flags_));
-  }
   const char* Flags() const;
 
   virtual bool CanonicalizeEquals(const Instance& other) const;
@@ -9305,8 +9233,13 @@
     StoreNonPointer(&raw_ptr()->type_flags_,
                     TypeBits::update(type, raw_ptr()->type_flags_));
   }
+  void set_flags(intptr_t value) const {
+    StoreNonPointer(&raw_ptr()->type_flags_,
+                    FlagsBits::update(value, raw_ptr()->type_flags_));
+  }
 
   RegExType type() const { return TypeBits::decode(raw_ptr()->type_flags_); }
+  intptr_t flags() const { return FlagsBits::decode(raw_ptr()->type_flags_); }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(RegExp, Instance);
   friend class Class;
diff --git a/runtime/vm/object_service.cc b/runtime/vm/object_service.cc
index 9895c42..0397f6e 100644
--- a/runtime/vm/object_service.cc
+++ b/runtime/vm/object_service.cc
@@ -1487,8 +1487,8 @@
     return;
   }
 
-  jsobj.AddProperty("isCaseSensitive", !flags().IgnoreCase());
-  jsobj.AddProperty("isMultiLine", flags().IsMultiLine());
+  jsobj.AddProperty("isCaseSensitive", !is_ignore_case());
+  jsobj.AddProperty("isMultiLine", is_multi_line());
 
   if (!FLAG_interpret_irregexp) {
     Function& func = Function::Handle();
diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h
index 75e7a92..05d60dd 100644
--- a/runtime/vm/raw_object.h
+++ b/runtime/vm/raw_object.h
@@ -2428,17 +2428,11 @@
   VISIT_TO(RawObject*, external_two_byte_sticky_function_)
   RawObject** to_snapshot(Snapshot::Kind kind) { return to(); }
 
-  // The same pattern may use different amount of registers if compiled
-  // for a one-byte target than a two-byte target. For example, we do not
-  // need to allocate registers to check whether the current position is within
-  // a surrogate pair when matching a Unicode pattern against a one-byte string.
-  intptr_t num_one_byte_registers_;
-  intptr_t num_two_byte_registers_;
+  intptr_t num_registers_;
 
   // A bitfield with two fields:
   // type: Uninitialized, simple or complex.
-  // flags: Represents global/local, case insensitive, multiline, unicode,
-  //        dotAll.
+  // flags: Represents global/local, case insensitive, multiline.
   int8_t type_flags_;
 };
 
diff --git a/runtime/vm/raw_object_snapshot.cc b/runtime/vm/raw_object_snapshot.cc
index 72ef288..20e3983 100644
--- a/runtime/vm/raw_object_snapshot.cc
+++ b/runtime/vm/raw_object_snapshot.cc
@@ -2172,9 +2172,7 @@
   *reader->StringHandle() ^= reader->ReadObjectImpl(kAsInlinedObject);
   regex.set_pattern(*reader->StringHandle());
 
-  regex.StoreNonPointer(&regex.raw_ptr()->num_one_byte_registers_,
-                        reader->Read<int32_t>());
-  regex.StoreNonPointer(&regex.raw_ptr()->num_two_byte_registers_,
+  regex.StoreNonPointer(&regex.raw_ptr()->num_registers_,
                         reader->Read<int32_t>());
   regex.StoreNonPointer(&regex.raw_ptr()->type_flags_, reader->Read<int8_t>());
 
@@ -2204,8 +2202,7 @@
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->num_bracket_expressions_);
   writer->WriteObjectImpl(ptr()->pattern_, kAsInlinedObject);
-  writer->Write<int32_t>(ptr()->num_one_byte_registers_);
-  writer->Write<int32_t>(ptr()->num_two_byte_registers_);
+  writer->Write<int32_t>(ptr()->num_registers_);
   writer->Write<int8_t>(ptr()->type_flags_);
 }
 
diff --git a/runtime/vm/regexp.cc b/runtime/vm/regexp.cc
index 23eff8f..dd559bd 100644
--- a/runtime/vm/regexp.cc
+++ b/runtime/vm/regexp.cc
@@ -4,11 +4,7 @@
 
 #include "vm/regexp.h"
 
-#include "platform/splay-tree-inl.h"
 #include "platform/unicode.h"
-
-#include "unicode/uniset.h"
-
 #include "vm/dart_entry.h"
 #include "vm/regexp_assembler.h"
 #include "vm/regexp_assembler_bytecode.h"
@@ -29,14 +25,14 @@
 static const intptr_t kMaxLookaheadForBoyerMoore = 8;
 
 ContainedInLattice AddRange(ContainedInLattice containment,
-                            const int32_t* ranges,
+                            const intptr_t* ranges,
                             intptr_t ranges_length,
                             Interval new_range) {
   ASSERT((ranges_length & 1) == 1);
-  ASSERT(ranges[ranges_length - 1] == Utf::kMaxCodePoint + 1);
+  ASSERT(ranges[ranges_length - 1] == Utf16::kMaxCodeUnit + 1);
   if (containment == kLatticeUnknown) return containment;
   bool inside = false;
-  int32_t last = 0;
+  intptr_t last = 0;
   for (intptr_t i = 0; i < ranges_length;
        inside = !inside, last = ranges[i], i++) {
     // Consider the range from last to ranges[i].
@@ -286,26 +282,10 @@
 
 class RegExpCompiler : public ValueObject {
  public:
-  RegExpCompiler(intptr_t capture_count, bool is_one_byte);
+  RegExpCompiler(intptr_t capture_count, bool ignore_case, bool is_one_byte);
 
   intptr_t AllocateRegister() { return next_register_++; }
 
-  // Lookarounds to match lone surrogates for unicode character class matches
-  // are never nested. We can therefore reuse registers.
-  intptr_t UnicodeLookaroundStackRegister() {
-    if (unicode_lookaround_stack_register_ == kNoRegister) {
-      unicode_lookaround_stack_register_ = AllocateRegister();
-    }
-    return unicode_lookaround_stack_register_;
-  }
-
-  intptr_t UnicodeLookaroundPositionRegister() {
-    if (unicode_lookaround_position_register_ == kNoRegister) {
-      unicode_lookaround_position_register_ = AllocateRegister();
-    }
-    return unicode_lookaround_position_register_;
-  }
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
   RegExpEngine::CompilationResult Assemble(IRRegExpMacroAssembler* assembler,
                                            RegExpNode* start,
@@ -335,6 +315,7 @@
 
   void SetRegExpTooBig() { reg_exp_too_big_ = true; }
 
+  inline bool ignore_case() { return ignore_case_; }
   inline bool one_byte() const { return is_one_byte_; }
   bool read_backward() { return read_backward_; }
   void set_read_backward(bool value) { read_backward_ = value; }
@@ -352,11 +333,10 @@
  private:
   EndNode* accept_;
   intptr_t next_register_;
-  intptr_t unicode_lookaround_stack_register_;
-  intptr_t unicode_lookaround_position_register_;
   ZoneGrowableArray<RegExpNode*>* work_list_;
   intptr_t recursion_depth_;
   RegExpMacroAssembler* macro_assembler_;
+  bool ignore_case_;
   bool is_one_byte_;
   bool reg_exp_too_big_;
   bool read_backward_;
@@ -382,12 +362,13 @@
 
 // Attempts to compile the regexp using an Irregexp code generator.  Returns
 // a fixed array or a null handle depending on whether it succeeded.
-RegExpCompiler::RegExpCompiler(intptr_t capture_count, bool is_one_byte)
+RegExpCompiler::RegExpCompiler(intptr_t capture_count,
+                               bool ignore_case,
+                               bool is_one_byte)
     : next_register_(2 * (capture_count + 1)),
-      unicode_lookaround_stack_register_(kNoRegister),
-      unicode_lookaround_position_register_(kNoRegister),
       work_list_(NULL),
       recursion_depth_(0),
+      ignore_case_(ignore_case),
       is_one_byte_(is_one_byte),
       reg_exp_too_big_(false),
       read_backward_(false),
@@ -1018,7 +999,7 @@
 }
 
 static void EmitBoundaryTest(RegExpMacroAssembler* masm,
-                             uint16_t border,
+                             intptr_t border,
                              BlockLabel* fall_through,
                              BlockLabel* above_or_equal,
                              BlockLabel* below) {
@@ -1031,8 +1012,8 @@
 }
 
 static void EmitDoubleBoundaryTest(RegExpMacroAssembler* masm,
-                                   uint16_t first,
-                                   uint16_t last,
+                                   intptr_t first,
+                                   intptr_t last,
                                    BlockLabel* fall_through,
                                    BlockLabel* in_range,
                                    BlockLabel* out_of_range) {
@@ -1055,10 +1036,10 @@
 // even_label is for ranges[i] to ranges[i + 1] where i - start_index is even.
 // odd_label is for ranges[i] to ranges[i + 1] where i - start_index is odd.
 static void EmitUseLookupTable(RegExpMacroAssembler* masm,
-                               ZoneGrowableArray<uint16_t>* ranges,
+                               ZoneGrowableArray<int>* ranges,
                                intptr_t start_index,
                                intptr_t end_index,
-                               uint16_t min_char,
+                               intptr_t min_char,
                                BlockLabel* fall_through,
                                BlockLabel* even_label,
                                BlockLabel* odd_label) {
@@ -1112,7 +1093,7 @@
 }
 
 static void CutOutRange(RegExpMacroAssembler* masm,
-                        ZoneGrowableArray<uint16_t>* ranges,
+                        ZoneGrowableArray<int>* ranges,
                         intptr_t start_index,
                         intptr_t end_index,
                         intptr_t cut_index,
@@ -1138,17 +1119,17 @@
 
 // Unicode case.  Split the search space into kSize spaces that are handled
 // with recursion.
-static void SplitSearchSpace(ZoneGrowableArray<uint16_t>* ranges,
+static void SplitSearchSpace(ZoneGrowableArray<int>* ranges,
                              intptr_t start_index,
                              intptr_t end_index,
                              intptr_t* new_start_index,
                              intptr_t* new_end_index,
-                             uint16_t* border) {
+                             intptr_t* border) {
   static const intptr_t kSize = RegExpMacroAssembler::kTableSize;
   static const intptr_t kMask = RegExpMacroAssembler::kTableMask;
 
-  uint16_t first = ranges->At(start_index);
-  uint16_t last = ranges->At(end_index) - 1;
+  intptr_t first = ranges->At(start_index);
+  intptr_t last = ranges->At(end_index) - 1;
 
   *new_start_index = start_index;
   *border = (ranges->At(start_index) & ~kMask) + kSize;
@@ -1208,7 +1189,7 @@
 // Either label can be NULL indicating backtracking.  Either label can also be
 // equal to the fall_through label.
 static void GenerateBranches(RegExpMacroAssembler* masm,
-                             ZoneGrowableArray<uint16_t>* ranges,
+                             ZoneGrowableArray<int>* ranges,
                              intptr_t start_index,
                              intptr_t end_index,
                              uint16_t min_char,
@@ -1216,8 +1197,8 @@
                              BlockLabel* fall_through,
                              BlockLabel* even_label,
                              BlockLabel* odd_label) {
-  uint16_t first = ranges->At(start_index);
-  uint16_t last = ranges->At(end_index) - 1;
+  intptr_t first = ranges->At(start_index);
+  intptr_t last = ranges->At(end_index) - 1;
 
   ASSERT(min_char < first);
 
@@ -1277,7 +1258,7 @@
 
   intptr_t new_start_index = 0;
   intptr_t new_end_index = 0;
-  uint16_t border = 0;
+  intptr_t border = 0;
 
   SplitSearchSpace(ranges, start_index, end_index, &new_start_index,
                    &new_end_index, &border);
@@ -1334,7 +1315,7 @@
     CharacterRange::Canonicalize(ranges);
   }
 
-  uint16_t max_char;
+  intptr_t max_char;
   if (one_byte) {
     max_char = Symbols::kMaxOneCharCodeSymbol;
   } else {
@@ -1345,7 +1326,7 @@
 
   intptr_t last_valid_range = range_count - 1;
   while (last_valid_range >= 0) {
-    const CharacterRange& range = ranges->At(last_valid_range);
+    CharacterRange& range = (*ranges)[last_valid_range];
     if (range.from() <= max_char) {
       break;
     }
@@ -1373,6 +1354,14 @@
     }
     return;
   }
+  if (last_valid_range == 0 && !cc->is_negated() &&
+      ranges->At(0).IsEverything(max_char)) {
+    // This is a common case hit by non-anchored expressions.
+    if (check_offset) {
+      macro_assembler->CheckPosition(cp_offset, on_failure);
+    }
+    return;
+  }
 
   if (!preloaded) {
     macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check_offset);
@@ -1389,24 +1378,25 @@
   // entry at zero which goes to the failure label, but if there
   // was already one there we fall through for success on that entry.
   // Subsequent entries have alternating meaning (success/failure).
-  ZoneGrowableArray<uint16_t>* range_boundaries =
-      new (zone) ZoneGrowableArray<uint16_t>(last_valid_range);
+  ZoneGrowableArray<int>* range_boundaries =
+      new (zone) ZoneGrowableArray<int>(last_valid_range);
 
   bool zeroth_entry_is_failure = !cc->is_negated();
 
   for (intptr_t i = 0; i <= last_valid_range; i++) {
-    const CharacterRange& range = ranges->At(i);
+    CharacterRange& range = (*ranges)[i];
     if (range.from() == 0) {
       ASSERT(i == 0);
       zeroth_entry_is_failure = !zeroth_entry_is_failure;
     } else {
       range_boundaries->Add(range.from());
     }
-    if (range.to() + 1 <= max_char) {
-      range_boundaries->Add(range.to() + 1);
-    }
+    range_boundaries->Add(range.to() + 1);
   }
   intptr_t end_index = range_boundaries->length() - 1;
+  if (range_boundaries->At(end_index) > max_char) {
+    end_index--;
+  }
 
   BlockLabel fall_through;
   GenerateBranches(macro_assembler, range_boundaries,
@@ -1704,7 +1694,7 @@
   if (read_backward()) return;
   ASSERT(characters_filled_in < details->characters());
   intptr_t characters = details->characters();
-  int32_t char_mask;
+  intptr_t char_mask;
   if (compiler->one_byte()) {
     char_mask = Symbols::kMaxOneCharCodeSymbol;
   } else {
@@ -1729,7 +1719,7 @@
           pos->determines_perfectly = false;
           return;
         }
-        if (elm.atom()->ignore_case()) {
+        if (compiler->ignore_case()) {
           int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
           intptr_t length =
               GetCaseIndependentLetters(c, compiler->one_byte(), chars);
@@ -1779,7 +1769,6 @@
           details->positions(characters_filled_in);
       RegExpCharacterClass* tree = elm.char_class();
       ZoneGrowableArray<CharacterRange>* ranges = tree->ranges();
-      ASSERT(!ranges->is_empty());
       if (tree->is_negated()) {
         // A quick check uses multi-character mask and compare.  There is no
         // useful way to incorporate a negative char class into this scheme
@@ -1918,16 +1907,16 @@
   NodeInfo* info_;
 };
 
-RegExpNode* SeqRegExpNode::FilterOneByte(intptr_t depth) {
+RegExpNode* SeqRegExpNode::FilterOneByte(intptr_t depth, bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
   ASSERT(!info()->visited);
   VisitMarker marker(info());
-  return FilterSuccessor(depth - 1);
+  return FilterSuccessor(depth - 1, ignore_case);
 }
 
-RegExpNode* SeqRegExpNode::FilterSuccessor(intptr_t depth) {
-  RegExpNode* next = on_success_->FilterOneByte(depth - 1);
+RegExpNode* SeqRegExpNode::FilterSuccessor(intptr_t depth, bool ignore_case) {
+  RegExpNode* next = on_success_->FilterOneByte(depth - 1, ignore_case);
   if (next == NULL) return set_replacement(NULL);
   on_success_ = next;
   return set_replacement(this);
@@ -1964,7 +1953,7 @@
   return 0;
 }
 
-RegExpNode* TextNode::FilterOneByte(intptr_t depth) {
+RegExpNode* TextNode::FilterOneByte(intptr_t depth, bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
   ASSERT(!info()->visited);
@@ -1977,7 +1966,7 @@
       for (intptr_t j = 0; j < quarks->length(); j++) {
         uint16_t c = quarks->At(j);
         if (c <= Symbols::kMaxOneCharCodeSymbol) continue;
-        if (!elm.atom()->ignore_case()) return set_replacement(NULL);
+        if (!ignore_case) return set_replacement(NULL);
         // Here, we need to check for characters whose upper and lower cases
         // are outside the Latin-1 range.
         uint16_t converted = ConvertNonLatin1ToLatin1(c);
@@ -1999,44 +1988,40 @@
         if (range_count != 0 && ranges->At(0).from() == 0 &&
             ranges->At(0).to() >= Symbols::kMaxOneCharCodeSymbol) {
           // This will be handled in a later filter.
-          if (cc->flags().IgnoreCase() &&
-              RangesContainLatin1Equivalents(ranges)) {
-            continue;
-          }
+          if (ignore_case && RangesContainLatin1Equivalents(ranges)) continue;
           return set_replacement(NULL);
         }
       } else {
         if (range_count == 0 ||
             ranges->At(0).from() > Symbols::kMaxOneCharCodeSymbol) {
           // This will be handled in a later filter.
-          if (cc->flags().IgnoreCase() &&
-              RangesContainLatin1Equivalents(ranges))
-            continue;
+          if (ignore_case && RangesContainLatin1Equivalents(ranges)) continue;
           return set_replacement(NULL);
         }
       }
     }
   }
-  return FilterSuccessor(depth - 1);
+  return FilterSuccessor(depth - 1, ignore_case);
 }
 
-RegExpNode* LoopChoiceNode::FilterOneByte(intptr_t depth) {
+RegExpNode* LoopChoiceNode::FilterOneByte(intptr_t depth, bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
   if (info()->visited) return this;
   {
     VisitMarker marker(info());
 
-    RegExpNode* continue_replacement = continue_node_->FilterOneByte(depth - 1);
+    RegExpNode* continue_replacement =
+        continue_node_->FilterOneByte(depth - 1, ignore_case);
     // If we can't continue after the loop then there is no sense in doing the
     // loop.
     if (continue_replacement == NULL) return set_replacement(NULL);
   }
 
-  return ChoiceNode::FilterOneByte(depth - 1);
+  return ChoiceNode::FilterOneByte(depth - 1, ignore_case);
 }
 
-RegExpNode* ChoiceNode::FilterOneByte(intptr_t depth) {
+RegExpNode* ChoiceNode::FilterOneByte(intptr_t depth, bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
   if (info()->visited) return this;
@@ -2055,7 +2040,8 @@
   RegExpNode* survivor = NULL;
   for (intptr_t i = 0; i < choice_count; i++) {
     GuardedAlternative alternative = alternatives_->At(i);
-    RegExpNode* replacement = alternative.node()->FilterOneByte(depth - 1);
+    RegExpNode* replacement =
+        alternative.node()->FilterOneByte(depth - 1, ignore_case);
     ASSERT(replacement != this);  // No missing EMPTY_MATCH_CHECK.
     if (replacement != NULL) {
       (*alternatives_)[i].set_node(replacement);
@@ -2075,7 +2061,7 @@
       new (Z) ZoneGrowableArray<GuardedAlternative>(surviving);
   for (intptr_t i = 0; i < choice_count; i++) {
     RegExpNode* replacement =
-        (*alternatives_)[i].node()->FilterOneByte(depth - 1);
+        (*alternatives_)[i].node()->FilterOneByte(depth - 1, ignore_case);
     if (replacement != NULL) {
       (*alternatives_)[i].set_node(replacement);
       new_alternatives->Add((*alternatives_)[i]);
@@ -2085,7 +2071,8 @@
   return this;
 }
 
-RegExpNode* NegativeLookaroundChoiceNode::FilterOneByte(intptr_t depth) {
+RegExpNode* NegativeLookaroundChoiceNode::FilterOneByte(intptr_t depth,
+                                                        bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
   if (info()->visited) return this;
@@ -2093,12 +2080,12 @@
   // Alternative 0 is the negative lookahead, alternative 1 is what comes
   // afterwards.
   RegExpNode* node = (*alternatives_)[1].node();
-  RegExpNode* replacement = node->FilterOneByte(depth - 1);
+  RegExpNode* replacement = node->FilterOneByte(depth - 1, ignore_case);
   if (replacement == NULL) return set_replacement(NULL);
   (*alternatives_)[1].set_node(replacement);
 
   RegExpNode* neg_node = (*alternatives_)[0].node();
-  RegExpNode* neg_replacement = neg_node->FilterOneByte(depth - 1);
+  RegExpNode* neg_replacement = neg_node->FilterOneByte(depth - 1, ignore_case);
   // If the negative lookahead is always going to fail then
   // we don't need to check it.
   if (neg_replacement == NULL) return set_replacement(replacement);
@@ -2396,21 +2383,13 @@
     if (elm.text_type() == TextElement::ATOM) {
       ZoneGrowableArray<uint16_t>* quarks = elm.atom()->data();
       for (intptr_t j = preloaded ? 0 : quarks->length() - 1; j >= 0; j--) {
-        if (SkipPass(pass, elm.atom()->ignore_case())) continue;
         if (first_element_checked && i == 0 && j == 0) continue;
         if (DeterminedAlready(quick_check, elm.cp_offset() + j)) continue;
         EmitCharacterFunction* emit_function = NULL;
-        uint16_t quark = quarks->At(j);
-        if (elm.atom()->ignore_case()) {
-          // Everywhere else we assume that a non-Latin-1 character cannot match
-          // a Latin-1 character. Avoid the cases where this is assumption is
-          // invalid by using the Latin1 equivalent instead.
-          quark = Latin1::TryConvertToLatin1(quark);
-        }
         switch (pass) {
           case NON_LATIN1_MATCH:
             ASSERT(one_byte);
-            if (quark > Symbols::kMaxOneCharCodeSymbol) {
+            if (quarks->At(j) > Symbols::kMaxOneCharCodeSymbol) {
               assembler->GoTo(backtrack);
               return;
             }
@@ -2466,34 +2445,6 @@
   }
 }
 
-TextNode* TextNode::CreateForCharacterRanges(
-    ZoneGrowableArray<CharacterRange>* ranges,
-    bool read_backward,
-    RegExpNode* on_success,
-    RegExpFlags flags) {
-  ASSERT(ranges != nullptr);
-  ZoneGrowableArray<TextElement>* elms = new ZoneGrowableArray<TextElement>(1);
-  elms->Add(TextElement::CharClass(new RegExpCharacterClass(ranges, flags)));
-  return new TextNode(elms, read_backward, on_success);
-}
-
-TextNode* TextNode::CreateForSurrogatePair(CharacterRange lead,
-                                           CharacterRange trail,
-                                           bool read_backward,
-                                           RegExpNode* on_success,
-                                           RegExpFlags flags) {
-  auto lead_ranges = CharacterRange::List(on_success->zone(), lead);
-  auto trail_ranges = CharacterRange::List(on_success->zone(), trail);
-  auto elms = new ZoneGrowableArray<TextElement>(2);
-
-  elms->Add(
-      TextElement::CharClass(new RegExpCharacterClass(lead_ranges, flags)));
-  elms->Add(
-      TextElement::CharClass(new RegExpCharacterClass(trail_ranges, flags)));
-
-  return new TextNode(elms, read_backward, on_success);
-}
-
 // This generates the code to match a text node.  A text node can contain
 // straight character sequences (possibly to be matched in a case-independent
 // way) and character classes.  For efficiency we do not do this in a single
@@ -2523,15 +2474,19 @@
   // check that now.
   if (trace->characters_preloaded() == 1) {
     for (intptr_t pass = kFirstRealPass; pass <= kLastPass; pass++) {
-      TextEmitPass(compiler, static_cast<TextEmitPassType>(pass), true, trace,
-                   false, &bound_checked_to);
+      if (!SkipPass(pass, compiler->ignore_case())) {
+        TextEmitPass(compiler, static_cast<TextEmitPassType>(pass), true, trace,
+                     false, &bound_checked_to);
+      }
     }
     first_elt_done = true;
   }
 
   for (intptr_t pass = kFirstRealPass; pass <= kLastPass; pass++) {
-    TextEmitPass(compiler, static_cast<TextEmitPassType>(pass), false, trace,
-                 first_elt_done, &bound_checked_to);
+    if (!SkipPass(pass, compiler->ignore_case())) {
+      TextEmitPass(compiler, static_cast<TextEmitPassType>(pass), false, trace,
+                   first_elt_done, &bound_checked_to);
+    }
   }
 
   Trace successor_trace(*trace);
@@ -2573,13 +2528,13 @@
     TextElement elm = elms_->At(i);
     if (elm.text_type() == TextElement::CHAR_CLASS) {
       RegExpCharacterClass* cc = elm.char_class();
-      bool case_equivalents_already_added =
-          cc->flags().NeedsUnicodeCaseEquivalents();
-      if (cc->flags().IgnoreCase() && !case_equivalents_already_added) {
-        // None of the standard character classes is different in the case
-        // independent case and it slows us down if we don't know that.
-        if (cc->is_standard()) continue;
-        CharacterRange::AddCaseEquivalents(cc->ranges(), is_one_byte, Z);
+      // None of the standard character classes is different in the case
+      // independent case and it slows us down if we don't know that.
+      if (cc->is_standard()) continue;
+      ZoneGrowableArray<CharacterRange>* ranges = cc->ranges();
+      intptr_t range_count = ranges->length();
+      for (intptr_t j = 0; j < range_count; j++) {
+        (*ranges)[j].AddCaseEquivalents(ranges, is_one_byte, Z);
       }
     }
   }
@@ -2619,7 +2574,7 @@
 // length nodes or other complications in the way then return a sentinel
 // value indicating that a greedy loop cannot be constructed.
 intptr_t ChoiceNode::GreedyLoopTextLengthForAlternative(
-    const GuardedAlternative* alternative) {
+    GuardedAlternative* alternative) {
   intptr_t length = 0;
   RegExpNode* node = alternative->node();
   // Later we will generate code for all these text nodes using recursion
@@ -2657,7 +2612,7 @@
   if (trace->stop_node() == this) {
     // Back edge of greedy optimized loop node graph.
     intptr_t text_length =
-        GreedyLoopTextLengthForAlternative(&alternatives_->At(0));
+        GreedyLoopTextLengthForAlternative(&((*alternatives_)[0]));
     ASSERT(text_length != kNodeIsTooComplexForGreedyLoops);
     // Update the counter-based backtracking info on the stack.  This is an
     // optimization for greedy loops (see below).
@@ -2738,27 +2693,25 @@
   DISALLOW_ALLOCATION();
 };
 
-static const int32_t kRangeEndMarker = Utf::kMaxCodePoint + 1;
-
 // The '2' variant is inclusive from and exclusive to.
 // This covers \s as defined in ECMA-262 5.1, 15.10.2.12,
 // which include WhiteSpace (7.2) or LineTerminator (7.3) values.
 // 0x180E has been removed from Unicode's Zs category and thus
 // from ECMAScript's WhiteSpace category as of Unicode 6.3.
-static const int32_t kSpaceRanges[] = {
+static const intptr_t kSpaceRanges[] = {
     '\t',   '\r' + 1, ' ',    ' ' + 1, 0x00A0, 0x00A1, 0x1680,
     0x1681, 0x2000,   0x200B, 0x2028,  0x202A, 0x202F, 0x2030,
-    0x205F, 0x2060,   0x3000, 0x3001,  0xFEFF, 0xFF00, kRangeEndMarker};
+    0x205F, 0x2060,   0x3000, 0x3001,  0xFEFF, 0xFF00, 0x10000};
 static const intptr_t kSpaceRangeCount = ARRAY_SIZE(kSpaceRanges);
-static const int32_t kWordRanges[] = {
-    '0', '9' + 1, 'A', 'Z' + 1, '_', '_' + 1, 'a', 'z' + 1, kRangeEndMarker};
+static const intptr_t kWordRanges[] = {'0',     '9' + 1, 'A',     'Z' + 1, '_',
+                                       '_' + 1, 'a',     'z' + 1, 0x10000};
 static const intptr_t kWordRangeCount = ARRAY_SIZE(kWordRanges);
-static const int32_t kDigitRanges[] = {'0', '9' + 1, kRangeEndMarker};
+static const intptr_t kDigitRanges[] = {'0', '9' + 1, 0x10000};
 static const intptr_t kDigitRangeCount = ARRAY_SIZE(kDigitRanges);
-static const int32_t kSurrogateRanges[] = {0xd800, 0xe000, kRangeEndMarker};
+static const intptr_t kSurrogateRanges[] = {0xd800, 0xe000, 0x10000};
 static const intptr_t kSurrogateRangeCount = ARRAY_SIZE(kSurrogateRanges);
-static const int32_t kLineTerminatorRanges[] = {
-    0x000A, 0x000B, 0x000D, 0x000E, 0x2028, 0x202A, kRangeEndMarker};
+static const intptr_t kLineTerminatorRanges[] = {0x000A, 0x000B, 0x000D, 0x000E,
+                                                 0x2028, 0x202A, 0x10000};
 static const intptr_t kLineTerminatorRangeCount =
     ARRAY_SIZE(kLineTerminatorRanges);
 
@@ -3104,11 +3057,6 @@
 void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   intptr_t choice_count = alternatives_->length();
 
-  if (choice_count == 1 && alternatives_->At(0).guards() == nullptr) {
-    alternatives_->At(0).node()->Emit(compiler, trace);
-    return;
-  }
-
   AssertGuardsMentionRegisters(trace);
 
   LimitResult limit_result = LimitVersions(compiler, trace);
@@ -3129,7 +3077,7 @@
   GreedyLoopState greedy_loop_state(not_at_start());
 
   intptr_t text_length =
-      GreedyLoopTextLengthForAlternative(&alternatives_->At(0));
+      GreedyLoopTextLengthForAlternative(&((*alternatives_)[0]));
   AlternativeGenerationList alt_gens(choice_count);
 
   if (choice_count > 1 && text_length != kNodeIsTooComplexForGreedyLoops) {
@@ -3515,9 +3463,9 @@
   RecursionCheck rc(compiler);
 
   ASSERT(start_reg_ + 1 == end_reg_);
-  if (flags_.IgnoreCase()) {
-    assembler->CheckNotBackReferenceIgnoreCase(
-        start_reg_, read_backward(), flags_.IsUnicode(), trace->backtrack());
+  if (compiler->ignore_case()) {
+    assembler->CheckNotBackReferenceIgnoreCase(start_reg_, read_backward(),
+                                               trace->backtrack());
   } else {
     assembler->CheckNotBackReference(start_reg_, read_backward(),
                                      trace->backtrack());
@@ -3525,11 +3473,6 @@
   // We are going to advance backward, so we may end up at the start.
   if (read_backward()) trace->set_at_start(Trace::UNKNOWN);
 
-  // Check that the back reference does not end inside a surrogate pair.
-  if (flags_.IsUnicode() && !compiler->one_byte()) {
-    assembler->CheckNotInSurrogatePair(trace->cp_offset(), trace->backtrack());
-  }
-
   on_success()->Emit(compiler, trace);
 }
 
@@ -3788,10 +3731,10 @@
 }
 
 static bool CompareInverseRanges(ZoneGrowableArray<CharacterRange>* ranges,
-                                 const int32_t* special_class,
+                                 const intptr_t* special_class,
                                  intptr_t length) {
-  length--;  // Remove final kRangeEndMarker.
-  ASSERT(special_class[length] == kRangeEndMarker);
+  length--;  // Remove final 0x10000.
+  ASSERT(special_class[length] == 0x10000);
   ASSERT(ranges->length() != 0);
   ASSERT(length != 0);
   ASSERT(special_class[0] != 0);
@@ -3811,17 +3754,17 @@
       return false;
     }
   }
-  if (range.to() != Utf::kMaxCodePoint) {
+  if (range.to() != 0xffff) {
     return false;
   }
   return true;
 }
 
 static bool CompareRanges(ZoneGrowableArray<CharacterRange>* ranges,
-                          const int32_t* special_class,
+                          const intptr_t* special_class,
                           intptr_t length) {
-  length--;  // Remove final kRangeEndMarker.
-  ASSERT(special_class[length] == kRangeEndMarker);
+  length--;  // Remove final 0x10000.
+  ASSERT(special_class[length] == 0x10000);
   if (ranges->length() * 2 != length) {
     return false;
   }
@@ -3838,7 +3781,7 @@
 bool RegExpCharacterClass::is_standard() {
   // TODO(lrn): Remove need for this function, by not throwing away information
   // along the way.
-  if (is_negated()) {
+  if (is_negated_) {
     return false;
   }
   if (set_.is_standard()) {
@@ -3873,307 +3816,8 @@
   return false;
 }
 
-UnicodeRangeSplitter::UnicodeRangeSplitter(
-    Zone* zone,
-    ZoneGrowableArray<CharacterRange>* base)
-    : zone_(zone),
-      table_(zone),
-      bmp_(nullptr),
-      lead_surrogates_(nullptr),
-      trail_surrogates_(nullptr),
-      non_bmp_(nullptr) {
-  // The unicode range splitter categorizes given character ranges into:
-  // - Code points from the BMP representable by one code unit.
-  // - Code points outside the BMP that need to be split into surrogate pairs.
-  // - Lone lead surrogates.
-  // - Lone trail surrogates.
-  // Lone surrogates are valid code points, even though no actual characters.
-  // They require special matching to make sure we do not split surrogate pairs.
-  // We use the dispatch table to accomplish this. The base range is split up
-  // by the table by the overlay ranges, and the Call callback is used to
-  // filter and collect ranges for each category.
-  for (intptr_t i = 0; i < base->length(); i++) {
-    table_.AddRange(base->At(i), kBase, zone_);
-  }
-  // Add overlay ranges.
-  table_.AddRange(CharacterRange::Range(0, Utf16::kLeadSurrogateStart - 1),
-                  kBmpCodePoints, zone_);
-  table_.AddRange(CharacterRange::Range(Utf16::kLeadSurrogateStart,
-                                        Utf16::kLeadSurrogateEnd),
-                  kLeadSurrogates, zone_);
-  table_.AddRange(CharacterRange::Range(Utf16::kTrailSurrogateStart,
-                                        Utf16::kTrailSurrogateEnd),
-                  kTrailSurrogates, zone_);
-  table_.AddRange(
-      CharacterRange::Range(Utf16::kTrailSurrogateEnd + 1, Utf16::kMaxCodeUnit),
-      kBmpCodePoints, zone_);
-  table_.AddRange(
-      CharacterRange::Range(Utf16::kMaxCodeUnit + 1, Utf::kMaxCodePoint),
-      kNonBmpCodePoints, zone_);
-  table_.ForEach(this);
-}
-
-void UnicodeRangeSplitter::Call(uint32_t from, DispatchTable::Entry entry) {
-  OutSet* outset = entry.out_set();
-  if (!outset->Get(kBase)) return;
-  ZoneGrowableArray<CharacterRange>** target = nullptr;
-  if (outset->Get(kBmpCodePoints)) {
-    target = &bmp_;
-  } else if (outset->Get(kLeadSurrogates)) {
-    target = &lead_surrogates_;
-  } else if (outset->Get(kTrailSurrogates)) {
-    target = &trail_surrogates_;
-  } else {
-    ASSERT(outset->Get(kNonBmpCodePoints));
-    target = &non_bmp_;
-  }
-  if (*target == nullptr) {
-    *target = new (zone_) ZoneGrowableArray<CharacterRange>(2);
-  }
-  (*target)->Add(CharacterRange::Range(entry.from(), entry.to()));
-}
-
-void AddBmpCharacters(RegExpCompiler* compiler,
-                      ChoiceNode* result,
-                      RegExpNode* on_success,
-                      UnicodeRangeSplitter* splitter) {
-  ZoneGrowableArray<CharacterRange>* bmp = splitter->bmp();
-  if (bmp == nullptr) return;
-  result->AddAlternative(GuardedAlternative(TextNode::CreateForCharacterRanges(
-      bmp, compiler->read_backward(), on_success, RegExpFlags())));
-}
-
-void AddNonBmpSurrogatePairs(RegExpCompiler* compiler,
-                             ChoiceNode* result,
-                             RegExpNode* on_success,
-                             UnicodeRangeSplitter* splitter) {
-  ZoneGrowableArray<CharacterRange>* non_bmp = splitter->non_bmp();
-  if (non_bmp == nullptr) return;
-  ASSERT(!compiler->one_byte());
-  CharacterRange::Canonicalize(non_bmp);
-  for (int i = 0; i < non_bmp->length(); i++) {
-    // Match surrogate pair.
-    // E.g. [\u10005-\u11005] becomes
-    //      \ud800[\udc05-\udfff]|
-    //      [\ud801-\ud803][\udc00-\udfff]|
-    //      \ud804[\udc00-\udc05]
-    uint32_t from = non_bmp->At(i).from();
-    uint32_t to = non_bmp->At(i).to();
-    uint16_t from_points[2];
-    Utf16::Encode(from, from_points);
-    uint16_t to_points[2];
-    Utf16::Encode(to, to_points);
-    if (from_points[0] == to_points[0]) {
-      // The lead surrogate is the same.
-      result->AddAlternative(
-          GuardedAlternative(TextNode::CreateForSurrogatePair(
-              CharacterRange::Singleton(from_points[0]),
-              CharacterRange::Range(from_points[1], to_points[1]),
-              compiler->read_backward(), on_success, RegExpFlags())));
-    } else {
-      if (from_points[1] != Utf16::kTrailSurrogateStart) {
-        // Add [from_l][from_t-\udfff]
-        result->AddAlternative(
-            GuardedAlternative(TextNode::CreateForSurrogatePair(
-                CharacterRange::Singleton(from_points[0]),
-                CharacterRange::Range(from_points[1],
-                                      Utf16::kTrailSurrogateEnd),
-                compiler->read_backward(), on_success, RegExpFlags())));
-        from_points[0]++;
-      }
-      if (to_points[1] != Utf16::kTrailSurrogateEnd) {
-        // Add [to_l][\udc00-to_t]
-        result->AddAlternative(
-            GuardedAlternative(TextNode::CreateForSurrogatePair(
-                CharacterRange::Singleton(to_points[0]),
-                CharacterRange::Range(Utf16::kTrailSurrogateStart,
-                                      to_points[1]),
-                compiler->read_backward(), on_success, RegExpFlags())));
-        to_points[0]--;
-      }
-      if (from_points[0] <= to_points[0]) {
-        // Add [from_l-to_l][\udc00-\udfff]
-        result->AddAlternative(
-            GuardedAlternative(TextNode::CreateForSurrogatePair(
-                CharacterRange::Range(from_points[0], to_points[0]),
-                CharacterRange::Range(Utf16::kTrailSurrogateStart,
-                                      Utf16::kTrailSurrogateEnd),
-                compiler->read_backward(), on_success, RegExpFlags())));
-      }
-    }
-  }
-}
-
-RegExpNode* NegativeLookaroundAgainstReadDirectionAndMatch(
-    RegExpCompiler* compiler,
-    ZoneGrowableArray<CharacterRange>* lookbehind,
-    ZoneGrowableArray<CharacterRange>* match,
-    RegExpNode* on_success,
-    bool read_backward,
-    RegExpFlags flags) {
-  RegExpNode* match_node = TextNode::CreateForCharacterRanges(
-      match, read_backward, on_success, flags);
-  int stack_register = compiler->UnicodeLookaroundStackRegister();
-  int position_register = compiler->UnicodeLookaroundPositionRegister();
-  RegExpLookaround::Builder lookaround(false, match_node, stack_register,
-                                       position_register);
-  RegExpNode* negative_match = TextNode::CreateForCharacterRanges(
-      lookbehind, !read_backward, lookaround.on_match_success(), flags);
-  return lookaround.ForMatch(negative_match);
-}
-
-RegExpNode* MatchAndNegativeLookaroundInReadDirection(
-    RegExpCompiler* compiler,
-    ZoneGrowableArray<CharacterRange>* match,
-    ZoneGrowableArray<CharacterRange>* lookahead,
-    RegExpNode* on_success,
-    bool read_backward,
-    RegExpFlags flags) {
-  int stack_register = compiler->UnicodeLookaroundStackRegister();
-  int position_register = compiler->UnicodeLookaroundPositionRegister();
-  RegExpLookaround::Builder lookaround(false, on_success, stack_register,
-                                       position_register);
-  RegExpNode* negative_match = TextNode::CreateForCharacterRanges(
-      lookahead, read_backward, lookaround.on_match_success(), flags);
-  return TextNode::CreateForCharacterRanges(
-      match, read_backward, lookaround.ForMatch(negative_match), flags);
-}
-
-void AddLoneLeadSurrogates(RegExpCompiler* compiler,
-                           ChoiceNode* result,
-                           RegExpNode* on_success,
-                           UnicodeRangeSplitter* splitter) {
-  auto lead_surrogates = splitter->lead_surrogates();
-  if (lead_surrogates == nullptr) return;
-  // E.g. \ud801 becomes \ud801(?![\udc00-\udfff]).
-  auto trail_surrogates = CharacterRange::List(
-      on_success->zone(), CharacterRange::Range(Utf16::kTrailSurrogateStart,
-                                                Utf16::kTrailSurrogateEnd));
-
-  RegExpNode* match;
-  if (compiler->read_backward()) {
-    // Reading backward. Assert that reading forward, there is no trail
-    // surrogate, and then backward match the lead surrogate.
-    match = NegativeLookaroundAgainstReadDirectionAndMatch(
-        compiler, trail_surrogates, lead_surrogates, on_success, true,
-        RegExpFlags());
-  } else {
-    // Reading forward. Forward match the lead surrogate and assert that
-    // no trail surrogate follows.
-    match = MatchAndNegativeLookaroundInReadDirection(
-        compiler, lead_surrogates, trail_surrogates, on_success, false,
-        RegExpFlags());
-  }
-  result->AddAlternative(GuardedAlternative(match));
-}
-
-void AddLoneTrailSurrogates(RegExpCompiler* compiler,
-                            ChoiceNode* result,
-                            RegExpNode* on_success,
-                            UnicodeRangeSplitter* splitter) {
-  auto trail_surrogates = splitter->trail_surrogates();
-  if (trail_surrogates == nullptr) return;
-  // E.g. \udc01 becomes (?<![\ud800-\udbff])\udc01
-  auto lead_surrogates = CharacterRange::List(
-      on_success->zone(), CharacterRange::Range(Utf16::kLeadSurrogateStart,
-                                                Utf16::kLeadSurrogateEnd));
-
-  RegExpNode* match;
-  if (compiler->read_backward()) {
-    // Reading backward. Backward match the trail surrogate and assert that no
-    // lead surrogate precedes it.
-    match = MatchAndNegativeLookaroundInReadDirection(
-        compiler, trail_surrogates, lead_surrogates, on_success, true,
-        RegExpFlags());
-  } 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,
-        RegExpFlags());
-  }
-  result->AddAlternative(GuardedAlternative(match));
-}
-
-RegExpNode* UnanchoredAdvance(RegExpCompiler* compiler,
-                              RegExpNode* on_success) {
-  // This implements ES2015 21.2.5.2.3, AdvanceStringIndex.
-  ASSERT(!compiler->read_backward());
-  // 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.
-  auto range = CharacterRange::List(
-      on_success->zone(), CharacterRange::Range(0, Utf16::kMaxCodeUnit));
-  return TextNode::CreateForCharacterRanges(range, false, on_success,
-                                            RegExpFlags());
-}
-
-void AddUnicodeCaseEquivalents(ZoneGrowableArray<CharacterRange>* ranges) {
-  ASSERT(CharacterRange::IsCanonical(ranges));
-
-  // Micro-optimization to avoid passing large ranges to UnicodeSet::closeOver.
-  // See also https://crbug.com/v8/6727.
-  // TODO(sstrickl): This only covers the special case of the {0,0x10FFFF}
-  // range, which we use frequently internally. But large ranges can also easily
-  // be created by the user. We might want to have a more general caching
-  // mechanism for such ranges.
-  if (ranges->length() == 1 && ranges->At(0).IsEverything(Utf::kMaxCodePoint)) {
-    return;
-  }
-
-  icu::UnicodeSet set;
-  for (int i = 0; i < ranges->length(); i++) {
-    set.add(ranges->At(i).from(), ranges->At(i).to());
-  }
-  ranges->Clear();
-  set.closeOver(USET_CASE_INSENSITIVE);
-  // Full case mapping map single characters to multiple characters.
-  // Those are represented as strings in the set. Remove them so that
-  // we end up with only simple and common case mappings.
-  set.removeAllStrings();
-  for (int i = 0; i < set.getRangeCount(); i++) {
-    ranges->Add(
-        CharacterRange::Range(set.getRangeStart(i), set.getRangeEnd(i)));
-  }
-  // No errors and everything we collected have been ranges.
-  CharacterRange::Canonicalize(ranges);
-}
-
 RegExpNode* RegExpCharacterClass::ToNode(RegExpCompiler* compiler,
                                          RegExpNode* on_success) {
-  set_.Canonicalize();
-  ZoneGrowableArray<CharacterRange>* ranges = this->ranges();
-  if (flags_.NeedsUnicodeCaseEquivalents()) {
-    AddUnicodeCaseEquivalents(ranges);
-  }
-  if (flags_.IsUnicode() && !compiler->one_byte() &&
-      !contains_split_surrogate()) {
-    if (is_negated()) {
-      ZoneGrowableArray<CharacterRange>* negated =
-          new ZoneGrowableArray<CharacterRange>(2);
-      CharacterRange::Negate(ranges, negated);
-      ranges = negated;
-    }
-    if (ranges->length() == 0) {
-      RegExpCharacterClass* fail =
-          new RegExpCharacterClass(ranges, RegExpFlags());
-      return new TextNode(fail, compiler->read_backward(), on_success);
-    }
-    if (standard_type() == '*') {
-      return UnanchoredAdvance(compiler, on_success);
-    } else {
-      ChoiceNode* result = new (OZ) ChoiceNode(2, OZ);
-      UnicodeRangeSplitter splitter(OZ, 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;
-    }
-  } else {
-    return new TextNode(this, compiler->read_backward(), on_success);
-  }
   return new (OZ) TextNode(this, compiler->read_backward(), on_success);
 }
 
@@ -4370,43 +4014,6 @@
   }
 }
 
-namespace {
-// Desugar \b to (?<=\w)(?=\W)|(?<=\W)(?=\w) and
-//         \B to (?<=\w)(?=\w)|(?<=\W)(?=\W)
-RegExpNode* BoundaryAssertionAsLookaround(RegExpCompiler* compiler,
-                                          RegExpNode* on_success,
-                                          RegExpAssertion::AssertionType type,
-                                          RegExpFlags flags) {
-  ASSERT(flags.NeedsUnicodeCaseEquivalents());
-  ZoneGrowableArray<CharacterRange>* word_range =
-      new ZoneGrowableArray<CharacterRange>(2);
-  CharacterRange::AddClassEscape('w', word_range, true);
-  int stack_register = compiler->UnicodeLookaroundStackRegister();
-  int position_register = compiler->UnicodeLookaroundPositionRegister();
-  ChoiceNode* result = new (OZ) ChoiceNode(2, OZ);
-  // Add two choices. The (non-)boundary could start with a word or
-  // a non-word-character.
-  for (int i = 0; i < 2; i++) {
-    bool lookbehind_for_word = i == 0;
-    bool lookahead_for_word =
-        (type == RegExpAssertion::BOUNDARY) ^ lookbehind_for_word;
-    // Look to the left.
-    RegExpLookaround::Builder lookbehind(lookbehind_for_word, on_success,
-                                         stack_register, position_register);
-    RegExpNode* backward = TextNode::CreateForCharacterRanges(
-        word_range, true, lookbehind.on_match_success(), flags);
-    // Look to the right.
-    RegExpLookaround::Builder lookahead(lookahead_for_word,
-                                        lookbehind.ForMatch(backward),
-                                        stack_register, position_register);
-    RegExpNode* forward = TextNode::CreateForCharacterRanges(
-        word_range, false, lookahead.on_match_success(), flags);
-    result->AddAlternative(GuardedAlternative(lookahead.ForMatch(forward)));
-  }
-  return result;
-}
-}  // anonymous namespace
-
 RegExpNode* RegExpAssertion::ToNode(RegExpCompiler* compiler,
                                     RegExpNode* on_success) {
   switch (assertion_type()) {
@@ -4415,15 +4022,9 @@
     case START_OF_INPUT:
       return AssertionNode::AtStart(on_success);
     case BOUNDARY:
-      return flags_.NeedsUnicodeCaseEquivalents()
-                 ? BoundaryAssertionAsLookaround(compiler, on_success, BOUNDARY,
-                                                 flags_)
-                 : AssertionNode::AtBoundary(on_success);
+      return AssertionNode::AtBoundary(on_success);
     case NON_BOUNDARY:
-      return flags_.NeedsUnicodeCaseEquivalents()
-                 ? BoundaryAssertionAsLookaround(compiler, on_success,
-                                                 NON_BOUNDARY, flags_)
-                 : AssertionNode::AtNonBoundary(on_success);
+      return AssertionNode::AtNonBoundary(on_success);
     case END_OF_INPUT:
       return AssertionNode::AtEnd(on_success);
     case END_OF_LINE: {
@@ -4438,8 +4039,7 @@
       ZoneGrowableArray<CharacterRange>* newline_ranges =
           new ZoneGrowableArray<CharacterRange>(3);
       CharacterRange::AddClassEscape('n', newline_ranges);
-      RegExpCharacterClass* newline_atom =
-          new RegExpCharacterClass('n', RegExpFlags());
+      RegExpCharacterClass* newline_atom = new RegExpCharacterClass('n');
       TextNode* newline_matcher =
           new TextNode(newline_atom, /*read_backwards=*/false,
                        ActionNode::PositiveSubmatchSuccess(
@@ -4466,7 +4066,7 @@
 RegExpNode* RegExpBackReference::ToNode(RegExpCompiler* compiler,
                                         RegExpNode* on_success) {
   return new (OZ) BackReferenceNode(RegExpCapture::StartRegister(index()),
-                                    RegExpCapture::EndRegister(index()), flags_,
+                                    RegExpCapture::EndRegister(index()),
                                     compiler->read_backward(), on_success);
 }
 
@@ -4574,24 +4174,24 @@
   return current;
 }
 
-static void AddClass(const int32_t* elmv,
+static void AddClass(const intptr_t* elmv,
                      intptr_t elmc,
                      ZoneGrowableArray<CharacterRange>* ranges) {
   elmc--;
-  ASSERT(elmv[elmc] == kRangeEndMarker);
+  ASSERT(elmv[elmc] == 0x10000);
   for (intptr_t i = 0; i < elmc; i += 2) {
     ASSERT(elmv[i] < elmv[i + 1]);
     ranges->Add(CharacterRange(elmv[i], elmv[i + 1] - 1));
   }
 }
 
-static void AddClassNegated(const int32_t* elmv,
+static void AddClassNegated(const intptr_t* elmv,
                             intptr_t elmc,
                             ZoneGrowableArray<CharacterRange>* ranges) {
   elmc--;
-  ASSERT(elmv[elmc] == kRangeEndMarker);
+  ASSERT(elmv[elmc] == 0x10000);
   ASSERT(elmv[0] != 0x0000);
-  ASSERT(elmv[elmc - 1] != Utf::kMaxCodePoint);
+  ASSERT(elmv[elmc - 1] != Utf16::kMaxCodeUnit);
   uint16_t last = 0x0000;
   for (intptr_t i = 0; i < elmc; i += 2) {
     ASSERT(last <= elmv[i] - 1);
@@ -4599,30 +4199,7 @@
     ranges->Add(CharacterRange(last, elmv[i] - 1));
     last = elmv[i + 1];
   }
-  ranges->Add(CharacterRange(last, Utf::kMaxCodePoint));
-}
-
-void CharacterRange::AddClassEscape(uint16_t type,
-                                    ZoneGrowableArray<CharacterRange>* ranges,
-                                    bool add_unicode_case_equivalents) {
-  if (add_unicode_case_equivalents && (type == 'w' || type == 'W')) {
-    // See #sec-runtime-semantics-wordcharacters-abstract-operation
-    // In case of unicode and ignore_case, we need to create the closure over
-    // case equivalent characters before negating.
-    ZoneGrowableArray<CharacterRange>* new_ranges =
-        new ZoneGrowableArray<CharacterRange>(2);
-    AddClass(kWordRanges, kWordRangeCount, new_ranges);
-    AddUnicodeCaseEquivalents(new_ranges);
-    if (type == 'W') {
-      ZoneGrowableArray<CharacterRange>* negated =
-          new ZoneGrowableArray<CharacterRange>(2);
-      CharacterRange::Negate(new_ranges, negated);
-      new_ranges = negated;
-    }
-    ranges->AddArray(*new_ranges);
-    return;
-  }
-  AddClassEscape(type, ranges);
+  ranges->Add(CharacterRange(last, Utf16::kMaxCodeUnit));
 }
 
 void CharacterRange::AddClassEscape(uint16_t type,
@@ -4669,79 +4246,69 @@
     ZoneGrowableArray<CharacterRange>* ranges,
     bool is_one_byte,
     Zone* zone) {
-  CharacterRange::Canonicalize(ranges);
-  int range_count = ranges->length();
-  for (intptr_t i = 0; i < range_count; i++) {
-    CharacterRange range = ranges->At(i);
-    int32_t bottom = range.from();
-    if (bottom > Utf16::kMaxCodeUnit) continue;
-    int32_t top = Utils::Minimum(range.to(), Utf16::kMaxCodeUnit);
-    // Nothing to be done for surrogates
-    if (bottom >= Utf16::kLeadSurrogateStart &&
-        top <= Utf16::kTrailSurrogateEnd) {
-      continue;
+  uint16_t bottom = from();
+  uint16_t top = to();
+  if (is_one_byte && !RangeContainsLatin1Equivalents(*this)) {
+    if (bottom > Symbols::kMaxOneCharCodeSymbol) return;
+    if (top > Symbols::kMaxOneCharCodeSymbol) {
+      top = Symbols::kMaxOneCharCodeSymbol;
     }
-    if (is_one_byte && !RangeContainsLatin1Equivalents(range)) {
-      if (bottom > Symbols::kMaxOneCharCodeSymbol) continue;
-      if (top > Symbols::kMaxOneCharCodeSymbol) {
-        top = Symbols::kMaxOneCharCodeSymbol;
-      }
-    }
+  }
 
-    unibrow::Mapping<unibrow::Ecma262UnCanonicalize> jsregexp_uncanonicalize;
-    unibrow::Mapping<unibrow::CanonicalizationRange> jsregexp_canonrange;
-    int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-    if (top == bottom) {
-      // If this is a singleton we just expand the one character.
-      intptr_t length = jsregexp_uncanonicalize.get(bottom, '\0', chars);
+  unibrow::Mapping<unibrow::Ecma262UnCanonicalize> jsregexp_uncanonicalize;
+  unibrow::Mapping<unibrow::CanonicalizationRange> jsregexp_canonrange;
+  int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
+  if (top == bottom) {
+    // If this is a singleton we just expand the one character.
+    intptr_t length =
+        jsregexp_uncanonicalize.get(bottom, '\0', chars);  // NOLINT
+    for (intptr_t i = 0; i < length; i++) {
+      uint32_t chr = chars[i];
+      if (chr != bottom) {
+        ranges->Add(CharacterRange::Singleton(chars[i]));
+      }
+    }
+  } else {
+    // If this is a range we expand the characters block by block,
+    // expanding contiguous subranges (blocks) one at a time.
+    // The approach is as follows.  For a given start character we
+    // look up the remainder of the block that contains it (represented
+    // by the end point), for instance we find 'z' if the character
+    // is 'c'.  A block is characterized by the property
+    // that all characters uncanonicalize in the same way, except that
+    // each entry in the result is incremented by the distance from the first
+    // element.  So a-z is a block because 'a' uncanonicalizes to ['a', 'A'] and
+    // the k'th letter uncanonicalizes to ['a' + k, 'A' + k].
+    // Once we've found the end point we look up its uncanonicalization
+    // and produce a range for each element.  For instance for [c-f]
+    // we look up ['z', 'Z'] and produce [c-f] and [C-F].  We then only
+    // add a range if it is not already contained in the input, so [c-f]
+    // will be skipped but [C-F] will be added.  If this range is not
+    // completely contained in a block we do this for all the blocks
+    // covered by the range (handling characters that is not in a block
+    // as a "singleton block").
+    int32_t range[unibrow::Ecma262UnCanonicalize::kMaxWidth];
+    intptr_t pos = bottom;
+    while (pos <= top) {
+      intptr_t length = jsregexp_canonrange.get(pos, '\0', range);
+      uint16_t block_end;
+      if (length == 0) {
+        block_end = pos;
+      } else {
+        ASSERT(length == 1);
+        block_end = range[0];
+      }
+      intptr_t end = (block_end > top) ? top : block_end;
+      length = jsregexp_uncanonicalize.get(block_end, '\0', range);  // NOLINT
       for (intptr_t i = 0; i < length; i++) {
-        int32_t chr = chars[i];
-        if (chr != bottom) {
-          ranges->Add(CharacterRange::Singleton(chars[i]));
+        uint32_t c = range[i];
+        uint16_t range_from = c - (block_end - pos);
+        uint16_t range_to = c - (block_end - end);
+        if (!(bottom <= range_from && range_to <= top)) {
+          ranges->Add(CharacterRange(range_from, range_to));
         }
       }
-    } else {
-      // If this is a range we expand the characters block by block,
-      // expanding contiguous subranges (blocks) one at a time.
-      // The approach is as follows.  For a given start character we
-      // look up the remainder of the block that contains it (represented
-      // by the end point), for instance we find 'z' if the character
-      // is 'c'.  A block is characterized by the property
-      // that all characters uncanonicalize in the same way, except that
-      // each entry in the result is incremented by the distance from the first
-      // element.  So a-z is a block because 'a' uncanonicalizes to ['a', 'A']
-      // and the k'th letter uncanonicalizes to ['a' + k, 'A' + k].
-      // Once we've found the end point we look up its uncanonicalization
-      // and produce a range for each element.  For instance for [c-f]
-      // we look up ['z', 'Z'] and produce [c-f] and [C-F].  We then only
-      // add a range if it is not already contained in the input, so [c-f]
-      // will be skipped but [C-F] will be added.  If this range is not
-      // completely contained in a block we do this for all the blocks
-      // covered by the range (handling characters that is not in a block
-      // as a "singleton block").
-      int32_t range[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-      intptr_t pos = bottom;
-      while (pos <= top) {
-        intptr_t length = jsregexp_canonrange.get(pos, '\0', range);
-        int32_t block_end;
-        if (length == 0) {
-          block_end = pos;
-        } else {
-          ASSERT(length == 1);
-          block_end = range[0];
-        }
-        intptr_t end = (block_end > top) ? top : block_end;
-        length = jsregexp_uncanonicalize.get(block_end, '\0', range);
-        for (intptr_t i = 0; i < length; i++) {
-          int32_t c = range[i];
-          int32_t range_from = c - (block_end - pos);
-          int32_t range_to = c - (block_end - end);
-          if (!(bottom <= range_from && range_to <= top)) {
-            ranges->Add(CharacterRange(range_from, range_to));
-          }
-        }
-        pos = end + 1;
-      }
+      pos = end + 1;
     }
   }
 }
@@ -4794,8 +4361,8 @@
   // list[0..count] for the result. Returns the number of resulting
   // canonicalized ranges. Inserting a range may collapse existing ranges into
   // fewer ranges, so the return value can be anything in the range 1..count+1.
-  int32_t from = insert.from();
-  int32_t to = insert.to();
+  uint16_t from = insert.from();
+  uint16_t to = insert.to();
   intptr_t start_pos = 0;
   intptr_t end_pos = count;
   for (intptr_t i = count - 1; i >= 0; i--) {
@@ -4891,7 +4458,7 @@
   ASSERT(CharacterRange::IsCanonical(ranges));
   ASSERT(negated_ranges->length() == 0);
   intptr_t range_count = ranges->length();
-  uint32_t from = 0;
+  uint16_t from = 0;
   intptr_t i = 0;
   if (range_count > 0 && ranges->At(0).from() == 0) {
     from = ranges->At(0).to();
@@ -4903,8 +4470,8 @@
     from = range.to();
     i++;
   }
-  if (from < Utf::kMaxCodePoint) {
-    negated_ranges->Add(CharacterRange(from + 1, Utf::kMaxCodePoint));
+  if (from < Utf16::kMaxCodeUnit) {
+    negated_ranges->Add(CharacterRange(from + 1, Utf16::kMaxCodeUnit));
   }
 }
 
@@ -4921,22 +4488,6 @@
   return false;
 }
 
-OutSet* OutSet::Extend(unsigned value, Zone* zone) {
-  if (Get(value)) return this;
-  if (successors() != nullptr) {
-    for (int i = 0; i < successors()->length(); i++) {
-      OutSet* successor = successors()->At(i);
-      if (successor->Get(value)) return successor;
-    }
-  } else {
-    successors_ = new (zone) ZoneGrowableArray<OutSet*>(2);
-  }
-  OutSet* result = new (zone) OutSet(first_, remaining_);
-  result->Set(value, zone);
-  successors()->Add(result);
-  return result;
-}
-
 void OutSet::Set(unsigned value, Zone* zone) {
   if (value < kFirstLimit) {
     first_ |= (1 << value);
@@ -4961,108 +4512,6 @@
   }
 }
 
-const int32_t DispatchTable::Config::kNoKey = Utf::kInvalidChar;
-
-void DispatchTable::AddRange(CharacterRange full_range,
-                             int32_t value,
-                             Zone* zone) {
-  CharacterRange current = full_range;
-  if (tree()->is_empty()) {
-    // If this is the first range we just insert into the table.
-    ZoneSplayTree<Config>::Locator loc;
-    bool inserted = tree()->Insert(current.from(), &loc);
-    ASSERT(inserted);
-    USE(inserted);
-    loc.set_value(
-        Entry(current.from(), current.to(), empty()->Extend(value, zone)));
-    return;
-  }
-  // First see if there is a range to the left of this one that
-  // overlaps.
-  ZoneSplayTree<Config>::Locator loc;
-  if (tree()->FindGreatestLessThan(current.from(), &loc)) {
-    Entry* entry = &loc.value();
-    // If we've found a range that overlaps with this one, and it
-    // starts strictly to the left of this one, we have to fix it
-    // because the following code only handles ranges that start on
-    // or after the start point of the range we're adding.
-    if (entry->from() < current.from() && entry->to() >= current.from()) {
-      // Snap the overlapping range in half around the start point of
-      // the range we're adding.
-      CharacterRange left =
-          CharacterRange::Range(entry->from(), current.from() - 1);
-      CharacterRange right = CharacterRange::Range(current.from(), entry->to());
-      // The left part of the overlapping range doesn't overlap.
-      // Truncate the whole entry to be just the left part.
-      entry->set_to(left.to());
-      // The right part is the one that overlaps.  We add this part
-      // to the map and let the next step deal with merging it with
-      // the range we're adding.
-      ZoneSplayTree<Config>::Locator loc;
-      bool inserted = tree()->Insert(right.from(), &loc);
-      ASSERT(inserted);
-      USE(inserted);
-      loc.set_value(Entry(right.from(), right.to(), entry->out_set()));
-    }
-  }
-  while (current.is_valid()) {
-    if (tree()->FindLeastGreaterThan(current.from(), &loc) &&
-        (loc.value().from() <= current.to()) &&
-        (loc.value().to() >= current.from())) {
-      Entry* entry = &loc.value();
-      // We have overlap.  If there is space between the start point of
-      // the range we're adding and where the overlapping range starts
-      // then we have to add a range covering just that space.
-      if (current.from() < entry->from()) {
-        ZoneSplayTree<Config>::Locator ins;
-        bool inserted = tree()->Insert(current.from(), &ins);
-        ASSERT(inserted);
-        USE(inserted);
-        ins.set_value(Entry(current.from(), entry->from() - 1,
-                            empty()->Extend(value, zone)));
-        current.set_from(entry->from());
-      }
-      ASSERT(current.from() == entry->from());
-      // If the overlapping range extends beyond the one we want to add
-      // we have to snap the right part off and add it separately.
-      if (entry->to() > current.to()) {
-        ZoneSplayTree<Config>::Locator ins;
-        bool inserted = tree()->Insert(current.to() + 1, &ins);
-        ASSERT(inserted);
-        USE(inserted);
-        ins.set_value(Entry(current.to() + 1, entry->to(), entry->out_set()));
-        entry->set_to(current.to());
-      }
-      ASSERT(entry->to() <= current.to());
-      // The overlapping range is now completely contained by the range
-      // we're adding so we can just update it and move the start point
-      // of the range we're adding just past it.
-      entry->AddValue(value, zone);
-      ASSERT(entry->to() + 1 > current.from());
-      current.set_from(entry->to() + 1);
-    } else {
-      // There is no overlap so we can just add the range
-      ZoneSplayTree<Config>::Locator ins;
-      bool inserted = tree()->Insert(current.from(), &ins);
-      ASSERT(inserted);
-      USE(inserted);
-      ins.set_value(
-          Entry(current.from(), current.to(), empty()->Extend(value, zone)));
-      break;
-    }
-  }
-}
-
-OutSet* DispatchTable::Get(int32_t value) {
-  ZoneSplayTree<Config>::Locator loc;
-  if (!tree()->FindGreatestLessThan(value, &loc)) return empty();
-  Entry* entry = &loc.value();
-  if (value <= entry->to())
-    return entry->out_set();
-  else
-    return empty();
-}
-
 // -------------------------------------------------------------------
 // Analysis
 
@@ -5091,7 +4540,9 @@
 }
 
 void Analysis::VisitText(TextNode* that) {
-  that->MakeCaseIndependent(is_one_byte_);
+  if (ignore_case_) {
+    that->MakeCaseIndependent(is_one_byte_);
+  }
   EnsureAnalyzed(that->on_success());
   if (!has_failed()) {
     that->CalculateOffsets();
@@ -5198,7 +4649,7 @@
           return;
         }
         uint16_t character = atom->data()->At(j);
-        if (atom->flags().IgnoreCase()) {
+        if (bm->compiler()->ignore_case()) {
           int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
           intptr_t length = GetCaseIndependentLetters(
               character, bm->max_char() == Symbols::kMaxOneCharCodeSymbol,
@@ -5218,7 +4669,7 @@
         bm->SetAll(offset);
       } else {
         for (intptr_t k = 0; k < ranges->length(); k++) {
-          const CharacterRange& range = ranges->At(k);
+          CharacterRange& range = (*ranges)[k];
           if (range.from() > max_char) continue;
           intptr_t to =
               Utils::Minimum(max_char, static_cast<intptr_t>(range.to()));
@@ -5237,40 +4688,6 @@
   if (initial_offset == 0) set_bm_info(not_at_start, bm);
 }
 
-RegExpNode* OptionallyStepBackToLeadSurrogate(RegExpCompiler* compiler,
-                                              RegExpNode* on_success,
-                                              RegExpFlags flags) {
-  // If the regexp matching starts within a surrogate pair, step back
-  // to the lead surrogate and start matching from there.
-  ASSERT(!compiler->read_backward());
-  Zone* zone = compiler->zone();
-
-  auto lead_surrogates = CharacterRange::List(
-      on_success->zone(), CharacterRange::Range(Utf16::kLeadSurrogateStart,
-                                                Utf16::kLeadSurrogateEnd));
-  auto trail_surrogates = CharacterRange::List(
-      on_success->zone(), CharacterRange::Range(Utf16::kTrailSurrogateStart,
-                                                Utf16::kTrailSurrogateEnd));
-
-  ChoiceNode* optional_step_back = new (zone) ChoiceNode(2, zone);
-
-  int stack_register = compiler->UnicodeLookaroundStackRegister();
-  int position_register = compiler->UnicodeLookaroundPositionRegister();
-  RegExpNode* step_back = TextNode::CreateForCharacterRanges(
-      lead_surrogates, /*read_backward=*/true, on_success, flags);
-  RegExpLookaround::Builder builder(/*is_positive=*/true, step_back,
-                                    stack_register, position_register);
-  RegExpNode* match_trail = TextNode::CreateForCharacterRanges(
-      trail_surrogates, /*read_backward=*/false, builder.on_match_success(),
-      flags);
-
-  optional_step_back->AddAlternative(
-      GuardedAlternative(builder.ForMatch(match_trail)));
-  optional_step_back->AddAlternative(GuardedAlternative(on_success));
-
-  return optional_step_back;
-}
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 RegExpEngine::CompilationResult RegExpEngine::CompileIR(
     RegExpCompileData* data,
@@ -5291,10 +4708,10 @@
   ASSERT(!regexp.IsNull());
   ASSERT(!pattern.IsNull());
 
-  const bool is_global = regexp.flags().IsGlobal();
-  const bool is_unicode = regexp.flags().IsUnicode();
+  const bool ignore_case = regexp.is_ignore_case();
+  const bool is_global = regexp.is_global();
 
-  RegExpCompiler compiler(data->capture_count, is_one_byte);
+  RegExpCompiler compiler(data->capture_count, ignore_case, is_one_byte);
 
   // TODO(zerny): Frequency sampling is currently disabled because of several
   // issues. We do not want to store subject strings in the regexp object since
@@ -5317,37 +4734,34 @@
     // Add a .*? at the beginning, outside the body capture, unless
     // this expression is anchored at the beginning or is sticky.
     RegExpNode* loop_node = RegExpQuantifier::ToNode(
-        0, RegExpTree::kInfinity, false,
-        new (zone) RegExpCharacterClass('*', RegExpFlags()), &compiler,
-        captured_body, data->contains_anchor);
+        0, RegExpTree::kInfinity, false, new (zone) RegExpCharacterClass('*'),
+        &compiler, captured_body, data->contains_anchor);
 
     if (data->contains_anchor) {
       // Unroll loop once, to take care of the case that might start
       // at the start of input.
       ChoiceNode* first_step_node = new (zone) ChoiceNode(2, zone);
       first_step_node->AddAlternative(GuardedAlternative(captured_body));
-      first_step_node->AddAlternative(GuardedAlternative(new (zone) TextNode(
-          new (zone) RegExpCharacterClass('*', RegExpFlags()),
-          /*read_backwards=*/false, loop_node)));
+      first_step_node->AddAlternative(GuardedAlternative(
+          new (zone) TextNode(new (zone) RegExpCharacterClass('*'),
+                              /*read_backwards=*/false, loop_node)));
       node = first_step_node;
     } else {
       node = loop_node;
     }
   }
   if (is_one_byte) {
-    node = node->FilterOneByte(RegExpCompiler::kMaxRecursion);
+    node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
     // Do it again to propagate the new nodes to places where they were not
     // put because they had not been calculated yet.
     if (node != NULL) {
-      node = node->FilterOneByte(RegExpCompiler::kMaxRecursion);
+      node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
     }
-  } else if (is_unicode && (is_global || is_sticky)) {
-    node = OptionallyStepBackToLeadSurrogate(&compiler, node, regexp.flags());
   }
 
   if (node == NULL) node = new (zone) EndNode(EndNode::BACKTRACK, zone);
   data->node = node;
-  Analysis analysis(is_one_byte);
+  Analysis analysis(ignore_case, is_one_byte);
   analysis.EnsureAnalyzed(node);
   if (analysis.has_failed()) {
     const char* error_message = analysis.error_message();
@@ -5369,13 +4783,10 @@
   }
 
   if (is_global) {
-    RegExpMacroAssembler::GlobalMode mode = RegExpMacroAssembler::GLOBAL;
-    if (data->tree->min_match() > 0) {
-      mode = RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK;
-    } else if (is_unicode) {
-      mode = RegExpMacroAssembler::GLOBAL_UNICODE;
-    }
-    macro_assembler->set_global_mode(mode);
+    macro_assembler->set_global_mode(
+        (data->tree->min_match() > 0)
+            ? RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK
+            : RegExpMacroAssembler::GLOBAL);
   }
 
   RegExpEngine::CompilationResult result =
@@ -5401,10 +4812,10 @@
   ASSERT(!regexp.IsNull());
   ASSERT(!pattern.IsNull());
 
-  const bool is_global = regexp.flags().IsGlobal();
-  const bool is_unicode = regexp.flags().IsUnicode();
+  const bool ignore_case = regexp.is_ignore_case();
+  const bool is_global = regexp.is_global();
 
-  RegExpCompiler compiler(data->capture_count, is_one_byte);
+  RegExpCompiler compiler(data->capture_count, ignore_case, is_one_byte);
 
   // TODO(zerny): Frequency sampling is currently disabled because of several
   // issues. We do not want to store subject strings in the regexp object since
@@ -5427,37 +4838,34 @@
     // Add a .*? at the beginning, outside the body capture, unless
     // this expression is anchored at the beginning.
     RegExpNode* loop_node = RegExpQuantifier::ToNode(
-        0, RegExpTree::kInfinity, false,
-        new (zone) RegExpCharacterClass('*', RegExpFlags()), &compiler,
-        captured_body, data->contains_anchor);
+        0, RegExpTree::kInfinity, false, new (zone) RegExpCharacterClass('*'),
+        &compiler, captured_body, data->contains_anchor);
 
     if (data->contains_anchor) {
       // Unroll loop once, to take care of the case that might start
       // at the start of input.
       ChoiceNode* first_step_node = new (zone) ChoiceNode(2, zone);
       first_step_node->AddAlternative(GuardedAlternative(captured_body));
-      first_step_node->AddAlternative(GuardedAlternative(new (zone) TextNode(
-          new (zone) RegExpCharacterClass('*', RegExpFlags()),
-          /*read_backwards=*/false, loop_node)));
+      first_step_node->AddAlternative(GuardedAlternative(
+          new (zone) TextNode(new (zone) RegExpCharacterClass('*'),
+                              /*read_backwards=*/false, loop_node)));
       node = first_step_node;
     } else {
       node = loop_node;
     }
   }
   if (is_one_byte) {
-    node = node->FilterOneByte(RegExpCompiler::kMaxRecursion);
+    node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
     // Do it again to propagate the new nodes to places where they were not
     // put because they had not been calculated yet.
     if (node != NULL) {
-      node = node->FilterOneByte(RegExpCompiler::kMaxRecursion);
+      node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
     }
-  } else if (is_unicode && (is_global || is_sticky)) {
-    node = OptionallyStepBackToLeadSurrogate(&compiler, node, regexp.flags());
   }
 
   if (node == NULL) node = new (zone) EndNode(EndNode::BACKTRACK, zone);
   data->node = node;
-  Analysis analysis(is_one_byte);
+  Analysis analysis(ignore_case, is_one_byte);
   analysis.EnsureAnalyzed(node);
   if (analysis.has_failed()) {
     const char* error_message = analysis.error_message();
@@ -5479,13 +4887,10 @@
   }
 
   if (is_global) {
-    RegExpMacroAssembler::GlobalMode mode = RegExpMacroAssembler::GLOBAL;
-    if (data->tree->min_match() > 0) {
-      mode = RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK;
-    } else if (is_unicode) {
-      mode = RegExpMacroAssembler::GLOBAL_UNICODE;
-    }
-    macro_assembler->set_global_mode(mode);
+    macro_assembler->set_global_mode(
+        (data->tree->min_match() > 0)
+            ? RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK
+            : RegExpMacroAssembler::GLOBAL);
   }
 
   RegExpEngine::CompilationResult result =
@@ -5547,12 +4952,19 @@
 
 RawRegExp* RegExpEngine::CreateRegExp(Thread* thread,
                                       const String& pattern,
-                                      RegExpFlags flags) {
+                                      bool multi_line,
+                                      bool ignore_case) {
   Zone* zone = thread->zone();
   const RegExp& regexp = RegExp::Handle(RegExp::New());
 
   regexp.set_pattern(pattern);
-  regexp.set_flags(flags);
+
+  if (multi_line) {
+    regexp.set_is_multi_line();
+  }
+  if (ignore_case) {
+    regexp.set_is_ignore_case();
+  }
 
   // TODO(zerny): We might want to use normal string searching algorithms
   // for simple patterns.
diff --git a/runtime/vm/regexp.h b/runtime/vm/regexp.h
index febcb91..092a06a 100644
--- a/runtime/vm/regexp.h
+++ b/runtime/vm/regexp.h
@@ -5,14 +5,11 @@
 #ifndef RUNTIME_VM_REGEXP_H_
 #define RUNTIME_VM_REGEXP_H_
 
-#include "platform/unicode.h"
-
 #include "vm/compiler/assembler/assembler.h"
 #include "vm/compiler/backend/flow_graph_compiler.h"
 #include "vm/compiler/backend/il.h"
 #include "vm/object.h"
 #include "vm/regexp_assembler.h"
-#include "vm/splay-tree.h"
 
 namespace dart {
 
@@ -28,42 +25,32 @@
 class CharacterRange {
  public:
   CharacterRange() : from_(0), to_(0) {}
-  CharacterRange(int32_t from, int32_t to) : from_(from), to_(to) {}
+  CharacterRange(uint16_t from, uint16_t to) : from_(from), to_(to) {}
 
   static void AddClassEscape(uint16_t type,
                              ZoneGrowableArray<CharacterRange>* ranges);
-  // Add class escapes with case equivalent closure for \w and \W if necessary.
-  static void AddClassEscape(uint16_t type,
-                             ZoneGrowableArray<CharacterRange>* ranges,
-                             bool add_unicode_case_equivalents);
   static GrowableArray<const intptr_t> GetWordBounds();
-  static inline CharacterRange Singleton(int32_t value) {
+  static inline CharacterRange Singleton(uint16_t value) {
     return CharacterRange(value, value);
   }
-  static inline CharacterRange Range(int32_t from, int32_t to) {
+  static inline CharacterRange Range(uint16_t from, uint16_t to) {
     ASSERT(from <= to);
     return CharacterRange(from, to);
   }
   static inline CharacterRange Everything() {
-    return CharacterRange(0, Utf::kMaxCodePoint);
+    return CharacterRange(0, 0xFFFF);
   }
-  static inline ZoneGrowableArray<CharacterRange>* List(Zone* zone,
-                                                        CharacterRange range) {
-    auto list = new (zone) ZoneGrowableArray<CharacterRange>(1);
-    list->Add(range);
-    return list;
-  }
-  bool Contains(int32_t i) const { return from_ <= i && i <= to_; }
-  int32_t from() const { return from_; }
-  void set_from(int32_t value) { from_ = value; }
-  int32_t to() const { return to_; }
-  void set_to(int32_t value) { to_ = value; }
+  bool Contains(uint16_t i) const { return from_ <= i && i <= to_; }
+  uint16_t from() const { return from_; }
+  void set_from(uint16_t value) { from_ = value; }
+  uint16_t to() const { return to_; }
+  void set_to(uint16_t value) { to_ = value; }
   bool is_valid() const { return from_ <= to_; }
-  bool IsEverything(int32_t max) const { return from_ == 0 && to_ >= max; }
+  bool IsEverything(uint16_t max) const { return from_ == 0 && to_ >= max; }
   bool IsSingleton() const { return (from_ == to_); }
-  static void AddCaseEquivalents(ZoneGrowableArray<CharacterRange>* ranges,
-                                 bool is_one_byte,
-                                 Zone* zone);
+  void AddCaseEquivalents(ZoneGrowableArray<CharacterRange>* ranges,
+                          bool is_one_byte,
+                          Zone* zone);
   static void Split(ZoneGrowableArray<CharacterRange>* base,
                     GrowableArray<const intptr_t> overlay,
                     ZoneGrowableArray<CharacterRange>** included,
@@ -84,8 +71,8 @@
   static const intptr_t kPayloadMask = (1 << 24) - 1;
 
  private:
-  int32_t from_;
-  int32_t to_;
+  uint16_t from_;
+  uint16_t to_;
 
   DISALLOW_ALLOCATION();
 };
@@ -118,98 +105,6 @@
   friend class Trace;
 };
 
-// A mapping from integers, specified as ranges, to a set of integers.
-// Used for mapping character ranges to choices.
-class DispatchTable : public ValueObject {
- public:
-  explicit DispatchTable(Zone* zone) : tree_(zone) {}
-
-  class Entry {
-   public:
-    Entry() : from_(0), to_(0), out_set_(nullptr) {}
-    Entry(int32_t from, int32_t to, OutSet* out_set)
-        : from_(from), to_(to), out_set_(out_set) {
-      ASSERT(from <= to);
-    }
-    int32_t from() { return from_; }
-    int32_t to() { return to_; }
-    void set_to(int32_t value) { to_ = value; }
-    void AddValue(int value, Zone* zone) {
-      out_set_ = out_set_->Extend(value, zone);
-    }
-    OutSet* out_set() { return out_set_; }
-
-   private:
-    int32_t from_;
-    int32_t to_;
-    OutSet* out_set_;
-  };
-
-  class Config {
-   public:
-    typedef int32_t Key;
-    typedef Entry Value;
-    static const int32_t kNoKey;
-    static const Entry NoValue() { return Value(); }
-    static inline int Compare(int32_t a, int32_t b) {
-      if (a == b)
-        return 0;
-      else if (a < b)
-        return -1;
-      else
-        return 1;
-    }
-  };
-
-  void AddRange(CharacterRange range, int32_t value, Zone* zone);
-  OutSet* Get(int32_t value);
-  void Dump();
-
-  template <typename Callback>
-  void ForEach(Callback* callback) {
-    return tree()->ForEach(callback);
-  }
-
- private:
-  // There can't be a static empty set since it allocates its
-  // successors in a zone and caches them.
-  OutSet* empty() { return &empty_; }
-  OutSet empty_;
-  ZoneSplayTree<Config>* tree() { return &tree_; }
-  ZoneSplayTree<Config> tree_;
-};
-
-// Categorizes character ranges into BMP, non-BMP, lead, and trail surrogates.
-class UnicodeRangeSplitter : public ValueObject {
- public:
-  UnicodeRangeSplitter(Zone* zone, ZoneGrowableArray<CharacterRange>* base);
-  void Call(uint32_t from, DispatchTable::Entry entry);
-
-  ZoneGrowableArray<CharacterRange>* bmp() { return bmp_; }
-  ZoneGrowableArray<CharacterRange>* lead_surrogates() {
-    return lead_surrogates_;
-  }
-  ZoneGrowableArray<CharacterRange>* trail_surrogates() {
-    return trail_surrogates_;
-  }
-  ZoneGrowableArray<CharacterRange>* non_bmp() const { return non_bmp_; }
-
- private:
-  static const int kBase = 0;
-  // Separate ranges into
-  static const int kBmpCodePoints = 1;
-  static const int kLeadSurrogates = 2;
-  static const int kTrailSurrogates = 3;
-  static const int kNonBmpCodePoints = 4;
-
-  Zone* zone_;
-  DispatchTable table_;
-  ZoneGrowableArray<CharacterRange>* bmp_;
-  ZoneGrowableArray<CharacterRange>* lead_surrogates_;
-  ZoneGrowableArray<CharacterRange>* trail_surrogates_;
-  ZoneGrowableArray<CharacterRange>* non_bmp_;
-};
-
 #define FOR_EACH_NODE_TYPE(VISIT)                                              \
   VISIT(End)                                                                   \
   VISIT(Action)                                                                \
@@ -449,7 +344,9 @@
   // 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 NULL if the node can never match.
-  virtual RegExpNode* FilterOneByte(intptr_t depth) { return this; }
+  virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case) {
+    return this;
+  }
   // Helper for FilterOneByte.
   RegExpNode* replacement() {
     ASSERT(info()->replacement_calculated);
@@ -546,7 +443,7 @@
       : 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(intptr_t depth);
+  virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case);
   virtual void FillInBMInfo(intptr_t offset,
                             intptr_t budget,
                             BoyerMooreLookahead* bm,
@@ -556,7 +453,7 @@
   }
 
  protected:
-  RegExpNode* FilterSuccessor(intptr_t depth);
+  RegExpNode* FilterSuccessor(intptr_t depth, bool ignore_case);
 
  private:
   RegExpNode* on_success_;
@@ -664,19 +561,6 @@
         read_backward_(read_backward) {
     elms_->Add(TextElement::CharClass(that));
   }
-  // Create TextNode for a single character class for the given ranges.
-  static TextNode* CreateForCharacterRanges(
-      ZoneGrowableArray<CharacterRange>* ranges,
-      bool read_backward,
-      RegExpNode* on_success,
-      RegExpFlags flags);
-  // Create TextNode for a surrogate pair with a range given for the
-  // lead and the trail surrogate each.
-  static TextNode* CreateForSurrogatePair(CharacterRange lead,
-                                          CharacterRange trail,
-                                          bool read_backward,
-                                          RegExpNode* on_success,
-                                          RegExpFlags flags);
   virtual void Accept(NodeVisitor* visitor);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
   virtual intptr_t EatsAtLeast(intptr_t still_to_find,
@@ -697,7 +581,7 @@
                             BoyerMooreLookahead* bm,
                             bool not_at_start);
   void CalculateOffsets();
-  virtual RegExpNode* FilterOneByte(intptr_t depth);
+  virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case);
 
  private:
   enum TextEmitPassType {
@@ -775,13 +659,11 @@
  public:
   BackReferenceNode(intptr_t start_reg,
                     intptr_t end_reg,
-                    RegExpFlags flags,
                     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);
   intptr_t start_register() { return start_reg_; }
@@ -805,7 +687,6 @@
  private:
   intptr_t start_reg_;
   intptr_t end_reg_;
-  RegExpFlags flags_;
   bool read_backward_;
 };
 
@@ -880,9 +761,9 @@
  public:
   explicit GuardedAlternative(RegExpNode* node) : node_(node), guards_(NULL) {}
   void AddGuard(Guard* guard, Zone* zone);
-  RegExpNode* node() const { return node_; }
+  RegExpNode* node() { return node_; }
   void set_node(RegExpNode* node) { node_ = node; }
-  ZoneGrowableArray<Guard*>* guards() const { return guards_; }
+  ZoneGrowableArray<Guard*>* guards() { return guards_; }
 
  private:
   RegExpNode* node_;
@@ -930,12 +811,11 @@
   virtual bool try_to_emit_quick_check_for_alternative(bool is_first) {
     return true;
   }
-  virtual RegExpNode* FilterOneByte(intptr_t depth);
+  virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case);
   virtual bool read_backward() { return false; }
 
  protected:
-  intptr_t GreedyLoopTextLengthForAlternative(
-      const GuardedAlternative* alternative);
+  intptr_t GreedyLoopTextLengthForAlternative(GuardedAlternative* alternative);
   ZoneGrowableArray<GuardedAlternative>* alternatives_;
 
  private:
@@ -1006,7 +886,7 @@
   virtual bool try_to_emit_quick_check_for_alternative(bool is_first) {
     return !is_first;
   }
-  virtual RegExpNode* FilterOneByte(intptr_t depth);
+  virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case);
 };
 
 class LoopChoiceNode : public ChoiceNode {
@@ -1038,7 +918,7 @@
   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(intptr_t depth);
+  virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case);
 
  private:
   // AddAlternative is made private for loop nodes because alternatives
@@ -1406,8 +1286,10 @@
 //   +-------+        +------------+
 class Analysis : public NodeVisitor {
  public:
-  explicit Analysis(bool is_one_byte)
-      : is_one_byte_(is_one_byte), error_message_(NULL) {}
+  Analysis(bool ignore_case, bool is_one_byte)
+      : ignore_case_(ignore_case),
+        is_one_byte_(is_one_byte),
+        error_message_(NULL) {}
   void EnsureAnalyzed(RegExpNode* node);
 
 #define DECLARE_VISIT(Type) virtual void Visit##Type(Type##Node* that);
@@ -1423,6 +1305,7 @@
   void fail(const char* error_message) { error_message_ = error_message; }
 
  private:
+  bool ignore_case_;
   bool is_one_byte_;
   const char* error_message_;
 
@@ -1515,7 +1398,8 @@
 
   static RawRegExp* CreateRegExp(Thread* thread,
                                  const String& pattern,
-                                 RegExpFlags flags);
+                                 bool multi_line,
+                                 bool ignore_case);
 
   static void DotPrint(const char* label, RegExpNode* node, bool ignore_case);
 };
diff --git a/runtime/vm/regexp_assembler.cc b/runtime/vm/regexp_assembler.cc
index ab242c4..fb7dc74 100644
--- a/runtime/vm/regexp_assembler.cc
+++ b/runtime/vm/regexp_assembler.cc
@@ -4,10 +4,6 @@
 
 #include "vm/regexp_assembler.h"
 
-#include "unicode/uchar.h"
-
-#include "platform/unicode.h"
-
 #include "vm/flags.h"
 #include "vm/regexp.h"
 #include "vm/unibrow-inl.h"
@@ -20,10 +16,11 @@
   OS::PrintErr(format, c);
 }
 
-RawBool* CaseInsensitiveCompareUCS2(RawString* str_raw,
-                                    RawSmi* lhs_index_raw,
-                                    RawSmi* rhs_index_raw,
-                                    RawSmi* length_raw) {
+
+static RawBool* CaseInsensitiveCompareUC16(RawString* str_raw,
+                                           RawSmi* lhs_index_raw,
+                                           RawSmi* rhs_index_raw,
+                                           RawSmi* length_raw) {
   const String& str = String::Handle(str_raw);
   const Smi& lhs_index = Smi::Handle(lhs_index_raw);
   const Smi& rhs_index = Smi::Handle(rhs_index_raw);
@@ -51,50 +48,13 @@
   return Bool::True().raw();
 }
 
-RawBool* CaseInsensitiveCompareUTF16(RawString* str_raw,
-                                     RawSmi* lhs_index_raw,
-                                     RawSmi* rhs_index_raw,
-                                     RawSmi* length_raw) {
-  const String& str = String::Handle(str_raw);
-  const Smi& lhs_index = Smi::Handle(lhs_index_raw);
-  const Smi& rhs_index = Smi::Handle(rhs_index_raw);
-  const Smi& length = Smi::Handle(length_raw);
-
-  for (intptr_t i = 0; i < length.Value(); i++) {
-    int32_t c1 = str.CharAt(lhs_index.Value() + i);
-    int32_t c2 = str.CharAt(rhs_index.Value() + i);
-    if (Utf16::IsLeadSurrogate(c1)) {
-      // Non-BMP characters do not have case-equivalents in the BMP.
-      // Both have to be non-BMP for them to be able to match.
-      if (!Utf16::IsLeadSurrogate(c2)) return Bool::False().raw();
-      if (i + 1 < length.Value()) {
-        uint16_t c1t = str.CharAt(lhs_index.Value() + i + 1);
-        uint16_t c2t = str.CharAt(rhs_index.Value() + i + 1);
-        if (Utf16::IsTrailSurrogate(c1t) && Utf16::IsTrailSurrogate(c2t)) {
-          c1 = Utf16::Decode(c1, c1t);
-          c2 = Utf16::Decode(c2, c2t);
-          i++;
-        }
-      }
-    }
-    c1 = u_foldCase(c1, U_FOLD_CASE_DEFAULT);
-    c2 = u_foldCase(c2, U_FOLD_CASE_DEFAULT);
-    if (c1 != c2) return Bool::False().raw();
-  }
-  return Bool::True().raw();
-}
 
 DEFINE_RAW_LEAF_RUNTIME_ENTRY(
-    CaseInsensitiveCompareUCS2,
+    CaseInsensitiveCompareUC16,
     4,
     false /* is_float */,
-    reinterpret_cast<RuntimeFunction>(&CaseInsensitiveCompareUCS2));
+    reinterpret_cast<RuntimeFunction>(&CaseInsensitiveCompareUC16));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(
-    CaseInsensitiveCompareUTF16,
-    4,
-    false /* is_float */,
-    reinterpret_cast<RuntimeFunction>(&CaseInsensitiveCompareUTF16));
 
 BlockLabel::BlockLabel()
     : block_(NULL), is_bound_(false), is_linked_(false), pos_(-1) {
@@ -112,18 +72,4 @@
 
 RegExpMacroAssembler::~RegExpMacroAssembler() {}
 
-void RegExpMacroAssembler::CheckNotInSurrogatePair(intptr_t cp_offset,
-                                                   BlockLabel* on_failure) {
-  BlockLabel ok;
-  // Check that current character is not a trail surrogate.
-  LoadCurrentCharacter(cp_offset, &ok);
-  CheckCharacterNotInRange(Utf16::kTrailSurrogateStart,
-                           Utf16::kTrailSurrogateEnd, &ok);
-  // Check that previous character is not a lead surrogate.
-  LoadCurrentCharacter(cp_offset - 1, &ok);
-  CheckCharacterInRange(Utf16::kLeadSurrogateStart, Utf16::kLeadSurrogateEnd,
-                        on_failure);
-  BindBlock(&ok);
-}
-
 }  // namespace dart
diff --git a/runtime/vm/regexp_assembler.h b/runtime/vm/regexp_assembler.h
index 818f573..a7b087e 100644
--- a/runtime/vm/regexp_assembler.h
+++ b/runtime/vm/regexp_assembler.h
@@ -13,19 +13,6 @@
 
 // Utility function for the DotPrinter
 void PrintUtf16(uint16_t c);
-// Compares two-byte strings case insensitively as UCS2.
-// Called from generated RegExp code.
-RawBool* CaseInsensitiveCompareUCS2(RawString* str_raw,
-                                    RawSmi* lhs_index_raw,
-                                    RawSmi* rhs_index_raw,
-                                    RawSmi* length_raw);
-
-// Compares two-byte strings case insensitively as UTF16.
-// Called from generated RegExp code.
-RawBool* CaseInsensitiveCompareUTF16(RawString* str_raw,
-                                     RawSmi* lhs_index_raw,
-                                     RawSmi* rhs_index_raw,
-                                     RawSmi* length_raw);
 
 /// Convenience wrapper around a BlockEntryInstr pointer.
 class BlockLabel : public ValueObject {
@@ -140,7 +127,6 @@
                                      BlockLabel* on_no_match) = 0;
   virtual void CheckNotBackReferenceIgnoreCase(intptr_t start_reg,
                                                bool read_backward,
-                                               bool unicode,
                                                BlockLabel* on_no_match) = 0;
   // Check the current character for a match with a literal character.  If we
   // fail to match then goto the on_failure label.  End of input always
@@ -229,33 +215,22 @@
   virtual void ClearRegisters(intptr_t reg_from, intptr_t reg_to) = 0;
   virtual void WriteStackPointerToRegister(intptr_t reg) = 0;
 
-  // Check that we are not in the middle of a surrogate pair.
-  void CheckNotInSurrogatePair(intptr_t cp_offset, BlockLabel* on_failure);
-
   // Controls the generation of large inlined constants in the code.
   void set_slow_safe(bool ssc) { slow_safe_compiler_ = ssc; }
   bool slow_safe() { return slow_safe_compiler_; }
 
-  enum GlobalMode {
-    NOT_GLOBAL,
-    GLOBAL,
-    GLOBAL_NO_ZERO_LENGTH_CHECK,
-    GLOBAL_UNICODE
-  };
+  enum GlobalMode { NOT_GLOBAL, GLOBAL, GLOBAL_NO_ZERO_LENGTH_CHECK };
   // Set whether the regular expression has the global flag.  Exiting due to
   // a failure in a global regexp may still mean success overall.
   inline void set_global_mode(GlobalMode mode) { global_mode_ = mode; }
   inline bool global() { return global_mode_ != NOT_GLOBAL; }
-  inline bool global_with_zero_length_check() {
-    return global_mode_ == GLOBAL || global_mode_ == GLOBAL_UNICODE;
-  }
-  inline bool global_unicode() { return global_mode_ == GLOBAL_UNICODE; }
+  inline bool global_with_zero_length_check() { return global_mode_ == GLOBAL; }
 
   Zone* zone() const { return zone_; }
 
  private:
   bool slow_safe_compiler_;
-  GlobalMode global_mode_;
+  bool global_mode_;
   Zone* zone_;
 };
 
diff --git a/runtime/vm/regexp_assembler_bytecode.cc b/runtime/vm/regexp_assembler_bytecode.cc
index 0318a27..8288e1b 100644
--- a/runtime/vm/regexp_assembler_bytecode.cc
+++ b/runtime/vm/regexp_assembler_bytecode.cc
@@ -349,14 +349,11 @@
 void BytecodeRegExpMacroAssembler::CheckNotBackReferenceIgnoreCase(
     intptr_t start_reg,
     bool read_backward,
-    bool unicode,
     BlockLabel* on_not_equal) {
   ASSERT(start_reg >= 0);
   ASSERT(start_reg <= kMaxRegister);
-  Emit(read_backward ? (unicode ? BC_CHECK_NOT_BACK_REF_NO_CASE_UNICODE_BACKWARD
-                                : BC_CHECK_NOT_BACK_REF_NO_CASE_BACKWARD)
-                     : (unicode ? BC_CHECK_NOT_BACK_REF_NO_CASE_UNICODE
-                                : BC_CHECK_NOT_BACK_REF_NO_CASE),
+  Emit(read_backward ? BC_CHECK_NOT_BACK_REF_NO_CASE_BACKWARD
+                     : BC_CHECK_NOT_BACK_REF_NO_CASE,
        start_reg);
   EmitOrLink(on_not_equal);
 }
@@ -437,10 +434,11 @@
     }
 #endif  // !defined(PRODUCT)
 
+    const bool multiline = regexp.is_multi_line();
     RegExpCompileData* compile_data = new (zone) RegExpCompileData();
 
     // Parsing failures are handled in the RegExp factory constructor.
-    RegExpParser::ParseRegExp(pattern, regexp.flags(), compile_data);
+    RegExpParser::ParseRegExp(pattern, multiline, compile_data);
 
     regexp.set_num_bracket_expressions(compile_data->capture_count);
     regexp.set_capture_name_map(compile_data->capture_name_map);
@@ -453,15 +451,15 @@
     RegExpEngine::CompilationResult result = RegExpEngine::CompileBytecode(
         compile_data, regexp, is_one_byte, sticky, zone);
     ASSERT(result.bytecode != NULL);
-    ASSERT(regexp.num_registers(is_one_byte) == -1 ||
-           regexp.num_registers(is_one_byte) == result.num_registers);
-    regexp.set_num_registers(is_one_byte, result.num_registers);
+    ASSERT((regexp.num_registers() == -1) ||
+           (regexp.num_registers() == result.num_registers));
+    regexp.set_num_registers(result.num_registers);
     regexp.set_bytecode(is_one_byte, sticky, *(result.bytecode));
   }
 
-  ASSERT(regexp.num_registers(is_one_byte) != -1);
+  ASSERT(regexp.num_registers() != -1);
 
-  return regexp.num_registers(is_one_byte) +
+  return regexp.num_registers() +
          (Smi::Value(regexp.num_bracket_expressions()) + 1) * 2;
 }
 
diff --git a/runtime/vm/regexp_assembler_bytecode.h b/runtime/vm/regexp_assembler_bytecode.h
index 59cf68f..3e17d49 100644
--- a/runtime/vm/regexp_assembler_bytecode.h
+++ b/runtime/vm/regexp_assembler_bytecode.h
@@ -83,7 +83,6 @@
                                      BlockLabel* on_no_match);
   virtual void CheckNotBackReferenceIgnoreCase(intptr_t start_reg,
                                                bool read_backward,
-                                               bool unicode,
                                                BlockLabel* on_no_match);
   virtual void IfRegisterLT(intptr_t register_index,
                             intptr_t comparand,
diff --git a/runtime/vm/regexp_assembler_ir.cc b/runtime/vm/regexp_assembler_ir.cc
index f7f18ac..b1efebe 100644
--- a/runtime/vm/regexp_assembler_ir.cc
+++ b/runtime/vm/regexp_assembler_ir.cc
@@ -821,7 +821,6 @@
 void IRRegExpMacroAssembler::CheckNotBackReferenceIgnoreCase(
     intptr_t start_reg,
     bool read_backward,
-    bool unicode,
     BlockLabel* on_no_match) {
   TAG();
   ASSERT(start_reg + 1 <= registers_count_);
@@ -968,17 +967,9 @@
     Value* rhs_index_value = Bind(LoadLocal(capture_start_index_));
     Value* length_value = Bind(LoadLocal(capture_length_));
 
-    Definition* is_match_def;
-
-    if (unicode) {
-      is_match_def = new (Z) CaseInsensitiveCompareInstr(
-          string_value, lhs_index_value, rhs_index_value, length_value,
-          kCaseInsensitiveCompareUTF16RuntimeEntry, specialization_cid_);
-    } else {
-      is_match_def = new (Z) CaseInsensitiveCompareInstr(
-          string_value, lhs_index_value, rhs_index_value, length_value,
-          kCaseInsensitiveCompareUCS2RuntimeEntry, specialization_cid_);
-    }
+    Definition* is_match_def = new (Z) CaseInsensitiveCompareUC16Instr(
+        string_value, lhs_index_value, rhs_index_value, length_value,
+        specialization_cid_);
 
     BranchOrBacktrack(Comparison(kNE, is_match_def, BoolConstant(true)),
                       on_no_match);
diff --git a/runtime/vm/regexp_assembler_ir.h b/runtime/vm/regexp_assembler_ir.h
index d8c222a..c4f6e1f 100644
--- a/runtime/vm/regexp_assembler_ir.h
+++ b/runtime/vm/regexp_assembler_ir.h
@@ -67,7 +67,6 @@
                                      BlockLabel* on_no_match);
   virtual void CheckNotBackReferenceIgnoreCase(intptr_t start_reg,
                                                bool read_backward,
-                                               bool unicode,
                                                BlockLabel* on_no_match);
   virtual void CheckNotCharacter(uint32_t c, BlockLabel* on_not_equal);
   virtual void CheckNotCharacterAfterAnd(uint32_t c,
diff --git a/runtime/vm/regexp_ast.h b/runtime/vm/regexp_ast.h
index 4fb64a3..17a175e 100644
--- a/runtime/vm/regexp_ast.h
+++ b/runtime/vm/regexp_ast.h
@@ -108,8 +108,7 @@
     BOUNDARY,
     NON_BOUNDARY
   };
-  RegExpAssertion(AssertionType type, RegExpFlags flags)
-      : assertion_type_(type), flags_(flags) {}
+  explicit RegExpAssertion(AssertionType type) : assertion_type_(type) {}
   virtual void* Accept(RegExpVisitor* visitor, void* data);
   virtual RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success);
   virtual RegExpAssertion* AsAssertion();
@@ -122,7 +121,6 @@
 
  private:
   AssertionType assertion_type_;
-  RegExpFlags flags_;
 };
 
 class CharacterSet : public ValueObject {
@@ -152,40 +150,18 @@
 
 class RegExpCharacterClass : public RegExpTree {
  public:
-  enum Flag {
-    // The character class is negated and should match everything but the
-    // specified ranges.
-    NEGATED = 1 << 0,
-    // The character class contains part of a split surrogate and should not
-    // be unicode-desugared.
-    CONTAINS_SPLIT_SURROGATE = 1 << 1,
-  };
-  using CharacterClassFlags = intptr_t;
-  static inline CharacterClassFlags DefaultFlags() { return 0; }
-
-  RegExpCharacterClass(
-      ZoneGrowableArray<CharacterRange>* ranges,
-      RegExpFlags flags,
-      CharacterClassFlags character_class_flags = DefaultFlags())
-      : set_(ranges),
-        flags_(flags),
-        character_class_flags_(character_class_flags) {
-    // Convert the empty set of ranges to the negated Everything() range.
-    if (ranges->is_empty()) {
-      ranges->Add(CharacterRange::Everything());
-      character_class_flags_ ^= NEGATED;
-    }
-  }
-  RegExpCharacterClass(uint16_t type, RegExpFlags flags)
-      : set_(type), flags_(flags), character_class_flags_(0) {}
+  RegExpCharacterClass(ZoneGrowableArray<CharacterRange>* ranges,
+                       bool is_negated)
+      : set_(ranges), is_negated_(is_negated) {}
+  explicit RegExpCharacterClass(uint16_t type)
+      : set_(type), is_negated_(false) {}
   virtual void* Accept(RegExpVisitor* visitor, void* data);
   virtual RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success);
   virtual RegExpCharacterClass* AsCharacterClass();
   virtual bool IsCharacterClass() const;
   virtual bool IsTextElement() const { return true; }
   virtual intptr_t min_match() const { return 1; }
-  // The character class may match two code units for unicode regexps.
-  virtual intptr_t max_match() const { return 2; }
+  virtual intptr_t max_match() const { return 1; }
   virtual void AppendToText(RegExpText* text);
   CharacterSet character_set() const { return set_; }
   // TODO(lrn): Remove need for complex version if is_standard that
@@ -204,22 +180,16 @@
   // * : All characters
   uint16_t standard_type() const { return set_.standard_set_type(); }
   ZoneGrowableArray<CharacterRange>* ranges() { return set_.ranges(); }
-  bool is_negated() const { return character_class_flags_ & NEGATED; }
-  RegExpFlags flags() const { return flags_; }
-  bool contains_split_surrogate() const {
-    return character_class_flags_ & CONTAINS_SPLIT_SURROGATE;
-  }
+  bool is_negated() const { return is_negated_; }
 
  private:
   CharacterSet set_;
-  RegExpFlags flags_;
-  CharacterClassFlags character_class_flags_;
+  bool is_negated_;
 };
 
 class RegExpAtom : public RegExpTree {
  public:
-  RegExpAtom(ZoneGrowableArray<uint16_t>* data, RegExpFlags flags)
-      : data_(data), flags_(flags) {}
+  explicit RegExpAtom(ZoneGrowableArray<uint16_t>* data) : data_(data) {}
   virtual void* Accept(RegExpVisitor* visitor, void* data);
   virtual RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success);
   virtual RegExpAtom* AsAtom();
@@ -230,12 +200,9 @@
   virtual void AppendToText(RegExpText* text);
   ZoneGrowableArray<uint16_t>* data() const { return data_; }
   intptr_t length() const { return data_->length(); }
-  RegExpFlags flags() const { return flags_; }
-  bool ignore_case() const { return flags_.IgnoreCase(); }
 
  private:
   ZoneGrowableArray<uint16_t>* data_;
-  const RegExpFlags flags_;
 };
 
 class RegExpText : public RegExpTree {
@@ -403,10 +370,9 @@
 
 class RegExpBackReference : public RegExpTree {
  public:
-  explicit RegExpBackReference(RegExpFlags flags)
-      : capture_(nullptr), name_(nullptr), flags_(flags) {}
-  RegExpBackReference(RegExpCapture* capture, RegExpFlags flags)
-      : capture_(capture), name_(nullptr), flags_(flags) {}
+  RegExpBackReference() : capture_(nullptr), name_(nullptr) {}
+  explicit RegExpBackReference(RegExpCapture* capture)
+      : capture_(capture), name_(nullptr) {}
   virtual void* Accept(RegExpVisitor* visitor, void* data);
   virtual RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success);
   virtual RegExpBackReference* AsBackReference();
@@ -425,7 +391,6 @@
  private:
   RegExpCapture* capture_;
   const ZoneGrowableArray<uint16_t>* name_;
-  RegExpFlags flags_;
 };
 
 class RegExpEmpty : public RegExpTree {
diff --git a/runtime/vm/regexp_bytecodes.h b/runtime/vm/regexp_bytecodes.h
index 178c950..858eef5 100644
--- a/runtime/vm/regexp_bytecodes.h
+++ b/runtime/vm/regexp_bytecodes.h
@@ -55,19 +55,17 @@
 V(CHECK_GT,          36, 8)   /* bc8 pad8 uc16 addr32                       */ \
 V(CHECK_NOT_BACK_REF, 37, 8)  /* bc8 reg_idx24 addr32                       */ \
 V(CHECK_NOT_BACK_REF_NO_CASE, 38, 8) /* bc8 reg_idx24 addr32                */ \
-V(CHECK_NOT_BACK_REF_NO_CASE_UNICODE, 39, 8) /* bc8 reg_idx24 addr32        */ \
-V(CHECK_NOT_BACK_REF_BACKWARD, 40, 8) /* bc8 reg_idx24 addr32               */ \
-V(CHECK_NOT_BACK_REF_NO_CASE_BACKWARD, 41, 8) /* bc8 reg_idx24 addr32       */ \
-V(CHECK_NOT_BACK_REF_NO_CASE_UNICODE_BACKWARD, 42, 8) /*bc8 reg_idx24 addr32*/ \
-V(CHECK_NOT_REGS_EQUAL, 43, 12) /* bc8 regidx24 reg_idx32 addr32            */ \
-V(CHECK_REGISTER_LT, 44, 12)  /* bc8 reg_idx24 value32 addr32               */ \
-V(CHECK_REGISTER_GE, 45, 12)  /* bc8 reg_idx24 value32 addr32               */ \
-V(CHECK_REGISTER_EQ_POS, 46, 8) /* bc8 reg_idx24 addr32                     */ \
-V(CHECK_AT_START,    47, 8)   /* bc8 pad24 addr32                           */ \
-V(CHECK_NOT_AT_START, 48, 8)  /* bc8 offset24 addr32                        */ \
-V(CHECK_GREEDY,      49, 8)   /* bc8 pad24 addr32                           */ \
-V(ADVANCE_CP_AND_GOTO, 50, 8) /* bc8 offset24 addr32                        */ \
-V(SET_CURRENT_POSITION_FROM_END, 51, 4) /* bc8 idx24                        */
+V(CHECK_NOT_BACK_REF_BACKWARD, 39, 8) /* bc8 reg_idx24 addr32               */ \
+V(CHECK_NOT_BACK_REF_NO_CASE_BACKWARD, 40, 8) /* bc8 reg_idx24 addr32       */ \
+V(CHECK_NOT_REGS_EQUAL, 41, 12) /* bc8 regidx24 reg_idx32 addr32            */ \
+V(CHECK_REGISTER_LT, 42, 12)  /* bc8 reg_idx24 value32 addr32               */ \
+V(CHECK_REGISTER_GE, 43, 12)  /* bc8 reg_idx24 value32 addr32               */ \
+V(CHECK_REGISTER_EQ_POS, 44, 8) /* bc8 reg_idx24 addr32                     */ \
+V(CHECK_AT_START,    45, 8)   /* bc8 pad24 addr32                           */ \
+V(CHECK_NOT_AT_START, 46, 8)  /* bc8 offset24 addr32                        */ \
+V(CHECK_GREEDY,      47, 8)   /* bc8 pad24 addr32                           */ \
+V(ADVANCE_CP_AND_GOTO, 48, 8) /* bc8 offset24 addr32                        */ \
+V(SET_CURRENT_POSITION_FROM_END, 49, 4) /* bc8 idx24                        */
 
 // clang-format on
 
diff --git a/runtime/vm/regexp_interpreter.cc b/runtime/vm/regexp_interpreter.cc
index 2921e3e..94c44ec 100644
--- a/runtime/vm/regexp_interpreter.cc
+++ b/runtime/vm/regexp_interpreter.cc
@@ -24,25 +24,27 @@
                                  intptr_t from,
                                  intptr_t current,
                                  intptr_t len,
-                                 const String& subject,
-                                 bool unicode);
+                                 const String& subject);
 
 template <>
 bool BackRefMatchesNoCase<uint16_t>(Canonicalize* interp_canonicalize,
                                     intptr_t from,
                                     intptr_t current,
                                     intptr_t len,
-                                    const String& subject,
-                                    bool unicode) {
-  Bool& ret = Bool::Handle();
-  if (unicode) {
-    ret = CaseInsensitiveCompareUTF16(subject.raw(), Smi::New(from),
-                                      Smi::New(current), Smi::New(len));
-  } else {
-    ret = CaseInsensitiveCompareUCS2(subject.raw(), Smi::New(from),
-                                     Smi::New(current), Smi::New(len));
+                                    const String& subject) {
+  for (int i = 0; i < len; i++) {
+    int32_t old_char = subject.CharAt(from++);
+    int32_t new_char = subject.CharAt(current++);
+    if (old_char == new_char) continue;
+    int32_t old_string[1] = {old_char};
+    int32_t new_string[1] = {new_char};
+    interp_canonicalize->get(old_char, '\0', old_string);
+    interp_canonicalize->get(new_char, '\0', new_string);
+    if (old_string[0] != new_string[0]) {
+      return false;
+    }
   }
-  return ret.value();
+  return true;
 }
 
 template <>
@@ -50,9 +52,7 @@
                                    intptr_t from,
                                    intptr_t current,
                                    intptr_t len,
-                                   const String& subject,
-                                   bool unicode) {
-  // For Latin1 characters the unicode flag makes no difference.
+                                   const String& subject) {
   for (int i = 0; i < len; i++) {
     unsigned int old_char = subject.CharAt(from++);
     unsigned int new_char = subject.CharAt(current++);
@@ -513,11 +513,7 @@
         pc += BC_CHECK_NOT_BACK_REF_LENGTH;
         break;
       }
-      BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_UNICODE)
-      FALL_THROUGH;
       BYTECODE(CHECK_NOT_BACK_REF_NO_CASE) {
-        const bool unicode =
-            (insn & BYTECODE_MASK) == BC_CHECK_NOT_BACK_REF_NO_CASE_UNICODE;
         int from = registers[insn >> BYTECODE_SHIFT];
         int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
         if (from < 0 || len <= 0) {
@@ -529,7 +525,7 @@
           break;
         } else {
           if (BackRefMatchesNoCase<Char>(&canonicalize, from, current, len,
-                                         subject, unicode)) {
+                                         subject)) {
             current += len;
             pc += BC_CHECK_NOT_BACK_REF_NO_CASE_LENGTH;
           } else {
@@ -566,11 +562,7 @@
         pc += BC_CHECK_NOT_BACK_REF_BACKWARD_LENGTH;
         break;
       }
-      BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_UNICODE_BACKWARD)
-      FALL_THROUGH;
       BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_BACKWARD) {
-        bool unicode = (insn & BYTECODE_MASK) ==
-                       BC_CHECK_NOT_BACK_REF_NO_CASE_UNICODE_BACKWARD;
         int from = registers[insn >> BYTECODE_SHIFT];
         int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
         if (from < 0 || len <= 0) {
@@ -582,7 +574,7 @@
           break;
         } else {
           if (BackRefMatchesNoCase<Char>(&canonicalize, from, current - len,
-                                         len, subject, unicode)) {
+                                         len, subject)) {
             current -= len;
             pc += BC_CHECK_NOT_BACK_REF_NO_CASE_BACKWARD_LENGTH;
           } else {
diff --git a/runtime/vm/regexp_parser.cc b/runtime/vm/regexp_parser.cc
index 31aff3f..b70b945 100644
--- a/runtime/vm/regexp_parser.cc
+++ b/runtime/vm/regexp_parser.cc
@@ -3,12 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/regexp_parser.h"
-
-#include "unicode/uchar.h"
-#include "unicode/uniset.h"
-
-#include "platform/unicode.h"
-
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 
@@ -19,12 +13,10 @@
 // Enables possessive quantifier syntax for testing.
 static const bool FLAG_regexp_possessive_quantifier = false;
 
-RegExpBuilder::RegExpBuilder(RegExpFlags flags)
+RegExpBuilder::RegExpBuilder()
     : zone_(Thread::Current()->zone()),
       pending_empty_(false),
-      flags_(flags),
       characters_(NULL),
-      pending_surrogate_(kNoPendingSurrogate),
       terms_(),
       text_(),
       alternatives_()
@@ -35,49 +27,10 @@
 {
 }
 
-void RegExpBuilder::AddLeadSurrogate(uint16_t lead_surrogate) {
-  ASSERT(Utf16::IsLeadSurrogate(lead_surrogate));
-  FlushPendingSurrogate();
-  // Hold onto the lead surrogate, waiting for a trail surrogate to follow.
-  pending_surrogate_ = lead_surrogate;
-}
-
-void RegExpBuilder::AddTrailSurrogate(uint16_t trail_surrogate) {
-  ASSERT(Utf16::IsTrailSurrogate(trail_surrogate));
-  if (pending_surrogate_ != kNoPendingSurrogate) {
-    uint16_t lead_surrogate = pending_surrogate_;
-    pending_surrogate_ = kNoPendingSurrogate;
-    ASSERT(Utf16::IsLeadSurrogate(lead_surrogate));
-    uint32_t combined = Utf16::Decode(lead_surrogate, trail_surrogate);
-    if (NeedsDesugaringForIgnoreCase(combined)) {
-      AddCharacterClassForDesugaring(combined);
-    } else {
-      auto surrogate_pair = new (Z) ZoneGrowableArray<uint16_t>(2);
-      surrogate_pair->Add(lead_surrogate);
-      surrogate_pair->Add(trail_surrogate);
-      RegExpAtom* atom = new (Z) RegExpAtom(surrogate_pair, flags_);
-      AddAtom(atom);
-    }
-  } else {
-    pending_surrogate_ = trail_surrogate;
-    FlushPendingSurrogate();
-  }
-}
-
-void RegExpBuilder::FlushPendingSurrogate() {
-  if (pending_surrogate_ != kNoPendingSurrogate) {
-    ASSERT(is_unicode());
-    uint32_t c = pending_surrogate_;
-    pending_surrogate_ = kNoPendingSurrogate;
-    AddCharacterClassForDesugaring(c);
-  }
-}
-
 void RegExpBuilder::FlushCharacters() {
-  FlushPendingSurrogate();
   pending_empty_ = false;
   if (characters_ != NULL) {
-    RegExpTree* atom = new (Z) RegExpAtom(characters_, flags_);
+    RegExpTree* atom = new (Z) RegExpAtom(characters_);
     characters_ = NULL;
     text_.Add(atom);
     LAST(ADD_ATOM);
@@ -101,62 +54,18 @@
 }
 
 void RegExpBuilder::AddCharacter(uint16_t c) {
-  FlushPendingSurrogate();
   pending_empty_ = false;
-  if (NeedsDesugaringForIgnoreCase(c)) {
-    AddCharacterClassForDesugaring(c);
-  } else {
-    if (characters_ == NULL) {
-      characters_ = new (Z) ZoneGrowableArray<uint16_t>(4);
-    }
-    characters_->Add(c);
-    LAST(ADD_CHAR);
+  if (characters_ == NULL) {
+    characters_ = new (Z) ZoneGrowableArray<uint16_t>(4);
   }
-}
-
-void RegExpBuilder::AddUnicodeCharacter(uint32_t c) {
-  if (c > static_cast<uint32_t>(Utf16::kMaxCodeUnit)) {
-    ASSERT(is_unicode());
-    uint16_t surrogates[2];
-    Utf16::Encode(c, surrogates);
-    AddLeadSurrogate(surrogates[0]);
-    AddTrailSurrogate(surrogates[1]);
-  } else if (is_unicode() && Utf16::IsLeadSurrogate(c)) {
-    AddLeadSurrogate(c);
-  } else if (is_unicode() && Utf16::IsTrailSurrogate(c)) {
-    AddTrailSurrogate(c);
-  } else {
-    AddCharacter(static_cast<uint16_t>(c));
-  }
-}
-
-void RegExpBuilder::AddEscapedUnicodeCharacter(uint32_t character) {
-  // A lead or trail surrogate parsed via escape sequence will not
-  // pair up with any preceding lead or following trail surrogate.
-  FlushPendingSurrogate();
-  AddUnicodeCharacter(character);
-  FlushPendingSurrogate();
+  characters_->Add(c);
+  LAST(ADD_CHAR);
 }
 
 void RegExpBuilder::AddEmpty() {
   pending_empty_ = true;
 }
 
-void RegExpBuilder::AddCharacterClass(RegExpCharacterClass* cc) {
-  if (NeedsDesugaringForUnicode(cc)) {
-    // With /u, character class needs to be desugared, so it
-    // must be a standalone term instead of being part of a RegExpText.
-    AddTerm(cc);
-  } else {
-    AddAtom(cc);
-  }
-}
-
-void RegExpBuilder::AddCharacterClassForDesugaring(uint32_t c) {
-  auto ranges = CharacterRange::List(Z, CharacterRange::Singleton(c));
-  AddTerm(new (Z) RegExpCharacterClass(ranges, flags_));
-}
-
 void RegExpBuilder::AddAtom(RegExpTree* term) {
   if (term->IsEmpty()) {
     AddEmpty();
@@ -172,12 +81,6 @@
   LAST(ADD_ATOM);
 }
 
-void RegExpBuilder::AddTerm(RegExpTree* term) {
-  FlushText();
-  terms_.Add(term);
-  LAST(ADD_ATOM);
-}
-
 void RegExpBuilder::AddAssertion(RegExpTree* assert) {
   FlushText();
   terms_.Add(assert);
@@ -209,37 +112,6 @@
   LAST(ADD_NONE);
 }
 
-bool RegExpBuilder::NeedsDesugaringForUnicode(RegExpCharacterClass* cc) {
-  if (!is_unicode()) return false;
-  // TODO(yangguo): we could be smarter than this. Case-insensitivity does not
-  // necessarily mean that we need to desugar. It's probably nicer to have a
-  // separate pass to figure out unicode desugarings.
-  if (ignore_case()) return true;
-  ZoneGrowableArray<CharacterRange>* ranges = cc->ranges();
-  CharacterRange::Canonicalize(ranges);
-  for (int i = ranges->length() - 1; i >= 0; i--) {
-    uint32_t from = ranges->At(i).from();
-    uint32_t to = ranges->At(i).to();
-    // Check for non-BMP characters.
-    if (to >= Utf16::kMaxCodeUnit) return true;
-    // Check for lone surrogates.
-    if (from <= Utf16::kTrailSurrogateEnd && to >= Utf16::kLeadSurrogateStart) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool RegExpBuilder::NeedsDesugaringForIgnoreCase(uint32_t c) {
-  if (is_unicode() && ignore_case()) {
-    icu::UnicodeSet set(c, c);
-    set.closeOver(USET_CASE_INSENSITIVE);
-    set.removeAllStrings();
-    return set.size() > 1;
-  }
-  return false;
-}
-
 RegExpTree* RegExpBuilder::ToRegExp() {
   FlushTerms();
   intptr_t num_alternatives = alternatives_.length();
@@ -280,13 +152,13 @@
       for (intptr_t i = 0; i < num_chars - 1; i++) {
         prefix->Add(char_vector->At(i));
       }
-      text_.Add(new (Z) RegExpAtom(prefix, flags_));
+      text_.Add(new (Z) RegExpAtom(prefix));
       ZoneGrowableArray<uint16_t>* tail = new (Z) ZoneGrowableArray<uint16_t>();
       tail->Add(char_vector->At(num_chars - 1));
       char_vector = tail;
     }
     characters_ = NULL;
-    atom = new (Z) RegExpAtom(char_vector, flags_);
+    atom = new (Z) RegExpAtom(char_vector);
     FlushText();
   } else if (text_.length() > 0) {
     DEBUG_ASSERT(last_added_ == ADD_ATOM);
@@ -296,8 +168,6 @@
     DEBUG_ASSERT(last_added_ == ADD_ATOM);
     atom = terms_.RemoveLast();
     if (auto lookaround = atom->AsLookaround()) {
-      // With /u, lookarounds are not quantifiable.
-      if (is_unicode()) return false;
       // Lookbehinds are not quantifiable.
       if (lookaround->type() == RegExpLookaround::LOOKBEHIND) {
         return false;
@@ -324,7 +194,7 @@
 // ----------------------------------------------------------------------------
 // Implementation of Parser
 
-RegExpParser::RegExpParser(const String& in, String* error, RegExpFlags flags)
+RegExpParser::RegExpParser(const String& in, String* error, bool multiline)
     : zone_(Thread::Current()->zone()),
       captures_(nullptr),
       named_captures_(nullptr),
@@ -335,7 +205,7 @@
       captures_started_(0),
       capture_count_(0),
       has_more_(true),
-      top_level_flags_(flags),
+      multiline_(multiline),
       simple_(false),
       contains_anchor_(false),
       is_scanned_for_captures_(false),
@@ -343,38 +213,20 @@
   Advance();
 }
 
-inline uint32_t RegExpParser::ReadNext(bool update_position) {
-  intptr_t position = next_pos_;
-  const uint16_t c0 = in().CharAt(position);
-  uint32_t c = c0;
-  position++;
-  if (is_unicode() && position < in().Length() && Utf16::IsLeadSurrogate(c0)) {
-    const uint16_t c1 = in().CharAt(position);
-    if (Utf16::IsTrailSurrogate(c1)) {
-      c = Utf16::Decode(c0, c1);
-      position++;
-    }
-  }
-  if (update_position) next_pos_ = position;
-  return c;
-}
-
 uint32_t RegExpParser::Next() {
   if (has_next()) {
-    return ReadNext(false);
+    return in().CharAt(next_pos_);
   } else {
     return kEndMarker;
   }
 }
 
 void RegExpParser::Advance() {
-  if (has_next()) {
-    current_ = ReadNext(true);
+  if (next_pos_ < in().Length()) {
+    current_ = in().CharAt(next_pos_);
+    next_pos_++;
   } else {
     current_ = kEndMarker;
-    // Advance so that position() points to 1 after the last character. This is
-    // important so that Reset() to this position works correctly.
-    next_pos_ = in().Length() + 1;
     has_more_ = false;
   }
 }
@@ -394,30 +246,6 @@
   return simple_;
 }
 
-bool RegExpParser::IsSyntaxCharacterOrSlash(uint32_t c) {
-  switch (c) {
-    case '^':
-    case '$':
-    case '\\':
-    case '.':
-    case '*':
-    case '+':
-    case '?':
-    case '(':
-    case ')':
-    case '[':
-    case ']':
-    case '{':
-    case '}':
-    case '|':
-    case '/':
-      return true;
-    default:
-      break;
-  }
-  return false;
-}
-
 void RegExpParser::ReportError(const char* message) {
   // Zip to the end to make sure the no more input is read.
   current_ = kEndMarker;
@@ -446,11 +274,6 @@
   return result;
 }
 
-// Used for error messages where we would have fallen back on treating an
-// escape as the identity escape, but we are in Unicode mode.
-static const char* kUnicodeIdentity =
-    "Invalid identity escape in Unicode pattern";
-
 // Disjunction ::
 //   Alternative
 //   Alternative | Disjunction
@@ -464,7 +287,7 @@
 RegExpTree* RegExpParser::ParseDisjunction() {
   // Used to store current state while parsing subexpressions.
   RegExpParserState initial_state(nullptr, INITIAL, RegExpLookaround::LOOKAHEAD,
-                                  0, nullptr, top_level_flags_, Z);
+                                  0, nullptr, Z);
   RegExpParserState* stored_state = &initial_state;
   // Cache the builder in a local variable for quick access.
   RegExpBuilder* builder = initial_state.builder();
@@ -535,12 +358,12 @@
         UNREACHABLE();
       case '^': {
         Advance();
-        if (builder->is_multi_line()) {
-          builder->AddAssertion(new (Z) RegExpAssertion(
-              RegExpAssertion::START_OF_LINE, builder->flags()));
+        if (multiline_) {
+          builder->AddAssertion(
+              new (Z) RegExpAssertion(RegExpAssertion::START_OF_LINE));
         } else {
-          builder->AddAssertion(new (Z) RegExpAssertion(
-              RegExpAssertion::START_OF_INPUT, builder->flags()));
+          builder->AddAssertion(
+              new (Z) RegExpAssertion(RegExpAssertion::START_OF_INPUT));
           set_contains_anchor();
         }
         continue;
@@ -548,29 +371,19 @@
       case '$': {
         Advance();
         RegExpAssertion::AssertionType assertion_type =
-            builder->is_multi_line() ? RegExpAssertion::END_OF_LINE
-                                     : RegExpAssertion::END_OF_INPUT;
-        builder->AddAssertion(
-            new (Z) RegExpAssertion(assertion_type, builder->flags()));
+            multiline_ ? RegExpAssertion::END_OF_LINE
+                       : RegExpAssertion::END_OF_INPUT;
+        builder->AddAssertion(new RegExpAssertion(assertion_type));
         continue;
       }
       case '.': {
         Advance();
-        auto ranges = new (Z) ZoneGrowableArray<CharacterRange>(2);
-        if (builder->is_dot_all()) {
-          // Everything.
-          CharacterRange::AddClassEscape(
-              '*', ranges,
-              /*add_unicode_case_equivalents=*/false);
-        } else {
-          // everything except \x0a, \x0d, \u2028 and \u2029
-          CharacterRange::AddClassEscape(
-              '.', ranges,
-              /*add_unicode_case_equivalents=*/false);
-        }
-        RegExpCharacterClass* cc =
-            new (Z) RegExpCharacterClass(ranges, builder->flags());
-        builder->AddCharacterClass(cc);
+        // everything except \x0a, \x0d, \u2028 and \u2029
+        ZoneGrowableArray<CharacterRange>* ranges =
+            new ZoneGrowableArray<CharacterRange>(2);
+        CharacterRange::AddClassEscape('.', ranges);
+        RegExpTree* atom = new RegExpCharacterClass(ranges, false);
+        builder->AddAtom(atom);
         break;
       }
       case '(': {
@@ -579,8 +392,8 @@
         continue;
       }
       case '[': {
-        RegExpTree* atom = ParseCharacterClass(builder);
-        builder->AddCharacterClass(atom->AsCharacterClass());
+        RegExpTree* atom = ParseCharacterClass();
+        builder->AddAtom(atom);
         break;
       }
       // Atom ::
@@ -592,13 +405,13 @@
             UNREACHABLE();
           case 'b':
             Advance(2);
-            builder->AddAssertion(new (Z) RegExpAssertion(
-                RegExpAssertion::BOUNDARY, builder->flags()));
+            builder->AddAssertion(
+                new RegExpAssertion(RegExpAssertion::BOUNDARY));
             continue;
           case 'B':
             Advance(2);
-            builder->AddAssertion(new (Z) RegExpAssertion(
-                RegExpAssertion::NON_BOUNDARY, builder->flags()));
+            builder->AddAssertion(
+                new RegExpAssertion(RegExpAssertion::NON_BOUNDARY));
             continue;
           // AtomEscape ::
           //   CharacterClassEscape
@@ -613,36 +426,11 @@
           case 'W': {
             uint32_t c = Next();
             Advance(2);
-            auto ranges = new (Z) ZoneGrowableArray<CharacterRange>(2);
-            CharacterRange::AddClassEscape(
-                c, ranges, is_unicode() && builder->ignore_case());
-            RegExpCharacterClass* cc =
-                new (Z) RegExpCharacterClass(ranges, builder->flags());
-            builder->AddCharacterClass(cc);
-            break;
-          }
-          case 'p':
-          case 'P': {
-            uint32_t p = Next();
-            Advance(2);
-
-            if (is_unicode()) {
-              auto name_1 = new (Z) ZoneGrowableArray<char>();
-              auto name_2 = new (Z) ZoneGrowableArray<char>();
-              auto ranges = new (Z) ZoneGrowableArray<CharacterRange>(2);
-              if (ParsePropertyClassName(name_1, name_2)) {
-                if (AddPropertyClassRange(ranges, p == 'P', name_1, name_2)) {
-                  RegExpCharacterClass* cc =
-                      new (Z) RegExpCharacterClass(ranges, builder->flags());
-                  builder->AddCharacterClass(cc);
-                  break;
-                }
-              }
-              ReportError("Invalid property name");
-              UNREACHABLE();
-            } else {
-              builder->AddCharacter(p);
-            }
+            ZoneGrowableArray<CharacterRange>* ranges =
+                new ZoneGrowableArray<CharacterRange>(2);
+            CharacterRange::AddClassEscape(c, ranges);
+            RegExpTree* atom = new RegExpCharacterClass(ranges, false);
+            builder->AddAtom(atom);
             break;
           }
           case '1':
@@ -665,20 +453,14 @@
                 builder->AddEmpty();
               } else {
                 RegExpCapture* capture = GetCapture(index);
-                RegExpTree* atom =
-                    new (Z) RegExpBackReference(capture, builder->flags());
+                RegExpTree* atom = new RegExpBackReference(capture);
                 builder->AddAtom(atom);
               }
               break;
             }
-            // With /u, no identity escapes except for syntax characters are
-            // allowed. Otherwise, all identity escapes are allowed.
-            if (is_unicode()) {
-              ReportError(kUnicodeIdentity);
-              UNREACHABLE();
-            }
             uint32_t first_digit = Next();
             if (first_digit == '8' || first_digit == '9') {
+              // Treat as identity escape
               builder->AddCharacter(first_digit);
               Advance(2);
               break;
@@ -687,11 +469,6 @@
           }
           case '0': {
             Advance();
-            if (is_unicode() && Next() >= '0' && Next() <= '9') {
-              // With /u, decimal escape with leading 0 are not parsed as octal.
-              ReportError("Invalid decimal escape");
-              UNREACHABLE();
-            }
             uint32_t octal = ParseOctalLiteral();
             builder->AddCharacter(octal);
             break;
@@ -729,11 +506,6 @@
               // This is outside the specification. We match JSC in
               // reading the backslash as a literal character instead
               // of as starting an escape.
-              if (is_unicode()) {
-                // With /u, invalid escapes are not treated as identity escapes.
-                ReportError(kUnicodeIdentity);
-                UNREACHABLE();
-              }
               builder->AddCharacter('\\');
             } else {
               Advance(2);
@@ -746,26 +518,18 @@
             uint32_t value;
             if (ParseHexEscape(2, &value)) {
               builder->AddCharacter(value);
-            } else if (!is_unicode()) {
-              builder->AddCharacter('x');
             } else {
-              // With /u, invalid escapes are not treated as identity escapes.
-              ReportError(kUnicodeIdentity);
-              UNREACHABLE();
+              builder->AddCharacter('x');
             }
             break;
           }
           case 'u': {
             Advance(2);
             uint32_t value;
-            if (ParseUnicodeEscape(&value)) {
-              builder->AddEscapedUnicodeCharacter(value);
-            } else if (!is_unicode()) {
-              builder->AddCharacter('u');
+            if (ParseHexEscape(4, &value)) {
+              builder->AddCharacter(value);
             } else {
-              // With /u, invalid escapes are not treated as identity escapes.
-              ReportError(kUnicodeIdentity);
-              UNREACHABLE();
+              builder->AddCharacter('u');
             }
             break;
           }
@@ -775,24 +539,16 @@
             // an identity escape for non-Unicode patterns without named
             // capture groups, and as the beginning of a named back-reference
             // in all other cases.
-            if (is_unicode() || HasNamedCaptures()) {
+            if (HasNamedCaptures()) {
               Advance(2);
               ParseNamedBackReference(builder, stored_state);
               break;
             }
             FALL_THROUGH;
           default:
-            Advance();
-            // With the unicode flag, no identity escapes except for syntax
-            // characters are allowed. Otherwise, all identity escapes are
-            // allowed.
-            if (!is_unicode() || IsSyntaxCharacterOrSlash(current())) {
-              builder->AddCharacter(current());
-              Advance();
-            } else {
-              ReportError(kUnicodeIdentity);
-              UNREACHABLE();
-            }
+            // Identity escape.
+            builder->AddCharacter(Next());
+            Advance(2);
             break;
         }
         break;
@@ -804,15 +560,8 @@
         }
         FALL_THROUGH;
       }
-      case '}':
-      case ']':
-        if (is_unicode()) {
-          ReportError("Lone quantifier brackets");
-          UNREACHABLE();
-        }
-        FALL_THROUGH;
       default:
-        builder->AddUnicodeCharacter(current());
+        builder->AddCharacter(current());
         Advance();
         break;
     }  // end switch(current())
@@ -944,9 +693,8 @@
     }
   }
   // Store current state and begin new disjunction parsing.
-  return new (Z)
-      RegExpParserState(state, subexpr_type, lookaround_type, captures_started_,
-                        capture_name, state->builder()->flags(), Z);
+  return new RegExpParserState(state, subexpr_type, lookaround_type,
+                               captures_started_, capture_name, Z);
 }
 
 // In order to know whether an escape is a backreference or not we have to scan
@@ -1008,6 +756,10 @@
   Reset(saved_position);
 }
 
+static inline bool IsDecimalDigit(int32_t c) {
+  return '0' <= c && c <= '9';
+}
+
 bool RegExpParser::ParseBackReferenceIndex(intptr_t* index_out) {
   ASSERT('\\' == current());
   ASSERT('1' <= Next() && Next() <= '9');
@@ -1018,7 +770,7 @@
   Advance(2);
   while (true) {
     uint32_t c = current();
-    if (Utils::IsDecimalDigit(c)) {
+    if (IsDecimalDigit(c)) {
       value = 10 * value + (c - '0');
       if (value > kMaxCaptures) {
         Reset(start);
@@ -1042,43 +794,17 @@
 
 namespace {
 
-static inline constexpr bool IsAsciiIdentifierPart(uint32_t ch) {
-  return Utils::IsAlphaNumeric(ch) || ch == '_' || ch == '$';
+inline constexpr bool IsIdentifierStart(uint16_t ch) {
+  return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || ch == '_' ||
+         ch == '$';
 }
 
-// ES#sec-names-and-keywords Names and Keywords
-// UnicodeIDStart, '$', '_' and '\'
-static bool IsIdentifierStartSlow(uint32_t c) {
-  // cannot use u_isIDStart because it does not work for
-  // Other_ID_Start characters.
-  return u_hasBinaryProperty(c, UCHAR_ID_START) ||
-         (c < 0x60 && (c == '$' || c == '\\' || c == '_'));
+inline constexpr bool IsIdentifierPart(uint16_t ch) {
+  return IsIdentifierStart(ch) || (ch >= '0' && ch <= '9');
 }
 
-// ES#sec-names-and-keywords Names and Keywords
-// UnicodeIDContinue, '$', '_', '\', ZWJ, and ZWNJ
-static bool IsIdentifierPartSlow(uint32_t c) {
-  const uint32_t kZeroWidthNonJoiner = 0x200C;
-  const uint32_t kZeroWidthJoiner = 0x200D;
-  // Can't use u_isIDPart because it does not work for
-  // Other_ID_Continue characters.
-  return u_hasBinaryProperty(c, UCHAR_ID_CONTINUE) ||
-         (c < 0x60 && (c == '$' || c == '\\' || c == '_')) ||
-         c == kZeroWidthNonJoiner || c == kZeroWidthJoiner;
-}
-
-static inline bool IsIdentifierStart(uint32_t c) {
-  if (c > 127) return IsIdentifierStartSlow(c);
-  return IsAsciiIdentifierPart(c) && !Utils::IsDecimalDigit(c);
-}
-
-static inline bool IsIdentifierPart(uint32_t c) {
-  if (c > 127) return IsIdentifierPartSlow(c);
-  return IsAsciiIdentifierPart(c);
-}
-
-static bool IsSameName(const RegExpCaptureName* name1,
-                       const RegExpCaptureName* name2) {
+bool IsSameName(const RegExpCaptureName* name1,
+                const RegExpCaptureName* name2) {
   if (name1->length() != name2->length()) return false;
   for (intptr_t i = 0; i < name1->length(); i++) {
     if (name1->At(i) != name2->At(i)) return false;
@@ -1088,34 +814,14 @@
 
 }  // end namespace
 
-static void PushCodeUnit(RegExpCaptureName* v, uint32_t code_unit) {
-  if (code_unit <= Utf16::kMaxCodeUnit) {
-    v->Add(code_unit);
-  } else {
-    uint16_t units[2];
-    Utf16::Encode(code_unit, units);
-    v->Add(units[0]);
-    v->Add(units[1]);
-  }
-}
-
 const RegExpCaptureName* RegExpParser::ParseCaptureGroupName() {
   auto name = new (Z) RegExpCaptureName();
 
   bool at_start = true;
   while (true) {
-    uint32_t c = current();
+    const uint16_t c = current();
     Advance();
 
-    // Convert unicode escapes.
-    if (c == '\\' && current() == 'u') {
-      Advance();
-      if (!ParseUnicodeEscape(&c)) {
-        ReportError("Invalid Unicode escape sequence");
-        UNREACHABLE();
-      }
-    }
-
     // The backslash char is misclassified as both ID_Start and ID_Continue.
     if (c == '\\') {
       ReportError("Invalid capture group name");
@@ -1127,13 +833,13 @@
         ReportError("Invalid capture group name");
         UNREACHABLE();
       }
-      PushCodeUnit(name, c);
+      name->Add(c);
       at_start = false;
     } else {
       if (c == '>') {
         break;
       } else if (IsIdentifierPart(c)) {
-        PushCodeUnit(name, c);
+        name->Add(c);
       } else {
         ReportError("Invalid capture group name");
         UNREACHABLE();
@@ -1190,7 +896,7 @@
   if (state->IsInsideCaptureGroup(name)) {
     builder->AddEmpty();
   } else {
-    RegExpBackReference* atom = new (Z) RegExpBackReference(builder->flags());
+    RegExpBackReference* atom = new (Z) RegExpBackReference();
     atom->set_name(name);
 
     builder->AddAtom(atom);
@@ -1309,17 +1015,17 @@
   intptr_t start = position();
   Advance();
   intptr_t min = 0;
-  if (!Utils::IsDecimalDigit(current())) {
+  if (!IsDecimalDigit(current())) {
     Reset(start);
     return false;
   }
-  while (Utils::IsDecimalDigit(current())) {
+  while (IsDecimalDigit(current())) {
     intptr_t next = current() - '0';
     if (min > (RegExpTree::kInfinity - next) / 10) {
       // Overflow. Skip past remaining decimal digits and return -1.
       do {
         Advance();
-      } while (Utils::IsDecimalDigit(current()));
+      } while (IsDecimalDigit(current()));
       min = RegExpTree::kInfinity;
       break;
     }
@@ -1336,12 +1042,12 @@
       max = RegExpTree::kInfinity;
       Advance();
     } else {
-      while (Utils::IsDecimalDigit(current())) {
+      while (IsDecimalDigit(current())) {
         intptr_t next = current() - '0';
         if (max > (RegExpTree::kInfinity - next) / 10) {
           do {
             Advance();
-          } while (Utils::IsDecimalDigit(current()));
+          } while (IsDecimalDigit(current()));
           max = RegExpTree::kInfinity;
           break;
         }
@@ -1411,317 +1117,6 @@
   return true;
 }
 
-// This parses RegExpUnicodeEscapeSequence as described in ECMA262.
-bool RegExpParser::ParseUnicodeEscape(uint32_t* value) {
-  // Accept both \uxxxx and \u{xxxxxx} (if harmony unicode escapes are
-  // allowed). In the latter case, the number of hex digits between { } is
-  // arbitrary. \ and u have already been read.
-  if (current() == '{' && is_unicode()) {
-    int start = position();
-    Advance();
-    if (ParseUnlimitedLengthHexNumber(Utf::kMaxCodePoint, value)) {
-      if (current() == '}') {
-        Advance();
-        return true;
-      }
-    }
-    Reset(start);
-    return false;
-  }
-  // \u but no {, or \u{...} escapes not allowed.
-  bool result = ParseHexEscape(4, value);
-  if (result && is_unicode() && Utf16::IsLeadSurrogate(*value) &&
-      current() == '\\') {
-    // Attempt to read trail surrogate.
-    int start = position();
-    if (Next() == 'u') {
-      Advance(2);
-      uint32_t trail;
-      if (ParseHexEscape(4, &trail) && Utf16::IsTrailSurrogate(trail)) {
-        *value = Utf16::Decode(static_cast<uint16_t>(*value),
-                               static_cast<uint16_t>(trail));
-        return true;
-      }
-    }
-    Reset(start);
-  }
-  return result;
-}
-
-namespace {
-
-bool IsExactPropertyAlias(const char* property_name, UProperty property) {
-  const char* short_name = u_getPropertyName(property, U_SHORT_PROPERTY_NAME);
-  if (short_name != nullptr && strcmp(property_name, short_name) == 0) {
-    return true;
-  }
-  for (int i = 0;; i++) {
-    const char* long_name = u_getPropertyName(
-        property, static_cast<UPropertyNameChoice>(U_LONG_PROPERTY_NAME + i));
-    if (long_name == nullptr) break;
-    if (strcmp(property_name, long_name) == 0) return true;
-  }
-  return false;
-}
-
-bool IsExactPropertyValueAlias(const char* property_value_name,
-                               UProperty property,
-                               int32_t property_value) {
-  const char* short_name =
-      u_getPropertyValueName(property, property_value, U_SHORT_PROPERTY_NAME);
-  if (short_name != nullptr && strcmp(property_value_name, short_name) == 0) {
-    return true;
-  }
-  for (int i = 0;; i++) {
-    const char* long_name = u_getPropertyValueName(
-        property, property_value,
-        static_cast<UPropertyNameChoice>(U_LONG_PROPERTY_NAME + i));
-    if (long_name == nullptr) break;
-    if (strcmp(property_value_name, long_name) == 0) return true;
-  }
-  return false;
-}
-
-bool LookupPropertyValueName(UProperty property,
-                             const char* property_value_name,
-                             bool negate,
-                             ZoneGrowableArray<CharacterRange>* result) {
-  UProperty property_for_lookup = property;
-  if (property_for_lookup == UCHAR_SCRIPT_EXTENSIONS) {
-    // For the property Script_Extensions, we have to do the property value
-    // name lookup as if the property is Script.
-    property_for_lookup = UCHAR_SCRIPT;
-  }
-  int32_t property_value =
-      u_getPropertyValueEnum(property_for_lookup, property_value_name);
-  if (property_value == UCHAR_INVALID_CODE) return false;
-
-  // We require the property name to match exactly to one of the property value
-  // aliases. However, u_getPropertyValueEnum uses loose matching.
-  if (!IsExactPropertyValueAlias(property_value_name, property_for_lookup,
-                                 property_value)) {
-    return false;
-  }
-
-  UErrorCode ec = U_ZERO_ERROR;
-  icu::UnicodeSet set;
-  set.applyIntPropertyValue(property, property_value, ec);
-  bool success = ec == U_ZERO_ERROR && !set.isEmpty();
-
-  if (success) {
-    set.removeAllStrings();
-    if (negate) set.complement();
-    for (int i = 0; i < set.getRangeCount(); i++) {
-      result->Add(
-          CharacterRange::Range(set.getRangeStart(i), set.getRangeEnd(i)));
-    }
-  }
-  return success;
-}
-
-template <size_t N>
-inline bool NameEquals(const char* name, const char (&literal)[N]) {
-  return strncmp(name, literal, N + 1) == 0;
-}
-
-bool LookupSpecialPropertyValueName(const char* name,
-                                    ZoneGrowableArray<CharacterRange>* result,
-                                    bool negate) {
-  if (NameEquals(name, "Any")) {
-    if (negate) {
-      // Leave the list of character ranges empty, since the negation of 'Any'
-      // is the empty set.
-    } else {
-      result->Add(CharacterRange::Everything());
-    }
-  } else if (NameEquals(name, "ASCII")) {
-    result->Add(negate ? CharacterRange::Range(0x80, Utf::kMaxCodePoint)
-                       : CharacterRange::Range(0x0, 0x7F));
-  } else if (NameEquals(name, "Assigned")) {
-    return LookupPropertyValueName(UCHAR_GENERAL_CATEGORY, "Unassigned",
-                                   !negate, result);
-  } else {
-    return false;
-  }
-  return true;
-}
-
-// Explicitly whitelist supported binary properties. The spec forbids supporting
-// properties outside of this set to ensure interoperability.
-bool IsSupportedBinaryProperty(UProperty property) {
-  switch (property) {
-    case UCHAR_ALPHABETIC:
-    // 'Any' is not supported by ICU. See LookupSpecialPropertyValueName.
-    // 'ASCII' is not supported by ICU. See LookupSpecialPropertyValueName.
-    case UCHAR_ASCII_HEX_DIGIT:
-    // 'Assigned' is not supported by ICU. See LookupSpecialPropertyValueName.
-    case UCHAR_BIDI_CONTROL:
-    case UCHAR_BIDI_MIRRORED:
-    case UCHAR_CASE_IGNORABLE:
-    case UCHAR_CASED:
-    case UCHAR_CHANGES_WHEN_CASEFOLDED:
-    case UCHAR_CHANGES_WHEN_CASEMAPPED:
-    case UCHAR_CHANGES_WHEN_LOWERCASED:
-    case UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED:
-    case UCHAR_CHANGES_WHEN_TITLECASED:
-    case UCHAR_CHANGES_WHEN_UPPERCASED:
-    case UCHAR_DASH:
-    case UCHAR_DEFAULT_IGNORABLE_CODE_POINT:
-    case UCHAR_DEPRECATED:
-    case UCHAR_DIACRITIC:
-    case UCHAR_EMOJI:
-    case UCHAR_EMOJI_COMPONENT:
-    case UCHAR_EMOJI_MODIFIER_BASE:
-    case UCHAR_EMOJI_MODIFIER:
-    case UCHAR_EMOJI_PRESENTATION:
-    case UCHAR_EXTENDED_PICTOGRAPHIC:
-    case UCHAR_EXTENDER:
-    case UCHAR_GRAPHEME_BASE:
-    case UCHAR_GRAPHEME_EXTEND:
-    case UCHAR_HEX_DIGIT:
-    case UCHAR_ID_CONTINUE:
-    case UCHAR_ID_START:
-    case UCHAR_IDEOGRAPHIC:
-    case UCHAR_IDS_BINARY_OPERATOR:
-    case UCHAR_IDS_TRINARY_OPERATOR:
-    case UCHAR_JOIN_CONTROL:
-    case UCHAR_LOGICAL_ORDER_EXCEPTION:
-    case UCHAR_LOWERCASE:
-    case UCHAR_MATH:
-    case UCHAR_NONCHARACTER_CODE_POINT:
-    case UCHAR_PATTERN_SYNTAX:
-    case UCHAR_PATTERN_WHITE_SPACE:
-    case UCHAR_QUOTATION_MARK:
-    case UCHAR_RADICAL:
-    case UCHAR_REGIONAL_INDICATOR:
-    case UCHAR_S_TERM:
-    case UCHAR_SOFT_DOTTED:
-    case UCHAR_TERMINAL_PUNCTUATION:
-    case UCHAR_UNIFIED_IDEOGRAPH:
-    case UCHAR_UPPERCASE:
-    case UCHAR_VARIATION_SELECTOR:
-    case UCHAR_WHITE_SPACE:
-    case UCHAR_XID_CONTINUE:
-    case UCHAR_XID_START:
-      return true;
-    default:
-      break;
-  }
-  return false;
-}
-
-bool IsUnicodePropertyValueCharacter(char c) {
-  // https://tc39.github.io/proposal-regexp-unicode-property-escapes/
-  //
-  // Note that using this to validate each parsed char is quite conservative.
-  // A possible alternative solution would be to only ensure the parsed
-  // property name/value candidate string does not contain '\0' characters and
-  // let ICU lookups trigger the final failure.
-  if (Utils::IsAlphaNumeric(c)) return true;
-  return (c == '_');
-}
-
-}  // anonymous namespace
-
-bool RegExpParser::ParsePropertyClassName(ZoneGrowableArray<char>* name_1,
-                                          ZoneGrowableArray<char>* name_2) {
-  ASSERT(name_1->is_empty());
-  ASSERT(name_2->is_empty());
-  // Parse the property class as follows:
-  // - In \p{name}, 'name' is interpreted
-  //   - either as a general category property value name.
-  //   - or as a binary property name.
-  // - In \p{name=value}, 'name' is interpreted as an enumerated property name,
-  //   and 'value' is interpreted as one of the available property value names.
-  // - Aliases in PropertyAlias.txt and PropertyValueAlias.txt can be used.
-  // - Loose matching is not applied.
-  if (current() == '{') {
-    // Parse \p{[PropertyName=]PropertyNameValue}
-    for (Advance(); current() != '}' && current() != '='; Advance()) {
-      if (!IsUnicodePropertyValueCharacter(current())) return false;
-      if (!has_next()) return false;
-      name_1->Add(static_cast<char>(current()));
-    }
-    if (current() == '=') {
-      for (Advance(); current() != '}'; Advance()) {
-        if (!IsUnicodePropertyValueCharacter(current())) return false;
-        if (!has_next()) return false;
-        name_2->Add(static_cast<char>(current()));
-      }
-      name_2->Add(0);  // null-terminate string.
-    }
-  } else {
-    return false;
-  }
-  Advance();
-  name_1->Add(0);  // null-terminate string.
-
-  ASSERT(static_cast<size_t>(name_1->length() - 1) == strlen(name_1->data()));
-  ASSERT(name_2->is_empty() ||
-         static_cast<size_t>(name_2->length() - 1) == strlen(name_2->data()));
-  return true;
-}
-
-bool RegExpParser::AddPropertyClassRange(
-    ZoneGrowableArray<CharacterRange>* add_to,
-    bool negate,
-    ZoneGrowableArray<char>* name_1,
-    ZoneGrowableArray<char>* name_2) {
-  ASSERT(name_1->At(name_1->length() - 1) == '\0');
-  ASSERT(name_2->is_empty() || name_2->At(name_2->length() - 1) == '\0');
-  if (name_2->is_empty()) {
-    // First attempt to interpret as general category property value name.
-    const char* name = name_1->data();
-    if (LookupPropertyValueName(UCHAR_GENERAL_CATEGORY_MASK, name, negate,
-                                add_to)) {
-      return true;
-    }
-    // Interpret "Any", "ASCII", and "Assigned".
-    if (LookupSpecialPropertyValueName(name, add_to, negate)) {
-      return true;
-    }
-    // Then attempt to interpret as binary property name with value name 'Y'.
-    UProperty property = u_getPropertyEnum(name);
-    if (!IsSupportedBinaryProperty(property)) return false;
-    if (!IsExactPropertyAlias(name, property)) return false;
-    return LookupPropertyValueName(property, negate ? "N" : "Y", false, add_to);
-  } else {
-    // Both property name and value name are specified. Attempt to interpret
-    // the property name as enumerated property.
-    const char* property_name = name_1->data();
-    const char* value_name = name_2->data();
-    UProperty property = u_getPropertyEnum(property_name);
-    if (!IsExactPropertyAlias(property_name, property)) return false;
-    if (property == UCHAR_GENERAL_CATEGORY) {
-      // We want to allow aggregate value names such as "Letter".
-      property = UCHAR_GENERAL_CATEGORY_MASK;
-    } else if (property != UCHAR_SCRIPT &&
-               property != UCHAR_SCRIPT_EXTENSIONS) {
-      return false;
-    }
-    return LookupPropertyValueName(property, value_name, negate, add_to);
-  }
-}
-
-bool RegExpParser::ParseUnlimitedLengthHexNumber(uint32_t max_value,
-                                                 uint32_t* value) {
-  uint32_t x = 0;
-  int d = HexValue(current());
-  if (d < 0) {
-    return false;
-  }
-  while (d >= 0) {
-    x = x * 16 + d;
-    if (x > max_value) {
-      return false;
-    }
-    Advance();
-    d = HexValue(current());
-  }
-  *value = x;
-  return true;
-}
-
 uint32_t RegExpParser::ParseClassCharacterEscape() {
   ASSERT(current() == '\\');
   DEBUG_ASSERT(has_next() && !IsSpecialClassEscape(Next()));
@@ -1752,47 +1147,35 @@
       uint32_t letter = controlLetter & ~('A' ^ 'a');
       // For compatibility with JSC, inside a character class
       // we also accept digits and underscore as control characters.
-      if (letter >= 'A' && letter <= 'Z') {
+      if ((controlLetter >= '0' && controlLetter <= '9') ||
+          controlLetter == '_' || (letter >= 'A' && letter <= 'Z')) {
         Advance(2);
         // Control letters mapped to ASCII control characters in the range
         // 0x00-0x1f.
         return controlLetter & 0x1f;
       }
-      if (is_unicode()) {
-        // With /u, \c# or \c_ are invalid.
-        ReportError("Invalid class escape");
-        UNREACHABLE();
-      }
-      if (Utils::IsDecimalDigit(controlLetter) || controlLetter == '_') {
-        Advance(2);
-        return controlLetter & 0x1f;
-      }
       // We match JSC in reading the backslash as a literal
       // character instead of as starting an escape.
       return '\\';
     }
     case '0':
-      // With /u, \0 is interpreted as NUL if not followed by another digit.
-      if (is_unicode() && !(Next() >= '0' && Next() <= '9')) {
-        Advance();
-        return 0;
-      }
       FALL_THROUGH;
     case '1':
+      FALL_THROUGH;
     case '2':
+      FALL_THROUGH;
     case '3':
+      FALL_THROUGH;
     case '4':
+      FALL_THROUGH;
     case '5':
+      FALL_THROUGH;
     case '6':
+      FALL_THROUGH;
     case '7':
       // For compatibility, we interpret a decimal escape that isn't
       // a back reference (and therefore either \0 or not valid according
       // to the specification) as a 1..3 digit octal character code.
-      if (is_unicode()) {
-        // With \u, decimal escape is not interpreted as octal character code.
-        ReportError("Invalid class escape");
-        UNREACHABLE();
-      }
       return ParseOctalLiteral();
     case 'x': {
       Advance();
@@ -1800,11 +1183,6 @@
       if (ParseHexEscape(2, &value)) {
         return value;
       }
-      if (is_unicode()) {
-        // With \u, invalid escapes are not treated as identity escapes.
-        ReportError("Invalid escape");
-        UNREACHABLE();
-      }
       // If \x is not followed by a two-digit hexadecimal, treat it
       // as an identity escape.
       return 'x';
@@ -1812,14 +1190,9 @@
     case 'u': {
       Advance();
       uint32_t value;
-      if (ParseUnicodeEscape(&value)) {
+      if (ParseHexEscape(4, &value)) {
         return value;
       }
-      if (is_unicode()) {
-        // With \u, invalid escapes are not treated as identity escapes.
-        ReportError(kUnicodeIdentity);
-        UNREACHABLE();
-      }
       // If \u is not followed by a four-digit hexadecimal, treat it
       // as an identity escape.
       return 'u';
@@ -1829,20 +1202,15 @@
       // been matched by a more specific case, not just the subset required
       // by the ECMAScript specification.
       uint32_t result = current();
-      if (!is_unicode() || IsSyntaxCharacterOrSlash(result) || result == '-') {
-        Advance();
-        return result;
-      }
-      ReportError(kUnicodeIdentity);
-      UNREACHABLE();
+      Advance();
+      return result;
     }
   }
   return 0;
 }
 
-bool RegExpParser::ParseClassEscape(ZoneGrowableArray<CharacterRange>* ranges,
-                                    bool add_unicode_case_equivalents,
-                                    uint32_t* char_out) {
+CharacterRange RegExpParser::ParseClassAtom(uint16_t* char_class) {
+  ASSERT(0 == *char_class);
   uint32_t first = current();
   if (first == '\\') {
     switch (Next()) {
@@ -1852,42 +1220,40 @@
       case 'D':
       case 's':
       case 'S': {
-        CharacterRange::AddClassEscape(static_cast<uint16_t>(Next()), ranges,
-                                       add_unicode_case_equivalents);
+        *char_class = Next();
         Advance(2);
-        return true;
-      }
-      case 'p':
-      case 'P': {
-        if (!is_unicode()) break;
-        bool negate = Next() == 'P';
-        Advance(2);
-        auto name_1 = new (Z) ZoneGrowableArray<char>();
-        auto name_2 = new (Z) ZoneGrowableArray<char>();
-        if (!ParsePropertyClassName(name_1, name_2) ||
-            !AddPropertyClassRange(ranges, negate, name_1, name_2)) {
-          ReportError("Invalid property name in character class");
-          UNREACHABLE();
-        }
-        return true;
+        return CharacterRange::Singleton(0);  // Return dummy value.
       }
       case kEndMarker:
         ReportError("\\ at end of pattern");
         UNREACHABLE();
       default:
-        break;
+        uint32_t c = ParseClassCharacterEscape();
+        return CharacterRange::Singleton(c);
     }
-    *char_out = ParseClassCharacterEscape();
-    return false;
+  } else {
+    Advance();
+    return CharacterRange::Singleton(first);
   }
-  Advance();
-  *char_out = first;
-  return false;
 }
 
-RegExpTree* RegExpParser::ParseCharacterClass(const RegExpBuilder* builder) {
+static const uint16_t kNoCharClass = 0;
+
+// Adds range or pre-defined character class to character ranges.
+// If char_class is not kInvalidClass, it's interpreted as a class
+// escape (i.e., 's' means whitespace, from '\s').
+static inline void AddRangeOrEscape(ZoneGrowableArray<CharacterRange>* ranges,
+                                    uint16_t char_class,
+                                    CharacterRange range) {
+  if (char_class != kNoCharClass) {
+    CharacterRange::AddClassEscape(char_class, ranges);
+  } else {
+    ranges->Add(range);
+  }
+}
+
+RegExpTree* RegExpParser::ParseCharacterClass() {
   static const char* kUnterminated = "Unterminated character class";
-  static const char* kRangeInvalid = "Invalid character class";
   static const char* kRangeOutOfOrder = "Range out of order in character class";
 
   ASSERT(current() == '[');
@@ -1899,11 +1265,9 @@
   }
   ZoneGrowableArray<CharacterRange>* ranges =
       new (Z) ZoneGrowableArray<CharacterRange>(2);
-  bool add_unicode_case_equivalents = is_unicode() && builder->ignore_case();
   while (has_more() && current() != ']') {
-    uint32_t char_1;
-    bool is_class_1 =
-        ParseClassEscape(ranges, add_unicode_case_equivalents, &char_1);
+    uint16_t char_class = kNoCharClass;
+    CharacterRange first = ParseClassAtom(&char_class);
     if (current() == '-') {
       Advance();
       if (current() == kEndMarker) {
@@ -1911,32 +1275,26 @@
         // following code report an error.
         break;
       } else if (current() == ']') {
-        if (!is_class_1) ranges->Add(CharacterRange::Singleton(char_1));
+        AddRangeOrEscape(ranges, char_class, first);
         ranges->Add(CharacterRange::Singleton('-'));
         break;
       }
-      uint32_t char_2;
-      bool is_class_2 =
-          ParseClassEscape(ranges, add_unicode_case_equivalents, &char_2);
-      if (is_class_1 || is_class_2) {
+      uint16_t char_class_2 = kNoCharClass;
+      CharacterRange next = ParseClassAtom(&char_class_2);
+      if (char_class != kNoCharClass || char_class_2 != kNoCharClass) {
         // Either end is an escaped character class. Treat the '-' verbatim.
-        if (is_unicode()) {
-          // ES2015 21.2.2.15.1 step 1.
-          ReportError(kRangeInvalid);
-          UNREACHABLE();
-        }
-        if (!is_class_1) ranges->Add(CharacterRange::Singleton(char_1));
+        AddRangeOrEscape(ranges, char_class, first);
         ranges->Add(CharacterRange::Singleton('-'));
-        if (!is_class_2) ranges->Add(CharacterRange::Singleton(char_2));
+        AddRangeOrEscape(ranges, char_class_2, next);
         continue;
       }
-      if (char_1 > char_2) {
+      if (first.from() > next.to()) {
         ReportError(kRangeOutOfOrder);
         UNREACHABLE();
       }
-      ranges->Add(CharacterRange::Range(char_1, char_2));
+      ranges->Add(CharacterRange::Range(first.from(), next.to()));
     } else {
-      if (!is_class_1) ranges->Add(CharacterRange::Singleton(char_1));
+      AddRangeOrEscape(ranges, char_class, first);
     }
   }
   if (!has_more()) {
@@ -1944,21 +1302,21 @@
     UNREACHABLE();
   }
   Advance();
-  RegExpCharacterClass::CharacterClassFlags character_class_flags =
-      RegExpCharacterClass::DefaultFlags();
-  if (is_negated) character_class_flags |= RegExpCharacterClass::NEGATED;
-  return new (Z)
-      RegExpCharacterClass(ranges, builder->flags(), character_class_flags);
+  if (ranges->length() == 0) {
+    ranges->Add(CharacterRange::Everything());
+    is_negated = !is_negated;
+  }
+  return new (Z) RegExpCharacterClass(ranges, is_negated);
 }
 
 // ----------------------------------------------------------------------------
 // The Parser interface.
 
 void RegExpParser::ParseRegExp(const String& input,
-                               RegExpFlags flags,
+                               bool multiline,
                                RegExpCompileData* result) {
   ASSERT(result != NULL);
-  RegExpParser parser(input, &result->error, flags);
+  RegExpParser parser(input, &result->error, multiline);
   // Throws an exception if 'input' is not valid.
   RegExpTree* tree = parser.ParsePattern();
   ASSERT(tree != NULL);
diff --git a/runtime/vm/regexp_parser.h b/runtime/vm/regexp_parser.h
index 63c237a..a2b626b 100644
--- a/runtime/vm/regexp_parser.h
+++ b/runtime/vm/regexp_parser.h
@@ -14,18 +14,13 @@
 // Accumulates RegExp atoms and assertions into lists of terms and alternatives.
 class RegExpBuilder : public ZoneAllocated {
  public:
-  explicit RegExpBuilder(RegExpFlags flags);
+  RegExpBuilder();
 
   void AddCharacter(uint16_t character);
-  void AddUnicodeCharacter(uint32_t character);
-  void AddEscapedUnicodeCharacter(uint32_t character);
   // "Adds" an empty expression. Does nothing except consume a
   // following quantifier
   void AddEmpty();
-  void AddCharacterClass(RegExpCharacterClass* cc);
-  void AddCharacterClassForDesugaring(uint32_t c);
   void AddAtom(RegExpTree* tree);
-  void AddTerm(RegExpTree* tree);
   void AddAssertion(RegExpTree* tree);
   void NewAlternative();  // '|'
   // Attempt to add a quantifier to the last atom added. The return value
@@ -35,30 +30,17 @@
                            intptr_t max,
                            RegExpQuantifier::QuantifierType type);
   RegExpTree* ToRegExp();
-  RegExpFlags flags() const { return flags_; }
-  bool ignore_case() const { return flags_.IgnoreCase(); }
-  bool is_multi_line() const { return flags_.IsMultiLine(); }
-  bool is_dot_all() const { return flags_.IsDotAll(); }
 
  private:
-  static const uint16_t kNoPendingSurrogate = 0;
-  void AddLeadSurrogate(uint16_t lead_surrogate);
-  void AddTrailSurrogate(uint16_t trail_surrogate);
-  void FlushPendingSurrogate();
   void FlushCharacters();
   void FlushText();
   void FlushTerms();
-  bool NeedsDesugaringForUnicode(RegExpCharacterClass* cc);
-  bool NeedsDesugaringForIgnoreCase(uint32_t c);
 
   Zone* zone() const { return zone_; }
-  bool is_unicode() const { return flags_.IsUnicode(); }
 
   Zone* zone_;
   bool pending_empty_;
-  RegExpFlags flags_;
   ZoneGrowableArray<uint16_t>* characters_;
-  uint16_t pending_surrogate_;
   GrowableArray<RegExpTree*> terms_;
   GrowableArray<RegExpTree*> text_;
   GrowableArray<RegExpTree*> alternatives_;
@@ -74,15 +56,16 @@
 
 class RegExpParser : public ValueObject {
  public:
-  RegExpParser(const String& in, String* error, RegExpFlags regexp_flags);
+  RegExpParser(const String& in, String* error, bool multiline_mode);
 
   static void ParseRegExp(const String& input,
-                          RegExpFlags regexp_flags,
+                          bool multiline,
                           RegExpCompileData* result);
 
   RegExpTree* ParsePattern();
   RegExpTree* ParseDisjunction();
   RegExpTree* ParseGroup();
+  RegExpTree* ParseCharacterClass();
 
   // Parses a {...,...} quantifier and stores the range in the given
   // out parameters.
@@ -95,24 +78,6 @@
   // Checks whether the following is a length-digit hexadecimal number,
   // and sets the value if it is.
   bool ParseHexEscape(intptr_t length, uint32_t* value);
-  bool ParseUnicodeEscape(uint32_t* value);
-  bool ParseUnlimitedLengthHexNumber(uint32_t max_value, uint32_t* value);
-
-  // Parses either {UNICODE_PROPERTY_NAME=UNICODE_PROPERTY_VALUE} or
-  // the shorthand {UNICODE_PROPERTY_NAME_OR_VALUE} and stores the
-  // result in the given out parameters. If the shorthand is used,
-  // nothing will be added to name_2.
-  bool ParsePropertyClassName(ZoneGrowableArray<char>* name_1,
-                              ZoneGrowableArray<char>* name_2);
-  // Adds the specified unicode property to the provided character range.
-  bool AddPropertyClassRange(ZoneGrowableArray<CharacterRange>* add_to,
-                             bool negate,
-                             ZoneGrowableArray<char>* name_1,
-                             ZoneGrowableArray<char>* name_2);
-  // Returns a regexp node that corresponds to one of these unicode
-  // property sequences: "Any", "ASCII", "Assigned".
-  RegExpTree* GetPropertySequence(ZoneGrowableArray<char>* name_1);
-  RegExpTree* ParseCharacterClass(const RegExpBuilder* builder);
 
   uint32_t ParseOctalLiteral();
 
@@ -122,10 +87,7 @@
   // can be reparsed.
   bool ParseBackReferenceIndex(intptr_t* index_out);
 
-  // Attempts to parse a possible escape within a character class.
-  bool ParseClassEscape(ZoneGrowableArray<CharacterRange>* ranges,
-                        bool add_unicode_case_equivalents,
-                        uint32_t* char_out);
+  CharacterRange ParseClassAtom(uint16_t* char_class);
   void ReportError(const char* message);
   void Advance();
   void Advance(intptr_t dist);
@@ -138,9 +100,6 @@
   void set_contains_anchor() { contains_anchor_ = true; }
   intptr_t captures_started() { return captures_started_; }
   intptr_t position() { return next_pos_ - 1; }
-  bool is_unicode() const { return top_level_flags_.IsUnicode(); }
-
-  static bool IsSyntaxCharacterOrSlash(uint32_t c);
 
   static const intptr_t kMaxCaptures = 1 << 16;
   static const uint32_t kEndMarker = (1 << 21);
@@ -161,10 +120,9 @@
                       RegExpLookaround::Type lookaround_type,
                       intptr_t disjunction_capture_index,
                       const RegExpCaptureName* capture_name,
-                      RegExpFlags flags,
                       Zone* zone)
         : previous_state_(previous_state),
-          builder_(new (zone) RegExpBuilder(flags)),
+          builder_(new (zone) RegExpBuilder()),
           group_type_(group_type),
           lookaround_type_(lookaround_type),
           disjunction_capture_index_(disjunction_capture_index),
@@ -240,7 +198,6 @@
   bool has_more() { return has_more_; }
   bool has_next() { return next_pos_ < in().Length(); }
   uint32_t Next();
-  uint32_t ReadNext(bool update_position);
   const String& in() { return in_; }
   void ScanForCaptures();
 
@@ -255,7 +212,7 @@
   // The capture count is only valid after we have scanned for captures.
   intptr_t capture_count_;
   bool has_more_;
-  RegExpFlags top_level_flags_;
+  bool multiline_;
   bool simple_;
   bool contains_anchor_;
   bool is_scanned_for_captures_;
diff --git a/runtime/vm/regexp_test.cc b/runtime/vm/regexp_test.cc
index f800931..531f12d 100644
--- a/runtime/vm/regexp_test.cc
+++ b/runtime/vm/regexp_test.cc
@@ -16,7 +16,7 @@
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const RegExp& regexp =
-      RegExp::Handle(RegExpEngine::CreateRegExp(thread, pat, RegExpFlags()));
+      RegExp::Handle(RegExpEngine::CreateRegExp(thread, pat, false, false));
   const Smi& idx = Smi::Handle(Smi::New(0));
   return IRRegExpMacroAssembler::Execute(regexp, str, idx, /*sticky=*/false,
                                          zone);
diff --git a/runtime/vm/runtime_entry_list.h b/runtime/vm/runtime_entry_list.h
index dd4159d..ddcd350 100644
--- a/runtime/vm/runtime_entry_list.h
+++ b/runtime/vm/runtime_entry_list.h
@@ -79,9 +79,7 @@
   V(double, LibcAsin, double)                                                  \
   V(double, LibcAtan, double)                                                  \
   V(double, LibcAtan2, double, double)                                         \
-  V(RawBool*, CaseInsensitiveCompareUCS2, RawString*, RawSmi*, RawSmi*,        \
-    RawSmi*)                                                                   \
-  V(RawBool*, CaseInsensitiveCompareUTF16, RawString*, RawSmi*, RawSmi*,       \
+  V(RawBool*, CaseInsensitiveCompareUC16, RawString*, RawSmi*, RawSmi*,        \
     RawSmi*)                                                                   \
   V(void, EnterSafepoint)                                                      \
   V(void, ExitSafepoint)
diff --git a/runtime/vm/splay-tree.h b/runtime/vm/splay-tree.h
deleted file mode 100644
index 54c5d9f..0000000
--- a/runtime/vm/splay-tree.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-#ifndef RUNTIME_VM_SPLAY_TREE_H_
-#define RUNTIME_VM_SPLAY_TREE_H_
-
-#include "platform/splay-tree.h"
-#include "vm/zone.h"
-
-namespace dart {
-
-// A zone splay tree.  The config type parameter encapsulates the
-// different configurations of a concrete splay tree (see
-// platform/splay-tree.h). The tree itself and all its elements are allocated
-// in the Zone.
-template <typename Config>
-class ZoneSplayTree final : public SplayTree<Config, ZoneAllocated, Zone> {
- public:
-  explicit ZoneSplayTree(Zone* zone)
-      : SplayTree<Config, ZoneAllocated, Zone>(ASSERT_NOTNULL(zone)) {}
-  ~ZoneSplayTree() {
-    // Reset the root to avoid unneeded iteration over all tree nodes
-    // in the destructor.  For a zone-allocated tree, nodes will be
-    // freed by the Zone.
-    SplayTree<Config, ZoneAllocated, Zone>::ResetRoot();
-  }
-};
-
-}  // namespace dart
-
-#endif  // RUNTIME_VM_SPLAY_TREE_H_
diff --git a/runtime/vm/stub_code_arm64_test.cc b/runtime/vm/stub_code_arm64_test.cc
index 7471c7d..4e69a5a 100644
--- a/runtime/vm/stub_code_arm64_test.cc
+++ b/runtime/vm/stub_code_arm64_test.cc
@@ -83,7 +83,7 @@
   __ LoadObject(R1, lhs_index);
   __ LoadObject(R2, rhs_index);
   __ LoadObject(R3, length);
-  __ CallRuntime(kCaseInsensitiveCompareUCS2RuntimeEntry, 4);
+  __ CallRuntime(kCaseInsensitiveCompareUC16RuntimeEntry, 4);
   __ LeaveDartFrame();
   __ ret();  // Return value is in R0.
 }
diff --git a/runtime/vm/stub_code_arm_test.cc b/runtime/vm/stub_code_arm_test.cc
index d849dc0..2a66478 100644
--- a/runtime/vm/stub_code_arm_test.cc
+++ b/runtime/vm/stub_code_arm_test.cc
@@ -82,7 +82,7 @@
   __ LoadObject(R1, lhs_index);
   __ LoadObject(R2, rhs_index);
   __ LoadObject(R3, length);
-  __ CallRuntime(kCaseInsensitiveCompareUCS2RuntimeEntry, 4);
+  __ CallRuntime(kCaseInsensitiveCompareUC16RuntimeEntry, 4);
   __ LeaveDartFrameAndReturn();  // Return value is in R0.
 }
 
diff --git a/runtime/vm/stub_code_ia32_test.cc b/runtime/vm/stub_code_ia32_test.cc
index 578afde..a4f79fc 100644
--- a/runtime/vm/stub_code_ia32_test.cc
+++ b/runtime/vm/stub_code_ia32_test.cc
@@ -86,7 +86,7 @@
   __ movl(Address(ESP, 2 * kWordSize), EAX);  // Push argument 3.
   __ LoadObject(EAX, length);
   __ movl(Address(ESP, 3 * kWordSize), EAX);  // Push argument 4.
-  __ CallRuntime(kCaseInsensitiveCompareUCS2RuntimeEntry, 4);
+  __ CallRuntime(kCaseInsensitiveCompareUC16RuntimeEntry, 4);
   __ leave();
   __ ret();  // Return value is in EAX.
 }
diff --git a/runtime/vm/stub_code_x64_test.cc b/runtime/vm/stub_code_x64_test.cc
index 4cdf613..a71484a 100644
--- a/runtime/vm/stub_code_x64_test.cc
+++ b/runtime/vm/stub_code_x64_test.cc
@@ -83,7 +83,7 @@
   __ LoadObject(CallingConventions::kArg2Reg, lhs_index);
   __ LoadObject(CallingConventions::kArg3Reg, rhs_index);
   __ LoadObject(CallingConventions::kArg4Reg, length);
-  __ CallRuntime(kCaseInsensitiveCompareUCS2RuntimeEntry, 4);
+  __ CallRuntime(kCaseInsensitiveCompareUC16RuntimeEntry, 4);
   __ LeaveStubFrame();
   __ ret();  // Return value is in RAX.
 }
diff --git a/sdk/lib/_internal/js_runtime/lib/core_patch.dart b/sdk/lib/_internal/js_runtime/lib/core_patch.dart
index 998f42b..e31fe29 100644
--- a/sdk/lib/_internal/js_runtime/lib/core_patch.dart
+++ b/sdk/lib/_internal/js_runtime/lib/core_patch.dart
@@ -528,15 +528,9 @@
   @pragma('dart2js:noInline')
   @patch
   factory RegExp(String source,
-          {bool multiLine: false,
-          bool caseSensitive: true,
-          bool unicode: false,
-          bool dotAll: false}) =>
+          {bool multiLine: false, bool caseSensitive: true}) =>
       new JSSyntaxRegExp(source,
-          multiLine: multiLine,
-          caseSensitive: caseSensitive,
-          unicode: unicode,
-          dotAll: dotAll);
+          multiLine: multiLine, caseSensitive: caseSensitive);
 
   @patch
   static String escape(String text) => quoteStringForRegExp(text);
diff --git a/sdk/lib/_internal/js_runtime/lib/regexp_helper.dart b/sdk/lib/_internal/js_runtime/lib/regexp_helper.dart
index 3dacc06..51b4bfb 100644
--- a/sdk/lib/_internal/js_runtime/lib/regexp_helper.dart
+++ b/sdk/lib/_internal/js_runtime/lib/regexp_helper.dart
@@ -42,22 +42,18 @@
   var _nativeGlobalRegExp;
   var _nativeAnchoredRegExp;
 
-  String toString() =>
-      'RegExp/$pattern/' + JS('String', '#.flags', _nativeRegExp);
+  String toString() => 'RegExp/$pattern/';
 
   JSSyntaxRegExp(String source,
-      {bool multiLine: false,
-      bool caseSensitive: true,
-      bool unicode: false,
-      bool dotAll: false})
+      {bool multiLine: false, bool caseSensitive: true})
       : this.pattern = source,
-        this._nativeRegExp = makeNative(
-            source, multiLine, caseSensitive, unicode, dotAll, false);
+        this._nativeRegExp =
+            makeNative(source, multiLine, caseSensitive, false);
 
   get _nativeGlobalVersion {
     if (_nativeGlobalRegExp != null) return _nativeGlobalRegExp;
-    return _nativeGlobalRegExp = makeNative(
-        pattern, _isMultiLine, _isCaseSensitive, _isUnicode, _isDotAll, true);
+    return _nativeGlobalRegExp =
+        makeNative(pattern, _isMultiLine, _isCaseSensitive, true);
   }
 
   get _nativeAnchoredVersion {
@@ -67,22 +63,18 @@
     // that it tries, and you can see if the original regexp matched, or it
     // was the added zero-width match that matched, by looking at the last
     // capture. If it is a String, the match participated, otherwise it didn't.
-    return _nativeAnchoredRegExp = makeNative('$pattern|()', _isMultiLine,
-        _isCaseSensitive, _isUnicode, _isDotAll, true);
+    return _nativeAnchoredRegExp =
+        makeNative('$pattern|()', _isMultiLine, _isCaseSensitive, true);
   }
 
   bool get _isMultiLine => JS('bool', '#.multiline', _nativeRegExp);
   bool get _isCaseSensitive => JS('bool', '!#.ignoreCase', _nativeRegExp);
-  bool get _isUnicode => JS('bool', '#.unicode', _nativeRegExp);
-  bool get _isDotAll => JS('bool', '#.dotAll', _nativeRegExp);
 
-  static makeNative(String source, bool multiLine, bool caseSensitive,
-      bool unicode, bool dotAll, bool global) {
+  static makeNative(
+      String source, bool multiLine, bool caseSensitive, bool global) {
     checkString(source);
     String m = multiLine == true ? 'm' : '';
     String i = caseSensitive == true ? '' : 'i';
-    String u = unicode ? 'u' : '';
-    String s = dotAll ? 's' : '';
     String g = global ? 'g' : '';
     // We're using the JavaScript's try catch instead of the Dart one to avoid
     // dragging in Dart runtime support just because of using RegExp.
@@ -95,12 +87,10 @@
             } catch (e) {
               return e;
             }
-          })(#, # + # + # + # + #)''',
+          })(#, # + # + #)''',
         source,
         m,
         i,
-        u,
-        s,
         g);
     if (JS('bool', '# instanceof RegExp', regexp)) return regexp;
     // The returned value is the JavaScript exception. Turn it into a
@@ -109,7 +99,7 @@
     throw new FormatException('Illegal RegExp pattern ($errorMessage)', source);
   }
 
-  RegExpMatch firstMatch(String string) {
+  Match firstMatch(String string) {
     List m = JS('JSExtendableArray|Null', r'#.exec(#)', _nativeRegExp,
         checkString(string));
     if (m == null) return null;
@@ -126,7 +116,7 @@
     return null;
   }
 
-  Iterable<RegExpMatch> allMatches(String string, [int start = 0]) {
+  Iterable<Match> allMatches(String string, [int start = 0]) {
     checkString(string);
     checkInt(start);
     if (start < 0 || start > string.length) {
@@ -135,7 +125,7 @@
     return new _AllMatchesIterable(this, string, start);
   }
 
-  RegExpMatch _execGlobal(String string, int start) {
+  Match _execGlobal(String string, int start) {
     Object regexp = _nativeGlobalVersion;
     JS('void', '#.lastIndex = #', regexp, start);
     List match = JS('JSExtendableArray|Null', '#.exec(#)', regexp, string);
@@ -143,7 +133,7 @@
     return new _MatchImplementation(this, match);
   }
 
-  RegExpMatch _execAnchored(String string, int start) {
+  Match _execAnchored(String string, int start) {
     Object regexp = _nativeAnchoredVersion;
     JS('void', '#.lastIndex = #', regexp, start);
     List match = JS('JSExtendableArray|Null', '#.exec(#)', regexp, string);
@@ -154,7 +144,7 @@
     return new _MatchImplementation(this, match);
   }
 
-  RegExpMatch matchAsPrefix(String string, [int start = 0]) {
+  Match matchAsPrefix(String string, [int start = 0]) {
     if (start < 0 || start > string.length) {
       throw new RangeError.range(start, 0, string.length);
     }
@@ -163,8 +153,6 @@
 
   bool get isMultiLine => _isMultiLine;
   bool get isCaseSensitive => _isCaseSensitive;
-  bool get isUnicode => _isUnicode;
-  bool get isDotAll => _isDotAll;
 }
 
 class _MatchImplementation implements RegExpMatch {
@@ -231,34 +219,25 @@
   }
 }
 
-class _AllMatchesIterable extends IterableBase<RegExpMatch> {
+class _AllMatchesIterable extends IterableBase<Match> {
   final JSSyntaxRegExp _re;
   final String _string;
   final int _start;
 
   _AllMatchesIterable(this._re, this._string, this._start);
 
-  Iterator<RegExpMatch> get iterator =>
-      new _AllMatchesIterator(_re, _string, _start);
+  Iterator<Match> get iterator => new _AllMatchesIterator(_re, _string, _start);
 }
 
-class _AllMatchesIterator implements Iterator<RegExpMatch> {
+class _AllMatchesIterator implements Iterator<Match> {
   final JSSyntaxRegExp _regExp;
   String _string;
   int _nextIndex;
-  RegExpMatch _current;
+  Match _current;
 
   _AllMatchesIterator(this._regExp, this._string, this._nextIndex);
 
-  RegExpMatch get current => _current;
-
-  static bool _isLeadSurrogate(int c) {
-    return c >= 0xd800 && c <= 0xdbff;
-  }
-
-  static bool _isTrailSurrogate(int c) {
-    return c >= 0xdc00 && c <= 0xdfff;
-  }
+  Match get current => _current;
 
   bool moveNext() {
     if (_string == null) return false;
@@ -268,15 +247,6 @@
         _current = match;
         int nextIndex = match.end;
         if (match.start == nextIndex) {
-          // Zero-width match. Advance by one more, unless the regexp
-          // is in unicode mode and it would put us within a surrogate
-          // pair. In that case, advance past the code point as a whole.
-          if (_regExp.isUnicode &&
-              _nextIndex + 1 < _string.length &&
-              _isLeadSurrogate(_string.codeUnitAt(_nextIndex)) &&
-              _isTrailSurrogate(_string.codeUnitAt(_nextIndex + 1))) {
-            nextIndex++;
-          }
           nextIndex++;
         }
         _nextIndex = nextIndex;
@@ -290,6 +260,6 @@
 }
 
 /// Find the first match of [regExp] in [string] at or after [start].
-RegExpMatch firstMatchAfter(JSSyntaxRegExp regExp, String string, int start) {
+Match firstMatchAfter(JSSyntaxRegExp regExp, String string, int start) {
   return regExp._execGlobal(string, start);
 }
diff --git a/sdk/lib/core/regexp.dart b/sdk/lib/core/regexp.dart
index 62a35f0..c0bd153 100644
--- a/sdk/lib/core/regexp.dart
+++ b/sdk/lib/core/regexp.dart
@@ -16,7 +16,7 @@
  * for the specification of JavaScript regular expressions.
  *
  * [firstMatch] is the main implementation method that applies a regular
- * expression to a string and returns the first [RegExpMatch]. All
+ * expression to a string and returns the first [Match]. All
  * other methods in [RegExp] can build on it.
  *
  * Use [allMatches] to look for all matches of a regular expression in
@@ -27,7 +27,7 @@
  * ```dart
  * RegExp exp = new RegExp(r"(\w+)");
  * String str = "Parse my string";
- * Iterable<RegExpMatch> matches = exp.allMatches(str);
+ * Iterable<Match> matches = exp.allMatches(str);
  * ```
  *
  * Note the use of a _raw string_ (a string prefixed with `r`)
@@ -47,12 +47,6 @@
    *
    * If `caseSensitive` is disabled, then case is ignored.
    *
-   * If `unicode` is enabled, then the pattern is treated as a Unicode
-   * pattern as described by the ECMAScript standard.
-   *
-   * If `dotAll` is enabled, then the `.` pattern will match _all_ characters,
-   * including line terminators.
-   *
    * Example:
    *
    * ```dart
@@ -66,10 +60,7 @@
    * interpolation is required.
    */
   external factory RegExp(String source,
-      {bool multiLine = false,
-      bool caseSensitive = true,
-      bool unicode = false,
-      bool dotAll = false});
+      {bool multiLine = false, bool caseSensitive = true});
 
   /**
    * Returns a regular expression that matches [text].
@@ -88,14 +79,14 @@
    * Searches for the first match of the regular expression
    * in the string [input]. Returns `null` if there is no match.
    */
-  RegExpMatch firstMatch(String input);
+  Match firstMatch(String input);
 
   /**
    * Returns an iterable of the matches of the regular expression on [input].
    *
    * If [start] is provided, only start looking for matches at `start`.
    */
-  Iterable<RegExpMatch> allMatches(String input, [int start = 0]);
+  Iterable<Match> allMatches(String input, [int start = 0]);
 
   /**
    * Returns whether the regular expression has a match in the string [input].
@@ -129,33 +120,6 @@
    * versions of the same letter.
    */
   bool get isCaseSensitive;
-
-  /**
-   * Whether this regular expression uses full Unicode matching.
-   *
-   * In Unicode mode, UTF-16 surrogate pairs in the original string will be
-   * treated as a single code point and will not match separately. Otherwise,
-   * the target string will be treated purely as a sequence of individual code
-   * units and surrogates will not be treated specially.
-   *
-   * In Unicode mode, the syntax of the RegExp pattern is more restricted, but
-   * some pattern features, like Unicode property escapes, are only available in
-   * this mode.
-   */
-  bool get isUnicode;
-
-  /**
-   * Whether "." in this regular expression matches line terminators.
-   *
-   * Normally, the "." character matches a single character, unless that
-   * character is a line terminator. If this feature is active, then the "."
-   * character will match any single character including line terminators.
-   *
-   * This feature is distinct from [isMultiline], as they affect the behavior
-   * of different pattern characters, and so they can be used together or
-   * separately.
-   */
-  bool get isDotAll;
 }
 
 /**
diff --git a/tests/corelib_2/regexp/dot-all_test.dart b/tests/corelib_2/regexp/dot-all_test.dart
deleted file mode 100644
index 5610e7f..0000000
--- a/tests/corelib_2/regexp/dot-all_test.dart
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2017 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  // The flags accessors.
-  var re = new RegExp(r".", dotAll: true);
-  assertTrue(re.isCaseSensitive);
-  assertFalse(re.isMultiLine);
-  assertFalse(re.isUnicode);
-  assertTrue(re.isDotAll);
-
-  re = new RegExp(r".",
-      caseSensitive: false, multiLine: true, unicode: true, dotAll: true);
-  assertFalse(re.isCaseSensitive);
-  assertTrue(re.isMultiLine);
-  assertTrue(re.isUnicode);
-  assertTrue(re.isDotAll);
-
-  re = new RegExp(r".", caseSensitive: false, multiLine: true, unicode: true);
-  assertFalse(re.isCaseSensitive);
-  assertTrue(re.isMultiLine);
-  assertTrue(re.isUnicode);
-  assertFalse(re.isDotAll);
-
-  // Default '.' behavior.
-  re = new RegExp(r"^.$");
-  assertTrue(re.hasMatch("a"));
-  assertTrue(re.hasMatch("3"));
-  assertTrue(re.hasMatch("π"));
-  assertTrue(re.hasMatch("\u2027"));
-  assertTrue(re.hasMatch("\u0085"));
-  assertTrue(re.hasMatch("\v"));
-  assertTrue(re.hasMatch("\f"));
-  assertTrue(re.hasMatch("\u180E"));
-  assertFalse(re.hasMatch("\u{10300}")); // Supplementary plane.
-  assertFalse(re.hasMatch("\n"));
-  assertFalse(re.hasMatch("\r"));
-  assertFalse(re.hasMatch("\u2028"));
-  assertFalse(re.hasMatch("\u2029"));
-
-  // Default '.' behavior (unicode).
-  re = new RegExp(r"^.$", unicode: true);
-  assertTrue(re.hasMatch("a"));
-  assertTrue(re.hasMatch("3"));
-  assertTrue(re.hasMatch("π"));
-  assertTrue(re.hasMatch("\u2027"));
-  assertTrue(re.hasMatch("\u0085"));
-  assertTrue(re.hasMatch("\v"));
-  assertTrue(re.hasMatch("\f"));
-  assertTrue(re.hasMatch("\u180E"));
-  assertTrue(re.hasMatch("\u{10300}")); // Supplementary plane.
-  assertFalse(re.hasMatch("\n"));
-  assertFalse(re.hasMatch("\r"));
-  assertFalse(re.hasMatch("\u2028"));
-  assertFalse(re.hasMatch("\u2029"));
-
-  // DotAll '.' behavior.
-  re = new RegExp(r"^.$", dotAll: true);
-  assertTrue(re.hasMatch("a"));
-  assertTrue(re.hasMatch("3"));
-  assertTrue(re.hasMatch("π"));
-  assertTrue(re.hasMatch("\u2027"));
-  assertTrue(re.hasMatch("\u0085"));
-  assertTrue(re.hasMatch("\v"));
-  assertTrue(re.hasMatch("\f"));
-  assertTrue(re.hasMatch("\u180E"));
-  assertFalse(re.hasMatch("\u{10300}")); // Supplementary plane.
-  assertTrue(re.hasMatch("\n"));
-  assertTrue(re.hasMatch("\r"));
-  assertTrue(re.hasMatch("\u2028"));
-  assertTrue(re.hasMatch("\u2029"));
-
-  // DotAll '.' behavior (unicode).
-  re = new RegExp(r"^.$", unicode: true, dotAll: true);
-  assertTrue(re.hasMatch("a"));
-  assertTrue(re.hasMatch("3"));
-  assertTrue(re.hasMatch("π"));
-  assertTrue(re.hasMatch("\u2027"));
-  assertTrue(re.hasMatch("\u0085"));
-  assertTrue(re.hasMatch("\v"));
-  assertTrue(re.hasMatch("\f"));
-  assertTrue(re.hasMatch("\u180E"));
-  assertTrue(re.hasMatch("\u{10300}")); // Supplementary plane.
-  assertTrue(re.hasMatch("\n"));
-  assertTrue(re.hasMatch("\r"));
-  assertTrue(re.hasMatch("\u2028"));
-  assertTrue(re.hasMatch("\u2029"));
-}
diff --git a/tests/corelib_2/regexp/lookbehind_test.dart b/tests/corelib_2/regexp/lookbehind_test.dart
index 3fd11af..5ccdcdb 100644
--- a/tests/corelib_2/regexp/lookbehind_test.dart
+++ b/tests/corelib_2/regexp/lookbehind_test.dart
@@ -433,6 +433,8 @@
   assertThrows(() => new RegExp(r"(?<=.)?")); //# 01: ok
   assertThrows(() => new RegExp(r"(?<=.)+")); //# 01: ok
 
-  assertThrows(() => new RegExp(r"(?<=.)*", unicode: true)); //# 01: ok
-  assertThrows(() => new RegExp(r"(?<=.){1,2}", unicode: true)); //# 01: ok
+  // No unicode flag (yet), so can't test these.
+  // See https://github.com/dart-lang/sdk/issues/36170.
+  // assertThrows("/(?<=.)*/u", SyntaxError);
+  // assertThrows("/(?<=.){1,2}/u", SyntaxError);
 }
diff --git a/tests/corelib_2/regexp/named-captures_test.dart b/tests/corelib_2/regexp/named-captures_test.dart
index ee2d843..aff61b8 100644
--- a/tests/corelib_2/regexp/named-captures_test.dart
+++ b/tests/corelib_2/regexp/named-captures_test.dart
@@ -31,90 +31,35 @@
 import 'v8_regexp_utils.dart';
 
 void main() {
+  void testRE(RegExp re, String input, bool expectedResult) {
+    if (expectedResult) {
+      assertTrue(re.hasMatch(input));
+    } else {
+      assertFalse(re.hasMatch(input));
+    }
+  }
+
   void execRE(RegExp re, String input, List<String> expectedResult) {
     assertTrue(re.hasMatch(input));
     shouldBe(re.firstMatch(input), expectedResult);
   }
 
-  void execString(String pattern, String input, List<String> expectedResult,
-      {bool unicode = true, bool caseSensitive: false}) {
-    execRE(RegExp(pattern, unicode: unicode, caseSensitive: caseSensitive),
-        input, expectedResult);
-  }
-
   void namedRE(RegExp re, String input, Map<String, String> expectedResults) {
     assertTrue(re.hasMatch(input));
-    var match = re.firstMatch(input);
+    var match = re.firstMatch(input) as RegExpMatch;
     for (var s in expectedResults.keys) {
       assertEquals(match.namedGroup(s), expectedResults[s]);
     }
   }
 
-  void execStringGroups(
-      String pattern, String input, Map<String, String> expectedResults,
-      {bool unicode = true, bool caseSensitive: false}) {
-    namedRE(RegExp(pattern, unicode: unicode, caseSensitive: caseSensitive),
-        input, expectedResults);
-  }
-
   void hasNames(RegExp re, String input, List<String> expectedResults) {
     assertTrue(re.hasMatch(input));
-    var match = re.firstMatch(input);
+    var match = re.firstMatch(input) as RegExpMatch;
     for (var s in match.groupNames) {
       assertTrue(expectedResults.contains(s));
     }
   }
 
-  void matchesIndexEqual(String input, RegExp re1, RegExp re2) {
-    var m1 = re1.firstMatch(input);
-    var m2 = re2.firstMatch(input);
-    if (m2 == null) {
-      assertNull(m1);
-    } else {
-      assertTrue(m1 != null);
-      assertEquals(m1.groupCount, m2.groupCount);
-      for (int i = 0; i < m1.groupCount; i++) {
-        assertEquals(m1.group(i), m2.group(i));
-      }
-    }
-  }
-
-  // Malformed named captures.
-  // Empty name.
-  assertThrows(() => RegExp(r"(?<>a)", unicode: true));
-  // Unterminated name.
-  assertThrows(() => RegExp(r"(?<aa)", unicode: true));
-  // Name starting with digits.
-  assertThrows(() => RegExp(r"(?<42a>a)", unicode: true));
-  // Name starting with invalid char.
-  assertThrows(() => RegExp(r"(?<:a>a)", unicode: true));
-  // Name containing invalid char.
-  assertThrows(() => RegExp(r"(?<a:>a)", unicode: true));
-  // Duplicate name.
-  assertThrows(() => RegExp(r"(?<a>a)(?<a>a)", unicode: true));
-  // Duplicate name.
-  assertThrows(() => RegExp(r"(?<a>a)(?<b>b)(?<a>a)", unicode: true));
-  // Invalid reference.
-  assertThrows(() => RegExp(r"\k<a>", unicode: true));
-  // Unterminated reference.
-  assertThrows(() => RegExp(r"\k<a", unicode: true));
-  // Lone \k.
-  assertThrows(() => RegExp(r"\k", unicode: true));
-  // Lone \k.
-  assertThrows(() => RegExp(r"(?<a>.)\k", unicode: true));
-  // Unterminated reference.
-  assertThrows(() => RegExp(r"(?<a>.)\k<a", unicode: true));
-  // Invalid reference.
-  assertThrows(() => RegExp(r"(?<a>.)\k<b>", unicode: true));
-  // Invalid reference.
-  assertThrows(() => RegExp(r"(?<a>a)\k<ab>", unicode: true));
-  // Invalid reference.
-  assertThrows(() => RegExp(r"(?<ab>a)\k<a>", unicode: true));
-  // Invalid reference.
-  assertThrows(() => RegExp(r"\k<a>(?<ab>a)", unicode: true));
-  // Identity escape in capture.
-  assertThrows(() => RegExp(r"(?<a>\a)", unicode: true));
-
   // Behavior in non-unicode mode.
   assertThrows(() => RegExp(r"(?<>a)"));
   assertThrows(() => RegExp(r"(?<aa)"));
@@ -157,182 +102,6 @@
   assertThrows(() => RegExp(r"\k<a(?<a>.)"));
   assertThrows(() => RegExp(r"\k(?<a>.)"));
 
-  // Basic named groups.
-  execString(r"(?<a>a)", "bab", ["a", "a"]);
-  execString(r"(?<a42>a)", "bab", ["a", "a"]);
-  execString(r"(?<_>a)", "bab", ["a", "a"]);
-  execString(r"(?<$>a)", "bab", ["a", "a"]);
-  execString(r".(?<$>a).", "bab", ["bab", "a"]);
-  execString(r".(?<a>a)(.)", "bab", ["bab", "a", "b"]);
-  execString(r".(?<a>a)(?<b>.)", "bab", ["bab", "a", "b"]);
-  execString(r".(?<a>\w\w)", "bab", ["bab", "ab"]);
-  execString(r"(?<a>\w\w\w)", "bab", ["bab", "bab"]);
-  execString(r"(?<a>\w\w)(?<b>\w)", "bab", ["bab", "ba", "b"]);
-
-  execString(r"(?<a>a)", "bab", ["a", "a"], unicode: false);
-  execString(r"(?<a42>a)", "bab", ["a", "a"], unicode: false);
-  execString(r"(?<_>a)", "bab", ["a", "a"], unicode: false);
-  execString(r"(?<$>a)", "bab", ["a", "a"], unicode: false);
-  execString(r".(?<$>a).", "bab", ["bab", "a"], unicode: false);
-  execString(r".(?<a>a)(.)", "bab", ["bab", "a", "b"], unicode: false);
-  execString(r".(?<a>a)(?<b>.)", "bab", ["bab", "a", "b"], unicode: false);
-  execString(r".(?<a>\w\w)", "bab", ["bab", "ab"], unicode: false);
-  execString(r"(?<a>\w\w\w)", "bab", ["bab", "bab"], unicode: false);
-  execString(r"(?<a>\w\w)(?<b>\w)", "bab", ["bab", "ba", "b"], unicode: false);
-
-  matchesIndexEqual(
-      "bab", RegExp(r"(?<a>a)", unicode: true), RegExp(r"(a)", unicode: true));
-  matchesIndexEqual("bab", RegExp(r"(?<a42>a)", unicode: true),
-      RegExp(r"(a)", unicode: true));
-  matchesIndexEqual(
-      "bab", RegExp(r"(?<_>a)", unicode: true), RegExp(r"(a)", unicode: true));
-  matchesIndexEqual(
-      "bab", RegExp(r"(?<$>a)", unicode: true), RegExp(r"(a)", unicode: true));
-  matchesIndexEqual("bab", RegExp(r".(?<$>a).", unicode: true),
-      RegExp(r".(a).", unicode: true));
-  matchesIndexEqual("bab", RegExp(r".(?<a>a)(.)", unicode: true),
-      RegExp(r".(a)(.)", unicode: true));
-  matchesIndexEqual("bab", RegExp(r".(?<a>a)(?<b>.)", unicode: true),
-      RegExp(r".(a)(.)", unicode: true));
-  matchesIndexEqual("bab", RegExp(r".(?<a>\w\w)", unicode: true),
-      RegExp(r".(\w\w)", unicode: true));
-  matchesIndexEqual("bab", RegExp(r"(?<a>\w\w\w)", unicode: true),
-      RegExp(r"(\w\w\w)", unicode: true));
-  matchesIndexEqual("bab", RegExp(r"(?<a>\w\w)(?<b>\w)", unicode: true),
-      RegExp(r"(\w\w)(\w)", unicode: true));
-
-  execString(r"(?<b>b).\1", "bab", ["bab", "b"]);
-  execString(r"(.)(?<a>a)\1\2", "baba", ["baba", "b", "a"]);
-  execString(r"(.)(?<a>a)(?<b>\1)(\2)", "baba", ["baba", "b", "a", "b", "a"]);
-  execString(r"(?<lt><)a", "<a", ["<a", "<"]);
-  execString(r"(?<gt>>)a", ">a", [">a", ">"]);
-
-  // Named references.
-  var pattern = r"(?<b>.).\k<b>";
-  execString(pattern, "bab", ["bab", "b"]);
-  assertFalse(RegExp(pattern, unicode: true).hasMatch("baa"));
-
-  // Nested groups.
-  pattern = r"(?<a>.(?<b>.(?<c>.)))";
-  execString(pattern, "bab", ["bab", "bab", "ab", "b"]);
-  execStringGroups(pattern, "bab", {"a": "bab", "b": "ab", "c": "b"});
-
-  // Reference inside group.
-  pattern = r"(?<a>\k<a>\w)..";
-  execString(pattern, "bab", ["bab", "b"]);
-  execStringGroups(pattern, "bab", {"a": "b"});
-
-  // Reference before group.
-  pattern = r"\k<a>(?<a>b)\w\k<a>";
-  execString(pattern, "bab", ["bab", "b"], unicode: false);
-  execString(pattern, "bab", ["bab", "b"]);
-  execStringGroups(pattern, "bab", {"a": "b"});
-
-  pattern = r"(?<b>b)\k<a>(?<a>a)\k<b>";
-  execString(pattern, "bab", ["bab", "b", "a"], unicode: false);
-  execString(pattern, "bab", ["bab", "b", "a"]);
-  execStringGroups(pattern, "bab", {"a": "a", "b": "b"});
-
-  // Reference named groups.
-  var match = RegExp(r"(?<a>a)(?<b>b)\k<a>", unicode: true).firstMatch("aba");
-  assertEquals("a", match.namedGroup("a"));
-  assertEquals("b", match.namedGroup("b"));
-  assertFalse(match.groupNames.contains("c"));
-
-  match =
-      RegExp(r"(?<a>a)(?<b>b)\k<a>|(?<c>c)", unicode: true).firstMatch("aba");
-  assertNull(match.namedGroup("c"));
-
-  // Unicode names.
-  execStringGroups(r"(?<π>a)", "bab", {"π": "a"});
-  execStringGroups(r"(?<\u{03C0}>a)", "bab", {"π": "a"});
-  execStringGroups(r"(?<π>a)", "bab", {"\u03C0": "a"});
-  execStringGroups(r"(?<\u{03C0}>a)", "bab", {"\u03C0": "a"});
-  execStringGroups(r"(?<$>a)", "bab", {"\$": "a"});
-  execStringGroups(r"(?<_>a)", "bab", {"_": "a"});
-  execStringGroups(r"(?<$𐒤>a)", "bab", {"\$𐒤": "a"});
-  execStringGroups(r"(?<_\u200C>a)", "bab", {"_\u200C": "a"});
-  execStringGroups(r"(?<_\u200D>a)", "bab", {"_\u200D": "a"});
-  execStringGroups(r"(?<ಠ_ಠ>a)", "bab", {"ಠ_ಠ": "a"});
-  // ID_Continue but not ID_Start.
-  assertThrows(() => RegExp(r"/(?<❤>a)", unicode: true));
-  assertThrows(() => RegExp(r"/(?<𐒤>a)", unicode: true));
-
-  execStringGroups(r"(?<π>a)", "bab", {"π": "a"}, unicode: false);
-  execStringGroups(r"(?<$>a)", "bab", {"\$": "a"}, unicode: false);
-  execStringGroups(r"(?<_>a)", "bab", {"_": "a"}, unicode: false);
-  assertThrows(() => RegExp(r"(?<$𐒤>a)"));
-  execStringGroups(r"(?<ಠ_ಠ>a)", "bab", {"ಠ_ಠ": "a"}, unicode: false);
-  // ID_Continue but not ID_Start.
-  assertThrows(() => RegExp(r"/(?<❤>a)"));
-  assertThrows(() => RegExp(r"/(?<𐒤>a)"));
-
-  // Interaction with lookbehind assertions.
-  pattern = r"(?<=(?<a>\w){3})f";
-  execString(pattern, "abcdef", ["f", "c"]);
-  execStringGroups(pattern, "abcdef", {"a": "c"});
-
-  execStringGroups(r"(?<=(?<a>\w){4})f", "abcdef", {"a": "b"});
-  execStringGroups(r"(?<=(?<a>\w)+)f", "abcdef", {"a": "a"});
-  assertFalse(RegExp(r"(?<=(?<a>\w){6})f", unicode: true).hasMatch("abcdef"));
-
-  execString(r"((?<=\w{3}))f", "abcdef", ["f", ""]);
-  execString(r"(?<a>(?<=\w{3}))f", "abcdef", ["f", ""]);
-
-  execString(r"(?<!(?<a>\d){3})f", "abcdef", ["f", null]);
-  assertFalse(RegExp(r"(?<!(?<a>\D){3})f", unicode: true).hasMatch("abcdef"));
-
-  execString(r"(?<!(?<a>\D){3})f|f", "abcdef", ["f", null]);
-  execString(r"(?<a>(?<!\D{3}))f|f", "abcdef", ["f", null]);
-
-  // Matches contain the names of named captures
-  match = RegExp(r"(?<fst>.)|(?<snd>.)", unicode: true).firstMatch("abcd");
-  Expect.setEquals(["fst", "snd"], match.groupNames);
-
-  // Backslash as ID_Start and ID_Continue (v8:5868).
-  assertThrows(() => RegExp("(?<\\>.)")); // '\' misclassified as ID_Start.
-  assertThrows(() => RegExp("(?<a\\>.)")); // '\' misclassified as ID_Continue.
-
-  // Backreference before the group (exercises the capture mini-parser).
-  assertThrows(() => RegExp(r"/\1(?:.)", unicode: true));
-  assertThrows(() => RegExp(r"/\1(?<=a).", unicode: true));
-  assertThrows(() => RegExp(r"/\1(?<!a).", unicode: true));
-  execString(r"\1(?<a>.)", "abcd", ["a", "a"]);
-
-  // Unicode escapes in capture names. (Testing both unicode interpreted by
-  // Dart string handling and also escaped unicode making it to RegExp parser.)
-
-  // \u Lead \u Trail
-  assertTrue(RegExp("(?<a\uD801\uDCA4>.)", unicode: true).hasMatch("a"));
-  assertTrue(RegExp(r"(?<a\uD801\uDCA4>.)", unicode: true).hasMatch("a"));
-  assertThrows(() => RegExp("(?<a\uD801>.)", unicode: true)); // \u Lead
-  assertThrows(() => RegExp(r"(?<a\uD801>.)", unicode: true)); // \u Lead
-  assertThrows(() => RegExp("(?<a\uDCA4>.)", unicode: true)); // \u Trail
-  assertThrows(() => RegExp(r"(?<a\uDCA4>.)", unicode: true)); // \u Trail
-  // \u NonSurrogate
-  assertTrue(RegExp("(?<\u0041>.)", unicode: true).hasMatch("a"));
-  assertTrue(RegExp(r"(?<\u0041>.)", unicode: true).hasMatch("a"));
-  // \u{ Surrogate, ID_Continue }
-  assertTrue(RegExp("(?<a\u{104A4}>.)", unicode: true).hasMatch("a"));
-  assertTrue(RegExp(r"(?<a\u{104A4}>.)", unicode: true).hasMatch("a"));
-
-  // \u{ Out-of-bounds } -- only need to test RegExp parser for this.
-  assertThrows(() => RegExp(r"(?<a\\u{110000}>.)", unicode: true));
-
-  // Also checking non-unicode patterns, where surrogate pairs will not
-  // be combined (so only \u0041 will have any success).
-
-  assertThrows(() => RegExp("(?<a\uD801\uDCA4>.)"));
-  assertThrows(() => RegExp(r"(?<a\uD801\uDCA4>.)"));
-  assertThrows(() => RegExp("(?<a\uD801>.)"));
-  assertThrows(() => RegExp(r"(?<a\uD801>.)"));
-  assertThrows(() => RegExp("(?<a\uDCA4>.)"));
-  assertThrows(() => RegExp(r"(?<a\uDCA4>.)"));
-  assertTrue(RegExp("(?<\u0041>.)").hasMatch("a"));
-  assertTrue(RegExp(r"(?<\u0041>.)").hasMatch("a"));
-  assertThrows(() => RegExp("(?<a\u{104A4}>.)"));
-  assertThrows(() => RegExp(r"(?<a\u{104A4}>.)"));
-  assertThrows(() => RegExp("(?<a\u{10FFFF}>.)"));
-  assertThrows(() => RegExp(r"(?<a\u{10FFFF}>.)"));
-  assertThrows(() => RegExp(r"(?<a\\u{110000}>.)"));
+  // TODO(sstrickl): Add more tests when unicode flag support is in.
+  // https://github.com/dart-lang/sdk/issues/36170
 }
diff --git a/tests/corelib_2/regexp/unicode-character-ranges_test.dart b/tests/corelib_2/regexp/unicode-character-ranges_test.dart
deleted file mode 100644
index 7154d0f..0000000
--- a/tests/corelib_2/regexp/unicode-character-ranges_test.dart
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2011 the V8 project authors. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-// 1.  Redistributions of source code must retain the above copyright
-//     notice, this list of conditions and the following disclaimer.
-// 2.  Redistributions in binary form must reproduce the above copyright
-//     notice, this list of conditions and the following disclaimer in the
-//     documentation and/or other materials provided with the distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
-// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void execl(List<String> expectation, RegExp re, String subject) {
-  shouldBe(re.firstMatch(subject), expectation);
-}
-
-void execs(List<String> expectation, String pattern, String subject) {
-  final re = RegExp(pattern, unicode: true);
-  shouldBe(re.firstMatch(subject), expectation);
-}
-
-void main() {
-  // Character ranges.
-  execs(["A"], r"[A-D]", "A");
-  execs(["ABCD"], r"[A-D]+", "ZABCDEF");
-
-  execs(["\u{12345}"], r"[\u1234-\u{12345}]", "\u{12345}");
-  execs(null, r"[^\u1234-\u{12345}]", "\u{12345}");
-
-  execs(["\u{1234}"], r"[\u1234-\u{12345}]", "\u{1234}");
-  execs(null, r"[^\u1234-\u{12345}]", "\u{1234}");
-
-  execs(null, r"[\u1234-\u{12345}]", "\u{1233}");
-  execs(["\u{1233}"], r"[^\u1234-\u{12345}]", "\u{1233}");
-
-  execs(["\u{12346}"], r"[^\u1234-\u{12345}]", "\u{12346}");
-  execs(null, r"[\u1234-\u{12345}]", "\u{12346}");
-
-  execs(["\u{12342}"], r"[\u{12340}-\u{12345}]", "\u{12342}");
-  execs(["\u{12342}"], r"[\ud808\udf40-\ud808\udf45]", "\u{12342}");
-  execs(null, r"[^\u{12340}-\u{12345}]", "\u{12342}");
-  execs(null, r"[^\ud808\udf40-\ud808\udf45]", "\u{12342}");
-
-  execs(["\u{ffff}"], r"[\u{ff80}-\u{12345}]", "\u{ffff}");
-  execs(["\u{ffff}"], r"[\u{ff80}-\ud808\udf45]", "\u{ffff}");
-  execs(null, r"[^\u{ff80}-\u{12345}]", "\u{ffff}");
-  execs(null, r"[^\u{ff80}-\ud808\udf45]", "\u{ffff}");
-
-  // Lone surrogate
-  execs(["\udc00"], r"[^\u{ff80}-\u{12345}]", "\uff99\u{dc00}A");
-  execs(["\udc01"], r"[\u0100-\u{10ffff}]", "A\udc01");
-  execs(["\udc03"], r"[\udc01-\udc03]", "\ud801\udc02\udc03");
-  execs(["\ud801"], r"[\ud801-\ud803]", "\ud802\udc01\ud801");
-
-  // Paired surrogate.
-  execs(null, r"[^\u{ff80}-\u{12345}]", "\u{d800}\u{dc00}");
-  execs(["\ud800\udc00"], r"[\u{ff80}-\u{12345}]", "\u{d800}\u{dc00}");
-  execs(["foo\u{10e6d}bar"], r"foo\ud803\ude6dbar", "foo\u{10e6d}bar");
-
-  // Lone surrogates
-  execs(["\ud801\ud801"], r"\ud801+", "\ud801\udc01\ud801\ud801");
-  execs(["\udc01\udc01"], r"\udc01+", "\ud801\ud801\udc01\udc01\udc01");
-
-  execs(["\udc02\udc03A"], r"\W\WA", "\ud801\udc01A\udc02\udc03A");
-  execs(["\ud801\ud802"], r"\ud801.", "\ud801\udc01\ud801\ud802");
-  execs(["\udc02\udc03A"], r"[\ud800-\udfff][\ud800-\udfff]A",
-      "\ud801\udc01A\udc02\udc03A");
-
-  // Character classes
-  execs(null, r"\w", "\ud801\udc01");
-  execl(["\ud801"], RegExp(r"[^\w]"), "\ud801\udc01");
-  execs(["\ud801\udc01"], r"[^\w]", "\ud801\udc01");
-  execl(["\ud801"], RegExp(r"\W"), "\ud801\udc01");
-  execs(["\ud801\udc01"], r"\W", "\ud801\udc01");
-
-  execs(["\ud800X"], r".X", "\ud800XaX");
-  execs(["aX"], r".(?<!\ud800)X", "\ud800XaX");
-  execs(["aX"], r".(?<![\ud800-\ud900])X", "\ud800XaX");
-
-  execs(null, r"[]", "\u1234");
-  execs(["0abc"], r"[^]abc", "0abc");
-  execs(["\u1234abc"], r"[^]abc", "\u1234abc");
-  execs(["\u{12345}abc"], r"[^]abc", "\u{12345}abc");
-
-  execs(null, r"[\u{0}-\u{1F444}]", "\ud83d\udfff");
-
-  // Backward matches of lone surrogates.
-  execs(["B", "\ud803A"], r"(?<=([\ud800-\ud900]A))B",
-      "\ud801\udc00AB\udc00AB\ud802\ud803AB");
-  execs(["B", "\udc00A"], r"(?<=([\ud800-\u{10300}]A))B",
-      "\ud801\udc00AB\udc00AB\ud802\ud803AB");
-  execs(["B", "\udc11A"], r"(?<=([\udc00-\udd00]A))B",
-      "\ud801\udc00AB\udc11AB\ud802\ud803AB");
-  execs(["X", "\ud800C"], r"(?<=(\ud800\w))X",
-      "\ud800\udc00AX\udc11BX\ud800\ud800CX");
-  execs(["C", "\ud800\ud800"], r"(?<=(\ud800.))\w",
-      "\ud800\udc00AX\udc11BX\ud800\ud800CX");
-  execs(["X", "\udc01C"], r"(?<=(\udc01\w))X",
-      "\ud800\udc01AX\udc11BX\udc01\udc01CX");
-  execs(["C", "\udc01\udc01"], r"(?<=(\udc01.)).",
-      "\ud800\udc01AX\udc11BX\udc01\udc01CX");
-
-  const L = "\ud800";
-  const T = "\udc00";
-  const X = "X";
-
-  // Test string contains only match.
-  void testw(bool expect, String src, String subject) {
-    var re = RegExp(r"^" + src + r"$", unicode: true);
-    assertEquals(expect, re.hasMatch(subject));
-  }
-
-  // Test string starts with match.
-  void tests(bool expect, String src, String subject) {
-    var re = RegExp(r"^" + src, unicode: true);
-    assertEquals(expect, re.hasMatch(subject));
-  }
-
-  testw(true, X, X);
-  testw(true, L, L);
-  testw(true, T, T);
-  testw(true, L + T, L + T);
-  testw(true, T + L, T + L);
-  testw(false, T, L + T);
-  testw(false, L, L + T);
-  testw(true, r".(?<=" + L + r")", L);
-  testw(true, r".(?<=" + T + r")", T);
-  testw(true, r".(?<=" + L + T + r")", L + T);
-  testw(true, r".(?<=" + L + T + r")", L + T);
-  tests(true, r".(?<=" + T + r")", T + L);
-  tests(false, r".(?<=" + L + r")", L + T);
-  tests(false, r".(?<=" + T + r")", L + T);
-  tests(true, r"..(?<=" + T + r")", T + T + L);
-  tests(true, r"..(?<=" + T + r")", X + T + L);
-  tests(true, r"...(?<=" + L + r")", X + T + L);
-  tests(false, r"...(?<=" + T + r")", X + L + T);
-  tests(true, r"..(?<=" + L + T + r")", X + L + T);
-  tests(true, r"..(?<=" + L + T + r"(?<=" + L + T + r"))", X + L + T);
-  tests(false, r"..(?<=" + L + r"(" + T + r"))", X + L + T);
-  tests(false, r".*" + L, X + L + T);
-  tests(true, r".*" + L, X + L + L + T);
-  tests(false, r".*" + L, X + L + T + L + T);
-  tests(false, r".*" + T, X + L + T + L + T);
-  tests(true, r".*" + T, X + L + T + T + L + T);
-}
diff --git a/tests/corelib_2/regexp/unicode-escapes-in-regexps_test.dart b/tests/corelib_2/regexp/unicode-escapes-in-regexps_test.dart
deleted file mode 100644
index 7cb0894..0000000
--- a/tests/corelib_2/regexp/unicode-escapes-in-regexps_test.dart
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2014 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// ES6 extends the \uxxxx escape and also allows \u{xxxxx}.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void testRegExpHelper(RegExp r) {
-  assertTrue(r.hasMatch("foo"));
-  assertTrue(r.hasMatch("boo"));
-  assertFalse(r.hasMatch("moo"));
-}
-
-void TestUnicodeEscapes() {
-  testRegExpHelper(RegExp(r"(\u0066|\u0062)oo"));
-  testRegExpHelper(RegExp(r"(\u0066|\u0062)oo", unicode: true));
-  testRegExpHelper(RegExp(r"(\u{0066}|\u{0062})oo", unicode: true));
-  testRegExpHelper(RegExp(r"(\u{66}|\u{000062})oo", unicode: true));
-
-  // Note that we need \\ inside a string, otherwise it's interpreted as a
-  // unicode escape inside a string.
-  testRegExpHelper(RegExp("(\\u0066|\\u0062)oo"));
-  testRegExpHelper(RegExp("(\\u0066|\\u0062)oo", unicode: true));
-  testRegExpHelper(RegExp("(\\u{0066}|\\u{0062})oo", unicode: true));
-  testRegExpHelper(RegExp("(\\u{66}|\\u{000062})oo", unicode: true));
-
-  // Though, unicode escapes via strings should work too.
-  testRegExpHelper(RegExp("(\u0066|\u0062)oo"));
-  testRegExpHelper(RegExp("(\u0066|\u0062)oo", unicode: true));
-  testRegExpHelper(RegExp("(\u{0066}|\u{0062})oo", unicode: true));
-  testRegExpHelper(RegExp("(\u{66}|\u{000062})oo", unicode: true));
-}
-
-void TestUnicodeEscapesInCharacterClasses() {
-  testRegExpHelper(RegExp(r"[\u0062-\u0066]oo"));
-  testRegExpHelper(RegExp(r"[\u0062-\u0066]oo", unicode: true));
-  testRegExpHelper(RegExp(r"[\u{0062}-\u{0066}]oo", unicode: true));
-  testRegExpHelper(RegExp(r"[\u{62}-\u{000066}]oo", unicode: true));
-
-  // Note that we need \\ inside a string, otherwise it's interpreted as a
-  // unicode escape inside a string.
-  testRegExpHelper(RegExp("[\\u0062-\\u0066]oo"));
-  testRegExpHelper(RegExp("[\\u0062-\\u0066]oo", unicode: true));
-  testRegExpHelper(RegExp("[\\u{0062}-\\u{0066}]oo", unicode: true));
-  testRegExpHelper(RegExp("[\\u{62}-\\u{000066}]oo", unicode: true));
-
-  // Though, unicode escapes via strings should work too.
-  testRegExpHelper(RegExp("[\u0062-\u0066]oo"));
-  testRegExpHelper(RegExp("[\u0062-\u0066]oo", unicode: true));
-  testRegExpHelper(RegExp("[\u{0062}-\u{0066}]oo", unicode: true));
-  testRegExpHelper(RegExp("[\u{62}-\u{000066}]oo", unicode: true));
-}
-
-void TestBraceEscapesWithoutUnicodeFlag() {
-  // \u followed by illegal escape will be parsed as u. {x} will be the
-  // character count.
-  void helper1(RegExp r) {
-    assertFalse(r.hasMatch("fbar"));
-    assertFalse(r.hasMatch("fubar"));
-    assertTrue(r.hasMatch("fuubar"));
-    assertFalse(r.hasMatch("fuuubar"));
-  }
-
-  helper1(RegExp(r"f\u{2}bar"));
-  helper1(RegExp("f\\u{2}bar"));
-
-  void helper2(RegExp r) {
-    assertFalse(r.hasMatch("fbar"));
-    assertTrue(r.hasMatch("fubar"));
-    assertTrue(r.hasMatch("fuubar"));
-    assertFalse(r.hasMatch("fuuubar"));
-  }
-
-  helper2(RegExp(r"f\u{1,2}bar"));
-  helper2(RegExp("f\\u{1,2}bar"));
-
-  void helper3(RegExp r) {
-    assertTrue(r.hasMatch("u"));
-    assertTrue(r.hasMatch("{"));
-    assertTrue(r.hasMatch("2"));
-    assertTrue(r.hasMatch("}"));
-    assertFalse(r.hasMatch("q"));
-    assertFalse(r.hasMatch("("));
-    assertFalse(r.hasMatch(")"));
-  }
-
-  helper3(RegExp(r"[\u{2}]"));
-  helper3(RegExp("[\\u{2}]"));
-}
-
-void TestInvalidEscapes() {
-  // Without the u flag, invalid unicode escapes and other invalid escapes are
-  // treated as identity escapes.
-  void helper1(RegExp r) {
-    assertTrue(r.hasMatch("firstuxz89second"));
-  }
-
-  helper1(RegExp(r"first\u\x\z\8\9second"));
-  helper1(RegExp("first\\u\\x\\z\\8\\9second"));
-
-  void helper2(RegExp r) {
-    assertTrue(r.hasMatch("u"));
-    assertTrue(r.hasMatch("x"));
-    assertTrue(r.hasMatch("z"));
-    assertTrue(r.hasMatch("8"));
-    assertTrue(r.hasMatch("9"));
-    assertFalse(r.hasMatch("q"));
-    assertFalse(r.hasMatch("7"));
-  }
-
-  helper2(RegExp(r"[\u\x\z\8\9]"));
-  helper2(RegExp("[\\u\\x\\z\\8\\9]"));
-
-  // However, with the u flag, these are treated as invalid escapes.
-  assertThrows(() => RegExp(r"\u", unicode: true));
-  assertThrows(() => RegExp(r"\u12", unicode: true));
-  assertThrows(() => RegExp(r"\ufoo", unicode: true));
-  assertThrows(() => RegExp(r"\x", unicode: true));
-  assertThrows(() => RegExp(r"\xfoo", unicode: true));
-  assertThrows(() => RegExp(r"\z", unicode: true));
-  assertThrows(() => RegExp(r"\8", unicode: true));
-  assertThrows(() => RegExp(r"\9", unicode: true));
-
-  assertThrows(() => RegExp("\\u", unicode: true));
-  assertThrows(() => RegExp("\\u12", unicode: true));
-  assertThrows(() => RegExp("\\ufoo", unicode: true));
-  assertThrows(() => RegExp("\\x", unicode: true));
-  assertThrows(() => RegExp("\\xfoo", unicode: true));
-  assertThrows(() => RegExp("\\z", unicode: true));
-  assertThrows(() => RegExp("\\8", unicode: true));
-  assertThrows(() => RegExp("\\9", unicode: true));
-}
-
-void TestTooBigHexEscape() {
-  // The hex number inside \u{} has a maximum value.
-  RegExp(r"\u{10ffff}", unicode: true);
-  RegExp("\\u{10ffff}", unicode: true);
-  assertThrows(() => RegExp(r"\u{110000}", unicode: true));
-  assertThrows(() => RegExp("\\u{110000}", unicode: true));
-
-  // Without the u flag, they're of course fine ({x} is the count).
-  RegExp(r"\u{110000}");
-  RegExp("\\u{110000}");
-}
-
-void TestSyntaxEscapes() {
-  // Syntax escapes work the same with or without the u flag.
-  void helper(RegExp r) {
-    assertTrue(r.hasMatch("foo[bar"));
-    assertFalse(r.hasMatch("foo]bar"));
-  }
-
-  helper(RegExp(r"foo\[bar"));
-  helper(RegExp("foo\\[bar"));
-  helper(RegExp(r"foo\[bar", unicode: true));
-  helper(RegExp("foo\\[bar", unicode: true));
-}
-
-void TestUnicodeSurrogates() {
-  // U+10E6D corresponds to the surrogate pair [U+D803, U+DE6D].
-  void helper(RegExp r) {
-    assertTrue(r.hasMatch("foo\u{10e6d}bar"));
-  }
-
-  helper(RegExp(r"foo\ud803\ude6dbar", unicode: true));
-  helper(RegExp("foo\\ud803\\ude6dbar", unicode: true));
-}
-
-void main() {
-  TestUnicodeEscapes();
-  TestUnicodeEscapesInCharacterClasses();
-  TestBraceEscapesWithoutUnicodeFlag();
-  TestInvalidEscapes();
-  TestTooBigHexEscape();
-  TestSyntaxEscapes();
-  TestUnicodeSurrogates();
-
-  // Non-BMP patterns.
-  // Single character atom.
-  assertTrue(RegExp("\u{12345}", unicode: true).hasMatch("\u{12345}"));
-  assertTrue(RegExp(r"\u{12345}", unicode: true).hasMatch("\u{12345}"));
-  assertTrue(RegExp(r"\u{12345}", unicode: true).hasMatch("\ud808\udf45"));
-  assertTrue(RegExp(r"\u{12345}", unicode: true).hasMatch("\ud808\udf45"));
-  assertFalse(RegExp(r"\u{12345}", unicode: true).hasMatch("\udf45"));
-  assertFalse(RegExp(r"\u{12345}", unicode: true).hasMatch("\udf45"));
-
-  // Multi-character atom.
-  assertTrue(RegExp(r"\u{12345}\u{23456}", unicode: true)
-      .hasMatch("a\u{12345}\u{23456}b"));
-  assertTrue(RegExp(r"\u{12345}\u{23456}", unicode: true)
-      .hasMatch("b\u{12345}\u{23456}c"));
-  assertFalse(RegExp(r"\u{12345}\u{23456}", unicode: true)
-      .hasMatch("a\udf45\u{23456}b"));
-  assertFalse(RegExp(r"\u{12345}\u{23456}", unicode: true)
-      .hasMatch("b\udf45\u{23456}c"));
-
-  // Disjunction.
-  assertTrue(RegExp(r"\u{12345}(?:\u{23456})", unicode: true)
-      .hasMatch("a\u{12345}\u{23456}b"));
-  assertTrue(RegExp(r"\u{12345}(?:\u{23456})", unicode: true)
-      .hasMatch("b\u{12345}\u{23456}c"));
-  assertFalse(RegExp(r"\u{12345}(?:\u{23456})", unicode: true)
-      .hasMatch("a\udf45\u{23456}b"));
-  assertFalse(RegExp(r"\u{12345}(?:\u{23456})", unicode: true)
-      .hasMatch("b\udf45\u{23456}c"));
-
-  // Alternative.
-  assertTrue(
-      RegExp(r"\u{12345}|\u{23456}", unicode: true).hasMatch("a\u{12345}b"));
-  assertTrue(
-      RegExp(r"\u{12345}|\u{23456}", unicode: true).hasMatch("b\u{23456}c"));
-  assertFalse(
-      RegExp(r"\u{12345}|\u{23456}", unicode: true).hasMatch("a\udf45\ud84db"));
-  assertFalse(
-      RegExp(r"\u{12345}|\u{23456}", unicode: true).hasMatch("b\udf45\ud808c"));
-
-  // Capture.
-  assertTrue(RegExp("(\u{12345}|\u{23456}).\\1", unicode: true)
-      .hasMatch("\u{12345}b\u{12345}"));
-  assertTrue(RegExp(r"(\u{12345}|\u{23456}).\1", unicode: true)
-      .hasMatch("\u{12345}b\u{12345}"));
-  assertFalse(RegExp("(\u{12345}|\u{23456}).\\1", unicode: true)
-      .hasMatch("\u{12345}b\u{23456}"));
-  assertFalse(RegExp(r"(\u{12345}|\u{23456}).\1", unicode: true)
-      .hasMatch("\u{12345}b\u{23456}"));
-
-  // Quantifier.
-  assertTrue(RegExp("\u{12345}{3}", unicode: true)
-      .hasMatch("\u{12345}\u{12345}\u{12345}"));
-  assertTrue(RegExp(r"\u{12345}{3}", unicode: true)
-      .hasMatch("\u{12345}\u{12345}\u{12345}"));
-  assertTrue(RegExp("\u{12345}{3}").hasMatch("\u{12345}\udf45\udf45"));
-  assertFalse(RegExp(r"\ud808\udf45{3}", unicode: true)
-      .hasMatch("\u{12345}\udf45\udf45"));
-  assertTrue(RegExp(r"\ud808\udf45{3}", unicode: true)
-      .hasMatch("\u{12345}\u{12345}\u{12345}"));
-  assertFalse(
-      RegExp("\u{12345}{3}", unicode: true).hasMatch("\u{12345}\udf45\udf45"));
-  assertFalse(
-      RegExp(r"\u{12345}{3}", unicode: true).hasMatch("\u{12345}\udf45\udf45"));
-
-  // Literal surrogates.
-  shouldBe(
-      RegExp("\ud800\udc00+", unicode: true).firstMatch("\u{10000}\u{10000}"),
-      ["\u{10000}\u{10000}"]);
-  shouldBe(
-      RegExp("\\ud800\\udc00+", unicode: true).firstMatch("\u{10000}\u{10000}"),
-      ["\u{10000}\u{10000}"]);
-
-  shouldBe(
-      RegExp("[\\ud800\\udc03-\\ud900\\udc01\]+", unicode: true)
-          .firstMatch("\u{10003}\u{50001}"),
-      ["\u{10003}\u{50001}"]);
-  shouldBe(
-      RegExp("[\ud800\udc03-\u{50001}\]+", unicode: true)
-          .firstMatch("\u{10003}\u{50001}"),
-      ["\u{10003}\u{50001}"]);
-
-  // Unicode escape sequences to represent a non-BMP character cannot have
-  // mixed notation, and must follow the rules for RegExpUnicodeEscapeSequence.
-  assertThrows(() => RegExp("[\\ud800\udc03-\ud900\\udc01\]+", unicode: true));
-  assertNull(
-      RegExp("\\ud800\udc00+", unicode: true).firstMatch("\u{10000}\u{10000}"));
-  assertNull(
-      RegExp("\ud800\\udc00+", unicode: true).firstMatch("\u{10000}\u{10000}"));
-
-  assertNull(RegExp("[\\ud800\udc00]", unicode: true).firstMatch("\u{10000}"));
-  assertNull(
-      RegExp("[\\{ud800}\udc00]", unicode: true).firstMatch("\u{10000}"));
-  assertNull(RegExp("[\ud800\\udc00]", unicode: true).firstMatch("\u{10000}"));
-  assertNull(
-      RegExp("[\ud800\\{udc00}]", unicode: true).firstMatch("\u{10000}"));
-
-  assertNull(RegExp(r"\u{d800}\u{dc00}+", unicode: true)
-      .firstMatch("\ud800\udc00\udc00"));
-  assertNull(RegExp(r"\ud800\u{dc00}+", unicode: true)
-      .firstMatch("\ud800\udc00\udc00"));
-  assertNull(RegExp(r"\u{d800}\udc00+", unicode: true)
-      .firstMatch("\ud800\udc00\udc00"));
-}
diff --git a/tests/corelib_2/regexp/unicode-property-binary_test.dart b/tests/corelib_2/regexp/unicode-property-binary_test.dart
deleted file mode 100644
index b8981a7..0000000
--- a/tests/corelib_2/regexp/unicode-property-binary_test.dart
+++ /dev/null
@@ -1,201 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  void t(RegExp re, String s) {
-    assertTrue(re.hasMatch(s));
-  }
-
-  void f(RegExp re, String s) {
-    assertFalse(re.hasMatch(s));
-  }
-
-  assertThrows(() => RegExp("\\p{Hiragana}", unicode: true));
-  assertThrows(() => RegExp("\\p{Bidi_Class}", unicode: true));
-  assertThrows(() => RegExp("\\p{Bidi_C=False}", unicode: true));
-  assertThrows(() => RegExp("\\P{Bidi_Control=Y}", unicode: true));
-  assertThrows(() => RegExp("\\p{AHex=Yes}", unicode: true));
-
-  assertThrows(() => RegExp("\\p{Composition_Exclusion}", unicode: true));
-  assertThrows(() => RegExp("\\p{CE}", unicode: true));
-  assertThrows(() => RegExp("\\p{Full_Composition_Exclusion}", unicode: true));
-  assertThrows(() => RegExp("\\p{Comp_Ex}", unicode: true));
-  assertThrows(() => RegExp("\\p{Grapheme_Link}", unicode: true));
-  assertThrows(() => RegExp("\\p{Gr_Link}", unicode: true));
-  assertThrows(() => RegExp("\\p{Hyphen}", unicode: true));
-  assertThrows(() => RegExp("\\p{NFD_Inert}", unicode: true));
-  assertThrows(() => RegExp("\\p{NFDK_Inert}", unicode: true));
-  assertThrows(() => RegExp("\\p{NFC_Inert}", unicode: true));
-  assertThrows(() => RegExp("\\p{NFKC_Inert}", unicode: true));
-  assertThrows(() => RegExp("\\p{Segment_Starter}", unicode: true));
-
-  t(RegExp(r"\p{Alphabetic}", unicode: true), "æ");
-  f(RegExp(r"\p{Alpha}", unicode: true), "1");
-
-  t(RegExp(r"\p{ASCII_Hex_Digit}", unicode: true), "f");
-  f(RegExp(r"\p{AHex}", unicode: true), "g");
-
-  t(RegExp(r"\p{Bidi_Control}", unicode: true), "\u200e");
-  f(RegExp(r"\p{Bidi_C}", unicode: true), "g");
-
-  t(RegExp(r"\p{Bidi_Mirrored}", unicode: true), "(");
-  f(RegExp(r"\p{Bidi_M}", unicode: true), "-");
-
-  t(RegExp(r"\p{Case_Ignorable}", unicode: true), "\u02b0");
-  f(RegExp(r"\p{CI}", unicode: true), "a");
-
-  t(RegExp(r"\p{Changes_When_Casefolded}", unicode: true), "B");
-  f(RegExp(r"\p{CWCF}", unicode: true), "1");
-
-  t(RegExp(r"\p{Changes_When_Casemapped}", unicode: true), "b");
-  f(RegExp(r"\p{CWCM}", unicode: true), "1");
-
-  t(RegExp(r"\p{Changes_When_Lowercased}", unicode: true), "B");
-  f(RegExp(r"\p{CWL}", unicode: true), "1");
-
-  t(RegExp(r"\p{Changes_When_Titlecased}", unicode: true), "b");
-  f(RegExp(r"\p{CWT}", unicode: true), "1");
-
-  t(RegExp(r"\p{Changes_When_Uppercased}", unicode: true), "b");
-  f(RegExp(r"\p{CWU}", unicode: true), "1");
-
-  t(RegExp(r"\p{Dash}", unicode: true), "-");
-  f(RegExp(r"\p{Dash}", unicode: true), "1");
-
-  t(RegExp(r"\p{Default_Ignorable_Code_Point}", unicode: true), "\u00ad");
-  f(RegExp(r"\p{DI}", unicode: true), "1");
-
-  t(RegExp(r"\p{Deprecated}", unicode: true), "\u17a3");
-  f(RegExp(r"\p{Dep}", unicode: true), "1");
-
-  t(RegExp(r"\p{Diacritic}", unicode: true), "\u0301");
-  f(RegExp(r"\p{Dia}", unicode: true), "1");
-
-  t(RegExp(r"\p{Emoji}", unicode: true), "\u2603");
-  f(RegExp(r"\p{Emoji}", unicode: true), "x");
-
-  t(RegExp(r"\p{Emoji_Component}", unicode: true), "\u{1F1E6}");
-  f(RegExp(r"\p{Emoji_Component}", unicode: true), "x");
-
-  t(RegExp(r"\p{Emoji_Modifier_Base}", unicode: true), "\u{1F6CC}");
-  f(RegExp(r"\p{Emoji_Modifier_Base}", unicode: true), "x");
-
-  t(RegExp(r"\p{Emoji_Modifier}", unicode: true), "\u{1F3FE}");
-  f(RegExp(r"\p{Emoji_Modifier}", unicode: true), "x");
-
-  t(RegExp(r"\p{Emoji_Presentation}", unicode: true), "\u{1F308}");
-  f(RegExp(r"\p{Emoji_Presentation}", unicode: true), "x");
-
-  t(RegExp(r"\p{Extender}", unicode: true), "\u3005");
-  f(RegExp(r"\p{Ext}", unicode: true), "x");
-
-  t(RegExp(r"\p{Grapheme_Base}", unicode: true), " ");
-  f(RegExp(r"\p{Gr_Base}", unicode: true), "\u0010");
-
-  t(RegExp(r"\p{Grapheme_Extend}", unicode: true), "\u0300");
-  f(RegExp(r"\p{Gr_Ext}", unicode: true), "x");
-
-  t(RegExp(r"\p{Hex_Digit}", unicode: true), "a");
-  f(RegExp(r"\p{Hex}", unicode: true), "g");
-
-  t(RegExp(r"\p{ID_Continue}", unicode: true), "1");
-  f(RegExp(r"\p{IDC}", unicode: true), ".");
-
-  t(RegExp(r"\p{ID_Start}", unicode: true), "a");
-  f(RegExp(r"\p{IDS}", unicode: true), "1");
-
-  t(RegExp(r"\p{Ideographic}", unicode: true), "漢");
-  f(RegExp(r"\p{Ideo}", unicode: true), "H");
-
-  t(RegExp(r"\p{IDS_Binary_Operator}", unicode: true), "\u2FF0");
-  f(RegExp(r"\p{IDSB}", unicode: true), "a");
-
-  t(RegExp(r"\p{IDS_Trinary_Operator}", unicode: true), "\u2FF2");
-  f(RegExp(r"\p{IDST}", unicode: true), "a");
-
-  t(RegExp(r"\p{Join_Control}", unicode: true), "\u200c");
-  f(RegExp(r"\p{Join_C}", unicode: true), "a");
-
-  t(RegExp(r"\p{Logical_Order_Exception}", unicode: true), "\u0e40");
-  f(RegExp(r"\p{LOE}", unicode: true), "a");
-
-  t(RegExp(r"\p{Lowercase}", unicode: true), "a");
-  f(RegExp(r"\p{Lower}", unicode: true), "A");
-
-  t(RegExp(r"\p{Math}", unicode: true), "=");
-  f(RegExp(r"\p{Math}", unicode: true), "A");
-
-  t(RegExp(r"\p{Noncharacter_Code_Point}", unicode: true), "\uFDD0");
-  f(RegExp(r"\p{NChar}", unicode: true), "A");
-
-  t(RegExp(r"\p{Pattern_Syntax}", unicode: true), "\u0021");
-  f(RegExp(r"\p{NChar}", unicode: true), "A");
-
-  t(RegExp(r"\p{Pattern_White_Space}", unicode: true), "\u0009");
-  f(RegExp(r"\p{Pat_Syn}", unicode: true), "A");
-
-  t(RegExp(r"\p{Quotation_Mark}", unicode: true), "'");
-  f(RegExp(r"\p{QMark}", unicode: true), "A");
-
-  t(RegExp(r"\p{Radical}", unicode: true), "\u2FAD");
-  f(RegExp(r"\p{Radical}", unicode: true), "A");
-
-  t(RegExp(r"\p{Regional_Indicator}", unicode: true), "\u{1F1E6}");
-  f(RegExp(r"\p{Regional_Indicator}", unicode: true), "A");
-
-  t(RegExp(r"\p{Sentence_Terminal}", unicode: true), "!");
-  f(RegExp(r"\p{STerm}", unicode: true), "A");
-
-  t(RegExp(r"\p{Soft_Dotted}", unicode: true), "i");
-  f(RegExp(r"\p{SD}", unicode: true), "A");
-
-  t(RegExp(r"\p{Terminal_Punctuation}", unicode: true), ".");
-  f(RegExp(r"\p{Term}", unicode: true), "A");
-
-  t(RegExp(r"\p{Unified_Ideograph}", unicode: true), "\u4e00");
-  f(RegExp(r"\p{UIdeo}", unicode: true), "A");
-
-  t(RegExp(r"\p{Uppercase}", unicode: true), "A");
-  f(RegExp(r"\p{Upper}", unicode: true), "a");
-
-  t(RegExp(r"\p{Variation_Selector}", unicode: true), "\uFE00");
-  f(RegExp(r"\p{VS}", unicode: true), "A");
-
-  t(RegExp(r"\p{White_Space}", unicode: true), " ");
-  f(RegExp(r"\p{WSpace}", unicode: true), "A");
-
-  t(RegExp(r"\p{XID_Continue}", unicode: true), "1");
-  f(RegExp(r"\p{XIDC}", unicode: true), " ");
-
-  t(RegExp(r"\p{XID_Start}", unicode: true), "A");
-  f(RegExp(r"\p{XIDS}", unicode: true), " ");
-}
diff --git a/tests/corelib_2/regexp/unicode-property-char-class_test.dart b/tests/corelib_2/regexp/unicode-property-char-class_test.dart
deleted file mode 100644
index db87fad..0000000
--- a/tests/corelib_2/regexp/unicode-property-char-class_test.dart
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2011 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  assertThrows(() => RegExp("[\\p]", unicode: true));
-  assertThrows(() => RegExp("[\\p{garbage}]", unicode: true));
-  assertThrows(() => RegExp("[\\p{}]", unicode: true));
-  assertThrows(() => RegExp("[\\p{]", unicode: true));
-  assertThrows(() => RegExp("[\\p}]", unicode: true));
-  assertThrows(() => RegExp("^[\\p{Lu}-\\p{Ll}]+\$", unicode: true));
-
-  assertTrue(RegExp(r"^[\p{Lu}\p{Ll}]+$", unicode: true).hasMatch("ABCabc"));
-  assertTrue(RegExp(r"^[\p{Lu}-]+$", unicode: true).hasMatch("ABC-"));
-  assertFalse(RegExp(r"^[\P{Lu}\p{Ll}]+$", unicode: true).hasMatch("ABCabc"));
-  assertTrue(RegExp(r"^[\P{Lu}\p{Ll}]+$", unicode: true).hasMatch("abc"));
-  assertTrue(RegExp(r"^[\P{Lu}]+$", unicode: true).hasMatch("abc123"));
-  assertFalse(RegExp(r"^[\P{Lu}]+$", unicode: true).hasMatch("XYZ"));
-  assertTrue(RegExp(r"[\p{Math}]", unicode: true).hasMatch("+"));
-  assertTrue(RegExp(r"[\P{Bidi_M}]", unicode: true).hasMatch(" "));
-  assertTrue(RegExp(r"[\p{Hex}]", unicode: true).hasMatch("A"));
-
-  assertTrue(RegExp(r"^[^\P{Lu}]+$", unicode: true).hasMatch("XYZ"));
-  assertFalse(RegExp(r"^[^\p{Lu}\p{Ll}]+$", unicode: true).hasMatch("abc"));
-  assertFalse(RegExp(r"^[^\p{Lu}\p{Ll}]+$", unicode: true).hasMatch("ABC"));
-  assertTrue(RegExp(r"^[^\p{Lu}\p{Ll}]+$", unicode: true).hasMatch("123"));
-  assertTrue(RegExp(r"^[^\p{Lu}\P{Ll}]+$", unicode: true).hasMatch("abc"));
-}
diff --git a/tests/corelib_2/regexp/unicode-property-enumerated_test.dart b/tests/corelib_2/regexp/unicode-property-enumerated_test.dart
deleted file mode 100644
index cfb3e02..0000000
--- a/tests/corelib_2/regexp/unicode-property-enumerated_test.dart
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  assertThrows(() => RegExp("\\p{Bidi_Class=L}+", unicode: true));
-  assertThrows(() => RegExp("\\p{bc=Left_To_Right}+", unicode: true));
-  assertThrows(() => RegExp("\\p{bc=AL}+", unicode: true));
-  assertThrows(() => RegExp("\\p{bc=Arabic_Letter}+", unicode: true));
-
-  assertThrows(() => RegExp("\\p{Line_Break=Glue}", unicode: true));
-  assertThrows(() => RegExp("\\p{lb=AL}", unicode: true));
-
-  assertThrows(() => RegExp("\\p{Block=}", unicode: true));
-  assertThrows(() => RegExp("\\p{=}", unicode: true));
-  assertThrows(() => RegExp("\\p{=L}", unicode: true));
-  assertThrows(() => RegExp("\\p{=Hiragana}", unicode: true));
-  assertThrows(() => RegExp("\\p{Block=CJK=}", unicode: true));
-
-  assertThrows(() => RegExp("\\p{Age=V8_0}", unicode: true));
-  assertDoesNotThrow(
-      () => RegExp("\\p{General_Category=Letter}", unicode: true));
-  assertDoesNotThrow(() => RegExp("\\p{gc=L}", unicode: true));
-  assertThrows(
-      () => RegExp("\\p{General_Category_Mask=Letter}", unicode: true));
-  assertThrows(() => RegExp("\\p{gcm=L}", unicode: true));
-}
diff --git a/tests/corelib_2/regexp/unicode-property-exact-match_test.dart b/tests/corelib_2/regexp/unicode-property-exact-match_test.dart
deleted file mode 100644
index bbf99d0..0000000
--- a/tests/corelib_2/regexp/unicode-property-exact-match_test.dart
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  assertThrows(() => RegExp("\\p{In CJK}", unicode: true));
-  assertThrows(() => RegExp("\\p{InCJKUnifiedIdeographs}", unicode: true));
-  assertThrows(() => RegExp("\\p{InCJK}", unicode: true));
-  assertThrows(() => RegExp("\\p{InCJK_Unified_Ideographs}", unicode: true));
-
-  assertThrows(() => RegExp("\\p{InCyrillic_Sup}", unicode: true));
-  assertThrows(() => RegExp("\\p{InCyrillic_Supplement}", unicode: true));
-  assertThrows(() => RegExp("\\p{InCyrillic_Supplementary}", unicode: true));
-  assertThrows(() => RegExp("\\p{InCyrillicSupplementary}", unicode: true));
-  assertThrows(() => RegExp("\\p{InCyrillic_supplementary}", unicode: true));
-
-  assertDoesNotThrow(() => RegExp("\\p{C}", unicode: true));
-  assertDoesNotThrow(() => RegExp("\\p{Other}", unicode: true));
-  assertDoesNotThrow(() => RegExp("\\p{Cc}", unicode: true));
-  assertDoesNotThrow(() => RegExp("\\p{Control}", unicode: true));
-  assertDoesNotThrow(() => RegExp("\\p{cntrl}", unicode: true));
-  assertDoesNotThrow(() => RegExp("\\p{M}", unicode: true));
-  assertDoesNotThrow(() => RegExp("\\p{Mark}", unicode: true));
-  assertDoesNotThrow(() => RegExp("\\p{Combining_Mark}", unicode: true));
-  assertThrows(() => RegExp("\\p{Combining Mark}", unicode: true));
-
-  assertDoesNotThrow(() => RegExp("\\p{Script=Copt}", unicode: true));
-  assertThrows(() => RegExp("\\p{Coptic}", unicode: true));
-  assertThrows(() => RegExp("\\p{Qaac}", unicode: true));
-  assertThrows(() => RegExp("\\p{Egyp}", unicode: true));
-  assertDoesNotThrow(
-      () => RegExp("\\p{Script=Egyptian_Hieroglyphs}", unicode: true));
-  assertThrows(() => RegExp("\\p{EgyptianHieroglyphs}", unicode: true));
-
-  assertThrows(() => RegExp("\\p{BidiClass=LeftToRight}", unicode: true));
-  assertThrows(() => RegExp("\\p{BidiC=LeftToRight}", unicode: true));
-  assertThrows(() => RegExp("\\p{bidi_c=Left_To_Right}", unicode: true));
-
-  assertThrows(() => RegExp("\\p{Block=CJK}", unicode: true));
-  assertThrows(() => RegExp("\\p{Block = CJK}", unicode: true));
-  assertThrows(() => RegExp("\\p{Block=cjk}", unicode: true));
-  assertThrows(() => RegExp("\\p{BLK=CJK}", unicode: true));
-}
diff --git a/tests/corelib_2/regexp/unicode-property-general-category_test.dart b/tests/corelib_2/regexp/unicode-property-general-category_test.dart
deleted file mode 100644
index cb94cac..0000000
--- a/tests/corelib_2/regexp/unicode-property-general-category_test.dart
+++ /dev/null
@@ -1,114 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  assertThrows(() => RegExp("\\p", unicode: true));
-  assertThrows(() => RegExp("\\p{garbage}", unicode: true));
-  assertThrows(() => RegExp("\\p{}", unicode: true));
-  assertThrows(() => RegExp("\\p{", unicode: true));
-  assertThrows(() => RegExp("\\p}", unicode: true));
-  assertThrows(() => RegExp("\\pL", unicode: true));
-  assertThrows(() => RegExp("\\P", unicode: true));
-  assertThrows(() => RegExp("\\P{garbage}", unicode: true));
-  assertThrows(() => RegExp("\\P{}", unicode: true));
-  assertThrows(() => RegExp("\\P{", unicode: true));
-  assertThrows(() => RegExp("\\P}", unicode: true));
-  assertThrows(() => RegExp("\\PL", unicode: true));
-
-  assertTrue(RegExp(r"\p{Ll}", unicode: true).hasMatch("a"));
-  assertFalse(RegExp(r"\P{Ll}", unicode: true).hasMatch("a"));
-  assertTrue(RegExp(r"\P{Ll}", unicode: true).hasMatch("A"));
-  assertFalse(RegExp(r"\p{Ll}", unicode: true).hasMatch("A"));
-  assertTrue(RegExp(r"\p{Ll}", unicode: true).hasMatch("\u{1D7BE}"));
-  assertFalse(RegExp(r"\P{Ll}", unicode: true).hasMatch("\u{1D7BE}"));
-  assertFalse(RegExp(r"\p{Ll}", unicode: true).hasMatch("\u{1D5E3}"));
-  assertTrue(RegExp(r"\P{Ll}", unicode: true).hasMatch("\u{1D5E3}"));
-
-  assertTrue(
-      RegExp(r"\p{Ll}", caseSensitive: false, unicode: true).hasMatch("a"));
-  assertTrue(RegExp(r"\p{Ll}", caseSensitive: false, unicode: true)
-      .hasMatch("\u{118D4}"));
-  assertTrue(
-      RegExp(r"\p{Ll}", caseSensitive: false, unicode: true).hasMatch("A"));
-  assertTrue(RegExp(r"\p{Ll}", caseSensitive: false, unicode: true)
-      .hasMatch("\u{118B4}"));
-  assertTrue(
-      RegExp(r"\P{Ll}", caseSensitive: false, unicode: true).hasMatch("a"));
-  assertTrue(RegExp(r"\P{Ll}", caseSensitive: false, unicode: true)
-      .hasMatch("\u{118D4}"));
-  assertTrue(
-      RegExp(r"\P{Ll}", caseSensitive: false, unicode: true).hasMatch("A"));
-  assertTrue(RegExp(r"\P{Ll}", caseSensitive: false, unicode: true)
-      .hasMatch("\u{118B4}"));
-
-  assertTrue(RegExp(r"\p{Lu}", unicode: true).hasMatch("A"));
-  assertFalse(RegExp(r"\P{Lu}", unicode: true).hasMatch("A"));
-  assertTrue(RegExp(r"\P{Lu}", unicode: true).hasMatch("a"));
-  assertFalse(RegExp(r"\p{Lu}", unicode: true).hasMatch("a"));
-  assertTrue(RegExp(r"\p{Lu}", unicode: true).hasMatch("\u{1D5E3}"));
-  assertFalse(RegExp(r"\P{Lu}", unicode: true).hasMatch("\u{1D5E3}"));
-  assertFalse(RegExp(r"\p{Lu}", unicode: true).hasMatch("\u{1D7BE}"));
-  assertTrue(RegExp(r"\P{Lu}", unicode: true).hasMatch("\u{1D7BE}"));
-
-  assertTrue(
-      RegExp(r"\p{Lu}", caseSensitive: false, unicode: true).hasMatch("a"));
-  assertTrue(RegExp(r"\p{Lu}", caseSensitive: false, unicode: true)
-      .hasMatch("\u{118D4}"));
-  assertTrue(
-      RegExp(r"\p{Lu}", caseSensitive: false, unicode: true).hasMatch("A"));
-  assertTrue(RegExp(r"\p{Lu}", caseSensitive: false, unicode: true)
-      .hasMatch("\u{118B4}"));
-  assertTrue(
-      RegExp(r"\P{Lu}", caseSensitive: false, unicode: true).hasMatch("a"));
-  assertTrue(RegExp(r"\P{Lu}", caseSensitive: false, unicode: true)
-      .hasMatch("\u{118D4}"));
-  assertTrue(
-      RegExp(r"\P{Lu}", caseSensitive: false, unicode: true).hasMatch("A"));
-  assertTrue(RegExp(r"\P{Lu}", caseSensitive: false, unicode: true)
-      .hasMatch("\u{118B4}"));
-
-  assertTrue(RegExp(r"\p{Sm}", unicode: true).hasMatch("+"));
-  assertFalse(RegExp(r"\P{Sm}", unicode: true).hasMatch("+"));
-  assertTrue(RegExp(r"\p{Sm}", unicode: true).hasMatch("\u{1D6C1}"));
-  assertFalse(RegExp(r"\P{Sm}", unicode: true).hasMatch("\u{1D6C1}"));
-
-  assertFalse(RegExp(r"\p{L}", unicode: true).hasMatch("\uA6EE"));
-  assertTrue(RegExp(r"\P{L}", unicode: true).hasMatch("\uA6EE"));
-
-  assertTrue(RegExp(r"\p{Lowercase_Letter}", unicode: true).hasMatch("a"));
-  assertTrue(RegExp(r"\p{Math_Symbol}", unicode: true).hasMatch("+"));
-
-  assertTrue(RegExp(r"\p{gc=Ll}", unicode: true).hasMatch("a"));
-  assertTrue(
-      RegExp(r"\p{General_Category=Math_Symbol}", unicode: true).hasMatch("+"));
-  assertTrue(RegExp(r"\p{General_Category=L}", unicode: true).hasMatch("X"));
-}
diff --git a/tests/corelib_2/regexp/unicode-property-invalid_test.dart b/tests/corelib_2/regexp/unicode-property-invalid_test.dart
deleted file mode 100644
index 8dddbc1..0000000
--- a/tests/corelib_2/regexp/unicode-property-invalid_test.dart
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  assertThrows(() => RegExp("\p{Block=ASCII}+", unicode: true));
-  assertThrows(() => RegExp("\p{Block=ASCII}+", unicode: true));
-  assertThrows(() => RegExp("\p{Block=Basic_Latin}+", unicode: true));
-  assertThrows(() => RegExp("\p{Block=Basic_Latin}+", unicode: true));
-
-  assertThrows(() => RegExp("\p{blk=CJK}+", unicode: true));
-  assertThrows(() => RegExp("\p{blk=CJK_Unified_Ideographs}+", unicode: true));
-  assertThrows(() => RegExp("\p{blk=CJK}+", unicode: true));
-  assertThrows(() => RegExp("\p{blk=CJK_Unified_Ideographs}+", unicode: true));
-
-  assertThrows(() => RegExp("\p{Block=ASCII}+", unicode: true));
-  assertThrows(() => RegExp("\p{Block=ASCII}+", unicode: true));
-  assertThrows(() => RegExp("\p{Block=Basic_Latin}+", unicode: true));
-  assertThrows(() => RegExp("\p{Block=Basic_Latin}+", unicode: true));
-
-  assertThrows(() => RegExp("\p{NFKD_Quick_Check=Y}+", unicode: true));
-  assertThrows(() => RegExp("\p{NFKD_QC=Yes}+", unicode: true));
-
-  assertThrows(() => RegExp("\p{Numeric_Type=Decimal}+", unicode: true));
-  assertThrows(() => RegExp("\p{nt=De}+", unicode: true));
-
-  assertThrows(() => RegExp("\p{Bidi_Class=Arabic_Letter}+", unicode: true));
-  assertThrows(() => RegExp("\p{Bidi_Class=AN}+", unicode: true));
-
-  assertThrows(() => RegExp("\p{ccc=OV}+", unicode: true));
-
-  assertThrows(() => RegExp("\p{Sentence_Break=Format}+", unicode: true));
-
-  assertThrows(() => RegExp("\\p{In}", unicode: true));
-  assertThrows(() => RegExp("\\pI", unicode: true));
-  assertThrows(() => RegExp("\\p{I}", unicode: true));
-  assertThrows(() => RegExp("\\p{CJK}", unicode: true));
-
-  assertThrows(() => RegExp("\\p{}", unicode: true));
-}
diff --git a/tests/corelib_2/regexp/unicode-property-scripts_test.dart b/tests/corelib_2/regexp/unicode-property-scripts_test.dart
deleted file mode 100644
index 5adec29..0000000
--- a/tests/corelib_2/regexp/unicode-property-scripts_test.dart
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  void t(RegExp re, String s) {
-    assertTrue(re.hasMatch(s));
-  }
-
-  void f(RegExp re, String s) {
-    assertFalse(re.hasMatch(s));
-  }
-
-  t(RegExp(r"\p{Script=Common}+", unicode: true), ".");
-  f(RegExp(r"\p{Script=Common}+", unicode: true),
-      "supercalifragilisticexpialidocious");
-
-  t(RegExp(r"\p{Script=Han}+", unicode: true), "话说天下大势，分久必合，合久必分");
-  t(RegExp(r"\p{Script=Hani}+", unicode: true), "吾庄后有一桃园，花开正盛");
-  f(RegExp(r"\p{Script=Han}+", unicode: true), "おはようございます");
-  f(RegExp(r"\p{Script=Hani}+", unicode: true),
-      "Something is rotten in the state of Denmark");
-
-  t(RegExp(r"\p{Script=Latin}+", unicode: true),
-      "Wie froh bin ich, daß ich weg bin!");
-  t(RegExp(r"\p{Script=Latn}+", unicode: true),
-      "It was a bright day in April, and the clocks were striking thirteen");
-  f(RegExp(r"\p{Script=Latin}+", unicode: true), "奔腾千里荡尘埃，渡水登山紫雾开");
-  f(RegExp(r"\p{Script=Latn}+", unicode: true), "いただきます");
-
-  t(RegExp(r"\p{sc=Hiragana}", unicode: true), "いただきます");
-  t(RegExp(r"\p{sc=Hira}", unicode: true), "ありがとうございました");
-  f(RegExp(r"\p{sc=Hiragana}", unicode: true),
-      "Als Gregor Samsa eines Morgens aus unruhigen Träumen erwachte");
-  f(RegExp(r"\p{sc=Hira}", unicode: true), "Call me Ishmael");
-
-  t(RegExp(r"\p{sc=Phoenician}", unicode: true), "\u{10900}\u{1091a}");
-  t(RegExp(r"\p{sc=Phnx}", unicode: true), "\u{1091f}\u{10916}");
-  f(RegExp(r"\p{sc=Phoenician}", unicode: true), "Arthur est un perroquet");
-  f(RegExp(r"\p{sc=Phnx}", unicode: true), "设心狠毒非良士，操卓原来一路人");
-
-  t(RegExp(r"\p{sc=Grek}", unicode: true),
-      "ἄνδρα μοι ἔννεπε, μοῦσα, πολύτροπον, ὃς μάλα πολλὰ");
-  t(RegExp(r"\p{sc=Greek}", unicode: true),
-      "μῆνιν ἄειδε θεὰ Πηληϊάδεω Ἀχιλῆος");
-  f(RegExp(r"\p{sc=Greek}", unicode: true), "高贤未服英雄志，屈节偏生杰士疑");
-  f(RegExp(r"\p{sc=Greek}", unicode: true),
-      "Mr. Jones, of the Manor Farm, had locked the hen-houses for the night");
-}
diff --git a/tests/corelib_2/regexp/unicode-property-special_test.dart b/tests/corelib_2/regexp/unicode-property-special_test.dart
deleted file mode 100644
index 1e0d2c1..0000000
--- a/tests/corelib_2/regexp/unicode-property-special_test.dart
+++ /dev/null
@@ -1,110 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  void t(RegExp re, String s) {
-    assertTrue(re.hasMatch(s));
-  }
-
-  void f(RegExp re, String s) {
-    assertFalse(re.hasMatch(s));
-  }
-
-  t(RegExp(r"\p{ASCII}+", unicode: true), "abc123");
-  f(RegExp(r"\p{ASCII}+", unicode: true), "ⓐⓑⓒ①②③");
-  f(RegExp(r"\p{ASCII}+", unicode: true), "🄰🄱🄲①②③");
-  f(RegExp(r"\P{ASCII}+", unicode: true), "abcd123");
-  t(RegExp(r"\P{ASCII}+", unicode: true), "ⓐⓑⓒ①②③");
-  t(RegExp(r"\P{ASCII}+", unicode: true), "🄰🄱🄲①②③");
-
-  f(RegExp(r"[^\p{ASCII}]+", unicode: true), "abc123");
-  f(RegExp(r"[\p{ASCII}]+", unicode: true), "ⓐⓑⓒ①②③");
-  f(RegExp(r"[\p{ASCII}]+", unicode: true), "🄰🄱🄲①②③");
-  t(RegExp(r"[^\P{ASCII}]+", unicode: true), "abcd123");
-  t(RegExp(r"[\P{ASCII}]+", unicode: true), "ⓐⓑⓒ①②③");
-  f(RegExp(r"[^\P{ASCII}]+", unicode: true), "🄰🄱🄲①②③");
-
-  t(RegExp(r"\p{Any}+", unicode: true), "🄰🄱🄲①②③");
-
-  shouldBe(
-      RegExp(r"\p{Any}", unicode: true).firstMatch("\ud800\ud801"), ["\ud800"]);
-  shouldBe(
-      RegExp(r"\p{Any}", unicode: true).firstMatch("\udc00\udc01"), ["\udc00"]);
-  shouldBe(RegExp(r"\p{Any}", unicode: true).firstMatch("\ud800\udc01"),
-      ["\ud800\udc01"]);
-  shouldBe(RegExp(r"\p{Any}", unicode: true).firstMatch("\udc01"), ["\udc01"]);
-
-  f(RegExp(r"\P{Any}+", unicode: true), "123");
-  f(RegExp(r"[\P{Any}]+", unicode: true), "123");
-  t(RegExp(r"[\P{Any}\d]+", unicode: true), "123");
-  t(RegExp(r"[^\P{Any}]+", unicode: true), "123");
-
-  t(RegExp(r"\p{Assigned}+", unicode: true), "123");
-  t(RegExp(r"\p{Assigned}+", unicode: true), "🄰🄱🄲");
-  f(RegExp(r"\p{Assigned}+", unicode: true), "\ufdd0");
-  f(RegExp(r"\p{Assigned}+", unicode: true), "\u{fffff}");
-
-  f(RegExp(r"\P{Assigned}+", unicode: true), "123");
-  f(RegExp(r"\P{Assigned}+", unicode: true), "🄰🄱🄲");
-  t(RegExp(r"\P{Assigned}+", unicode: true), "\ufdd0");
-  t(RegExp(r"\P{Assigned}+", unicode: true), "\u{fffff}");
-  f(RegExp(r"\P{Assigned}", unicode: true), "");
-
-  t(RegExp(r"[^\P{Assigned}]+", unicode: true), "123");
-  f(RegExp(r"[\P{Assigned}]+", unicode: true), "🄰🄱🄲");
-  f(RegExp(r"[^\P{Assigned}]+", unicode: true), "\ufdd0");
-  t(RegExp(r"[\P{Assigned}]+", unicode: true), "\u{fffff}");
-  f(RegExp(r"[\P{Assigned}]", unicode: true), "");
-
-  f(RegExp(r"[^\u1234\p{ASCII}]+", unicode: true), "\u1234");
-  t(RegExp(r"[x\P{ASCII}]+", unicode: true), "x");
-  t(RegExp(r"[\u1234\p{ASCII}]+", unicode: true), "\u1234");
-
-// Contributory binary properties are not supported.
-  assertThrows(() => RegExp("\\p{Other_Alphabetic}", unicode: true));
-  assertThrows(() => RegExp("\\P{OAlpha}", unicode: true));
-  assertThrows(
-      () => RegExp("\\p{Other_Default_Ignorable_Code_Point}", unicode: true));
-  assertThrows(() => RegExp("\\P{ODI}", unicode: true));
-  assertThrows(() => RegExp("\\p{Other_Grapheme_Extend}", unicode: true));
-  assertThrows(() => RegExp("\\P{OGr_Ext}", unicode: true));
-  assertThrows(() => RegExp("\\p{Other_ID_Continue}", unicode: true));
-  assertThrows(() => RegExp("\\P{OIDC}", unicode: true));
-  assertThrows(() => RegExp("\\p{Other_ID_Start}", unicode: true));
-  assertThrows(() => RegExp("\\P{OIDS}", unicode: true));
-  assertThrows(() => RegExp("\\p{Other_Lowercase}", unicode: true));
-  assertThrows(() => RegExp("\\P{OLower}", unicode: true));
-  assertThrows(() => RegExp("\\p{Other_Math}", unicode: true));
-  assertThrows(() => RegExp("\\P{OMath}", unicode: true));
-  assertThrows(() => RegExp("\\p{Other_Uppercase}", unicode: true));
-  assertThrows(() => RegExp("\\P{OUpper}", unicode: true));
-}
diff --git a/tests/corelib_2/regexp/unicode-regexp-backrefs_test.dart b/tests/corelib_2/regexp/unicode-regexp-backrefs_test.dart
deleted file mode 100644
index 2fcb7c1..0000000
--- a/tests/corelib_2/regexp/unicode-regexp-backrefs_test.dart
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-String replace(String string) {
-  return string
-      .replaceAll("L", "\ud800")
-      .replaceAll("l", "\ud801")
-      .replaceAll("T", "\udc00")
-      .replaceAll(".", "[^]");
-}
-
-void test(List<String> expectation, String regexp_source, String subject) {
-  if (expectation != null) expectation = expectation.map(replace).toList();
-  subject = replace(subject);
-  regexp_source = replace(regexp_source);
-  shouldBe(new RegExp(regexp_source, unicode: true).firstMatch(subject),
-      expectation);
-}
-
-void main() {
-  // Back reference does not end in the middle of a surrogate pair.
-  test(null, "(L)\\1", "LLT");
-  test(["LLTLl", "L", "l"], "(L).*\\1(.)", "LLTLl");
-  test(null, "(aL).*\\1", "aLaLT");
-  test(["aLaLTaLl", "aL", "l"], "(aL).*\\1(.)", "aLaLTaLl");
-
-  var s = "TabcLxLTabcLxTabcLTyTabcLz";
-  test([s, "TabcL", "z"], "([^x]+).*\\1(.)", s);
-
-  // Back reference does not start in the middle of a surrogate pair.
-  test(["TLTabTc", "T", "c"], "(T).*\\1(.)", "TLTabTc");
-
-  // Lookbehinds.
-  test(null, "(?<=\\1(T)x)", "LTTx");
-  test(["", "b", "T"], "(?<=(.)\\2.*(T)x)", "bTaLTTx");
-  test(null, "(?<=\\1.*(L)x)", "LTLx");
-  test(["", "b", "L"], "(?<=(.)\\2.*(L)x)", "bLaLTLx");
-
-  test(null, "([^x]+)x*\\1", "LxLT");
-  test(null, "([^x]+)x*\\1", "TxLT");
-  test(null, "([^x]+)x*\\1", "LTxL");
-  test(null, "([^x]+)x*\\1", "LTxT");
-  test(null, "([^x]+)x*\\1", "xLxLT");
-  test(null, "([^x]+)x*\\1", "xTxLT");
-  test(null, "([^x]+)x*\\1", "xLTxL");
-  test(null, "([^x]+)x*\\1", "xLTxT");
-  test(null, "([^x]+)x*\\1", "xxxLxxLTxx");
-  test(null, "([^x]+)x*\\1", "xxxTxxLTxx");
-  test(null, "([^x]+)x*\\1", "xxxLTxxLxx");
-  test(null, "([^x]+)x*\\1", "xxxLTxxTxx");
-  test(["LTTxxLTT", "LTT"], "([^x]+)x*\\1", "xxxLTTxxLTTxx");
-}
diff --git a/tests/corelib_2/regexp/unicode-regexp-ignore-case_test.dart b/tests/corelib_2/regexp/unicode-regexp-ignore-case_test.dart
deleted file mode 100644
index c87047c..0000000
--- a/tests/corelib_2/regexp/unicode-regexp-ignore-case_test.dart
+++ /dev/null
@@ -1,135 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  // Non-unicode use toUpperCase mappings.
-  assertFalse(RegExp(r"[\u00e5]", caseSensitive: false).hasMatch("\u212b"));
-  assertFalse(
-      RegExp(r"[\u212b]", caseSensitive: false).hasMatch("\u00e5\u1234"));
-  assertFalse(RegExp(r"[\u212b]", caseSensitive: false).hasMatch("\u00e5"));
-
-  assertTrue("\u212b".toLowerCase() == "\u00e5");
-  assertTrue("\u00c5".toLowerCase() == "\u00e5");
-  assertTrue("\u00e5".toUpperCase() == "\u00c5");
-
-  // Unicode uses case folding mappings.
-  assertTrue(RegExp(r"\u00e5", caseSensitive: false, unicode: true)
-      .hasMatch("\u212b"));
-  assertTrue(RegExp(r"\u00e5", caseSensitive: false, unicode: true)
-      .hasMatch("\u00c5"));
-  assertTrue(RegExp(r"\u00e5", caseSensitive: false, unicode: true)
-      .hasMatch("\u00e5"));
-  assertTrue(RegExp(r"\u00e5", caseSensitive: false, unicode: true)
-      .hasMatch("\u212b"));
-  assertTrue(RegExp(r"\u00c5", caseSensitive: false, unicode: true)
-      .hasMatch("\u00e5"));
-  assertTrue(RegExp(r"\u00c5", caseSensitive: false, unicode: true)
-      .hasMatch("\u212b"));
-  assertTrue(RegExp(r"\u00c5", caseSensitive: false, unicode: true)
-      .hasMatch("\u00c5"));
-  assertTrue(RegExp(r"\u212b", caseSensitive: false, unicode: true)
-      .hasMatch("\u00c5"));
-  assertTrue(RegExp(r"\u212b", caseSensitive: false, unicode: true)
-      .hasMatch("\u00e5"));
-  assertTrue(RegExp(r"\u212b", caseSensitive: false, unicode: true)
-      .hasMatch("\u212b"));
-
-  // Non-BMP.
-  assertFalse(RegExp(r"\u{10400}", caseSensitive: false).hasMatch("\u{10428}"));
-  assertTrue(RegExp(r"\u{10400}", caseSensitive: false, unicode: true)
-      .hasMatch("\u{10428}"));
-  assertTrue(RegExp(r"\ud801\udc00", caseSensitive: false, unicode: true)
-      .hasMatch("\u{10428}"));
-  assertTrue(RegExp(r"[\u{10428}]", caseSensitive: false, unicode: true)
-      .hasMatch("\u{10400}"));
-  assertTrue(RegExp(r"[\ud801\udc28]", caseSensitive: false, unicode: true)
-      .hasMatch("\u{10400}"));
-  shouldBe(
-      RegExp(r"[\uff40-\u{10428}]+", caseSensitive: false, unicode: true)
-          .firstMatch("\uff21\u{10400}abc"),
-      ["\uff21\u{10400}"]);
-  shouldBe(
-      RegExp(r"[^\uff40-\u{10428}]+", caseSensitive: false, unicode: true)
-          .firstMatch("\uff21\u{10400}abc\uff23"),
-      ["abc"]);
-  shouldBe(
-      RegExp(r"[\u24d5-\uff33]+", caseSensitive: false, unicode: true)
-          .firstMatch("\uff54\uff53\u24bb\u24ba"),
-      ["\uff53\u24bb"]);
-
-  // Full mappings are ignored.
-  assertFalse(
-      RegExp(r"\u00df", caseSensitive: false, unicode: true).hasMatch("SS"));
-  assertFalse(RegExp(r"\u1f8d", caseSensitive: false, unicode: true)
-      .hasMatch("\u1f05\u03b9"));
-
-  // Simple mappings work.
-  assertTrue(RegExp(r"\u1f8d", caseSensitive: false, unicode: true)
-      .hasMatch("\u1f85"));
-
-  // Common mappings work.
-  assertTrue(RegExp(r"\u1f6b", caseSensitive: false, unicode: true)
-      .hasMatch("\u1f63"));
-
-  // Back references.
-  shouldBe(
-      RegExp(r"(.)\1\1", caseSensitive: false, unicode: true)
-          .firstMatch("\u00e5\u212b\u00c5"),
-      ["\u00e5\u212b\u00c5", "\u00e5"]);
-  shouldBe(
-      RegExp(r"(.)\1", caseSensitive: false, unicode: true)
-          .firstMatch("\u{118aa}\u{118ca}"),
-      ["\u{118aa}\u{118ca}", "\u{118aa}"]);
-
-  // Misc.
-  assertTrue(RegExp(r"\u00e5\u00e5\u00e5", caseSensitive: false, unicode: true)
-      .hasMatch("\u212b\u00e5\u00c5"));
-  assertTrue(RegExp(r"AB\u{10400}", caseSensitive: false, unicode: true)
-      .hasMatch("ab\u{10428}"));
-
-  // Non-Latin1 maps to Latin1.
-  shouldBe(
-      RegExp(r"^\u017F", caseSensitive: false, unicode: true).firstMatch("s"),
-      ["s"]);
-  shouldBe(
-      RegExp(r"^\u017F", caseSensitive: false, unicode: true)
-          .firstMatch("s\u1234"),
-      ["s"]);
-  shouldBe(
-      RegExp(r"^a[\u017F]", caseSensitive: false, unicode: true)
-          .firstMatch("as"),
-      ["as"]);
-  shouldBe(
-      RegExp(r"^a[\u017F]", caseSensitive: false, unicode: true)
-          .firstMatch("as\u1234"),
-      ["as"]);
-}
diff --git a/tests/corelib_2/regexp/unicode-regexp-match-index_test.dart b/tests/corelib_2/regexp/unicode-regexp-match-index_test.dart
deleted file mode 100644
index 3e69658..0000000
--- a/tests/corelib_2/regexp/unicode-regexp-match-index_test.dart
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  // Testing handling of paired and non-paired surrogates in unicode mode
-  var r = new RegExp(r".", unicode: true);
-
-  var m = r.matchAsPrefix("\ud800\udc00\ud801\udc01");
-  shouldBe(m, ["\ud800\udc00"]);
-  assertEquals(m.end, 2);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 1);
-  shouldBe(m, ["\ud800\udc00"]);
-  assertEquals(m.end, 2);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 2);
-  shouldBe(m, ["\ud801\udc01"]);
-  assertEquals(m.end, 4);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 3);
-  shouldBe(m, ["\ud801\udc01"]);
-  assertEquals(m.end, 4);
-
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 4));
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\ud802", 3);
-  shouldBe(m, ["\ud802"]);
-
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\ud802", 4));
-
-  // Testing handling of paired and non-paired surrogates in non-unicode mode
-  r = new RegExp(r".");
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01");
-  shouldBe(m, ["\ud800"]);
-  assertEquals(m.end, 1);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 1);
-  shouldBe(m, ["\udc00"]);
-  assertEquals(m.end, 2);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 2);
-  shouldBe(m, ["\ud801"]);
-  assertEquals(m.end, 3);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 3);
-  shouldBe(m, ["\udc01"]);
-  assertEquals(m.end, 4);
-
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 4));
-
-  // Testing same with start anchor, unicode mode.
-  r = new RegExp("^.", unicode: true);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01");
-  shouldBe(m, ["\ud800\udc00"]);
-  assertEquals(2, m.end);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 1);
-  shouldBe(m, ["\ud800\udc00"]);
-  assertEquals(2, m.end);
-
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 2));
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 3));
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 4));
-
-  // Testing same with start anchor, non-unicode mode.
-  r = new RegExp("^.");
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01");
-  shouldBe(m, ["\ud800"]);
-  assertEquals(1, m.end);
-
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 1));
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 2));
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 3));
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 4));
-
-  // Now with both anchored and not as alternatives (with the anchored
-  // version as a captured group), unicode mode.
-  r = new RegExp(r"(?:(^.)|.)", unicode: true);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01");
-  shouldBe(m, ["\ud800\udc00", "\ud800\udc00"]);
-  assertEquals(m.end, 2);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 1);
-  shouldBe(m, ["\ud800\udc00", "\ud800\udc00"]);
-  assertEquals(m.end, 2);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 2);
-  shouldBe(m, ["\ud801\udc01", null]);
-  assertEquals(m.end, 4);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 3);
-  shouldBe(m, ["\ud801\udc01", null]);
-  assertEquals(m.end, 4);
-
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 4));
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\ud802", 3);
-  shouldBe(m, ["\ud802", null]);
-
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\ud802", 4));
-
-  // Now with both anchored and not as alternatives (with the anchored
-  // version as a captured group), non-unicode mode.
-  r = new RegExp(r"(?:(^.)|.)");
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01");
-  shouldBe(m, ["\ud800", "\ud800"]);
-  assertEquals(m.end, 1);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 1);
-  shouldBe(m, ["\udc00", null]);
-  assertEquals(m.end, 2);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 2);
-  shouldBe(m, ["\ud801", null]);
-  assertEquals(m.end, 3);
-
-  m = r.matchAsPrefix("\ud800\udc00\ud801\udc01", 3);
-  shouldBe(m, ["\udc01", null]);
-  assertEquals(m.end, 4);
-
-  assertNull(r.matchAsPrefix("\ud800\udc00\ud801\udc01", 4));
-}
diff --git a/tests/corelib_2/regexp/unicode-regexp-restricted-syntax_test.dart b/tests/corelib_2/regexp/unicode-regexp-restricted-syntax_test.dart
deleted file mode 100644
index d894c7b..0000000
--- a/tests/corelib_2/regexp/unicode-regexp-restricted-syntax_test.dart
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  // test262/data/test/language/literals/regexp/u-dec-esc
-  assertThrows(() => RegExp(r"\1", unicode: true));
-  // test262/language/literals/regexp/u-invalid-char-range-a
-  assertThrows(() => RegExp(r"[\w-a]", unicode: true));
-  // test262/language/literals/regexp/u-invalid-char-range-b
-  assertThrows(() => RegExp(r"[a-\w]", unicode: true));
-  // test262/language/literals/regexp/u-invalid-char-esc
-  assertThrows(() => RegExp(r"\c", unicode: true));
-  assertThrows(() => RegExp(r"\c0", unicode: true));
-  // test262/built-ins/RegExp/unicode_restricted_quantifiable_assertion
-  assertThrows(() => RegExp(r"(?=.)*", unicode: true));
-  assertThrows(() => RegExp(r"(?=.){1,2}", unicode: true));
-  // test262/built-ins/RegExp/unicode_restricted_octal_escape
-  assertThrows(() => RegExp(r"[\1]", unicode: true));
-  assertThrows(() => RegExp(r"\00", unicode: true));
-  assertThrows(() => RegExp(r"\09", unicode: true));
-  // test262/built-ins/RegExp/unicode_restricted_identity_escape_alpha
-  assertThrows(() => RegExp(r"[\c]", unicode: true));
-  // test262/built-ins/RegExp/unicode_restricted_identity_escape_c
-  assertThrows(() => RegExp(r"[\c0]", unicode: true));
-  // test262/built-ins/RegExp/unicode_restricted_incomple_quantifier
-  assertThrows(() => RegExp(r"a{", unicode: true));
-  assertThrows(() => RegExp(r"a{1,", unicode: true));
-  assertThrows(() => RegExp(r"{", unicode: true));
-  assertThrows(() => RegExp(r"}", unicode: true));
-  // test262/data/test/built-ins/RegExp/unicode_restricted_brackets
-  assertThrows(() => RegExp(r"]", unicode: true));
-  // test262/built-ins/RegExp/unicode_identity_escape
-  assertDoesNotThrow(() => RegExp(r"\/", unicode: true));
-
-  // escaped \0 (as NUL) is allowed inside a character class.
-  shouldBe(RegExp(r"[\0]", unicode: true).firstMatch("\u0000"), ["\u0000"]);
-  // unless it is followed by another digit.
-  assertThrows(() => RegExp(r"[\00]", unicode: true));
-  assertThrows(() => RegExp(r"[\01]", unicode: true));
-  assertThrows(() => RegExp(r"[\09]", unicode: true));
-  shouldBe(RegExp(r"[1\0a]+", unicode: true).firstMatch("b\u{0}1\u{0}a\u{0}2"),
-      ["\u{0}1\u{0}a\u{0}"]);
-  // escaped \- is allowed inside a character class.
-  shouldBe(RegExp(r"[a\-z]", unicode: true).firstMatch("12-34"), ["-"]);
-}
diff --git a/tests/corelib_2/regexp/unicode-regexp-unanchored-advance_test.dart b/tests/corelib_2/regexp/unicode-regexp-unanchored-advance_test.dart
deleted file mode 100644
index e57d810..0000000
--- a/tests/corelib_2/regexp/unicode-regexp-unanchored-advance_test.dart
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2013 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  final s = "a" * 10000000 + "\u1234";
-  shouldBe(
-      RegExp(r"(\u1234)", unicode: true).firstMatch(s), ["\u1234", "\u1234"]);
-}
diff --git a/tests/corelib_2/regexp/unicode-regexp-zero-length_test.dart b/tests/corelib_2/regexp/unicode-regexp-zero-length_test.dart
deleted file mode 100644
index 1d07628..0000000
--- a/tests/corelib_2/regexp/unicode-regexp-zero-length_test.dart
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. All rights reserved.
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-import 'package:expect/expect.dart';
-
-import 'v8_regexp_utils.dart';
-
-void main() {
-  const L = "\ud800";
-  const T = "\udc00";
-  const x = "x";
-
-  var r = RegExp(r"()"); // Not unicode.
-  // Zero-length matches do not advance lastIndex.
-  var m = r.matchAsPrefix(L + T + L + T);
-  shouldBe(m, ["", ""]);
-  assertEquals(0, m.end);
-
-  m = r.matchAsPrefix(L + T + L + T, 1);
-  shouldBe(m, ["", ""]);
-  assertEquals(1, m.end);
-
-  var u = RegExp(r"()", unicode: true);
-
-  // Zero-length matches do not advance lastIndex (but do respect paired
-  // surrogates).
-  m = u.matchAsPrefix(L + T + L + T);
-  shouldBe(m, ["", ""]);
-  assertEquals(0, m.end);
-
-  m = u.matchAsPrefix(L + T + L + T, 1);
-  shouldBe(m, ["", ""]);
-  assertEquals(0, m.end);
-
-  // However, with repeating matches, we do advance from match to match.
-  var ms = r.allMatches(L + T + L + T);
-  assertEquals(5, ms.length);
-  for (var i = 0; i < ms.length; i++) {
-    shouldBe(ms.elementAt(i), ["", ""]);
-  }
-
-  // With unicode flag, we advance code point by code point.
-  ms = u.allMatches(L + T + L + T);
-  assertEquals(3, ms.length);
-  for (var i = 0; i < ms.length; i++) {
-    shouldBe(ms.elementAt(i), ["", ""]);
-  }
-
-  // Test with a lot of copies.
-  const c = 1000;
-  ms = u.allMatches((L + T) * c);
-  assertEquals(c + 1, ms.length);
-  for (var i = 0; i < ms.length; i++) {
-    shouldBe(ms.elementAt(i), ["", ""]);
-  }
-
-  // Same with replaceAll().
-  assertEquals(
-      x + L + x + T + x + L + x + T + x, (L + T + L + T).replaceAll(r, "x"));
-
-  assertEquals(x + L + T + x + L + T + x, (L + T + L + T).replaceAll(u, "x"));
-
-  assertEquals((x + L + T) * c + x, ((L + T) * c).replaceAll(u, "x"));
-
-  // Also test String#split.
-  Expect.deepEquals(
-      ["\u{12345}"], "\u{12345}".split(RegExp(r"(?:)", unicode: true)));
-}
diff --git a/tests/corelib_2/regexp/v8_regexp_utils.dart b/tests/corelib_2/regexp/v8_regexp_utils.dart
index 111ab90..cde750a 100644
--- a/tests/corelib_2/regexp/v8_regexp_utils.dart
+++ b/tests/corelib_2/regexp/v8_regexp_utils.dart
@@ -22,10 +22,6 @@
   Expect.throws(fn, null, "Test $testid");
 }
 
-void assertDoesNotThrow(fn, [num testid = null]) {
-  fn();
-}
-
 void assertNull(actual, [num testid = null]) {
   Expect.isNull(actual, "Test $testid");
 }