A class/interface cannot implement/extend a type parameter (issues 886 and 887).

runtime/vm/parser.cc

 // Copyright (c) 2011, 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/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 2494 matching lines @@
                class_name.ToCString());
     }
   }
   ASSERT(!cls.IsNull());
   ASSERT(cls.functions() == Array::Empty());
   set_current_class(cls);
   ParseTypeParameters(cls);
   Type& super_type = Type::Handle();
   if (CurrentToken() == Token::kEXTENDS) {
     ConsumeToken();
-    super_type ^= ParseType(kCanResolve);
+    const intptr_t type_pos = token_index_;
+    const AbstractType& type = AbstractType::Handle(ParseType(kCanResolve));
+    if (type.IsTypeParameter()) {
+      ErrorMsg(type_pos,
+               "class '%s' may not extend type parameter '%s'",
+               class_name.ToCString(),
+               String::Handle(type.Name()).ToCString());
+    }
+    super_type ^= type.raw();
     if (super_type.IsInterfaceType()) {
-      ErrorMsg("class '%s' may implement, but cannot extend interface '%s'",
+      ErrorMsg(type_pos,
+               "class '%s' may implement, but cannot extend interface '%s'",
                class_name.ToCString(),
                String::Handle(super_type.Name()).ToCString());
     }
   } else {
     // No extends clause: Implicitly extend Object.
     super_type = Type::ObjectType();
   }
   ASSERT(!super_type.IsNull());
   cls.set_super_type(super_type);
 
@@ skipping 469 matching lines @@
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
     AbstractType& interface = AbstractType::ZoneHandle();
     interface ^= cls_interfaces.At(i);
     all_interfaces.Add(&interface);
   }
   // Now add the new interfaces.
   AbstractType& conflicting = AbstractType::Handle();
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
     AbstractType& interface = AbstractType::ZoneHandle();
     interface ^= interfaces.At(i);
+    if (interface.IsTypeParameter()) {
+      if (cls.is_interface()) {
+        ErrorMsg(interfaces_pos,
+                 "interface '%s' may not extend type parameter '%s'",
+                 String::Handle(cls.Name()).ToCString(),
+                 String::Handle(interface.Name()).ToCString());
+      } else {
+        ErrorMsg(interfaces_pos,
+                 "class '%s' may not implement type parameter '%s'",
+                 String::Handle(cls.Name()).ToCString(),
+                 String::Handle(interface.Name()).ToCString());
+      }
+    }
     if (!ClassFinalizer::AddInterfaceIfUnique(&all_interfaces,
                                               &interface,
                                               &conflicting)) {
       ASSERT(!conflicting.IsNull());
       ErrorMsg(interfaces_pos,
                "interface '%s' conflicts with interface '%s'",
                String::Handle(interface.Name()).ToCString(),
                String::Handle(conflicting.Name()).ToCString());
     }
   }
@@ skipping 4687 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart