Support generic method syntax (fixes #25869).

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 2271 matching lines @@
   RawArray* parameter_types() const { return raw_ptr()->parameter_types_; }
   void set_parameter_types(const Array& value) const;
 
   // Parameter names are valid for all valid parameter indices, and are not
   // limited to named optional parameters.
   RawString* ParameterNameAt(intptr_t index) const;
   void SetParameterNameAt(intptr_t index, const String& value) const;
   RawArray* parameter_names() const { return raw_ptr()->parameter_names_; }
   void set_parameter_names(const Array& value) const;
 
+  // The type parameters (and their bounds) are specified as an array of
+  // TypeParameter.
+  RawTypeArguments* type_parameters() const {
+      return raw_ptr()->type_parameters_;
+  }
+  void set_type_parameters(const TypeArguments& value) const;
+  intptr_t NumTypeParameters(Thread* thread) const;
+  intptr_t NumTypeParameters() const {
+    return NumTypeParameters(Thread::Current());
+  }
+
+  // Return a TypeParameter if the type_name is a type parameter of this
+  // function or of one of its parent functions.
+  // Unless NULL, adjust function_level accordingly (in and out parameter).
+  // Return null otherwise.
+  RawTypeParameter* LookupTypeParameter(const String& type_name,
+                                        intptr_t* function_level) const;
+
+  // Return true if this function declares type parameters.
+  bool IsGeneric() const { return NumTypeParameters() > 0; }
+
   // Not thread-safe; must be called in the main thread.
   // Sets function's code and code's function.
   void InstallOptimizedCode(const Code& code, bool is_osr) const;
   void AttachCode(const Code& value) const;
   void SetInstructions(const Code& value) const;
   void ClearCode() const;
 
   // Disables optimized code and switches to unoptimized code.
   void SwitchToUnoptimizedCode() const;
 
@@ skipping 3796 matching lines @@
   }
   virtual void SetIsFinalized() const;
   virtual bool IsBeingFinalized() const { return false; }
   virtual bool IsMalformed() const { return false; }
   virtual bool IsMalbounded() const { return false; }
   virtual bool IsMalformedOrMalbounded() const { return false; }
   virtual bool IsResolved() const { return true; }
   virtual bool HasResolvedTypeClass() const { return false; }
   classid_t parameterized_class_id() const;
   RawClass* parameterized_class() const;
+  RawFunction* parameterized_function() const {
+    return raw_ptr()->parameterized_function_;
+  }
+  bool IsClassTypeParameter() const {
+    return parameterized_class_id() != kIllegalCid;
+  }
+  bool IsFunctionTypeParameter() const {
+    return parameterized_function() != Function::null();
+  }
   RawString* name() const { return raw_ptr()->name_; }
   intptr_t index() const { return raw_ptr()->index_; }
   void set_index(intptr_t value) const;
   RawAbstractType* bound() const { return raw_ptr()->bound_; }
   void set_bound(const AbstractType& value) const;
   // Returns true if bounded_type is below upper_bound, otherwise return false
   // and set bound_error if both bounded_type and upper_bound are instantiated.
   // If one or both are not instantiated, returning false only means that the
   // bound cannot be checked yet and this is not an error.
   bool CheckBound(const AbstractType& bounded_type,
@@ skipping 26 matching lines @@
   }
 #endif  // DEBUG
   virtual RawString* EnumerateURIs() const;
 
   virtual intptr_t Hash() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawTypeParameter));
   }
 
+  // Only one of parameterized_class and parameterized_function is non-null.
   static RawTypeParameter* New(const Class& parameterized_class,
+                               const Function& parameterized_function,
                                intptr_t index,
                                const String& name,
                                const AbstractType& bound,
                                TokenPosition token_pos);
 
  private:
   intptr_t ComputeHash() const;
   void SetHash(intptr_t value) const;
 
   void set_parameterized_class(const Class& value) const;
+  void set_parameterized_function(const Function& value) const;
   void set_name(const String& value) const;
   void set_token_pos(TokenPosition token_pos) const;
   void set_type_state(int8_t state) const;
 
   static RawTypeParameter* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
@@ skipping 2773 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  // VM_OBJECT_H_