Verify that user classes/interfaces do not extend/implement any of bool, num,

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 859 matching lines @@
                   interface_name.ToCString());
     }
   }
 
   // If the class/interface has no explicit interfaces, we are done.
   Array& super_interfaces = Array::Handle(cls.interfaces());
   if (super_interfaces.Length() == 0) {
     return;
   }
 
+  // If cls belongs to core lib or to core lib's implementation, restrictions
+  // about allowed interfaces are lifted.
+  const bool cls_belongs_to_core_lib =
+      (cls.library() == Library::CoreLibrary()) ||
+      (cls.library() == Library::CoreImplLibrary());
+
+  // Resolve and check the interfaces of cls.
   visited->Add(&cls);
   Type& interface = Type::Handle();
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
     interface = ResolveType(cls, interface);
     super_interfaces.SetAt(i, interface);
     if (interface.IsTypeParameter()) {
       ReportError("Type parameter '%s' cannot be used as interface\n",
                   String::Handle(interface.Name()).ToCString());
     }
     const Class& interface_class = Class::Handle(interface.type_class());
     if (!interface_class.is_interface()) {
-      ReportError("Class name '%s' used where interface expected\n",
+      ReportError("Class '%s' is used where an interface is expected\n",
                   String::Handle(interface_class.Name()).ToCString());
     }
-    // TODO(regis): Verify that unless cls is in core lib, it cannot implement
-    // an instance of Number or String. Any other? bool?
-
+    // Verify that unless cls belongs to core lib, it cannot extend or implement
+    // any of bool, num, int, double, String, Function, Dynamic.
+    // The exception is signature classes, which are compiler generated and
+    // represent a function type, therefore implementing the Function interface.
+    if (!cls_belongs_to_core_lib) {
+      if (interface.IsBoolInterface() ||
+          interface.IsNumberInterface() ||
+          interface.IsIntInterface() ||
+          interface.IsDoubleInterface() ||
+          interface.IsStringInterface() ||
+          (interface.IsFunctionInterface() && !cls.IsSignatureClass()) ||
+          interface.IsDynamicType()) {
+        ReportError("'%s' is not allowed to extend or implement '%s'\n",
+                    String::Handle(cls.Name()).ToCString(),
+                    String::Handle(interface_class.Name()).ToCString());
+      }
+      // TODO(regis): We also need to prevent extending classes Smi, Mint,
+      // BigInt, Double, OneByteString, TwoByteString, FourByteString.
+    }
     // Now resolve the super interfaces.
     ResolveInterfaces(interface_class, visited);
   }
   visited->RemoveLast();
 }
 
 
 // A class is marked as constant if it has one constant constructor.
 // A constant class:
 // - may extend only const classes.
@@ skipping 104 matching lines @@
   ASSERT(msg_buffer != NULL);
   va_list args;
   va_start(args, format);
   OS::VSNPrint(msg_buffer, kBufferLength, format, args);
   va_end(args);
   isolate->long_jump_base()->Jump(1, msg_buffer);
   UNREACHABLE();
 }
 
 }  // namespace dart