Register synthesized mixin application classes in the library and reuse them

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 2592 matching lines @@
 
 
 void Class::set_interfaces(const Array& value) const {
   // Verification and resolving of interfaces occurs in finalizer.
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->interfaces_, value.raw());
 }
 
 
 void Class::set_mixin(const Type& value) const {
-  // Resolution and application of mixin type occurs in finalizer.
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->mixin_, value.raw());
 }
 
 
 bool Class::IsMixinApplication() const {
   return mixin() != Type::null();
 }
 
 
@@ skipping 9608 matching lines @@
   return chars;
 }
 
 
 void BoundedType::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 intptr_t MixinAppType::token_pos() const {
-  return Class::Handle(MixinAppAt(0)).token_pos();
+  return AbstractType::Handle(MixinTypeAt(0)).token_pos();

[hausner, 2013/10/25 17:11:49]

Should this be the position of the super type instead of the first mixin? Before
this change, MixinTypeAt(0) was the super type.

[regis, 2013/10/25 18:34:25]

I think the position of the first mixin type is better. It used to be the
position of class MixinAppAt(0), which was already the position of the fist
mixin type. The super type was MixinAppAt(0)->super_type().

 }
 
 
 intptr_t MixinAppType::Depth() const {
-  const Array& mixin_apps = Array::Handle(mixins());
-  return mixin_apps.Length();
+  return Array::Handle(mixin_types()).Length();
 }
 
 
 RawString* MixinAppType::Name() const {
   return String::New("MixinAppType");
 }
 
 
 const char* MixinAppType::ToCString() const {
-  const char* format = "MixinAppType: super type: %s; first mixin app: %s";
+  const char* format = "MixinAppType: super type: %s; first mixin type: %s";
   const char* super_type_cstr = String::Handle(AbstractType::Handle(
-      SuperType()).Name()).ToCString();
-  const char* first_mixin_app_cstr = String::Handle(Class::Handle(
-      MixinAppAt(0)).Name()).ToCString();
+      super_type()).Name()).ToCString();
+  const char* first_mixin_type_cstr = String::Handle(AbstractType::Handle(
+      MixinTypeAt(0)).Name()).ToCString();
   intptr_t len = OS::SNPrint(
-      NULL, 0, format, super_type_cstr, first_mixin_app_cstr) + 1;
+      NULL, 0, format, super_type_cstr, first_mixin_type_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, format, super_type_cstr, first_mixin_app_cstr);
+  OS::SNPrint(chars, len, format, super_type_cstr, first_mixin_type_cstr);
   return chars;
 }
 
 
 void MixinAppType::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
-RawAbstractType* MixinAppType::SuperType() const {
-  return Class::Handle(MixinAppAt(0)).super_type();
+RawAbstractType* MixinAppType::MixinTypeAt(intptr_t depth) const {
+  return AbstractType::RawCast(Array::Handle(mixin_types()).At(depth));
 }
 
 
-RawClass* MixinAppType::MixinAppAt(intptr_t depth) const {
-  return Class::RawCast(Array::Handle(mixins()).At(depth));
+void MixinAppType::set_super_type(const AbstractType& value) const {
+  StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
 
-void MixinAppType::set_mixins(const Array& value) const {
-  StorePointer(&raw_ptr()->mixins_, value.raw());
+void MixinAppType::set_mixin_types(const Array& value) const {
+  StorePointer(&raw_ptr()->mixin_types_, value.raw());
 }
 
 
 RawMixinAppType* MixinAppType::New() {
   ASSERT(Isolate::Current()->object_store()->mixin_app_type_class() !=
          Class::null());
   // MixinAppType objects do not survive finalization, so allocate
   // on new heap.
   RawObject* raw = Object::Allocate(MixinAppType::kClassId,
                                     MixinAppType::InstanceSize(),
                                     Heap::kNew);
   return reinterpret_cast<RawMixinAppType*>(raw);
 }
 
 
-RawMixinAppType* MixinAppType::New(const Array& mixins) {
+RawMixinAppType* MixinAppType::New(const AbstractType& super_type,
+                                   const Array& mixin_types) {
   const MixinAppType& result = MixinAppType::Handle(MixinAppType::New());
-  result.set_mixins(mixins);
+  result.set_super_type(super_type);
+  result.set_mixin_types(mixin_types);
   return result.raw();
 }
 
 
 const char* Number::ToCString() const {
   // Number is an interface. No instances of Number should exist.
   UNREACHABLE();
   return "Number";
 }
 
@@ skipping 3272 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart