Add Genericity enum in VM to distinguish how a type is uninstantiated.

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 RUNTIME_VM_OBJECT_H_
 #define RUNTIME_VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 1530 matching lines @@
   void set_ident(const String& ident) const;
   void set_token_pos(TokenPosition token_pos) const;
 
   static RawUnresolvedClass* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
 
+// Classification of type genericity according to type parameter owners.
+enum Genericity {
+  kAny,              // Consider type params of class and functions.
+  kClass,            // Consider type params of class only.
+  kFunctions,        // Consider type params of current and parent functions.
+  kCurrentFunction,  // Consider type params of current function only.
+  kParentFunctions   // Consider type params of parent functions only.
+};
+
+
 // A TypeArguments is an array of AbstractType.
 class TypeArguments : public Object {
  public:
   // We use 30 bits for the hash code so hashes in a snapshot taken on a
   // 64-bit architecture stay in Smi range when loaded on a 32-bit
   // architecture.
   static const intptr_t kHashBits = 30;
 
   intptr_t Length() const;
   RawAbstractType* TypeAt(intptr_t index) const;
@@ skipping 57 matching lines @@
 
   bool IsEquivalent(const TypeArguments& other, TrailPtr trail = NULL) const {
     return IsSubvectorEquivalent(other, 0, IsNull() ? 0 : Length(), trail);
   }
   bool IsSubvectorEquivalent(const TypeArguments& other,
                              intptr_t from_index,
                              intptr_t len,
                              TrailPtr trail = NULL) const;
 
   // Check if the vector is instantiated (it must not be null).
-  bool IsInstantiated(TrailPtr trail = NULL) const {
-    return IsSubvectorInstantiated(0, Length(), trail);
+  bool IsInstantiated(Genericity genericity = kAny,
+                      TrailPtr trail = NULL) const {
+    return IsSubvectorInstantiated(0, Length(), genericity, trail);
   }
   bool IsSubvectorInstantiated(intptr_t from_index,
                                intptr_t len,
+                               Genericity genericity = kAny,
                                TrailPtr trail = NULL) const;
   bool IsUninstantiatedIdentity() const;
   bool CanShareInstantiatorTypeArguments(const Class& instantiator_class) const;
 
   // Return true if all types of this vector are respectively, resolved,
   // finalized, or bounded.
   bool IsResolved() const;
   bool IsFinalized() const;
   bool IsBounded() const;
 
@@ skipping 625 matching lines @@
   // Return a TypeParameter if the type_name is a type parameter of this
   // function or of one of its parent functions.
   // Unless NULL, adjust function_level accordingly (in and out parameter).
   // Return null otherwise.
   RawTypeParameter* LookupTypeParameter(const String& type_name,
                                         intptr_t* function_level) const;
 
   // Return true if this function declares type parameters.
   bool IsGeneric() const { return NumTypeParameters(Thread::Current()) > 0; }
 
+  // Return true if any parent function of this function is generic.
+  bool HasGenericParent() const;
+
   // Not thread-safe; must be called in the main thread.
   // Sets function's code and code's function.
   void InstallOptimizedCode(const Code& code, bool is_osr) const;
   void AttachCode(const Code& value) const;
   void SetInstructions(const Code& value) const;
   void ClearCode() const;
 
   // Disables optimized code and switches to unoptimized code.
   void SwitchToUnoptimizedCode() const;
 
@@ skipping 3383 matching lines @@
   virtual void set_error(const LanguageError& value) const;
   virtual bool IsResolved() const;
   virtual void SetIsResolved() const;
   virtual bool HasResolvedTypeClass() const;
   virtual classid_t type_class_id() const;
   virtual RawClass* type_class() const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const;
   virtual void set_arguments(const TypeArguments& value) const;
   virtual TokenPosition token_pos() const;
-  virtual bool IsInstantiated(TrailPtr trail = NULL) const;
+  virtual bool IsInstantiated(Genericity genericity = kAny,
+                              TrailPtr trail = NULL) const;
   virtual bool CanonicalizeEquals(const Instance& other) const {
     return Equals(other);
   }
   virtual bool Equals(const Instance& other) const {
     return IsEquivalent(other);
   }
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const;
 
   // Check if this type represents a function type.
@@ skipping 194 matching lines @@
   virtual void SetIsResolved() const;
   virtual bool HasResolvedTypeClass() const;  // Own type class resolved.
   virtual classid_t type_class_id() const;
   virtual RawClass* type_class() const;
   void set_type_class(const Class& value) const;
   void set_unresolved_class(const Object& value) const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const { return raw_ptr()->arguments_; }
   virtual void set_arguments(const TypeArguments& value) const;
   virtual TokenPosition token_pos() const { return raw_ptr()->token_pos_; }
-  virtual bool IsInstantiated(TrailPtr trail = NULL) const;
+  virtual bool IsInstantiated(Genericity genericity = kAny,
+                              TrailPtr trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const;
   // If signature is not null, this type represents a function type.
   RawFunction* signature() const;
   void set_signature(const Function& value) const;
   virtual bool IsFunctionType() const {
     return signature() != Function::null();
   }
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
@@ skipping 117 matching lines @@
   void set_type(const AbstractType& value) const;
   virtual RawClass* type_class() const {
     return AbstractType::Handle(type()).type_class();
   }
   virtual RawTypeArguments* arguments() const {
     return AbstractType::Handle(type()).arguments();
   }
   virtual TokenPosition token_pos() const {
     return AbstractType::Handle(type()).token_pos();
   }
-  virtual bool IsInstantiated(TrailPtr trail = NULL) const;
+  virtual bool IsInstantiated(Genericity genericity = kAny,
+                              TrailPtr trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const { return true; }
   virtual RawTypeRef* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       TrailPtr instantiation_trail,
       TrailPtr bound_trail,
       Heap::Space space) const;
   virtual RawTypeRef* CloneUninstantiated(const Class& new_owner,
                                           TrailPtr trail = NULL) const;
@@ skipping 63 matching lines @@
   // Returns true if bounded_type is below upper_bound, otherwise return false
   // and set bound_error if both bounded_type and upper_bound are instantiated.
   // If one or both are not instantiated, returning false only means that the
   // bound cannot be checked yet and this is not an error.
   bool CheckBound(const AbstractType& bounded_type,
                   const AbstractType& upper_bound,
                   Error* bound_error,
                   TrailPtr bound_trail,
                   Heap::Space space) const;
   virtual TokenPosition token_pos() const { return raw_ptr()->token_pos_; }
-  virtual bool IsInstantiated(TrailPtr trail = NULL) const { return false; }
+  virtual bool IsInstantiated(Genericity genericity = kAny,
+                              TrailPtr trail = NULL) const;
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const { return false; }
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       TrailPtr instantiation_trail,
       TrailPtr bound_trail,
       Heap::Space space) const;
   virtual RawAbstractType* CloneUnfinalized() const;
   virtual RawAbstractType* CloneUninstantiated(const Class& new_owner,
@@ skipping 73 matching lines @@
     return AbstractType::Handle(type()).arguments();
   }
   RawAbstractType* type() const { return raw_ptr()->type_; }
   RawAbstractType* bound() const { return raw_ptr()->bound_; }
   RawTypeParameter* type_parameter() const {
     return raw_ptr()->type_parameter_;
   }
   virtual TokenPosition token_pos() const {
     return AbstractType::Handle(type()).token_pos();
   }
-  virtual bool IsInstantiated(TrailPtr trail = NULL) const {
+  virtual bool IsInstantiated(Genericity genericity = kAny,
+                              TrailPtr trail = NULL) const {
     // It is not possible to encounter an instantiated bounded type with an
     // uninstantiated upper bound. Therefore, we do not need to check if the
     // bound is instantiated. Moreover, doing so could lead into cycles, as in
     // class C<T extends C<C>> { }.
-    return AbstractType::Handle(type()).IsInstantiated(trail);
+    return AbstractType::Handle(type()).IsInstantiated(genericity, trail);
   }
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const;
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       Error* bound_error,
       TrailPtr instantiation_trail,
       TrailPtr bound_trail,
       Heap::Space space) const;
   virtual RawAbstractType* CloneUnfinalized() const;
@@ skipping 2701 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_OBJECT_H_