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

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/become.h"
@@ skipping 4782 matching lines @@
     if (!type.IsResolved()) {
       return false;
     }
   }
   return true;
 }
 
 
 bool TypeArguments::IsSubvectorInstantiated(intptr_t from_index,
                                             intptr_t len,
+                                            Genericity genericity,
                                             TrailPtr trail) const {
   ASSERT(!IsNull());
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     // If the type argument is null, the type parameterized with this type
     // argument is still being finalized. Skip this null type argument.
-    if (!type.IsNull() && !type.IsInstantiated(trail)) {
+    if (!type.IsNull() && !type.IsInstantiated(genericity, trail)) {
       return false;
     }
   }
   return true;
 }
 
 
 bool TypeArguments::IsUninstantiatedIdentity() const {
   ASSERT(!IsInstantiated());
   AbstractType& type = AbstractType::Handle();
   const intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsTypeParameter()) {
       return false;
     }
     const TypeParameter& type_param = TypeParameter::Cast(type);
     ASSERT(type_param.IsFinalized());
-    if ((type_param.index() != i)) {
+    if ((type_param.index() != i) || type_param.IsFunctionTypeParameter()) {
       return false;
     }
     // If this type parameter specifies an upper bound, then the type argument
     // vector does not really represent the identity vector. It cannot be
     // substituted by the instantiator's type argument vector without checking
     // the upper bound.
     const AbstractType& bound = AbstractType::Handle(type_param.bound());
     ASSERT(bound.IsResolved());
     if (!bound.IsObjectType() && !bound.IsDynamicType()) {
       return false;
@@ skipping 38 matching lines @@
   // arguments of this type argument vector must refer to the corresponding type
   // parameters of the instantiator class.
   AbstractType& type_arg = AbstractType::Handle();
   for (intptr_t i = first_type_param_offset; i < num_type_args; i++) {
     type_arg = TypeAt(i);
     if (!type_arg.IsTypeParameter()) {
       return false;
     }
     const TypeParameter& type_param = TypeParameter::Cast(type_arg);
     ASSERT(type_param.IsFinalized());
-    if ((type_param.index() != i)) {
+    if ((type_param.index() != i) || type_param.IsFunctionTypeParameter()) {
       return false;
     }
   }
   // As a second requirement, the type arguments corresponding to the super type
   // must be identical. Overlapping ones have already been checked starting at
   // first_type_param_offset.
   if (first_type_param_offset == 0) {
     return true;
   }
   AbstractType& super_type =
@@ skipping 644 matching lines @@
   ASSERT(!obj.IsNull());
   if (IsClosureFunction()) {
     ClosureData::Cast(obj).set_parent_function(value);
   } else {
     ASSERT(IsSignatureFunction());
     SignatureData::Cast(obj).set_parent_function(value);
   }
 }
 
 
+bool Function::HasGenericParent() const {
+  Function& parent = Function::Handle(parent_function());
+  while (!parent.IsNull()) {
+    if (parent.IsGeneric()) {
+      return true;
+    }
+    parent = parent.parent_function();
+  }
+  return false;
+}
+
+
 RawFunction* Function::implicit_closure_function() const {
   if (IsClosureFunction() || IsSignatureFunction() || IsFactory()) {
     return Function::null();
   }
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(obj.IsNull() || obj.IsScript() || obj.IsFunction() || obj.IsArray());
   if (obj.IsNull() || obj.IsScript()) {
     return Function::null();
   }
   if (obj.IsFunction()) {
@@ skipping 10479 matching lines @@
   UNREACHABLE();
 }
 
 TokenPosition AbstractType::token_pos() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return TokenPosition::kNoSource;
 }
 
 
-bool AbstractType::IsInstantiated(TrailPtr trail) const {
+bool AbstractType::IsInstantiated(Genericity genericity, TrailPtr trail) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 bool AbstractType::IsFinalized() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
@@ skipping 785 matching lines @@
   ASSERT(!unresolved_class.IsNull());
   return unresolved_class.raw();
 #else
   ASSERT(!Object::Handle(raw_ptr()->type_class_id_).IsNull());
   ASSERT(Object::Handle(raw_ptr()->type_class_id_).IsUnresolvedClass());
   return reinterpret_cast<RawUnresolvedClass*>(raw_ptr()->type_class_id_);
 #endif
 }
 
 
-bool Type::IsInstantiated(TrailPtr trail) const {
+bool Type::IsInstantiated(Genericity genericity, TrailPtr trail) const {
   if (raw_ptr()->type_state_ == RawType::kFinalizedInstantiated) {
     return true;
   }
-  if (raw_ptr()->type_state_ == RawType::kFinalizedUninstantiated) {
+  if ((genericity == kAny) &&
+      (raw_ptr()->type_state_ == RawType::kFinalizedUninstantiated)) {
     return false;
   }
   if (arguments() == TypeArguments::null()) {
     return true;
   }
   const TypeArguments& args = TypeArguments::Handle(arguments());
   intptr_t num_type_args = args.Length();
   intptr_t len = num_type_args;  // Check the full vector of type args.
   ASSERT(num_type_args > 0);
   // This type is not instantiated if it refers to type parameters.
   // Although this type may still be unresolved, the type parameters it may
   // refer to are resolved by definition. We can therefore return the correct
   // result even for an unresolved type. We just need to look at all type
   // arguments and not just at the type parameters.
   if (HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type_class());
     len = cls.NumTypeParameters();  // Check the type parameters only.
   }
   return (len == 0) ||
-         args.IsSubvectorInstantiated(num_type_args - len, len, trail);
+         args.IsSubvectorInstantiated(num_type_args - len, len, genericity,
+                                      trail);
 }
 
 
 RawAbstractType* Type::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
   Zone* zone = Thread::Current()->zone();
@@ skipping 667 matching lines @@
     const intptr_t hash = Hash();
     return OS::SCreate(zone, "Type: (@%p H%" Px ") class '%s', args:[%s]",
                        raw(), hash, class_name, args_cstr);
   } else {
     return OS::SCreate(zone, "%sType: class '%s', args:[%s]", unresolved,
                        class_name, args_cstr);
   }
 }
 
 
-bool TypeRef::IsInstantiated(TrailPtr trail) const {
+bool TypeRef::IsInstantiated(Genericity genericity, TrailPtr trail) const {
   if (TestAndAddToTrail(&trail)) {
     return true;
   }
-  return AbstractType::Handle(type()).IsInstantiated(trail);
+  return AbstractType::Handle(type()).IsInstantiated(genericity, trail);
 }
 
 
 bool TypeRef::IsEquivalent(const Instance& other, TrailPtr trail) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsAbstractType()) {
     return false;
   }
@@ skipping 140 matching lines @@
   }
 }
 
 
 void TypeParameter::SetIsFinalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawTypeParameter::kFinalizedUninstantiated);
 }
 
 
+bool TypeParameter::IsInstantiated(Genericity genericity,
+                                   TrailPtr trail) const {
+  switch (genericity) {
+    case kAny:
+      return false;
+    case kClass:
+      return IsFunctionTypeParameter();
+    case kFunctions:
+      return IsClassTypeParameter();
+    case kCurrentFunction:
+      return IsClassTypeParameter() || (parent_level() > 0);
+    case kParentFunctions:
+      return IsClassTypeParameter() || (parent_level() == 0);
+    default:
+      UNREACHABLE();
+  }
+  return false;
+}
+
+
 bool TypeParameter::IsEquivalent(const Instance& other, TrailPtr trail) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (other.IsTypeRef()) {
     // Unfold right hand type. Divergence is controlled by left hand type.
     const AbstractType& other_ref_type =
         AbstractType::Handle(TypeRef::Cast(other).type());
     ASSERT(!other_ref_type.IsTypeRef());
     return IsEquivalent(other_ref_type, trail);
@@ skipping 5306 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart