Precompilation: Including generative constructor entry points should mark a class as instantiated.

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/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
@@ skipping 168 matching lines @@
     kCapabilityCid,
     ReceivePort::kClassId,
     SendPort::kClassId,
 
     kIllegalCid
   };
 
   Class& cls = Class::Handle(Z);
   for (intptr_t i = 0; kExternallyAllocatedCids[i] != kIllegalCid; i++) {
     cls = isolate()->class_table()->At(kExternallyAllocatedCids[i]);
-    AddClass(cls);
+    AddInstantiatedClass(cls);
   }
 
   Dart_QualifiedFunctionName vm_entry_points[] = {
     { "dart:async", "::", "_setScheduleImmediateClosure" },
     { "dart:core", "::", "_completeDeferredLoads"},
     { "dart:core", "AbstractClassInstantiationError",
                    "AbstractClassInstantiationError._create" },
     { "dart:core", "ArgumentError", "ArgumentError." },
     { "dart:core", "AssertionError", "AssertionError." },
     { "dart:core", "CyclicInitializationError",
@@ skipping 75 matching lines @@
       if (FLAG_trace_precompiler) {
         THR_Print("WARNING: Missing %s %s %s\n",
                   entry_points[i].library_uri,
                   entry_points[i].class_name,
                   entry_points[i].function_name);
       }
       continue;
     }
 
     AddFunction(func);
+    if (func.IsGenerativeConstructor()) {
+      // Allocation stubs are referenced from the call site of the constructor,
+      // not in the constructor itself. So compiling the constructor isn't
+      // enough for us to discover the class is instantiated if the class isn't
+      // otherwise instantiated from Dart code and only instantiated from C++.
+      AddInstantiatedClass(cls);
+    }
   }
 }
 
 
 void Precompiler::Iterate() {
   Function& function = Function::Handle(Z);
 
   while (changed_) {
     changed_ = false;
 
@@ skipping 93 matching lines @@
         instance ^= entry.raw();
         AddConstObject(instance);
       } else if (entry.IsFunction()) {
         // Local closure function.
         target ^= entry.raw();
         AddFunction(target);
       } else if (entry.IsCode()) {
         target_code ^= entry.raw();
         if (target_code.IsAllocationStubCode()) {
           cls ^= target_code.owner();
-          AddClass(cls);
+          AddInstantiatedClass(cls);
         }
       }
     }
   }
 }
 
 
 void Precompiler::AddConstObject(const Instance& instance) {
   const Class& cls = Class::Handle(Z, instance.clazz());
-  AddClass(cls);
+  AddInstantiatedClass(cls);
 
   if (instance.IsClosure()) {
     // An implicit static closure.
     const Function& func = Function::Handle(Z, Closure::function(instance));
     ASSERT(func.is_static());
     AddFunction(func);
     return;
   }
 
   // Can't ask immediate objects if they're canoncial.
@@ skipping 104 matching lines @@
 
     if (FLAG_trace_precompiler) {
       THR_Print("Enqueueing selector %" Pd " %s\n",
                 selector_count_,
                 selector.ToCString());
     }
   }
 }
 
 
-void Precompiler::AddClass(const Class& cls) {
+void Precompiler::AddInstantiatedClass(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);
+    AddInstantiatedClass(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);
@@ skipping 309 matching lines @@
         continue;  // class 'dynamic' is in the read-only VM isolate.
       }
       cls.EnsureIsFinalized(T);
     }
   }
   I->set_all_classes_finalized(true);
 }
 
 
 }  // namespace dart