First stab at mixins in VM compiler

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 2057 matching lines @@
 }
 
 
 void Class::set_interfaces(const Array& value) const {
   // Verification and resolving of interfaces occurs in finalizer.
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->interfaces_, value.raw());
 }
 
 
+void Class::set_mixin(const Type& value) const {
+  // Resolution and application of mixin type occurs in finalizer.
+  ASSERT(!value.IsNull());
+  StorePointer(&raw_ptr()->mixin_, value.raw());
+}
+
+
 void Class::AddDirectSubclass(const Class& subclass) const {
   ASSERT(!subclass.IsNull());
   ASSERT(subclass.SuperClass() == raw());
   // Do not keep track of the direct subclasses of class Object.
   ASSERT(!IsObjectClass());
   GrowableObjectArray& direct_subclasses =
       GrowableObjectArray::Handle(raw_ptr()->direct_subclasses_);
   if (direct_subclasses.IsNull()) {
     direct_subclasses = GrowableObjectArray::New(4, Heap::kOld);
     StorePointer(&raw_ptr()->direct_subclasses_, direct_subclasses.raw());
@@ skipping 1986 matching lines @@
       }
     }
     if (!found_param_name) {
       return false;
     }
   }
   return true;
 }
 
 
+// The compiler generates an implicit constructor if a class definition
+// does not contain an explicit constructor or factory. The implicit
+// constructor has the same token position as the owner class.
+bool Function::IsImplicitConstructor() const {
+  return IsConstructor() &&
+         (token_pos() == Class::Handle(Owner()).token_pos());
+}
+
+
 bool Function::IsImplicitClosureFunction() const {
   if (!IsClosureFunction()) {
     return false;
   }
   const Function& parent = Function::Handle(parent_function());
   return (parent.implicit_closure_function() == raw());
 }
 
 
 RawFunction* Function::New() {
@@ skipping 39 matching lines @@
   result.set_is_native(false);
   result.set_is_inlinable(true);
   if (kind == RawFunction::kClosureFunction) {
     const ClosureData& data = ClosureData::Handle(ClosureData::New());
     result.set_data(data);
   }
   return result.raw();
 }
 
 
+RawFunction* Function::Clone(const Class& new_owner) const {
+  ASSERT(!IsConstructor());
+  Function& clone = Function::Handle();
+  clone ^= Object::Clone(*this, Heap::kOld);
+  const Class& owner = Class::Handle(this->Owner());
+  const PatchClass& clone_owner =
+      PatchClass::Handle(PatchClass::New(new_owner, owner));
+  clone.set_owner(clone_owner);
+  clone.StorePointer(&clone.raw_ptr()->code_, Code::null());
+  clone.StorePointer(&clone.raw_ptr()->unoptimized_code_, Code::null());
+  clone.set_usage_counter(0);
+  clone.set_deoptimization_counter(0);
+  clone.set_optimized_instruction_count(0);
+  clone.set_optimized_call_site_count(0);
+  return clone.raw();
+}
+
+
 RawFunction* Function::NewClosureFunction(const String& name,
                                           const Function& parent,
                                           intptr_t token_pos) {
   ASSERT(!parent.IsNull());
   // Use the owner defining the parent function and not the class containing it.
   const Object& parent_owner = Object::Handle(parent.raw_ptr()->owner_);
   ASSERT(!parent_owner.IsNull());
   const Function& result = Function::Handle(
       Function::New(name,
                     RawFunction::kClosureFunction,
@@ skipping 218 matching lines @@
 RawClass* Function::Owner() const {
   const Object& obj = Object::Handle(raw_ptr()->owner_);
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   ASSERT(obj.IsPatchClass());
   return PatchClass::Cast(obj).patched_class();
 }
 
 
+RawClass* Function::origin() const {
+  const Object& obj = Object::Handle(raw_ptr()->owner_);
+  if (obj.IsClass()) {
+    return Class::Cast(obj).raw();
+  }
+  ASSERT(obj.IsPatchClass());
+  return PatchClass::Cast(obj).source_class();
+}
+
+
 RawScript* Function::script() const {
   const Object& obj = Object::Handle(raw_ptr()->owner_);
   if (obj.IsClass()) {
     return Class::Cast(obj).script();
   }
   ASSERT(obj.IsPatchClass());
   return PatchClass::Cast(obj).Script();
 }
 
 
@@ skipping 239 matching lines @@
   return function_name.StartsWith(String::Handle(String::New(kSetterPrefix)));
 }
 
 
 void Field::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
+RawClass* Field::owner() const {
+  const Object& obj = Object::Handle(raw_ptr()->owner_);
+  if (obj.IsClass()) {
+    return Class::Cast(obj).raw();
+  }
+  ASSERT(obj.IsPatchClass());
+  return PatchClass::Cast(obj).patched_class();
+}
+
+
+RawClass* Field::origin() const {
+  const Object& obj = Object::Handle(raw_ptr()->owner_);
+  if (obj.IsClass()) {
+    return Class::Cast(obj).raw();
+  }
+  ASSERT(obj.IsPatchClass());
+  return PatchClass::Cast(obj).source_class();
+}
+
+
 RawInstance* Field::value() const {
   ASSERT(is_static());  // Valid only for static dart fields.
   return raw_ptr()->value_;
 }
 
 
 void Field::set_value(const Instance& value) const {
   ASSERT(is_static());  // Valid only for static dart fields.
   StorePointer(&raw_ptr()->value_, value.raw());
 }
@@ skipping 31 matching lines @@
   }
   result.set_is_final(is_final);
   result.set_is_const(is_const);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_has_initializer(false);
   return result.raw();
 }
 
 
+
+RawField* Field::Clone(const Class& new_owner) const {
+  Field& clone = Field::Handle();
+  clone ^= Object::Clone(*this, Heap::kOld);
+  const Class& owner = Class::Handle(this->owner());
+  const PatchClass& clone_owner =
+      PatchClass::Handle(PatchClass::New(new_owner, owner));
+  clone.set_owner(clone_owner);
+  return clone.raw();
+}
+
+
 RawString* Field::UserVisibleName() const {
   const String& str = String::Handle(name());
   return IdentifierPrettyName(str);
 }
 
 
 const char* Field::ToCString() const {
   const char* kF0 = is_static() ? " static" : "";
   const char* kF1 = is_final() ? " final" : "";
   const char* kF2 = is_const() ? " const" : "";
@@ skipping 8092 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart