Standardize on using "kind" to distinguish sub-varieties of a type.

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/app.dart';
@@ skipping 270 matching lines @@
       '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) {
+      if (event.kind == ServiceEvent.kPauseStart) {
         debugger.console.print("Type 'continue' to start the isolate");
         return new Future.value(null);
       }
-      if (event.eventType == ServiceEvent.kPauseExit) {
+      if (event.kind == ServiceEvent.kPauseExit) {
         debugger.console.print("Type 'continue' to exit the isolate");
         return new Future.value(null);
       }
       return debugger.isolate.stepOver();
     } else {
       debugger.console.print('The program is already running');
       return new Future.value(null);
     }
   }
 
   String helpShort =
       'Continue running the isolate until it reaches the next source location '
       'in the current function';
 
   String helpLong =
       'Continue running the isolate until it reaches the next source location '
       'in the current function.\n'
       '\n'
       'Syntax: next\n';
 }
 
 class StepCommand extends DebuggerCommand {
   StepCommand(Debugger debugger) : super(debugger, 'step', []);
 
   Future run(List<String> args) {
     if (debugger.isolatePaused()) {
       var event = debugger.isolate.pauseEvent;
-      if (event.eventType == ServiceEvent.kPauseStart) {
+      if (event.kind == ServiceEvent.kPauseStart) {
         debugger.console.print("Type 'continue' to start the isolate");
         return new Future.value(null);
       }
-      if (event.eventType == ServiceEvent.kPauseExit) {
+      if (event.kind == ServiceEvent.kPauseExit) {
         debugger.console.print("Type 'continue' to exit the isolate");
         return new Future.value(null);
       }
       return debugger.isolate.stepInto();
     } else {
       debugger.console.print('The program is already running');
       return new Future.value(null);
     }
   }
 
@@ skipping 587 matching lines @@
       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 != null &&
             isolate.pauseEvent != null &&
-            isolate.pauseEvent.eventType != ServiceEvent.kResume);
+            isolate.pauseEvent.kind != 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;
       }
     });
   }
@@ skipping 21 matching lines @@
       console.print("Isolate is running (type 'pause' to interrupt)");
     } else if (_isolate.pauseEvent != null) {
       _reportPause(_isolate.pauseEvent);
     } else {
       console.print('Isolate is in unknown state');
     }
     warnOutOfDate();
   }
 
   void _reportPause(ServiceEvent event) {
-    if (event.eventType == ServiceEvent.kPauseStart) {
+    if (event.kind == ServiceEvent.kPauseStart) {
       console.print(
           "Paused at isolate start (type 'continue' to start the isolate')");
-    } else if (event.eventType == ServiceEvent.kPauseExit) {
+    } else if (event.kind == ServiceEvent.kPauseExit) {
       console.print(
           "Paused at isolate exit (type 'continue' to exit the isolate')");
     }
     if (stack['frames'].length > 0) {
       var frame = stack['frames'][0];
       var script = frame['script'];
       script.load().then((_) {
         var line = script.tokenToLine(frame['tokenPos']);
         var col = script.tokenToCol(frame['tokenPos']);
         if (event.breakpoint != null) {
           var bpId = event.breakpoint.number;
           console.print('Paused at breakpoint ${bpId} at '
                         '${script.name}:${line}:${col}');
         } else if (event.exception != null) {
           // TODO(turnidge): Test this.
           console.print('Paused due to exception ${event.exception} at '
                         '${script.name}:${line}:${col}');
         } else {
           console.print('Paused at ${script.name}:${line}:${col}');
         }
       });
     }
   }
 
   Future _reportBreakpointEvent(ServiceEvent event) {
     var bpt = event.breakpoint;
     var verb = null;
-    switch (event.eventType) {
+    switch (event.kind) {
       case ServiceEvent.kBreakpointAdded:
         verb = 'added';
         break;
       case ServiceEvent.kBreakpointResolved:
         verb = 'resolved';
         break;
       case ServiceEvent.kBreakpointRemoved:
         verb = 'removed';
         break;
       default:
         break;
     }
     var script = bpt.script;
     return script.load().then((_) {
       var bpId = bpt.number;
       var tokenPos = bpt.tokenPos;
       var line = script.tokenToLine(tokenPos);
       var col = script.tokenToCol(tokenPos);
       if (bpt.resolved) {
         console.print(
             'Breakpoint ${bpId} ${verb} at ${script.name}:${line}:${col}');
       } else {
         console.print(
             'Future breakpoint ${bpId} ${verb} at ${script.name}:${line}:${col}');
       }
     });
   }
 
   void _onEvent(ServiceEvent event) {
-    switch(event.eventType) {
+    switch(event.kind) {
       case ServiceEvent.kIsolateStart:
         {
           var iso = event.owner;
           console.print(
               "Isolate ${iso.number} '${iso.name}' has been created");
         }
         break;
 
       case ServiceEvent.kIsolateExit:
         {
@@ skipping 618 matching lines @@
           default:
             busy = false;
             break;
         }
       });
   }
 
   DebuggerInputElement.created() : super.created();
 }