Keep track of type parameter processing in mixin application classes.

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 1622 matching lines @@
   return closure.raw();
 }
 
 
 void Class::set_signature_function(const Function& value) const {
   ASSERT(value.IsClosureFunction() || value.IsSignatureFunction());
   StorePointer(&raw_ptr()->signature_function_, value.raw());
 }
 
 
-void Class::set_class_state(RawClass::ClassState state) const {
-  ASSERT((state == RawClass::kAllocated) ||
-         (state == RawClass::kPreFinalized) ||
-         (state == RawClass::kFinalized));
-  set_state_bits(StateBits::update(state, raw_ptr()->state_bits_));
-}
-
-
 void Class::set_state_bits(intptr_t bits) const {
   raw_ptr()->state_bits_ = static_cast<uint16_t>(bits);
 }
 
 
 void Class::set_library(const Library& value) const {
   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() const {
+  if (IsMixinApplication() && !is_mixin_type_applied()) {
+    ClassFinalizer::ApplyMixinType(*this);
+  }
   if (type_parameters() == TypeArguments::null()) {
     return 0;
   }
   const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   return type_params.Length();
 }
 
 
 intptr_t Class::NumTypeArguments() const {
   // To work properly, this call requires the super class of this class to be
-  // resolved, which is checked by the SuperClass() call.
+  // resolved, which is checked by the type_class() call on the super type.
+  // Note that calling type_class() on a MixinAppType fails.
   Isolate* isolate = Isolate::Current();
   ReusableHandleScope reused_handles(isolate);
   Class& cls = reused_handles.ClassHandle();
   TypeArguments& type_params = reused_handles.TypeArgumentsHandle();
   AbstractType& sup_type = reused_handles.AbstractTypeHandle();
   cls ^= raw();
   intptr_t num_type_args = 0;
 
   do {
     if (cls.IsSignatureClass()) {
       Function& signature_fun = reused_handles.FunctionHandle();
       signature_fun ^= cls.signature_function();
       if (!signature_fun.is_static() &&
           !signature_fun.HasInstantiatedSignature()) {
         cls = signature_fun.Owner();
       }
     }
-    if (cls.type_parameters() != TypeArguments::null()) {
+    // Calling NumTypeParameters() on a mixin application class will setup the
+    // type parameters if not already done.
+    if (cls.NumTypeParameters() > 0) {
       type_params ^= cls.type_parameters();
       num_type_args += type_params.Length();
     }
 
     // Super type of Object class is null.
     if (cls.super_type() == AbstractType::null() ||
         cls.super_type() == isolate->object_store()->object_type()) {
       break;
     }
     sup_type ^= cls.super_type();
@@ skipping 641 matching lines @@
 void Class::set_is_const() const {
   set_state_bits(ConstBit::update(true, raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_mixin_typedef() const {
   set_state_bits(MixinTypedefBit::update(true, raw_ptr()->state_bits_));
 }
 
 
+void Class::set_is_mixin_type_applied() const {
+  set_state_bits(MixinTypeAppliedBit::update(true, raw_ptr()->state_bits_));
+}
+
+
 void Class::set_is_finalized() const {
   ASSERT(!is_finalized());
-  set_state_bits(StateBits::update(RawClass::kFinalized,
-                                   raw_ptr()->state_bits_));
+  set_state_bits(ClassFinalizedBits::update(RawClass::kFinalized,
+                                            raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_prefinalized() const {
   ASSERT(!is_finalized());
-  set_state_bits(StateBits::update(RawClass::kPreFinalized,
-                                   raw_ptr()->state_bits_));
+  set_state_bits(ClassFinalizedBits::update(RawClass::kPreFinalized,
+                                            raw_ptr()->state_bits_));
 }
 
 
 void Class::set_is_marked_for_parsing() const {
   set_state_bits(MarkedForParsingBit::update(true, raw_ptr()->state_bits_));
 }
 
 
 void Class::reset_is_marked_for_parsing() const {
   set_state_bits(MarkedForParsingBit::update(false, raw_ptr()->state_bits_));
 }
 
 
 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();
+}
+
+
 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 12507 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart