Gentle start with removing explicit interfaces

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 1110 matching lines @@
                   "typedef '%s' illegally refers to itself",
                   name.ToCString());
     }
     cls.Finalize();
     // Signature classes extend Object. No need to add this class to the direct
     // subclasses of Object.
     ASSERT(super_type.IsNull() || super_type.IsObjectType());
     return;
   }
   // Finalize factory class, if any.
   if (cls.is_interface()) {

[siva, 2012/08/21 21:22:06]

Are we going to remove the notion of interface from the VM, since all classes
are interfaces now does it make sense to still have this distinction?

[hausner, 2012/08/23 00:25:06]

Yes, this will go away, I would expect.

     if (cls.HasFactoryClass()) {
       const Class& factory_class = Class::Handle(cls.FactoryClass());
       if (!factory_class.is_finalized()) {
         FinalizeClass(factory_class, generating_snapshot);
         // Finalizing the factory class may indirectly finalize this interface.
         if (cls.is_finalized()) {
           return;
         }
       }
     }
@@ skipping 195 matching lines @@
       ReportError(script, cls.token_pos(),
                   "'%s' is used where an interface or class name is expected",
                   String::Handle(interface_class.Name()).ToCString());
     }
     // 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.IsNumber() ||

[regis, 2012/08/21 19:13:22]

Besides type testers, we also have class testers and handle tester:
IsObjectType(), IsObjectClass(), and IsObject(); IsDynamicType() and
IsDynamicClass() (no handle tester for Dynamic).

With your rename, I guess all flavors would have the same name. The code would
be harder to read, since you would need  to known if the receiver is a class, a
type, or a handle:
handle.IsString()  VM class String or one of its subclass?
cls.IsString()  cls == String?   
type.IsString()  dart String type?

[hausner, 2012/08/23 00:25:06]

Agree. Changing to IsFunctionType() and IsNumberType() as you suggest.

On 2012/08/21 19:13:22, regis wrote:

           interface.IsIntInterface() ||
           interface.IsDoubleInterface() ||
           interface.IsStringInterface() ||
-          (interface.IsFunctionInterface() && !cls.IsSignatureClass()) ||
+          (interface.IsFunction() && !cls.IsSignatureClass()) ||
           interface.IsDynamicType()) {
         const Script& script = Script::Handle(cls.script());
         ReportError(script, cls.token_pos(),
                     "'%s' is not allowed to extend or implement '%s'",
                     String::Handle(cls.Name()).ToCString(),
                     String::Handle(interface_class.Name()).ToCString());
       }
     }
     // Now resolve the super interfaces.
     ResolveInterfaces(interface_class, visited);
@@ skipping 147 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart