Rename debug domain to execution

pkg/analysis_server/lib/src/generated_protocol.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.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analysis_server/spec/generate_files".
 
 part of protocol;
 /**
@@ skipping 3350 matching lines @@
 
 /**
  * edit.getFixes result
  *
  * {
  *   "fixes": List<AnalysisErrorFixes>
  * }
  */
 class EditGetFixesResult implements HasToJson {
   /**
-   * The fixes that are available for each of the analysis errors. There is a
-   * one-to-one correspondence between the analysis errors in the request and
-   * the lists of changes in the response. In particular, it is always the case
-   * that errors.length == fixes.length and that fixes[i] is the list of fixes
-   * for the error in errors[i]. The list of changes corresponding to an error
-   * can be empty if there are no fixes available for that error.
+   * The fixes that are available for the errors at the given offset.
    */
   List<AnalysisErrorFixes> fixes;
 
   EditGetFixesResult(this.fixes);
 
   factory EditGetFixesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
@@ skipping 314 matching lines @@
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, problems.hashCode);
     hash = _JenkinsSmiHash.combine(hash, feedback.hashCode);
     hash = _JenkinsSmiHash.combine(hash, change.hashCode);
     hash = _JenkinsSmiHash.combine(hash, potentialEdits.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
- * debug.createContext params
+ * execution.createContext params
  *
  * {
  *   "contextRoot": FilePath
  * }
  */
-class DebugCreateContextParams implements HasToJson {
+class ExecutionCreateContextParams implements HasToJson {
   /**
    * The path of the Dart or HTML file that will be launched.
    */
   String contextRoot;
 
-  DebugCreateContextParams(this.contextRoot);
+  ExecutionCreateContextParams(this.contextRoot);
 
-  factory DebugCreateContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExecutionCreateContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String contextRoot;
       if (json.containsKey("contextRoot")) {
         contextRoot = jsonDecoder._decodeString(jsonPath + ".contextRoot", json["contextRoot"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "contextRoot");
       }
-      return new DebugCreateContextParams(contextRoot);
+      return new ExecutionCreateContextParams(contextRoot);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "debug.createContext params");
+      throw jsonDecoder.mismatch(jsonPath, "execution.createContext params");
     }
   }
 
-  factory DebugCreateContextParams.fromRequest(Request request) {
-    return new DebugCreateContextParams.fromJson(
+  factory ExecutionCreateContextParams.fromRequest(Request request) {
+    return new ExecutionCreateContextParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["contextRoot"] = contextRoot;
     return result;
   }
 
   Request toRequest(String id) {
-    return new Request(id, "debug.createContext", toJson());
+    return new Request(id, "execution.createContext", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
-    if (other is DebugCreateContextParams) {
+    if (other is ExecutionCreateContextParams) {
       return contextRoot == other.contextRoot;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, contextRoot.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
- * debug.createContext result
+ * execution.createContext result
  *
  * {
- *   "id": DebugContextId
+ *   "id": ExecutionContextId
  * }
  */
-class DebugCreateContextResult implements HasToJson {
+class ExecutionCreateContextResult implements HasToJson {
   /**
-   * The identifier used to refer to the debugging context that was created.
+   * The identifier used to refer to the execution context that was created.
    */
   String id;
 
-  DebugCreateContextResult(this.id);
+  ExecutionCreateContextResult(this.id);
 
-  factory DebugCreateContextResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExecutionCreateContextResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
-      return new DebugCreateContextResult(id);
+      return new ExecutionCreateContextResult(id);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "debug.createContext result");
+      throw jsonDecoder.mismatch(jsonPath, "execution.createContext result");
     }
   }
 
-  factory DebugCreateContextResult.fromResponse(Response response) {
-    return new DebugCreateContextResult.fromJson(
+  factory ExecutionCreateContextResult.fromResponse(Response response) {
+    return new ExecutionCreateContextResult.fromJson(
         new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
-    if (other is DebugCreateContextResult) {
+    if (other is ExecutionCreateContextResult) {
       return id == other.id;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, id.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
- * debug.deleteContext params
+ * execution.deleteContext params
  *
  * {
- *   "id": DebugContextId
+ *   "id": ExecutionContextId
  * }
  */
-class DebugDeleteContextParams implements HasToJson {
+class ExecutionDeleteContextParams implements HasToJson {
   /**
-   * The identifier of the debugging context that is to be deleted.
+   * The identifier of the execution context that is to be deleted.
    */
   String id;
 
-  DebugDeleteContextParams(this.id);
+  ExecutionDeleteContextParams(this.id);
 
-  factory DebugDeleteContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExecutionDeleteContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
-      return new DebugDeleteContextParams(id);
+      return new ExecutionDeleteContextParams(id);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "debug.deleteContext params");
+      throw jsonDecoder.mismatch(jsonPath, "execution.deleteContext params");
     }
   }
 
-  factory DebugDeleteContextParams.fromRequest(Request request) {
-    return new DebugDeleteContextParams.fromJson(
+  factory ExecutionDeleteContextParams.fromRequest(Request request) {
+    return new ExecutionDeleteContextParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Request toRequest(String id) {
-    return new Request(id, "debug.deleteContext", toJson());
+    return new Request(id, "execution.deleteContext", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
-    if (other is DebugDeleteContextParams) {
+    if (other is ExecutionDeleteContextParams) {
       return id == other.id;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, id.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 /**
- * debug.deleteContext result
+ * execution.deleteContext result
  */
-class DebugDeleteContextResult {
+class ExecutionDeleteContextResult {
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
   bool operator==(other) {
-    if (other is DebugDeleteContextResult) {
+    if (other is ExecutionDeleteContextResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
-    return 923895626;
+    return 479954425;
   }
 }
 
 /**
- * debug.mapUri params
+ * execution.mapUri params
  *
  * {
- *   "id": DebugContextId
+ *   "id": ExecutionContextId
  *   "file": optional FilePath
  *   "uri": optional String
  * }
  */
-class DebugMapUriParams implements HasToJson {
+class ExecutionMapUriParams implements HasToJson {
   /**
-   * The identifier of the debugging context in which the URI is to be mapped.
+   * The identifier of the execution context in which the URI is to be mapped.
    */
   String id;
 
   /**
    * The path of the file to be mapped into a URI.
    */
   String file;
 
   /**
    * The URI to be mapped into a file path.
    */
   String uri;
 
-  DebugMapUriParams(this.id, {this.file, this.uri});
+  ExecutionMapUriParams(this.id, {this.file, this.uri});
 
-  factory DebugMapUriParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExecutionMapUriParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
       }
       String uri;
       if (json.containsKey("uri")) {
         uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]);
       }
-      return new DebugMapUriParams(id, file: file, uri: uri);
+      return new ExecutionMapUriParams(id, file: file, uri: uri);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "debug.mapUri params");
+      throw jsonDecoder.mismatch(jsonPath, "execution.mapUri params");
     }
   }
 
-  factory DebugMapUriParams.fromRequest(Request request) {
-    return new DebugMapUriParams.fromJson(
+  factory ExecutionMapUriParams.fromRequest(Request request) {
+    return new ExecutionMapUriParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     if (file != null) {
       result["file"] = file;
     }
     if (uri != null) {
       result["uri"] = uri;
     }
     return result;
   }
 
   Request toRequest(String id) {
-    return new Request(id, "debug.mapUri", toJson());
+    return new Request(id, "execution.mapUri", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
-    if (other is DebugMapUriParams) {
+    if (other is ExecutionMapUriParams) {
       return id == other.id &&
           file == other.file &&
           uri == other.uri;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, id.hashCode);
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, uri.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
- * debug.mapUri result
+ * execution.mapUri result
  *
  * {
  *   "file": optional FilePath
  *   "uri": optional String
  * }
  */
-class DebugMapUriResult implements HasToJson {
+class ExecutionMapUriResult implements HasToJson {
   /**
    * The file to which the URI was mapped. This field is omitted if the uri
    * field was not given in the request.
    */
   String file;
 
   /**
    * The URI to which the file path was mapped. This field is omitted if the
    * file field was not given in the request.
    */
   String uri;
 
-  DebugMapUriResult({this.file, this.uri});
+  ExecutionMapUriResult({this.file, this.uri});
 
-  factory DebugMapUriResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExecutionMapUriResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
       }
       String uri;
       if (json.containsKey("uri")) {
         uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]);
       }
-      return new DebugMapUriResult(file: file, uri: uri);
+      return new ExecutionMapUriResult(file: file, uri: uri);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "debug.mapUri result");
+      throw jsonDecoder.mismatch(jsonPath, "execution.mapUri result");
     }
   }
 
-  factory DebugMapUriResult.fromResponse(Response response) {
-    return new DebugMapUriResult.fromJson(
+  factory ExecutionMapUriResult.fromResponse(Response response) {
+    return new ExecutionMapUriResult.fromJson(
         new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (file != null) {
       result["file"] = file;
     }
     if (uri != null) {
       result["uri"] = uri;
     }
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
-    if (other is DebugMapUriResult) {
+    if (other is ExecutionMapUriResult) {
       return file == other.file &&
           uri == other.uri;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, uri.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
- * debug.setSubscriptions params
+ * execution.setSubscriptions params
  *
  * {
- *   "subscriptions": List<DebugService>
+ *   "subscriptions": List<ExecutionService>
  * }
  */
-class DebugSetSubscriptionsParams implements HasToJson {
+class ExecutionSetSubscriptionsParams implements HasToJson {
   /**
    * A list of the services being subscribed to.
    */
-  List<DebugService> subscriptions;
+  List<ExecutionService> subscriptions;
 
-  DebugSetSubscriptionsParams(this.subscriptions);
+  ExecutionSetSubscriptionsParams(this.subscriptions);
 
-  factory DebugSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExecutionSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
-      List<DebugService> subscriptions;
+      List<ExecutionService> subscriptions;
       if (json.containsKey("subscriptions")) {
-        subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new DebugService.fromJson(jsonDecoder, jsonPath, json));
+        subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new ExecutionService.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
-      return new DebugSetSubscriptionsParams(subscriptions);
+      return new ExecutionSetSubscriptionsParams(subscriptions);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "debug.setSubscriptions params");
+      throw jsonDecoder.mismatch(jsonPath, "execution.setSubscriptions params");
     }
   }
 
-  factory DebugSetSubscriptionsParams.fromRequest(Request request) {
-    return new DebugSetSubscriptionsParams.fromJson(
+  factory ExecutionSetSubscriptionsParams.fromRequest(Request request) {
+    return new ExecutionSetSubscriptionsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["subscriptions"] = subscriptions.map((DebugService value) => value.toJson()).toList();
+    result["subscriptions"] = subscriptions.map((ExecutionService value) => value.toJson()).toList();
     return result;
   }
 
   Request toRequest(String id) {
-    return new Request(id, "debug.setSubscriptions", toJson());
+    return new Request(id, "execution.setSubscriptions", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
-    if (other is DebugSetSubscriptionsParams) {
-      return _listEqual(subscriptions, other.subscriptions, (DebugService a, DebugService b) => a == b);
+    if (other is ExecutionSetSubscriptionsParams) {
+      return _listEqual(subscriptions, other.subscriptions, (ExecutionService a, ExecutionService b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 /**
- * debug.setSubscriptions result
+ * execution.setSubscriptions result
  */
-class DebugSetSubscriptionsResult {
+class ExecutionSetSubscriptionsResult {
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
   bool operator==(other) {
-    if (other is DebugSetSubscriptionsResult) {
+    if (other is ExecutionSetSubscriptionsResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
-    return 36732888;
+    return 287678780;
   }
 }
 
 /**
- * debug.launchData params
+ * execution.launchData params
  *
  * {
  *   "executables": List<ExecutableFile>
  *   "dartToHtml": Map<FilePath, List<FilePath>>
  *   "htmlToDart": Map<FilePath, List<FilePath>>
  * }
  */
-class DebugLaunchDataParams implements HasToJson {
+class ExecutionLaunchDataParams implements HasToJson {
   /**
    * A list of the files that are executable in the given context. This list
    * replaces any previous list provided for the given context.
    */
   List<ExecutableFile> executables;
 
   /**
    * A mapping from the paths of Dart files that are referenced by HTML files
    * to a list of the HTML files that reference the Dart files.
    */
   Map<String, List<String>> dartToHtml;
 
   /**
    * A mapping from the paths of HTML files that reference Dart files to a list
    * of the Dart files they reference.
    */
   Map<String, List<String>> htmlToDart;
 
-  DebugLaunchDataParams(this.executables, this.dartToHtml, this.htmlToDart);
+  ExecutionLaunchDataParams(this.executables, this.dartToHtml, this.htmlToDart);
 
-  factory DebugLaunchDataParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExecutionLaunchDataParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<ExecutableFile> executables;
       if (json.containsKey("executables")) {
         executables = jsonDecoder._decodeList(jsonPath + ".executables", json["executables"], (String jsonPath, Object json) => new ExecutableFile.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "executables");
       }
       Map<String, List<String>> dartToHtml;
       if (json.containsKey("dartToHtml")) {
         dartToHtml = jsonDecoder._decodeMap(jsonPath + ".dartToHtml", json["dartToHtml"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "dartToHtml");
       }
       Map<String, List<String>> htmlToDart;
       if (json.containsKey("htmlToDart")) {
         htmlToDart = jsonDecoder._decodeMap(jsonPath + ".htmlToDart", json["htmlToDart"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "htmlToDart");
       }
-      return new DebugLaunchDataParams(executables, dartToHtml, htmlToDart);
+      return new ExecutionLaunchDataParams(executables, dartToHtml, htmlToDart);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "debug.launchData params");
+      throw jsonDecoder.mismatch(jsonPath, "execution.launchData params");
     }
   }
 
-  factory DebugLaunchDataParams.fromNotification(Notification notification) {
-    return new DebugLaunchDataParams.fromJson(
+  factory ExecutionLaunchDataParams.fromNotification(Notification notification) {
+    return new ExecutionLaunchDataParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["executables"] = executables.map((ExecutableFile value) => value.toJson()).toList();
     result["dartToHtml"] = dartToHtml;
     result["htmlToDart"] = htmlToDart;
     return result;
   }
 
   Notification toNotification() {
-    return new Notification("debug.launchData", toJson());
+    return new Notification("execution.launchData", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
-    if (other is DebugLaunchDataParams) {
+    if (other is ExecutionLaunchDataParams) {
       return _listEqual(executables, other.executables, (ExecutableFile a, ExecutableFile b) => a == b) &&
           _mapEqual(dartToHtml, other.dartToHtml, (List<String> a, List<String> b) => _listEqual(a, b, (String a, String b) => a == b)) &&
           _mapEqual(htmlToDart, other.htmlToDart, (List<String> a, List<String> b) => _listEqual(a, b, (String a, String b) => a == b));
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
@@ skipping 1226 matching lines @@
   factory CompletionSuggestionKind.fromElementKind(engine.ElementKind kind) =>
       _completionSuggestionKindFromElementKind(kind);
 
   @override
   String toString() => "CompletionSuggestionKind.$name";
 
   String toJson() => name;
 }
 
 /**
- * DebugService
- *
- * enum {
- *   LAUNCH_DATA
- * }
- */
-class DebugService {
-  static const LAUNCH_DATA = const DebugService._("LAUNCH_DATA");
-
-  final String name;
-
-  const DebugService._(this.name);
-
-  factory DebugService(String name) {
-    switch (name) {
-      case "LAUNCH_DATA":
-        return LAUNCH_DATA;
-    }
-    throw new Exception('Illegal enum value: $name');
-  }
-
-  factory DebugService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
-    if (json is String) {
-      try {
-        return new DebugService(json);
-      } catch(_) {
-        // Fall through
-      }
-    }
-    throw jsonDecoder.mismatch(jsonPath, "DebugService");
-  }
-
-  @override
-  String toString() => "DebugService.$name";
-
-  String toJson() => name;
-}
-
-/**
  * Element
  *
  * {
  *   "kind": ElementKind
  *   "name": String
  *   "location": optional Location
  *   "flags": int
  *   "parameters": optional String
  *   "returnType": optional String
  * }
@@ skipping 407 matching lines @@
     throw jsonDecoder.mismatch(jsonPath, "ExecutableKind");
   }
 
   @override
   String toString() => "ExecutableKind.$name";
 
   String toJson() => name;
 }
 
 /**
+ * ExecutionService
+ *
+ * enum {
+ *   LAUNCH_DATA
+ * }
+ */
+class ExecutionService {
+  static const LAUNCH_DATA = const ExecutionService._("LAUNCH_DATA");
+
+  final String name;
+
+  const ExecutionService._(this.name);
+
+  factory ExecutionService(String name) {
+    switch (name) {
+      case "LAUNCH_DATA":
+        return LAUNCH_DATA;
+    }
+    throw new Exception('Illegal enum value: $name');
+  }
+
+  factory ExecutionService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json is String) {
+      try {
+        return new ExecutionService(json);
+      } catch(_) {
+        // Fall through
+      }
+    }
+    throw jsonDecoder.mismatch(jsonPath, "ExecutionService");
+  }
+
+  @override
+  String toString() => "ExecutionService.$name";
+
+  String toJson() => name;
+}
+
+/**
  * FoldingKind
  *
  * enum {
  *   COMMENT
  *   CLASS_MEMBER
  *   DIRECTIVES
  *   DOCUMENTATION_COMMENT
  *   TOP_LEVEL_DECLARATION
  * }
  */
@@ skipping 3865 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }