[regexp] Mark functions MUST_USE_RESULT

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"
@@ skipping 21 matching lines @@
   if ((flags & JSRegExp::kSticky) != 0) flags_string[i++] = 'y';
 
   DCHECK_LT(i, kMaxFlagsLength);
   memset(&flags_string[i], '\0', kMaxFlagsLength - i);
 
   return isolate->factory()->NewStringFromAsciiChecked(flags_string);
 }
 
 // ES#sec-regexpinitialize
 // Runtime Semantics: RegExpInitialize ( obj, pattern, flags )
-MaybeHandle<JSRegExp> RegExpInitialize(Isolate* isolate,
-                                       Handle<JSRegExp> regexp,
-                                       Handle<Object> pattern,
-                                       Handle<Object> flags) {
+MUST_USE_RESULT MaybeHandle<JSRegExp> RegExpInitialize(Isolate* isolate,
+                                                       Handle<JSRegExp> regexp,
+                                                       Handle<Object> pattern,
+                                                       Handle<Object> flags) {
   Handle<String> pattern_string;
   if (pattern->IsUndefined(isolate)) {
     pattern_string = isolate->factory()->empty_string();
   } else {
     ASSIGN_RETURN_ON_EXCEPTION(isolate, pattern_string,
                                Object::ToString(isolate, pattern), JSRegExp);
   }
 
   Handle<String> flags_string;
   if (flags->IsUndefined(isolate)) {
@@ skipping 1278 matching lines @@
     }
 
     start_index = current_index = end_index;
   }
 
   return NewJSArrayWithElements(isolate, elems, num_elems);
 }
 
 // ES##sec-speciesconstructor
 // SpeciesConstructor ( O, defaultConstructor )
-MaybeHandle<Object> SpeciesConstructor(Isolate* isolate,
-                                       Handle<JSReceiver> recv,
-                                       Handle<JSFunction> default_ctor) {
+MUST_USE_RESULT MaybeHandle<Object> SpeciesConstructor(
+    Isolate* isolate, Handle<JSReceiver> recv,
+    Handle<JSFunction> default_ctor) {
   Handle<Object> ctor_obj;
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate, ctor_obj,
       JSObject::GetProperty(recv, isolate->factory()->constructor_string()),
       Object);
 
   if (ctor_obj->IsUndefined(isolate)) return default_ctor;
 
   if (!ctor_obj->IsJSReceiver()) {
     THROW_NEW_ERROR(isolate,
@@ skipping 653 matching lines @@
   a->Bind(&if_matched);
   {
     Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
                                                    match_indices, string);
     a->Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8