Pass a second type argument vector to all type instantiation calls in the VM.

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 1578 matching lines @@
     return SubvectorName(0, Length(), kUserVisibleName);
   }
 
   // Check if the subvector of length 'len' starting at 'from_index' of this
   // type argument vector consists solely of DynamicType.
   bool IsRaw(intptr_t from_index, intptr_t len) const {
     return IsDynamicTypes(false, from_index, len);
   }
 
   // Check if this type argument vector would consist solely of DynamicType if
-  // it was instantiated from a raw (null) instantiator, i.e. consider each type
-  // parameter as it would be first instantiated from a vector of dynamic types.
+  // it was instantiated from both a raw (null) instantiator typearguments and
+  // a raw (null) function type arguments, i.e. consider each class type
+  // parameter and function type parameters as it would be first instantiated
+  // from a vector of dynamic types.
   // Consider only a prefix of length 'len'.
   bool IsRawInstantiatedRaw(intptr_t len) const {

[siva, 2017/04/10 22:04:55]

Why does the name repeat Raw twice, why not just
IsRawInstantiated

[regis, 2017/04/11 04:23:08]

A raw vector is a vector consisting of Dynamic only. What the name means is "is
this vector becoming raw when it is instantiated from a raw vector?"
I've renamed it to IsRawWhenInstantiatedFromRaw.

     return IsDynamicTypes(true, 0, len);
   }
 
   // Check the subtype relationship, considering only a subvector of length
   // 'len' starting at 'from_index'.
   bool IsSubtypeOf(const TypeArguments& other,
                    intptr_t from_index,
                    intptr_t len,
                    Error* bound_error,
                    TrailPtr bound_trail,
@@ skipping 60 matching lines @@
 
   // Canonicalize only if instantiated, otherwise returns 'this'.
   RawTypeArguments* Canonicalize(TrailPtr trail = NULL) const;
 
   // Returns a formatted list of occuring type arguments with their URI.
   RawString* EnumerateURIs() const;
 
   // Return 'this' if this type argument vector is instantiated, i.e. if it does
   // not refer to type parameters. Otherwise, return a new type argument vector
   // where each reference to a type parameter is replaced with the corresponding
-  // type of the instantiator type argument vector.
+  // type from the various type argument vectors (class instantiator, function,
+  // or parent functions via the current context).
   // If bound_error is not NULL, it may be set to reflect a bound error.
   RawTypeArguments* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
+      const TypeArguments& function_type_arguments,
       Error* bound_error,
       TrailPtr instantiation_trail,
       TrailPtr bound_trail,
       Heap::Space space) const;
 
   // Runtime instantiation with canonicalization. Not to be used during type
   // finalization at compile time.
   RawTypeArguments* InstantiateAndCanonicalizeFrom(
       const TypeArguments& instantiator_type_arguments,
+      const TypeArguments& function_type_arguments,
       Error* bound_error) const;
 
   // Return true if this type argument vector has cached instantiations.
   bool HasInstantiations() const;
 
   // Return the number of cached instantiations for this type argument vector.
   intptr_t NumInstantiations() const;
 
   static intptr_t instantiations_offset() {
     return OFFSET_OF(RawTypeArguments, instantiations_);
@@ skipping 21 matching lines @@
   intptr_t Hash() const;
 
   static RawTypeArguments* New(intptr_t len, Heap::Space space = Heap::kOld);
 
  private:
   intptr_t ComputeHash() const;
   void SetHash(intptr_t value) const;
 
   // Check if the subvector of length 'len' starting at 'from_index' of this
   // type argument vector consists solely of DynamicType.
-  // If raw_instantiated is true, consider each type parameter to be first
+  // If raw_instantiated is true, consider each class type parameter to be first
   // instantiated from a vector of dynamic types.
   bool IsDynamicTypes(bool raw_instantiated,
                       intptr_t from_index,
                       intptr_t len) const;
 
   // Check the subtype or 'more specific' relationship, considering only a
   // subvector of length 'len' starting at 'from_index'.
   bool TypeTest(TypeTestKind test_kind,
                 const TypeArguments& other,
                 intptr_t from_index,
@@ skipping 448 matching lines @@
   // function type with uninstantiated type arguments 'T' and 'R' as elements of
   // its type argument vector.
   RawType* SignatureType() const;
 
   // Update the signature type (with a canonical version).
   void SetSignatureType(const Type& value) const;
 
   // Return a new function with instantiated result and parameter types.
   RawFunction* InstantiateSignatureFrom(
       const TypeArguments& instantiator_type_arguments,
+      const TypeArguments& function_type_arguments,
       Heap::Space space) const;
 
   // Build a string of the form '(T, {B b, C c}) => R' representing the
   // internal signature of the given function. In this example, T and R are
   // type parameters of class C, the owner of the function.
   RawString* Signature() const { return BuildSignature(kInternalName); }
 
   // Build a string of the form '(T, {B b, C c}) => R' representing the
   // user visible signature of the given function. In this example, T and R are
   // type parameters of class C, the owner of the function.
@@ skipping 3024 matching lines @@
   FINAL_HEAP_OBJECT_IMPLEMENTATION(MegamorphicCache, Object);
 };
 
 
 class SubtypeTestCache : public Object {
  public:
   enum Entries {
     kInstanceClassIdOrFunction = 0,
     kInstanceTypeArguments = 1,
     kInstantiatorTypeArguments = 2,
-    kTestResult = 3,
-    kTestEntryLength = 4,
+    kFunctionTypeArguments = 3,
+    kTestResult = 4,
+    kTestEntryLength = 5,
   };
 
   intptr_t NumberOfChecks() const;
   void AddCheck(const Object& instance_class_id_or_function,
                 const TypeArguments& instance_type_arguments,
                 const TypeArguments& instantiator_type_arguments,
+                const TypeArguments& function_type_arguments,
                 const Bool& test_result) const;
   void GetCheck(intptr_t ix,
                 Object* instance_class_id_or_function,
                 TypeArguments* instance_type_arguments,
                 TypeArguments* instantiator_type_arguments,
+                TypeArguments* function_type_arguments,
                 Bool* test_result) const;
 
   static RawSubtypeTestCache* New();
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawSubtypeTestCache));
   }
 
   static intptr_t cache_offset() {
     return OFFSET_OF(RawSubtypeTestCache, cache_);
@@ skipping 214 matching lines @@
   void SetField(const Field& field, const Object& value) const {
     field.RecordStore(value);
     StorePointer(FieldAddr(field), value.raw());
   }
 
   RawAbstractType* GetType(Heap::Space space) const;
 
   virtual RawTypeArguments* GetTypeArguments() const;
   virtual void SetTypeArguments(const TypeArguments& value) const;
 
-  // Check if the type of this instance is a subtype of the given type.
-  bool IsInstanceOf(const AbstractType& type,
-                    const TypeArguments& type_instantiator,
+  // Check if the type of this instance is a subtype of the given other type.
+  // The type argument vectors are used to instantiate the other type if needed.
+  bool IsInstanceOf(const AbstractType& other,
+                    const TypeArguments& other_instantiator_type_arguments,
+                    const TypeArguments& other_function_type_arguments,
                     Error* bound_error) const;
 
   bool IsValidNativeIndex(int index) const {
     return ((index >= 0) && (index < clazz()->ptr()->num_native_fields_));
   }
 
   intptr_t* NativeFieldsDataAddr() const;
   inline intptr_t GetNativeField(int index) const;
   inline void GetNativeFields(uint16_t num_fields,
                               intptr_t* field_values) const;
@@ skipping 176 matching lines @@
   }
   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.
   virtual bool IsFunctionType() const { return false; }
 
-  // Instantiate this type using the given type argument vector.
+  // Instantiate this type using the given type argument vectors and possibly
+  // the current context.
   // Return a new type, or return 'this' if it is already instantiated.
   // If bound_error is not NULL, it may be set to reflect a bound error.
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
+      const TypeArguments& function_type_arguments,
       Error* bound_error,
       TrailPtr instantiation_trail,
       TrailPtr bound_trail,
       Heap::Space space) const;
 
   // Return a clone of this unfinalized type or the type itself if it is
   // already finalized. Apply recursively to type arguments, i.e. finalized
   // type arguments of an unfinalized type are not cloned, but shared.
   virtual RawAbstractType* CloneUnfinalized() const;
 
@@ skipping 195 matching lines @@
   // the signature fully represents the type and type arguments can be ignored.
   // However, in case of a generic typedef, they document how the typedef class
   // was parameterized to obtain the actual signature.
   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,
+      const TypeArguments& function_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,
                                                TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const;
 #if defined(DEBUG)
   // Check if type is canonical.
@@ skipping 116 matching lines @@
   }
   virtual TokenPosition token_pos() const {
     return AbstractType::Handle(type()).token_pos();
   }
   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,
+      const TypeArguments& function_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;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const;
 #if defined(DEBUG)
   // Check if typeref is canonical.
   virtual bool CheckIsCanonical(Thread* thread) const;
@@ skipping 65 matching lines @@
                   Error* bound_error,
                   TrailPtr bound_trail,
                   Heap::Space space) const;
   virtual TokenPosition token_pos() const { return raw_ptr()->token_pos_; }
   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,
+      const TypeArguments& function_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,
                                                TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const {
     return raw();
   }
@@ skipping 81 matching lines @@
     // 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(genericity, trail);
   }
   virtual bool IsEquivalent(const Instance& other, TrailPtr trail = NULL) const;
   virtual bool IsRecursive() const;
   virtual RawAbstractType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
+      const TypeArguments& function_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,
                                                TrailPtr trail = NULL) const;
   virtual RawAbstractType* Canonicalize(TrailPtr trail = NULL) const {
     return raw();
   }
@@ skipping 2696 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_