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

runtime/vm/kernel_binary_flowgraph.h

 // Copyright (c) 2017, 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.
 
 #ifndef RUNTIME_VM_KERNEL_BINARY_FLOWGRAPH_H_
 #define RUNTIME_VM_KERNEL_BINARY_FLOWGRAPH_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include <map>
@@ skipping 835 matching lines @@
     kFlags,
     kParentClassBinaryOffset,
     kName,
     kSourceUriIndex,
     kAnnotations,
     kType,
     kInitializer,
     kEnd
   };
 
-  explicit FieldHelper(StreamingFlowGraphBuilder* builder) {
-    builder_ = builder;
-    next_read_ = kStart;
+  explicit FieldHelper(StreamingFlowGraphBuilder* builder)
+      : builder_(builder),
+        next_read_(kStart),
+        has_function_literal_initializer_(false) {}
+
+  FieldHelper(StreamingFlowGraphBuilder* builder, intptr_t offset)
+      : builder_(builder),
+        next_read_(kStart),
+        has_function_literal_initializer_(false) {
+    builder_->SetOffset(offset);
   }
 
   void ReadUntilIncluding(Fields field) {
     ReadUntilExcluding(static_cast<Fields>(static_cast<int>(field) + 1));
   }
 
-  void ReadUntilExcluding(Fields field) {
+  void ReadUntilExcluding(Fields field,
+                          bool detect_function_literal_initializer = false) {
     if (field <= next_read_) return;
 
     // Ordered with fall-through.
     switch (next_read_) {
       case kStart: {
         Tag tag = builder_->ReadTag();  // read tag.
         ASSERT(tag == kField);
         if (++next_read_ == field) return;
       }
       case kCanonicalName:
@@ skipping 26 matching lines @@
         annotation_count_ = builder_->ReadListLength();  // read list length.
         for (intptr_t i = 0; i < annotation_count_; ++i) {
           builder_->SkipExpression();  // read ith expression.
         }
         if (++next_read_ == field) return;
       }
       case kType:
         builder_->SkipDartType();  // read type.
         if (++next_read_ == field) return;
       case kInitializer:
-        if (builder_->ReadTag() == kSomething)
+        if (builder_->ReadTag() == kSomething) {
+          if (detect_function_literal_initializer &&
+              builder_->PeekTag() == kFunctionExpression) {
+            has_function_literal_initializer_ = true;
+            intptr_t expr_offset = builder_->ReaderOffset();
+            Tag tag = builder_->ReadTag();
+            ASSERT(tag == kFunctionExpression);
+            tag = builder_->ReadTag();
+            ASSERT(tag == kFunctionNode);
+            function_literal_start_ = builder_->ReadPosition();
+            function_literal_end_ = builder_->ReadPosition();
+
+            builder_->SetOffset(expr_offset);
+          }
           builder_->SkipExpression();  // read initializer.
+        }
         if (++next_read_ == field) return;
       case kEnd:
         return;
     }
   }
 
   void SetNext(Fields field) { next_read_ = field; }
   void SetJustRead(Fields field) {
     next_read_ = field;
     ++next_read_;
   }
 
   bool IsConst() { return (flags_ & Field::kFlagConst) == Field::kFlagConst; }
   bool IsFinal() { return (flags_ & Field::kFlagFinal) == Field::kFlagFinal; }
   bool IsStatic() {
     return (flags_ & Field::kFlagStatic) == Field::kFlagStatic;
   }
 
+  bool FieldHasFunctionLiteralInitializer(TokenPosition* start,
+                                          TokenPosition* end) {
+    if (has_function_literal_initializer_) {
+      *start = function_literal_start_;
+      *end = function_literal_end_;
+    }
+    return has_function_literal_initializer_;
+  }
+
   NameIndex canonical_name_;
   TokenPosition position_;
   TokenPosition end_position_;
   word flags_;
   intptr_t parent_class_binary_offset_;
   intptr_t source_uri_index_;
   intptr_t annotation_count_;
 
  private:
   StreamingFlowGraphBuilder* builder_;
   intptr_t next_read_;
+
+  bool has_function_literal_initializer_;
+  TokenPosition function_literal_start_;
+  TokenPosition function_literal_end_;
 };
 
 // Helper class that reads a kernel Procedure from binary.
 //
 // Use ReadUntilExcluding to read up to but not including a field.
 // One can then for instance read the field from the call-site (and remember to
 // call SetAt to inform this helper class), and then use this to read more.
 // "Dumb" fields are stored (e.g. integers) and can be fetched from this class.
 // If asked to read a "non-dumb" field (e.g. an expression) it will be skipped.
 class ProcedureHelper {
@@ skipping 529 matching lines @@
  private:
   Reader* reader_;
   intptr_t saved_offset_;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_BINARY_FLOWGRAPH_H_