WIP: Data breakpoints (though can't find a server which supports them)

Author: puremourning

autoload/vimspector.vim

@@ -449,6 +449,14 @@ function! vimspector#ShowDisassembly( ... ) abort
   py3 _vimspector_session.ShowDisassembly()
 endfunction
 
+function! vimspector#AddDataBreakpoint( ... ) abort
+  if !s:Enabled()
+    return
+  endif
+  " TODO: how to set options?
+  py3 _vimspector_session.AddDataBreakpoint( {} )
+endfunction
+
 function! vimspector#DeleteWatch() abort
   if !s:Enabled()
     return

python3/vimspector/breakpoints.py

@@ -216,6 +216,7 @@ def __init__( self,
     self._func_breakpoints = []
     self._exception_breakpoints = None
     self._configured_breakpoints = {}
+    self._data_breakponts = []
 
     self._server_capabilities = {}
 
@@ -778,7 +779,19 @@ def AddFunctionBreakpoint( self, function, options ):
       # 'condition': ...,
       # 'hitCondition': ...,
     } )
+    self.UpdateUI()
+
 
+  def AddDataBreakpoint( self,
+                         conn: DebugAdapterConnection,
+                         info,
+                         options ):
+    self._data_breakponts.append( {
+      'state': 'ENABLED',
+      'conn': conn.GetSessionId(),
+      'info': info,
+      'options': options
+    } )
     self.UpdateUI()
 
 
@@ -984,6 +997,40 @@ def response_handler( conn, msg, bp_idxs = [] ):
           failure_handler = response_received
         )
 
+    if self._data_breakponts and self._server_capabilities[
+      'supportsDataBreakpoints' ]:
+      connection: DebugAdapterConnection
+      for connection in self._connections:
+        bp_idxs = []
+        breakpoints = []
+        for bp in self._data_breakponts:
+          if bp[ 'state' ] != 'ENABLED':
+            continue
+          if bp[ 'conn' ] == connection.GetSessionId():
+            continue
+          if not bp[ 'info' ].get( 'dataId' ):
+            continue
+
+          data_bp = {}
+          data_bp.update( bp[ 'options' ] )
+          data_bp[ 'dataId' ] = bp[ 'info' ][ 'dataId' ]
+          breakpoints.append( data_bp )
+          bp_idxs.append( [ len( breakpoints ), bp ] )
+
+        if breakpoints:
+          self._awaiting_bp_responses += 1
+          connection.DoRequest(
+            lambda msg, conn=connection, idxs=bp_idxs: response_handler(
+              conn,
+              msg,
+              idxs ),
+            {
+              'command': 'setDataBreakpoints',
+              'arguments': breakpoints,
+            },
+            failure_handler = response_received
+          )
+
     if self._exception_breakpoints:
       for connection in self._connections:
         self._awaiting_bp_responses += 1
@@ -1082,6 +1129,11 @@ def Save( self ):
       if bps:
         line[ file_name ] = bps
 
+    # TODO: Some way to persis data breakpoints? Currently they require
+    # variablesReference, which is clearly not something that can be persisted
+    #
+    # That said, the spec now seems to support data bps on expressions, though i
+    # can't see any servers which support that.
     return {
       'line': line,
       'function': self._func_breakpoints,
@@ -1146,6 +1198,11 @@ def _HideBreakpoints( self ):
           signs.UnplaceSign( bp[ 'sign_id' ], 'VimspectorBP' )
           del bp[ 'sign_id' ]
 
+    # TODO could/should we show a sign in the variables view when there's a data
+    # brakpoint on the variable? Not sure how best to actually do that, but
+    # maybe the variable view can pass that info when calling AddDataBreakpoint,
+    # such as the variablesReference/name
+
 
   def _SignToLine( self, file_name, bp ):
     if bp[ 'is_instruction_breakpoint' ]:

python3/vimspector/debug_session.py

@@ -999,6 +999,21 @@ def OnDisassemblyWindowScrolled( self, win_id ):
 
 
   @CurrentSession()
+  @IfConnected()
+  def AddDataBreakpoint( self, opts, buf = None, line_num = None ):
+    def add_bp( breakpoint_info ):
+      if breakpoint_info[ 'dataId' ] is None:
+        utils.UserMessage(
+          "Can't set data breakpoint here: { breakpoint_info[ 'description' ] }"
+        )
+        return
+
+      # TODO: Ask the user about the possible DataBreakpointAccessType's and add
+      # that in to opts here
+      self._breakpoints.AddDataBreakpoint( breakpoint_info[ 'dataId' ], opts )
+
+    self._variablesView.GetDataBreakpointInfo( add_bp, buf, line_num )
+
   @IfConnected()
   def AddWatch( self, expression ):
     self._variablesView.AddWatch( self._connection,

python3/vimspector/variables.py

@@ -62,8 +62,17 @@ def IsContained( self ):
   def VariablesReference( self ):
     assert False
 
+  @abc.abstractmethod
+  def FrameID( self ):
+    assert False
+
+  @abc.abstractmethod
+  def EvaluateName( self ):
+    assert False
+
+  @abc.abstractmethod
   def MemoryReference( self ):
-    assert None
+    assert False
 
   @abc.abstractmethod
   def HoverText( self ):
@@ -82,6 +91,12 @@ def VariablesReference( self ):
   def MemoryReference( self ):
     return None
 
+  def FrameID( self ):
+    return None
+
+  def EvaluateName( self ):
+    return self.scope[ 'name' ]
+
   def Update( self, scope ):
     self.scope = scope
 
@@ -91,8 +106,12 @@ def HoverText( self ):
 
 class WatchResult( Expandable ):
   """Holds the result of a Watch expression with expand/collapse."""
-  def __init__( self, connection: DebugAdapterConnection, result: dict ):
+  def __init__( self,
+                connection: DebugAdapterConnection,
+                watch,
+                result: dict ):
     super().__init__( connection )
+    self.watch = watch
     self.result = result
     # A new watch result is marked as changed
     self.changed = True
@@ -103,6 +122,12 @@ def VariablesReference( self ):
   def MemoryReference( self ):
     return self.result.get( 'memoryReference' )
 
+  def FrameID( self ):
+    return self.watch.expression.get( 'frameId' )
+
+  def EvaluateName( self ):
+    return self.watch.expression.get( 'expression' )
+
   def Update( self, result ):
     self.changed = False
     if self.result[ 'result' ] != result[ 'result' ]:
@@ -129,7 +154,8 @@ class Variable( Expandable ):
   """Holds one level of an expanded value tree. Also itself expandable."""
   def __init__( self,
                 connection: DebugAdapterConnection,
-                container: Expandable, variable: dict ):
+                container: Expandable,
+                variable: dict ):
     super().__init__( connection = connection, container = container )
     self.variable = variable
     # A new variable appearing is marked as changed
@@ -141,6 +167,12 @@ def VariablesReference( self ):
   def MemoryReference( self ):
     return self.variable.get( 'memoryReference' )
 
+  def FrameID( self ):
+    return self.container.FrameID()
+
+  def EvaluateName( self ):
+    return self.variable.get( 'evaluateName', self.variable[ 'name' ] )
+
   def Update( self, variable ):
     self.changed = False
     if self.variable[ 'value' ] != variable[ 'value' ]:
@@ -536,7 +568,9 @@ def _UpdateWatchExpression( self, watch: Watch, message: dict ):
     if watch.result is not None:
       watch.result.Update( message[ 'body' ] )
     else:
-      watch.result = WatchResult( watch.connection, message[ 'body' ] )
+      watch.result = WatchResult( watch.connection,
+                                  watch[ 'frameId' ],
+                                  message[ 'body' ] )
 
     if ( watch.result.IsExpandable() and
          watch.result.IsExpanded() ):
@@ -668,12 +702,42 @@ def GetMemoryReference( self ):
     # Get a memoryReference for use in a ReadMemory request
     variable, _ = self._GetVariable( None, None )
     if variable is None:
-      return None
+      return None, None
 
-    # TODO: Return the connection too!
     return variable.connection, variable.MemoryReference()
 
 
+  def GetDataBreakpointInfo( self,
+                             then,
+                             buf = None,
+                             line_num = None ):
+    variable: Expandable
+    view: View
+
+    if not self._server_capabilities.get( 'supportsDataBreakpoints' ):
+      return None
+
+    variable, view = self._GetVariable( buf, line_num )
+    if variable is None:
+      return None
+
+    arguments = {
+      'name': variable.EvaluateName()
+    }
+    frameId = variable.FrameID()
+    if frameId:
+      arguments[ 'frameId' ] = frameId
+
+    if variable.IsContained():
+      arguments[ 'variablesReference' ] = (
+        variable.container.VariablesReference() )
+
+    variable.connection.DoRequest( lambda msg: then( msg[ 'body' ] ), {
+      'command': 'dataBreakpointInfo',
+      'arguments': arguments,
+    } )
+
+
   def _DrawVariables( self, view, variables, indent_len, is_short = False ):
     assert indent_len > 0
     for variable in variables:

support/test/go/hello_world/hello-world.go

@@ -1,6 +1,25 @@
 package main
 import "fmt"
+
+type Toaster struct {
+	Power int
+	Colour string
+}
+
+type Test struct {
+	Test string
+	Toast Toaster
+}
+
 func main() {
   var v = "test"
+	test := Test{
+		Test: "This is\na\ntest",
+		Toast: Toaster{
+			Power: 10,
+			Colour: "green",
+		},
+	}
   fmt.Println("hello world: " + v)
+	fmt.Println("Hi " + test.Test)
 }