Support generic method syntax (fixes #25869).

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/class_finalizer.h"
 
 #include "vm/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 1675 matching lines @@
       }
     }
 
     const TypeArguments& cloned_type_params = TypeArguments::Handle(zone,
         TypeArguments::New((share_type_params ? 0 : num_super_type_params) +
                            num_mixin_type_params));
     TypeParameter& param = TypeParameter::Handle(zone);
     TypeParameter& cloned_param = TypeParameter::Handle(zone);
     String& param_name = String::Handle(zone);
     AbstractType& param_bound = AbstractType::Handle(zone);
+    Function& null_function = Function::Handle(zone);
     intptr_t cloned_index = 0;
 
     // First, clone the super class type parameters. Rename them so that
     // there can be no name conflict between the parameters of the super
     // class and the mixin class.
     if (!share_type_params && (num_super_type_params > 0)) {
       const TypeArguments& super_type_params =
           TypeArguments::Handle(zone, super_class.type_parameters());
       const TypeArguments& super_type_args = TypeArguments::Handle(zone,
           TypeArguments::New(num_super_type_params));
       // The cloned super class type parameters do not need to repeat their
       // bounds, since the bound checks will be performed at the super class
       // level. As a consequence, if this mixin application is used itself as a
       // mixin in another mixin application, the bounds will be ignored, which
       // is correct, because the other mixin application does not inherit from
       // the super class of its mixin. Note also that the other mixin
       // application will only mixin the last mixin type listed in the first
       // mixin application it is mixing in.
       param_bound = thread->isolate()->object_store()->object_type();
       for (intptr_t i = 0; i < num_super_type_params; i++) {
         param ^= super_type_params.TypeAt(i);
         param_name = param.name();
         param_name = Symbols::FromConcat(thread,
                                          param_name, Symbols::Backtick());
         cloned_param = TypeParameter::New(mixin_app_class,
+                                          null_function,
                                           cloned_index,
                                           param_name,
                                           param_bound,
                                           param.token_pos());
         cloned_type_params.SetTypeAt(cloned_index, cloned_param);
         // Change the type arguments of the super type to refer to the
         // cloned type parameters of the mixin application class.
         super_type_args.SetTypeAt(cloned_index, cloned_param);
         cloned_index++;
       }
@@ skipping 18 matching lines @@
       instantiator ^= TypeArguments::New(offset + num_mixin_type_params);
       bool has_uninstantiated_bounds = false;
       for (intptr_t i = 0; i < num_mixin_type_params; i++) {
         param ^= mixin_params.TypeAt(i);
         param_name = param.name();
         param_bound = param.bound();  // The bound will be adjusted below.
         if (!param_bound.IsInstantiated()) {
           has_uninstantiated_bounds = true;
         }
         cloned_param = TypeParameter::New(mixin_app_class,
+                                          null_function,
                                           cloned_index,  // Unfinalized index.
                                           param_name,
                                           param_bound,
                                           param.token_pos());
         cloned_type_params.SetTypeAt(cloned_index, cloned_param);
         mixin_type_args.SetTypeAt(i, cloned_param);  // Unfinalized length.
         instantiator.SetTypeAt(offset + i, cloned_param);  // Finalized length.
         cloned_index++;
       }
 
@@ skipping 1573 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart