Rename IsConstructor to IsGenerativeConstructor.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
@@ skipping 2666 matching lines @@
       isolate, lib.LookupClassAllowPrivate(class_name));
   ASSERT(!cls.IsNull());
   Object& result = Object::Handle(isolate);
   String& dot_name = String::Handle(String::New("."));
   String& constr_name = String::Handle(String::Concat(class_name, dot_name));
   result = ResolveConstructor(CURRENT_FUNC, cls, class_name, constr_name, 1);
   if (result.IsError()) return result.raw();
   ASSERT(result.IsFunction());
   Function& constructor = Function::Handle(isolate);
   constructor ^= result.raw();
-  if (!constructor.IsConstructor()) {
+  if (!constructor.IsGenerativeConstructor()) {
     const String& message = String::Handle(
         String::NewFormatted("%s: class '%s' is not a constructor.",
                              CURRENT_FUNC, class_name.ToCString()));
     return ApiError::New(message);
   }
   Instance& exception = Instance::Handle(isolate);
   exception = Instance::New(cls);
   const Array& args = Array::Handle(isolate, Array::New(3));
   args.SetAt(0, exception);
   args.SetAt(1,
@@ skipping 446 matching lines @@
 }
 
 
 static Dart_Handle NewByteData(Isolate* isolate, intptr_t length) {
   CHECK_LENGTH(length, TypedData::MaxElements(kTypedDataInt8ArrayCid));
   Object& result = Object::Handle(isolate);
   result = GetByteDataConstructor(isolate, Symbols::ByteDataDot(), 1);
   ASSERT(!result.IsNull());
   ASSERT(result.IsFunction());
   const Function& factory = Function::Cast(result);
-  ASSERT(!factory.IsConstructor());
+  ASSERT(!factory.IsGenerativeConstructor());
 
   // Create the argument list.
   const Array& args = Array::Handle(isolate, Array::New(2));
   // Factories get type arguments.
   args.SetAt(0, Object::null_type_arguments());
   args.SetAt(1, Smi::Handle(isolate, Smi::New(length)));
 
   // Invoke the constructor and return the new object.
   result = DartEntry::InvokeFunction(factory, args);
   ASSERT(result.IsInstance() || result.IsNull() || result.IsError());
@@ skipping 28 matching lines @@
   Dart_Handle ext_data = NewExternalTypedData(
       isolate, kExternalTypedDataUint8ArrayCid, data, length);
   if (::Dart_IsError(ext_data)) {
     return ext_data;
   }
   Object& result = Object::Handle(isolate);
   result = GetByteDataConstructor(isolate, Symbols::ByteDataDot_view(), 3);
   ASSERT(!result.IsNull());
   ASSERT(result.IsFunction());
   const Function& factory = Function::Cast(result);
-  ASSERT(!factory.IsConstructor());
+  ASSERT(!factory.IsGenerativeConstructor());
 
   // Create the argument list.
   const intptr_t num_args = 3;
   const Array& args = Array::Handle(isolate, Array::New(num_args + 1));
   // Factories get type arguments.
   args.SetAt(0, Object::null_type_arguments());
   const ExternalTypedData& array =
       Api::UnwrapExternalTypedDataHandle(isolate, ext_data);
   args.SetAt(1, array);
   Smi& smi = Smi::Handle(isolate);
@@ skipping 160 matching lines @@
     RETURN_TYPE_ERROR(isolate, typed_data, 'TypedData');
   }
   Object& result = Object::Handle(isolate);
   result = GetByteBufferConstructor(isolate,
                                     Symbols::_ByteBuffer(),
                                     Symbols::_ByteBufferDot_New(),
                                     1);
   ASSERT(!result.IsNull());
   ASSERT(result.IsFunction());
   const Function& factory = Function::Cast(result);
-  ASSERT(!factory.IsConstructor());
+  ASSERT(!factory.IsGenerativeConstructor());
 
   // Create the argument list.
   const Array& args = Array::Handle(isolate, Array::New(2));
   // Factories get type arguments.
   args.SetAt(0, Object::null_type_arguments());
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(typed_data));
   args.SetAt(1, obj);
 
   // Invoke the factory constructor and return the new object.
   result = DartEntry::InvokeFunction(factory, args);
