Implement 'print', 'up', 'down', and 'frame' commands in the Observatory debugger.

runtime/observatory/lib/src/elements/debugger.dart

 // Copyright (c) 2014, 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.
 
 library debugger_page_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'observatory_element.dart';
 import 'package:observatory/cli.dart';
@@ skipping 86 matching lines @@
 
   String helpShort = 'List commands or provide details about a specific command';
 
   String helpLong =
       'List commands or provide details about a specific command.\n'
       '\n'
       'Syntax: help            - Show a list of all commands\n'
       '        help <command>  - Help for a specific command\n';
 }
 
+class PrintCommand extends DebuggerCommand {
+  PrintCommand(Debugger debugger) : super(debugger, 'print', []) {
+    alias = 'p';
+  }
+
+  Future run(List<String> args) {
+    if (args.length < 1) {
+      debugger.console.print('print expects arguments');
+      return new Future.value(null);
+    }
+    var expr = args.join('');
+    return debugger.isolate.evalFrame(debugger.currentFrame, expr)
+      .then((response) {
+          if (response is DartError) {
+            debugger.console.print(response.message);
+          } else {
+            ServiceMap instance = response;
+            debugger.console.print('= ', newline:false);
+            debugger.console.printRef(instance);
+          }
+      });
+  }
+
+  String helpShort = 'Evaluate and print an expression in the current frame';
+
+  String helpLong =
+      'Evaluate and print an expression in the current frame.\n'
+      '\n'
+      'Syntax: print <expression>\n'
+      '        p <expression>\n';
+}
+
+class DownCommand extends DebuggerCommand {
+  DownCommand(Debugger debugger) : super(debugger, 'down', []);
+
+  Future run(List<String> args) {
+    int count = 1;
+    if (args.length == 1) {
+      count = int.parse(args[0]);
+    } else if (args.length > 1) {
+      debugger.console.print('down expects 0 or 1 argument');
+      return new Future.value(null);
+    }
+    if (debugger.currentFrame == null) {
+      debugger.console.print('No stack');
+      return new Future.value(null);
+    }
+    try {
+      debugger.currentFrame -= count;
+      debugger.console.print('frame = ${debugger.currentFrame}');
+    } catch (e) {
+      debugger.console.print('frame must be in range [${e.start},${e.end-1}]');
+    }
+    return new Future.value(null);
+  }
+
+  String helpShort = 'Move down one or more frames';
+
+  String helpLong =
+      'Move down one or more frames.\n'
+      '\n'
+      'Syntax: down\n'
+      '        down <count>\n';
+}
+
+class UpCommand extends DebuggerCommand {
+  UpCommand(Debugger debugger) : super(debugger, 'up', []);
+
+  Future run(List<String> args) {
+    int count = 1;
+    if (args.length == 1) {
+      count = int.parse(args[0]);
+    } else if (args.length > 1) {
+      debugger.console.print('up expects 0 or 1 argument');
+      return new Future.value(null);
+    }
+    if (debugger.currentFrame == null) {
+      debugger.console.print('No stack');
+      return new Future.value(null);
+    }
+    try {
+      debugger.currentFrame += count;
+      debugger.console.print('frame = ${debugger.currentFrame}');
+    } on RangeError catch (e) {
+      debugger.console.print('frame must be in range [${e.start},${e.end-1}]');
+    }
+    return new Future.value(null);
+  }
+
+  String helpShort = 'Move up one or more frames';
+
+  String helpLong =
+      'Move up one or more frames.\n'
+      '\n'
+      'Syntax: up\n'
+      '        up <count>\n';
+}
+
+class FrameCommand extends DebuggerCommand {
+  FrameCommand(Debugger debugger) : super(debugger, 'frame', []) {
+    alias = 'f';
+  }
+
+  Future run(List<String> args) {
+    int frame = 1;
+    if (args.length == 1) {
+      frame = int.parse(args[0]);
+    } else {
+      debugger.console.print('frame expects 1 argument');
+      return new Future.value(null);
+    }
+    if (debugger.currentFrame == null) {
+      debugger.console.print('No stack');
+      return new Future.value(null);
+    }
+    try {
+      debugger.currentFrame = frame;
+      debugger.console.print('frame = ${debugger.currentFrame}');
+    } on RangeError catch (e) {
+      debugger.console.print('frame must be in range [${e.start},${e.end-1}]');
+    }
+    return new Future.value(null);
+  }
+
+  String helpShort = 'Set the current frame';
+
+  String helpLong =
+      'Set the current frame.\n'
+      '\n'
+      'Syntax: frame <number>\n'
+      '        f <count>\n';
+}
+
 class PauseCommand extends DebuggerCommand {
   PauseCommand(Debugger debugger) : super(debugger, 'pause', []);
 
   Future run(List<String> args) {
     if (!debugger.isolatePaused()) {
       return debugger.isolate.pause();
     } else {
       debugger.console.print('The program is already paused');
       return new Future.value(null);
     }
@@ skipping 21 matching lines @@
       debugger.console.print('The program must be paused');
       return new Future.value(null);
     }
   }
 
   String helpShort = 'Resume execution of the isolate';
 
   String helpLong =
       'Continue running the isolate.\n'
       '\n'
