Fix class patching involving type parameters: type parameters of patched classes

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 578 matching lines @@
   // parameter types of the signature.
   RawFunction* signature_function() const {
     return raw_ptr()->signature_function_;
   }
   static intptr_t signature_function_offset() {
     return OFFSET_OF(RawClass, signature_function_);
   }
 
   // Return the signature type of this signature class.
   // For example, if this class represents a signature of the form
-  // '<T, R>(T, [b: B, c: C]) => R', then its signature type is a parameterized
+  // 'F<T, R>(T, [b: B, c: C]) => R', then its signature type is a parameterized
   // type with this class as the type class and type parameters 'T' and 'R'
   // as its type argument vector.
   RawType* SignatureType() const;
 
   RawLibrary* library() const { return raw_ptr()->library_; }
   void set_library(const Library& value) const;
 
   // The type parameters (and their bounds) are specified as an array of
   // TypeParameter.
   RawTypeArguments* type_parameters() const {
@@ skipping 216 matching lines @@
 
   // Allocate the raw string classes.
   static RawClass* NewStringClass(intptr_t class_id);
 
   // Allocate a class representing a function signature described by
   // signature_function, which must be a closure function or a signature
   // function.
   // The class may be type parameterized unless the signature_function is in a
   // static scope. In that case, the type parameters are copied from the owner
   // class of signature_function.
+  // A null signature function may be passed in and patched later. See below.
   static RawClass* NewSignatureClass(const String& name,
                                      const Function& signature_function,
-                                     const Script& script);
+                                     const Script& script,
+                                     intptr_t token_pos);
+
+  // Patch the signature function of a signature class allocated without it.
+  void PatchSignatureFunction(const Function& signature_function);
 
   // Return a class object corresponding to the specified kind. If
   // a canonicalized version of it exists then that object is returned
   // otherwise a new object is allocated and returned.
   static RawClass* GetClass(intptr_t class_id, bool is_signature_class);
 
  private:
   enum {
     kConstBit = 1,
     kImplementedBit = 2,
@@ skipping 5491 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_