In background compilation make a copy of Field in order to freeze its state

runtime/vm/ast.cc

 // Copyright (c) 2011, 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/ast.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/object_store.h"
@@ skipping 19 matching lines @@
 
 #define DEFINE_NAME_FUNCTION(BaseName)                                         \
 const char* BaseName##Node::Name() const {                                     \
   return #BaseName;                                                            \
 }
 
 FOR_EACH_NODE(DEFINE_NAME_FUNCTION)
 #undef DEFINE_NAME_FUNCTION
 
 
+const Field* AstNode::MayCloneField(const Field& value) {
+  if (Compiler::IsBackgroundCompilation() ||
+      FLAG_force_clone_compiler_objects) {
+    return value.CloneFromOriginal();

[siva, 2016/02/25 23:38:32]

Why not create the zone handle here instead of having CloneFromOriginal return a
pointer to a handle. In Object.h we have kept a pattern of returning raw
pointers and taking in arguments as handles.

  return &Field::ZoneHandle(value.CloneFromOriginal());

[srdjan, 2016/02/26 00:40:42]

OK, always returning RawField* instead of Field* in object.h.

+  } else {
+    ASSERT(value.IsZoneHandle());
+    return &value;
+  }
+}
+
+

[siva, 2016/02/25 23:38:32]

Add 
const Field* AstNode::OriginalAsHandle(const Field& value) const {
  return OriginalAsHandle(Thread::Current()->zone(), value);
}
const Field* AstNode::OriginalAsHandle(Zone* zone, const Field& value) const {
  return &Field::ZoneHandle(zone, value.Original());
}

[srdjan, 2016/02/26 00:40:42]

It feels wrong to put that shared functionality in ASTNode, especially since it
cannot be used in the frequent intermediate_language_xxx.cc case. Removing
OriginalAsHandle

 // A visitor class to collect all the nodes (including children) into an
 // array.
 class AstNodeCollector : public AstNodeVisitor {
  public:
   explicit AstNodeCollector(GrowableArray<AstNode*>* nodes)
     : nodes_(nodes) { }
 
 #define DEFINE_VISITOR_FUNCTION(BaseName)                                      \
   virtual void Visit##BaseName##Node(BaseName##Node* node) {                   \
     nodes_->Add(node);                                                         \
@@ skipping 525 matching lines @@
   if (field().is_final()) {
     return NULL;
   }
   if (Isolate::Current()->flags().type_checks()) {
     rhs = new AssignableNode(
         field().token_pos(),
         rhs,
         AbstractType::ZoneHandle(field().type()),
         String::ZoneHandle(field().name()));
   }
-  return new StoreStaticFieldNode(token_pos(), field(), rhs);
+  return new StoreStaticFieldNode(
+      token_pos(), *field().OriginalAsHandle(), rhs);

[siva, 2016/02/25 23:38:32]

token_pos(), *OriginalAsHandle(field(), rhs);

[srdjan, 2016/02/26 00:40:42]

Resolved using Field::ZoneHandle

 }
 
 
 AstNode* InstanceGetterNode::MakeAssignmentNode(AstNode* rhs) {
   return new InstanceSetterNode(token_pos(),
                                 receiver(),
                                 field_name(),
                                 rhs,
                                 is_conditional());
 }
@@ skipping 221 matching lines @@
   if (result.IsError() || result.IsNull()) {
     // TODO(turnidge): We could get better error messages by returning
     // the Error object directly to the parser.  This will involve
     // replumbing all of the EvalConstExpr methods.
     return NULL;
   }
   return &Instance::ZoneHandle(Instance::Cast(result).raw());
 }
 
 }  // namespace dart