Rename IsConstructor to IsGenerativeConstructor.

runtime/lib/mirrors.cc

 // Copyright (c) 2012, 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 "lib/mirrors.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 53 matching lines @@
     args.SetAt(5, array);
   }
 
   Exceptions::ThrowByType(Exceptions::kNoSuchMethod, args);
   UNREACHABLE();
 }
 
 
 static void EnsureConstructorsAreCompiled(const Function& func) {
   // Only generative constructors can have initializing formals.
-  if (!func.IsConstructor()) return;
+  if (!func.IsGenerativeConstructor()) return;
 
   Isolate* isolate = Isolate::Current();
   const Class& cls = Class::Handle(isolate, func.Owner());
   const Error& error = Error::Handle(
       isolate, cls.EnsureIsFinalized(Isolate::Current()));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
   if (!func.HasCode()) {
@@ skipping 164 matching lines @@
 
   args.SetAt(2, owner_mirror);
   args.SetAt(3, Bool::Get(func.is_static()));
   args.SetAt(4, Bool::Get(func.is_abstract()));
   args.SetAt(5, Bool::Get(func.IsGetterFunction()));
   args.SetAt(6, Bool::Get(func.IsSetterFunction()));
 
   bool isConstructor = (func.kind() == RawFunction::kConstructor);
   args.SetAt(7, Bool::Get(isConstructor));
   args.SetAt(8, Bool::Get(isConstructor && func.is_const()));
-  args.SetAt(9, Bool::Get(isConstructor && func.IsConstructor()));
+  args.SetAt(9, Bool::Get(isConstructor && func.IsGenerativeConstructor()));
   args.SetAt(10, Bool::Get(isConstructor && func.is_redirecting()));
   args.SetAt(11, Bool::Get(isConstructor && func.IsFactory()));
 
   return CreateMirror(Symbols::_LocalMethodMirror(), args);
 }
 
 
 static RawInstance* CreateVariableMirror(const Field& field,
                                          const Instance& owner_mirror) {
   const MirrorReference& field_ref =
@@ skipping 1263 matching lines @@
       String::Handle(String::Concat(klass_name, Symbols::Dot()));
   if (!constructor_name.IsNull()) {
     internal_constructor_name =
         String::Concat(internal_constructor_name, constructor_name);
   }
 
   Function& lookup_constructor = Function::Handle(
       klass.LookupFunction(internal_constructor_name));
 
   if (lookup_constructor.IsNull() ||
-      !(lookup_constructor.IsConstructor() || lookup_constructor.IsFactory()) ||
+      (lookup_constructor.kind() != RawFunction::kConstructor) ||
       !lookup_constructor.is_reflectable()) {
     // Pretend we didn't find the constructor at all when the arity is wrong
     // so as to produce the same NoSuchMethodError as the non-reflective case.
     lookup_constructor = Function::null();
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       internal_constructor_name,
                       lookup_constructor,
                       Object::null_array(),
                       InvocationMirror::kConstructor,
                       InvocationMirror::kMethod);
@@ skipping 41 matching lines @@
     type = redirect_type.raw();
     type_arguments = redirect_type.arguments();
 
     redirected_constructor = lookup_constructor.RedirectionTarget();
     ASSERT(!redirected_constructor.IsNull());
     redirected_klass = type.type_class();
   }
 
   const intptr_t num_explicit_args = explicit_args.Length();
   const intptr_t num_implicit_args =
-      redirected_constructor.IsConstructor() ? 2 : 1;
+      redirected_constructor.IsGenerativeConstructor() ? 2 : 1;
   const Array& args =
       Array::Handle(Array::New(num_implicit_args + num_explicit_args));
 
   // Copy over the explicit arguments.
   Object& explicit_argument = Object::Handle();
   for (int i = 0; i < num_explicit_args; i++) {
     explicit_argument = explicit_args.At(i);
     args.SetAt(i + num_implicit_args, explicit_argument);
   }
 
@@ skipping 10 matching lines @@
     ThrowNoSuchMethod(AbstractType::Handle(klass.RareType()),
                       internal_constructor_name,
                       redirected_constructor,
                       Object::null_array(),
                       InvocationMirror::kConstructor,
                       InvocationMirror::kMethod);
     UNREACHABLE();
   }
 
   Instance& new_object = Instance::Handle();
-  if (redirected_constructor.IsConstructor()) {
+  if (redirected_constructor.IsGenerativeConstructor()) {
     // Constructors get the uninitialized object and a constructor phase. Note
     // we have delayed allocation until after the function type and argument
     // matching checks.
     new_object = Instance::New(redirected_klass);
     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);
     }
@@ skipping 10 matching lines @@
                                                args,
                                                args_descriptor_array));
   if (result.IsError()) {
     Exceptions::PropagateError(Error::Cast(result));
     UNREACHABLE();
   }
 
   // Factories may return null.
   ASSERT(result.IsInstance() || result.IsNull());
 
-  if (redirected_constructor.IsConstructor()) {
+  if (redirected_constructor.IsGenerativeConstructor()) {
     return new_object.raw();
   } else {
     return result.raw();
   }
 }
 
 
 DEFINE_NATIVE_ENTRY(LibraryMirror_invoke, 5) {
   // Argument 0 is the mirror, which is unused by the native. It exists
   // because this native is an instance method in order to be polymorphic
@@ skipping 155 matching lines @@
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   return CreateParameterMirrorList(func, owner);
 }
 
 
 DEFINE_NATIVE_ENTRY(MethodMirror_return_type, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   GET_NATIVE_ARGUMENT(AbstractType, instantiator, arguments->NativeArgAt(1));
   // We handle constructors in Dart code.
-  ASSERT(!func.IsConstructor());
+  ASSERT(!func.IsGenerativeConstructor());
   const AbstractType& type = AbstractType::Handle(func.result_type());
   return InstantiateType(type, instantiator);
 }
 
 
 DEFINE_NATIVE_ENTRY(MethodMirror_source, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(MirrorReference, ref, arguments->NativeArgAt(0));
   const Function& func = Function::Handle(ref.GetFunctionReferent());
   if (func.IsImplicitConstructor() || func.IsSignatureFunction()) {
     // We may need to handle more cases when the restrictions on mixins are
@@ skipping 111 matching lines @@
 }
 
 DEFINE_NATIVE_ENTRY(TypeMirror_moreSpecificTest, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, a, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(AbstractType, b, arguments->NativeArgAt(1));
   return Bool::Get(a.IsMoreSpecificThan(b, NULL)).raw();
 }
 
 
 }  // namespace dart