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());
+  }

[siva, 2016/09/19 23:23:46]

Do we really want this version of NumTypeParmeters? it seems to be used in only
one place IsGeneric, why not pass Thread::Current() there. That way it would
avoid future use without the thread argument.

We are planning on similarly getting rid of the Handle() without the zone
parameter but it is taking forever as more new code keeps getting added.

[regis, 2016/09/23 00:35:23]

Done.

+
+  // 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 3797 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_