Properly handle implicit closure function when a generic function.

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 5598 matching lines @@
   if (IsClosureFunction()) {
     ClosureData::Cast(obj).set_parent_function(value);
   } else {
     ASSERT(IsSignatureFunction());
     SignatureData::Cast(obj).set_parent_function(value);
   }
 }
 
 
 bool Function::HasGenericParent() const {
+  if (IsImplicitClosureFunction()) {
+    // The parent function of an implicit closure function is not the enclosing
+    // function we are asking about here.
+    return false;
+  }
   Function& parent = Function::Handle(parent_function());
   while (!parent.IsNull()) {
     if (parent.IsGeneric()) {
       return true;
     }
     parent = parent.parent_function();
   }
   return false;
 }
 
@@ skipping 378 matching lines @@
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(thread);
   TypeArguments& type_params = thread->TypeArgumentsHandle();
   type_params = type_parameters();
   // We require null to represent a non-generic function.
   ASSERT(type_params.Length() != 0);
   return type_params.Length();
 }
 
 
 intptr_t Function::NumParentTypeParameters() const {
+  if (IsImplicitClosureFunction()) {
+    return 0;
+  }
   Thread* thread = Thread::Current();
   Function& parent = Function::Handle(parent_function());
   intptr_t num_parent_type_params = 0;
   while (!parent.IsNull()) {
     num_parent_type_params += parent.NumTypeParameters(thread);
     parent ^= parent.parent_function();
   }
   return num_parent_type_params;
 }
 
@@ skipping 18 matching lines @@
     if (!type_params.IsNull()) {
       const intptr_t num_type_params = type_params.Length();
       for (intptr_t i = 0; i < num_type_params; i++) {
         type_param ^= type_params.TypeAt(i);
         type_param_name = type_param.name();
         if (type_param_name.Equals(type_name)) {
           return type_param.raw();
         }
       }
     }
+    if (function.IsImplicitClosureFunction()) {
+      // The parent function is not the enclosing function, but the closurized
+      // function with identical type parameters.
+      break;
+    }
     function ^= function.parent_function();
     if (function_level != NULL) {
       (*function_level)--;
     }
   }
   return TypeParameter::null();
 }
 
 
 void Function::set_kind(RawFunction::Kind value) const {
@@ skipping 271 matching lines @@
 // constructed name is a valid C++ identifier for debugging purpose.
 // Set 'chars' to allocated buffer and return number of written characters.
 
 enum QualifiedFunctionLibKind {
   kQualifiedFunctionLibKindLibUrl,
   kQualifiedFunctionLibKindLibName
 };
 
 
 static intptr_t ConstructFunctionFullyQualifiedCString(
-    const Function& function,
+    const Function& fun,
     char** chars,
     intptr_t reserve_len,
     bool with_lib,
     QualifiedFunctionLibKind lib_kind) {
+  // Hide implicit closure functions.
+  const Function& function = Function::Handle(

[rmacnak, 2017/04/25 19:21:42]

I think this output is only used for debug printing in the VM. Can we keep the
current format or some other identifying mark in the string? It's helpful to
distinguish the implicit closure function.

[regis, 2017/04/25 19:57:26]

OK, I removed the change.

+      fun.IsImplicitClosureFunction() ? fun.parent_function() : fun.raw());
   const char* name = String::Handle(function.name()).ToCString();
   const char* function_format = (reserve_len == 0) ? "%s" : "%s_";
   reserve_len += OS::SNPrint(NULL, 0, function_format, name);
   const Function& parent = Function::Handle(function.parent_function());
   intptr_t written = 0;
   if (parent.IsNull()) {
     const Class& function_class = Class::Handle(function.Owner());
     ASSERT(!function_class.IsNull());
     const char* class_name = String::Handle(function_class.Name()).ToCString();
     ASSERT(class_name != NULL);
@@ skipping 16949 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart