Eliminate phase parameter in constructors

runtime/vm/parser.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 "vm/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED
 
 #include "lib/invocation_mirror.h"
@@ skipping 30 matching lines @@
 namespace dart {
 
 DEFINE_FLAG(bool, enable_debug_break, false, "Allow use of break \"message\".");
 DEFINE_FLAG(bool, enable_mirrors, true,
     "Disable to make importing dart:mirrors an error.");
 DEFINE_FLAG(bool, load_deferred_eagerly, false,
     "Load deferred libraries eagerly.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warn_mixin_typedef, true, "Warning on legacy mixin typedef.");
 DEFINE_FLAG(bool, link_natives_lazily, false, "Link native calls lazily");
-DEFINE_FLAG(bool, move_super, true, "Move super initializer to end of list.");
 DEFINE_FLAG(bool, conditional_directives, false,
     "Enable conditional directives");
 DEFINE_FLAG(bool, warn_super, false,
     "Warning if super initializer not last in initializer list.");
 
 DECLARE_FLAG(bool, lazy_dispatchers);
 DECLARE_FLAG(bool, load_deferred_eagerly);
 DECLARE_FLAG(bool, profile_vm);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
@@ skipping 883 matching lines @@
   const Script& script = Script::Handle(zone, func.script());
   Parser parser(script, parsed_function, func.token_pos());
   if (tds.enabled()) {
     tds.SetNumArguments(1);
     tds.CopyArgument(0, "function", String::Handle(func.name()).ToCString());
   }
   SequenceNode* node_sequence = NULL;
   switch (func.kind()) {
     case RawFunction::kClosureFunction:
       if (func.IsImplicitClosureFunction()) {
-        node_sequence =
-            parser.ParseImplicitClosure(func);
+        node_sequence = parser.ParseImplicitClosure(func);
         break;
       }
       if (func.IsConstructorClosureFunction()) {
-        node_sequence =
-            parser.ParseConstructorClosure(func);
+        node_sequence = parser.ParseConstructorClosure(func);
         break;
       }
       // Fall-through: Handle non-implicit closures.
     case RawFunction::kRegularFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor:
       // The call to a redirecting factory is redirected.
       ASSERT(!func.IsRedirectingFactory());
       if (!func.IsImplicitConstructor()) {
@@ skipping 392 matching lines @@
 SequenceNode* Parser::ParseConstructorClosure(const Function& func) {
   TRACE_PARSER("ParseConstructorClosure");
   const intptr_t token_pos = func.token_pos();
 
   Function& constructor = Function::ZoneHandle(Z);
   TypeArguments& type_args = TypeArguments::ZoneHandle(Z);
   ParseConstructorClosurization(&constructor, &type_args);
   ASSERT(!constructor.IsNull());
 
   ParamList params;
-  // The first parameter of the closure function is the implicit closure
-  // argument.
+  // The first parameter of the closure function is the
+  // implicit closure argument.
   params.AddFinalParameter(token_pos,
                            &Symbols::ClosureParameter(),
                            &Object::dynamic_type());
   bool params_ok = ParseFormalParameters(constructor, &params);
   USE(params_ok);
   ASSERT(params_ok);
   // Per language spec, the type of the closure parameters is dynamic.
   // Replace the types parsed from the constructor.
   params.EraseParameterTypes();
 
@@ skipping 981 matching lines @@
   }
   return new(Z) StaticGetterNode(
       field_pos, implicit_argument, super_class, field_name);
 }
 
 
 StaticCallNode* Parser::GenerateSuperConstructorCall(
       const Class& cls,
       intptr_t supercall_pos,
       LocalVariable* receiver,
-      AstNode* phase_parameter,
       ArgumentListNode* forwarding_args) {
   const Class& super_class = Class::Handle(Z, cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
   // we're not compiling class Object), or if the super class is an
   // artificially generated "wrapper class" that has no constructor.
   if (super_class.IsNull() ||
       (super_class.num_native_fields() > 0 &&
        Class::Handle(Z, super_class.SuperClass()).IsObjectClass())) {
     return NULL;
   }
   String& super_ctor_name = String::Handle(Z, super_class.Name());
   super_ctor_name = Symbols::FromConcat(super_ctor_name, Symbols::Dot());
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // Implicit 'this' parameter is the first argument.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
-  // Implicit construction phase parameter is second argument.
-  arguments->Add(phase_parameter);
 
   // If this is a super call in a forwarding constructor, add the user-
   // defined arguments to the super call and adjust the the super
   // constructor name to the respective named constructor if necessary.
   if (forwarding_args != NULL) {
     for (int i = 0; i < forwarding_args->length(); i++) {
       arguments->Add(forwarding_args->NodeAt(i));
     }
     String& ctor_name = String::Handle(Z, current_function().name());
     String& class_name = String::Handle(Z, cls.Name());
@@ skipping 45 matching lines @@
     ConsumeToken();
     ctor_name = Symbols::FromConcat(
         ctor_name, *ExpectIdentifier("constructor name expected"));
   }
   CheckToken(Token::kLPAREN, "parameter list expected");
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super class constructor.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
-  // Second implicit parameter is the construction phase. We optimistically
-  // assume that we can execute both the super initializer and the super
-  // constructor body. We may later change this to only execute the
-  // super initializer.
-  AstNode* phase_parameter =
-      new LiteralNode(supercall_pos,
-                      Smi::ZoneHandle(Z, Smi::New(Function::kCtorPhaseAll)));
-  arguments->Add(phase_parameter);
+
   // 'this' parameter must not be accessible to the other super call arguments.
   receiver->set_invisible(true);
   ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
 
   // Resolve the constructor.
   const Function& super_ctor = Function::ZoneHandle(Z,
       super_class.LookupConstructor(ctor_name));
   if (super_ctor.IsNull()) {
     ReportError(supercall_pos,
@@ skipping 307 matching lines @@
         AstNode* init_statement =
             ParseInitializer(cls, receiver, initialized_fields);
         super_init_is_last = false;
         current_block_->statements->Add(init_statement);
       }
     } while (CurrentToken() == Token::kCOMMA);
   }
   if (super_init_call == NULL) {
     // Generate implicit super() if we haven't seen an explicit super call
     // or constructor redirection.
-    AstNode* phase_parameter = new LiteralNode(
-        TokenPos(), Smi::ZoneHandle(Z, Smi::New(Function::kCtorPhaseAll)));
-    super_init_call = GenerateSuperConstructorCall(
-        cls, TokenPos(), receiver, phase_parameter, NULL);
+    super_init_call =
+        GenerateSuperConstructorCall(cls, TokenPos(), receiver, NULL);
     if (super_init_call != NULL) {
       super_init_index = current_block_->statements->length();
       current_block_->statements->Add(super_init_call);
       super_init_is_last = true;
     }
   }
-  if (FLAG_move_super && (super_init_call != NULL) && !super_init_is_last) {
+  if ((super_init_call != NULL) && !super_init_is_last) {
     // If the super initializer call is not at the end of the initializer
     // list, implicitly move it to the end. The actual parameter values
     // are evaluated at the original position in the list and preserved
     // in temporary variables. (The following initializer expressions
     // could have side effects that alter the arguments to the super
     // initializer.) E.g:
     // A(x) : super(x), f = x++ { ... }
     // is transformed to:
     // A(x) : temp = x, f = x++, super(temp) { ... }
     if (FLAG_warn_super) {
       ReportWarning("Super initializer not at end");
     }
     ASSERT(super_init_index >= 0);
     ArgumentListNode* ctor_args = super_init_call->arguments();
     LetNode* saved_args = new(Z) LetNode(super_init_call->token_pos());
-    // The super initializer call has at least 2 arguments: the
-    // implicit receiver, and the hidden construction phase.
-    ASSERT(ctor_args->length() >= 2);
-    for (int i = 2; i < ctor_args->length(); i++) {
+    // The super initializer call has at least 1 arguments: the
+    // implicit receiver.
+    ASSERT(ctor_args->length() >= 1);
+    for (int i = 1; i < ctor_args->length(); i++) {
       AstNode* arg = ctor_args->NodeAt(i);
       LocalVariable* temp = CreateTempConstVariable(arg->token_pos(), "sca");
       AstNode* save_temp = new(Z) StoreLocalNode(arg->token_pos(), temp, arg);
       saved_args->AddNode(save_temp);
       ctor_args->SetNodeAt(i, new(Z) LoadLocalNode(arg->token_pos(), temp));
     }
     current_block_->statements->ReplaceNodeAt(super_init_index, saved_args);
     current_block_->statements->Add(super_init_call);
   }
   CheckFieldsInitialized(cls);
@@ skipping 15 matching lines @@
     ConsumeToken();
     pieces.Add(*ExpectIdentifier("constructor name expected"));
   }
   ctor_name = Symbols::FromConcatAll(pieces);
   CheckToken(Token::kLPAREN, "parameter list expected");
 
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
   // 'this' parameter is the first argument to constructor.
   AstNode* implicit_argument = new LoadLocalNode(call_pos, receiver);
   arguments->Add(implicit_argument);
-  // Construction phase parameter is second argument.
-  LocalVariable* phase_param = LookupPhaseParameter();
-  ASSERT(phase_param != NULL);
-  AstNode* phase_argument = new LoadLocalNode(call_pos, phase_param);
-  arguments->Add(phase_argument);
+
   receiver->set_invisible(true);
   ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
   // Resolve the constructor.
   const Function& redirect_ctor = Function::ZoneHandle(Z,
       cls.LookupConstructor(ctor_name));
   if (redirect_ctor.IsNull()) {
     ReportError(call_pos, "constructor '%s' not found", ctor_name.ToCString());
   }
   String& error_message = String::Handle(Z);
@@ skipping 13 matching lines @@
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsGenerativeConstructor());
   ASSERT(func.Owner() == current_class().raw());
   const intptr_t ctor_pos = TokenPos();
   OpenFunctionBlock(func);
 
   LocalVariable* receiver = new LocalVariable(
       Scanner::kNoSourcePos, Symbols::This(), *ReceiverType(current_class()));
   current_block_->scope->InsertParameterAt(0, receiver);
 
-  LocalVariable* phase_parameter =
-      new LocalVariable(Scanner::kNoSourcePos,
-                        Symbols::PhaseParameter(),
-                        Type::ZoneHandle(Z, Type::SmiType()));
-  current_block_->scope->InsertParameterAt(1, phase_parameter);
-
   // Parse expressions of instance fields that have an explicit
   // initializer expression.
   // The receiver must not be visible to field initializer expressions.
   receiver->set_invisible(true);
   GrowableArray<Field*> initialized_fields;
   ParseInitializedInstanceFields(
       current_class(), receiver, &initialized_fields);
   receiver->set_invisible(false);
 
   // If the class of this implicit constructor is a mixin application alias,
@@ skipping 19 matching lines @@
                   "cannot generate an implicit mixin application constructor "
                   "forwarding to a super class constructor with optional "
                   "parameters; add a constructor without optional parameters "
                   "to class '%s' that redirects to the constructor with "
                   "optional parameters and invoke it via super from a "
                   "constructor of the class extending the mixin application",
                   String::Handle(Z, super_class.Name()).ToCString());
     }
 
     // Prepare user-defined arguments to be forwarded to super call.
-    // The first user-defined argument is at position 2.
+    // The first user-defined argument is at position 1.
     forwarding_args = new ArgumentListNode(Scanner::kNoSourcePos);
-    for (int i = 2; i < func.NumParameters(); i++) {
+    for (int i = 1; i < func.NumParameters(); i++) {
       LocalVariable* param = new LocalVariable(
           Scanner::kNoSourcePos,
           String::ZoneHandle(Z, func.ParameterNameAt(i)),
           Object::dynamic_type());
       current_block_->scope->InsertParameterAt(i, param);
       forwarding_args->Add(new LoadLocalNode(Scanner::kNoSourcePos, param));
     }
   }
 
   AstNode* super_call = GenerateSuperConstructorCall(
       current_class(),
       Scanner::kNoSourcePos,
       receiver,
-      new LoadLocalNode(Scanner::kNoSourcePos, phase_parameter),
       forwarding_args);
   if (super_call != NULL) {
     current_block_->statements->Add(super_call);
   }
   CheckFieldsInitialized(current_class());
 
   // Empty constructor body.
   current_block_->statements->Add(new ReturnNode(Scanner::kNoSourcePos));
   SequenceNode* statements = CloseBlock();
   return statements;
@@ skipping 42 matching lines @@
   OpenFunctionBlock(func);
   ParamList params;
   const bool allow_explicit_default_values = true;
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   // Add implicit receiver parameter which is passed the allocated
   // but uninitialized instance to construct.
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), func.token_pos());
 
