Support redirecting factory constructors in the VM (issue 3969).

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 63 matching lines @@
 RawClass* Object::unresolved_class_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_parameter_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_arguments_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::patch_class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::closure_data_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::redirection_data_class_ =
+    reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::field_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::literal_token_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::token_stream_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::script_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_prefix_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::code_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::pc_descriptors_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::stackmap_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 235 matching lines @@
 
   cls = Class::New<PatchClass>();
   patch_class_class_ = cls.raw();
 
   cls = Class::New<Function>();
   function_class_ = cls.raw();
 
   cls = Class::New<ClosureData>();
   closure_data_class_ = cls.raw();
 
+  cls = Class::New<RedirectionData>();
+  redirection_data_class_ = cls.raw();
+
   cls = Class::New<Field>();
   field_class_ = cls.raw();
 
   cls = Class::New<LiteralToken>();
   literal_token_class_ = cls.raw();
 
   cls = Class::New<TokenStream>();
   token_stream_class_ = cls.raw();
 
   cls = Class::New<Script>();
@@ skipping 85 matching lines @@
   SET_CLASS_NAME(dynamic, Dynamic);
   SET_CLASS_NAME(void, Void);
   SET_CLASS_NAME(unresolved_class, UnresolvedClass);
   SET_CLASS_NAME(type, Type);
   SET_CLASS_NAME(type_parameter, TypeParameter);
   SET_CLASS_NAME(type_arguments, TypeArguments);
   SET_CLASS_NAME(instantiated_type_arguments, InstantiatedTypeArguments);
   SET_CLASS_NAME(patch_class, PatchClass);
   SET_CLASS_NAME(function, Function);
   SET_CLASS_NAME(closure_data, ClosureData);
+  SET_CLASS_NAME(redirection_data, RedirectionData);
   SET_CLASS_NAME(field, Field);
   SET_CLASS_NAME(literal_token, LiteralToken);
   SET_CLASS_NAME(token_stream, TokenStream);
   SET_CLASS_NAME(script, Script);
   SET_CLASS_NAME(library, LibraryClass);
   SET_CLASS_NAME(library_prefix, LibraryPrefix);
   SET_CLASS_NAME(code, Code);
   SET_CLASS_NAME(instructions, Instructions);
   SET_CLASS_NAME(pc_descriptors, PcDescriptors);
   SET_CLASS_NAME(stackmap, Stackmap);
@@ skipping 3475 matching lines @@
   if (IsClosureFunction()) {
     const Object& obj = Object::Handle(raw_ptr()->data_);
     ASSERT(!obj.IsNull());
     ClosureData::Cast(obj).set_signature_class(value);
     return;
   }
   UNREACHABLE();
 }
 
 
+bool Function::IsRedirectingFactory() const {
+  if (!IsFactory() || (raw_ptr()->data_ == Object::null())) {
+    return false;
+  }
+  ASSERT(!IsClosure());  // A factory cannot also be a closure.
+  return true;
+}
+
+
+RawType* Function::RedirectionType() const {
+  ASSERT(IsRedirectingFactory());
+  const Object& obj = Object::Handle(raw_ptr()->data_);
+  ASSERT(!obj.IsNull());
+  return RedirectionData::Cast(obj).type();
+}
+
+
+void Function::SetRedirectionType(const Type& type) const {
+  ASSERT(IsFactory());
+  Object& obj = Object::Handle(raw_ptr()->data_);
+  if (obj.IsNull()) {
+    obj = RedirectionData::New();
+    set_data(obj);
+  }
+  RedirectionData::Cast(obj).set_type(type);
+}
+
+
+RawString* Function::RedirectionIdentifier() const {
+  ASSERT(IsRedirectingFactory());
+  const Object& obj = Object::Handle(raw_ptr()->data_);
+  ASSERT(!obj.IsNull());
+  return RedirectionData::Cast(obj).identifier();
+}
+
+
+void Function::SetRedirectionIdentifier(const String& identifier) const {
+  ASSERT(IsFactory());
+  Object& obj = Object::Handle(raw_ptr()->data_);
+  if (obj.IsNull()) {
+    obj = RedirectionData::New();
+    set_data(obj);
+  }
+  RedirectionData::Cast(obj).set_identifier(identifier);
+}
+
+
+RawFunction* Function::RedirectionTarget() const {
+  ASSERT(IsRedirectingFactory());
+  const Object& obj = Object::Handle(raw_ptr()->data_);
+  ASSERT(!obj.IsNull());
+  return RedirectionData::Cast(obj).target();
+}
+
+
+void Function::SetRedirectionTarget(const Function& target) const {
+  ASSERT(IsFactory());
+  Object& obj = Object::Handle(raw_ptr()->data_);
+  if (obj.IsNull()) {
+    obj = RedirectionData::New();
+    set_data(obj);
+  }
+  RedirectionData::Cast(obj).set_target(target);
+}
+
+
 void Function::set_data(const Object& value) const {
   StorePointer(&raw_ptr()->data_, value.raw());
 }
 
 
 bool Function::IsInFactoryScope() const {
   Function& outer_function = Function::Handle(raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
@@ skipping 370 matching lines @@
 
 bool Function::HasCompatibleParametersWith(const Function& other) const {
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
   const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t other_num_fixed_params = other.num_fixed_parameters();
   const intptr_t other_num_opt_pos_params =
       other.NumOptionalPositionalParameters();
   const intptr_t other_num_opt_named_params =
       other.NumOptionalNamedParameters();
+  // A generative constructor may be compared to a redirecting factory and be
+  // compatible although it has an additional phase parameter.
+  const intptr_t num_ignored_params =
+      (other.IsRedirectingFactory() && IsConstructor()) ? 1 : 0;
   if (FLAG_reject_named_argument_as_positional) {
     // The default values of optional parameters can differ.
-    if ((num_fixed_params != other_num_fixed_params) ||
+    if (((num_fixed_params - num_ignored_params) != other_num_fixed_params) ||
         (num_opt_pos_params < other_num_opt_pos_params) ||
         (num_opt_named_params < other_num_opt_named_params)) {
       return false;
     }
     if (other_num_opt_named_params == 0) {
       return true;
     }
     // Check that for each optional named parameter of the other function there
     // exists an optional named parameter of this function with an identical
     // name.
@@ skipping 19 matching lines @@
     }
     return true;
   }
 
   // TODO(regis): Remove the following code once the flag is removed.
 
   // The default values of optional parameters can differ.
   const intptr_t num_opt_params = num_opt_pos_params + num_opt_named_params;
   const intptr_t other_num_opt_params =
       other_num_opt_pos_params + other_num_opt_named_params;
-  if ((num_fixed_params != other_num_fixed_params) ||
+  if (((num_fixed_params - num_ignored_params) != other_num_fixed_params) ||
       (num_opt_params < other_num_opt_params)) {
     return false;
   }
   // Check that for each optional named parameter of the other function there is
   // a corresponding optional named parameter of this function with an identical
   // name at the same position.
   // Note that SetParameterNameAt() guarantees that names are symbols, so we can
   // compare their raw pointers.
   const int other_num_params = other_num_fixed_params + other_num_opt_params;
   for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
@@ skipping 590 matching lines @@
                                     Heap::kOld);
   return reinterpret_cast<RawClosureData*>(raw);
 }
 
 
 const char* ClosureData::ToCString() const {
   return "ClosureData class";
 }
 
 
+void RedirectionData::set_type(const Type& value) const {
+  ASSERT(!value.IsNull());
+  StorePointer(&raw_ptr()->type_, value.raw());
+}
+
+
+void RedirectionData::set_identifier(const String& value) const {
+  StorePointer(&raw_ptr()->identifier_, value.raw());
+}
+
+
+void RedirectionData::set_target(const Function& value) const {
+  StorePointer(&raw_ptr()->target_, value.raw());
+}
+
+
+RawRedirectionData* RedirectionData::New() {
+  ASSERT(Object::redirection_data_class() != Class::null());
+  RawObject* raw = Object::Allocate(RedirectionData::kClassId,
+                                    RedirectionData::InstanceSize(),
+                                    Heap::kOld);
+  return reinterpret_cast<RawRedirectionData*>(raw);
+}
+
+
+const char* RedirectionData::ToCString() const {
+  return "RedirectionData class";
+}
+
+
 RawString* Field::GetterName(const String& field_name) {
   String& str = String::Handle();
   str = String::New(kGetterPrefix);
   str = String::Concat(str, field_name);
   return str.raw();
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
   String& str = String::Handle();
@@ skipping 6941 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart