VM: [Kernel] don't crash when encountering generic methods in Kernel.

runtime/vm/kernel_to_il.h

 // Copyright (c) 2016, 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 RUNTIME_VM_KERNEL_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/growable_array.h"
@@ skipping 266 matching lines @@
 // Any use of a malformed type gives rise to a static warning.  A malformed
 // type is then interpreted as dynamic by the static type checker and the
 // runtime unless explicitly specified otherwise.
 class DartTypeTranslator : public DartTypeVisitor {
  public:
   DartTypeTranslator(TranslationHelper* helper,
                      ActiveClass* active_class,
                      bool finalize = false)
       : translation_helper_(*helper),
         active_class_(active_class),
+        type_parameter_scope_(NULL),
         zone_(helper->zone()),
         result_(AbstractType::Handle(helper->zone())),
         finalize_(finalize) {}
 
   // Can return a malformed type.
   AbstractType& TranslateType(DartType* node);
 
   // Can return a malformed type.
   AbstractType& TranslateTypeWithoutFinalization(DartType* node);
 
@@ skipping 23 matching lines @@
       intptr_t length);
 
   // Will return `TypeArguments::null()` in case any of the arguments are
   // malformed.
   const TypeArguments& TranslateTypeArguments(DartType** dart_types,
                                               intptr_t length);
 
   const Type& ReceiverType(const dart::Class& klass);
 
  private:
+  class TypeParameterScope {
+   public:
+    TypeParameterScope(DartTypeTranslator* translator,
+                       List<TypeParameter>* parameters)
+        : parameters_(parameters),
+          outer_(translator->type_parameter_scope_),
+          translator_(translator) {
+      translator_->type_parameter_scope_ = this;
+    }
+    ~TypeParameterScope() { translator_->type_parameter_scope_ = outer_; }
+
+    TypeParameterScope* outer() const { return outer_; }
+    List<TypeParameter>* parameters() const { return parameters_; }
+
+   private:
+    List<TypeParameter>* parameters_;
+    TypeParameterScope* outer_;
+    DartTypeTranslator* translator_;
+  };
+
   TranslationHelper& translation_helper_;
   ActiveClass* active_class_;
+  TypeParameterScope* type_parameter_scope_;
   Zone* zone_;
   AbstractType& result_;
-
   bool finalize_;
 };
 
 
 // There are several cases when we are compiling constant expressions:
 //
 //   * constant field initializers:
 //      const FieldName = <expr>;
 //
 //   * constant expressions:
@@ skipping 575 matching lines @@
   friend class SwitchBlock;
   friend class TryCatchBlock;
   friend class TryFinallyBlock;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_