-  // Add implicit parameter for construction phase.
-  params.AddFinalParameter(
-      TokenPos(),
-      &Symbols::PhaseParameter(),
-      &Type::ZoneHandle(Z, Type::SmiType()));
-
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
   SetupDefaultsForOptionalParams(params);
   ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
   ASSERT(func.NumParameters() == params.parameters->length());
 
   // Now populate function scope with the formal parameters.
@@ skipping 19 matching lines @@
     // storing values. We make the formal parameters temporarily invisible
     // while parsing the instance field initializer expressions.
     params.SetInvisible(true);
     ParseInitializedInstanceFields(cls, receiver, &initialized_fields);
     // Make the parameters (which are in the outer scope) visible again.
     params.SetInvisible(false);
   }
 
   // Turn formal field parameters into field initializers.
   if (params.has_field_initializer) {
-    // First two parameters are implicit receiver and phase.
-    ASSERT(params.parameters->length() >= 2);
-    for (int i = 2; i < params.parameters->length(); i++) {
+    // The first parameter is the implicit receiver.
+    ASSERT(params.parameters->length() >= 1);
+    for (int i = 1; i < params.parameters->length(); i++) {
       ParamDesc& param = (*params.parameters)[i];
       if (param.is_field_initializer) {
         const String& field_name = *param.name;
         Field& field =
             Field::ZoneHandle(Z, cls.LookupInstanceField(field_name));
         if (field.IsNull()) {
           ReportError(param.name_pos,
                       "unresolved reference to instance field '%s'",
                       field_name.ToCString());
         }
@@ skipping 36 matching lines @@
     }
   }
 
   if (is_redirecting_constructor) {
     ParseConstructorRedirection(cls, receiver);
   } else {
     ParseInitializers(cls, receiver, &initialized_fields);
   }
 
   SequenceNode* init_statements = CloseBlock();
-  if (FLAG_move_super) {
-    // Ignore the phase parameter.
-    current_block_->statements->Add(init_statements);
-  } else if (is_redirecting_constructor) {
-    // A redirecting super constructor simply passes the phase parameter on to
-    // the target which executes the corresponding phase.
-    current_block_->statements->Add(init_statements);
-  } else if (init_statements->length() > 0) {
-    // Generate guard around the initializer code.
-    LocalVariable* phase_param = LookupPhaseParameter();
-    AstNode* phase_value = new
-        LoadLocalNode(Scanner::kNoSourcePos, phase_param);
-    AstNode* phase_check = new BinaryOpNode(
-        Scanner::kNoSourcePos, Token::kBIT_AND, phase_value,
-        new LiteralNode(Scanner::kNoSourcePos,
-            Smi::ZoneHandle(Z, Smi::New(Function::kCtorPhaseInit))));
-    AstNode* comparison =
-        new ComparisonNode(Scanner::kNoSourcePos,
-                           Token::kNE_STRICT,
-                           phase_check,
-                           new LiteralNode(TokenPos(),
-                                           Smi::ZoneHandle(Z, Smi::New(0))));
-    AstNode* guarded_init_statements =
-        new IfNode(Scanner::kNoSourcePos,
-                   comparison,
-                   init_statements,
-                   NULL);
-    current_block_->statements->Add(guarded_init_statements);
-  }
+  current_block_->statements->Add(init_statements);
 
-  // Parsing of initializers done. Now we parse the constructor body
-  // and add the implicit super call to the super constructor's body
-  // if necessary.
-  StaticCallNode* super_call = NULL;
-  // Look for the super initializer call in the sequence of initializer
-  // statements. If it exists and is not the last initializer statement,
-  // we need to create an implicit super call to the super constructor's
-  // body.
-  // Thus, iterate over all but the last initializer to see whether
-  // it's a super constructor call.
-  for (int i = 0; i < init_statements->length() - 1; i++) {
-    if (init_statements->NodeAt(i)->IsStaticCallNode()) {
-      StaticCallNode* static_call =
-      init_statements->NodeAt(i)->AsStaticCallNode();
-      if (static_call->function().IsGenerativeConstructor()) {
-        super_call = static_call;
-        break;
-      }
-    }
-  }
-  if (super_call != NULL) {
-    ASSERT(!FLAG_move_super);
-    // Generate an implicit call to the super constructor's body.
-    // We need to patch the super _initializer_ call so that it
-    // saves the evaluated actual arguments in temporary variables.
-    // The temporary variables are necessary so that the argument
-    // expressions are not evaluated twice.
-    // Note: we should never get here in the case of a redirecting
-    // constructor. In that case, the call to the target constructor
-    // is the "super call" and is implicitly at the end of the
-    // initializer list.
-    ASSERT(!is_redirecting_constructor);
-    ArgumentListNode* ctor_args = super_call->arguments();
-    // The super initializer call has at least 2 arguments: the
-    // implicit receiver, and the hidden construction phase.
-    ASSERT(ctor_args->length() >= 2);
-    for (int i = 2; i < ctor_args->length(); i++) {
-      AstNode* arg = ctor_args->NodeAt(i);
-      if (!IsSimpleLocalOrLiteralNode(arg)) {
-        LocalVariable* temp = CreateTempConstVariable(arg->token_pos(), "sca");
-        AstNode* save_temp = new StoreLocalNode(arg->token_pos(), temp, arg);
-        ctor_args->SetNodeAt(i, save_temp);
-      }
-    }
-  }
+  // Parsing of initializers done. Now we parse the constructor body.
   OpenBlock();  // Block to collect constructor body nodes.
-  intptr_t body_pos = TokenPos();
-
-  // Insert the implicit super call to the super constructor body.
-  if (super_call != NULL) {
-    ASSERT(!FLAG_move_super);
-    ArgumentListNode* initializer_args = super_call->arguments();
-    const Function& super_ctor = super_call->function();
-    // Patch the initializer call so it only executes the super initializer.
-    initializer_args->SetNodeAt(1, new LiteralNode(
-        body_pos, Smi::ZoneHandle(Z, Smi::New(Function::kCtorPhaseInit))));
-
-    ArgumentListNode* super_call_args = new ArgumentListNode(body_pos);
-    // First argument is the receiver.
-    super_call_args->Add(new LoadLocalNode(body_pos, receiver));
-    // Second argument is the construction phase argument.
-    AstNode* phase_parameter = new(Z) LiteralNode(
-        body_pos, Smi::ZoneHandle(Z, Smi::New(Function::kCtorPhaseBody)));
-    super_call_args->Add(phase_parameter);
-    super_call_args->set_names(initializer_args->names());
-    for (int i = 2; i < initializer_args->length(); i++) {
-      AstNode* arg = initializer_args->NodeAt(i);
-      if (arg->IsLiteralNode()) {
-        LiteralNode* lit = arg->AsLiteralNode();
-        super_call_args->Add(new LiteralNode(body_pos, lit->literal()));
-      } else {
-        ASSERT(arg->IsLoadLocalNode() || arg->IsStoreLocalNode());
-        if (arg->IsLoadLocalNode()) {
-          const LocalVariable& temp = arg->AsLoadLocalNode()->local();
-          super_call_args->Add(new LoadLocalNode(body_pos, &temp));
-        } else if (arg->IsStoreLocalNode()) {
-          const LocalVariable& temp = arg->AsStoreLocalNode()->local();
-          super_call_args->Add(new LoadLocalNode(body_pos, &temp));
-        }
-      }
-    }
-    ASSERT(super_ctor.AreValidArguments(super_call_args->length(),
-                                        super_call_args->names(),
-                                        NULL));
-    current_block_->statements->Add(
-        new StaticCallNode(body_pos, super_ctor, super_call_args));
-  }
-
   if (CurrentToken() == Token::kLBRACE) {
     // We checked in the top-level parse phase that a redirecting
     // constructor does not have a body.
     ASSERT(!is_redirecting_constructor);
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ReportError("constructors may not return a value");
   } else if (IsSymbol(Symbols::Native())) {
@@ skipping 12 matching lines @@
                                  InvocationMirror::kStatic,
                                  InvocationMirror::kMethod,
                                  NULL));  // No existing function.
     }
   } else {
     UnexpectedToken();
   }
 
   SequenceNode* ctor_block = CloseBlock();
   if (ctor_block->length() > 0) {
-    if (FLAG_move_super) {
-      // Ignore the phase parameter.
-      current_block_->statements->Add(ctor_block);
-    } else {
-      // Generate guard around the constructor body code.
-      LocalVariable* phase_param = LookupPhaseParameter();
-      AstNode* phase_value =
-          new LoadLocalNode(Scanner::kNoSourcePos, phase_param);
-      AstNode* phase_check =
-          new BinaryOpNode(Scanner::kNoSourcePos, Token::kBIT_AND,
-              phase_value,
-              new LiteralNode(Scanner::kNoSourcePos,
-                  Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody))));
-      AstNode* comparison =
-          new ComparisonNode(Scanner::kNoSourcePos,
-                             Token::kNE_STRICT,
-                             phase_check,
-                             new LiteralNode(body_pos,
-                                             Smi::ZoneHandle(Smi::New(0))));
-      AstNode* guarded_block_statements =
-          new IfNode(Scanner::kNoSourcePos, comparison, ctor_block, NULL);
-      current_block_->statements->Add(guarded_block_statements);
-    }
+    current_block_->statements->Add(ctor_block);
   }
   current_block_->statements->Add(new ReturnNode(func.end_token_pos()));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
 // Parse the formal parameters and code.
@@ skipping 399 matching lines @@
   // The first parameter of a factory is the TypeArguments vector of
   // the type of the instance to be allocated.
   if (!method->has_static || method->IsConstructor()) {
     method->params.AddReceiver(ReceiverType(current_class()), formal_param_pos);
   } else if (method->IsFactory()) {
     method->params.AddFinalParameter(
         formal_param_pos,
         &Symbols::TypeArgumentsParameter(),
         &Object::dynamic_type());
   }
-  // Constructors have an implicit parameter for the construction phase.
-  if (method->IsConstructor()) {
-    method->params.AddFinalParameter(
-        TokenPos(),
-        &Symbols::PhaseParameter(),
-        &Type::ZoneHandle(Z, Type::SmiType()));
-  }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   if (!method->IsGetter()) {
     ParseFormalParameterList(allow_explicit_default_values,
                              false,
                              &method->params);
   }
 
   // Now that we know the parameter list, we can distinguish between the
@@ skipping 1216 matching lines @@
   ctor.set_end_token_pos(ctor.token_pos());
   ctor.set_is_debuggable(false);
   if (library_.is_dart_scheme() && library_.IsPrivate(ctor_name)) {
     ctor.set_is_reflectable(false);
   }
 
   ParamList params;
   // Add implicit 'this' parameter.
   const AbstractType* receiver_type = ReceiverType(cls);
   params.AddReceiver(receiver_type, cls.token_pos());
-  // Add implicit parameter for construction phase.
-  params.AddFinalParameter(cls.token_pos(),
-                           &Symbols::PhaseParameter(),
-                           &Type::ZoneHandle(Z, Type::SmiType()));
 
   AddFormalParamsToFunction(&params, ctor);
   // The body of the constructor cannot modify the type of the constructed
   // instance, which is passed in as the receiver.
   ctor.set_result_type(*receiver_type);
   cls.AddFunction(ctor);
 }
 
 
 // Check for cycles in constructor redirection.
@@ skipping 2506 matching lines @@
 
 
 LocalVariable* Parser::LookupTypeArgumentsParameter(LocalScope* from_scope,
                                                     bool test_only) {
   ASSERT(current_function().IsInFactoryScope());
   return from_scope->LookupVariable(Symbols::TypeArgumentsParameter(),
                                     test_only);
 }
 
 
-LocalVariable* Parser::LookupPhaseParameter() {
-  const bool kTestOnly = false;
-  return current_block_->scope->LookupVariable(Symbols::PhaseParameter(),
-                                               kTestOnly);
-}
-
-
 void Parser::CaptureInstantiator() {
   ASSERT(current_block_->scope->function_level() > 0);
   const String* variable_name = current_function().IsInFactoryScope() ?
       &Symbols::TypeArgumentsParameter() : &Symbols::This();
   current_block_->scope->CaptureVariable(
       current_block_->scope->LookupVariable(*variable_name, true));
 }
 
 
 AstNode* Parser::LoadReceiver(intptr_t token_pos) {
@@ skipping 4741 matching lines @@
       field_ref_pos, NULL, field_owner, field_name);
 }
 
 
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   // Factories have one extra argument: the type arguments.
-  // Constructors have 2 extra arguments: rcvr and construction phase.
-  const int kNumExtraArgs = constructor.IsFactory() ? 1 : 2;
+  // Constructors have 1 extra arguments: receiver.
+  const int kNumExtraArgs = 1;
   const int num_arguments = arguments->length() + kNumExtraArgs;
   const Array& arg_values =
       Array::Handle(Z, Array::New(num_arguments, Heap::kOld));
   Instance& instance = Instance::Handle(Z);
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class, Heap::kOld);
     if (!type_arguments.IsNull()) {
       if (!type_arguments.IsInstantiated()) {
         ReportError("type must be constant in const constructor");
       }
       instance.SetTypeArguments(
           TypeArguments::Handle(Z, type_arguments.Canonicalize()));
     }
     arg_values.SetAt(0, instance);
