Be more vigilant with deferred loading.

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 367 matching lines @@
         optimized_(optimized),
         osr_id_(osr_id),
         thread_(Thread::Current()),
         cha_invalidation_gen_at_start_(isolate()->cha_invalidation_gen()),
         field_invalidation_gen_at_start_(isolate()->field_invalidation_gen()),
         prefix_invalidation_gen_at_start_(
             isolate()->prefix_invalidation_gen()) {
   }
 
   bool Compile(CompilationPipeline* pipeline);
+  uint32_t prefix_invalidation_gen_at_start() const {
+    return prefix_invalidation_gen_at_start_;
+  }
 
  private:
   ParsedFunction* parsed_function() const { return parsed_function_; }
   bool optimized() const { return optimized_; }
   intptr_t osr_id() const { return osr_id_; }
   Thread* thread() const { return thread_; }
   Isolate* isolate() const { return thread_->isolate(); }
   uint32_t cha_invalidation_gen_at_start() const {
     return cha_invalidation_gen_at_start_;
   }
   uint32_t field_invalidation_gen_at_start() const {
     return field_invalidation_gen_at_start_;
   }
-  uint32_t prefix_invalidation_gen_at_start() const {
-    return prefix_invalidation_gen_at_start_;
-  }
   void FinalizeCompilation(Assembler* assembler,
                            FlowGraphCompiler* graph_compiler,
                            FlowGraph* flow_graph);
 
   ParsedFunction* parsed_function_;
   const bool optimized_;
   const intptr_t osr_id_;
   Thread* const thread_;
   const uint32_t cha_invalidation_gen_at_start_;
   const uint32_t field_invalidation_gen_at_start_;
@@ skipping 733 matching lines @@
                 (optimized ? "optimized " : ""),
                 (Compiler::IsBackgroundCompilation() ? "(background)" : ""),
                 function.ToFullyQualifiedCString(),
                 function.token_pos().ToCString(),
                 token_size);
     }
     INC_STAT(thread, num_functions_compiled, 1);
     if (optimized) {
       INC_STAT(thread, num_functions_optimized, 1);
     }
+    // Makes sure no libraries are loaded during parsing.
+    const uint32_t prefix_invalidation_gen_at_start =
+        isolate->prefix_invalidation_gen();
     {
       HANDLESCOPE(thread);
       const int64_t num_tokens_before = STAT_VALUE(thread, num_tokens_consumed);
       pipeline->ParseFunction(parsed_function);
       const int64_t num_tokens_after = STAT_VALUE(thread, num_tokens_consumed);
       INC_STAT(thread,
                num_func_tokens_compiled,
                num_tokens_after - num_tokens_before);
     }
 
     CompileParsedFunctionHelper helper(parsed_function, optimized, osr_id);
+    if (prefix_invalidation_gen_at_start !=
+        helper.prefix_invalidation_gen_at_start()) {
+      ASSERT(Compiler::IsBackgroundCompilation());
+      // Deferred loading occured while parsing or copying ICData.
+      Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId);

[rmacnak, 2016/03/24 18:18:19]

Add comment here that we need to abort because the deopt-ids may have changed.

[srdjan, 2016/03/24 18:22:08]

Done.

+    }
     const bool success = helper.Compile(pipeline);
     if (!success) {
       if (optimized) {
         if (Compiler::IsBackgroundCompilation()) {
           // Try again later, background compilation may abort because of
           // state change during compilation.
           if (FLAG_trace_compiler) {
             THR_Print("Aborted background compilation: %s\n",
                 function.ToFullyQualifiedCString());
           }
@@ skipping 192 matching lines @@
   ASSERT(!code.is_optimized());
   const Function& function = Function::Handle(code.function());
   ParsedFunction* parsed_function = new ParsedFunction(
       Thread::Current(), Function::ZoneHandle(function.raw()));
   LocalVarDescriptors& var_descs =
       LocalVarDescriptors::Handle(code.var_descriptors());
   ASSERT(var_descs.IsNull());
   // IsIrregexpFunction have eager var descriptors generation.
   ASSERT(!function.IsIrregexpFunction());
   // Parser should not produce any errors, therefore no LongJumpScope needed.
+  // (exception is background compilation).
+  ASSERT(!Compiler::IsBackgroundCompilation());
   Parser::ParseFunction(parsed_function);
   parsed_function->AllocateVariables();
   var_descs = parsed_function->node_sequence()->scope()->
       GetVarDescriptors(function);
   ASSERT(!var_descs.IsNull());
   code.set_var_descriptors(var_descs);
 }
 
 
 RawError* Compiler::CompileAllFunctions(const Class& cls) {
@@ skipping 506 matching lines @@
 }
 
 
 void BackgroundCompiler::EnsureInit(Thread* thread) {
   UNREACHABLE();
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart