Implement forwarding constructors for mixins

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/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 1795 matching lines @@
       // No function or field exists of the specified field_name.
       // Emit a StaticGetterNode anyway, so that noSuchMethod gets called.
     }
   }
   return new StaticGetterNode(
       field_pos, implicit_argument, true, super_class, field_name);
 }
 
 
 void Parser::GenerateSuperConstructorCall(const Class& cls,
-                                          LocalVariable* receiver) {
+                                          LocalVariable* receiver,
+                                          ArgumentListNode* forwarding_args) {
   const intptr_t supercall_pos = TokenPos();
   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 &&
        Class::Handle(super_class.SuperClass()).IsObjectClass())) {
     return;
   }
-  String& ctor_name = String::Handle(super_class.Name());
-  ctor_name = String::Concat(ctor_name, Symbols::Dot());
+  String& super_ctor_name = String::Handle(super_class.Name());
+  super_ctor_name = String::Concat(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.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
                       Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   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(current_function().name());
+    String& class_name = String::Handle(cls.Name());
+    if (ctor_name.Length() > class_name.Length() + 1) {
+      // Generating a forwarding call to a named constructor 'C.n'.
+      // Add the constructor name 'n' to the super constructor.
+      ctor_name = String::SubString(ctor_name, class_name.Length() + 1);
+      super_ctor_name = String::Concat(super_ctor_name, ctor_name);
+    }
+  }
+
+  // Resolve super constructor function and check arguments.
   const Function& super_ctor = Function::ZoneHandle(
-      super_class.LookupConstructor(ctor_name));
+      super_class.LookupConstructor(super_ctor_name));
   if (super_ctor.IsNull()) {
       ErrorMsg(supercall_pos,
                "unresolved implicit call to super constructor '%s()'",
                String::Handle(super_class.Name()).ToCString());
   }
   if (current_function().is_const() && !super_ctor.is_const()) {
     ErrorMsg(supercall_pos, "implicit call to non-const super constructor");
   }
 
   String& error_message = String::Handle();
@@ skipping 272 matching lines @@
         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);
+    GenerateSuperConstructorCall(cls, receiver, NULL);
   }
   CheckConstFieldsInitialized(cls);
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   TRACE_PARSER("ParseConstructorRedirection");
   ASSERT(CurrentToken() == Token::kTHIS);
   const intptr_t call_pos = TokenPos();
@@ skipping 40 matching lines @@
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
   const intptr_t ctor_pos = TokenPos();
   OpenFunctionBlock(func);
   const Class& cls = Class::Handle(func.Owner());
+
   LocalVariable* receiver = new LocalVariable(
       ctor_pos,
       Symbols::This(),
       Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(receiver);
 
   LocalVariable* phase_parameter = new LocalVariable(
        ctor_pos,
        Symbols::PhaseParameter(),
        Type::ZoneHandle(Type::SmiType()));
   current_block_->scope->AddVariable(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(cls, receiver, &initialized_fields);
   receiver->set_invisible(false);
 
-  GenerateSuperConstructorCall(cls, receiver);
+  // If the class of this implicit constructor is a mixin application class,
+  // it is a forwarding constructor of the mixin. The forwarding
+  // constructor initializes the instance fields that have initializer
+  // expressions and then calls the respective super constructor with
+  // the same name and number of parameters.
+  ArgumentListNode* forwarding_args = NULL;
+  if (cls.mixin() != Type::null()) {
+    // At this point we don't support forwarding constructors
+    // that have optional parameters because we don't know the default
+    // values of the optional parameters. We would have to compile the super
+    // constructor to get the default values. Also, the spec is not clear
+    // whether optional parameters are even allowed in this situation.
+    // TODO(hausner): Remove this limitation if the language spec indeed
+    // allows optional parameters.
+    if (func.HasOptionalParameters()) {
+      ErrorMsg(ctor_pos,
+               "forwarding constructors must not have optional parameters");
+    }
+
+    // Prepare user-defined arguments to be forwarded to super call.
+    // The first user-defined argument is at position 2.
+    forwarding_args = new ArgumentListNode(ctor_pos);
+    for (int i = 2; i < func.NumParameters(); i++) {
+      LocalVariable* param = new LocalVariable(
+          ctor_pos,
+          String::ZoneHandle(func.ParameterNameAt(i)),
+          Type::ZoneHandle(Type::DynamicType()));
+      current_block_->scope->AddVariable(param);
+      forwarding_args->Add(new LoadLocalNode(ctor_pos, param));
+    }
+  }
+
+  GenerateSuperConstructorCall(cls, receiver, forwarding_args);
   CheckConstFieldsInitialized(cls);
 
   // Empty constructor body.
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // Helper function to make the first num_variables variables in the
 // given scope visible/invisible.
@@ skipping 625 matching lines @@
       }
       SkipToMatchingParenthesis();
     } else {
       SkipInitializers();
     }
   }
 
   // Only constructors can redirect to another method.
   ASSERT((method->redirect_name == NULL) || method->IsConstructor());
 
