Avoid eagerly enqueueing converted forms of selectors or eagerly creating their converted symbols.

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/compiler.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
@@ skipping 46 matching lines @@
   pending_functions_(GrowableObjectArray::Handle(Z,
                                                  GrowableObjectArray::New())),
   collected_closures_(GrowableObjectArray::Handle(Z, I->collected_closures())),
   sent_selectors_(Z),
   error_(Error::Handle(Z)) {
 }
 
 
 void Precompiler::DoCompileAll(
     Dart_QualifiedFunctionName embedder_entry_points[]) {
-  LogBlock lb;
-
   // Drop all existing code so we can use the presence of code as an indicator
   // that we have already looked for the function's callees.
   ClearAllCode();
 
   // Start with the allocations and invocations that happen from C++.
   AddRoots(embedder_entry_points);
 
   // TODO(rmacnak): Eagerly add field-invocation functions to all signature
   // classes so closure calls don't go through the runtime.
 
@@ skipping 385 matching lines @@
 
 void Precompiler::AddFunction(const Function& function) {
   if (function.HasCode()) return;
 
   pending_functions_.Add(function);
   changed_ = true;
 }
 
 
 bool Precompiler::IsSent(const String& selector) {
+  if (selector.IsNull()) {
+    return false;
+  }
   return sent_selectors_.Includes(selector);
 }
 
 
 void Precompiler::AddSelector(const String& selector) {
   if (!IsSent(selector)) {

[hausner, 2015/09/29 19:43:21]

You enter this if for a null selector. Is that on purpose?

[rmacnak, 2015/09/29 20:40:06]

AddSelector should never be called with null, selectors from instance call
sites. Added assert. IsSent may see a null if we lookup a getter that doesn't
exist.

     sent_selectors_.Add(selector);
     selector_count_++;
     changed_ = true;
 
     if (FLAG_trace_precompiler) {
       THR_Print("Enqueueing selector %" Pd " %s\n",
                 selector_count_,
                 selector.ToCString());
     }
-
-    if (!Field::IsGetterName(selector) &&
-        !Field::IsSetterName(selector)) {
-      // Regular method may be call-through-getter.
-      const String& getter = String::Handle(Field::GetterSymbol(selector));
-      AddSelector(getter);
-    }
   }
 }
 
 
 void Precompiler::AddClass(const Class& cls) {
   if (cls.is_allocated()) return;
 
   class_count_++;
   cls.set_is_allocated();
   changed_ = true;
 
   if (FLAG_trace_precompiler) {
     THR_Print("Allocation %" Pd " %s\n", class_count_, cls.ToCString());
   }
 
   const Class& superclass = Class::Handle(cls.SuperClass());
   if (!superclass.IsNull()) {
     AddClass(superclass);
   }
 }
 
 
 void Precompiler::CheckForNewDynamicFunctions() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
   Function& function = Function::Handle(Z);
+  Function& function2 = Function::Handle(Z);
   String& selector = String::Handle(Z);
+  String& selector2 = String::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
     while (it.HasNext()) {
       cls = it.GetNextClass();
 
       if (!cls.is_allocated()) {
         bool has_compiled_constructor = false;
         if (cls.allocation_stub() != Code::null()) {
@@ skipping 40 matching lines @@
 
         // Don't bail out early if there is already code because we may discover
         // the corresponding getter selector is sent in some later iteration.
         // if (function.HasCode()) continue;
 
         selector = function.name();
         if (IsSent(selector)) {
           AddFunction(function);
         }
 
-        if (function.kind() == RawFunction::kRegularFunction &&
-            !Field::IsGetterName(selector) &&
-            !Field::IsSetterName(selector)) {
-          selector = Field::GetterSymbol(selector);
-          if (IsSent(selector)) {
-            function = function.ImplicitClosureFunction();
+        // Handle the implicit call type conversions.
+        if (Field::IsGetterName(selector)) {
+          selector2 = Field::NameFromGetter(selector);
+          selector2 = Symbols::Lookup(selector2);

[hausner, 2015/09/29 19:43:21]

Is this symbol guaranteed to exist?

[rmacnak, 2015/09/29 20:40:06]

In this case, yes. There cannot be a getter function without the corresponding
name having been made a symbol by the scanner. But it isn't guaranteed for the
other conversions below, and we generally don't rely on it existing. In fact we
hope it doesn't exist so we don't have to compile.

+          if (IsSent(selector2)) {
+            // Call-through-getter.
+            // Function is get:foo and somewhere foo is called.
             AddFunction(function);
           }
+          selector2 = Field::NameFromGetter(selector);

[hausner, 2015/09/29 19:43:21]

This has been computed above. Why do it again?

[rmacnak, 2015/09/29 20:40:06]

Hoisted out.

+          selector2 = Symbols::LookupFromConcat(Symbols::ClosurizePrefix(),
+                                                selector2);
+          if (IsSent(selector2)) {
+            // Hash-closurization.
+            // Function is get:foo and somewhere get:#foo is called.
+            AddFunction(function);
+
+            function2 = function.ImplicitClosureFunction();
+            AddFunction(function2);
+          }
+        } else if (Field::IsSetterName(selector)) {
+          selector2 = Symbols::LookupFromConcat(Symbols::ClosurizePrefix(),
+                                                selector);
+          if (IsSent(selector2)) {
+            // Hash-closurization.
+            // Function is set:foo and somewhere get:#set:foo is called.
+            AddFunction(function);
+
+            function2 = function.ImplicitClosureFunction();
+            AddFunction(function2);
+          }
+        } else if (function.kind() == RawFunction::kRegularFunction) {
+          selector2 = Field::LookupGetterSymbol(selector);
+          if (IsSent(selector2)) {
+            // Closurization.
+            // Function is foo and somewhere get:foo is called.
+            function2 = function.ImplicitClosureFunction();
+            AddFunction(function2);
+          }
+          selector2 = Symbols::LookupFromConcat(Symbols::ClosurizePrefix(),
+                                                selector);
+          if (IsSent(selector2)) {
+            // Hash-closurization.
+            // Function is foo and somewhere get:#foo is called.
+            function2 = function.ImplicitClosureFunction();
+            AddFunction(function2);
+          }
         }
       }
     }
   }
 }
 
 
 void Precompiler::DropUncompiledFunctions() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
@@ skipping 38 matching lines @@
         for (intptr_t j = 0; j < closures.Length(); j++) {
           function ^= closures.At(j);
           ASSERT(function.HasCode());
         }
       }
     }
   }
 }
 
 }  // namespace dart