Handle creating ParameterMirrors for the parameters of forwarding 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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 2439 matching lines @@
   receiver->set_invisible(false);
 
   // If the class of this implicit constructor is a mixin application alias,
   // it is a forwarding constructor of the aliased mixin application class.
   // 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 (current_class().is_mixin_app_alias() ||
-      current_class().IsMixinApplication()) {
+  if (current_class().IsMixinApplication()) {
     // 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");
@@ skipping 6550 matching lines @@
     if (node != NULL) {
       *node = new LoadLocalNode(ident_pos, local);
     }
     return true;
   }
 
   // Try to find the identifier in the class scope of the current class.
   // If the current class is the result of a mixin application, we must
   // use the class scope of the class from which the function originates.
   Class& cls = Class::Handle(isolate());
-  if (!current_class().IsMixinApplication()) {
+  if (!current_class().IsAnonymousMixinApplication()) {

[hausner, 2014/03/27 17:10:27]

I think this is wrong. The scoping is the same whether the mixin is anonymous or
named. You can add a test if you like.

OTOH, maybe I don't understand what the difference is between a mixin
application class and an anoymous mixin application class. Regis can comment if
I'm wrong.

[regis, 2014/03/27 18:23:58]

I think the change is correct. If the current class is a mixin application
alias, we should use it to resolve locals, such as its type parameters.

The confusion comes from the fact that this cl is changing names to match the
spec. However, the new names do not match the comments in the code anymore. This
is bad.

Before the change we had:
mixin application
mixin application alias

With this change, they become:
anonymous mixin application
mixin application

But the comments still refer to the previous terms.

I am not sure if it is worth using the terms of the spec, which does not know
anything about the implementation. I'd rather stick with mixin application and
mixin application alias, which makes IsAnonymousMixinApplication a bad name and
mostly reverts this cl.

See how I would fix this in object.cc

     cls = current_class().raw();
   } else {
     cls = parsed_function()->function().origin();
   }
   Function& func = Function::Handle(isolate(), Function::null());
   Field& field = Field::Handle(isolate(), Field::null());
 
   // First check if a field exists.
   field = cls.LookupField(ident);
   if (!field.IsNull()) {
@@ skipping 1750 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart