Treat generic method parameters as dynamic in all contexts in the VM (fixes #27460)

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 11896 matching lines @@
     }
     type_parameter ^= ClassFinalizer::FinalizeType(
         current_class(), type_parameter, ClassFinalizer::kCanonicalize);
     ASSERT(!type_parameter.IsMalformed());
     return new(Z) TypeNode(primary_pos, type_parameter);
   } else {
     ASSERT(type_parameter.IsFunctionTypeParameter());
     // TODO(regis): Verify that CaptureFunctionInstantiator() was already
     // called if necessary.
     // TODO(regis): Finalize type parameter and return as type node.
-    // For now, throw a type error.
-    Type& malformed_type = Type::ZoneHandle(Z);
-    malformed_type = ClassFinalizer::NewFinalizedMalformedType(
-        Error::Handle(Z),  // No previous error.
-        script_,
-        primary_pos,
-        "function type parameter '%s' not yet supported",
-        String::Handle(Z, type_parameter.name()).ToCString());
-    return ThrowTypeError(primary_pos, malformed_type);
+    // For now, map to dynamic type.
+    Type& type = Type::ZoneHandle(Z, Type::DynamicType());
+    return new(Z) TypeNode(primary_pos, type);
   }
 }
 
 
 AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
     if ((CurrentToken() == Token::kPERIOD) ||
         (CurrentToken() == Token::kQM_PERIOD)) {
@@ skipping 440 matching lines @@
     Class& resolved_type_class = Class::Handle(Z);
     if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
       // First check if the type is a function type parameter.
       if (!innermost_function().IsNull()) {
         // TODO(regis): Shortcut this lookup if no generic functions in scope.
         TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z,
             innermost_function().LookupTypeParameter(unresolved_class_name,
                                                      NULL));
         if (!type_parameter.IsNull()) {
           // TODO(regis): Check for absence of type arguments.
-          // For now, return as malformed type.
-          Type& malformed_type = Type::ZoneHandle(Z);
-          malformed_type = ClassFinalizer::NewFinalizedMalformedType(
-              Error::Handle(Z),  // No previous error.
-              script_,
-              type->token_pos(),
-              "function type parameter '%s' not yet supported",
-              String::Handle(Z, type_parameter.name()).ToCString());
-          *type = malformed_type.raw();
+          // For now, resolve the function type parameter to dynamic.
+          *type = Type::DynamicType();
           return;
         }
       }
       // Then check if the type is a class type parameter.
       const TypeParameter& type_parameter = TypeParameter::Handle(Z,
           current_class().LookupTypeParameter(unresolved_class_name));
       if (!type_parameter.IsNull()) {
         // A type parameter is considered to be a malformed type when
         // referenced by a static member.
         if (ParsingStaticMember()) {
@@ skipping 589 matching lines @@
                                                  &type_param_func_level));
     if (!type_parameter.IsNull()) {
       if ((resolved == NULL) || (resolved_func_level < type_param_func_level)) {
         // The identifier is a function type parameter, possibly shadowing
         // 'resolved'.
         if (type_param_func_level < FunctionLevel()) {
           // Make sure that the function instantiator is captured.
           CaptureFunctionInstantiator();
         }
         // TODO(regis): Finalize type parameter and return as type node.
-        // For now, return as malformed type.
-        Type& malformed_type = Type::ZoneHandle(Z);
-        malformed_type = ClassFinalizer::NewFinalizedMalformedType(
-            Error::Handle(Z),  // No previous error.
-            script_,
-            ident_pos,
-            "function type parameter '%s' not yet supported",
-            ident.ToCString());
-        return new(Z) TypeNode(ident_pos, malformed_type);
+        // For now, map to dynamic type.
+        Type& type = Type::ZoneHandle(Z, Type::DynamicType());
+        return new(Z) TypeNode(ident_pos, type);
       }
     }
   }
   if (resolved == NULL) {
     // Check whether the identifier is a class type parameter.
     if (!current_class().IsNull()) {
       TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z,
           current_class().LookupTypeParameter(ident));
       if (!type_parameter.IsNull()) {
         if (FunctionLevel() > 0) {
@@ skipping 2090 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME