Move family of MakeError functions to C++

src/builtins/builtins-error.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.h"
 #include "src/builtins/builtins-utils.h"
 
 #include "src/messages.h"
 #include "src/property-descriptor.h"
 #include "src/string-builder.h"
@@ skipping 63 matching lines @@
   return isolate->heap()->undefined_value();
 }
 
 // ES6 section 19.5.3.4 Error.prototype.toString ( )
 BUILTIN(ErrorPrototypeToString) {
   HandleScope scope(isolate);
   RETURN_RESULT_OR_FAILURE(isolate,
                            ErrorUtils::ToString(isolate, args.receiver()));
 }
 
-BUILTIN(MakeGenericError) {
-  HandleScope scope(isolate);
+namespace {
 
-  Handle<Object> constructor = args.atOrUndefined(isolate, 1);
-  Handle<Object> template_index = args.atOrUndefined(isolate, 2);
-  Handle<Object> arg0 = args.atOrUndefined(isolate, 3);
-  Handle<Object> arg1 = args.atOrUndefined(isolate, 4);
-  Handle<Object> arg2 = args.atOrUndefined(isolate, 5);
+Object* MakeGenericError(Isolate* isolate, BuiltinArguments args,
+                         Handle<JSFunction> constructor) {
+  Handle<Object> template_index = args.atOrUndefined(isolate, 1);
+  Handle<Object> arg0 = args.atOrUndefined(isolate, 2);
+  Handle<Object> arg1 = args.atOrUndefined(isolate, 3);
+  Handle<Object> arg2 = args.atOrUndefined(isolate, 4);
 
-  DCHECK(constructor->IsJSFunction());
   DCHECK(template_index->IsSmi());
 
   RETURN_RESULT_OR_FAILURE(
+      isolate, ErrorUtils::MakeGenericError(isolate, constructor,
+                                            Smi::cast(*template_index)->value(),
+                                            arg0, arg1, arg2, SKIP_NONE));
+}
+
+}  // namespace
+
+BUILTIN(MakeError) {
+  HandleScope scope(isolate);
+  return MakeGenericError(isolate, args, isolate->error_function());
+}
+
+BUILTIN(MakeRangeError) {
+  HandleScope scope(isolate);
+  return MakeGenericError(isolate, args, isolate->range_error_function());
+}
+
+BUILTIN(MakeSyntaxError) {
+  HandleScope scope(isolate);
+  return MakeGenericError(isolate, args, isolate->syntax_error_function());
+}
+
+BUILTIN(MakeTypeError) {
+  HandleScope scope(isolate);
+  return MakeGenericError(isolate, args, isolate->type_error_function());
+}
+
+BUILTIN(MakeURIError) {
+  HandleScope scope(isolate);
+  Handle<JSFunction> constructor = isolate->uri_error_function();
+  Handle<Object> undefined = isolate->factory()->undefined_value();
+  const int template_index = MessageTemplate::kURIMalformed;
+  RETURN_RESULT_OR_FAILURE(
       isolate,
-      ErrorUtils::MakeGenericError(
-          isolate, Handle<JSFunction>::cast(constructor),
-          Smi::cast(*template_index)->value(), arg0, arg1, arg2, SKIP_FIRST));
+      ErrorUtils::MakeGenericError(isolate, constructor, template_index,
+                                   undefined, undefined, undefined, SKIP_NONE));
 }
 
 }  // namespace internal
 }  // namespace v8