Introduce class TypeRef in the VM to fully support recursive types.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 4150 matching lines @@
   virtual bool IsMalformed() const;
   virtual bool IsMalbounded() const;
   virtual bool IsMalformedOrMalbounded() const;
   virtual RawLanguageError* error() const { return raw_ptr()->error_; }
   virtual void set_error(const LanguageError& value) const;
   virtual bool IsResolved() const;  // Class and all arguments classes resolved.
   virtual bool HasResolvedTypeClass() const;  // Own type class resolved.
   virtual RawClass* type_class() const;
   void set_type_class(const Object& value) const;
   virtual RawUnresolvedClass* unresolved_class() const;
-  RawString* TypeClassName() const;
   virtual RawAbstractTypeArguments* arguments() const;
   void set_arguments(const AbstractTypeArguments& value) const;
   virtual intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   virtual bool IsInstantiated() const;
   virtual bool Equals(const Instance& other) const;
   virtual RawAbstractType* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments,
       Error* malformed_error) const;
   virtual RawAbstractType* CloneUnfinalized() const;
   virtual RawAbstractType* Canonicalize() const;
@@ skipping 61 matching lines @@
   void set_token_pos(intptr_t token_pos) const;
   void set_type_state(int8_t state) const;
 
   static RawType* New(Heap::Space space = Heap::kOld);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType);
   friend class Class;
 };
 
 
+// A TypeRef is used to break cycles in the representation of recursive types.
+// Its only field is the recursive AbstractType it refers to.
+// Note that the cycle always involves type arguments.
+class TypeRef : public AbstractType {
+ public:
+  virtual bool IsFinalized() const {
+    return AbstractType::Handle(type()).IsFinalized();
+  }
+  virtual bool IsBeingFinalized() const {
+    return AbstractType::Handle(type()).IsBeingFinalized();
+  }
+  virtual bool IsMalformed() const {
+    return AbstractType::Handle(type()).IsMalformed();
+  }
+  virtual bool IsMalbounded() const {
+    return AbstractType::Handle(type()).IsMalbounded();
+  }
+  virtual bool IsMalformedOrMalbounded() const {
+    return AbstractType::Handle(type()).IsMalformedOrMalbounded();
+  }
+  virtual bool IsResolved() const { return true; }
+  virtual bool HasResolvedTypeClass() const { return true; }
+  RawAbstractType* type() const { return raw_ptr()->type_; }
+  void set_type(const AbstractType& value) const;
+  virtual RawClass* type_class() const {
+    return AbstractType::Handle(type()).type_class();
+  }
+  virtual RawAbstractTypeArguments* arguments() const {
+    return AbstractType::Handle(type()).arguments();
+  }
+  virtual intptr_t token_pos() const {
+    return AbstractType::Handle(type()).token_pos();
+  }
+  virtual bool IsInstantiated() const;
+  virtual bool Equals(const Instance& other) const;
+  virtual RawAbstractType* InstantiateFrom(
+      const AbstractTypeArguments& instantiator_type_arguments,
+      Error* bound_error) const;
+  virtual RawAbstractType* Canonicalize() const;
+
+  virtual intptr_t Hash() const;
+
+  static intptr_t InstanceSize() {
+    return RoundedAllocationSize(sizeof(RawTypeRef));
+  }
+
+  static RawTypeRef* New(const AbstractType& type);
+
+ private:
+  bool is_being_checked() const {
+    return raw_ptr()->is_being_checked_;
+  }
+  void set_is_being_checked(bool value) const;
+
+  static RawTypeRef* New();
+
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeRef, AbstractType);
+  friend class Class;
+};
+
+
 // A TypeParameter represents a type parameter of a parameterized class.
 // It specifies its index (and its name for debugging purposes), as well as its
 // upper bound.
 // For example, the type parameter 'V' is specified as index 1 in the context of
 // the class HashMap<K, V>. At compile time, the TypeParameter is not
 // instantiated yet, i.e. it is only a place holder.
 // Upon finalization, the TypeParameter index is changed to reflect its position
 // as type argument (rather than type parameter) of the parameterized class.
 // If the type parameter is declared without an extends clause, its bound is set
 // to the ObjectType.
@@ skipping 2190 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_