Fix redirecting 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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 2331 matching lines @@
   initialized_fields->Add(field);
 }
 
 
 void Parser::ParseInitializers(const Class& cls,
                                LocalVariable* receiver,
                                GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializers");
   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_seen) {
           ErrorMsg("duplicate call to super constructor");
         }
         init_statement = ParseSuperInitializer(cls, receiver);
         super_init_seen = true;
       } else {
         init_statement = ParseInitializer(cls, receiver, initialized_fields);
       }
       current_block_->statements->Add(init_statement);
     } while (CurrentToken() == Token::kCOMMA);
   }
   if (!super_init_seen) {
     // Generate implicit super() if we haven't seen an explicit super call
     // or constructor redirection.
     GenerateSuperConstructorCall(cls, receiver, NULL);
   }
   CheckConstFieldsInitialized(cls);
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   TRACE_PARSER("ParseConstructorRedirection");
+  ExpectToken(Token::kCOLON);
   ASSERT(CurrentToken() == Token::kTHIS);
   const intptr_t call_pos = TokenPos();
   ConsumeToken();
   String& ctor_name = String::Handle(cls.Name());
 
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_name = String::Concat(ctor_name,
                                *ExpectIdentifier("constructor name expected"));
@@ skipping 160 matching lines @@
   }
   ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
   ASSERT(func.NumParameters() == params.parameters->length());
 
   // Now populate function scope with the formal parameters.
   AddFormalParamsToScope(&params, current_block_->scope);
 
-  // Initialize instance fields that have an explicit initializer expression.
-  // The formal parameter names must not be visible to the instance
-  // field initializer expressions, yet the parameters must be added to
-  // the scope so the expressions use the correct offsets for 'this' when
-  // storing values. We make the formal parameters temporarily invisible
-  // while parsing the instance field initializer expressions.
-  params.SetInvisible(true);
+  const bool is_redirecting_constructor =
+      (CurrentToken() == Token::kCOLON) &&
+          ((LookaheadToken(1) == Token::kTHIS) &&
+              ((LookaheadToken(2) == Token::kLPAREN) ||
+              ((LookaheadToken(2) == Token::kPERIOD) &&
+              (LookaheadToken(4) == Token::kLPAREN))));
+
   GrowableArray<Field*> initialized_fields;
-  LocalVariable* receiver = current_block_->scope->VariableAt(0);
+  LocalVariable* receiver = (*params.parameters)[0].var;
   OpenBlock();
-  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 or report error
-  // if the function is not a constructor.
+  // If this is not a redirecting constructor, initialize
+  // instance fields that have an explicit initializer expression.
+  if (!is_redirecting_constructor) {
+    // The formal parameter names must not be visible to the instance
+    // field initializer expressions, yet the parameters must be added to
+    // the scope so the expressions use the correct offsets for 'this' when
+    // 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) {
-    for (int i = 0; i < params.parameters->length(); i++) {
+    // First two parameters are implicit receiver and phase.
+    ASSERT(params.parameters->length() >= 2);
+    for (int i = 2; 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(cls.LookupInstanceField(field_name));
         if (field.IsNull()) {
           ErrorMsg(param.name_pos,
                    "unresolved reference to instance field '%s'",
                    field_name.ToCString());
         }
+        if (is_redirecting_constructor) {
+          ErrorMsg(param.name_pos,
+                   "redirecting constructors may not have "
+                   "initializing formal parameters");
+        }
         CheckDuplicateFieldInit(param.name_pos, &initialized_fields, &field);
         AstNode* instance = new LoadLocalNode(param.name_pos, receiver);
         // Initializing formals cannot be used in the explicit initializer
         // list, nor can they be used in the constructor body.
         // Thus, they are set to be invisible when added to the scope.
         LocalVariable* p = param.var;
         ASSERT(p != NULL);
         ASSERT(p->is_invisible());
         AstNode* value = new LoadLocalNode(param.name_pos, p);
         EnsureExpressionTemp();
         AstNode* initializer = new StoreInstanceFieldNode(
             param.name_pos, instance, field, value);
         current_block_->statements->Add(initializer);
       }
     }
   }
 
-  // Now parse the explicit initializer list or constructor redirection.
-  ParseInitializers(cls, receiver, &initialized_fields);
+  if (is_redirecting_constructor) {
+    ParseConstructorRedirection(cls, receiver);
+  } else {
+    ParseInitializers(cls, receiver, &initialized_fields);
+  }
 
   SequenceNode* init_statements = CloseBlock();
   if (init_statements->length() > 0) {
     // Generate guard around the initializer code.
     LocalVariable* phase_param = LookupPhaseParameter();
     AstNode* phase_value = new LoadLocalNode(TokenPos(), phase_param);
     AstNode* phase_check = new BinaryOpNode(
         TokenPos(), Token::kBIT_AND, phase_value,
         new LiteralNode(TokenPos(),
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
@@ skipping 26 matching lines @@
         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.
+    // 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);
@@ skipping 39 matching lines @@
       }
     }
     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) {
     ErrorMsg("constructors may not return a value");
   } else if (IsLiteral("native")) {
     ErrorMsg("native constructors not supported");
   } else if (CurrentToken() == Token::kSEMICOLON) {
     // Some constructors have no function body.
     ConsumeToken();
@@ skipping 7693 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart