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

runtime/vm/debugger.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/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "platform/address_sanitizer.h"
 
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/deopt_instructions.h"
 #include "vm/disassembler.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/json_stream.h"
+#include "vm/kernel_binary.h"
+#include "vm/kernel_binary_flowgraph.h"
+#include "vm/kernel_to_il.h"
 #include "vm/longjump.h"
 #include "vm/message_handler.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 #include "vm/port.h"
 #include "vm/runtime_entry.h"
 #include "vm/service.h"
 #include "vm/service_event.h"
@@ skipping 2613 matching lines @@
           *best_fit = function.raw();
           return true;
         }
       }
     }
     // If none of the functions in the class contain token_pos, then we
     // check if it falls within a function literal initializer of a field
     // that has not been initialized yet. If the field (and hence the
     // function literal initializer) has already been initialized, then
     // it would have been found above in the object store as a closure.
+    const uint8_t* kernel_data = script.kernel_data();
     fields = cls.fields();
     if (!fields.IsNull()) {
       const intptr_t num_fields = fields.Length();
       for (intptr_t pos = 0; pos < num_fields; pos++) {
         TokenPosition start;
         TokenPosition end;
         field ^= fields.At(pos);
         ASSERT(!field.IsNull());
         if (field.Script() != script.raw()) {
           // The field should be defined in the script we want to set
           // the breakpoint in.
           continue;
         }
-        if (Parser::FieldHasFunctionLiteralInitializer(field, &start, &end)) {
+        bool has_func_literal_initializer = false;
+        if (kernel_data != NULL) {
+#ifndef DART_PRECOMPILED_RUNTIME
+          // If we have the kernel program, use it.
+          kernel::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,
+                                                    kernel_data,
+                                                    script.kernel_data_size());
+          kernel::FieldHelper field_helper(builder, field.kernel_offset());
+          field_helper.ReadUntilExcluding(kernel::FieldHelper::kEnd, true);
+          has_func_literal_initializer =
+              field_helper.FieldHasFunctionLiteralInitializer(&start, &end);
+          delete builder;
+#endif  // !DART_PRECOMPILED_RUNTIME

[siva, 2017/07/17 22:39:23]

Is it possible to abstract this out as a function in KernelReader and invoke it
conditionally under 'if (FLAG_use_dart_front_end)'

Also can a similar check
if (!field.has_initialized()) {

[sivachandra, 2017/07/17 23:49:36]

Done.

+        } else {
+          has_func_literal_initializer =
+              Parser::FieldHasFunctionLiteralInitializer(field, &start, &end);
+        }
+        if (has_func_literal_initializer) {
           if ((start <= token_pos && token_pos <= end) ||
               (token_pos <= start && start <= last_token_pos)) {
             return true;
           }
         }
       }
     }
   }
   return false;
 }
@@ skipping 1664 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart