Implicitly move super constructor call

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 1345 matching lines @@
       initializers->Add(initializer);
     }
   }
   SetPosition(saved_pos);
 }
 
 
 void Parser::ParseInitializers(const Class& cls) {
   TRACE_PARSER("ParseInitializers");
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
-  bool super_init_seen = false;
+  AstNode* super_init_statement = NULL;
   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 = NULL;
       if (CurrentToken() == Token::kSUPER) {
-        if (super_init_seen) {
+        if (super_init_statement != NULL) {
           ErrorMsg("Duplicate call to super constructor");
         }
-        init_statement = ParseSuperInitializer(cls, receiver);
-        super_init_seen = true;
+        super_init_statement = ParseSuperInitializer(cls, receiver);
       } else {
-        init_statement = ParseInitializer(cls, receiver);
+        AstNode* init_statement = ParseInitializer(cls, receiver);
+        current_block_->statements->Add(init_statement);
       }
-      current_block_->statements->Add(init_statement);
     } while (CurrentToken() == Token::kCOMMA);
   }
 
-  // Generate implicit super() if we haven't seen an explicit super call
-  // or constructor redirection.
-  // 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_init_seen) {
+  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 {
+    // Generate implicit super() if we haven't seen an explicit super call
+    // or constructor redirection.
     GenerateSuperInitializerCall(cls, receiver);
   }
 
   CheckConstFieldsInitialized(cls);
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   ASSERT(CurrentToken() == Token::kTHIS);
@@ skipping 5590 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart