Create implicit super constructor call if necessary

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 1181 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,
+                                          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.
+  AstNode* implicit_argument = new LoadLocalNode(supercall_pos, *receiver);
+  arguments->Add(implicit_argument);
+  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);
+  current_block_->statements->Add(
+      new StaticCallNode(supercall_pos, super_ctor, arguments));
+}
+
+
 AstNode* Parser::ParseSuperInitializer(const Class& cls,
                                        LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
   const intptr_t supercall_pos = token_index_;
   ConsumeToken();
   const Class& super_class = Class::Handle(cls.SuperClass());
   ASSERT(!super_class.IsNull());
   String& ctor_name = String::Handle(super_class.Name());
   String& ctor_suffix = String::Handle(String::NewSymbol("."));
@@ skipping 109 matching lines @@
       FieldInitExpression initializer;
       initializer.inst_field = &field;
       initializer.expr = init_expr;
       initializers->Add(initializer);
     }
   }
   SetPosition(saved_pos);
 }
 
 
-void Parser::ParseInitializers(const Class& cls, LocalVariable* receiver) {
+void Parser::ParseInitializers(const Class& cls) {
   TRACE_PARSER("ParseInitializers");
-  AstNode* init_statement = NULL;
-  AstNode* super_init_statement = NULL;
-  // TODO(4995181): Allow super initializer to appear in any position
-  // of the initializer list.
-  if (CurrentToken() == Token::kSUPER) {
-    super_init_statement = ParseSuperInitializer(cls, receiver);
-  } else {
-    init_statement = ParseInitializer(cls, receiver);
-    current_block_->statements->Add(init_statement);
+  LocalVariable* receiver = current_block_->scope->VariableAt(0);
+  bool super_init_seen = false;
+  if (CurrentToken() == Token::kCOLON) {
+    ConsumeToken();
+    if ((CurrentToken() == Token::kTHIS) &&
+        ((LookaheadToken(1) == Token::kLPAREN) ||
+        ((LookaheadToken(1) == Token::kPERIOD) &&
+            (LookaheadToken(3) == 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.
+      ParseConstructorRedirection(cls, receiver);
+      return;
+    }
+
+    for (;;) {

[regis, 2011/10/13 19:32:29]

If you do not consume the colon above (and increment the look ahead count), you
can change this for loop to a more readable form:
do {
  ConsumeToken();
  ...
} while (CurrentToken() == Token::kCOMMA);

But it's fine if you leave it as is.
  

[hausner, 2011/10/13 20:24:09]

Nice idea. Done.

+      AstNode* init_statement = NULL;
+      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);
+      }
+      current_block_->statements->Add(init_statement);
+      if (CurrentToken() != Token::kCOMMA) {
+        break;
+      }
+      ConsumeToken();
+    }
   }
-  while (CurrentToken() == Token::kCOMMA) {
-    ConsumeToken();
-    init_statement = ParseInitializer(cls, receiver);
-    current_block_->statements->Add(init_statement);
+
+  // 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) {
+    GenerateSuperInitializerCall(cls, receiver);
   }
-  // The call to super constructor is to be done after all initializers.
-  if (super_init_statement != NULL) {
-    current_block_->statements->Add(super_init_statement);
-  }
+
+  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("."));
@@ skipping 53 matching lines @@
     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);
   }
 
-  // Super call to constructor of super class.
-  const Class& super_class = Class::Handle(cls.SuperClass());
-  ASSERT(!super_class.IsNull());
-  String& ctor_name = String::Handle(super_class.Name());
-  String& ctor_suffix = String::Handle(String::NewSymbol("."));
-  ctor_name = String::Concat(ctor_name, ctor_suffix);
-  ctor_name = String::NewSymbol(ctor_name);
-  ArgumentListNode* arguments = new ArgumentListNode(ctor_pos);
-  AstNode* implicit_argument = new LoadLocalNode(ctor_pos, *receiver);
-  arguments->Add(implicit_argument);
-  const Function& super_ctor = Function::ZoneHandle(
-      super_class.LookupConstructor(ctor_name));
-  if (super_ctor.IsNull() ||
-      !super_ctor.AreValidArgumentCounts(arguments->length(), 0)) {
-    ErrorMsg(ctor_pos,
-             "super class constructor '%s' not found",
-             ctor_name.ToCString());
-  }
-  current_block_->statements->Add(
-      new StaticCallNode(ctor_pos, super_ctor, arguments));
-
+  GenerateSuperInitializerCall(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.
 SequenceNode* Parser::ParseFunc(const Function& func,
                                 Array& default_parameter_values) {
   if (IsLiteral("class")) {
     // Special case: implicit constructor. There is no source text to
     // parse. We just build the sequence node by hand.
     return MakeImplicitConstructor(func);
   }
 
+  const Class& cls = Class::Handle(func.owner());
+  ASSERT(!cls.IsNull());
+
   // Build local scope for function.
   OpenFunctionBlock(func);
 
   ParamList params;
   // Static functions do not have a receiver, except constructors, which are
   // passed the allocated but uninitialized instance to construct.
   // An instance closure may capture and access the receiver, but via the
   // context and not via the first formal parameter.
   // 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'.
@@ skipping 21 matching lines @@
 
   // 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.
 
   GrowableArray<FieldInitExpression> initializers;
   if (func.IsConstructor()) {
-    Class& cls = Class::Handle(func.owner());
     ParseInitializedInstanceFields(cls, &initializers);
   }
 
   // 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
   // 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) {
     LocalVariable* receiver = current_block_->scope->VariableAt(0);
-    Class& cls = Class::ZoneHandle(func.owner());
     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));
@@ skipping 10 matching lines @@
         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()) {
-    Class& cls = Class::ZoneHandle(func.owner());
-    bool initialized_check_needed = true;
-    if (CurrentToken() == Token::kCOLON) {
-      ConsumeToken();
-      LocalVariable* receiver = current_block_->scope->VariableAt(0);
-      ASSERT(receiver != NULL);
-      if ((CurrentToken() == Token::kTHIS) &&
-          ((LookaheadToken(1) == Token::kLPAREN) ||
-          ((LookaheadToken(1) == Token::kPERIOD) &&
-              (LookaheadToken(3) == 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.
-        initialized_check_needed = false;
-        ParseConstructorRedirection(cls, receiver);
-      } else {
-        ParseInitializers(cls, receiver);
-      }
-    }
-    if (initialized_check_needed) {
-      CheckConstFieldsInitialized(cls);
-    }
+    ParseInitializers(cls);
   }
 
   if (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 or
     // allocation of generic types.
     if (current_class().IsParameterized() &&
         (!current_function().is_static() ||
          current_function().IsInFactoryScope())) {
       // Make sure that the receiver of the enclosing instance function
@@ skipping 47 matching lines @@
       level++;
     } else if (CurrentToken() == Token::kRPAREN) {
       level--;
     }
     ConsumeToken();
   } while ((level > 0) && (CurrentToken() != Token::kEOS));
 }
 
 
 void Parser::SkipInitializers() {
-  if (CurrentToken() == Token::kSUPER) {
+  for (;;) {

[regis, 2011/10/13 19:32:29]

Same comment here about a do loop instead of a for(;;).
You could delay the consume on line 1818 and start here with
ASSERT(CurrentToken() == Token::kCOLON);

[hausner, 2011/10/13 20:24:09]

And done.

+    if (CurrentToken() == Token::kSUPER) {
+      ConsumeToken();
+      if (CurrentToken() == Token::kPERIOD) {
+        ConsumeToken();
+        ExpectIdentifier("identifier expected");
+      }
+      if (CurrentToken() != Token::kLPAREN) {
+        ErrorMsg("'(' expected");
+      }
+      SkipToMatchingParenthesis();
+    } else {
+      SkipIf(Token::kTHIS);
+      SkipIf(Token::kPERIOD);
+      ExpectIdentifier("identifier expected");
+      ExpectToken(Token::kASSIGN);
+      SetAllowFunctionLiterals(false);
+      SkipExpr();
+      SetAllowFunctionLiterals(true);
+    }
+    if (CurrentToken() != Token::kCOMMA) {
+      break;
+    }
     ConsumeToken();
-    if (CurrentToken() == Token::kPERIOD) {
-      ConsumeToken();
-      ExpectIdentifier("identifier expected");
-    }
-    if (CurrentToken() != Token::kLPAREN) {
-      ErrorMsg("'(' expected");
-    }
-    SkipToMatchingParenthesis();
-  } else {
-    SkipIf(Token::kTHIS);
-    SkipIf(Token::kPERIOD);
-    ExpectIdentifier("identifier expected");
-    ExpectToken(Token::kASSIGN);
-    SetAllowFunctionLiterals(false);
-    SkipExpr();
-    SetAllowFunctionLiterals(true);
-  }
-  while (CurrentToken() == Token::kCOMMA) {
-    ConsumeToken();
-    SkipIf(Token::kTHIS);
-    SkipIf(Token::kPERIOD);
-    ExpectIdentifier("instance field expected");
-    ExpectToken(Token::kASSIGN);
-    SetAllowFunctionLiterals(false);
-    SkipExpr();
-    SetAllowFunctionLiterals(true);
   }
 }
 
 
 void Parser::ParseQualIdent(QualIdent* qual_ident) {
   ASSERT(CurrentToken() == Token::kIDENT);
   if (!is_top_level_) {
     bool local_ident = ResolveIdentInLocalScope(token_index_,
                                                 *CurrentLiteral(),
                                                 NULL);
@@ skipping 5289 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart