Simpler regex names:

runtime/vm/regexp.cc

 // Copyright (c) 2014, 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.
 
 #include "vm/regexp.h"
 
 #include "vm/dart_entry.h"
 #include "vm/regexp_assembler.h"
 #include "vm/regexp_assembler_bytecode.h"
 #include "vm/regexp_assembler_ir.h"
@@ skipping 5000 matching lines @@
     RegExpCompileData* data,
     const ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array) {
   ASSERT(!FLAG_interpret_irregexp);
   Zone* zone = Thread::Current()->zone();
 
   const Function& function = parsed_function->function();
   const intptr_t specialization_cid = function.string_specialization_cid();
   const bool is_one_byte = (specialization_cid == kOneByteStringCid ||
                             specialization_cid == kExternalOneByteStringCid);
-  JSRegExp& regexp = JSRegExp::Handle(zone, function.regexp());
+  RegExp& regexp = RegExp::Handle(zone, function.regexp());
   const String& pattern = String::Handle(zone, regexp.pattern());
 
   ASSERT(!regexp.IsNull());
   ASSERT(!pattern.IsNull());
 
   const bool ignore_case = regexp.is_ignore_case();
   const bool is_global = regexp.is_global();
 
   RegExpCompiler compiler(data->capture_count, ignore_case, is_one_byte);
 
@@ skipping 93 matching lines @@
   if (FLAG_trace_irregexp) {
     macro_assembler->PrintBlocks();
   }
 
   return result;
 }
 
 
 RegExpEngine::CompilationResult RegExpEngine::CompileBytecode(
     RegExpCompileData* data,
-    const JSRegExp& regexp,
+    const RegExp& regexp,
     bool is_one_byte,
     Zone* zone) {
   ASSERT(FLAG_interpret_irregexp);
   const String& pattern = String::Handle(zone, regexp.pattern());
 
   ASSERT(!regexp.IsNull());
   ASSERT(!pattern.IsNull());
 
   const bool ignore_case = regexp.is_ignore_case();
   const bool is_global = regexp.is_global();
@@ skipping 92 matching lines @@
 
   if (FLAG_trace_irregexp) {
     macro_assembler->PrintBlocks();
   }
 
   return result;
 }
 
 
 static void CreateSpecializedFunction(Zone* zone,
-                                      const JSRegExp& regexp,
+                                      const RegExp& regexp,
                                       intptr_t specialization_cid,
                                       const Object& owner) {
   const intptr_t kParamCount = RegExpMacroAssembler::kParamCount;
 
   Function& fn = Function::Handle(zone, Function::New(
       // Append the regexp pattern to the function name.
       String::Handle(zone, Symbols::New(
           String::Handle(zone, String::Concat(
               String::Handle(zone, String::Concat(
-                  Symbols::Irregexp(),
+                  Symbols::ColonMatcher(),
                   Symbols::ColonSpace(), Heap::kOld)),
               String::Handle(regexp.pattern()), Heap::kOld)))),
       RawFunction::kIrregexpFunction,
       true,  // Static.
       false,  // Not const.
       false,  // Not abstract.
       false,  // Not external.
       false,  // Not native.
       owner,
       TokenPosition::kMinSource));
@@ skipping 21 matching lines @@
   // Cache the result.
   regexp.set_function(specialization_cid, fn);
 
   fn.SetRegExpData(regexp, specialization_cid);
   fn.set_is_debuggable(false);
 
   // The function is compiled lazily during the first call.
 }
 
 
-RawJSRegExp* RegExpEngine::CreateJSRegExp(Zone* zone,
+RawRegExp* RegExpEngine::CreateRegExp(Zone* zone,
                                           const String& pattern,
                                           bool multi_line,
                                           bool ignore_case) {
-  const JSRegExp& regexp = JSRegExp::Handle(JSRegExp::New());
+  const RegExp& regexp = RegExp::Handle(RegExp::New());
 
   regexp.set_pattern(pattern);
 
   if (multi_line) {
     regexp.set_is_multi_line();
   }
   if (ignore_case) {
     regexp.set_is_ignore_case();
   }
 
@@ skipping 11 matching lines @@
     CreateSpecializedFunction(zone, regexp, kTwoByteStringCid, owner);
     CreateSpecializedFunction(zone, regexp, kExternalOneByteStringCid, owner);
     CreateSpecializedFunction(zone, regexp, kExternalTwoByteStringCid, owner);
   }
 
   return regexp.raw();
 }
 
 
 }  // namespace dart