[VM generic functions] Disallow generic function types as type arguments or bounds.

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/flags.h"
 #include "vm/hash_table.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 778 matching lines @@
       // Finalize the current type arguments of the type, which are still the
       // parsed type arguments.
       if (!arguments.IsNull()) {
         for (intptr_t i = 0; i < num_type_parameters; i++) {
           type_arg = full_arguments.TypeAt(offset + i);
           ASSERT(!type_arg.IsBeingFinalized());
           type_arg = FinalizeType(cls, type_arg, kFinalize, pending_types);
           if (type_arg.IsMalformed()) {
             // Malformed type arguments are mapped to dynamic.
             type_arg = Type::DynamicType();
+          } else if (type_arg.IsFunctionType()) {
+            const Function& signature_function =
+                Function::Handle(zone, Type::Cast(type_arg).signature());
+            if (signature_function.IsGeneric()) {
+              const String& type_arg_name =
+                  String::Handle(zone, type_arg.UserVisibleName());
+              const String& type_name =
+                  String::Handle(zone, type.UserVisibleName());
+              ReportError(cls, type_arg.token_pos(),
+                          "generic function type '%s' not allowed as type "
+                          "argument of type '%s'",
+                          type_arg_name.ToCString(), type_name.ToCString());
+            }
           }
           full_arguments.SetTypeAt(offset + i, type_arg);
         }
       }
       if (offset > 0) {
         TrailPtr instantiation_trail = new Trail(zone, 4);
         Error& bound_error = Error::Handle(zone);
         FinalizeTypeArguments(type_class, full_arguments, offset, &bound_error,
                               pending_types, instantiation_trail);
       }
@@ skipping 525 matching lines @@
   // Resolve upper bounds of function type parameters.
   const intptr_t num_type_params = function.NumTypeParameters();
   if (num_type_params > 0) {
     TypeParameter& type_param = TypeParameter::Handle();
     const TypeArguments& type_params =
         TypeArguments::Handle(function.type_parameters());
     for (intptr_t i = 0; i < num_type_params; i++) {
       type_param ^= type_params.TypeAt(i);
       type = type_param.bound();
       ResolveType(cls, type);
+      if (type.IsFunctionType()) {
+        const Function& signature_function =
+            Function::Handle(Type::Cast(type).signature());
+        if (signature_function.IsGeneric()) {
+          const String& type_name = String::Handle(type.UserVisibleName());
+          const String& type_param_name = String::Handle(type_param.name());
+          ReportError(cls, type.token_pos(),
+                      "generic function type '%s' not allowed as bound of "
+                      "function type parameter '%s'",
+                      type_name.ToCString(), type_param_name.ToCString());
+        }
+      }
     }
   }
   // Resolve result type.
   type = function.result_type();
   // It is not a compile time error if this name does not resolve to a class or
   // interface.
   ResolveType(cls, type);
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
@@ skipping 98 matching lines @@
   const TypeArguments& type_params =
       TypeArguments::Handle(cls.type_parameters());
   ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
          (type_params.Length() == num_type_params));
   // In a first pass, resolve all bounds. This guarantees that finalization
   // of mutually referencing bounds will not encounter an unresolved bound.
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     bound = type_param.bound();
     ResolveType(cls, bound);
+    if (bound.IsFunctionType()) {
+      const Function& signature_function =
+          Function::Handle(Type::Cast(bound).signature());
+      if (signature_function.IsGeneric()) {
+        const String& bound_name = String::Handle(bound.UserVisibleName());
+        const String& type_param_name = String::Handle(type_param.name());
+        ReportError(cls, bound.token_pos(),
+                    "generic function type '%s' not allowed as bound of "
+                    "class type parameter '%s'",
+                    bound_name.ToCString(), type_param_name.ToCString());
+      }
+    }
   }
 }
 
 // Finalize the upper bounds of the type parameters of class cls.
 void ClassFinalizer::FinalizeUpperBounds(const Class& cls,
                                          FinalizationKind finalization) {
   const intptr_t num_type_params = cls.NumTypeParameters();
   TypeParameter& type_param = TypeParameter::Handle();
   AbstractType& bound = AbstractType::Handle();
   const TypeArguments& type_params =
@@ skipping 2281 matching lines @@
   ProgramVisitor::VisitFunctions(&function_visitor);
 
   class ClearCodeClassVisitor : public ClassVisitor {
     void Visit(const Class& cls) { cls.DisableAllocationStub(); }
   };
   ClearCodeClassVisitor class_visitor;
   ProgramVisitor::VisitClasses(&class_visitor);
 }
 
 }  // namespace dart