[vm, aot] Ensure fixups applied after the world has been compiled are applied to closures in finall…

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 2168 matching lines @@
 
    private:
     Code& code_;
     Array& table_;
     Smi& pc_offset_;
     Function& target_;
     Code& target_code_;
   };
 
   BindStaticCallsVisitor visitor(Z);
+
+  // We need both iterations to ensure we visit all the functions that might end
+  // up in the snapshot. The ProgramVisitor will miss closures from duplicated
+  // finally clauses, and not all functions are compiled through the
+  // tree-shaker's queue
   ProgramVisitor::VisitFunctions(&visitor);
+  FunctionSet::Iterator it(enqueued_functions_.GetIterator());
+  for (const Function** current = it.Next(); current != NULL;
+       current = it.Next()) {
+    visitor.Visit(**current);
+  }
 }
 
 void Precompiler::SwitchICCalls() {
 #if !defined(TARGET_ARCH_DBC)
   // Now that all functions have been compiled, we can switch to an instance
   // call sequence that loads the Code object and entry point directly from
   // the ic data array instead indirectly through a Function in the ic data
   // array. Iterate all the object pools and rewrite the ic data from
   // (cid, target function, count) to (cid, target code, entry point), and
   // replace the ICCallThroughFunction stub with ICCallThroughCode.
@@ skipping 67 matching lines @@
     ICData& ic_;
     String& target_name_;
     Array& args_descriptor_;
     UnlinkedCall& unlinked_;
     Code& target_code_;
     UnlinkedCallSet canonical_unlinked_calls_;
   };
 
   ASSERT(!I->compilation_allowed());
   SwitchICCallsVisitor visitor(Z);
+
+  // We need both iterations to ensure we visit all the functions that might end
+  // up in the snapshot. The ProgramVisitor will miss closures from duplicated
+  // finally clauses, and not all functions are compiled through the
+  // tree-shaker's queue
   ProgramVisitor::VisitFunctions(&visitor);
+  FunctionSet::Iterator it(enqueued_functions_.GetIterator());
+  for (const Function** current = it.Next(); current != NULL;
+       current = it.Next()) {
+    visitor.Visit(**current);
+  }
 #endif
 }
 
 void Precompiler::FinalizeAllClasses() {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     if (!lib.Loaded()) {
@@ skipping 1034 matching lines @@
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   DartPrecompilationPipeline pipeline(zone, field_type_map);
   return PrecompileFunctionHelper(precompiler, &pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart