Set type argument vector at compile time in type of closure parameters; this

runtime/vm/object.h

 // Copyright (c) 2011, 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 "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 373 matching lines @@
   // The associated function may be a closure function (with code) or a
   // signature function (without code) solely describing the result type and
   // 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
+  // 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 are specified as an array of Strings.
   RawArray* type_parameters() const { return raw_ptr()->type_parameters_; }
   void set_type_parameters(const Array& value) const;
   intptr_t NumTypeParameters() const;
 
   // Type parameters may optionally extend a Type (VarType if no extends).
   RawTypeArray* type_parameter_extends() const {
@@ skipping 179 matching lines @@
 
   // 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(ObjectKind kind);
 
  private:
   void set_name(const String& value) const;
   void set_script(const Script& value) const;
   void set_signature_function(const Function& value) const;
+  void set_signature_type(const Type& value) const;
   void set_class_state(int8_t state) const;
 
   void set_constants(const Array& value) const;
   RawArray* constants() const;
 
   void set_num_constants(intptr_t value) const;
   intptr_t num_constants() const;
 
   void CalculateFieldOffsets() const;
 
@@ skipping 44 matching lines @@
 // Type is an abstract superclass.
 // Subclasses of Type are ParameterizedType, TypeParameter, and
 // InstantiatedType.
 //
 // Caution: 'RawType*' denotes a 'raw' pointer to a VM object of class Type,
 // as opposed to 'Type' denoting a 'handle' to the same object. 'RawType' does
 // not relate to a 'raw type', as opposed to a 'cooked type' or 'rare type'.
 class Type : public Object {
  public:
   virtual bool IsFinalized() const;
+  virtual bool IsBeingFinalized() const;
   virtual bool IsResolved() const;
   virtual bool HasResolvedTypeClass() const;
   virtual RawClass* type_class() const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const;
   virtual bool IsInstantiated() const;
 
   // Instantiate this type using the given type argument vector starting at the
   // given offset.
   // Return a new type, or return 'this' if it is already instantiated.
@@ skipping 124 matching lines @@
 
 // A ParameterizedType consists of a class, possibly parameterized with type
 // arguments. Example: C<T1, T2>.
 // An unresolved class is a String specifying the class name.
 class ParameterizedType : public Type {
  public:
   virtual bool IsFinalized() const {
     return raw_ptr()->type_state_ == RawParameterizedType::kFinalized;
   }
   void set_is_finalized() const;
-  bool is_being_finalized() const {
+  virtual bool IsBeingFinalized() const {
     return raw_ptr()->type_state_ == RawParameterizedType::kBeingFinalized;
   }
   void set_is_being_finalized() const;
   virtual bool IsResolved() const;  // Class and all arguments classes resolved.
   virtual bool HasResolvedTypeClass() const;  // Own type class resolved.
   virtual RawClass* type_class() const;
   void set_type_class(const Object& value) const;
   virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const;
   void set_arguments(const TypeArguments& value) const;
@@ skipping 20 matching lines @@
 
 
 // A TypeParameter, in the context of a parameterized class, references a type
 // parameter of a class by its index (and by its name for debugging purposes).
 // For example, the type parameter 'V' is specified as index 1 in the context of
 // the class HashMap<K, V>. At compile time, the TypeParameter is not
 // instantiated yet, i.e. it is only a place holder.
 class TypeParameter : public Type {
  public:
   virtual bool IsFinalized() const { return true; }
+  virtual bool IsBeingFinalized() const { return false; }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return false; }
   virtual RawString* Name() const { return raw_ptr()->name_; }
   virtual intptr_t Index() const { return raw_ptr()->index_; }
   virtual bool IsInstantiated() const { return false; }
   virtual RawType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
 
   static intptr_t InstanceSize() {
@@ skipping 17 matching lines @@
 // An instance of InstantiatedType consists of an uninstantiated Type object
 // and of a TypeArguments object. The type is uninstantiated, because it
 // refers to at least one TypeParameter object, i.e. to a type that is not known
 // at compile time.
 // The type argument vector is the instantiator, because each type parameter
 // with index i in the uninstantiated type can be substituted (or
 // "instantiated") with the type at index i in the type argument vector.
 class InstantiatedType : public Type {
  public:
   virtual bool IsFinalized() const { return true; }
+  virtual bool IsBeingFinalized() const { return false; }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return true; }
   virtual RawClass* type_class() const;
   virtual RawTypeArguments* arguments() const;
   virtual bool IsInstantiated() const { return true; }
 
   RawType* uninstantiated_type() const {
     return raw_ptr()->uninstantiated_type_;
   }
   RawTypeArguments* instantiator_type_arguments() const {
@@ skipping 145 matching lines @@
   static RawInstantiatedTypeArguments* New();
 
   HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments, TypeArguments);
   friend class Class;
 };
 
 
 class Function : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
-  RawString* Signature() const;
+
+  // Build a string of the form '<T, R>(T, [b: B, c: C]) => R' representing the
+  // signature of the given function.
+  RawString* Signature() const {
+    return BuildSignature(false, TypeArguments::Handle(), 0);
+  }
+
+  // Build a string of the form '(A, [b: B, c: C]) => D' representing the
+  // signature of the given function, where all generic types (e.g. '<T, R>' in
+  // '<T, R>(T, [b: B, c: C]) => R') are instantiated using the given
+  // instantiator type argument vector (e.g. '<A, D>').
+  RawString* InstantiatedSignatureFrom(const TypeArguments& instantiator,
+                                       intptr_t offset) const {
+    return BuildSignature(true, instantiator, offset);
+  }
+
+  // Returns true if the signature of this function is instantiated, i.e. if it
+  // does not involve generic parameter types or generic result type.
+  bool HasInstantiatedSignature() const;
 
   RawClass* owner() const { return raw_ptr()->owner_; }
   void set_owner(const Class& value) const;
 
   RawType* result_type() const { return raw_ptr()->result_type_; }
   void set_result_type(const Type& value) const;
 
   RawType* ParameterTypeAt(intptr_t index) const;
   void SetParameterTypeAt(intptr_t index, const Type& value) const;
   void set_parameter_types(const Array& value) const;
@@ skipping 170 matching lines @@
  private:
   void set_name(const String& value) const;
   void set_kind(RawFunction::Kind value) const;
   void set_is_static(bool is_static) const;
   void set_is_const(bool is_const) const;
   void set_parent_function(const Function& value) const;
   void set_token_index(intptr_t value) const;
   void set_implicit_closure_function(const Function& value) const;
   static RawFunction* New();
 
+  RawString* BuildSignature(bool instantiate,
+                            const TypeArguments& instantiator,
+                            intptr_t offset) const;
+
   // Checks the subtype or assignability relationship between the type of this
   // function and the type of the other function.
   bool TestType(TypeTestKind test, const Function& other) const;
 
   HEAP_OBJECT_IMPLEMENTATION(Function, Object);
   friend class Class;
 };
 
 
 class Field : public Object {
@@ skipping 1598 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_