Non-tree-shaking --precompile.

runtime/vm/compiler.cc

 // Copyright (c) 2012, 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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 1063 matching lines @@
   return Error::null();
 }
 
 
 RawError* Compiler::CompileFunction(Thread* thread,
                                     const Function& function) {
   Isolate* isolate = thread->isolate();
   VMTagScope tagScope(isolate, VMTag::kCompileUnoptimizedTagId);
   TIMELINE_FUNCTION_COMPILATION_DURATION(isolate, "Function", function);
 
+  if (!isolate->compilation_allowed()) {
+    FATAL2("Precompilation missed function %s (%s)\n",
+           function.ToQualifiedCString(),
+           Function::KindToCString(function.kind()));
+  }
+
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
 
   const bool optimized =
       Compiler::always_optimize() && function.IsOptimizable();
 
   return CompileFunctionHelper(pipeline, function, optimized,
       Isolate::kNoDeoptId);
 }
 
@@ skipping 140 matching lines @@
 
 
 static void CreateLocalVarDescriptors(const ParsedFunction& parsed_function) {
   const Function& func = parsed_function.function();
   LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle();
   var_descs = parsed_function.node_sequence()->scope()->GetVarDescriptors(func);
   Code::Handle(func.unoptimized_code()).set_var_descriptors(var_descs);
 }
 
 
+void Compiler::CompileStaticInitializer(const Field& field) {
+  ASSERT(field.is_static());
+  if (field.initializer() != Function::null()) {
+    // TODO(rmacnak): Investigate why this happens for _enum_names.
+    OS::Print("Warning: Ignoring repeated request for initializer for %s\n",
+              field.ToCString());
+    return;
+  }
+  ASSERT(field.initializer() == Function::null());
+  Isolate* isolate = Isolate::Current();
+  StackZone zone(isolate);
+
+  ParsedFunction* parsed_function = Parser::ParseStaticFieldInitializer(field);
+
+  parsed_function->AllocateVariables();
+  // Non-optimized code generator.
+  DartCompilationPipeline pipeline;
+  CompileParsedFunctionHelper(&pipeline,
+                              parsed_function,
+                              false,  // optimized
+                              Isolate::kNoDeoptId);
+
+  const Function& initializer = parsed_function->function();
+  field.set_initializer(initializer);
+}
+
+
 RawObject* Compiler::EvaluateStaticInitializer(const Field& field) {
   ASSERT(field.is_static());
   // The VM sets the field's value to transiton_sentinel prior to
   // evaluating the initializer value.
   ASSERT(field.value() == Object::transition_sentinel().raw());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
-    Isolate* const isolate = Isolate::Current();
-    StackZone zone(isolate);
-    ParsedFunction* parsed_function =
-        Parser::ParseStaticFieldInitializer(field);
+    Function& initializer = Function::Handle(field.initializer());
 
-    parsed_function->AllocateVariables();
-    // Non-optimized code generator.
-    DartCompilationPipeline pipeline;
-    CompileParsedFunctionHelper(&pipeline,
-                                parsed_function,
-                                false,
-                                Isolate::kNoDeoptId);
-    // Eagerly create local var descriptors.
-    CreateLocalVarDescriptors(*parsed_function);
+    // Under precompilation, the initializer may have already been compiled, in
+    // which case use it. Under lazy compilation or early in precompilation, the
+    // initializer has not yet been created, so create it now, but don't bother
+    // remembering it because it won't be used again.
+    if (initializer.IsNull()) {
+      Isolate* const isolate = Isolate::Current();
+      StackZone zone(isolate);
+      ParsedFunction* parsed_function =
+          Parser::ParseStaticFieldInitializer(field);
 
+      parsed_function->AllocateVariables();
+      // Non-optimized code generator.
+      DartCompilationPipeline pipeline;
+      CompileParsedFunctionHelper(&pipeline,
+                                  parsed_function,
+                                  false,  // optimized
+                                  Isolate::kNoDeoptId);
+      // Eagerly create local var descriptors.
+      CreateLocalVarDescriptors(*parsed_function);
+
+      initializer = parsed_function->function().raw();
+    }
     // Invoke the function to evaluate the expression.
-    const Function& initializer = parsed_function->function();
     const Object& result = PassiveObject::Handle(
         DartEntry::InvokeFunction(initializer, Object::empty_array()));
     return result.raw();
   } else {
     Isolate* const isolate = Isolate::Current();
     StackZone zone(isolate);
     const Error& error =
         Error::Handle(isolate, isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return error.raw();
@@ skipping 64 matching lines @@
     const Object& result =
       PassiveObject::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart