Try to avoid checks for lazy initialization when recompiling.

runtime/vm/parser.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/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 902 matching lines @@
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   intptr_t ident_pos = TokenPos();
   const String& field_name = *ExpectIdentifier("field name expected");
   const Class& field_class = Class::Handle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupStaticField(field_name));
 
+  if (!field.is_const() &&
+      (field.value() != Object::transition_sentinel().raw()) &&
+      (field.value() != Object::sentinel().raw())) {
+    // The field has already been initialized at compile time (this can
+    // happen, e.g., if we are recompiling for optimization).  There is no
+    // need to check for initialization and compile the potentially very
+    // large initialization code.  By skipping this code, the deoptimization
+    // ids will not line up with the original code, but this is safe because
+    // LoadStaticField does not deoptimize.
+    LoadStaticFieldNode* load_node = new LoadStaticFieldNode(ident_pos, field);
+    ReturnNode* return_node = new ReturnNode(ident_pos, load_node);
+    current_block_->statements->Add(return_node);
+    return CloseBlock();
+  }
+
   // Static const fields must have an initializer.
   ExpectToken(Token::kASSIGN);
 
   // We don't want to use ParseConstExpr() here because we don't want
   // the constant folding code to create, compile and execute a code
   // fragment to evaluate the expression. Instead, we just make sure
   // the static const field initializer is a constant expression and
   // leave the evaluation to the getter function.
   const intptr_t expr_pos = TokenPos();
   AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
@@ skipping 9157 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart