Allow setting breakpoints in function literal field initializers under --dfe.

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, 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/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/kernel_binary.h"
 #include "vm/kernel_binary_flowgraph.h"
+#include "vm/kernel_to_il.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 namespace dart {
 namespace kernel {
 
 #define Z (zone_)
@@ skipping 852 matching lines @@
   };
   intptr_t kind = static_cast<int>(procedure_kind);
   if (kind == Procedure::kIncompleteProcedure) {
     return RawFunction::kSignatureFunction;
   } else {
     ASSERT(0 <= kind && kind <= Procedure::kFactory);
     return static_cast<RawFunction::Kind>(lookuptable[kind]);
   }
 }
 
+bool KernelReader::FieldHasFunctionLiteralInitializer(const dart::Field& field,
+                                                      TokenPosition* start,
+                                                      TokenPosition* end) {
+  dart::Zone* zone = Thread::Current()->zone();
+  const Script& script = Script::Handle(zone, field.Script());
+
+  TranslationHelper translation_helper(
+      Thread::Current(), script.kernel_string_offsets(),
+      script.kernel_string_data(), script.kernel_canonical_names());
+
+  kernel::StreamingFlowGraphBuilder* builder =
+      new kernel::StreamingFlowGraphBuilder(&translation_helper, zone,
+                                            script.kernel_data(),
+                                            script.kernel_data_size());
+
+  kernel::FieldHelper field_helper(builder, field.kernel_offset());
+  field_helper.ReadUntilExcluding(kernel::FieldHelper::kEnd, true);
+  bool result = field_helper.FieldHasFunctionLiteralInitializer(start, end);
+
+  delete builder;
+  return result;
+}
+
 ParsedFunction* ParseStaticFieldInitializer(Zone* zone,
                                             const dart::Field& field) {
   Thread* thread = Thread::Current();
 
   dart::String& init_name = dart::String::Handle(zone, field.name());
   init_name = Symbols::FromConcat(thread, Symbols::InitPrefix(), init_name);
 
   // Create a static initializer.
   const Object& owner = Object::Handle(field.RawOwner());
   const Function& initializer_fun = Function::ZoneHandle(
       zone,
       dart::Function::New(init_name, RawFunction::kImplicitStaticFinalGetter,
                           true,   // is_static
                           false,  // is_const
                           false,  // is_abstract
                           false,  // is_external
                           false,  // is_native
                           owner, TokenPosition::kNoSource));
   initializer_fun.set_kernel_offset(field.kernel_offset());
   initializer_fun.set_result_type(AbstractType::Handle(zone, field.type()));
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)