@@ skipping 124 matching lines @@
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
                                      const String& constr_name,
                                      int num_args) {
   // The constructor must be present in the interface.
   const Function& constructor =
       Function::Handle(cls.LookupFunctionAllowPrivate(constr_name));
   if (constructor.IsNull() ||
-      (!constructor.IsConstructor() && !constructor.IsFactory())) {
+      (!constructor.IsGenerativeConstructor() && !constructor.IsFactory())) {
     const String& lookup_class_name = String::Handle(cls.Name());
     if (!class_name.Equals(lookup_class_name)) {
       // When the class name used to build the constructor name is
       // different than the name of the class in which we are doing
       // the lookup, it can be confusing to the user to figure out
       // what's going on.  Be a little more explicit for these error
       // messages.
       const String& message = String::Handle(
           String::NewFormatted(
               "%s: could not find factory '%s' in class '%s'.",
               current_func,
               constr_name.ToCString(),
               lookup_class_name.ToCString()));
       return ApiError::New(message);
     } else {
       const String& message = String::Handle(
           String::NewFormatted("%s: could not find constructor '%s'.",
                                current_func, constr_name.ToCString()));
       return ApiError::New(message);
     }
   }
-  int extra_args = (constructor.IsConstructor() ? 2 : 1);
+  int extra_args = (constructor.IsGenerativeConstructor() ? 2 : 1);
   String& error_message = String::Handle();
   if (!constructor.AreValidArgumentCounts(num_args + extra_args,
                                           0,
                                           &error_message)) {
     const String& message = String::Handle(
         String::NewFormatted("%s: wrong argument count for "
                              "constructor '%s': %s.",
                              current_func,
                              constr_name.ToCString(),
                              error_message.ToCString()));
@@ skipping 82 matching lines @@
         return Api::NewHandle(isolate, bound_error.raw());
       }
       redirect_type ^= redirect_type.Canonicalize();
     }
 
     type_obj = redirect_type.raw();
     type_arguments = redirect_type.arguments();
 
     cls = type_obj.type_class();
   }
-  if (constructor.IsConstructor()) {
+  if (constructor.IsGenerativeConstructor()) {
     // Create the new object.
     new_object = Instance::New(cls);
   }
 
   // Create the argument list.
   intptr_t arg_index = 0;
-  int extra_args = (constructor.IsConstructor() ? 2 : 1);
+  int extra_args = (constructor.IsGenerativeConstructor() ? 2 : 1);
   const Array& args =
       Array::Handle(isolate, Array::New(number_of_arguments + extra_args));
-  if (constructor.IsConstructor()) {
+  if (constructor.IsGenerativeConstructor()) {
     // Constructors get the uninitialized object and a constructor phase.
     if (!type_arguments.IsNull()) {
       // The type arguments will be null if the class has no type parameters, in
       // which case the following call would fail because there is no slot
       // reserved in the object for the type vector.
       new_object.SetTypeArguments(type_arguments);
     }
     args.SetAt(arg_index++, new_object);
     args.SetAt(arg_index++,
                Smi::Handle(isolate, Smi::New(Function::kCtorPhaseAll)));
@@ skipping 15 matching lines @@
     }
     args.SetAt(arg_index++, argument);
   }
 
   // Invoke the constructor and return the new object.
   result = DartEntry::InvokeFunction(constructor, args);
   if (result.IsError()) {
     return Api::NewHandle(isolate, result.raw());
   }
 
-  if (constructor.IsConstructor()) {
+  if (constructor.IsGenerativeConstructor()) {
     ASSERT(result.IsNull());
   } else {
     ASSERT(result.IsNull() || result.IsInstance());
     new_object ^= result.raw();
   }
   return Api::NewHandle(isolate, new_object.raw());
 }
 
 
 static RawInstance* AllocateObject(Isolate* isolate, const Class& cls) {
@@ skipping 137 matching lines @@
   strings.SetAt(0, class_name);
   strings.SetAt(1, Symbols::Dot());
   strings.SetAt(2, constructor_name);
   const String& dot_name = String::Handle(isolate, String::ConcatAll(strings));
   const TypeArguments& type_arguments =
     TypeArguments::Handle(isolate, type_obj.arguments());
   const Function& constructor =
     Function::Handle(isolate, cls.LookupFunctionAllowPrivate(dot_name));
   const int extra_args = 2;
   if (!constructor.IsNull() &&
-      constructor.IsConstructor() &&
+      constructor.IsGenerativeConstructor() &&
       constructor.AreValidArgumentCounts(number_of_arguments + extra_args,
                                          0,
                                          NULL)) {
     // Create the argument list.
     // Constructors get the uninitialized object and a constructor phase.
     if (!type_arguments.IsNull()) {
       // The type arguments will be null if the class has no type
       // parameters, in which case the following call would fail
       // because there is no slot reserved in the object for the
       // type vector.
@@ skipping 1606 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart