Eliminate phase parameter in constructors

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 2729 matching lines @@
   Function& constructor = Function::Handle(zone);
   constructor ^= result.raw();
   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(zone);
   exception = Instance::New(cls);
-  const Array& args = Array::Handle(zone, Array::New(3));
+  const Array& args = Array::Handle(zone, Array::New(2));
   args.SetAt(0, exception);
-  args.SetAt(1, Smi::Handle(zone, Smi::New(Function::kCtorPhaseAll)));
-  args.SetAt(2, String::Handle(String::New(exception_message)));
+  args.SetAt(1, String::Handle(String::New(exception_message)));
   result = DartEntry::InvokeFunction(constructor, args);
   if (result.IsError()) return result.raw();
   ASSERT(result.IsNull());
 
   if (thread->top_exit_frame_info() == 0) {
     // There are no dart frames on the stack so it would be illegal to
     // throw an exception here.
     const String& message = String::Handle(
             String::New("No Dart frames on stack, cannot throw exception"));
     return ApiError::New(message);
@@ skipping 833 matching lines @@
               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.IsGenerativeConstructor() ? 2 : 1);
+  int extra_args = 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 93 matching lines @@
     if (!cls.is_allocated() && Dart::IsRunningPrecompiledCode()) {
       return Api::NewError("Precompilation dropped '%s'", cls.ToCString());
     }
 #endif
     // Create the new object.
     new_object = Instance::New(cls);
   }
 
   // Create the argument list.
   intptr_t arg_index = 0;
-  int extra_args = (constructor.IsGenerativeConstructor() ? 2 : 1);
+  int extra_args = 1;
   const Array& args =
       Array::Handle(Z, Array::New(number_of_arguments + extra_args));
   if (constructor.IsGenerativeConstructor()) {
-    // Constructors get the uninitialized object and a constructor phase.
+    // Constructors get the uninitialized object.
     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(Z, Smi::New(Function::kCtorPhaseAll)));
   } else {
     // Factories get type arguments.
     args.SetAt(arg_index++, type_arguments);
   }
   Object& argument = Object::Handle(Z);
   for (int i = 0; i < number_of_arguments; i++) {
     argument = Api::UnwrapHandle(arguments[i]);
     if (!argument.IsNull() && !argument.IsInstance()) {
       if (argument.IsError()) {
         return Api::NewHandle(T, argument.raw());
@@ skipping 171 matching lines @@
   if (constructor_name.IsNull()) {
     strings.SetAt(2, Symbols::Empty());
   } else {
     strings.SetAt(2, constructor_name);
   }
   const String& dot_name = String::Handle(Z, String::ConcatAll(strings));
   const TypeArguments& type_arguments =
       TypeArguments::Handle(Z, type_obj.arguments());
   const Function& constructor =
       Function::Handle(Z, cls.LookupFunctionAllowPrivate(dot_name));
-  const int extra_args = 2;
+  const int extra_args = 1;
   if (!constructor.IsNull() &&
       constructor.IsGenerativeConstructor() &&
       constructor.AreValidArgumentCounts(number_of_arguments + extra_args,
                                          0,
                                          NULL)) {
     // Create the argument list.
-    // Constructors get the uninitialized object and a constructor phase.
+    // Constructors get the uninitialized object.
     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.
       instance.SetTypeArguments(type_arguments);
     }
     Dart_Handle result;
     Array& args = Array::Handle(Z);
     result = SetupArguments(
         T, number_of_arguments, arguments, extra_args, &args);
     if (!::Dart_IsError(result)) {
       args.SetAt(0, instance);
-      args.SetAt(1, Smi::Handle(Z, Smi::New(Function::kCtorPhaseAll)));
       const Object& retval = Object::Handle(Z,
           DartEntry::InvokeFunction(constructor, args));
       if (retval.IsError()) {
         result = Api::NewHandle(T, retval.raw());
       } else {
         result = Api::NewHandle(T, instance.raw());
       }
     }
     return result;
   }
@@ skipping 2040 matching lines @@
   return Api::Success();
 }
 #endif  // DART_PRECOMPILED
 
 
 DART_EXPORT bool Dart_IsRunningPrecompiledCode() {
   return Dart::IsRunningPrecompiledCode();
 }
 
 }  // namespace dart