-    arg_values.SetAt(1, Smi::Handle(Z, Smi::New(Function::kCtorPhaseAll)));
   } else {
     // Prepend type_arguments to list of arguments to factory.
     ASSERT(type_arguments.IsZoneHandle());
     arg_values.SetAt(0, type_arguments);
   }
   for (int i = 0; i < arguments->length(); i++) {
     AstNode* arg = arguments->NodeAt(i);
     // Arguments have been evaluated to a literal value already.
     ASSERT(arg->IsLiteralNode());
     arg_values.SetAt((i + kNumExtraArgs), arg->AsLiteralNode()->literal());
@@ skipping 1211 matching lines @@
     return ThrowTypeError(type_pos, type);
   }
 
   // Resolve the type and optional identifier to a constructor or factory.
   String& type_class_name = String::Handle(Z, type_class.Name());
   TypeArguments& type_arguments =
       TypeArguments::ZoneHandle(Z, type.arguments());
 
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
-  // A constructor has a second implicit 'phase' parameter.
-  intptr_t arguments_length = arguments->length() + 2;
+  intptr_t arguments_length = arguments->length() + 1;
 
   // An additional type check of the result of a redirecting factory may be
   // required.
   AbstractType& type_bound = AbstractType::ZoneHandle(Z);
 
   // Make sure that an appropriate constructor exists.
   String& constructor_name =
       BuildConstructorName(type_class_name, named_constructor);
   Function& constructor = Function::ZoneHandle(Z,
       type_class.LookupConstructor(constructor_name));
@@ skipping 77 matching lines @@
         type_bound = type.raw();
       }
       type = redirect_type.raw();
       type_class = type.type_class();
       type_class_name = type_class.Name();
       type_arguments = type.arguments();
       constructor = constructor.RedirectionTarget();
       constructor_name = constructor.name();
       ASSERT(!constructor.IsNull());
     }
-    if (constructor.IsFactory()) {
-      // A factory does not have the implicit 'phase' parameter.
-      arguments_length -= 1;
-    }
   }
   ASSERT(!constructor.IsNull());
 
   // It is ok to call a factory method of an abstract class, but it is
   // a dynamic error to instantiate an abstract class.
   if (type_class.is_abstract() && !constructor.IsFactory()) {
     // Evaluate arguments before throwing.
     LetNode* result = new(Z) LetNode(call_pos);
     for (intptr_t i = 0; i < arguments->length(); ++i) {
       result->AddNode(arguments->NodeAt(i));
@@ skipping 955 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED