Toward a green tools/build.py -cprecompiler -rdart_precompiled:

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 572 matching lines @@
         types = handlers.GetHandledTypes(i);
         if (!types.IsNull()) {
           for (intptr_t j = 0; j < types.Length(); j++) {
             type ^= types.At(j);
             AddType(type);
           }
         }
       }
     }
   }
+  // A function can always be inlined and have only a nested local function
+  // remain.
+  const Function& parent = Function::Handle(Z, function.parent_function());
+  if (!parent.IsNull()) {
+    AddTypesOf(parent);
+  }
+  // A class may have all functions inlined except a local function.
+  const Class& owner = Class::Handle(Z, function.Owner());
+  AddTypesOf(owner);
 }
 
 
 void Precompiler::AddType(const AbstractType& abstype) {
   if (abstype.IsNull()) return;
 
   if (types_to_retain_.Lookup(&abstype) != NULL) return;
   types_to_retain_.Insert(&AbstractType::ZoneHandle(Z, abstype.raw()));
 
   if (abstype.IsType()) {
@@ skipping 13 matching lines @@
   } else if (abstype.IsBoundedType()) {
     AbstractType& type = AbstractType::Handle(Z);
     type = BoundedType::Cast(abstype).type();
     AddType(type);
     type = BoundedType::Cast(abstype).bound();
     AddType(type);
   } else if (abstype.IsTypeRef()) {
     AbstractType& type = AbstractType::Handle(Z);
     type = TypeRef::Cast(abstype).type();
     AddType(type);
+  } else if (abstype.IsTypeParameter()) {
+    const AbstractType& type =
+        AbstractType::Handle(Z, TypeParameter::Cast(abstype).bound());
+    AddType(type);
+    const Class& cls =
+        Class::Handle(Z, TypeParameter::Cast(abstype).parameterized_class());
+    AddTypesOf(cls);
   }
 }
 
 
 void Precompiler::AddTypeArguments(const TypeArguments& args) {
   if (args.IsNull()) return;
 
   if (typeargs_to_retain_.Lookup(&args) != NULL) return;
   typeargs_to_retain_.Insert(&TypeArguments::ZoneHandle(Z, args.raw()));
 
@@ skipping 1885 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