-      'Syntax: continue\n';
+      'Syntax: continue\n'
+      '        c\n';
 }
 
 class NextCommand extends DebuggerCommand {
   NextCommand(Debugger debugger) : super(debugger, 'next', []);
 
   Future run(List<String> args) {
     if (debugger.isolatePaused()) {
       var event = debugger.isolate.pauseEvent;
       if (event.eventType == ServiceEvent.kPauseStart) {
         debugger.console.print("Type 'continue' to start the isolate");
@@ skipping 324 matching lines @@
   }
 
   String helpShort = 'List all isolates';
 
   String helpLong =
       'List all isolates.\n'
       '\n'
       'Syntax: info isolates\n';
 }
 
+class InfoFrameCommand extends DebuggerCommand {
+  InfoFrameCommand(Debugger debugger) : super(debugger, 'frame', []);
+
+  Future run(List<String> args) {
+    if (args.length > 0) {
+      debugger.console.print('info frame expects 1 argument');
+      return new Future.value(null);
+    }
+    debugger.console.print('frame = ${debugger.currentFrame}');
+    return new Future.value(null);
+  }
+
+  String helpShort = 'Show current frame';
+
+  String helpLong =
+      'Show current frame.\n'
+      '\n'
+      'Syntax: info frame\n';
+}
+
 class InfoCommand extends DebuggerCommand {
   InfoCommand(Debugger debugger) : super(debugger, 'info', [
       new InfoBreakpointsCommand(debugger),
       new InfoIsolatesCommand(debugger),
+      new InfoFrameCommand(debugger),
   ]);
 
   Future run(List<String> args) {
     debugger.console.print("'info' expects a subcommand (see 'help info')");
     return new Future.value(null);
   }
 
   String helpShort = 'Show information on a variety of topics';
 
   String helpLong =
@@ skipping 59 matching lines @@
       '\n'
       'Syntax: refresh <subcommand>\n';
 }
 
 // Tracks the state for an isolate debugging session.
 class ObservatoryDebugger extends Debugger {
   RootCommand cmd;
   DebuggerConsoleElement console;
   DebuggerStackElement stackElement;
   ServiceMap stack;
-  int currentFrame = 0;
+
+  int get currentFrame => _currentFrame;
+  void set currentFrame(int value) {
+    if (value != null && (value < 0 || value >= stackDepth)) {
+      throw new RangeError.range(value, 0, stackDepth);
+    }
+    _currentFrame = value;
+    if (stackElement != null) {
+      stackElement.setCurrentFrame(value);
+    }
+  }
+  int _currentFrame = null;
+
+  int get stackDepth => stack['frames'].length;
 
   ObservatoryDebugger() {
     cmd = new RootCommand([
         new HelpCommand(this),
+        new PrintCommand(this),
+        new DownCommand(this),
+        new UpCommand(this),
+        new FrameCommand(this),
         new PauseCommand(this),
         new ContinueCommand(this),
         new NextCommand(this),
         new StepCommand(this),
         new FinishCommand(this),
         new BreakCommand(this),
         new ClearCommand(this),
         new DeleteCommand(this),
         new InfoCommand(this),
         new RefreshCommand(this),
@@ skipping 32 matching lines @@
   Future refreshStack() {
     return _refreshStack(isolate.pauseEvent).then((_) {
         reportStatus();
       });
   }
 
   bool isolatePaused() {
     // TODO(turnidge): Stop relying on the isolate to track the last
     // pause event.  Since we listen to events directly in the
     // debugger, this could introduce a race.
-    return (isolate.pauseEvent != null &&
+    return (isolate != null &&
+            isolate.pauseEvent != null &&
             isolate.pauseEvent.eventType != ServiceEvent.kResume);
   }
 
   void warnOutOfDate() {
     // Wait a bit, then tell the user that the stack may be out of date.
     new Timer(const Duration(seconds:2), () {
       if (!isolatePaused()) {
         stackElement.isSampled = true;
       }
     });
   }
 
   Future<ServiceMap> _refreshStack(ServiceEvent pauseEvent) {
     return isolate.getStack().then((result) {
       stack = result;
       // TODO(turnidge): Replace only the changed part of the stack to
       // reduce flicker.
       stackElement.updateStack(stack, pauseEvent);
+      if (stack['frames'].length > 0) {
+        currentFrame = 0;
+      } else {
+        currentFrame = null;
+      }
     });
   }
 
   void reportStatus() {
     if (_isolate.idle) {
       console.print('Isolate is idle');
     } else if (_isolate.running) {
       console.print("Isolate is running (type 'pause' to interrupt)");
     } else if (_isolate.pauseEvent != null) {
       _reportPause(_isolate.pauseEvent);
@@ skipping 209 matching lines @@
     debugger.init();
   }
 
 }
 
 @CustomTag('debugger-stack')
 class DebuggerStackElement extends ObservatoryElement {
   @published Isolate isolate;
   @observable bool hasStack = false;
   @observable bool isSampled = false;
+  @observable int currentFrame;
   ObservatoryDebugger debugger;
 
-  _addFrame(List frameList, ObservableMap frameInfo, bool expand) {
+  _addFrame(List frameList, ObservableMap frameInfo) {
     DebuggerFrameElement frameElement = new Element.tag('debugger-frame');
-    frameElement.expand = expand;
     frameElement.frame = frameInfo;
 
+    if (frameInfo['depth'] == currentFrame) {
+      frameElement.setCurrent(true);
+    } else {
+      frameElement.setCurrent(false);
+    }
+
     var li = new LIElement();
     li.classes.add('list-group-item');
     li.children.insert(0, frameElement);
 
     frameList.insert(0, li);
   }
 
   void updateStack(ServiceMap newStack, ServiceEvent pauseEvent) {
     List frameElements = $['frameList'].children;
     List newFrames = newStack['frames'];
@@ skipping 23 matching lines @@
         frameElements.removeAt(0);
       }
     }
 
     // Add any new frames.
     int newCount = 0;
     if (frameElements.length < newFrames.length) {
       // Add new frames to the top of stack.
       newCount = newFrames.length - frameElements.length;
       for (int i = newCount-1; i >= 0; i--) {
-        _addFrame(frameElements, newFrames[i], i == 0);
+        _addFrame(frameElements, newFrames[i]);
       }
     }
     assert(frameElements.length == newFrames.length);
 
     if (frameElements.isNotEmpty) {
-      frameElements[0].children[0].expand = true;
       for (int i = newCount; i < frameElements.length; i++) {
         frameElements[i].children[0].updateFrame(newFrames[i]);
       }
     }
 
     isSampled = pauseEvent == null;
     hasStack = frameElements.isNotEmpty;
   }
 
+  void setCurrentFrame(int value) {
+    currentFrame = value;
+    List frameElements = $['frameList'].children;
+    for (var frameElement in frameElements) {
+      var dbgFrameElement = frameElement.children[0];
+      if (dbgFrameElement.frame['depth'] == currentFrame) {
+        dbgFrameElement.setCurrent(true);
+      } else {
+        dbgFrameElement.setCurrent(false);
+      }
+    }
+  }
+
   Set<Script> activeScripts() {
     var s = new Set<Script>();
     List frameElements = $['frameList'].children;
     for (var frameElement in frameElements) {
       s.add(frameElement.children[0].script);
     }
     return s;
   }
 
   doPauseIsolate(_) {
@@ skipping 12 matching lines @@
     }
   }
 
   DebuggerStackElement.created() : super.created();
 }
 
 @CustomTag('debugger-frame')
 class DebuggerFrameElement extends ObservatoryElement {
   @published ObservableMap frame;
 
-  // When true, the frame will start out expanded.
-  @published bool expand = false;
+  // Is this the current frame?
+  bool _current = false;
+
+  // Has this frame been pinned open?
+  bool _pinned = false;
+
+  void setCurrent(bool value) {
+    busy = true;
+    frame['function'].load().then((func) {
+      _current = value;
+      var frameOuter = $['frameOuter'];
+      if (_current) {
+        frameOuter.classes.add('current');
+        expanded = true;
+        frameOuter.classes.add('shadow');
+        scrollIntoView();
+      } else {
+        frameOuter.classes.remove('current');
+        if (_pinned) {
+          expanded = true;
+          frameOuter.classes.add('shadow');
+        } else {
+          expanded = false;
+          frameOuter.classes.remove('shadow');
+        }
+      }
+      busy = false;
+    });
+  }
 
   @observable String scriptHeight;
   @observable bool expanded = false;
   @observable bool busy = false;
 
   DebuggerFrameElement.created() : super.created();
 
   bool matchFrame(ObservableMap newFrame) {
     return newFrame['function'].id == frame['function'].id;
   }
 
   void updateFrame(ObservableMap newFrame) {
     assert(matchFrame(newFrame));
     frame['depth'] = newFrame['depth'];
     frame['tokenPos'] = newFrame['tokenPos'];
     frame['vars'] = newFrame['vars'];
   }
 
   Script get script => frame['script'];
 
   @override
   void attached() {
     super.attached();
     int windowHeight = window.innerHeight;
     scriptHeight = '${windowHeight ~/ 1.6}px';
   }
 
-  void expandChanged(oldValue) {
-    if (expand != expanded) {
-      toggleExpand(null, null, null);
-    }
-  }
-
   void toggleExpand(var a, var b, var c) {
     if (busy) {
       return;
     }
     busy = true;
     frame['function'].load().then((func) {
-        expanded = !expanded;
+        _pinned = !_pinned;
         var frameOuter = $['frameOuter'];
-        if (expanded) {
+        if (_pinned) {
+          expanded = true;
           frameOuter.classes.add('shadow');
         } else {
+          expanded = false;
           frameOuter.classes.remove('shadow');
         }
         busy = false;
       });
   }
 }
 
 @CustomTag('debugger-console')
 class DebuggerConsoleElement extends ObservatoryElement {
   @published Isolate isolate;
@@ skipping 15 matching lines @@
     var span = new SpanElement();
     span.classes.add('bold');
     span.appendText(line);
     if (newline) {
       span.appendText('\n');
     }
     $['consoleText'].children.add(span);
     span.scrollIntoView();
   }
 
+  void printRef(ServiceMap ref, { bool newline:true }) {
+    var refElement = new Element.tag('instance-ref');
+    refElement.ref = ref;
+    $['consoleText'].children.add(refElement);
+    if (newline) {
+      this.newline();
+    }
+    refElement.scrollIntoView();
+  }
+
   void newline() {
     var br = new BRElement();
     $['consoleText'].children.add(br);
     br.scrollIntoView();
   }
 }
 
 @CustomTag('debugger-input')
 class DebuggerInputElement extends ObservatoryElement {
   @published Isolate isolate;
@@ skipping 48 matching lines @@
           default:
             busy = false;
             break;
         }
       });
   }
 
   DebuggerInputElement.created() : super.created();
 }