-  intptr_t method_end_pos = method_pos;
+  intptr_t method_end_pos = TokenPos();
   if ((CurrentToken() == Token::kLBRACE) ||
       (CurrentToken() == Token::kARROW)) {
     if (method->has_abstract) {
       ErrorMsg(method->name_pos,
                "abstract method '%s' may not have a function body",
                method->name->ToCString());
     } else if (method->has_external) {
       ErrorMsg(method->name_pos,
                "external method '%s' may not have a function body",
                method->name->ToCString());
@@ skipping 694 matching lines @@
 }
 
 
 // Add an implicit constructor to the given class.
 void Parser::AddImplicitConstructor(const Class& cls) {
   // The implicit constructor is unnamed, has no explicit parameter.
   String& ctor_name = String::ZoneHandle(cls.Name());
   ctor_name = String::Concat(ctor_name, Symbols::Dot());
   ctor_name = Symbols::New(ctor_name);
   // To indicate that this is an implicit constructor, we set the
-  // token position is the same as the token position of the class.
+  // token position and end token position of the function
+  // to the token position of the class.
   Function& ctor = Function::Handle(
       Function::New(ctor_name,
                     RawFunction::kConstructor,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     cls,
                     cls.token_pos()));
+  ctor.set_end_token_pos(ctor.token_pos());
+
   ParamList params;
   // Add implicit 'this' parameter. We don't care about the specific type
   // and just specify dynamic.
   const Type& receiver_type = Type::Handle(Type::DynamicType());
   params.AddReceiver(&receiver_type, cls.token_pos());
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(cls.token_pos(),
                            &Symbols::PhaseParameter(),
                            &Type::ZoneHandle(Type::SmiType()));
 
@@ skipping 493 matching lines @@
     mixin_app_name = String::Concat(mixin_app_name, Symbols::Ampersand());
     mixin_app_name = String::Concat(mixin_app_name,
                                     String::Handle(mixin_type.ClassName()));
     mixin_app_name = Symbols::New(mixin_app_name);
 
     mixin_application = Class::New(mixin_app_name, script_, mixin_pos);
     mixin_application.set_super_type(mixin_super_type);
     mixin_application.set_mixin(Type::Cast(mixin_type));
     mixin_application.set_library(library_);
     mixin_application.set_is_synthesized_class();
-    AddImplicitConstructor(mixin_application);
+
     // Add the mixin type to the interfaces that the mixin application
     // class implements. This is necessary so that type tests work.
     mixin_application_interfaces = Array::New(1);
     mixin_application_interfaces.SetAt(0, mixin_type);
     mixin_application.set_interfaces(mixin_application_interfaces);
 
     // For the type arguments of the mixin application type, we need
     // a copy of the type arguments to the mixin type. The simplest way
     // to get the copy is to rewind the parser, parse the mixin type
     // again and steal its type arguments.
@@ skipping 711 matching lines @@
 // Populate the parameter type array and parameter name array of the function
 // with the formal parameter types and names.
 void Parser::AddFormalParamsToFunction(const ParamList* params,
                                        const Function& func) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT((params->num_optional_parameters > 0) ==
          (params->has_optional_positional_parameters ||
           params->has_optional_named_parameters));
   if (!Utils::IsInt(16, params->num_fixed_parameters) ||
       !Utils::IsInt(16, params->num_optional_parameters)) {
-    ErrorMsg("too many formal parameters");
+    ErrorMsg(func.token_pos(), "too many formal parameters");
   }
   func.set_num_fixed_parameters(params->num_fixed_parameters);
   func.SetNumOptionalParameters(params->num_optional_parameters,
                                 params->has_optional_positional_parameters);
   const int num_parameters = params->parameters->length();
   ASSERT(num_parameters == func.NumParameters());
   func.set_parameter_types(Array::Handle(Array::New(num_parameters,
                                                     Heap::kOld)));
   func.set_parameter_names(Array::Handle(Array::New(num_parameters,
                                                     Heap::kOld)));
@@ skipping 5237 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart