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

runtime/vm/kernel_to_il.cc

 // 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.
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 3933 matching lines @@
 
 
 void DartTypeTranslator::VisitFunctionType(FunctionType* node) {
   // The spec describes in section "19.1 Static Types":
   //
   //     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.
   //
   // So we convert malformed return/parameter types to `dynamic`.
+  TypeParameterScope scope(this, &node->type_parameters());
 
   const Function& signature_function = Function::ZoneHandle(
       Z, Function::NewSignatureFunction(*active_class_->klass,
                                         TokenPosition::kNoSource));
 
   node->return_type()->AcceptDartTypeVisitor(this);
   if (result_.IsMalformed()) {
     result_ = AbstractType::dynamic_type().raw();
   }
   signature_function.set_result_type(result_);
@@ skipping 43 matching lines @@
   if (finalize_) {
     signature_type ^= ClassFinalizer::FinalizeType(
         *active_class_->klass, signature_type, ClassFinalizer::kCanonicalize);
   }
   signature_function.SetSignatureType(signature_type);
 
   result_ = signature_type.raw();
 }
 
 
+static intptr_t FindTypeParameterIndex(List<TypeParameter>* parameters,
+                                       TypeParameter* param) {
+  for (intptr_t i = 0; i < parameters->length(); i++) {
+    if (param == (*parameters)[i]) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+
 void DartTypeTranslator::VisitTypeParameterType(TypeParameterType* node) {
-  ASSERT(active_class_->kernel_class != NULL);
+  for (TypeParameterScope* scope = type_parameter_scope_; scope != NULL;
+       scope = scope->outer()) {
+    const intptr_t index =
+        FindTypeParameterIndex(scope->parameters(), node->parameter());
+    if (index >= 0) {
+      result_ ^= dart::Type::DynamicType();
+      return;
+    }
+  }
 
-  List<TypeParameter>* parameters =
-      &active_class_->kernel_class->type_parameters();
   if ((active_class_->member != NULL) && active_class_->member->IsProcedure()) {
     Procedure* procedure = Procedure::Cast(active_class_->member);
     if ((procedure->function() != NULL) &&
         (procedure->function()->type_parameters().length() > 0)) {
       //
       // WARNING: This is a little hackish:
       //
       // We have a static factory constructor. The kernel IR gives the factory
       // constructor function it's own type parameters (which are equal in name
       // and number to the ones of the enclosing class).
       // I.e.,
       //
       //   class A<T> {
       //     factory A.x() { return new B<T>(); }
       //   }
       //
       //  is basically translated to this:
       //
       //   class A<T> {
       //     static A.x<T'>() { return new B<T'>(); }
       //   }
       //
-      parameters = &procedure->function()->type_parameters();
+      const intptr_t index = FindTypeParameterIndex(
+          &procedure->function()->type_parameters(), node->parameter());
+      if (index >= 0) {
+        if (procedure->kind() == Procedure::kFactory) {
+          // The index of the type parameter in [parameters] is
+          // the same index into the `klass->type_parameters()` array.
+          result_ ^= dart::TypeArguments::Handle(
+                         Z, active_class_->klass->type_parameters())
+                         .TypeAt(index);
+        } else {
+          result_ ^= dart::Type::DynamicType();
+        }
+        return;
+      }
     }
   }
 
-  for (intptr_t i = 0; i < parameters->length(); i++) {
-    TypeParameter* type_parameter = (*parameters)[i];
-    if (node->parameter() == type_parameter) {
-      // The index of the type parameter in [parameters] is
-      // the same index into the `klass->type_parameters()` array.
-      result_ ^= dart::TypeArguments::Handle(
-                     Z, active_class_->klass->type_parameters())
-                     .TypeAt(i);
-      return;
-    }
+  ASSERT(active_class_->kernel_class != NULL);
+  List<TypeParameter>* parameters =
+      &active_class_->kernel_class->type_parameters();
+  const intptr_t index = FindTypeParameterIndex(parameters, node->parameter());
+  if (index >= 0) {
+    // The index of the type parameter in [parameters] is
+    // the same index into the `klass->type_parameters()` array.
+    result_ ^=
+        dart::TypeArguments::Handle(Z, active_class_->klass->type_parameters())
+            .TypeAt(index);
+    return;
   }
 
   UNREACHABLE();
 }
 
 
 void DartTypeTranslator::VisitInterfaceType(InterfaceType* node) {
   // NOTE: That an interface type like `T<A, B>` is considered to be
   // malformed iff `T` is malformed.
   //   => We therefore ignore errors in `A` or `B`.
@@ skipping 317 matching lines @@
     // into Kernel.
     List<DartType>& kernel_type_arguments = node->arguments()->types();
 
     const TypeArguments& type_arguments = T.TranslateInstantiatedTypeArguments(
         klass, kernel_type_arguments.raw_array(),
         kernel_type_arguments.length());
 
     instructions += TranslateInstantiatedTypeArguments(type_arguments);
     instructions += PushArgument();
   } else {
-    ASSERT(node->arguments()->types().length() == 0);
+    // TODO(28109) Support generic methods in the VM or reify them away.
   }
 
   // Special case identical(x, y) call.
   // TODO(27590) consider moving this into the inliner and force inline it
   // there.
   if (klass.IsTopLevel() && (klass.library() == dart::Library::CoreLibrary()) &&
       (target.name() == Symbols::Identical().raw())) {
     ASSERT(argument_count == 2);
 
     List<Expression>& positional = node->arguments()->positional();
@@ skipping 40 matching lines @@
       if (!result.IsError()) {
         fragment_ = Constant(result);
         return;
       }
     }
   }
 
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
 
-  // Dart does not support generic methods yet.
-  ASSERT(node->arguments()->types().length() == 0);
-
+  // TODO(28109) Support generic methods in the VM or reify them away.
   Array& argument_names = Array::ZoneHandle(Z);
   instructions += TranslateArguments(node->arguments(), &argument_names);
 
   intptr_t num_args_checked = 1;
   // If we have a special operation (e.g. +/-/==) we mark both arguments as
   // to be checked.
   if (token_kind != Token::kILLEGAL) {
     ASSERT(argument_count <= 2);
     num_args_checked = argument_count;
   }
 
   fragment_ = instructions + InstanceCall(node->position(), name, token_kind,
                                           argument_count, argument_names,
                                           num_args_checked);
 }
 
 
 void FlowGraphBuilder::VisitDirectMethodInvocation(
     DirectMethodInvocation* node) {
   const dart::String& method_name = H.DartMethodName(node->target()->name());
   const Function& target = Function::ZoneHandle(
       Z, LookupMethodByMember(node->target(), method_name));
 
   intptr_t argument_count = node->arguments()->count() + 1;
   Array& argument_names = Array::ZoneHandle(Z);
 
-  ASSERT(node->arguments()->types().length() == 0);
+  // TODO(28109) Support generic methods in the VM or reify them away.
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
   instructions += TranslateArguments(node->arguments(), &argument_names);
   fragment_ = instructions + StaticCall(node->position(), target,
                                         argument_count, argument_names);
 }
 
 
 void FlowGraphBuilder::VisitConstructorInvocation(ConstructorInvocation* node) {
   if (node->is_const()) {
@@ skipping 1311 matching lines @@
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)