First stab at mixins in VM compiler

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/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 1227 matching lines @@
           !IsAliasCycleFree(type_class, visited)) {
         return false;
       }
     }
   }
   visited->RemoveLast();
   return true;
 }
 
 
+void ClassFinalizer::ApplyMixin(const Class& cls, const Type& mixin) {
+  ASSERT(mixin.HasResolvedTypeClass());
+  const Class& mixin_cls = Class::Handle(mixin.type_class());
+
+  // Check that the super class of the mixin class is extending
+  // class Object.
+  const Type& mixin_super_type = Type::Handle(mixin_cls.super_type());
+  ResolveType(mixin_cls, mixin_super_type, kCanonicalizeWellFormed);
+  if (!mixin_super_type.IsObjectType()) {
+    const Script& script = Script::Handle(cls.script());
+    const String& class_name = String::Handle(mixin_cls.Name());
+    ReportError(script, cls.token_pos(),

[siva, 2013/02/13 01:34:37]

I am wondering if it would be more helpful if you also reported the script and
token position of the original mixin class here.

[hausner, 2013/02/13 19:58:14]

I thought it makes more sense to report it where the class is used as a mixin
(i.e. at the keyword "with"). Ideally we should have a way to report two
locations. Since we can only report one location, the user may have to search
for one or the other related location.

+                "mixin class %s must extend class Object",
+                class_name.ToCString());
+  }
+
+  const Array& functions = Array::Handle(mixin_cls.functions());
+  Function& func = Function::Handle();
+  const intptr_t num_functions = functions.Length();
+  for (int i = 0; i < num_functions; i++) {
+    func ^= functions.At(i);
+    if (func.IsConstructor()) {
+      // A mixin class must not have explicit constructors.
+      if (!func.IsImplicitConstructor()) {
+        const Script& script = Script::Handle(cls.script());
+        ReportError(script, cls.token_pos(),

[siva, 2013/02/13 01:34:37]

Ditto.

[hausner, 2013/02/13 19:58:14]

Ditto.

+                    "mixin class %s must not have constructors\n",
+                    String::Handle(mixin_cls.Name()).ToCString());
+      }
+      continue;  // Skip the implicit constructor.
+    }
+    // TODO(hausner): must check whether the function contains
+    // super calls. If so, report error.
+    if (!func.is_static()) {
+      func = func.Clone(cls);
+      cls.AddFunction(func);

[siva, 2013/02/13 01:34:37]

Our AddFunction implementation is very inefficient, In this case it might make
sense to create a cloned_functions array (similar to cloned_fields below) and
add the implicit constructor which should probably be the only function in cls
to the list.

[hausner, 2013/02/13 19:58:14]

I agree with what you suggest, but let me check it in this way so Mixins get
picked up by M3. I will make this more efficient with a follow-up changelist.

On 2013/02/13 01:34:37, siva wrote:

+    }
+  }
+  Array& fields = Array::Handle(mixin_cls.fields());
+  Field& field = Field::Handle();
+  const GrowableObjectArray& cloned_fields =
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
+  const intptr_t num_fields = fields.Length();
+  for (int i = 0; i < num_fields; i++) {
+    field ^= fields.At(i);
+    if (!field.is_static()) {
+      field = field.Clone(cls);
+      cloned_fields.Add(field);
+    }
+  }
+  fields = Array::MakeArray(cloned_fields);

[siva, 2013/02/13 01:34:37]

Maybe we should assert here that
ASSERT(cls.fields() == Array::null());

[hausner, 2013/02/13 19:58:14]

Done.

+  cls.SetFields(fields);
+}
+
+
 // Recursively walks the graph of explicitly declared super type and
 // interfaces, resolving unresolved super types and interfaces.
 // Reports an error if there is an interface reference that cannot be
 // resolved, or if there is a cycle in the graph. We detect cycles by
 // remembering interfaces we've visited in each path through the
 // graph. If we visit an interface a second time on a given path,
 // we found a loop.
 void ClassFinalizer::ResolveSuperTypeAndInterfaces(
     const Class& cls, GrowableArray<intptr_t>* visited) {
   ASSERT(visited != NULL);
   const intptr_t cls_index = cls.id();
   for (int i = 0; i < visited->length(); i++) {
     if ((*visited)[i] == cls_index) {
       // We have already visited class 'cls'. We found a cycle.
       const String& class_name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "cyclic reference found for class '%s'",
                   class_name.ToCString());
     }
   }
 
-  // If the class/interface has no explicit super class/interfaces, we are done.
+  // If the class/interface has no explicit super class/interfaces
+  // and is not a mixin application, we are done.
   Type& super_type = Type::Handle(cls.super_type());
+  Type& mixin_type = Type::Handle(cls.mixin());
   Array& super_interfaces = Array::Handle(cls.interfaces());
   if ((super_type.IsNull() || super_type.IsObjectType()) &&
-      (super_interfaces.Length() == 0)) {
+      (super_interfaces.Length() == 0) &&
+      (mixin_type.IsNull())) {
     return;
   }
 
-  // If cls belongs to core lib or to core lib's implementation, restrictions
-  // about allowed interfaces are lifted.
+  if (!mixin_type.IsNull()) {
+    ResolveType(cls, mixin_type, kCanonicalizeWellFormed);
+    ApplyMixin(cls, mixin_type);
+  }
+
+  // If cls belongs to core lib, restrictions about allowed interfaces
+  // are lifted.
   const bool cls_belongs_to_core_lib = cls.library() == Library::CoreLibrary();
 
   // Resolve and check the super type and interfaces of cls.
   visited->Add(cls_index);
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
 
   // Resolve super type. Failures lead to a longjmp.
   ResolveType(cls, super_type, kCanonicalizeWellFormed);
 
-  // If cls belongs to core lib or to core lib's implementation, restrictions
   interface_class = super_type.type_class();
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   if (!cls_belongs_to_core_lib) {
     // Prevent extending core implementation classes.
     bool is_error = false;
     switch (interface_class.id()) {
       case kNumberCid:
       case kIntegerCid:  // Class Integer, not int.
       case kSmiCid:
@@ skipping 281 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