Handle creating ParameterMirrors for the parameters of forwarding constructors.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 2004 matching lines @@
   StorePointer(&raw_ptr()->library_, value.raw());
 }
 
 
 void Class::set_type_parameters(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->type_parameters_, value.raw());
 }
 
 
 intptr_t Class::NumTypeParameters(Isolate* isolate) const {
-  if (IsMixinApplication() && !is_mixin_type_applied()) {
+  if (IsAnonymousMixinApplication() && !is_mixin_type_applied()) {
     ClassFinalizer::ApplyMixinType(*this);
   }
   if (type_parameters() == TypeArguments::null()) {
     return 0;
   }
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(isolate);
   TypeArguments& type_params = isolate->TypeArgumentsHandle();
   type_params = type_parameters();
   return type_params.Length();
 }
 
 
 intptr_t Class::NumOwnTypeArguments() const {
   // Return cached value if already calculated.
   if (num_own_type_arguments() != kUnknownNumTypeArguments) {
     return num_own_type_arguments();
   }
   Isolate* isolate = Isolate::Current();
   const intptr_t num_type_params = NumTypeParameters();
   if (!FLAG_overlap_type_arguments ||
       (num_type_params == 0) ||
       (super_type() == AbstractType::null()) ||
       (super_type() == isolate->object_store()->object_type())) {
     set_num_own_type_arguments(num_type_params);
     return num_type_params;
   }
-  ASSERT(!IsMixinApplication() || is_mixin_type_applied());
+  ASSERT(!IsAnonymousMixinApplication() || is_mixin_type_applied());
   const AbstractType& sup_type = AbstractType::Handle(isolate, super_type());
   const TypeArguments& sup_type_args =
       TypeArguments::Handle(isolate, sup_type.arguments());
   if (sup_type_args.IsNull()) {
     // The super type is raw or the super class is non generic.
     // In either case, overlapping is not possible.
     set_num_own_type_arguments(num_type_params);
     return num_type_params;
   }
   const intptr_t num_sup_type_args = sup_type_args.Length();
@@ skipping 1116 matching lines @@
 }
 
 
 void Class::set_mixin(const Type& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->mixin_, value.raw());
 }
 
 
 bool Class::IsMixinApplication() const {
-  return mixin() != Type::null();
+  return mixin() != Type::null() || is_mixin_app_alias();

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

See my comment in parser.cc first.

I would not make this change. Things are getting very confusing if you consider
an alias to be a mixin application class.

We need to distance ourselves from the terminology of the spec.

 }
 
+
 bool Class::IsAnonymousMixinApplication() const {
   return IsMixinApplication() && !is_mixin_app_alias();

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

This is what you need to fix. IsAnonymousMixinApplication() is identical to
IsMixinApplication(). I think this was not your intent when you introduced it.

I think you can achieve what you need using only IsMixinApplication() and
is_mixin_app_alias().

 }
 
+
 void Class::set_patch_class(const Class& cls) const {
   ASSERT(patch_class() == Class::null());
   StorePointer(&raw_ptr()->patch_class_, cls.raw());
 }
 
 
 void Class::AddDirectSubclass(const Class& subclass) const {
   ASSERT(!subclass.IsNull());
   ASSERT(subclass.SuperClass() == raw());
   // Do not keep track of the direct subclasses of class Object.
@@ skipping 1868 matching lines @@
   ASSERT(IsFactory());
   Object& obj = Object::Handle(raw_ptr()->data_);
   if (obj.IsNull()) {
     obj = RedirectionData::New();
     set_data(obj);
   }
   RedirectionData::Cast(obj).set_target(target);
 }
 
 
+bool Function::IsForwardingConstructor() const {
+  if (!IsImplicitConstructor()) return false;
+  const Class& owner = Class::Handle(Owner());
+  return owner.IsMixinApplication();
+}
+
+
+RawFunction* Function::ForwardingTarget() const {
+  ASSERT(IsForwardingConstructor());
+  Object& obj = Object::Handle(raw_ptr()->data_);
+  ASSERT(!obj.IsNull());
+  return Function::Cast(obj).raw();

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

Asserting that obj is indeed a function?

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

I am pretty sure that the Cast checks the actual type in debug mode.

On a different note, I find it slightly hacky to stuff the function object into
the data_ field. You could use a RedirectionTarget object here as well. I
understand that you only need one field and this is wasteful to allocate a
RedirectionTarget object. Are you sure you do not need any other field, like a
type or an identifier? :-) That's fine you can leave it as is.

+}
+
+
+void Function::SetForwardingTarget(const Function& target) const {
+  ASSERT(IsForwardingConstructor());
+  ASSERT(Object::Handle(raw_ptr()->data_).IsNull());
+  set_data(target);
+}
+
+
 void Function::set_data(const Object& value) const {
   StorePointer(&raw_ptr()->data_, value.raw());
 }
 
 
 bool Function::IsInFactoryScope() const {
   if (!IsLocalFunction()) {
     return IsFactory();
   }
   Function& outer_function = Function::Handle(parent_function());
@@ skipping 12909 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart