Minor improvement in mixin application

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 1103 matching lines @@
   // class Object.
   const Type& mixin_super_type = Type::Handle(mixin_cls.super_type());
   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(),
                 "mixin class %s must extend class Object",
                 class_name.ToCString());
   }
 
-  const Array& functions = Array::Handle(mixin_cls.functions());
+  const GrowableObjectArray& cloned_funcs =
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
+  Array& functions = Array::Handle();
   Function& func = Function::Handle();
+  // The parser creates the mixin application class and adds just
+  // one function, the implicit constructor.
+  functions = cls.functions();
+  ASSERT(functions.Length() == 1);
+  func ^= functions.At(0);
+  ASSERT(func.IsImplicitConstructor());
+  cloned_funcs.Add(func);
+  // Now clone the functions from the mixin class.
+  functions = mixin_cls.functions();
   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(),
                     "mixin class %s must not have constructors\n",
                     String::Handle(mixin_cls.Name()).ToCString());
       }
       continue;  // Skip the implicit constructor.
     }
     if (!func.is_static()) {
       func = func.Clone(cls);
-      cls.AddFunction(func);
+      cloned_funcs.Add(func);
     }
   }
+  functions = Array::MakeArray(cloned_funcs);
+  cls.SetFunctions(functions);
+
+  // Now clone the fields from the mixin class. There should be no
+  // existing fields in the mixin application class.
+  ASSERT(Array::Handle(cls.fields()).Length() == 0);
   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);
-  ASSERT(Array::Handle(cls.fields()).Length() == 0);
   cls.SetFields(fields);
 }
 
 
 void ClassFinalizer::FinalizeClass(const Class& cls) {
   if (cls.is_finalized()) {
     return;
   }
   if (FLAG_trace_class_finalization) {
     OS::Print("Finalize %s\n", cls.ToCString());
@@ skipping 487 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