[regexp] Add file-level typedefs to builtins-regexp.cc

src/builtins/builtins-regexp.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 
 #include "src/code-factory.h"
 #include "src/regexp/jsregexp.h"
 #include "src/regexp/regexp-utils.h"
 #include "src/string-builder.h"
 
 namespace v8 {
 namespace internal {
 
+typedef compiler::Node Node;
+typedef CodeStubAssembler::Label CLabel;
+typedef CodeStubAssembler::Variable CVariable;
+typedef compiler::CodeAssemblerState CodeAssemblerState;
+
 // -----------------------------------------------------------------------------
 // ES6 section 21.2 RegExp Objects
 
 namespace {
 
 Handle<String> PatternFlags(Isolate* isolate, Handle<JSRegExp> regexp) {
   static const int kMaxFlagsLength = 5 + 1;  // 5 flags and '\0';
   char flags_string[kMaxFlagsLength];
   int i = 0;
 
@@ skipping 137 matching lines @@
       isolate, regexp, RegExpInitialize(isolate, regexp, pattern, flags));
 
   // Return undefined for compatibility with JSC.
   // See http://crbug.com/585775 for web compat details.
 
   return isolate->heap()->undefined_value();
 }
 
 namespace {
 
-compiler::Node* FastLoadLastIndex(CodeStubAssembler* a, compiler::Node* context,
-                                  compiler::Node* regexp) {
+Node* FastLoadLastIndex(CodeStubAssembler* a, Node* context, Node* regexp) {
   // Load the in-object field.
   static const int field_offset =
       JSRegExp::kSize + JSRegExp::kLastIndexFieldIndex * kPointerSize;
   return a->LoadObjectField(regexp, field_offset);
 }
 
-compiler::Node* SlowLoadLastIndex(CodeStubAssembler* a, compiler::Node* context,
-                                  compiler::Node* regexp) {
+Node* SlowLoadLastIndex(CodeStubAssembler* a, Node* context, Node* regexp) {
   // Load through the GetProperty stub.
-  typedef compiler::Node Node;
-
   Node* const name =
       a->HeapConstant(a->isolate()->factory()->lastIndex_string());
   Callable getproperty_callable = CodeFactory::GetProperty(a->isolate());
   return a->CallStub(getproperty_callable, context, regexp, name);
 }
 
-compiler::Node* LoadLastIndex(CodeStubAssembler* a, compiler::Node* context,
-                              compiler::Node* has_initialmap,
-                              compiler::Node* regexp) {
-  typedef CodeStubAssembler::Variable Variable;
-  typedef CodeStubAssembler::Label Label;
+Node* LoadLastIndex(CodeStubAssembler* a, Node* context, Node* has_initialmap,
+                    Node* regexp) {
+  CVariable var_value(a, MachineRepresentation::kTagged);
 
-  Variable var_value(a, MachineRepresentation::kTagged);
-
-  Label out(a), if_unmodified(a), if_modified(a);
+  CLabel out(a), if_unmodified(a), if_modified(a);
   a->Branch(has_initialmap, &if_unmodified, &if_modified);
 
   a->Bind(&if_unmodified);
   {
     var_value.Bind(FastLoadLastIndex(a, context, regexp));
     a->Goto(&out);
   }
 
   a->Bind(&if_modified);
   {
     var_value.Bind(SlowLoadLastIndex(a, context, regexp));
     a->Goto(&out);
   }
 
   a->Bind(&out);
   return var_value.value();
 }
 
 // The fast-path of StoreLastIndex when regexp is guaranteed to be an unmodified
 // JSRegExp instance.
-void FastStoreLastIndex(CodeStubAssembler* a, compiler::Node* context,
-                        compiler::Node* regexp, compiler::Node* value) {
+void FastStoreLastIndex(CodeStubAssembler* a, Node* context, Node* regexp,
+                        Node* value) {
   // Store the in-object field.
   static const int field_offset =
       JSRegExp::kSize + JSRegExp::kLastIndexFieldIndex * kPointerSize;
   a->StoreObjectField(regexp, field_offset, value);
 }
 
-void SlowStoreLastIndex(CodeStubAssembler* a, compiler::Node* context,
-                        compiler::Node* regexp, compiler::Node* value) {
+void SlowStoreLastIndex(CodeStubAssembler* a, Node* context, Node* regexp,
+                        Node* value) {
   // Store through runtime.
   // TODO(ishell): Use SetPropertyStub here once available.
-  typedef compiler::Node Node;
-
   Node* const name =
       a->HeapConstant(a->isolate()->factory()->lastIndex_string());
   Node* const language_mode = a->SmiConstant(Smi::FromInt(STRICT));
   a->CallRuntime(Runtime::kSetProperty, context, regexp, name, value,
                  language_mode);
 }
 
-void StoreLastIndex(CodeStubAssembler* a, compiler::Node* context,
-                    compiler::Node* has_initialmap, compiler::Node* regexp,
-                    compiler::Node* value) {
-  typedef CodeStubAssembler::Label Label;
-
-  Label out(a), if_unmodified(a), if_modified(a);
+void StoreLastIndex(CodeStubAssembler* a, Node* context, Node* has_initialmap,
+                    Node* regexp, Node* value) {
+  CLabel out(a), if_unmodified(a), if_modified(a);
   a->Branch(has_initialmap, &if_unmodified, &if_modified);
 
   a->Bind(&if_unmodified);
   {
     FastStoreLastIndex(a, context, regexp, value);
     a->Goto(&out);
   }
 
   a->Bind(&if_modified);
   {
     SlowStoreLastIndex(a, context, regexp, value);
     a->Goto(&out);
   }
 
   a->Bind(&out);
 }
 
-compiler::Node* ConstructNewResultFromMatchInfo(Isolate* isolate,
-                                                CodeStubAssembler* a,
-                                                compiler::Node* context,
-                                                compiler::Node* match_info,
-                                                compiler::Node* string) {
-  typedef CodeStubAssembler::Variable Variable;
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-
-  Label out(a);
+Node* ConstructNewResultFromMatchInfo(Isolate* isolate, CodeStubAssembler* a,
+                                      Node* context, Node* match_info,
+                                      Node* string) {
+  CLabel out(a);
 
   CodeStubAssembler::ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
   Node* const num_indices = a->SmiUntag(a->LoadFixedArrayElement(
       match_info, a->IntPtrConstant(RegExpMatchInfo::kNumberOfCapturesIndex), 0,
       mode));
   Node* const num_results = a->SmiTag(a->WordShr(num_indices, 1));
   Node* const start = a->LoadFixedArrayElement(
       match_info, a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex), 0,
       mode);
   Node* const end = a->LoadFixedArrayElement(
@@ skipping 10 matching lines @@
 
   a->StoreFixedArrayElement(result_elements, a->IntPtrConstant(0), first,
                             SKIP_WRITE_BARRIER);
 
   a->GotoIf(a->SmiEqual(num_results, a->SmiConstant(Smi::FromInt(1))), &out);
 
   // Store all remaining captures.
   Node* const limit = a->IntPtrAdd(
       a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex), num_indices);
 
-  Variable var_from_cursor(a, MachineType::PointerRepresentation());
-  Variable var_to_cursor(a, MachineType::PointerRepresentation());
+  CVariable var_from_cursor(a, MachineType::PointerRepresentation());
+  CVariable var_to_cursor(a, MachineType::PointerRepresentation());
 
   var_from_cursor.Bind(
       a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 2));
   var_to_cursor.Bind(a->IntPtrConstant(1));
 
-  Variable* vars[] = {&var_from_cursor, &var_to_cursor};
-  Label loop(a, 2, vars);
+  CVariable* vars[] = {&var_from_cursor, &var_to_cursor};
+  CLabel loop(a, 2, vars);
 
   a->Goto(&loop);
   a->Bind(&loop);
   {
     Node* const from_cursor = var_from_cursor.value();
     Node* const to_cursor = var_to_cursor.value();
     Node* const start = a->LoadFixedArrayElement(match_info, from_cursor);
 
-    Label next_iter(a);
+    CLabel next_iter(a);
     a->GotoIf(a->SmiEqual(start, a->SmiConstant(Smi::FromInt(-1))), &next_iter);
 
     Node* const from_cursor_plus1 =
         a->IntPtrAdd(from_cursor, a->IntPtrConstant(1));
     Node* const end = a->LoadFixedArrayElement(match_info, from_cursor_plus1);
 
     Node* const capture = a->SubString(context, string, start, end);
     a->StoreFixedArrayElement(result_elements, to_cursor, capture);
     a->Goto(&next_iter);
 
     a->Bind(&next_iter);
     var_from_cursor.Bind(a->IntPtrAdd(from_cursor, a->IntPtrConstant(2)));
     var_to_cursor.Bind(a->IntPtrAdd(to_cursor, a->IntPtrConstant(1)));
     a->Branch(a->UintPtrLessThan(var_from_cursor.value(), limit), &loop, &out);
   }
 
   a->Bind(&out);
   return result;
 }
 
 // ES#sec-regexp.prototype.exec
 // RegExp.prototype.exec ( string )
-compiler::Node* RegExpPrototypeExecInternal(CodeStubAssembler* a,
-                                            compiler::Node* context,
-                                            compiler::Node* maybe_receiver,
-                                            compiler::Node* maybe_string) {
-  typedef CodeStubAssembler::Variable Variable;
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-
+Node* RegExpPrototypeExecInternal(CodeStubAssembler* a, Node* context,
+                                  Node* maybe_receiver, Node* maybe_string) {
   Isolate* const isolate = a->isolate();
 
   Node* const null = a->NullConstant();
   Node* const int_zero = a->IntPtrConstant(0);
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
 
-  Variable var_result(a, MachineRepresentation::kTagged);
-  Label out(a);
+  CVariable var_result(a, MachineRepresentation::kTagged);
+  CLabel out(a);
 
   // Ensure {maybe_receiver} is a JSRegExp.
   Node* const regexp_map = a->ThrowIfNotInstanceType(
       context, maybe_receiver, JS_REGEXP_TYPE, "RegExp.prototype.exec");
   Node* const regexp = maybe_receiver;
 
   // Check whether the regexp instance is unmodified.
   Node* const native_context = a->LoadNativeContext(context);
   Node* const regexp_fun =
       a->LoadContextElement(native_context, Context::REGEXP_FUNCTION_INDEX);
   Node* const initial_map =
       a->LoadObjectField(regexp_fun, JSFunction::kPrototypeOrInitialMapOffset);
   Node* const has_initialmap = a->WordEqual(regexp_map, initial_map);
 
   // Convert {maybe_string} to a string.
   Callable tostring_callable = CodeFactory::ToString(isolate);
   Node* const string = a->CallStub(tostring_callable, context, maybe_string);
   Node* const string_length = a->LoadStringLength(string);
 
   // Check whether the regexp is global or sticky, which determines whether we
   // update last index later on.
   Node* const flags = a->LoadObjectField(regexp, JSRegExp::kFlagsOffset);
   Node* const is_global_or_sticky =
       a->WordAnd(a->SmiUntag(flags),
                  a->IntPtrConstant(JSRegExp::kGlobal | JSRegExp::kSticky));
   Node* const should_update_last_index =
       a->WordNotEqual(is_global_or_sticky, int_zero);
 
   // Grab and possibly update last index.
-  Label run_exec(a);
-  Variable var_lastindex(a, MachineRepresentation::kTagged);
+  CLabel run_exec(a);
+  CVariable var_lastindex(a, MachineRepresentation::kTagged);
   {
-    Label if_doupdate(a), if_dontupdate(a);
+    CLabel if_doupdate(a), if_dontupdate(a);
     a->Branch(should_update_last_index, &if_doupdate, &if_dontupdate);
 
     a->Bind(&if_doupdate);
     {
       Node* const regexp_lastindex =
           LoadLastIndex(a, context, has_initialmap, regexp);
 
       Callable tolength_callable = CodeFactory::ToLength(isolate);
       Node* const lastindex =
           a->CallStub(tolength_callable, context, regexp_lastindex);
       var_lastindex.Bind(lastindex);
 
-      Label if_isoob(a, Label::kDeferred);
+      CLabel if_isoob(a, CLabel::kDeferred);
       a->GotoUnless(a->TaggedIsSmi(lastindex), &if_isoob);
       a->GotoUnless(a->SmiLessThanOrEqual(lastindex, string_length), &if_isoob);
       a->Goto(&run_exec);
 
       a->Bind(&if_isoob);
       {
         StoreLastIndex(a, context, has_initialmap, regexp, smi_zero);
         var_result.Bind(null);
         a->Goto(&out);
       }
     }
 
     a->Bind(&if_dontupdate);
     {
       var_lastindex.Bind(smi_zero);
       a->Goto(&run_exec);
     }
   }
 
   Node* match_indices;
-  Label successful_match(a);
+  CLabel successful_match(a);
   a->Bind(&run_exec);
   {
     // Get last match info from the context.
     Node* const last_match_info = a->LoadContextElement(
         native_context, Context::REGEXP_LAST_MATCH_INFO_INDEX);
 
     // Call the exec stub.
     Callable exec_callable = CodeFactory::RegExpExec(isolate);
     match_indices = a->CallStub(exec_callable, context, regexp, string,
                                 var_lastindex.value(), last_match_info);
 
     // {match_indices} is either null or the RegExpMatchInfo array.
     // Return early if exec failed, possibly updating last index.
     a->GotoUnless(a->WordEqual(match_indices, null), &successful_match);
 
-    Label return_null(a);
+    CLabel return_null(a);
     a->GotoUnless(should_update_last_index, &return_null);
 
     StoreLastIndex(a, context, has_initialmap, regexp, smi_zero);
     a->Goto(&return_null);
 
     a->Bind(&return_null);
     var_result.Bind(null);
     a->Goto(&out);
   }
 
-  Label construct_result(a);
+  CLabel construct_result(a);
   a->Bind(&successful_match);
   {
     a->GotoUnless(should_update_last_index, &construct_result);
 
     // Update the new last index from {match_indices}.
     Node* const new_lastindex = a->LoadFixedArrayElement(
         match_indices,
         a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 1));
 
     StoreLastIndex(a, context, has_initialmap, regexp, new_lastindex);
     a->Goto(&construct_result);
 
     a->Bind(&construct_result);
     {
       Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
                                                      match_indices, string);
       var_result.Bind(result);
       a->Goto(&out);
     }
   }
 
   a->Bind(&out);
   return var_result.value();
 }
 
 }  // namespace
 
 // ES#sec-regexp.prototype.exec
 // RegExp.prototype.exec ( string )
-void Builtins::Generate_RegExpPrototypeExec(
-    compiler::CodeAssemblerState* state) {
-  typedef compiler::Node Node;
+void Builtins::Generate_RegExpPrototypeExec(CodeAssemblerState* state) {
   CodeStubAssembler a(state);
 
   Node* const maybe_receiver = a.Parameter(0);
   Node* const maybe_string = a.Parameter(1);
   Node* const context = a.Parameter(4);
 
   Node* const result =
       RegExpPrototypeExecInternal(&a, context, maybe_receiver, maybe_string);
   a.Return(result);
 }
 
 namespace {
 
-compiler::Node* ThrowIfNotJSReceiver(CodeStubAssembler* a, Isolate* isolate,
-                                     compiler::Node* context,
-                                     compiler::Node* value,
-                                     MessageTemplate::Template msg_template,
-                                     char const* method_name) {
-  typedef compiler::Node Node;
-  typedef CodeStubAssembler::Label Label;
-  typedef CodeStubAssembler::Variable Variable;
-
-  Label out(a), throw_exception(a, Label::kDeferred);
-  Variable var_value_map(a, MachineRepresentation::kTagged);
+Node* ThrowIfNotJSReceiver(CodeStubAssembler* a, Isolate* isolate,
+                           Node* context, Node* value,
+                           MessageTemplate::Template msg_template,
+                           char const* method_name) {
+  CLabel out(a), throw_exception(a, CLabel::kDeferred);
+  CVariable var_value_map(a, MachineRepresentation::kTagged);
 
   a->GotoIf(a->TaggedIsSmi(value), &throw_exception);
 
   // Load the instance type of the {value}.
   var_value_map.Bind(a->LoadMap(value));
   Node* const value_instance_type =
       a->LoadMapInstanceType(var_value_map.value());
 
   a->Branch(a->IsJSReceiverInstanceType(value_instance_type), &out,
             &throw_exception);
@@ skipping 11 matching lines @@
     a->CallRuntime(Runtime::kThrowTypeError, context, message_id,
                    method_name_str, value_str);
     var_value_map.Bind(a->UndefinedConstant());
     a->Goto(&out);  // Never reached.
   }
 
   a->Bind(&out);
   return var_value_map.value();
 }
 
-compiler::Node* IsInitialRegExpMap(CodeStubAssembler* a,
-                                   compiler::Node* context,
-                                   compiler::Node* map) {
-  typedef compiler::Node Node;
-
+Node* IsInitialRegExpMap(CodeStubAssembler* a, Node* context, Node* map) {
   Node* const native_context = a->LoadNativeContext(context);
   Node* const regexp_fun =
       a->LoadContextElement(native_context, Context::REGEXP_FUNCTION_INDEX);
   Node* const initial_map =
       a->LoadObjectField(regexp_fun, JSFunction::kPrototypeOrInitialMapOffset);
   Node* const has_initialmap = a->WordEqual(map, initial_map);
 
   return has_initialmap;
 }
 
 // RegExp fast path implementations rely on unmodified JSRegExp instances.
 // We use a fairly coarse granularity for this and simply check whether both
 // the regexp itself is unmodified (i.e. its map has not changed) and its
 // prototype is unmodified.
-void BranchIfFastPath(CodeStubAssembler* a, compiler::Node* context,
-                      compiler::Node* map,
-                      CodeStubAssembler::Label* if_isunmodified,
-                      CodeStubAssembler::Label* if_ismodified) {
-  typedef compiler::Node Node;
-
+void BranchIfFastPath(CodeStubAssembler* a, Node* context, Node* map,
+                      CLabel* if_isunmodified, CLabel* if_ismodified) {
   Node* const native_context = a->LoadNativeContext(context);
   Node* const regexp_fun =
       a->LoadContextElement(native_context, Context::REGEXP_FUNCTION_INDEX);
   Node* const initial_map =
       a->LoadObjectField(regexp_fun, JSFunction::kPrototypeOrInitialMapOffset);
   Node* const has_initialmap = a->WordEqual(map, initial_map);
 
   a->GotoUnless(has_initialmap, if_ismodified);
 
   Node* const initial_proto_initial_map = a->LoadContextElement(
       native_context, Context::REGEXP_PROTOTYPE_MAP_INDEX);
   Node* const proto_map = a->LoadMap(a->LoadMapPrototype(map));
   Node* const proto_has_initialmap =
       a->WordEqual(proto_map, initial_proto_initial_map);
 
   // TODO(ishell): Update this check once map changes for constant field
   // tracking are landing.
 
   a->Branch(proto_has_initialmap, if_isunmodified, if_ismodified);
 }
 
 }  // namespace
 
-void Builtins::Generate_RegExpPrototypeFlagsGetter(
-    compiler::CodeAssemblerState* state) {
-  typedef CodeStubAssembler::Variable Variable;
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
+void Builtins::Generate_RegExpPrototypeFlagsGetter(CodeAssemblerState* state) {
   CodeStubAssembler a(state);
 
   Node* const receiver = a.Parameter(0);
   Node* const context = a.Parameter(3);
 
   Isolate* isolate = a.isolate();
   Node* const int_zero = a.IntPtrConstant(0);
   Node* const int_one = a.IntPtrConstant(1);
 
   Node* const map = ThrowIfNotJSReceiver(&a, isolate, context, receiver,
                                          MessageTemplate::kRegExpNonObject,
                                          "RegExp.prototype.flags");
 
-  Variable var_length(&a, MachineType::PointerRepresentation());
-  Variable var_flags(&a, MachineType::PointerRepresentation());
+  CVariable var_length(&a, MachineType::PointerRepresentation());
+  CVariable var_flags(&a, MachineType::PointerRepresentation());
 
   // First, count the number of characters we will need and check which flags
   // are set.
 
   var_length.Bind(int_zero);
 
-  Label if_isunmodifiedjsregexp(&a),
-      if_isnotunmodifiedjsregexp(&a, Label::kDeferred);
+  CLabel if_isunmodifiedjsregexp(&a),
+      if_isnotunmodifiedjsregexp(&a, CLabel::kDeferred);
   a.Branch(IsInitialRegExpMap(&a, context, map), &if_isunmodifiedjsregexp,
            &if_isnotunmodifiedjsregexp);
 
-  Label construct_string(&a);
+  CLabel construct_string(&a);
   a.Bind(&if_isunmodifiedjsregexp);
   {
     // Refer to JSRegExp's flag property on the fast-path.
     Node* const flags_smi = a.LoadObjectField(receiver, JSRegExp::kFlagsOffset);
     Node* const flags_intptr = a.SmiUntag(flags_smi);
     var_flags.Bind(flags_intptr);
 
-    Label label_global(&a), label_ignorecase(&a), label_multiline(&a),
+    CLabel label_global(&a), label_ignorecase(&a), label_multiline(&a),
         label_unicode(&a), label_sticky(&a);
 
 #define CASE_FOR_FLAG(FLAG, LABEL, NEXT_LABEL)                     \
   do {                                                             \
     a.Bind(&LABEL);                                                \
     Node* const mask = a.IntPtrConstant(FLAG);                     \
     a.GotoIf(a.WordEqual(a.WordAnd(flags_intptr, mask), int_zero), \
              &NEXT_LABEL);                                         \
     var_length.Bind(a.IntPtrAdd(var_length.value(), int_one));     \
     a.Goto(&NEXT_LABEL);                                           \
   } while (false)
 
     a.Goto(&label_global);
     CASE_FOR_FLAG(JSRegExp::kGlobal, label_global, label_ignorecase);
     CASE_FOR_FLAG(JSRegExp::kIgnoreCase, label_ignorecase, label_multiline);
     CASE_FOR_FLAG(JSRegExp::kMultiline, label_multiline, label_unicode);
     CASE_FOR_FLAG(JSRegExp::kUnicode, label_unicode, label_sticky);
     CASE_FOR_FLAG(JSRegExp::kSticky, label_sticky, construct_string);
 #undef CASE_FOR_FLAG
   }
 
   a.Bind(&if_isnotunmodifiedjsregexp);
   {
     // Fall back to GetProperty stub on the slow-path.
     var_flags.Bind(int_zero);
 
     Callable getproperty_callable = CodeFactory::GetProperty(a.isolate());
-    Label label_global(&a), label_ignorecase(&a), label_multiline(&a),
+    CLabel label_global(&a), label_ignorecase(&a), label_multiline(&a),
         label_unicode(&a), label_sticky(&a);
 
 #define CASE_FOR_FLAG(NAME, FLAG, LABEL, NEXT_LABEL)                         \
   do {                                                                       \
     a.Bind(&LABEL);                                                          \
     Node* const name =                                                       \
         a.HeapConstant(isolate->factory()->NewStringFromAsciiChecked(NAME)); \
     Node* const flag =                                                       \
         a.CallStub(getproperty_callable, context, receiver, name);           \
-    Label if_isflagset(&a);                                                  \
+    CLabel if_isflagset(&a);                                                 \
     a.BranchIfToBooleanIsTrue(flag, &if_isflagset, &NEXT_LABEL);             \
     a.Bind(&if_isflagset);                                                   \
     var_length.Bind(a.IntPtrAdd(var_length.value(), int_one));               \
     var_flags.Bind(a.WordOr(var_flags.value(), a.IntPtrConstant(FLAG)));     \
     a.Goto(&NEXT_LABEL);                                                     \
   } while (false)
 
     a.Goto(&label_global);
     CASE_FOR_FLAG("global", JSRegExp::kGlobal, label_global, label_ignorecase);
     CASE_FOR_FLAG("ignoreCase", JSRegExp::kIgnoreCase, label_ignorecase,
                   label_multiline);
     CASE_FOR_FLAG("multiline", JSRegExp::kMultiline, label_multiline,
                   label_unicode);
     CASE_FOR_FLAG("unicode", JSRegExp::kUnicode, label_unicode, label_sticky);
     CASE_FOR_FLAG("sticky", JSRegExp::kSticky, label_sticky, construct_string);
 #undef CASE_FOR_FLAG
   }
 
   // Allocate a string of the required length and fill it with the corresponding
   // char for each set flag.
 
   a.Bind(&construct_string);
   {
     Node* const result =
         a.AllocateSeqOneByteString(context, var_length.value());
     Node* const flags_intptr = var_flags.value();
 
-    Variable var_offset(&a, MachineType::PointerRepresentation());
+    CVariable var_offset(&a, MachineType::PointerRepresentation());
     var_offset.Bind(
         a.IntPtrConstant(SeqOneByteString::kHeaderSize - kHeapObjectTag));
 
-    Label label_global(&a), label_ignorecase(&a), label_multiline(&a),
+    CLabel label_global(&a), label_ignorecase(&a), label_multiline(&a),
         label_unicode(&a), label_sticky(&a), out(&a);
 
 #define CASE_FOR_FLAG(FLAG, CHAR, LABEL, NEXT_LABEL)               \
   do {                                                             \
     a.Bind(&LABEL);                                                \
     Node* const mask = a.IntPtrConstant(FLAG);                     \
     a.GotoIf(a.WordEqual(a.WordAnd(flags_intptr, mask), int_zero), \
              &NEXT_LABEL);                                         \
     Node* const value = a.IntPtrConstant(CHAR);                    \
     a.StoreNoWriteBarrier(MachineRepresentation::kWord8, result,   \
@@ skipping 76 matching lines @@
 
 // ES6 21.2.4.2.
 BUILTIN(RegExpPrototypeSpeciesGetter) {
   HandleScope scope(isolate);
   return *args.receiver();
 }
 
 namespace {
 
 // Fast-path implementation for flag checks on an unmodified JSRegExp instance.
-compiler::Node* FastFlagGetter(CodeStubAssembler* a,
-                               compiler::Node* const regexp,
-                               JSRegExp::Flag flag) {
-  typedef compiler::Node Node;
-
+Node* FastFlagGetter(CodeStubAssembler* a, Node* const regexp,
+                     JSRegExp::Flag flag) {
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
   Node* const flags = a->LoadObjectField(regexp, JSRegExp::kFlagsOffset);
   Node* const mask = a->SmiConstant(Smi::FromInt(flag));
   Node* const is_flag_set = a->WordNotEqual(a->WordAnd(flags, mask), smi_zero);
 
   return is_flag_set;
 }
 
 void Generate_FlagGetter(CodeStubAssembler* a, JSRegExp::Flag flag,
                          v8::Isolate::UseCounterFeature counter,
                          const char* method_name) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-
   Node* const receiver = a->Parameter(0);
   Node* const context = a->Parameter(3);
 
   Isolate* isolate = a->isolate();
 
   // Check whether we have an unmodified regexp instance.
-  Label if_isunmodifiedjsregexp(a),
-      if_isnotunmodifiedjsregexp(a, Label::kDeferred);
+  CLabel if_isunmodifiedjsregexp(a),
+      if_isnotunmodifiedjsregexp(a, CLabel::kDeferred);
 
   a->GotoIf(a->TaggedIsSmi(receiver), &if_isnotunmodifiedjsregexp);
 
   Node* const receiver_map = a->LoadMap(receiver);
   Node* const instance_type = a->LoadMapInstanceType(receiver_map);
 
   a->Branch(a->Word32Equal(instance_type, a->Int32Constant(JS_REGEXP_TYPE)),
             &if_isunmodifiedjsregexp, &if_isnotunmodifiedjsregexp);
 
   a->Bind(&if_isunmodifiedjsregexp);
   {
     // Refer to JSRegExp's flag property on the fast-path.
     Node* const is_flag_set = FastFlagGetter(a, receiver, flag);
     a->Return(a->Select(is_flag_set, a->TrueConstant(), a->FalseConstant()));
   }
 
   a->Bind(&if_isnotunmodifiedjsregexp);
   {
     Node* const native_context = a->LoadNativeContext(context);
     Node* const regexp_fun =
         a->LoadContextElement(native_context, Context::REGEXP_FUNCTION_INDEX);
     Node* const initial_map = a->LoadObjectField(
         regexp_fun, JSFunction::kPrototypeOrInitialMapOffset);
     Node* const initial_prototype = a->LoadMapPrototype(initial_map);
 
-    Label if_isprototype(a), if_isnotprototype(a);
+    CLabel if_isprototype(a), if_isnotprototype(a);
     a->Branch(a->WordEqual(receiver, initial_prototype), &if_isprototype,
               &if_isnotprototype);
 
     a->Bind(&if_isprototype);
     {
       Node* const counter_smi = a->SmiConstant(Smi::FromInt(counter));
       a->CallRuntime(Runtime::kIncrementUseCounter, context, counter_smi);
       a->Return(a->UndefinedConstant());
     }
 
     a->Bind(&if_isnotprototype);
     {
       Node* const message_id =
           a->SmiConstant(Smi::FromInt(MessageTemplate::kRegExpNonRegExp));
       Node* const method_name_str = a->HeapConstant(
           isolate->factory()->NewStringFromAsciiChecked(method_name));
       a->CallRuntime(Runtime::kThrowTypeError, context, message_id,
                      method_name_str);
       a->Return(a->UndefinedConstant());  // Never reached.
     }
   }
 }
 
 }  // namespace
 
 // ES6 21.2.5.4.
-void Builtins::Generate_RegExpPrototypeGlobalGetter(
-    compiler::CodeAssemblerState* state) {
+void Builtins::Generate_RegExpPrototypeGlobalGetter(CodeAssemblerState* state) {
   CodeStubAssembler a(state);
   Generate_FlagGetter(&a, JSRegExp::kGlobal,
                       v8::Isolate::kRegExpPrototypeOldFlagGetter,
                       "RegExp.prototype.global");
 }
 
 // ES6 21.2.5.5.
 void Builtins::Generate_RegExpPrototypeIgnoreCaseGetter(
-    compiler::CodeAssemblerState* state) {
+    CodeAssemblerState* state) {
   CodeStubAssembler a(state);
   Generate_FlagGetter(&a, JSRegExp::kIgnoreCase,
                       v8::Isolate::kRegExpPrototypeOldFlagGetter,
                       "RegExp.prototype.ignoreCase");
 }
 
 // ES6 21.2.5.7.
 void Builtins::Generate_RegExpPrototypeMultilineGetter(
-    compiler::CodeAssemblerState* state) {
+    CodeAssemblerState* state) {
   CodeStubAssembler a(state);
   Generate_FlagGetter(&a, JSRegExp::kMultiline,
                       v8::Isolate::kRegExpPrototypeOldFlagGetter,
                       "RegExp.prototype.multiline");
 }
 
 // ES6 21.2.5.12.
-void Builtins::Generate_RegExpPrototypeStickyGetter(
-    compiler::CodeAssemblerState* state) {
+void Builtins::Generate_RegExpPrototypeStickyGetter(CodeAssemblerState* state) {
   CodeStubAssembler a(state);
   Generate_FlagGetter(&a, JSRegExp::kSticky,
                       v8::Isolate::kRegExpPrototypeStickyGetter,
                       "RegExp.prototype.sticky");
 }
 
 // ES6 21.2.5.15.
 void Builtins::Generate_RegExpPrototypeUnicodeGetter(
-    compiler::CodeAssemblerState* state) {
+    CodeAssemblerState* state) {
   CodeStubAssembler a(state);
   Generate_FlagGetter(&a, JSRegExp::kUnicode,
                       v8::Isolate::kRegExpPrototypeUnicodeGetter,
                       "RegExp.prototype.unicode");
 }
 
 // The properties $1..$9 are the first nine capturing substrings of the last
 // successful match, or ''.  The function RegExpMakeCaptureGetter will be
 // called with indices from 1 to 9.
 #define DEFINE_CAPTURE_GETTER(i)                        \
@@ skipping 72 matching lines @@
   Handle<RegExpMatchInfo> match_info = isolate->regexp_last_match_info();
   const int start_index = match_info->Capture(1);
   Handle<String> last_subject(match_info->LastSubject());
   const int len = last_subject->length();
   return *isolate->factory()->NewSubString(last_subject, start_index, len);
 }
 
 namespace {
 
 // ES#sec-regexpexec Runtime Semantics: RegExpExec ( R, S )
-compiler::Node* RegExpExec(CodeStubAssembler* a, compiler::Node* context,
-                           compiler::Node* recv, compiler::Node* string) {
-  typedef CodeStubAssembler::Variable Variable;
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-
+Node* RegExpExec(CodeStubAssembler* a, Node* context, Node* recv,
+                 Node* string) {
   Isolate* isolate = a->isolate();
 
   Node* const null = a->NullConstant();
 
-  Variable var_result(a, MachineRepresentation::kTagged);
-  Label out(a), call_builtin_exec(a), slow_path(a, Label::kDeferred);
+  CVariable var_result(a, MachineRepresentation::kTagged);
+  CLabel out(a), call_builtin_exec(a), slow_path(a, CLabel::kDeferred);
 
   Node* const map = a->LoadMap(recv);
   BranchIfFastPath(a, context, map, &call_builtin_exec, &slow_path);
 
   a->Bind(&call_builtin_exec);
   {
     Node* const result = RegExpPrototypeExecInternal(a, context, recv, string);
     var_result.Bind(result);
     a->Goto(&out);
   }
 
   a->Bind(&slow_path);
   {
     // Take the slow path of fetching the exec property, calling it, and
     // verifying its return value.
 
     // Get the exec property.
     Node* const name = a->HeapConstant(isolate->factory()->exec_string());
     Callable getproperty_callable = CodeFactory::GetProperty(a->isolate());
     Node* const exec = a->CallStub(getproperty_callable, context, recv, name);
 
     // Is {exec} callable?
-    Label if_iscallable(a), if_isnotcallable(a);
+    CLabel if_iscallable(a), if_isnotcallable(a);
 
     a->GotoIf(a->TaggedIsSmi(exec), &if_isnotcallable);
 
     Node* const exec_map = a->LoadMap(exec);
     a->Branch(a->IsCallableMap(exec_map), &if_iscallable, &if_isnotcallable);
 
     a->Bind(&if_iscallable);
     {
       Callable call_callable = CodeFactory::Call(isolate);
       Node* const result =
@@ skipping 17 matching lines @@
   }
 
   a->Bind(&out);
   return var_result.value();
 }
 
 }  // namespace
 
 // ES#sec-regexp.prototype.test
 // RegExp.prototype.test ( S )
-void Builtins::Generate_RegExpPrototypeTest(
-    compiler::CodeAssemblerState* state) {
-  typedef compiler::Node Node;
+void Builtins::Generate_RegExpPrototypeTest(CodeAssemblerState* state) {
   CodeStubAssembler a(state);
 
   Isolate* const isolate = a.isolate();
 
   Node* const maybe_receiver = a.Parameter(0);
   Node* const maybe_string = a.Parameter(1);
   Node* const context = a.Parameter(4);
 
   // Ensure {maybe_receiver} is a JSReceiver.
   ThrowIfNotJSReceiver(&a, isolate, context, maybe_receiver,
@@ skipping 80 matching lines @@
     }
   }
 
   elems->Shrink(n);
   return *isolate->factory()->NewJSArrayWithElements(elems);
 }
 
 namespace {
 
 void Generate_RegExpPrototypeSearchBody(CodeStubAssembler* a,
-                                        compiler::Node* const receiver,
-                                        compiler::Node* const string,
-                                        compiler::Node* const context,
+                                        Node* const receiver,
+                                        Node* const string, Node* const context,
                                         bool is_fastpath) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-
   Isolate* const isolate = a->isolate();
 
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
 
   // Grab the initial value of last index.
   Node* const previous_last_index =
       is_fastpath ? FastLoadLastIndex(a, context, receiver)
                   : SlowLoadLastIndex(a, context, receiver);
 
   // Ensure last index is 0.
   if (is_fastpath) {
     FastStoreLastIndex(a, context, receiver, smi_zero);
   } else {
-    Label next(a);
+    CLabel next(a);
     a->GotoIf(a->SameValue(previous_last_index, smi_zero, context), &next);
 
     SlowStoreLastIndex(a, context, receiver, smi_zero);
     a->Goto(&next);
     a->Bind(&next);
   }
 
   // Call exec.
   Node* const match_indices =
       is_fastpath ? RegExpPrototypeExecInternal(a, context, receiver, string)
                   : RegExpExec(a, context, receiver, string);
 
   // Reset last index if necessary.
   if (is_fastpath) {
     FastStoreLastIndex(a, context, receiver, previous_last_index);
   } else {
-    Label next(a);
+    CLabel next(a);
     Node* const current_last_index = SlowLoadLastIndex(a, context, receiver);
 
     a->GotoIf(a->SameValue(current_last_index, previous_last_index, context),
               &next);
 
     SlowStoreLastIndex(a, context, receiver, previous_last_index);
     a->Goto(&next);
     a->Bind(&next);
   }
 
   // Return -1 if no match was found.
   {
-    Label next(a);
+    CLabel next(a);
     a->GotoUnless(a->WordEqual(match_indices, a->NullConstant()), &next);
     a->Return(a->SmiConstant(-1));
     a->Bind(&next);
   }
 
   // Return the index of the match.
   {
-    Label fast_result(a), slow_result(a, Label::kDeferred);
+    CLabel fast_result(a), slow_result(a, CLabel::kDeferred);
 
     Node* const native_context = a->LoadNativeContext(context);
     Node* const initial_regexp_result_map =
         a->LoadContextElement(native_context, Context::REGEXP_RESULT_MAP_INDEX);
     Node* const match_indices_map = a->LoadMap(match_indices);
 
     a->Branch(a->WordEqual(match_indices_map, initial_regexp_result_map),
               &fast_result, &slow_result);
 
     a->Bind(&fast_result);
@@ skipping 12 matching lines @@
           a->CallStub(getproperty_callable, context, match_indices, name);
       a->Return(index);
     }
   }
 }
 
 }  // namespace
 
 // ES#sec-regexp.prototype-@@search
 // RegExp.prototype [ @@search ] ( string )
-void Builtins::Generate_RegExpPrototypeSearch(
-    compiler::CodeAssemblerState* state) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
+void Builtins::Generate_RegExpPrototypeSearch(CodeAssemblerState* state) {
   CodeStubAssembler a(state);
 
   Isolate* const isolate = a.isolate();
 
   Node* const maybe_receiver = a.Parameter(0);
   Node* const maybe_string = a.Parameter(1);
   Node* const context = a.Parameter(4);
 
   // Ensure {maybe_receiver} is a JSReceiver.
   Node* const map =
       ThrowIfNotJSReceiver(&a, isolate, context, maybe_receiver,
                            MessageTemplate::kIncompatibleMethodReceiver,
                            "RegExp.prototype.@@search");
   Node* const receiver = maybe_receiver;
 
   // Convert {maybe_string} to a String.
   Node* const string = a.ToString(context, maybe_string);
 
-  Label fast_path(&a), slow_path(&a);
+  CLabel fast_path(&a), slow_path(&a);
   BranchIfFastPath(&a, context, map, &fast_path, &slow_path);
 
   a.Bind(&fast_path);
   Generate_RegExpPrototypeSearchBody(&a, receiver, string, context, true);
 
   a.Bind(&slow_path);
   Generate_RegExpPrototypeSearchBody(&a, receiver, string, context, false);
 }
 
 namespace {
@@ skipping 335 matching lines @@
     Handle<String> substr =
         factory->NewSubString(string, prev_string_index, length);
     elems = FixedArray::SetAndGrow(elems, num_elems++, substr);
   }
 
   return *NewJSArrayWithElements(isolate, elems, num_elems);
 }
 
 namespace {
 
-compiler::Node* ReplaceGlobalCallableFastPath(
-    CodeStubAssembler* a, compiler::Node* context, compiler::Node* regexp,
-    compiler::Node* subject_string, compiler::Node* replace_callable) {
+Node* ReplaceGlobalCallableFastPath(CodeStubAssembler* a, Node* context,
+                                    Node* regexp, Node* subject_string,
+                                    Node* replace_callable) {
   // The fast path is reached only if {receiver} is a global unmodified
   // JSRegExp instance and {replace_callable} is callable.
 
-  typedef CodeStubAssembler::Variable Variable;
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-
   Isolate* const isolate = a->isolate();
 
   Node* const null = a->NullConstant();
   Node* const undefined = a->UndefinedConstant();
   Node* const int_zero = a->IntPtrConstant(0);
   Node* const int_one = a->IntPtrConstant(1);
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
 
   Node* const native_context = a->LoadNativeContext(context);
 
-  Label out(a);
-  Variable var_result(a, MachineRepresentation::kTagged);
+  CLabel out(a);
+  CVariable var_result(a, MachineRepresentation::kTagged);
 
   // Set last index to 0.
   FastStoreLastIndex(a, context, regexp, smi_zero);
 
   // Allocate {result_array}.
   Node* result_array;
   {
     ElementsKind kind = FAST_ELEMENTS;
     Node* const array_map = a->LoadJSArrayElementsMap(kind, native_context);
     Node* const capacity = a->IntPtrConstant(16);
@@ skipping 26 matching lines @@
 
   Node* const res_length = a->LoadJSArrayLength(res);
   Node* const res_elems = a->LoadElements(res);
   CSA_ASSERT(a, a->HasInstanceType(res_elems, FIXED_ARRAY_TYPE));
 
   CodeStubAssembler::ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
   Node* const num_capture_registers = a->LoadFixedArrayElement(
       last_match_info,
       a->IntPtrConstant(RegExpMatchInfo::kNumberOfCapturesIndex), 0, mode);
 
-  Label if_hasexplicitcaptures(a), if_noexplicitcaptures(a), create_result(a);
+  CLabel if_hasexplicitcaptures(a), if_noexplicitcaptures(a), create_result(a);
   a->Branch(a->SmiEqual(num_capture_registers, a->SmiConstant(Smi::FromInt(2))),
             &if_noexplicitcaptures, &if_hasexplicitcaptures);
 
   a->Bind(&if_noexplicitcaptures);
   {
     // If the number of captures is two then there are no explicit captures in
     // the regexp, just the implicit capture that captures the whole match. In
     // this case we can simplify quite a bit and end up with something faster.
     // The builder will consist of some integers that indicate slices of the
     // input string and some replacements that were returned from the replace
     // function.
 
-    Variable var_match_start(a, MachineRepresentation::kTagged);
+    CVariable var_match_start(a, MachineRepresentation::kTagged);
     var_match_start.Bind(smi_zero);
 
     Node* const end = a->SmiUntag(res_length);
-    Variable var_i(a, MachineType::PointerRepresentation());
+    CVariable var_i(a, MachineType::PointerRepresentation());
     var_i.Bind(int_zero);
 
-    Variable* vars[] = {&var_i, &var_match_start};
-    Label loop(a, 2, vars);
+    CVariable* vars[] = {&var_i, &var_match_start};
+    CLabel loop(a, 2, vars);
     a->Goto(&loop);
     a->Bind(&loop);
     {
       Node* const i = var_i.value();
       a->GotoUnless(a->IntPtrLessThan(i, end), &create_result);
 
       CodeStubAssembler::ParameterMode mode =
           CodeStubAssembler::INTPTR_PARAMETERS;
       Node* const elem = a->LoadFixedArrayElement(res_elems, i, 0, mode);
 
-      Label if_issmi(a), if_isstring(a), loop_epilogue(a);
+      CLabel if_issmi(a), if_isstring(a), loop_epilogue(a);
       a->Branch(a->TaggedIsSmi(elem), &if_issmi, &if_isstring);
 
       a->Bind(&if_issmi);
       {
         // Integers represent slices of the original string.
-        Label if_isnegativeorzero(a), if_ispositive(a);
+        CLabel if_isnegativeorzero(a), if_ispositive(a);
         a->BranchIfSmiLessThanOrEqual(elem, smi_zero, &if_isnegativeorzero,
                                       &if_ispositive);
 
         a->Bind(&if_ispositive);
         {
           Node* const int_elem = a->SmiUntag(elem);
           Node* const new_match_start =
               a->IntPtrAdd(a->WordShr(int_elem, a->IntPtrConstant(11)),
                            a->WordAnd(int_elem, a->IntPtrConstant(0x7ff)));
           var_match_start.Bind(a->SmiTag(new_match_start));
@@ skipping 51 matching lines @@
     Node* const to = a->SmiUntag(res_length);
     const int increment = 1;
 
     a->BuildFastLoop(
         MachineType::PointerRepresentation(), from, to,
         [res_elems, isolate, native_context, context, undefined,
          replace_callable, mode](CodeStubAssembler* a, Node* index) {
           Node* const elem =
               a->LoadFixedArrayElement(res_elems, index, 0, mode);
 
-          Label do_continue(a);
+          CLabel do_continue(a);
           a->GotoIf(a->TaggedIsSmi(elem), &do_continue);
 
           // elem must be an Array.
           // Use the apply argument as backing for global RegExp properties.
 
           CSA_ASSERT(a, a->HasInstanceType(elem, JS_ARRAY_TYPE));
 
           // TODO(jgruber): Remove indirection through Call->ReflectApply.
           Callable call_callable = CodeFactory::Call(isolate);
           Node* const reflect_apply = a->LoadContextElement(
@@ skipping 23 matching lines @@
     Node* const result = a->CallRuntime(Runtime::kStringBuilderConcat, context,
                                         res, res_length, subject_string);
     var_result.Bind(result);
     a->Goto(&out);
   }
 
   a->Bind(&out);
   return var_result.value();
 }
 
-compiler::Node* ReplaceSimpleStringFastPath(CodeStubAssembler* a,
-                                            compiler::Node* context,
-                                            compiler::Node* regexp,
-                                            compiler::Node* subject_string,
-                                            compiler::Node* replace_string) {
+Node* ReplaceSimpleStringFastPath(CodeStubAssembler* a, Node* context,
+                                  Node* regexp, Node* subject_string,
+                                  Node* replace_string) {
   // The fast path is reached only if {receiver} is an unmodified
   // JSRegExp instance, {replace_value} is non-callable, and
   // ToString({replace_value}) does not contain '$', i.e. we're doing a simple
   // string replacement.
 
-  typedef CodeStubAssembler::Variable Variable;
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
-
   Isolate* const isolate = a->isolate();
 
   Node* const null = a->NullConstant();
   Node* const int_zero = a->IntPtrConstant(0);
   Node* const smi_zero = a->SmiConstant(Smi::kZero);
 
-  Label out(a);
-  Variable var_result(a, MachineRepresentation::kTagged);
+  CLabel out(a);
+  CVariable var_result(a, MachineRepresentation::kTagged);
 
   // Load the last match info.
   Node* const native_context = a->LoadNativeContext(context);
   Node* const last_match_info = a->LoadContextElement(
       native_context, Context::REGEXP_LAST_MATCH_INFO_INDEX);
 
   // Is {regexp} global?
-  Label if_isglobal(a), if_isnonglobal(a);
+  CLabel if_isglobal(a), if_isnonglobal(a);
   Node* const flags = a->LoadObjectField(regexp, JSRegExp::kFlagsOffset);
   Node* const is_global =
       a->WordAnd(a->SmiUntag(flags), a->IntPtrConstant(JSRegExp::kGlobal));
   a->Branch(a->WordEqual(is_global, int_zero), &if_isnonglobal, &if_isglobal);
 
   a->Bind(&if_isglobal);
   {
     // Hand off global regexps to runtime.
     FastStoreLastIndex(a, context, regexp, smi_zero);
     Node* const result =
         a->CallRuntime(Runtime::kStringReplaceGlobalRegExpWithString, context,
                        subject_string, regexp, replace_string, last_match_info);
     var_result.Bind(result);
     a->Goto(&out);
   }
 
   a->Bind(&if_isnonglobal);
   {
     // Run exec, then manually construct the resulting string.
     Callable exec_callable = CodeFactory::RegExpExec(isolate);
     Node* const match_indices =
         a->CallStub(exec_callable, context, regexp, subject_string, smi_zero,
                     last_match_info);
 
-    Label if_matched(a), if_didnotmatch(a);
+    CLabel if_matched(a), if_didnotmatch(a);
     a->Branch(a->WordEqual(match_indices, null), &if_didnotmatch, &if_matched);
 
     a->Bind(&if_didnotmatch);
     {
       FastStoreLastIndex(a, context, regexp, smi_zero);
       var_result.Bind(subject_string);
       a->Goto(&out);
     }
 
     a->Bind(&if_matched);
     {
       CodeStubAssembler::ParameterMode mode =
           CodeStubAssembler::INTPTR_PARAMETERS;
 
       Node* const subject_start = smi_zero;
       Node* const match_start = a->LoadFixedArrayElement(
           match_indices, a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex),
           0, mode);
       Node* const match_end = a->LoadFixedArrayElement(
           match_indices,
           a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 1), 0, mode);
       Node* const subject_end = a->LoadStringLength(subject_string);
 
-      Label if_replaceisempty(a), if_replaceisnotempty(a);
+      CLabel if_replaceisempty(a), if_replaceisnotempty(a);
       Node* const replace_length = a->LoadStringLength(replace_string);
       a->Branch(a->SmiEqual(replace_length, smi_zero), &if_replaceisempty,
                 &if_replaceisnotempty);
 
       a->Bind(&if_replaceisempty);
       {
         // TODO(jgruber): We could skip many of the checks that using SubString
         // here entails.
 
         Node* const first_part =
@@ skipping 24 matching lines @@
   }
 
   a->Bind(&out);
   return var_result.value();
 }
 
 }  // namespace
 
 // ES#sec-regexp.prototype-@@replace
 // RegExp.prototype [ @@replace ] ( string, replaceValue )
-void Builtins::Generate_RegExpPrototypeReplace(
-    compiler::CodeAssemblerState* state) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
+void Builtins::Generate_RegExpPrototypeReplace(CodeAssemblerState* state) {
   CodeStubAssembler a(state);
 
   Isolate* const isolate = a.isolate();
 
   Node* const maybe_receiver = a.Parameter(0);
   Node* const maybe_string = a.Parameter(1);
   Node* const replace_value = a.Parameter(2);
   Node* const context = a.Parameter(5);
 
   Node* const int_zero = a.IntPtrConstant(0);
 
   // Ensure {maybe_receiver} is a JSReceiver.
   Node* const map =
       ThrowIfNotJSReceiver(&a, isolate, context, maybe_receiver,
                            MessageTemplate::kIncompatibleMethodReceiver,
                            "RegExp.prototype.@@replace");
   Node* const receiver = maybe_receiver;
 
   // Convert {maybe_string} to a String.
   Callable tostring_callable = CodeFactory::ToString(isolate);
   Node* const string = a.CallStub(tostring_callable, context, maybe_string);
 
   // Fast-path checks: 1. Is the {receiver} an unmodified JSRegExp instance?
-  Label checkreplacecallable(&a), runtime(&a, Label::kDeferred), fastpath(&a);
+  CLabel checkreplacecallable(&a), runtime(&a, CLabel::kDeferred), fastpath(&a);
   BranchIfFastPath(&a, context, map, &checkreplacecallable, &runtime);
 
   a.Bind(&checkreplacecallable);
   Node* const regexp = receiver;
 
   // 2. Is {replace_value} callable?
-  Label checkreplacestring(&a), if_iscallable(&a);
+  CLabel checkreplacestring(&a), if_iscallable(&a);
   a.GotoIf(a.TaggedIsSmi(replace_value), &checkreplacestring);
 
   Node* const replace_value_map = a.LoadMap(replace_value);
   a.Branch(a.IsCallableMap(replace_value_map), &if_iscallable,
            &checkreplacestring);
 
   // 3. Does ToString({replace_value}) contain '$'?
   a.Bind(&checkreplacestring);
   {
     Node* const replace_string =
         a.CallStub(tostring_callable, context, replace_value);
 
     Node* const dollar_char = a.IntPtrConstant('$');
     Node* const smi_minusone = a.SmiConstant(Smi::FromInt(-1));
     a.GotoUnless(a.SmiEqual(a.StringIndexOfChar(context, replace_string,
                                                 dollar_char, int_zero),
                             smi_minusone),
                  &runtime);
 
     a.Return(ReplaceSimpleStringFastPath(&a, context, regexp, string,
                                          replace_string));
   }
 
   // {regexp} is unmodified and {replace_value} is callable.
   a.Bind(&if_iscallable);
   {
     Node* const replace_callable = replace_value;
 
     // Check if the {regexp} is global.
-    Label if_isglobal(&a), if_isnotglobal(&a);
+    CLabel if_isglobal(&a), if_isnotglobal(&a);
     Node* const is_global = FastFlagGetter(&a, regexp, JSRegExp::kGlobal);
     a.Branch(is_global, &if_isglobal, &if_isnotglobal);
 
     a.Bind(&if_isglobal);
     {
       Node* const result = ReplaceGlobalCallableFastPath(
           &a, context, regexp, string, replace_callable);
       a.Return(result);
     }
 
     a.Bind(&if_isnotglobal);
     {
       Node* const result =
           a.CallRuntime(Runtime::kStringReplaceNonGlobalRegExpWithFunction,
                         context, string, regexp, replace_callable);
       a.Return(result);
     }
   }
 
   a.Bind(&runtime);
   {
     Node* const result = a.CallRuntime(Runtime::kRegExpReplace, context,
                                        receiver, string, replace_value);
     a.Return(result);
   }
 }
 
 // Simple string matching functionality for internal use which does not modify
 // the last match info.
-void Builtins::Generate_RegExpInternalMatch(
-    compiler::CodeAssemblerState* state) {
-  typedef CodeStubAssembler::Label Label;
-  typedef compiler::Node Node;
+void Builtins::Generate_RegExpInternalMatch(CodeAssemblerState* state) {
   CodeStubAssembler a(state);
 
   Isolate* const isolate = a.isolate();
 
   Node* const regexp = a.Parameter(1);
   Node* const string = a.Parameter(2);
   Node* const context = a.Parameter(5);
 
   Node* const null = a.NullConstant();
   Node* const smi_zero = a.SmiConstant(Smi::FromInt(0));
 
   Node* const native_context = a.LoadNativeContext(context);
   Node* const internal_match_info = a.LoadContextElement(
       native_context, Context::REGEXP_INTERNAL_MATCH_INFO_INDEX);
 
   Callable exec_callable = CodeFactory::RegExpExec(isolate);
   Node* const match_indices = a.CallStub(exec_callable, context, regexp, string,
                                          smi_zero, internal_match_info);
 
-  Label if_matched(&a), if_didnotmatch(&a);
+  CLabel if_matched(&a), if_didnotmatch(&a);
   a.Branch(a.WordEqual(match_indices, null), &if_didnotmatch, &if_matched);
 
   a.Bind(&if_didnotmatch);
   a.Return(null);
 
   a.Bind(&if_matched);
   {
     Node* result = ConstructNewResultFromMatchInfo(isolate, &a, context,
                                                    match_indices, string);
     a.Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8