Revert "Simplify and fix implicit closure check, speed up Closure_equals"

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/become.h"
@@ skipping 5583 matching lines @@
 }
 
 const char* Function::KindToCString(RawFunction::Kind kind) {
   switch (kind) {
     case RawFunction::kRegularFunction:
       return "RegularFunction";
       break;
     case RawFunction::kClosureFunction:
       return "ClosureFunction";
       break;
-    case RawFunction::kImplicitClosureFunction:
-      return "ImplicitClosureFunction";
-      break;
     case RawFunction::kSignatureFunction:
       return "SignatureFunction";
       break;
     case RawFunction::kGetterFunction:
       return "GetterFunction";
       break;
     case RawFunction::kSetterFunction:
       return "SetterFunction";
       break;
     case RawFunction::kConstructor:
@@ skipping 366 matching lines @@
   return is_inlinable() && !is_external() && !is_generated_body() &&
          !thread->isolate()->debugger()->HasBreakpoint(*this, thread->zone());
 #endif
 }
 
 intptr_t Function::NumParameters() const {
   return num_fixed_parameters() + NumOptionalParameters();
 }
 
 intptr_t Function::NumImplicitParameters() const {
-  const RawFunction::Kind k = kind();
-  if (k == RawFunction::kConstructor) {
+  if (kind() == RawFunction::kConstructor) {
     // Type arguments for factory; instance for generative constructor.
     return 1;
   }
-  if ((k == RawFunction::kClosureFunction) ||
-      (k == RawFunction::kImplicitClosureFunction) ||
-      (k == RawFunction::kSignatureFunction)) {
+  if ((kind() == RawFunction::kClosureFunction) ||
+      (kind() == RawFunction::kSignatureFunction)) {
     return 1;  // Closure object.
   }
   if (!is_static()) {
     // Closure functions defined inside instance (i.e. non-static) functions are
     // marked as non-static, but they do not have a receiver.
     // Closures are handled above.
-    ASSERT((k != RawFunction::kClosureFunction) &&
-           (k != RawFunction::kImplicitClosureFunction) &&
-           (k != RawFunction::kSignatureFunction));
+    ASSERT((kind() != RawFunction::kClosureFunction) &&
+           (kind() != RawFunction::kSignatureFunction));
     return 1;  // Receiver.
   }
   return 0;  // No implicit parameters.
 }
 
 bool Function::AreValidArgumentCounts(intptr_t num_type_arguments,
                                       intptr_t num_arguments,
                                       intptr_t num_named_arguments,
                                       String* error_message) const {
   if ((num_type_arguments != 0) &&
@@ skipping 509 matching lines @@
   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 IsGenerativeConstructor() && (token_pos() == end_token_pos());
 }
 
+bool Function::IsImplicitClosureFunction() const {
+  if (!IsClosureFunction()) {
+    return false;
+  }
+  const Function& parent = Function::Handle(parent_function());
+  return (parent.implicit_closure_function() == raw());
+}
+
 bool Function::IsImplicitStaticClosureFunction(RawFunction* func) {
   NoSafepointScope no_safepoint;
   uint32_t kind_tag = func->ptr()->kind_tag_;
-  return (KindBits::decode(kind_tag) ==
-          RawFunction::kImplicitClosureFunction) &&
-         StaticBit::decode(kind_tag);
+  if (KindBits::decode(kind_tag) != RawFunction::kClosureFunction) {
+    return false;
+  }
+  if (!StaticBit::decode(kind_tag)) {
+    return false;
+  }
+  RawClosureData* data = reinterpret_cast<RawClosureData*>(func->ptr()->data_);
+  RawFunction* parent_function = data->ptr()->parent_function_;
+  return (parent_function->ptr()->data_ == reinterpret_cast<RawObject*>(func));
 }
 
 bool Function::IsConstructorClosureFunction() const {
   return IsClosureFunction() &&
          String::Handle(name()).StartsWith(Symbols::ConstructorClosurePrefix());
 }
 
 RawFunction* Function::New(Heap::Space space) {
   ASSERT(Object::function_class() != Class::null());
   RawObject* raw =
@@ skipping 43 matching lines @@
   NOT_IN_PRECOMPILED(result.set_optimized_instruction_count(0));
   NOT_IN_PRECOMPILED(result.set_optimized_call_site_count(0));
   result.set_kernel_offset(0);
   result.set_is_optimizable(is_native ? false : true);
   result.set_is_inlinable(true);
   result.set_allows_hoisting_check_class(true);
   result.set_allows_bounds_check_generalization(true);
   result.SetInstructionsSafe(
       Code::Handle(StubCode::LazyCompile_entry()->code()));
   if (kind == RawFunction::kClosureFunction ||
-      kind == RawFunction::kImplicitClosureFunction ||
       kind == RawFunction::kConvertedClosureFunction) {
     ASSERT(space == Heap::kOld);
     const ClosureData& data = ClosureData::Handle(ClosureData::New());
     result.set_data(data);
   } else if (kind == RawFunction::kSignatureFunction) {
     const SignatureData& data =
         SignatureData::Handle(SignatureData::New(space));
     result.set_data(data);
   } else {
     // Functions other than signature functions have no reason to be allocated
@@ skipping 45 matching lines @@
     clone.set_parameter_types(array);
     for (intptr_t i = 0; i < num_params; i++) {
       type = clone.ParameterTypeAt(i);
       type ^= type.CloneUninstantiated(new_owner);
       clone.SetParameterTypeAt(i, type);
     }
   }
   return clone.raw();
 }
 
-RawFunction* Function::NewClosureFunctionWithKind(RawFunction::Kind kind,
-                                                  const String& name,
-                                                  const Function& parent,
-                                                  TokenPosition token_pos) {
-  ASSERT((kind == RawFunction::kClosureFunction) ||
-         (kind == RawFunction::kImplicitClosureFunction) ||
-         (kind == RawFunction::kConvertedClosureFunction));
+RawFunction* Function::NewClosureFunction(const String& name,
+                                          const Function& parent,
+                                          TokenPosition token_pos) {
   ASSERT(!parent.IsNull());
-  // Only static top-level functions are allowed to be converted right now.
-  ASSERT((kind != RawFunction::kConvertedClosureFunction) ||
-         parent.is_static());
   // 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, kind,
+      Function::New(name, RawFunction::kClosureFunction,
                     /* is_static = */ parent.is_static(),
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     /* is_native = */ false, parent_owner, token_pos));
   result.set_parent_function(parent);
   return result.raw();
 }
 
-RawFunction* Function::NewClosureFunction(const String& name,
-                                          const Function& parent,
-                                          TokenPosition token_pos) {
-  return NewClosureFunctionWithKind(RawFunction::kClosureFunction, name, parent,
-                                    token_pos);
-}
-
-RawFunction* Function::NewImplicitClosureFunction(const String& name,
-                                                  const Function& parent,
-                                                  TokenPosition token_pos) {
-  return NewClosureFunctionWithKind(RawFunction::kImplicitClosureFunction, name,
-                                    parent, token_pos);
-}
-
 RawFunction* Function::NewConvertedClosureFunction(const String& name,
                                                    const Function& parent,
                                                    TokenPosition token_pos) {
-  return NewClosureFunctionWithKind(RawFunction::kConvertedClosureFunction,
-                                    name, parent, token_pos);
+  ASSERT(!parent.IsNull());
+  // Only static top-level functions are allowed to be converted right now.
+  ASSERT(parent.is_static());
+  // 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::kConvertedClosureFunction,
+                    /* is_static = */ true,
+                    /* is_const = */ false,
+                    /* is_abstract = */ false,
+                    /* is_external = */ false,
+                    /* is_native = */ false, parent_owner, token_pos));
+  result.set_parent_function(parent);
+  return result.raw();
 }
 
 RawFunction* Function::NewSignatureFunction(const Object& owner,
                                             const Function& parent,
                                             TokenPosition token_pos,
                                             Heap::Space space) {
   const Function& result = Function::Handle(Function::New(
       Symbols::AnonymousSignature(), RawFunction::kSignatureFunction,
       /* is_static = */ false,
       /* is_const = */ false,
@@ skipping 33 matching lines @@
   // Return the existing implicit closure function if any.
   if (implicit_closure_function() != Function::null()) {
     return implicit_closure_function();
   }
   ASSERT(!IsSignatureFunction() && !IsClosureFunction());
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   // Create closure function.
   const String& closure_name = String::Handle(zone, name());
   const Function& closure_function = Function::Handle(
-      zone, NewImplicitClosureFunction(closure_name, *this, token_pos()));
+      zone, NewClosureFunction(closure_name, *this, token_pos()));
 
   // Set closure function's context scope.
   if (is_static()) {
     closure_function.set_context_scope(Object::empty_context_scope());
   } else {
     const ContextScope& context_scope = ContextScope::Handle(
         zone, LocalScope::CreateImplicitClosureScope(*this));
     closure_function.set_context_scope(context_scope);
   }
 
@@ skipping 694 matching lines @@
   if (IsNull()) {
     return "Function: null";
   }
   const char* static_str = is_static() ? " static" : "";
   const char* abstract_str = is_abstract() ? " abstract" : "";
   const char* kind_str = NULL;
   const char* const_str = is_const() ? " const" : "";
   switch (kind()) {
     case RawFunction::kRegularFunction:
     case RawFunction::kClosureFunction:
-    case RawFunction::kImplicitClosureFunction:
     case RawFunction::kConvertedClosureFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
       kind_str = "";
       break;
     case RawFunction::kSignatureFunction:
       kind_str = " signature";
       break;
     case RawFunction::kConstructor:
       kind_str = is_static() ? " factory" : " constructor";
@@ skipping 15029 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart