Fix incorrect assertion failures in noopt regarding removing classes that still have constants.

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/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 185 matching lines @@
       Iterate();
     }
 
     I->set_compilation_allowed(false);
 
     DropFunctions();
     DropFields();
     TraceTypesFromRetainedClasses();
     DropTypes();
     DropTypeArguments();
+
+    // Clear these before dropping classes as they may hold onto otherwise
+    // dead instances of classes we will remove.
+    I->object_store()->set_compile_time_constants(Array::null_array());
+    I->object_store()->set_unique_dynamic_targets(Array::null_array());
+
     DropClasses();
     DropLibraries();
 
     BindStaticCalls();
 
     DedupStackmaps();
     DedupStackmapLists();
 
     if (FLAG_dedup_instructions) {
       // Reduces binary size but obfuscates profiler results.
       DedupInstructions();
     }
 
-    I->object_store()->set_compile_time_constants(Array::null_array());
-    I->object_store()->set_unique_dynamic_targets(Array::null_array());
-
     zone_ = NULL;
   }
 
   intptr_t dropped_symbols_count = Symbols::Compact(I);
 
   if (FLAG_trace_precompiler) {
     THR_Print("Precompiled %" Pd " functions,", function_count_);
     THR_Print(" %" Pd " dynamic types,", class_count_);
     THR_Print(" %" Pd " dynamic selectors.\n", selector_count_);
 
@@ skipping 1234 matching lines @@
         constant ^= constants.At(j);
         bool retain = consts_to_retain_.Lookup(&constant) != NULL;
         if (retain) {
           retained_constants.Add(constant);
         }
       }
       if (retained_constants.Length() > 0) {
         constants = Array::MakeArray(retained_constants);
         cls.set_constants(constants);
       } else {
+        constants = Object::empty_array().raw();
         cls.set_constants(Object::empty_array());
       }
 
       if (constants.Length() > 0) {
         ASSERT(retain);  // This shouldn't be the reason we keep a class.
         retain = true;
       }
 
       if (retain) {
         AddTypesOf(cls);
       }
     }
   }
 }
 
 
 void Precompiler::DropClasses() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
-  Array& members = Array::Handle(Z);
+  Array& constants = Array::Handle(Z);
   String& name = String::Handle(Z);
 
 #if defined(DEBUG)
-  {
-    // Force GC for allocation stats.
-    I->heap()->CollectAllGarbage();
-  }
+  // We are about to remove classes from the class table. For this to be safe,
+  // there must be no instances of these classes on the heap, not even
+  // corpses because the class table entry may be used to find the size of
+  // corpses. Request a full GC and wait for the sweeper tasks to finish before
+  // we continue.
+  I->heap()->CollectAllGarbage();
+  I->heap()->WaitForSweeperTasks();
 #endif
 
   ClassTable* class_table = I->class_table();
   intptr_t num_cids = class_table->NumCids();
 
   for (intptr_t cid = kNumPredefinedCids; cid < num_cids; cid++) {
     if (!class_table->IsValidIndex(cid)) continue;
     if (!class_table->HasValidClassAt(cid)) continue;
 
     cls = class_table->At(cid);
     ASSERT(!cls.IsNull());
 
     if (cls.IsTopLevel()) {
       // Top-level classes are referenced directly from their library. They
       // will only be removed as a consequence of an entire library being
       // removed.
       continue;
     }
-    if (cls.is_enum_class()) {
-      // Enum classes have live instances, so we cannot unregister
-      // them.
-      continue;
-    }
-    members = cls.constants();
-    if (members.Length() > 0) {
-      // --compile_all?
-      continue;
-    }
 
     bool retain = classes_to_retain_.Lookup(&cls) != NULL;
     if (retain) {
       continue;
     }
 
+    ASSERT(!cls.is_allocated());
+    constants = cls.constants();
+    ASSERT(constants.Length() == 0);
+
 #if defined(DEBUG)
     intptr_t instances =
         class_table->StatsWithUpdatedSize(cid)->post_gc.new_count +
         class_table->StatsWithUpdatedSize(cid)->post_gc.old_count;
     if (instances != 0) {
       FATAL2("Want to drop class %s, but it has %" Pd " instances\n",
              cls.ToCString(),
              instances);
     }
 #endif
@@ skipping 1048 matching lines @@
       CompilationPipeline::New(thread->zone(), function);
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   return PrecompileFunctionHelper(pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart