[VM, generic functions reification, work in progress]

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 4843 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 
 bool TypeArguments::IsSubvectorInstantiated(intptr_t from_index,
                                             intptr_t len,
                                             Genericity genericity,
+                                            intptr_t num_free_fun_type_params,
                                             TrailPtr trail) const {
   ASSERT(!IsNull());
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     // If this type argument T is null, the type A containing T in its flattened
     // type argument vector V is recursive and is still being finalized.
     // T is the type argument of a super type of A. T is being instantiated
     // during finalization of V, which is also the instantiator. T depends
     // solely on the type parameters of A and will be replaced by a non-null
     // type before A is marked as finalized.
-    if (!type.IsNull() && !type.IsInstantiated(genericity, trail)) {
+    if (!type.IsNull() &&
+        !type.IsInstantiated(genericity, num_free_fun_type_params, trail)) {
       return false;
     }
   }
   return true;
 }
 
 
 bool TypeArguments::IsUninstantiatedIdentity() const {
   AbstractType& type = AbstractType::Handle();
   const intptr_t num_types = Length();
@@ skipping 2362 matching lines @@
   BuildSignatureParameters(thread, zone, name_visibility, &pieces);
   pieces.Add(Symbols::RParenArrow());
   const AbstractType& res_type = AbstractType::Handle(zone, result_type());
   name = res_type.BuildName(name_visibility);
   pieces.Add(name);
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
 bool Function::HasInstantiatedSignature(Genericity genericity,
+                                        intptr_t num_free_fun_type_params,
                                         TrailPtr trail) const {
+  if (genericity != kCurrentClass) {
+    // We only consider the function type parameters declared by the parents of
+    // this signature function.
+    const int num_parent_type_params = NumParentTypeParameters();
+    if (num_parent_type_params < num_free_fun_type_params) {
+      num_free_fun_type_params = num_parent_type_params;
+    }
+  }
   AbstractType& type = AbstractType::Handle(result_type());
-  if (!type.IsInstantiated(genericity, trail)) {
+  if (!type.IsInstantiated(genericity, num_free_fun_type_params, trail)) {
     return false;
   }
   const intptr_t num_parameters = NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = ParameterTypeAt(i);
-    if (!type.IsInstantiated(genericity, trail)) {
+    if (!type.IsInstantiated(genericity, num_free_fun_type_params, trail)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawClass* Function::Owner() const {
   if (raw_ptr()->owner_ == Object::null()) {
     ASSERT(IsSignatureFunction());
@@ skipping 9112 matching lines @@
   UNREACHABLE();
 }
 
 TokenPosition AbstractType::token_pos() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return TokenPosition::kNoSource;
 }
 
 
-bool AbstractType::IsInstantiated(Genericity genericity, TrailPtr trail) const {
+bool AbstractType::IsInstantiated(Genericity genericity,
+                                  intptr_t num_free_fun_type_params,
+                                  TrailPtr trail) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 bool AbstractType::IsFinalized() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
@@ skipping 822 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(Genericity genericity, TrailPtr trail) const {
+bool Type::IsInstantiated(Genericity genericity,
+                          intptr_t num_free_fun_type_params,
+                          TrailPtr trail) const {
   if (raw_ptr()->type_state_ == RawType::kFinalizedInstantiated) {
     return true;
   }
-  if ((genericity == kAny) &&
+  if ((genericity == kAny) && (num_free_fun_type_params == kMaxInt32) &&
       (raw_ptr()->type_state_ == RawType::kFinalizedUninstantiated)) {
     return false;
   }
   if (IsFunctionType()) {
     const Function& sig_fun = Function::Handle(signature());
-    if (!sig_fun.HasInstantiatedSignature(genericity, trail)) {
+    if (!sig_fun.HasInstantiatedSignature(genericity, num_free_fun_type_params,
+                                          trail)) {
       return false;
     }
     // Because a generic typedef with an instantiated signature is considered
     // uninstantiated, we still need to check the type arguments, even if the
     // signature is instantiated.
   }
   if (arguments() == TypeArguments::null()) {
     return true;
   }
   const TypeArguments& args = TypeArguments::Handle(arguments());
@@ skipping 10 matching lines @@
     len = cls.NumTypeParameters();  // Check the type parameters only.
     if (len > num_type_args) {
       // This type has the wrong number of arguments and is not finalized yet.
       // Type arguments are reset to null when finalizing such a type.
       ASSERT(!IsFinalized());
       len = num_type_args;
     }
   }
   return (len == 0) ||
          args.IsSubvectorInstantiated(num_type_args - len, len, genericity,
-                                      trail);
+                                      num_free_fun_type_params, trail);
 }
 
 
 RawAbstractType* Type::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     const TypeArguments& function_type_arguments,
     Error* bound_error,
     TrailPtr instantiation_trail,
     TrailPtr bound_trail,
     Heap::Space space) const {
@@ skipping 696 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(Genericity genericity, TrailPtr trail) const {
+bool TypeRef::IsInstantiated(Genericity genericity,
+                             intptr_t num_free_fun_type_params,
+                             TrailPtr trail) const {
   if (TestAndAddToTrail(&trail)) {
     return true;
   }
   const AbstractType& ref_type = AbstractType::Handle(type());
-  return !ref_type.IsNull() && ref_type.IsInstantiated(genericity, trail);
+  return !ref_type.IsNull() &&
+         ref_type.IsInstantiated(genericity, num_free_fun_type_params, trail);
 }
 
 
 bool TypeRef::IsEquivalent(const Instance& other, TrailPtr trail) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsAbstractType()) {
     return false;
   }
@@ skipping 146 matching lines @@
 }
 
 
 void TypeParameter::SetIsFinalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawTypeParameter::kFinalizedUninstantiated);
 }
 
 
 bool TypeParameter::IsInstantiated(Genericity genericity,
+                                   intptr_t num_free_fun_type_params,
                                    TrailPtr trail) const {
-  switch (genericity) {
-    case kAny:
-      return false;
-    case kCurrentClass:
-      return IsFunctionTypeParameter();
-    case kFunctions:
-      return IsClassTypeParameter();
-    default:
-      UNREACHABLE();
+  if (IsClassTypeParameter()) {
+    return genericity == kFunctions;
   }
-  return false;
+  ASSERT(IsFunctionTypeParameter());
+  ASSERT(IsFinalized());
+  return (genericity == kCurrentClass) || (index() >= num_free_fun_type_params);
 }
 
 
 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 =
@@ skipping 5359 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart