Run field initializers for new instance fields after a reload

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 3041 matching lines @@
     piece ^= formal_params.At(i);
     src_pieces.Add(piece);
   }
   src_pieces.Add(Symbols::RParenArrow());
   src_pieces.Add(expr);
   src_pieces.Add(Symbols::Semicolon());
   return String::ConcatAll(Array::Handle(Array::MakeArray(src_pieces)));
 }
 
 
-static RawFunction* EvaluateHelper(const Class& cls,
-                                   const String& expr,
-                                   const Array& param_names,
-                                   bool is_static) {
+RawFunction* Function::EvaluateHelper(const Class& cls,
+                                      const String& expr,
+                                      const Array& param_names,
+                                      bool is_static) {
   const String& func_src =
       String::Handle(BuildClosureSource(param_names, expr));
   Script& script = Script::Handle();
   script = Script::New(Symbols::EvalSourceUri(),
                        func_src,
                        RawScript::kEvaluateTag);
   // In order to tokenize the source, we need to get the key to mangle
   // private names from the library from which the class originates.
   const Library& lib = Library::Handle(cls.library());
   ASSERT(!lib.IsNull());
@@ skipping 16 matching lines @@
                            const Array& param_values) const {
   ASSERT(Thread::Current()->IsMutatorThread());
   if (id() < kInstanceCid) {
     const Instance& exception = Instance::Handle(String::New(
         "Cannot evaluate against a VM internal class"));
     const Instance& stacktrace = Instance::Handle();
     return UnhandledException::New(exception, stacktrace);
   }
 
   const Function& eval_func =
-      Function::Handle(EvaluateHelper(*this, expr, param_names, true));
+      Function::Handle(
+          Function::EvaluateHelper(*this, expr, param_names, true));
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(eval_func, param_values));
   return result.raw();
 }
 
 
 // Ensure that top level parsing of the class has been done.
 RawError* Class::EnsureIsFinalized(Thread* thread) const {
   // Finalized classes have already been parsed.
   if (is_finalized()) {
@@ skipping 4527 matching lines @@
   }
   ASSERT(original.IsOriginal());
   Field& clone = Field::Handle();
   clone ^= Object::Clone(*this, Heap::kOld);
   clone.SetOriginal(original);
   clone.set_kernel_field(original.kernel_field());
   return clone.raw();
 }
 
 
+RawString* Field::InitializingExpression() const {

[rmacnak, 2016/11/09 00:36:32]

Copying the initializer like this means any stacktrace running this expression
will have the wrong source position. Fixing this and the analogous problem with
eval expressions probably involving adding new function kinds, so just add a
TODO for this CL.

+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  const class Script& scr = Script::Handle(zone, Script());
+  ASSERT(!scr.IsNull());
+  const TokenStream& tkns = TokenStream::Handle(zone, scr.tokens());
+  if (tkns.IsNull()) {
+    ASSERT(Dart::snapshot_kind() == Snapshot::kAppNoJIT);
+    return String::null();
+  }
+  TokenStream::Iterator tkit(zone,
+                             tkns,
+                             token_pos());
+  ASSERT(Token::IsIdentifier(tkit.CurrentTokenKind()));
+#if defined(DEBUG)
+  const String& literal = String::Handle(zone, tkit.CurrentLiteral());
+  ASSERT(literal.raw() == name());
+#endif
+  tkit.Advance();
+  if (tkit.CurrentTokenKind() != Token::kASSIGN) {
+    return String::null();
+  }
+  tkit.Advance();
+  const TokenPosition start_of_expression = tkit.CurrentPosition();
+  while (tkit.CurrentTokenKind() != Token::kSEMICOLON) {
+    tkit.Advance();
+  }
+  const TokenPosition end_of_expression = tkit.CurrentPosition();
+  return scr.GetSnippet(start_of_expression, end_of_expression);
+}
+
+
 RawString* Field::UserVisibleName() const {
   if (FLAG_show_internal_names) {
     return name();
   }
   return String::ScrubName(String::Handle(name()));
 }
 
 
 intptr_t Field::guarded_list_length() const {
   return Smi::Value(raw_ptr()->guarded_list_length_);
@@ skipping 1448 matching lines @@
     return String::SubString(src,
                              line_start_idx,
                              last_char_idx - line_start_idx + 1,
                              space);
   } else {
     return Symbols::Empty().raw();
   }
 }
 
 
+RawString* Script::GetSnippet(TokenPosition from, TokenPosition to) const {
+  intptr_t from_line;
+  intptr_t from_column;
+  intptr_t to_line;
+  intptr_t to_column;
+  GetTokenLocation(from, &from_line, &from_column);
+  GetTokenLocation(to, &to_line, &to_column);
+  return GetSnippet(from_line, from_column,
+                    to_line, to_column);
+}
+
+
 RawString* Script::GetSnippet(intptr_t from_line,
                               intptr_t from_column,
                               intptr_t to_line,
                               intptr_t to_column) const {
   const String& src = String::Handle(Source());
   if (src.IsNull()) {
     ASSERT(Dart::snapshot_kind() == Snapshot::kAppNoJIT);
     return Symbols::OptimizedOut().raw();
   }
   intptr_t length = src.Length();
@@ skipping 6330 matching lines @@
 const char* UnwindError::ToCString() const {
   return "UnwindError";
 }
 
 
 RawObject* Instance::Evaluate(const Class& method_cls,
                               const String& expr,
                               const Array& param_names,
                               const Array& param_values) const {
   const Function& eval_func =
-      Function::Handle(EvaluateHelper(method_cls, expr, param_names, false));
+      Function::Handle(
+          Function::EvaluateHelper(method_cls, expr, param_names, false));
   const Array& args = Array::Handle(Array::New(1 + param_values.Length()));
   PassiveObject& param = PassiveObject::Handle();
   args.SetAt(0, *this);
   for (intptr_t i = 0; i < param_values.Length(); i++) {
     param = param_values.At(i);
     args.SetAt(i + 1, param);
   }
   return DartEntry::InvokeFunction(eval_func, args);
 }
 
@@ skipping 7556 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart