Two-phase constructors

runtime/vm/parser.cc

 // Copyright (c) 2011, 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/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 23 matching lines @@
 static const char* kGrowableObjectArrayFromArrayName =
     "GrowableObjectArray._usingArray";
 static const char* kGrowableObjectArrayName = "GrowableObjectArray";
 static const char* kMutableMapName = "MutableMap";
 static const char* kMutableMapFromLiteralName = "fromLiteral";
 static const char* kImmutableMapName = "ImmutableMap";
 static const char* kImmutableMapConstructorName = "ImmutableMap.";
 static const char* kStringClassName = "StringBase";
 static const char* kInterpolateName = "_interpolate";
 static const char* kThisName = "this";
+static const char* kPhaseParameterName = ":phase";
 static const char* kGetIteratorName = "iterator";
 
 #if defined(DEBUG)
 
 class TraceParser : public ValueObject {
  public:
   TraceParser(intptr_t token_index, const Script& script, const char* msg) {
     if (FLAG_trace_parser) {
       intptr_t line, column;
       script.GetTokenLocation(token_index, &line, &column);
@@ skipping 976 matching lines @@
 
 
 AstNode* Parser::ParseSuperCall(const String& function_name) {
   TRACE_PARSER("ParseSuperCall");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const intptr_t supercall_pos = token_index_;
 
   const Function& super_function = Function::ZoneHandle(
       GetSuperFunction(supercall_pos, function_name));
 
+  ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super call.
   AstNode* receiver = LoadReceiver(supercall_pos);
-  ArgumentListNode* arguments =
-      ParseActualParameters(receiver, kAllowConst);
+  arguments->Add(receiver);
+  ParseActualParameters(arguments, kAllowConst);
   return new StaticCallNode(supercall_pos, super_function, arguments);
 }
 
 
 AstNode* Parser::ParseSuperOperator() {
   TRACE_PARSER("ParseSuperOperator");
   AstNode* super_op = NULL;
   const intptr_t operator_pos = token_index_;
 
   if (CurrentToken() == Token::kLBRACK) {
@@ skipping 151 matching lines @@
 
     ArgumentListNode* setter_arguments = new ArgumentListNode(field_pos);
     setter_arguments->Add(implicit_argument);
     setter_arguments->Add(value);
     super_field = new StaticCallNode(field_pos, super_setter, setter_arguments);
   }
   return super_field;
 }
 
 
-void Parser::GenerateSuperInitializerCall(const Class& cls,
+void Parser::GenerateSuperConstructorCall(const Class& cls,
                                           LocalVariable* receiver) {
   const intptr_t supercall_pos = token_index_;
   const Class& super_class = Class::Handle(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)) {
     return;
   }
   String& ctor_name = String::Handle(super_class.Name());
   String& ctor_suffix = String::Handle(String::NewSymbol("."));
   ctor_name = String::Concat(ctor_name, ctor_suffix);
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
-  // implicit 'this' parameter is the only argument.
+  // Implicit 'this' parameter is the first argument.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, *receiver);
   arguments->Add(implicit_argument);
+  // Implicit constructor phase parameter is second argument.
+  AstNode* phase_parameter =
+      new LiteralNode(supercall_pos,
+                      Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
+  arguments->Add(phase_parameter);
   const Function& super_ctor = Function::ZoneHandle(
       super_class.LookupConstructor(ctor_name));
   if (super_ctor.IsNull() ||
       !super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names())) {
     ErrorMsg(supercall_pos,
              "unresolved implicit call to super constructor '%s()'",
              String::Handle(super_class.Name()).ToCString());
   }
   CheckFunctionIsCallable(supercall_pos, super_ctor);
@@ skipping 14 matching lines @@
   String& ctor_suffix = String::Handle(String::NewSymbol("."));
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_suffix = String::Concat(
         ctor_suffix, *ExpectIdentifier("constructor name expected"));
   }
   ctor_name = String::Concat(ctor_name, ctor_suffix);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("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 constructor 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(Smi::New(Function::kCtorPhaseAll)));
+  arguments->Add(phase_parameter);
   // 'this' parameter must not be accessible to the other super call arguments.
   receiver->set_invisible(true);
-  ArgumentListNode* arguments =
-      ParseActualParameters(implicit_argument, kAllowConst);
+  ParseActualParameters(arguments, kAllowConst);
   receiver->set_invisible(false);
+
   // Resolve the constructor.
   const Function& super_ctor = Function::ZoneHandle(
       super_class.LookupConstructor(ctor_name));
   if (super_ctor.IsNull() ||
       !super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names())) {
     ErrorMsg(supercall_pos,
              "super class constructor '%s' not found",
              ctor_name.ToCString());
   }
@@ skipping 83 matching lines @@
       FieldInitExpression initializer;
       initializer.inst_field = &field;
       initializer.expr = init_expr;
       initializers->Add(initializer);
     }
   }
   SetPosition(saved_pos);
 }
 
 
-void Parser::ParseInitializers(const Class& cls) {
+void Parser::ParseInitializers(const Class& cls, LocalVariable* receiver) {
   TRACE_PARSER("ParseInitializers");
-  LocalVariable* receiver = current_block_->scope->VariableAt(0);
-  AstNode* super_init_statement = NULL;
+  bool super_init_seen = false;
   if (CurrentToken() == Token::kCOLON) {
     if ((LookaheadToken(1) == Token::kTHIS) &&
         ((LookaheadToken(2) == Token::kLPAREN) ||
         ((LookaheadToken(2) == Token::kPERIOD) &&
             (LookaheadToken(4) == Token::kLPAREN)))) {
       // Either we see this(...) or this.xxx(...) which is a
       // redirected constructor. We don't need to check whether
       // const fields are initialized. The other constructor will
       // guarantee that.
       ConsumeToken();  // Colon.
       ParseConstructorRedirection(cls, receiver);
       return;
     }
-
     do {
       ConsumeToken();  // Colon or comma.
+      AstNode* init_statement;
       if (CurrentToken() == Token::kSUPER) {
-        if (super_init_statement != NULL) {
+        if (super_init_seen) {
           ErrorMsg("Duplicate call to super constructor");
         }
-        super_init_statement = ParseSuperInitializer(cls, receiver);
+        init_statement = ParseSuperInitializer(cls, receiver);
+        super_init_seen = true;
       } else {
-        AstNode* init_statement = ParseInitializer(cls, receiver);
-        current_block_->statements->Add(init_statement);
+        init_statement = ParseInitializer(cls, receiver);
       }
+      current_block_->statements->Add(init_statement);
     } while (CurrentToken() == Token::kCOMMA);
   }
-
-  if (super_init_statement != NULL) {
-    // Move explicit supercall to the end of the initializer list to
-    // avoid executing constructor code on partially initialized objects.
-    // TODO(hausner): Fix issue 4995181, evaluation order of constructor
-    // initializer lists.
-    current_block_->statements->Add(super_init_statement);
-  } else {
+  if (!super_init_seen) {
     // Generate implicit super() if we haven't seen an explicit super call
     // or constructor redirection.
-    GenerateSuperInitializerCall(cls, receiver);
+    GenerateSuperConstructorCall(cls, receiver);
   }
-
   CheckConstFieldsInitialized(cls);
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   ASSERT(CurrentToken() == Token::kTHIS);
   intptr_t call_pos = token_index_;
   ConsumeToken();
   String& ctor_name = String::Handle(cls.Name());
   String& ctor_suffix = String::Handle(String::NewSymbol("."));
 
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_suffix = String::Concat(
         ctor_suffix, *ExpectIdentifier("constructor name expected"));
   }
   ctor_name = String::Concat(ctor_name, ctor_suffix);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("parameter list expected");
   }
-  // 'this' parameter is the first argument to super class constructor.
+
+  ArgumentListNode* arguments = new ArgumentListNode(call_pos);
+  // 'this' parameter is the first argument to constructor.
   AstNode* implicit_argument = new LoadLocalNode(call_pos, *receiver);
-  ArgumentListNode* arguments =
-      ParseActualParameters(implicit_argument, kAllowConst);
+  arguments->Add(implicit_argument);
+  // Constructor 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);
+  ParseActualParameters(arguments, kAllowConst);
 
   // Resolve the constructor.
   const Function& redirect_ctor = Function::ZoneHandle(
       cls.LookupConstructor(ctor_name));
   if (redirect_ctor.IsNull() ||
       !redirect_ctor.AreValidArguments(arguments->length(),
                                        arguments->names())) {
     ErrorMsg(call_pos, "constructor '%s' not found",
              ctor_name.ToCString());
   }
   CheckFunctionIsCallable(call_pos, redirect_ctor);
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
   intptr_t ctor_pos = token_index_;
 
   // Implicit 'this' is the only parameter/local variable.
   OpenFunctionBlock(func);
 
-
   // Parse expressions of instance fields that have an explicit
   // initializers.
   GrowableArray<FieldInitExpression> initializers;
   Class& cls = Class::Handle(func.owner());
   ParseInitializedInstanceFields(cls, &initializers);
 
   LocalVariable* receiver = new LocalVariable(
       ctor_pos,
       String::ZoneHandle(String::NewSymbol(kThisName)),
       Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(receiver);
 
+  LocalVariable* phase_parameter = new LocalVariable(
+       ctor_pos,
+       String::ZoneHandle(String::NewSymbol(kPhaseParameterName)),
+       Type::ZoneHandle(Type::DynamicType()));
+  current_block_->scope->AddVariable(phase_parameter);
+
   // Now that the "this" parameter is in scope, we can generate the code
   // to strore the initializer expressions in the respective instance fields.
   for (int i = 0; i < initializers.length(); i++) {
     const Field* field = initializers[i].inst_field;
     AstNode* instance = new LoadLocalNode(field->token_index(), *receiver);
     AstNode* field_init =
         new StoreInstanceFieldNode(field->token_index(),
                                    instance,
                                    *field,
                                    initializers[i].expr);
     current_block_->statements->Add(field_init);
   }
 
-  GenerateSuperInitializerCall(cls, receiver);
+  GenerateSuperConstructorCall(cls, receiver);
   CheckConstFieldsInitialized(cls);
 
   // Empty constructor body.
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter declaration
 // of function. Parse the formal parameters and code.
@@ skipping 19 matching lines @@
   // The first parameter of a factory is the TypeArguments vector of the type
   // of the instance to be allocated. We name this hidden parameter 'this'.
   const bool has_receiver = !func.IsClosureFunction() &&
       (!func.is_static() || func.IsConstructor() || func.IsFactory());
   const bool are_implicitly_final = func.is_const() && func.IsConstructor();
   const bool allow_explicit_default_values = true;
   ASSERT(CurrentToken() == Token::kLPAREN);
   if (has_receiver) {
     params.AddReceiver(token_index_);
   }
+  if (func.IsConstructor()) {
+    // Add implicit parameter for constructor phase.
+    params.AddFinalParameter(token_index_, kPhaseParameterName,
+                             &Type::ZoneHandle(Type::DynamicType()));
+  }
   if (are_implicitly_final) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   // The number of parameters and their type are not yet set in local functions,
   // since they are not 'top-level' parsed.
   if (func.IsLocalFunction()) {
     AddFormalParamsToFunction(&params, func);
   }
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(Type::Handle(func.result_type()).IsResolved());
   ASSERT(func.NumberOfParameters() == params.parameters->length());
 
   // If this is a constructor, initialize instance fields that have an
   // explicit initializer expression. This has to be done before code
   // for field initializer parameters are is generated.
   // NB: the instance field initializers have to be compiled before
   // the parameters are added to the scope, so that a parameter
   // name cannot shadow a name used in the field initializer expression.
+  SequenceNode* init_statements = NULL;
+  if (func.IsConstructor()) {
+    GrowableArray<FieldInitExpression> initializers;
+    ParseInitializedInstanceFields(cls, &initializers);
 
-  GrowableArray<FieldInitExpression> initializers;
-  if (func.IsConstructor()) {
-    ParseInitializedInstanceFields(cls, &initializers);
-  }
+    // Now populate function scope with the formal parameters.
+    AddFormalParamsToScope(&params, current_block_->scope);
+    LocalVariable* receiver = current_block_->scope->VariableAt(0);
 
-  // Now populate function scope with the formal parameters.
-  AddFormalParamsToScope(&params, current_block_->scope);
+    // Now that the "this" parameter is in scope, we can generate the code
+    // to strore the initializer expressions in the respective instance fields.
+    // We do this before the field parameters and the initializers from the
+    // constructor's initializer list get compiled.
+    OpenBlock();
+    if (initializers.length() > 0) {
+      for (int i = 0; i < initializers.length(); i++) {
+        const Field* field = initializers[i].inst_field;
+        AstNode* instance = new LoadLocalNode(field->token_index(), *receiver);
+        AstNode* field_init =
+            new StoreInstanceFieldNode(field->token_index(),
+                                       instance,
+                                       *field,
+                                       initializers[i].expr);
+        current_block_->statements->Add(field_init);
+      }
+    }
 
-  // Now that the "this" parameter is in scope, we can generate the code
-  // to strore the initializer expressions in the respective instance fields.
-  // We do this before the field parameters and the initializers from the
-  // constuctor's initializer list get compiled.
-  if (initializers.length() > 0) {
-    LocalVariable* receiver = current_block_->scope->VariableAt(0);
-    for (int i = 0; i < initializers.length(); i++) {
-      const Field* field = initializers[i].inst_field;
-      AstNode* instance = new LoadLocalNode(field->token_index(), *receiver);
-      AstNode* field_init =
-          new StoreInstanceFieldNode(field->token_index(),
-                                     instance,
-                                     *field,
-                                     initializers[i].expr);
-      current_block_->statements->Add(field_init);
+    // Turn formal field parameters into field initializers or report error
+    // if the function is not a constructor
+    if (params.has_field_initializer) {
+      for (int i = 0; i < params.parameters->length(); i++) {
+        ParamDesc& param = (*params.parameters)[i];
+        if (param.is_field_initializer) {
+          if (!func.IsConstructor()) {
+            ErrorMsg(param.name_pos,
+                     "field initializer only allowed in constructors");
+          }
+
+          const String& field_name = *param.name;
+          Field& field = Field::ZoneHandle(cls.LookupInstanceField(field_name));
+          if (field.IsNull()) {
+            ErrorMsg(param.name_pos,
+                     "unresolved reference to instance field '%s'",
+                     field_name.ToCString());
+          }
+          const String& mangled_name =
+              String::ZoneHandle(MangledInitParamName(field_name));
+          AstNode* instance = new LoadLocalNode(param.name_pos, *receiver);
+          LocalVariable* p =
+              current_block_->scope->LookupVariable(mangled_name, false);
+          ASSERT(p != NULL);
+          AstNode* value = new LoadLocalNode(param.name_pos, *p);
+          AstNode* initializer = new StoreInstanceFieldNode(
+              param.name_pos, instance, field, value);
+          current_block_->statements->Add(initializer);
+        }
+      }
     }
-  }
-
-  // Turn formal field parameters into field initializers or report error
-  // if the function is not a constructor
-  if (params.has_field_initializer) {
-    LocalVariable* receiver = current_block_->scope->VariableAt(0);
-    for (int i = 0; i < params.parameters->length(); i++) {
-      ParamDesc& param = (*params.parameters)[i];
-      if (param.is_field_initializer) {
-        if (!func.IsConstructor()) {
+    ParseInitializers(cls, receiver);
+    init_statements = CloseBlock();
+    LocalVariable* phase_param = LookupPhaseParameter();
+    AstNode* phase_value = new LoadLocalNode(token_index_, *phase_param);
+    AstNode* phase_check =
+        new BinaryOpNode(token_index_, Token::kBIT_AND,
+                phase_value,
+                new LiteralNode(token_index_,
+                        Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
+    AstNode* comparison =
+        new ComparisonNode(token_index_, Token::kNE_STRICT,
+                phase_check,
+                new LiteralNode(token_index_, Smi::ZoneHandle(Smi::New(0))));
+    AstNode* guarded_init_statements =
+        new IfNode(token_index_, comparison, init_statements, NULL);
+    current_block_->statements->Add(guarded_init_statements);
+  } else {
+    // Parsing a function that is not a constructor.
+    if (params.has_field_initializer) {
+      for (int i = 0; i < params.parameters->length(); i++) {
+        ParamDesc& param = (*params.parameters)[i];
+        if (param.is_field_initializer) {
           ErrorMsg(param.name_pos,
                    "field initializer only allowed in constructors");
         }
-
-        const String& field_name = *param.name;
-        Field& field = Field::ZoneHandle(cls.LookupInstanceField(field_name));
-        if (field.IsNull()) {
-          ErrorMsg(param.name_pos,
-                   "unresolved reference to instance field '%s'",
-                   field_name.ToCString());
-        }
-        const String& mangled_name =
-            String::ZoneHandle(MangledInitParamName(field_name));
-        AstNode* instance = new LoadLocalNode(param.name_pos, *receiver);
-        LocalVariable* p =
-            current_block_->scope->LocalLookupVariable(mangled_name);
-        ASSERT(p != NULL);
-        AstNode* value = new LoadLocalNode(param.name_pos, *p);
-        AstNode* initializer =
-            new StoreInstanceFieldNode(param.name_pos, instance, field, value);
-        current_block_->statements->Add(initializer);
       }
     }
-  }
-
-  if (func.IsConstructor()) {
-    ParseInitializers(cls);
+    // Populate function scope with the formal parameters.
+    AddFormalParamsToScope(&params, current_block_->scope);
   }
 
   if (FLAG_enable_type_checks &&
       (current_block_->scope->function_level() > 0)) {
     // We are parsing, but not compiling, a local function.
     // The instantiator may be required at run time for generic type checks.
     if ((current_class().NumTypeParameters() > 0) &&
         (!current_function().is_static() ||
          current_function().IsInFactoryScope())) {
       // Make sure that the receiver of the enclosing instance function
       // (or implicit first parameter of an enclosing factory) is marked as
       // captured if type checks are enabled, because they may access the
       // receiver to instantiate types.
       CaptureReceiver();
     }
   }
 
+  if (func.IsConstructor()) {
+    LocalVariable* receiver = current_block_->scope->VariableAt(0);
+    StaticCallNode* super_call = NULL;
+    ASSERT(init_statements != 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().IsConstructor()) {
+          super_call = static_call;
+          break;
+        }
+      }
+    }
+    if (super_call != NULL) {
+      // 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.
+      ArgumentListNode* ctor_args = super_call->arguments();
+      // The super initializer call has at least 2 arguments: the
+      // implicit receiver, and the hidden constructor phase.
+      ASSERT(ctor_args->length() >= 2);
+      for (int i = 2; i < ctor_args->length(); i++) {
+        AstNode* arg = ctor_args->NodeAt(i);
+        if (!arg->IsLoadLocalNode() && !arg->IsLiteralNode()) {
+          LocalVariable* temp =
+              CreateTempConstVariable(arg->token_index(), arg->id(), "sca");
+          AstNode* save_temp =
+              new StoreLocalNode(arg->token_index(), *temp, arg);
+          ctor_args->SetNodeAt(i, save_temp);
+        }
+      }
+    }
+    OpenBlock();
+    if (super_call != NULL) {
+      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(token_index_,
+                  Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
+
+      ArgumentListNode* super_call_args = new ArgumentListNode(token_index_);
+      // First argument is the receiver.
+      super_call_args->Add(new LoadLocalNode(token_index_, *receiver));
+      // Second argument is the constructor phase argument.
+      AstNode* phase_parameter =
+          new LiteralNode(token_index_,
+               Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody)));
+      super_call_args->Add(phase_parameter);
+      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(token_index_, lit->literal()));
+        } else {
+          ASSERT(arg->IsLoadLocalNode() || arg->IsStoreLocalNode());
+          if (arg->IsLoadLocalNode()) {
+            const LocalVariable& temp = arg->AsLoadLocalNode()->local();
+            super_call_args->Add(new LoadLocalNode(token_index_, temp));
+          } else if (arg->IsStoreLocalNode()) {
+            const LocalVariable& temp = arg->AsStoreLocalNode()->local();
+            super_call_args->Add(new LoadLocalNode(token_index_, temp));
+          }
+        }
+      }
+      ASSERT(super_ctor.AreValidArguments(super_call_args->length(),
+                                          super_call_args->names()));
+      current_block_->statements->Add(
+          new StaticCallNode(token_index_, super_ctor, super_call_args));
+    }
+  }
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     intptr_t expr_pos = token_index_;
     AstNode* expr = ParseExpr(kAllowConst);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
   } else if (IsLiteral("native")) {
     ParseNativeFunctionBlock(&params, func);
   } else if (CurrentToken() == Token::kSEMICOLON) {
     ConsumeToken();
     ASSERT(func.IsConstructor());
     // Some constructors have no function body.
   } else {
     UnexpectedToken();
   }
+  if (func.IsConstructor()) {
+    SequenceNode* ctor_block = CloseBlock();
+    LocalVariable* phase_param = LookupPhaseParameter();
+    AstNode* phase_value = new LoadLocalNode(token_index_, *phase_param);
+    AstNode* phase_check =
+        new BinaryOpNode(token_index_, Token::kBIT_AND,
+                phase_value,
+                new LiteralNode(token_index_,
+                        Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody))));
+    AstNode* comparison =
+    new ComparisonNode(token_index_, Token::kNE_STRICT,
+            phase_check,
+            new LiteralNode(token_index_, Smi::ZoneHandle(Smi::New(0))));
+    AstNode* guarded_block_statements =
+        new IfNode(token_index_, comparison, ctor_block, NULL);
+    current_block_->statements->Add(guarded_block_statements);
+  }
 
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 void Parser::SkipIf(Token::Kind token) {
   if (CurrentToken() == token) {
     ConsumeToken();
   }
@@ skipping 127 matching lines @@
   const bool has_this_param =
       !method->has_static || method->IsConstructor() || method->has_factory;
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values =
       (!method->has_abstract && !members->is_interface());
   const intptr_t formal_param_pos = token_index_;
   method->params.Clear();
   if (has_this_param) {
     method->params.AddReceiver(formal_param_pos);
   }
+  // Constructors have an implicit parameter for the constructor phase.
+  if (method->IsConstructor()) {
+    method->params.AddFinalParameter(token_index_, kPhaseParameterName,
+                                     &Type::ZoneHandle(Type::DynamicType()));
+  }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &method->params);
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
     if (method->IsGetter()) {
       expected_num_parameters = (method->has_static) ? 0 : 1;
       method->name = &String::ZoneHandle(Field::GetterName(*method->name));
     } else {
@@ skipping 491 matching lines @@
   cls.SetFunctions(Array::Handle(NewArray<Function>(members.functions())));
   classes->Add(&cls);
 }
 
 
 // 1. Add an implicit constructor if no explicit constructor is present.
 // 2. Check for cycles in constructor redirection.
 void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Add an implicit constructor if no explicit constructor is present.
   if (!class_desc->has_constructor()) {
-    // The implicit constructor is unnamed, has no parameter, and contains
-    // a supercall in the initializer list.
+    // The implicit constructor is unnamed, has no explicit parameter,
+    // and contains a supercall in the initializer list.
     String& ctor_name = String::ZoneHandle(
         String::Concat(class_desc->class_name(),
                        String::Handle(String::NewSymbol("."))));
     ctor_name = String::NewSymbol(ctor_name);
     Function& ctor = Function::ZoneHandle(
         Function::New(ctor_name,
                       RawFunction::kConstructor,
                       /* is_static = */ false,
                       /* is_const = */ false,
                       class_desc->token_pos()));
     ParamList params;
+    // Add implicit 'this' parameter.
     params.AddReceiver(token_index_);
+    // Add implicit parameter for constructor phase.
+    params.AddFinalParameter(token_index_, kPhaseParameterName,
+                             &Type::ZoneHandle(Type::DynamicType()));
+
     AddFormalParamsToFunction(&params, ctor);
     // TODO(regis): What are the type arguments?
     Type& result_type = Type::ZoneHandle(
         Type::NewRawType(Class::Handle(class_desc->clazz())));
     ctor.set_result_type(result_type);
     class_desc->AddFunction(&ctor);
   }
 
   // Check for cycles in constructor redirection.
   const GrowableArray<MemberDesc>& members = class_desc->members();
@@ skipping 859 matching lines @@
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope,
                                       bool test_only) {
   const String& this_name = String::Handle(String::NewSymbol(kThisName));
   return from_scope->LookupVariable(this_name, test_only);
 }
 
 
+LocalVariable* Parser::LookupPhaseParameter() {
+  const String& phase_name =
+      String::Handle(String::NewSymbol(kPhaseParameterName));
+  const bool kTestOnly = false;
+  return current_block_->scope->LookupVariable(phase_name, kTestOnly);
+}
+
+
 void Parser::CaptureReceiver() {
   ASSERT(current_block_->scope->function_level() > 0);
   const bool kTestOnly = false;
   // Side effect of lookup captures the receiver variable.
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   ASSERT(receiver != NULL);
 }
 
 
 AstNode* Parser::LoadReceiver(intptr_t token_pos) {
@@ skipping 1980 matching lines @@
       Unimplemented("incr operation not implemented");
     }
     expr = incr_op_node;
   } else {
     expr = ParsePostfixExpr();
   }
   return expr;
 }
 
 
-ArgumentListNode* Parser::ParseActualParameters(AstNode* implicit_argument,
-                                                bool require_const) {
+ArgumentListNode* Parser::ParseActualParameters(
+                              ArgumentListNode* implicit_arguments,
+                              bool require_const) {
   TRACE_PARSER("ParseActualParameters");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const bool saved_mode = SetAllowFunctionLiterals(true);
-  ArgumentListNode* arguments = new ArgumentListNode(token_index_);
-  if (implicit_argument != NULL) {
-    arguments->Add(implicit_argument);
+  ArgumentListNode* arguments;
+  if (implicit_arguments == NULL) {
+    arguments = new ArgumentListNode(token_index_);
+  } else {
+    arguments = implicit_arguments;
   }
   GrowableArray<const String*> names;
   bool named_argument_seen = false;
   if (LookaheadToken(1) != Token::kRPAREN) {
     do {
       ASSERT((CurrentToken() == Token::kLPAREN) ||
              (CurrentToken() == Token::kCOMMA));
       ConsumeToken();
       if ((CurrentToken() == Token::kIDENT) &&
           (LookaheadToken(1) == Token::kCOLON)) {
@@ skipping 579 matching lines @@
     field.set_value(const_value);
   }
 }
 
 
 RawInstance* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
-  GrowableArray<const Object*> arg_values(arguments->length() + 1);
+  // +2 for implicit receiver and constructor phase arguments.
+  GrowableArray<const Object*> arg_values(arguments->length() + 2);
   Instance& instance = Instance::Handle();
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class);
     if (!type_arguments.IsNull()) {
       // TODO(regis): Where should we check the constraints on type parameters?
       if (!type_arguments.IsInstantiated()) {
         ErrorMsg("type must be constant in const constructor");
       }
       instance.SetTypeArguments(type_arguments);
     }
     arg_values.Add(&instance);
+    arg_values.Add(&Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   } else {
     // Prepend type_arguments to list of arguments to factory.
     ASSERT(type_arguments.IsZoneHandle());
     arg_values.Add(&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.Add(&arg->AsLiteralNode()->literal());
@@ skipping 644 matching lines @@
   }
 
   // Parse constructor parameters.
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
   ArgumentListNode* arguments = ParseActualParameters(NULL, is_const);
 
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
-  intptr_t arguments_length = arguments->length() + 1;
+  // A constructor has a second implicit 'phase' parameter.
+  intptr_t arguments_length = arguments->length() + 2;
 
   if (type_class.is_interface()) {
     // We need to make sure that an appropriate constructor is
     // declared in the interface.
     const String& constructor_name =
         BuildConstructorName(type_class_name, named_constructor);
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     Function& constructor = Function::ZoneHandle(
         type_class.LookupConstructor(constructor_name));
@@ skipping 44 matching lines @@
 
   // Make sure that an appropriate constructor exists.
   const String& constructor_name =
       BuildConstructorName(type_class_name, named_constructor);
   const String& external_constructor_name =
       (named_constructor ? constructor_name : type_class_name);
   Function& constructor = Function::ZoneHandle(
       type_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = type_class.LookupFactory(constructor_name);
+    // A factory does not have the implicit 'phase' parameter.
+    arguments_length -= 1;
   }
   if (constructor.IsNull()) {
     ErrorMsg(new_pos, "class '%s' has no constructor or factory named '%s'",
              String::Handle(type_class.Name()).ToCString(),
              external_constructor_name.ToCString());
   }
   if (!constructor.AreValidArguments(arguments_length, arguments->names())) {
     ErrorMsg(new_pos, "invalid arguments passed to constructor '%s' "
              "for class '%s'",
              external_constructor_name.ToCString(),
@@ skipping 461 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart