Run dartfmt on dart2js codebase.

pkg/analyzer_plugin/lib/protocol/protocol_generated.dart

 // 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.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analysis_server/tool/spec/generate_files".
 
 import 'dart:convert' hide JsonDecoder;
 
@@ skipping 24 matching lines @@
    */
   void set content(String value) {
     assert(value != null);
     this._content = value;
   }
 
   AddContentOverlay(String content) {
     this.content = content;
   }
 
-  factory AddContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AddContentOverlay.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       if (json["type"] != "add") {
         throw jsonDecoder.mismatch(jsonPath, "equal " + "add", json);
       }
       String content;
       if (json.containsKey("content")) {
-        content = jsonDecoder.decodeString(jsonPath + ".content", json["content"]);
+        content =
+            jsonDecoder.decodeString(jsonPath + ".content", json["content"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "content");
       }
       return new AddContentOverlay(content);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "AddContentOverlay", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["type"] = "add";
     result["content"] = content;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AddContentOverlay) {
       return content == other.content;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, 704418402);
@@ skipping 134 matching lines @@
    * needs to be performant it is possible that complicated tests will be
    * skipped and a false negative returned. For this reason, this attribute
    * should be treated as a "hint". Despite the possibility of false negatives,
    * no false positives should be returned. If a client sees this flag set they
    * can proceed with the confidence that there are in fact associated fixes.
    */
   void set hasFix(bool value) {
     this._hasFix = value;
   }
 
-  AnalysisError(AnalysisErrorSeverity severity, AnalysisErrorType type, Location location, String message, String code, {String correction, bool hasFix}) {
+  AnalysisError(AnalysisErrorSeverity severity, AnalysisErrorType type,
+      Location location, String message, String code,
+      {String correction, bool hasFix}) {
     this.severity = severity;
     this.type = type;
     this.location = location;
     this.message = message;
     this.correction = correction;
     this.code = code;
     this.hasFix = hasFix;
   }
 
-  factory AnalysisError.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisError.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       AnalysisErrorSeverity severity;
       if (json.containsKey("severity")) {
-        severity = new AnalysisErrorSeverity.fromJson(jsonDecoder, jsonPath + ".severity", json["severity"]);
+        severity = new AnalysisErrorSeverity.fromJson(
+            jsonDecoder, jsonPath + ".severity", json["severity"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "severity");
       }
       AnalysisErrorType type;
       if (json.containsKey("type")) {
-        type = new AnalysisErrorType.fromJson(jsonDecoder, jsonPath + ".type", json["type"]);
+        type = new AnalysisErrorType.fromJson(
+            jsonDecoder, jsonPath + ".type", json["type"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "type");
       }
       Location location;
       if (json.containsKey("location")) {
-        location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
+        location = new Location.fromJson(
+            jsonDecoder, jsonPath + ".location", json["location"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "location");
       }
       String message;
       if (json.containsKey("message")) {
-        message = jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
+        message =
+            jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "message");
       }
       String correction;
       if (json.containsKey("correction")) {
-        correction = jsonDecoder.decodeString(jsonPath + ".correction", json["correction"]);
+        correction = jsonDecoder.decodeString(
+            jsonPath + ".correction", json["correction"]);
       }
       String code;
       if (json.containsKey("code")) {
         code = jsonDecoder.decodeString(jsonPath + ".code", json["code"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "code");
       }
       bool hasFix;
       if (json.containsKey("hasFix")) {
         hasFix = jsonDecoder.decodeBool(jsonPath + ".hasFix", json["hasFix"]);
       }
-      return new AnalysisError(severity, type, location, message, code, correction: correction, hasFix: hasFix);
+      return new AnalysisError(severity, type, location, message, code,
+          correction: correction, hasFix: hasFix);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "AnalysisError", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["severity"] = severity.toJson();
     result["type"] = type.toJson();
     result["location"] = location.toJson();
     result["message"] = message;
     if (correction != null) {
       result["correction"] = correction;
     }
     result["code"] = code;
     if (hasFix != null) {
       result["hasFix"] = hasFix;
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisError) {
       return severity == other.severity &&
           type == other.type &&
           location == other.location &&
           message == other.message &&
           correction == other.correction &&
           code == other.code &&
           hasFix == other.hasFix;
     }
     return false;
@@ skipping 47 matching lines @@
   List<PrioritizedSourceChange> get fixes => _fixes;
 
   /**
    * The fixes associated with the error.
    */
   void set fixes(List<PrioritizedSourceChange> value) {
     assert(value != null);
     this._fixes = value;
   }
 
-  AnalysisErrorFixes(AnalysisError error, {List<PrioritizedSourceChange> fixes}) {
+  AnalysisErrorFixes(AnalysisError error,
+      {List<PrioritizedSourceChange> fixes}) {
     this.error = error;
     if (fixes == null) {
       this.fixes = <PrioritizedSourceChange>[];
     } else {
       this.fixes = fixes;
     }
   }
 
-  factory AnalysisErrorFixes.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisErrorFixes.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       AnalysisError error;
       if (json.containsKey("error")) {
-        error = new AnalysisError.fromJson(jsonDecoder, jsonPath + ".error", json["error"]);
+        error = new AnalysisError.fromJson(
+            jsonDecoder, jsonPath + ".error", json["error"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "error");
       }
       List<PrioritizedSourceChange> fixes;
       if (json.containsKey("fixes")) {
-        fixes = jsonDecoder.decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new PrioritizedSourceChange.fromJson(jsonDecoder, jsonPath, json));
+        fixes = jsonDecoder.decodeList(
+            jsonPath + ".fixes",
+            json["fixes"],
+            (String jsonPath, Object json) =>
+                new PrioritizedSourceChange.fromJson(
+                    jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "fixes");
       }
       return new AnalysisErrorFixes(error, fixes: fixes);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorFixes", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["error"] = error.toJson();
-    result["fixes"] = fixes.map((PrioritizedSourceChange value) => value.toJson()).toList();
+    result["fixes"] =
+        fixes.map((PrioritizedSourceChange value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisErrorFixes) {
       return error == other.error &&
-          listEqual(fixes, other.fixes, (PrioritizedSourceChange a, PrioritizedSourceChange b) => a == b);
+          listEqual(fixes, other.fixes,
+              (PrioritizedSourceChange a, PrioritizedSourceChange b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, error.hashCode);
     hash = JenkinsSmiHash.combine(hash, fixes.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * AnalysisErrorSeverity
  *
  * enum {
  *   INFO
  *   WARNING
  *   ERROR
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class AnalysisErrorSeverity implements Enum {
-  static const AnalysisErrorSeverity INFO = const AnalysisErrorSeverity._("INFO");
+  static const AnalysisErrorSeverity INFO =
+      const AnalysisErrorSeverity._("INFO");
 
-  static const AnalysisErrorSeverity WARNING = const AnalysisErrorSeverity._("WARNING");
+  static const AnalysisErrorSeverity WARNING =
+      const AnalysisErrorSeverity._("WARNING");
 
-  static const AnalysisErrorSeverity ERROR = const AnalysisErrorSeverity._("ERROR");
+  static const AnalysisErrorSeverity ERROR =
+      const AnalysisErrorSeverity._("ERROR");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<AnalysisErrorSeverity> VALUES = const <AnalysisErrorSeverity>[INFO, WARNING, ERROR];
+  static const List<AnalysisErrorSeverity> VALUES =
+      const <AnalysisErrorSeverity>[INFO, WARNING, ERROR];
 
   @override
   final String name;
 
   const AnalysisErrorSeverity._(this.name);
 
   factory AnalysisErrorSeverity(String name) {
     switch (name) {
       case "INFO":
         return INFO;
       case "WARNING":
         return WARNING;
       case "ERROR":
         return ERROR;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory AnalysisErrorSeverity.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisErrorSeverity.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new AnalysisErrorSeverity(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorSeverity", json);
   }
 
   @override
   String toString() => "AnalysisErrorSeverity.$name";
 
   String toJson() => name;
 }
 
 /**
  * AnalysisErrorType
  *
  * enum {
  *   CHECKED_MODE_COMPILE_TIME_ERROR
  *   COMPILE_TIME_ERROR
  *   HINT
  *   LINT
  *   STATIC_TYPE_WARNING
  *   STATIC_WARNING
  *   SYNTACTIC_ERROR
  *   TODO
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class AnalysisErrorType implements Enum {
-  static const AnalysisErrorType CHECKED_MODE_COMPILE_TIME_ERROR = const AnalysisErrorType._("CHECKED_MODE_COMPILE_TIME_ERROR");
+  static const AnalysisErrorType CHECKED_MODE_COMPILE_TIME_ERROR =
+      const AnalysisErrorType._("CHECKED_MODE_COMPILE_TIME_ERROR");
 
-  static const AnalysisErrorType COMPILE_TIME_ERROR = const AnalysisErrorType._("COMPILE_TIME_ERROR");
+  static const AnalysisErrorType COMPILE_TIME_ERROR =
+      const AnalysisErrorType._("COMPILE_TIME_ERROR");
 
   static const AnalysisErrorType HINT = const AnalysisErrorType._("HINT");
 
   static const AnalysisErrorType LINT = const AnalysisErrorType._("LINT");
 
-  static const AnalysisErrorType STATIC_TYPE_WARNING = const AnalysisErrorType._("STATIC_TYPE_WARNING");
+  static const AnalysisErrorType STATIC_TYPE_WARNING =
+      const AnalysisErrorType._("STATIC_TYPE_WARNING");
 
-  static const AnalysisErrorType STATIC_WARNING = const AnalysisErrorType._("STATIC_WARNING");
+  static const AnalysisErrorType STATIC_WARNING =
+      const AnalysisErrorType._("STATIC_WARNING");
 
-  static const AnalysisErrorType SYNTACTIC_ERROR = const AnalysisErrorType._("SYNTACTIC_ERROR");
+  static const AnalysisErrorType SYNTACTIC_ERROR =
+      const AnalysisErrorType._("SYNTACTIC_ERROR");
 
   static const AnalysisErrorType TODO = const AnalysisErrorType._("TODO");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<AnalysisErrorType> VALUES = const <AnalysisErrorType>[CHECKED_MODE_COMPILE_TIME_ERROR, COMPILE_TIME_ERROR, HINT, LINT, STATIC_TYPE_WARNING, STATIC_WARNING, SYNTACTIC_ERROR, TODO];
+  static const List<AnalysisErrorType> VALUES = const <AnalysisErrorType>[
+    CHECKED_MODE_COMPILE_TIME_ERROR,
+    COMPILE_TIME_ERROR,
+    HINT,
+    LINT,
+    STATIC_TYPE_WARNING,
+    STATIC_WARNING,
+    SYNTACTIC_ERROR,
+    TODO
+  ];
 
   @override
   final String name;
 
   const AnalysisErrorType._(this.name);
 
   factory AnalysisErrorType(String name) {
     switch (name) {
       case "CHECKED_MODE_COMPILE_TIME_ERROR":
         return CHECKED_MODE_COMPILE_TIME_ERROR;
       case "COMPILE_TIME_ERROR":
         return COMPILE_TIME_ERROR;
       case "HINT":
         return HINT;
       case "LINT":
         return LINT;
       case "STATIC_TYPE_WARNING":
         return STATIC_TYPE_WARNING;
       case "STATIC_WARNING":
         return STATIC_WARNING;
       case "SYNTACTIC_ERROR":
         return SYNTACTIC_ERROR;
       case "TODO":
         return TODO;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory AnalysisErrorType.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisErrorType.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new AnalysisErrorType(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorType", json);
   }
 
   @override
   String toString() => "AnalysisErrorType.$name";
 
   String toJson() => name;
@@ skipping 38 matching lines @@
   void set errors(List<AnalysisError> value) {
     assert(value != null);
     this._errors = value;
   }
 
   AnalysisErrorsParams(String file, List<AnalysisError> errors) {
     this.file = file;
     this.errors = errors;
   }
 
-  factory AnalysisErrorsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisErrorsParams.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       List<AnalysisError> errors;
       if (json.containsKey("errors")) {
-        errors = jsonDecoder.decodeList(jsonPath + ".errors", json["errors"], (String jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPath, json));
+        errors = jsonDecoder.decodeList(
+            jsonPath + ".errors",
+            json["errors"],
+            (String jsonPath, Object json) =>
+                new AnalysisError.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "errors");
       }
       return new AnalysisErrorsParams(file, errors);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.errors params", json);
     }
   }
 
   factory AnalysisErrorsParams.fromNotification(Notification notification) {
     return new AnalysisErrorsParams.fromJson(
         new ResponseDecoder(null), "params", notification.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["errors"] = errors.map((AnalysisError value) => value.toJson()).toList();
+    result["errors"] =
+        errors.map((AnalysisError value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
     return new Notification("analysis.errors", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisErrorsParams) {
       return file == other.file &&
-          listEqual(errors, other.errors, (AnalysisError a, AnalysisError b) => a == b);
+          listEqual(errors, other.errors,
+              (AnalysisError a, AnalysisError b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, file.hashCode);
     hash = JenkinsSmiHash.combine(hash, errors.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 39 matching lines @@
   void set regions(List<FoldingRegion> value) {
     assert(value != null);
     this._regions = value;
   }
 
   AnalysisFoldingParams(String file, List<FoldingRegion> regions) {
     this.file = file;
     this.regions = regions;
   }
 
-  factory AnalysisFoldingParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisFoldingParams.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       List<FoldingRegion> regions;
       if (json.containsKey("regions")) {
-        regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new FoldingRegion.fromJson(jsonDecoder, jsonPath, json));
+        regions = jsonDecoder.decodeList(
+            jsonPath + ".regions",
+            json["regions"],
+            (String jsonPath, Object json) =>
+                new FoldingRegion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "regions");
       }
       return new AnalysisFoldingParams(file, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.folding params", json);
     }
   }
 
   factory AnalysisFoldingParams.fromNotification(Notification notification) {
     return new AnalysisFoldingParams.fromJson(
         new ResponseDecoder(null), "params", notification.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["regions"] = regions.map((FoldingRegion value) => value.toJson()).toList();
+    result["regions"] =
+        regions.map((FoldingRegion value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
     return new Notification("analysis.folding", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisFoldingParams) {
       return file == other.file &&
-          listEqual(regions, other.regions, (FoldingRegion a, FoldingRegion b) => a == b);
+          listEqual(regions, other.regions,
+              (FoldingRegion a, FoldingRegion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, file.hashCode);
     hash = JenkinsSmiHash.combine(hash, regions.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 22 matching lines @@
    */
   void set events(List<WatchEvent> value) {
     assert(value != null);
     this._events = value;
   }
 
   AnalysisHandleWatchEventsParams(List<WatchEvent> events) {
     this.events = events;
   }
 
-  factory AnalysisHandleWatchEventsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisHandleWatchEventsParams.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<WatchEvent> events;
       if (json.containsKey("events")) {
-        events = jsonDecoder.decodeList(jsonPath + ".events", json["events"], (String jsonPath, Object json) => new WatchEvent.fromJson(jsonDecoder, jsonPath, json));
+        events = jsonDecoder.decodeList(
+            jsonPath + ".events",
+            json["events"],
+            (String jsonPath, Object json) =>
+                new WatchEvent.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "events");
       }
       return new AnalysisHandleWatchEventsParams(events);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.handleWatchEvents params", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "analysis.handleWatchEvents params", json);
     }
   }
 
   factory AnalysisHandleWatchEventsParams.fromRequest(Request request) {
     return new AnalysisHandleWatchEventsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["events"] = events.map((WatchEvent value) => value.toJson()).toList();
+    result["events"] =
+        events.map((WatchEvent value) => value.toJson()).toList();
     return result;
   }
 
   @override
   Request toRequest(String id) {
     return new Request(id, "analysis.handleWatchEvents", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisHandleWatchEventsParams) {
-      return listEqual(events, other.events, (WatchEvent a, WatchEvent b) => a == b);
+      return listEqual(
+          events, other.events, (WatchEvent a, WatchEvent b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, events.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.handleWatchEvents result
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class AnalysisHandleWatchEventsResult implements ResponseResult {
   @override
   Map<String, dynamic> toJson() => <String, dynamic>{};
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisHandleWatchEventsResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 779767607;
   }
@@ skipping 38 matching lines @@
   void set regions(List<HighlightRegion> value) {
     assert(value != null);
     this._regions = value;
   }
 
   AnalysisHighlightsParams(String file, List<HighlightRegion> regions) {
     this.file = file;
     this.regions = regions;
   }
 
-  factory AnalysisHighlightsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisHighlightsParams.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       List<HighlightRegion> regions;
       if (json.containsKey("regions")) {
-        regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new HighlightRegion.fromJson(jsonDecoder, jsonPath, json));
+        regions = jsonDecoder.decodeList(
+            jsonPath + ".regions",
+            json["regions"],
+            (String jsonPath, Object json) =>
+                new HighlightRegion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "regions");
       }
       return new AnalysisHighlightsParams(file, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params", json);
     }
   }
 
   factory AnalysisHighlightsParams.fromNotification(Notification notification) {
     return new AnalysisHighlightsParams.fromJson(
         new ResponseDecoder(null), "params", notification.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["regions"] = regions.map((HighlightRegion value) => value.toJson()).toList();
+    result["regions"] =
+        regions.map((HighlightRegion value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
     return new Notification("analysis.highlights", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisHighlightsParams) {
       return file == other.file &&
-          listEqual(regions, other.regions, (HighlightRegion a, HighlightRegion b) => a == b);
+          listEqual(regions, other.regions,
+              (HighlightRegion a, HighlightRegion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, file.hashCode);
     hash = JenkinsSmiHash.combine(hash, regions.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 70 matching lines @@
 
   /**
    * The files containing navigation targets referenced in the file. They are
    * referenced by NavigationTargets by their index in this array.
    */
   void set files(List<String> value) {
     assert(value != null);
     this._files = value;
   }
 
-  AnalysisNavigationParams(String file, List<NavigationRegion> regions, List<NavigationTarget> targets, List<String> files) {
+  AnalysisNavigationParams(String file, List<NavigationRegion> regions,
+      List<NavigationTarget> targets, List<String> files) {
     this.file = file;
     this.regions = regions;
     this.targets = targets;
     this.files = files;
   }
 
-  factory AnalysisNavigationParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisNavigationParams.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       List<NavigationRegion> regions;
       if (json.containsKey("regions")) {
-        regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, jsonPath, json));
+        regions = jsonDecoder.decodeList(
+            jsonPath + ".regions",
+            json["regions"],
+            (String jsonPath, Object json) =>
+                new NavigationRegion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "regions");
       }
       List<NavigationTarget> targets;
       if (json.containsKey("targets")) {
-        targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, jsonPath, json));
+        targets = jsonDecoder.decodeList(
+            jsonPath + ".targets",
+            json["targets"],
+            (String jsonPath, Object json) =>
+                new NavigationTarget.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "targets");
       }
       List<String> files;
       if (json.containsKey("files")) {
-        files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonDecoder.decodeString);
+        files = jsonDecoder.decodeList(
+            jsonPath + ".files", json["files"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "files");
       }
       return new AnalysisNavigationParams(file, regions, targets, files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params", json);
     }
   }
 
   factory AnalysisNavigationParams.fromNotification(Notification notification) {
     return new AnalysisNavigationParams.fromJson(
         new ResponseDecoder(null), "params", notification.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["regions"] = regions.map((NavigationRegion value) => value.toJson()).toList();
-    result["targets"] = targets.map((NavigationTarget value) => value.toJson()).toList();
+    result["regions"] =
+        regions.map((NavigationRegion value) => value.toJson()).toList();
+    result["targets"] =
+        targets.map((NavigationTarget value) => value.toJson()).toList();
     result["files"] = files;
     return result;
   }
 
   Notification toNotification() {
     return new Notification("analysis.navigation", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisNavigationParams) {
       return file == other.file &&
-          listEqual(regions, other.regions, (NavigationRegion a, NavigationRegion b) => a == b) &&
-          listEqual(targets, other.targets, (NavigationTarget a, NavigationTarget b) => a == b) &&
+          listEqual(regions, other.regions,
+              (NavigationRegion a, NavigationRegion b) => a == b) &&
+          listEqual(targets, other.targets,
+              (NavigationTarget a, NavigationTarget b) => a == b) &&
           listEqual(files, other.files, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, file.hashCode);
     hash = JenkinsSmiHash.combine(hash, regions.hashCode);
@@ skipping 42 matching lines @@
   void set occurrences(List<Occurrences> value) {
     assert(value != null);
     this._occurrences = value;
   }
 
   AnalysisOccurrencesParams(String file, List<Occurrences> occurrences) {
     this.file = file;
     this.occurrences = occurrences;
   }
 
-  factory AnalysisOccurrencesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisOccurrencesParams.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       List<Occurrences> occurrences;
       if (json.containsKey("occurrences")) {
-        occurrences = jsonDecoder.decodeList(jsonPath + ".occurrences", json["occurrences"], (String jsonPath, Object json) => new Occurrences.fromJson(jsonDecoder, jsonPath, json));
+        occurrences = jsonDecoder.decodeList(
+            jsonPath + ".occurrences",
+            json["occurrences"],
+            (String jsonPath, Object json) =>
+                new Occurrences.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "occurrences");
       }
       return new AnalysisOccurrencesParams(file, occurrences);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params", json);
     }
   }
 
-  factory AnalysisOccurrencesParams.fromNotification(Notification notification) {
+  factory AnalysisOccurrencesParams.fromNotification(
+      Notification notification) {
     return new AnalysisOccurrencesParams.fromJson(
         new ResponseDecoder(null), "params", notification.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["occurrences"] = occurrences.map((Occurrences value) => value.toJson()).toList();
+    result["occurrences"] =
+        occurrences.map((Occurrences value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
     return new Notification("analysis.occurrences", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisOccurrencesParams) {
       return file == other.file &&
-          listEqual(occurrences, other.occurrences, (Occurrences a, Occurrences b) => a == b);
+          listEqual(occurrences, other.occurrences,
+              (Occurrences a, Occurrences b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, file.hashCode);
     hash = JenkinsSmiHash.combine(hash, occurrences.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 39 matching lines @@
   void set outline(List<Outline> value) {
     assert(value != null);
     this._outline = value;
   }
 
   AnalysisOutlineParams(String file, List<Outline> outline) {
     this.file = file;
     this.outline = outline;
   }
 
-  factory AnalysisOutlineParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisOutlineParams.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       List<Outline> outline;
       if (json.containsKey("outline")) {
-        outline = jsonDecoder.decodeList(jsonPath + ".outline", json["outline"], (String jsonPath, Object json) => new Outline.fromJson(jsonDecoder, jsonPath, json));
+        outline = jsonDecoder.decodeList(
+            jsonPath + ".outline",
+            json["outline"],
+            (String jsonPath, Object json) =>
+                new Outline.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "outline");
       }
       return new AnalysisOutlineParams(file, outline);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.outline params", json);
     }
   }
 
   factory AnalysisOutlineParams.fromNotification(Notification notification) {
@@ skipping 10 matching lines @@
   }
 
   Notification toNotification() {
     return new Notification("analysis.outline", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisOutlineParams) {
       return file == other.file &&
           listEqual(outline, other.outline, (Outline a, Outline b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
@@ skipping 30 matching lines @@
    * re-analyzed.
    */
   void set roots(List<String> value) {
     this._roots = value;
   }
 
   AnalysisReanalyzeParams({List<String> roots}) {
     this.roots = roots;
   }
 
-  factory AnalysisReanalyzeParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisReanalyzeParams.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> roots;
       if (json.containsKey("roots")) {
-        roots = jsonDecoder.decodeList(jsonPath + ".roots", json["roots"], jsonDecoder.decodeString);
+        roots = jsonDecoder.decodeList(
+            jsonPath + ".roots", json["roots"], jsonDecoder.decodeString);
       }
       return new AnalysisReanalyzeParams(roots: roots);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.reanalyze params", json);
     }
   }
 
   factory AnalysisReanalyzeParams.fromRequest(Request request) {
     return new AnalysisReanalyzeParams.fromJson(
         new RequestDecoder(request), "params", request.params);
@@ skipping 10 matching lines @@
 
   @override
   Request toRequest(String id) {
     return new Request(id, "analysis.reanalyze", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisReanalyzeParams) {
       return listEqual(roots, other.roots, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, roots.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.reanalyze result
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class AnalysisReanalyzeResult implements ResponseResult {
   @override
   Map<String, dynamic> toJson() => <String, dynamic>{};
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisReanalyzeResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 846803925;
   }
 }
 
 /**
  * AnalysisService
  *
  * enum {
  *   FOLDING
  *   HIGHLIGHTS
  *   NAVIGATION
  *   OCCURRENCES
  *   OUTLINE
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class AnalysisService implements Enum {
   static const AnalysisService FOLDING = const AnalysisService._("FOLDING");
 
-  static const AnalysisService HIGHLIGHTS = const AnalysisService._("HIGHLIGHTS");
+  static const AnalysisService HIGHLIGHTS =
+      const AnalysisService._("HIGHLIGHTS");
 
-  static const AnalysisService NAVIGATION = const AnalysisService._("NAVIGATION");
+  static const AnalysisService NAVIGATION =
+      const AnalysisService._("NAVIGATION");
 
-  static const AnalysisService OCCURRENCES = const AnalysisService._("OCCURRENCES");
+  static const AnalysisService OCCURRENCES =
+      const AnalysisService._("OCCURRENCES");
 
   static const AnalysisService OUTLINE = const AnalysisService._("OUTLINE");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<AnalysisService> VALUES = const <AnalysisService>[FOLDING, HIGHLIGHTS, NAVIGATION, OCCURRENCES, OUTLINE];
+  static const List<AnalysisService> VALUES = const <AnalysisService>[
+    FOLDING,
+    HIGHLIGHTS,
+    NAVIGATION,
+    OCCURRENCES,
+    OUTLINE
+  ];
 
   @override
   final String name;
 
   const AnalysisService._(this.name);
 
   factory AnalysisService(String name) {
     switch (name) {
       case "FOLDING":
         return FOLDING;
       case "HIGHLIGHTS":
         return HIGHLIGHTS;
       case "NAVIGATION":
         return NAVIGATION;
       case "OCCURRENCES":
         return OCCURRENCES;
       case "OUTLINE":
         return OUTLINE;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory AnalysisService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisService.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new AnalysisService(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "AnalysisService", json);
   }
 
   @override
   String toString() => "AnalysisService.$name";
 
   String toJson() => name;
@@ skipping 21 matching lines @@
    */
   void set options(ContextBuilderOptions value) {
     assert(value != null);
     this._options = value;
   }
 
   AnalysisSetContextBuilderOptionsParams(ContextBuilderOptions options) {
     this.options = options;
   }
 
-  factory AnalysisSetContextBuilderOptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisSetContextBuilderOptionsParams.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       ContextBuilderOptions options;
       if (json.containsKey("options")) {
-        options = new ContextBuilderOptions.fromJson(jsonDecoder, jsonPath + ".options", json["options"]);
+        options = new ContextBuilderOptions.fromJson(
+            jsonDecoder, jsonPath + ".options", json["options"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "options");
       }
       return new AnalysisSetContextBuilderOptionsParams(options);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.setContextBuilderOptions params", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "analysis.setContextBuilderOptions params", json);
     }
   }
 
   factory AnalysisSetContextBuilderOptionsParams.fromRequest(Request request) {
     return new AnalysisSetContextBuilderOptionsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["options"] = options.toJson();
     return result;
   }
 
   @override
   Request toRequest(String id) {
     return new Request(id, "analysis.setContextBuilderOptions", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisSetContextBuilderOptionsParams) {
       return options == other.options;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, options.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.setContextBuilderOptions result
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class AnalysisSetContextBuilderOptionsResult implements ResponseResult {
   @override
   Map<String, dynamic> toJson() => <String, dynamic>{};
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisSetContextBuilderOptionsResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 645412314;
   }
@@ skipping 21 matching lines @@
    */
   void set roots(List<ContextRoot> value) {
     assert(value != null);
     this._roots = value;
   }
 
   AnalysisSetContextRootsParams(List<ContextRoot> roots) {
     this.roots = roots;
   }
 
-  factory AnalysisSetContextRootsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisSetContextRootsParams.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<ContextRoot> roots;
       if (json.containsKey("roots")) {
-        roots = jsonDecoder.decodeList(jsonPath + ".roots", json["roots"], (String jsonPath, Object json) => new ContextRoot.fromJson(jsonDecoder, jsonPath, json));
+        roots = jsonDecoder.decodeList(
+            jsonPath + ".roots",
+            json["roots"],
+            (String jsonPath, Object json) =>
+                new ContextRoot.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "roots");
       }
       return new AnalysisSetContextRootsParams(roots);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.setContextRoots params", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "analysis.setContextRoots params", json);
     }
   }
 
   factory AnalysisSetContextRootsParams.fromRequest(Request request) {
     return new AnalysisSetContextRootsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["roots"] = roots.map((ContextRoot value) => value.toJson()).toList();
     return result;
   }
 
   @override
   Request toRequest(String id) {
     return new Request(id, "analysis.setContextRoots", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisSetContextRootsParams) {
-      return listEqual(roots, other.roots, (ContextRoot a, ContextRoot b) => a == b);
+      return listEqual(
+          roots, other.roots, (ContextRoot a, ContextRoot b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, roots.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.setContextRoots result
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class AnalysisSetContextRootsResult implements ResponseResult {
   @override
   Map<String, dynamic> toJson() => <String, dynamic>{};
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisSetContextRootsResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 969645618;
   }
@@ skipping 21 matching lines @@
    */
   void set files(List<String> value) {
     assert(value != null);
     this._files = value;
   }
 
   AnalysisSetPriorityFilesParams(List<String> files) {
     this.files = files;
   }
 
-  factory AnalysisSetPriorityFilesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisSetPriorityFilesParams.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> files;
       if (json.containsKey("files")) {
-        files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonDecoder.decodeString);
+        files = jsonDecoder.decodeList(
+            jsonPath + ".files", json["files"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "files");
       }
       return new AnalysisSetPriorityFilesParams(files);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.setPriorityFiles params", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "analysis.setPriorityFiles params", json);
     }
   }
 
   factory AnalysisSetPriorityFilesParams.fromRequest(Request request) {
     return new AnalysisSetPriorityFilesParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["files"] = files;
     return result;
   }
 
   @override
   Request toRequest(String id) {
     return new Request(id, "analysis.setPriorityFiles", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisSetPriorityFilesParams) {
       return listEqual(files, other.files, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, files.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.setPriorityFiles result
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class AnalysisSetPriorityFilesResult implements ResponseResult {
   @override
   Map<String, dynamic> toJson() => <String, dynamic>{};
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisSetPriorityFilesResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 330050055;
   }
@@ skipping 19 matching lines @@
 
   /**
    * A table mapping services to a list of the files being subscribed to the
    * service.
    */
   void set subscriptions(Map<AnalysisService, List<String>> value) {
     assert(value != null);
     this._subscriptions = value;
   }
 
-  AnalysisSetSubscriptionsParams(Map<AnalysisService, List<String>> subscriptions) {
+  AnalysisSetSubscriptionsParams(
+      Map<AnalysisService, List<String>> subscriptions) {
     this.subscriptions = subscriptions;
   }
 
-  factory AnalysisSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisSetSubscriptionsParams.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       Map<AnalysisService, List<String>> subscriptions;
       if (json.containsKey("subscriptions")) {
-        subscriptions = jsonDecoder.decodeMap(jsonPath + ".subscriptions", json["subscriptions"], keyDecoder: (String jsonPath, Object json) => new AnalysisService.fromJson(jsonDecoder, jsonPath, json), valueDecoder: (String jsonPath, Object json) => jsonDecoder.decodeList(jsonPath, json, jsonDecoder.decodeString));
+        subscriptions = jsonDecoder.decodeMap(
+            jsonPath + ".subscriptions", json["subscriptions"],
+            keyDecoder: (String jsonPath, Object json) =>
+                new AnalysisService.fromJson(jsonDecoder, jsonPath, json),
+            valueDecoder: (String jsonPath, Object json) => jsonDecoder
+                .decodeList(jsonPath, json, jsonDecoder.decodeString));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "subscriptions");
       }
       return new AnalysisSetSubscriptionsParams(subscriptions);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.setSubscriptions params", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "analysis.setSubscriptions params", json);
     }
   }
 
   factory AnalysisSetSubscriptionsParams.fromRequest(Request request) {
     return new AnalysisSetSubscriptionsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["subscriptions"] = mapMap(subscriptions, keyCallback: (AnalysisService value) => value.toJson());
+    result["subscriptions"] = mapMap(subscriptions,
+        keyCallback: (AnalysisService value) => value.toJson());
     return result;
   }
 
   @override
   Request toRequest(String id) {
     return new Request(id, "analysis.setSubscriptions", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisSetSubscriptionsParams) {
-      return mapEqual(subscriptions, other.subscriptions, (List<String> a, List<String> b) => listEqual(a, b, (String a, String b) => a == b));
+      return mapEqual(
+          subscriptions,
+          other.subscriptions,
+          (List<String> a, List<String> b) =>
+              listEqual(a, b, (String a, String b) => a == b));
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, subscriptions.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.setSubscriptions result
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class AnalysisSetSubscriptionsResult implements ResponseResult {
   @override
   Map<String, dynamic> toJson() => <String, dynamic>{};
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisSetSubscriptionsResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 218088493;
   }
@@ skipping 23 matching lines @@
    */
   void set files(Map<String, dynamic> value) {
     assert(value != null);
     this._files = value;
   }
 
   AnalysisUpdateContentParams(Map<String, dynamic> files) {
     this.files = files;
   }
 
-  factory AnalysisUpdateContentParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory AnalysisUpdateContentParams.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       Map<String, dynamic> files;
       if (json.containsKey("files")) {
-        files = jsonDecoder.decodeMap(jsonPath + ".files", json["files"], valueDecoder: (String jsonPath, Object json) => jsonDecoder.decodeUnion(jsonPath, json, "type", {"add": (String jsonPath, Object json) => new AddContentOverlay.fromJson(jsonDecoder, jsonPath, json), "change": (String jsonPath, Object json) => new ChangeContentOverlay.fromJson(jsonDecoder, jsonPath, json), "remove": (String jsonPath, Object json) => new RemoveContentOverlay.fromJson(jsonDecoder, jsonPath, json)}));
+        files = jsonDecoder.decodeMap(jsonPath + ".files", json["files"],
+            valueDecoder: (String jsonPath, Object json) =>
+                jsonDecoder.decodeUnion(jsonPath, json, "type", {
+                  "add": (String jsonPath, Object json) =>
+                      new AddContentOverlay.fromJson(
+                          jsonDecoder, jsonPath, json),
+                  "change": (String jsonPath, Object json) =>
+                      new ChangeContentOverlay.fromJson(
+                          jsonDecoder, jsonPath, json),
+                  "remove": (String jsonPath, Object json) =>
+                      new RemoveContentOverlay.fromJson(
+                          jsonDecoder, jsonPath, json)
+                }));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "files");
       }
       return new AnalysisUpdateContentParams(files);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent params", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "analysis.updateContent params", json);
     }
   }
 
   factory AnalysisUpdateContentParams.fromRequest(Request request) {
     return new AnalysisUpdateContentParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["files"] = mapMap(files, valueCallback: (dynamic value) => value.toJson());
+    result["files"] =
+        mapMap(files, valueCallback: (dynamic value) => value.toJson());
     return result;
   }
 
   @override
   Request toRequest(String id) {
     return new Request(id, "analysis.updateContent", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisUpdateContentParams) {
       return mapEqual(files, other.files, (dynamic a, dynamic b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, files.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.updateContent result
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class AnalysisUpdateContentResult implements ResponseResult {
   @override
   Map<String, dynamic> toJson() => <String, dynamic>{};
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is AnalysisUpdateContentResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 468798730;
   }
@@ skipping 22 matching lines @@
    */
   void set edits(List<SourceEdit> value) {
     assert(value != null);
     this._edits = value;
   }
 
   ChangeContentOverlay(List<SourceEdit> edits) {
     this.edits = edits;
   }
 
-  factory ChangeContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ChangeContentOverlay.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       if (json["type"] != "change") {
         throw jsonDecoder.mismatch(jsonPath, "equal " + "change", json);
       }
       List<SourceEdit> edits;
       if (json.containsKey("edits")) {
-        edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
+        edits = jsonDecoder.decodeList(
+            jsonPath + ".edits",
+            json["edits"],
+            (String jsonPath, Object json) =>
+                new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "edits");
       }
       return new ChangeContentOverlay(edits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "ChangeContentOverlay", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["type"] = "change";
     result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ChangeContentOverlay) {
-      return listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b);
+      return listEqual(
+          edits, other.edits, (SourceEdit a, SourceEdit b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, 873118866);
     hash = JenkinsSmiHash.combine(hash, edits.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 39 matching lines @@
   void set offset(int value) {
     assert(value != null);
     this._offset = value;
   }
 
   CompletionGetSuggestionsParams(String file, int offset) {
     this.file = file;
     this.offset = offset;
   }
 
-  factory CompletionGetSuggestionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory CompletionGetSuggestionsParams.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       return new CompletionGetSuggestionsParams(file, offset);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions params", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "completion.getSuggestions params", json);
     }
   }
 
   factory CompletionGetSuggestionsParams.fromRequest(Request request) {
     return new CompletionGetSuggestionsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
   @override
   Request toRequest(String id) {
     return new Request(id, "completion.getSuggestions", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is CompletionGetSuggestionsParams) {
-      return file == other.file &&
-          offset == other.offset;
+      return file == other.file && offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, file.hashCode);
     hash = JenkinsSmiHash.combine(hash, offset.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 68 matching lines @@
    * possible completions at the requested cursor position, even those that do
    * not match the characters the user has already typed. This allows the
    * client to respond to further keystrokes from the user without having to
    * make additional requests.
    */
   void set results(List<CompletionSuggestion> value) {
     assert(value != null);
     this._results = value;
   }
 
-  CompletionGetSuggestionsResult(int replacementOffset, int replacementLength, List<CompletionSuggestion> results) {
+  CompletionGetSuggestionsResult(int replacementOffset, int replacementLength,
+      List<CompletionSuggestion> results) {
     this.replacementOffset = replacementOffset;
     this.replacementLength = replacementLength;
     this.results = results;
   }
 
-  factory CompletionGetSuggestionsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory CompletionGetSuggestionsResult.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int replacementOffset;
       if (json.containsKey("replacementOffset")) {
-        replacementOffset = jsonDecoder.decodeInt(jsonPath + ".replacementOffset", json["replacementOffset"]);
+        replacementOffset = jsonDecoder.decodeInt(
+            jsonPath + ".replacementOffset", json["replacementOffset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "replacementOffset");
       }
       int replacementLength;
       if (json.containsKey("replacementLength")) {
-        replacementLength = jsonDecoder.decodeInt(jsonPath + ".replacementLength", json["replacementLength"]);
+        replacementLength = jsonDecoder.decodeInt(
+            jsonPath + ".replacementLength", json["replacementLength"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "replacementLength");
       }
       List<CompletionSuggestion> results;
       if (json.containsKey("results")) {
-        results = jsonDecoder.decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new CompletionSuggestion.fromJson(jsonDecoder, jsonPath, json));
+        results = jsonDecoder.decodeList(
+            jsonPath + ".results",
+            json["results"],
+            (String jsonPath, Object json) =>
+                new CompletionSuggestion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "results");
       }
-      return new CompletionGetSuggestionsResult(replacementOffset, replacementLength, results);
+      return new CompletionGetSuggestionsResult(
+          replacementOffset, replacementLength, results);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions result", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "completion.getSuggestions result", json);
     }
   }
 
   factory CompletionGetSuggestionsResult.fromResponse(Response response) {
     return new CompletionGetSuggestionsResult.fromJson(
-        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response.result);
+        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)),
+        "result",
+        response.result);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["replacementOffset"] = replacementOffset;
     result["replacementLength"] = replacementLength;
-    result["results"] = results.map((CompletionSuggestion value) => value.toJson()).toList();
+    result["results"] =
+        results.map((CompletionSuggestion value) => value.toJson()).toList();
     return result;
   }
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is CompletionGetSuggestionsResult) {
       return replacementOffset == other.replacementOffset &&
           replacementLength == other.replacementLength &&
-          listEqual(results, other.results, (CompletionSuggestion a, CompletionSuggestion b) => a == b);
+          listEqual(results, other.results,
+              (CompletionSuggestion a, CompletionSuggestion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, replacementOffset.hashCode);
     hash = JenkinsSmiHash.combine(hash, replacementLength.hashCode);
     hash = JenkinsSmiHash.combine(hash, results.hashCode);
@@ skipping 379 matching lines @@
   String get importUri => _importUri;
 
   /**
    * The import to be added if the suggestion is out of scope and needs an
    * import to be added to be in scope.
    */
   void set importUri(String value) {
     this._importUri = value;
   }
 
-  CompletionSuggestion(CompletionSuggestionKind kind, int relevance, String completion, int selectionOffset, int selectionLength, bool isDeprecated, bool isPotential, {String docSummary, String docComplete, String declaringType, String defaultArgumentListString, List<int> defaultArgumentListTextRanges, Element element, String returnType, List<String> parameterNames, List<String> parameterTypes, int requiredParameterCount, bool hasNamedParameters, String parameterName, String parameterType, String importUri}) {
+  CompletionSuggestion(
+      CompletionSuggestionKind kind,
+      int relevance,
+      String completion,
+      int selectionOffset,
+      int selectionLength,
+      bool isDeprecated,
+      bool isPotential,
+      {String docSummary,
+      String docComplete,
+      String declaringType,
+      String defaultArgumentListString,
+      List<int> defaultArgumentListTextRanges,
+      Element element,
+      String returnType,
+      List<String> parameterNames,
+      List<String> parameterTypes,
+      int requiredParameterCount,
+      bool hasNamedParameters,
+      String parameterName,
+      String parameterType,
+      String importUri}) {
     this.kind = kind;
     this.relevance = relevance;
     this.completion = completion;
     this.selectionOffset = selectionOffset;
     this.selectionLength = selectionLength;
     this.isDeprecated = isDeprecated;
     this.isPotential = isPotential;
     this.docSummary = docSummary;
     this.docComplete = docComplete;
     this.declaringType = declaringType;
     this.defaultArgumentListString = defaultArgumentListString;
     this.defaultArgumentListTextRanges = defaultArgumentListTextRanges;
     this.element = element;
     this.returnType = returnType;
     this.parameterNames = parameterNames;
     this.parameterTypes = parameterTypes;
     this.requiredParameterCount = requiredParameterCount;
     this.hasNamedParameters = hasNamedParameters;
     this.parameterName = parameterName;
     this.parameterType = parameterType;
     this.importUri = importUri;
   }
 
-  factory CompletionSuggestion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory CompletionSuggestion.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       CompletionSuggestionKind kind;
       if (json.containsKey("kind")) {
-        kind = new CompletionSuggestionKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
+        kind = new CompletionSuggestionKind.fromJson(
+            jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "kind");
       }
       int relevance;
       if (json.containsKey("relevance")) {
-        relevance = jsonDecoder.decodeInt(jsonPath + ".relevance", json["relevance"]);
+        relevance =
+            jsonDecoder.decodeInt(jsonPath + ".relevance", json["relevance"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "relevance");
       }
       String completion;
       if (json.containsKey("completion")) {
-        completion = jsonDecoder.decodeString(jsonPath + ".completion", json["completion"]);
+        completion = jsonDecoder.decodeString(
+            jsonPath + ".completion", json["completion"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "completion");
       }
       int selectionOffset;
       if (json.containsKey("selectionOffset")) {
-        selectionOffset = jsonDecoder.decodeInt(jsonPath + ".selectionOffset", json["selectionOffset"]);
+        selectionOffset = jsonDecoder.decodeInt(
+            jsonPath + ".selectionOffset", json["selectionOffset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "selectionOffset");
       }
       int selectionLength;
       if (json.containsKey("selectionLength")) {
-        selectionLength = jsonDecoder.decodeInt(jsonPath + ".selectionLength", json["selectionLength"]);
+        selectionLength = jsonDecoder.decodeInt(
+            jsonPath + ".selectionLength", json["selectionLength"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "selectionLength");
       }
       bool isDeprecated;
       if (json.containsKey("isDeprecated")) {
-        isDeprecated = jsonDecoder.decodeBool(jsonPath + ".isDeprecated", json["isDeprecated"]);
+        isDeprecated = jsonDecoder.decodeBool(
+            jsonPath + ".isDeprecated", json["isDeprecated"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "isDeprecated");
       }
       bool isPotential;
       if (json.containsKey("isPotential")) {
-        isPotential = jsonDecoder.decodeBool(jsonPath + ".isPotential", json["isPotential"]);
+        isPotential = jsonDecoder.decodeBool(
+            jsonPath + ".isPotential", json["isPotential"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "isPotential");
       }
       String docSummary;
       if (json.containsKey("docSummary")) {
-        docSummary = jsonDecoder.decodeString(jsonPath + ".docSummary", json["docSummary"]);
+        docSummary = jsonDecoder.decodeString(
+            jsonPath + ".docSummary", json["docSummary"]);
       }
       String docComplete;
       if (json.containsKey("docComplete")) {
-        docComplete = jsonDecoder.decodeString(jsonPath + ".docComplete", json["docComplete"]);
+        docComplete = jsonDecoder.decodeString(
+            jsonPath + ".docComplete", json["docComplete"]);
       }
       String declaringType;
       if (json.containsKey("declaringType")) {
-        declaringType = jsonDecoder.decodeString(jsonPath + ".declaringType", json["declaringType"]);
+        declaringType = jsonDecoder.decodeString(
+            jsonPath + ".declaringType", json["declaringType"]);
       }
       String defaultArgumentListString;
       if (json.containsKey("defaultArgumentListString")) {
-        defaultArgumentListString = jsonDecoder.decodeString(jsonPath + ".defaultArgumentListString", json["defaultArgumentListString"]);
+        defaultArgumentListString = jsonDecoder.decodeString(
+            jsonPath + ".defaultArgumentListString",
+            json["defaultArgumentListString"]);
       }
       List<int> defaultArgumentListTextRanges;
       if (json.containsKey("defaultArgumentListTextRanges")) {
-        defaultArgumentListTextRanges = jsonDecoder.decodeList(jsonPath + ".defaultArgumentListTextRanges", json["defaultArgumentListTextRanges"], jsonDecoder.decodeInt);
+        defaultArgumentListTextRanges = jsonDecoder.decodeList(
+            jsonPath + ".defaultArgumentListTextRanges",
+            json["defaultArgumentListTextRanges"],
+            jsonDecoder.decodeInt);
       }
       Element element;
       if (json.containsKey("element")) {
-        element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
+        element = new Element.fromJson(
+            jsonDecoder, jsonPath + ".element", json["element"]);
       }
       String returnType;
       if (json.containsKey("returnType")) {
-        returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["returnType"]);
+        returnType = jsonDecoder.decodeString(
+            jsonPath + ".returnType", json["returnType"]);
       }
       List<String> parameterNames;
       if (json.containsKey("parameterNames")) {
-        parameterNames = jsonDecoder.decodeList(jsonPath + ".parameterNames", json["parameterNames"], jsonDecoder.decodeString);
+        parameterNames = jsonDecoder.decodeList(jsonPath + ".parameterNames",
+            json["parameterNames"], jsonDecoder.decodeString);
       }
       List<String> parameterTypes;
       if (json.containsKey("parameterTypes")) {
-        parameterTypes = jsonDecoder.decodeList(jsonPath + ".parameterTypes", json["parameterTypes"], jsonDecoder.decodeString);
+        parameterTypes = jsonDecoder.decodeList(jsonPath + ".parameterTypes",
+            json["parameterTypes"], jsonDecoder.decodeString);
       }
       int requiredParameterCount;
       if (json.containsKey("requiredParameterCount")) {
-        requiredParameterCount = jsonDecoder.decodeInt(jsonPath + ".requiredParameterCount", json["requiredParameterCount"]);
+        requiredParameterCount = jsonDecoder.decodeInt(
+            jsonPath + ".requiredParameterCount",
+            json["requiredParameterCount"]);
       }
       bool hasNamedParameters;
       if (json.containsKey("hasNamedParameters")) {
-        hasNamedParameters = jsonDecoder.decodeBool(jsonPath + ".hasNamedParameters", json["hasNamedParameters"]);
+        hasNamedParameters = jsonDecoder.decodeBool(
+            jsonPath + ".hasNamedParameters", json["hasNamedParameters"]);
       }
       String parameterName;
       if (json.containsKey("parameterName")) {
-        parameterName = jsonDecoder.decodeString(jsonPath + ".parameterName", json["parameterName"]);
+        parameterName = jsonDecoder.decodeString(
+            jsonPath + ".parameterName", json["parameterName"]);
       }
       String parameterType;
       if (json.containsKey("parameterType")) {
-        parameterType = jsonDecoder.decodeString(jsonPath + ".parameterType", json["parameterType"]);
+        parameterType = jsonDecoder.decodeString(
+            jsonPath + ".parameterType", json["parameterType"]);
       }
       String importUri;
       if (json.containsKey("importUri")) {
-        importUri = jsonDecoder.decodeString(jsonPath + ".importUri", json["importUri"]);
+        importUri = jsonDecoder.decodeString(
+            jsonPath + ".importUri", json["importUri"]);
       }
-      return new CompletionSuggestion(kind, relevance, completion, selectionOffset, selectionLength, isDeprecated, isPotential, docSummary: docSummary, docComplete: docComplete, declaringType: declaringType, defaultArgumentListString: defaultArgumentListString, defaultArgumentListTextRanges: defaultArgumentListTextRanges, element: element, returnType: returnType, parameterNames: parameterNames, parameterTypes: parameterTypes, requiredParameterCount: requiredParameterCount, hasNamedParameters: hasNamedParameters, parameterName: parameterName, parameterType: parameterType, importUri: importUri);
+      return new CompletionSuggestion(kind, relevance, completion,
+          selectionOffset, selectionLength, isDeprecated, isPotential,
+          docSummary: docSummary,
+          docComplete: docComplete,
+          declaringType: declaringType,
+          defaultArgumentListString: defaultArgumentListString,
+          defaultArgumentListTextRanges: defaultArgumentListTextRanges,
+          element: element,
+          returnType: returnType,
+          parameterNames: parameterNames,
+          parameterTypes: parameterTypes,
+          requiredParameterCount: requiredParameterCount,
+          hasNamedParameters: hasNamedParameters,
+          parameterName: parameterName,
+          parameterType: parameterType,
+          importUri: importUri);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestion", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["kind"] = kind.toJson();
     result["relevance"] = relevance;
@@ skipping 44 matching lines @@
     if (importUri != null) {
       result["importUri"] = importUri;
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is CompletionSuggestion) {
       return kind == other.kind &&
           relevance == other.relevance &&
           completion == other.completion &&
           selectionOffset == other.selectionOffset &&
           selectionLength == other.selectionLength &&
           isDeprecated == other.isDeprecated &&
           isPotential == other.isPotential &&
           docSummary == other.docSummary &&
           docComplete == other.docComplete &&
           declaringType == other.declaringType &&
           defaultArgumentListString == other.defaultArgumentListString &&
-          listEqual(defaultArgumentListTextRanges, other.defaultArgumentListTextRanges, (int a, int b) => a == b) &&
+          listEqual(defaultArgumentListTextRanges,
+              other.defaultArgumentListTextRanges, (int a, int b) => a == b) &&
           element == other.element &&
           returnType == other.returnType &&
-          listEqual(parameterNames, other.parameterNames, (String a, String b) => a == b) &&
-          listEqual(parameterTypes, other.parameterTypes, (String a, String b) => a == b) &&
+          listEqual(parameterNames, other.parameterNames,
+              (String a, String b) => a == b) &&
+          listEqual(parameterTypes, other.parameterTypes,
+              (String a, String b) => a == b) &&
           requiredParameterCount == other.requiredParameterCount &&
           hasNamedParameters == other.hasNamedParameters &&
           parameterName == other.parameterName &&
           parameterType == other.parameterType &&
           importUri == other.importUri;
     }
     return false;
   }
 
   @override
@@ skipping 40 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class CompletionSuggestionKind implements Enum {
   /**
    * A list of arguments for the method or function that is being invoked. For
    * this suggestion kind, the completion field is a textual representation of
    * the invocation and the parameterNames, parameterTypes, and
    * requiredParameterCount attributes are defined.
    */
-  static const CompletionSuggestionKind ARGUMENT_LIST = const CompletionSuggestionKind._("ARGUMENT_LIST");
+  static const CompletionSuggestionKind ARGUMENT_LIST =
+      const CompletionSuggestionKind._("ARGUMENT_LIST");
 
-  static const CompletionSuggestionKind IMPORT = const CompletionSuggestionKind._("IMPORT");
+  static const CompletionSuggestionKind IMPORT =
+      const CompletionSuggestionKind._("IMPORT");
 
   /**
    * The element identifier should be inserted at the completion location. For
    * example "someMethod" in import 'myLib.dart' show someMethod;. For
    * suggestions of this kind, the element attribute is defined and the
    * completion field is the element's identifier.
    */
-  static const CompletionSuggestionKind IDENTIFIER = const CompletionSuggestionKind._("IDENTIFIER");
+  static const CompletionSuggestionKind IDENTIFIER =
+      const CompletionSuggestionKind._("IDENTIFIER");
 
   /**
    * The element is being invoked at the completion location. For example,
    * 'someMethod' in x.someMethod();. For suggestions of this kind, the element
    * attribute is defined and the completion field is the element's identifier.
    */
-  static const CompletionSuggestionKind INVOCATION = const CompletionSuggestionKind._("INVOCATION");
+  static const CompletionSuggestionKind INVOCATION =
+      const CompletionSuggestionKind._("INVOCATION");
 
   /**
    * A keyword is being suggested. For suggestions of this kind, the completion
    * is the keyword.
    */
-  static const CompletionSuggestionKind KEYWORD = const CompletionSuggestionKind._("KEYWORD");
+  static const CompletionSuggestionKind KEYWORD =
+      const CompletionSuggestionKind._("KEYWORD");
 
   /**
    * A named argument for the current call site is being suggested. For
    * suggestions of this kind, the completion is the named argument identifier
    * including a trailing ':' and a space.
    */
-  static const CompletionSuggestionKind NAMED_ARGUMENT = const CompletionSuggestionKind._("NAMED_ARGUMENT");
+  static const CompletionSuggestionKind NAMED_ARGUMENT =
+      const CompletionSuggestionKind._("NAMED_ARGUMENT");
 
-  static const CompletionSuggestionKind OPTIONAL_ARGUMENT = const CompletionSuggestionKind._("OPTIONAL_ARGUMENT");
+  static const CompletionSuggestionKind OPTIONAL_ARGUMENT =
+      const CompletionSuggestionKind._("OPTIONAL_ARGUMENT");
 
-  static const CompletionSuggestionKind PARAMETER = const CompletionSuggestionKind._("PARAMETER");
+  static const CompletionSuggestionKind PARAMETER =
+      const CompletionSuggestionKind._("PARAMETER");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<CompletionSuggestionKind> VALUES = const <CompletionSuggestionKind>[ARGUMENT_LIST, IMPORT, IDENTIFIER, INVOCATION, KEYWORD, NAMED_ARGUMENT, OPTIONAL_ARGUMENT, PARAMETER];
+  static const List<CompletionSuggestionKind> VALUES =
+      const <CompletionSuggestionKind>[
+    ARGUMENT_LIST,
+    IMPORT,
+    IDENTIFIER,
+    INVOCATION,
+    KEYWORD,
+    NAMED_ARGUMENT,
+    OPTIONAL_ARGUMENT,
+    PARAMETER
+  ];
 
   @override
   final String name;
 
   const CompletionSuggestionKind._(this.name);
 
   factory CompletionSuggestionKind(String name) {
     switch (name) {
       case "ARGUMENT_LIST":
         return ARGUMENT_LIST;
       case "IMPORT":
         return IMPORT;
       case "IDENTIFIER":
         return IDENTIFIER;
       case "INVOCATION":
         return INVOCATION;
       case "KEYWORD":
         return KEYWORD;
       case "NAMED_ARGUMENT":
         return NAMED_ARGUMENT;
       case "OPTIONAL_ARGUMENT":
         return OPTIONAL_ARGUMENT;
       case "PARAMETER":
         return PARAMETER;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory CompletionSuggestionKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory CompletionSuggestionKind.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new CompletionSuggestionKind(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestionKind", json);
   }
 
   @override
   String toString() => "CompletionSuggestionKind.$name";
 
   String toJson() => name;
@@ skipping 37 matching lines @@
    */
   void set dartSdkSummaryPath(String value) {
     this._dartSdkSummaryPath = value;
   }
 
   /**
    * The file path of the analysis options file that should be used in place of
    * any file in the root directory or a parent of the root directory. The
    * field will be omitted if the normal lookup mechanism should be used.
    */
-  List<String> get defaultAnalysisOptionsFilePath => _defaultAnalysisOptionsFilePath;
+  List<String> get defaultAnalysisOptionsFilePath =>
+      _defaultAnalysisOptionsFilePath;
 
   /**
    * The file path of the analysis options file that should be used in place of
    * any file in the root directory or a parent of the root directory. The
    * field will be omitted if the normal lookup mechanism should be used.
    */
   void set defaultAnalysisOptionsFilePath(List<String> value) {
     this._defaultAnalysisOptionsFilePath = value;
   }
 
@@ skipping 26 matching lines @@
   void set defaultPackageFilePath(List<String> value) {
     this._defaultPackageFilePath = value;
   }
 
   /**
    * The file path of the packages directory that should be used in place of
    * any file found using the normal (Package Specification DEP) lookup
    * mechanism. The field will be omitted if the normal lookup mechanism should
    * be used.
    */
-  List<String> get defaultPackagesDirectoryPath => _defaultPackagesDirectoryPath;
+  List<String> get defaultPackagesDirectoryPath =>
+      _defaultPackagesDirectoryPath;
 
   /**
    * The file path of the packages directory that should be used in place of
    * any file found using the normal (Package Specification DEP) lookup
    * mechanism. The field will be omitted if the normal lookup mechanism should
    * be used.
    */
   void set defaultPackagesDirectoryPath(List<String> value) {
     this._defaultPackagesDirectoryPath = value;
   }
 
-  ContextBuilderOptions({String dartSdkSummaryPath, List<String> defaultAnalysisOptionsFilePath, Map<String, String> declaredVariables, List<String> defaultPackageFilePath, List<String> defaultPackagesDirectoryPath}) {
+  ContextBuilderOptions(
+      {String dartSdkSummaryPath,
+      List<String> defaultAnalysisOptionsFilePath,
+      Map<String, String> declaredVariables,
+      List<String> defaultPackageFilePath,
+      List<String> defaultPackagesDirectoryPath}) {
     this.dartSdkSummaryPath = dartSdkSummaryPath;
     this.defaultAnalysisOptionsFilePath = defaultAnalysisOptionsFilePath;
     this.declaredVariables = declaredVariables;
     this.defaultPackageFilePath = defaultPackageFilePath;
     this.defaultPackagesDirectoryPath = defaultPackagesDirectoryPath;
   }
 
-  factory ContextBuilderOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ContextBuilderOptions.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String dartSdkSummaryPath;
       if (json.containsKey("dartSdkSummaryPath")) {
-        dartSdkSummaryPath = jsonDecoder.decodeString(jsonPath + ".dartSdkSummaryPath", json["dartSdkSummaryPath"]);
+        dartSdkSummaryPath = jsonDecoder.decodeString(
+            jsonPath + ".dartSdkSummaryPath", json["dartSdkSummaryPath"]);
       }
       List<String> defaultAnalysisOptionsFilePath;
       if (json.containsKey("defaultAnalysisOptionsFilePath")) {
-        defaultAnalysisOptionsFilePath = jsonDecoder.decodeList(jsonPath + ".defaultAnalysisOptionsFilePath", json["defaultAnalysisOptionsFilePath"], jsonDecoder.decodeString);
+        defaultAnalysisOptionsFilePath = jsonDecoder.decodeList(
+            jsonPath + ".defaultAnalysisOptionsFilePath",
+            json["defaultAnalysisOptionsFilePath"],
+            jsonDecoder.decodeString);
       }
       Map<String, String> declaredVariables;
       if (json.containsKey("declaredVariables")) {
-        declaredVariables = jsonDecoder.decodeMap(jsonPath + ".declaredVariables", json["declaredVariables"], valueDecoder: jsonDecoder.decodeString);
+        declaredVariables = jsonDecoder.decodeMap(
+            jsonPath + ".declaredVariables", json["declaredVariables"],
+            valueDecoder: jsonDecoder.decodeString);
       }
       List<String> defaultPackageFilePath;
       if (json.containsKey("defaultPackageFilePath")) {
-        defaultPackageFilePath = jsonDecoder.decodeList(jsonPath + ".defaultPackageFilePath", json["defaultPackageFilePath"], jsonDecoder.decodeString);
+        defaultPackageFilePath = jsonDecoder.decodeList(
+            jsonPath + ".defaultPackageFilePath",
+            json["defaultPackageFilePath"],
+            jsonDecoder.decodeString);
       }
       List<String> defaultPackagesDirectoryPath;
       if (json.containsKey("defaultPackagesDirectoryPath")) {
-        defaultPackagesDirectoryPath = jsonDecoder.decodeList(jsonPath + ".defaultPackagesDirectoryPath", json["defaultPackagesDirectoryPath"], jsonDecoder.decodeString);
+        defaultPackagesDirectoryPath = jsonDecoder.decodeList(
+            jsonPath + ".defaultPackagesDirectoryPath",
+            json["defaultPackagesDirectoryPath"],
+            jsonDecoder.decodeString);
       }
-      return new ContextBuilderOptions(dartSdkSummaryPath: dartSdkSummaryPath, defaultAnalysisOptionsFilePath: defaultAnalysisOptionsFilePath, declaredVariables: declaredVariables, defaultPackageFilePath: defaultPackageFilePath, defaultPackagesDirectoryPath: defaultPackagesDirectoryPath);
+      return new ContextBuilderOptions(
+          dartSdkSummaryPath: dartSdkSummaryPath,
+          defaultAnalysisOptionsFilePath: defaultAnalysisOptionsFilePath,
+          declaredVariables: declaredVariables,
+          defaultPackageFilePath: defaultPackageFilePath,
+          defaultPackagesDirectoryPath: defaultPackagesDirectoryPath);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "ContextBuilderOptions", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (dartSdkSummaryPath != null) {
       result["dartSdkSummaryPath"] = dartSdkSummaryPath;
@@ skipping 10 matching lines @@
     if (defaultPackagesDirectoryPath != null) {
       result["defaultPackagesDirectoryPath"] = defaultPackagesDirectoryPath;
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ContextBuilderOptions) {
       return dartSdkSummaryPath == other.dartSdkSummaryPath &&
-          listEqual(defaultAnalysisOptionsFilePath, other.defaultAnalysisOptionsFilePath, (String a, String b) => a == b) &&
-          mapEqual(declaredVariables, other.declaredVariables, (String a, String b) => a == b) &&
-          listEqual(defaultPackageFilePath, other.defaultPackageFilePath, (String a, String b) => a == b) &&
-          listEqual(defaultPackagesDirectoryPath, other.defaultPackagesDirectoryPath, (String a, String b) => a == b);
+          listEqual(
+              defaultAnalysisOptionsFilePath,
+              other.defaultAnalysisOptionsFilePath,
+              (String a, String b) => a == b) &&
+          mapEqual(declaredVariables, other.declaredVariables,
+              (String a, String b) => a == b) &&
+          listEqual(defaultPackageFilePath, other.defaultPackageFilePath,
+              (String a, String b) => a == b) &&
+          listEqual(
+              defaultPackagesDirectoryPath,
+              other.defaultPackagesDirectoryPath,
+              (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, dartSdkSummaryPath.hashCode);
-    hash = JenkinsSmiHash.combine(hash, defaultAnalysisOptionsFilePath.hashCode);
+    hash =
+        JenkinsSmiHash.combine(hash, defaultAnalysisOptionsFilePath.hashCode);
     hash = JenkinsSmiHash.combine(hash, declaredVariables.hashCode);
     hash = JenkinsSmiHash.combine(hash, defaultPackageFilePath.hashCode);
     hash = JenkinsSmiHash.combine(hash, defaultPackagesDirectoryPath.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * ContextRoot
  *
@@ skipping 37 matching lines @@
   void set exclude(List<String> value) {
     assert(value != null);
     this._exclude = value;
   }
 
   ContextRoot(String root, List<String> exclude) {
     this.root = root;
     this.exclude = exclude;
   }
 
-  factory ContextRoot.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ContextRoot.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String root;
       if (json.containsKey("root")) {
         root = jsonDecoder.decodeString(jsonPath + ".root", json["root"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "root");
       }
       List<String> exclude;
       if (json.containsKey("exclude")) {
-        exclude = jsonDecoder.decodeList(jsonPath + ".exclude", json["exclude"], jsonDecoder.decodeString);
+        exclude = jsonDecoder.decodeList(
+            jsonPath + ".exclude", json["exclude"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "exclude");
       }
       return new ContextRoot(root, exclude);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "ContextRoot", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["root"] = root;
     result["exclude"] = exclude;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ContextRoot) {
       return root == other.root &&
           listEqual(exclude, other.exclude, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, root.hashCode);
     hash = JenkinsSmiHash.combine(hash, exclude.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * convertGetterToMethod feedback
  *
  * Clients may not extend, implement or mix-in this class.
  */
-class ConvertGetterToMethodFeedback extends RefactoringFeedback implements HasToJson {
+class ConvertGetterToMethodFeedback extends RefactoringFeedback
+    implements HasToJson {
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ConvertGetterToMethodFeedback) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 616032599;
   }
 }
 
 /**
  * convertGetterToMethod options
  *
  * Clients may not extend, implement or mix-in this class.
  */
-class ConvertGetterToMethodOptions extends RefactoringOptions implements HasToJson {
+class ConvertGetterToMethodOptions extends RefactoringOptions
+    implements HasToJson {
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ConvertGetterToMethodOptions) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 488848400;
   }
 }
 
 /**
  * convertMethodToGetter feedback
  *
  * Clients may not extend, implement or mix-in this class.
  */
-class ConvertMethodToGetterFeedback extends RefactoringFeedback implements HasToJson {
+class ConvertMethodToGetterFeedback extends RefactoringFeedback
+    implements HasToJson {
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ConvertMethodToGetterFeedback) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 165291526;
   }
 }
 
 /**
  * convertMethodToGetter options
  *
  * Clients may not extend, implement or mix-in this class.
  */
-class ConvertMethodToGetterOptions extends RefactoringOptions implements HasToJson {
+class ConvertMethodToGetterOptions extends RefactoringOptions
+    implements HasToJson {
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ConvertMethodToGetterOptions) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 27952290;
   }
@@ skipping 55 matching lines @@
     assert(value != null);
     this._length = value;
   }
 
   EditGetAssistsParams(String file, int offset, int length) {
     this.file = file;
     this.offset = offset;
     this.length = length;
   }
 
-  factory EditGetAssistsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory EditGetAssistsParams.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
@@ skipping 31 matching lines @@
 
   @override
   Request toRequest(String id) {
     return new Request(id, "edit.getAssists", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is EditGetAssistsParams) {
       return file == other.file &&
           offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 27 matching lines @@
    */
   void set assists(List<PrioritizedSourceChange> value) {
     assert(value != null);
     this._assists = value;
   }
 
   EditGetAssistsResult(List<PrioritizedSourceChange> assists) {
     this.assists = assists;
   }
 
-  factory EditGetAssistsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory EditGetAssistsResult.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<PrioritizedSourceChange> assists;
       if (json.containsKey("assists")) {
-        assists = jsonDecoder.decodeList(jsonPath + ".assists", json["assists"], (String jsonPath, Object json) => new PrioritizedSourceChange.fromJson(jsonDecoder, jsonPath, json));
+        assists = jsonDecoder.decodeList(
+            jsonPath + ".assists",
+            json["assists"],
+            (String jsonPath, Object json) =>
+                new PrioritizedSourceChange.fromJson(
+                    jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "assists");
       }
       return new EditGetAssistsResult(assists);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAssists result", json);
     }
   }
 
   factory EditGetAssistsResult.fromResponse(Response response) {
     return new EditGetAssistsResult.fromJson(
-        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response.result);
+        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)),
+        "result",
+        response.result);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["assists"] = assists.map((PrioritizedSourceChange value) => value.toJson()).toList();
+    result["assists"] =
+        assists.map((PrioritizedSourceChange value) => value.toJson()).toList();
     return result;
   }
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is EditGetAssistsResult) {
-      return listEqual(assists, other.assists, (PrioritizedSourceChange a, PrioritizedSourceChange b) => a == b);
+      return listEqual(assists, other.assists,
+          (PrioritizedSourceChange a, PrioritizedSourceChange b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, assists.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
@@ skipping 55 matching lines @@
     assert(value != null);
     this._length = value;
   }
 
   EditGetAvailableRefactoringsParams(String file, int offset, int length) {
     this.file = file;
     this.offset = offset;
     this.length = length;
   }
 
-  factory EditGetAvailableRefactoringsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory EditGetAvailableRefactoringsParams.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       return new EditGetAvailableRefactoringsParams(file, offset, length);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings params", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "edit.getAvailableRefactorings params", json);
     }
   }
 
   factory EditGetAvailableRefactoringsParams.fromRequest(Request request) {
     return new EditGetAvailableRefactoringsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     result["length"] = length;
     return result;
   }
 
   @override
   Request toRequest(String id) {
     return new Request(id, "edit.getAvailableRefactorings", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is EditGetAvailableRefactoringsParams) {
       return file == other.file &&
           offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 37 matching lines @@
    */
   void set kinds(List<RefactoringKind> value) {
     assert(value != null);
     this._kinds = value;
   }
 
   EditGetAvailableRefactoringsResult(List<RefactoringKind> kinds) {
     this.kinds = kinds;
   }
 
-  factory EditGetAvailableRefactoringsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory EditGetAvailableRefactoringsResult.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<RefactoringKind> kinds;
       if (json.containsKey("kinds")) {
-        kinds = jsonDecoder.decodeList(jsonPath + ".kinds", json["kinds"], (String jsonPath, Object json) => new RefactoringKind.fromJson(jsonDecoder, jsonPath, json));
+        kinds = jsonDecoder.decodeList(
+            jsonPath + ".kinds",
+            json["kinds"],
+            (String jsonPath, Object json) =>
+                new RefactoringKind.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "kinds");
       }
       return new EditGetAvailableRefactoringsResult(kinds);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings result", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "edit.getAvailableRefactorings result", json);
     }
   }
 
   factory EditGetAvailableRefactoringsResult.fromResponse(Response response) {
     return new EditGetAvailableRefactoringsResult.fromJson(
-        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response.result);
+        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)),
+        "result",
+        response.result);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["kinds"] = kinds.map((RefactoringKind value) => value.toJson()).toList();
+    result["kinds"] =
+        kinds.map((RefactoringKind value) => value.toJson()).toList();
     return result;
   }
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is EditGetAvailableRefactoringsResult) {
-      return listEqual(kinds, other.kinds, (RefactoringKind a, RefactoringKind b) => a == b);
+      return listEqual(
+          kinds, other.kinds, (RefactoringKind a, RefactoringKind b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, kinds.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
@@ skipping 38 matching lines @@
   void set offset(int value) {
     assert(value != null);
     this._offset = value;
   }
 
   EditGetFixesParams(String file, int offset) {
     this.file = file;
     this.offset = offset;
   }
 
-  factory EditGetFixesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory EditGetFixesParams.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
@@ skipping 24 matching lines @@
 
   @override
   Request toRequest(String id) {
     return new Request(id, "edit.getFixes", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is EditGetFixesParams) {
-      return file == other.file &&
-          offset == other.offset;
+      return file == other.file && offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, file.hashCode);
     hash = JenkinsSmiHash.combine(hash, offset.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 22 matching lines @@
    */
   void set fixes(List<AnalysisErrorFixes> value) {
     assert(value != null);
     this._fixes = value;
   }
 
   EditGetFixesResult(List<AnalysisErrorFixes> fixes) {
     this.fixes = fixes;
   }
 
-  factory EditGetFixesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory EditGetFixesResult.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<AnalysisErrorFixes> fixes;
       if (json.containsKey("fixes")) {
-        fixes = jsonDecoder.decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new AnalysisErrorFixes.fromJson(jsonDecoder, jsonPath, json));
+        fixes = jsonDecoder.decodeList(
+            jsonPath + ".fixes",
+            json["fixes"],
+            (String jsonPath, Object json) =>
+                new AnalysisErrorFixes.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "fixes");
       }
       return new EditGetFixesResult(fixes);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result", json);
     }
   }
 
   factory EditGetFixesResult.fromResponse(Response response) {
     return new EditGetFixesResult.fromJson(
-        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response.result);
+        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)),
+        "result",
+        response.result);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["fixes"] = fixes.map((AnalysisErrorFixes value) => value.toJson()).toList();
+    result["fixes"] =
+        fixes.map((AnalysisErrorFixes value) => value.toJson()).toList();
     return result;
   }
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is EditGetFixesResult) {
-      return listEqual(fixes, other.fixes, (AnalysisErrorFixes a, AnalysisErrorFixes b) => a == b);
+      return listEqual(fixes, other.fixes,
+          (AnalysisErrorFixes a, AnalysisErrorFixes b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, fixes.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
@@ skipping 106 matching lines @@
    * Data used to provide values provided by the user. The structure of the
    * data is dependent on the kind of refactoring being performed. The data
    * that is expected is documented in the section titled Refactorings, labeled
    * as "Options". This field can be omitted if the refactoring does not
    * require any options or if the values of those options are not known.
    */
   void set options(RefactoringOptions value) {
     this._options = value;
   }
 
-  EditGetRefactoringParams(RefactoringKind kind, String file, int offset, int length, bool validateOnly, {RefactoringOptions options}) {
+  EditGetRefactoringParams(RefactoringKind kind, String file, int offset,
+      int length, bool validateOnly,
+      {RefactoringOptions options}) {
     this.kind = kind;
     this.file = file;
     this.offset = offset;
     this.length = length;
     this.validateOnly = validateOnly;
     this.options = options;
   }
 
-  factory EditGetRefactoringParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory EditGetRefactoringParams.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       RefactoringKind kind;
       if (json.containsKey("kind")) {
-        kind = new RefactoringKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
+        kind = new RefactoringKind.fromJson(
+            jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "kind");
       }
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       bool validateOnly;
       if (json.containsKey("validateOnly")) {
-        validateOnly = jsonDecoder.decodeBool(jsonPath + ".validateOnly", json["validateOnly"]);
+        validateOnly = jsonDecoder.decodeBool(
+            jsonPath + ".validateOnly", json["validateOnly"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "validateOnly");
       }
       RefactoringOptions options;
       if (json.containsKey("options")) {
-        options = new RefactoringOptions.fromJson(jsonDecoder, jsonPath + ".options", json["options"], kind);
+        options = new RefactoringOptions.fromJson(
+            jsonDecoder, jsonPath + ".options", json["options"], kind);
       }
-      return new EditGetRefactoringParams(kind, file, offset, length, validateOnly, options: options);
+      return new EditGetRefactoringParams(
+          kind, file, offset, length, validateOnly,
+          options: options);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring params", json);
     }
   }
 
   factory EditGetRefactoringParams.fromRequest(Request request) {
     var params = new EditGetRefactoringParams.fromJson(
         new RequestDecoder(request), "params", request.params);
     REQUEST_ID_REFACTORING_KINDS[request.id] = params.kind;
     return params;
@@ skipping 15 matching lines @@
 
   @override
   Request toRequest(String id) {
     return new Request(id, "edit.getRefactoring", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is EditGetRefactoringParams) {
       return kind == other.kind &&
           file == other.file &&
           offset == other.offset &&
           length == other.length &&
           validateOnly == other.validateOnly &&
           options == other.options;
     }
     return false;
   }
@@ skipping 140 matching lines @@
    * known to be valid if there was insufficient type information for the
    * plugin to be able to determine whether or not the code needs to be
    * modified, such as when a member is being renamed and there is a reference
    * to a member from an unknown type. This field can be omitted if the change
    * field is omitted or if there are no potential edits for the refactoring.
    */
   void set potentialEdits(List<String> value) {
     this._potentialEdits = value;
   }
 
-  EditGetRefactoringResult(List<RefactoringProblem> initialProblems, List<RefactoringProblem> optionsProblems, List<RefactoringProblem> finalProblems, {RefactoringFeedback feedback, SourceChange change, List<String> potentialEdits}) {
+  EditGetRefactoringResult(
+      List<RefactoringProblem> initialProblems,
+      List<RefactoringProblem> optionsProblems,
+      List<RefactoringProblem> finalProblems,
+      {RefactoringFeedback feedback,
+      SourceChange change,
+      List<String> potentialEdits}) {
     this.initialProblems = initialProblems;
     this.optionsProblems = optionsProblems;
     this.finalProblems = finalProblems;
     this.feedback = feedback;
     this.change = change;
     this.potentialEdits = potentialEdits;
   }
 
-  factory EditGetRefactoringResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory EditGetRefactoringResult.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<RefactoringProblem> initialProblems;
       if (json.containsKey("initialProblems")) {
-        initialProblems = jsonDecoder.decodeList(jsonPath + ".initialProblems", json["initialProblems"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
+        initialProblems = jsonDecoder.decodeList(
+            jsonPath + ".initialProblems",
+            json["initialProblems"],
+            (String jsonPath, Object json) =>
+                new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "initialProblems");
       }
       List<RefactoringProblem> optionsProblems;
       if (json.containsKey("optionsProblems")) {
-        optionsProblems = jsonDecoder.decodeList(jsonPath + ".optionsProblems", json["optionsProblems"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
+        optionsProblems = jsonDecoder.decodeList(
+            jsonPath + ".optionsProblems",
+            json["optionsProblems"],
+            (String jsonPath, Object json) =>
+                new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "optionsProblems");
       }
       List<RefactoringProblem> finalProblems;
       if (json.containsKey("finalProblems")) {
-        finalProblems = jsonDecoder.decodeList(jsonPath + ".finalProblems", json["finalProblems"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
+        finalProblems = jsonDecoder.decodeList(
+            jsonPath + ".finalProblems",
+            json["finalProblems"],
+            (String jsonPath, Object json) =>
+                new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "finalProblems");
       }
       RefactoringFeedback feedback;
       if (json.containsKey("feedback")) {
-        feedback = new RefactoringFeedback.fromJson(jsonDecoder, jsonPath + ".feedback", json["feedback"], json);
+        feedback = new RefactoringFeedback.fromJson(
+            jsonDecoder, jsonPath + ".feedback", json["feedback"], json);
       }
       SourceChange change;
       if (json.containsKey("change")) {
-        change = new SourceChange.fromJson(jsonDecoder, jsonPath + ".change", json["change"]);
+        change = new SourceChange.fromJson(
+            jsonDecoder, jsonPath + ".change", json["change"]);
       }
       List<String> potentialEdits;
       if (json.containsKey("potentialEdits")) {
-        potentialEdits = jsonDecoder.decodeList(jsonPath + ".potentialEdits", json["potentialEdits"], jsonDecoder.decodeString);
+        potentialEdits = jsonDecoder.decodeList(jsonPath + ".potentialEdits",
+            json["potentialEdits"], jsonDecoder.decodeString);
       }
-      return new EditGetRefactoringResult(initialProblems, optionsProblems, finalProblems, feedback: feedback, change: change, potentialEdits: potentialEdits);
+      return new EditGetRefactoringResult(
+          initialProblems, optionsProblems, finalProblems,
+          feedback: feedback, change: change, potentialEdits: potentialEdits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result", json);
     }
   }
 
   factory EditGetRefactoringResult.fromResponse(Response response) {
     return new EditGetRefactoringResult.fromJson(
-        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response.result);
+        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)),
+        "result",
+        response.result);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["initialProblems"] = initialProblems.map((RefactoringProblem value) => value.toJson()).toList();
-    result["optionsProblems"] = optionsProblems.map((RefactoringProblem value) => value.toJson()).toList();
-    result["finalProblems"] = finalProblems.map((RefactoringProblem value) => value.toJson()).toList();
+    result["initialProblems"] = initialProblems
+        .map((RefactoringProblem value) => value.toJson())
+        .toList();
+    result["optionsProblems"] = optionsProblems
+        .map((RefactoringProblem value) => value.toJson())
+        .toList();
+    result["finalProblems"] = finalProblems
+        .map((RefactoringProblem value) => value.toJson())
+        .toList();
     if (feedback != null) {
       result["feedback"] = feedback.toJson();
     }
     if (change != null) {
       result["change"] = change.toJson();
     }
     if (potentialEdits != null) {
       result["potentialEdits"] = potentialEdits;
     }
     return result;
   }
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is EditGetRefactoringResult) {
-      return listEqual(initialProblems, other.initialProblems, (RefactoringProblem a, RefactoringProblem b) => a == b) &&
-          listEqual(optionsProblems, other.optionsProblems, (RefactoringProblem a, RefactoringProblem b) => a == b) &&
-          listEqual(finalProblems, other.finalProblems, (RefactoringProblem a, RefactoringProblem b) => a == b) &&
+      return listEqual(initialProblems, other.initialProblems,
+              (RefactoringProblem a, RefactoringProblem b) => a == b) &&
+          listEqual(optionsProblems, other.optionsProblems,
+              (RefactoringProblem a, RefactoringProblem b) => a == b) &&
+          listEqual(finalProblems, other.finalProblems,
+              (RefactoringProblem a, RefactoringProblem b) => a == b) &&
           feedback == other.feedback &&
           change == other.change &&
-          listEqual(potentialEdits, other.potentialEdits, (String a, String b) => a == b);
+          listEqual(potentialEdits, other.potentialEdits,
+              (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, initialProblems.hashCode);
     hash = JenkinsSmiHash.combine(hash, optionsProblems.hashCode);
     hash = JenkinsSmiHash.combine(hash, finalProblems.hashCode);
@@ skipping 20 matching lines @@
  * Clients may not extend, implement or mix-in this class.
  */
 class Element implements HasToJson {
   static const int FLAG_ABSTRACT = 0x01;
   static const int FLAG_CONST = 0x02;
   static const int FLAG_FINAL = 0x04;
   static const int FLAG_STATIC = 0x08;
   static const int FLAG_PRIVATE = 0x10;
   static const int FLAG_DEPRECATED = 0x20;
 
-  static int makeFlags({isAbstract: false, isConst: false, isFinal: false, isStatic: false, isPrivate: false, isDeprecated: false}) {
+  static int makeFlags(
+      {isAbstract: false,
+      isConst: false,
+      isFinal: false,
+      isStatic: false,
+      isPrivate: false,
+      isDeprecated: false}) {
     int flags = 0;
     if (isAbstract) flags |= FLAG_ABSTRACT;
     if (isConst) flags |= FLAG_CONST;
     if (isFinal) flags |= FLAG_FINAL;
     if (isStatic) flags |= FLAG_STATIC;
     if (isPrivate) flags |= FLAG_PRIVATE;
     if (isDeprecated) flags |= FLAG_DEPRECATED;
     return flags;
   }
 
@@ skipping 121 matching lines @@
   String get typeParameters => _typeParameters;
 
   /**
    * The type parameter list for the element. If the element doesn't have type
    * parameters, this field will not be defined.
    */
   void set typeParameters(String value) {
     this._typeParameters = value;
   }
 
-  Element(ElementKind kind, String name, int flags, {Location location, String parameters, String returnType, String typeParameters}) {
+  Element(ElementKind kind, String name, int flags,
+      {Location location,
+      String parameters,
+      String returnType,
+      String typeParameters}) {
     this.kind = kind;
     this.name = name;
     this.location = location;
     this.flags = flags;
     this.parameters = parameters;
     this.returnType = returnType;
     this.typeParameters = typeParameters;
   }
 
-  factory Element.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory Element.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       ElementKind kind;
       if (json.containsKey("kind")) {
-        kind = new ElementKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
+        kind = new ElementKind.fromJson(
+            jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "kind");
       }
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "name");
       }
       Location location;
       if (json.containsKey("location")) {
-        location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
+        location = new Location.fromJson(
+            jsonDecoder, jsonPath + ".location", json["location"]);
       }
       int flags;
       if (json.containsKey("flags")) {
         flags = jsonDecoder.decodeInt(jsonPath + ".flags", json["flags"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "flags");
       }
       String parameters;
       if (json.containsKey("parameters")) {
-        parameters = jsonDecoder.decodeString(jsonPath + ".parameters", json["parameters"]);
+        parameters = jsonDecoder.decodeString(
+            jsonPath + ".parameters", json["parameters"]);
       }
       String returnType;
       if (json.containsKey("returnType")) {
-        returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["returnType"]);
+        returnType = jsonDecoder.decodeString(
+            jsonPath + ".returnType", json["returnType"]);
       }
       String typeParameters;
       if (json.containsKey("typeParameters")) {
-        typeParameters = jsonDecoder.decodeString(jsonPath + ".typeParameters", json["typeParameters"]);
+        typeParameters = jsonDecoder.decodeString(
+            jsonPath + ".typeParameters", json["typeParameters"]);
       }
-      return new Element(kind, name, flags, location: location, parameters: parameters, returnType: returnType, typeParameters: typeParameters);
+      return new Element(kind, name, flags,
+          location: location,
+          parameters: parameters,
+          returnType: returnType,
+          typeParameters: typeParameters);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Element", json);
     }
   }
 
   bool get isAbstract => (flags & FLAG_ABSTRACT) != 0;
   bool get isConst => (flags & FLAG_CONST) != 0;
   bool get isFinal => (flags & FLAG_FINAL) != 0;
   bool get isStatic => (flags & FLAG_STATIC) != 0;
   bool get isPrivate => (flags & FLAG_PRIVATE) != 0;
@@ skipping 17 matching lines @@
     if (typeParameters != null) {
       result["typeParameters"] = typeParameters;
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is Element) {
       return kind == other.kind &&
           name == other.name &&
           location == other.location &&
           flags == other.flags &&
           parameters == other.parameters &&
           returnType == other.returnType &&
           typeParameters == other.typeParameters;
     }
     return false;
@@ skipping 38 matching lines @@
  *   TOP_LEVEL_VARIABLE
  *   TYPE_PARAMETER
  *   UNKNOWN
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class ElementKind implements Enum {
   static const ElementKind CLASS = const ElementKind._("CLASS");
 
-  static const ElementKind CLASS_TYPE_ALIAS = const ElementKind._("CLASS_TYPE_ALIAS");
+  static const ElementKind CLASS_TYPE_ALIAS =
+      const ElementKind._("CLASS_TYPE_ALIAS");
 
-  static const ElementKind COMPILATION_UNIT = const ElementKind._("COMPILATION_UNIT");
+  static const ElementKind COMPILATION_UNIT =
+      const ElementKind._("COMPILATION_UNIT");
 
   static const ElementKind CONSTRUCTOR = const ElementKind._("CONSTRUCTOR");
 
   static const ElementKind ENUM = const ElementKind._("ENUM");
 
   static const ElementKind ENUM_CONSTANT = const ElementKind._("ENUM_CONSTANT");
 
   static const ElementKind FIELD = const ElementKind._("FIELD");
 
   static const ElementKind FILE = const ElementKind._("FILE");
 
   static const ElementKind FUNCTION = const ElementKind._("FUNCTION");
 
-  static const ElementKind FUNCTION_TYPE_ALIAS = const ElementKind._("FUNCTION_TYPE_ALIAS");
+  static const ElementKind FUNCTION_TYPE_ALIAS =
+      const ElementKind._("FUNCTION_TYPE_ALIAS");
 
   static const ElementKind GETTER = const ElementKind._("GETTER");
 
   static const ElementKind LABEL = const ElementKind._("LABEL");
 
   static const ElementKind LIBRARY = const ElementKind._("LIBRARY");
 
-  static const ElementKind LOCAL_VARIABLE = const ElementKind._("LOCAL_VARIABLE");
+  static const ElementKind LOCAL_VARIABLE =
+      const ElementKind._("LOCAL_VARIABLE");
 
   static const ElementKind METHOD = const ElementKind._("METHOD");
 
   static const ElementKind PARAMETER = const ElementKind._("PARAMETER");
 
   static const ElementKind PREFIX = const ElementKind._("PREFIX");
 
   static const ElementKind SETTER = const ElementKind._("SETTER");
 
-  static const ElementKind TOP_LEVEL_VARIABLE = const ElementKind._("TOP_LEVEL_VARIABLE");
+  static const ElementKind TOP_LEVEL_VARIABLE =
+      const ElementKind._("TOP_LEVEL_VARIABLE");
 
-  static const ElementKind TYPE_PARAMETER = const ElementKind._("TYPE_PARAMETER");
+  static const ElementKind TYPE_PARAMETER =
+      const ElementKind._("TYPE_PARAMETER");
 
   static const ElementKind UNKNOWN = const ElementKind._("UNKNOWN");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<ElementKind> VALUES = const <ElementKind>[CLASS, CLASS_TYPE_ALIAS, COMPILATION_UNIT, CONSTRUCTOR, ENUM, ENUM_CONSTANT, FIELD, FILE, FUNCTION, FUNCTION_TYPE_ALIAS, GETTER, LABEL, LIBRARY, LOCAL_VARIABLE, METHOD, PARAMETER, PREFIX, SETTER, TOP_LEVEL_VARIABLE, TYPE_PARAMETER, UNKNOWN];
+  static const List<ElementKind> VALUES = const <ElementKind>[
+    CLASS,
+    CLASS_TYPE_ALIAS,
+    COMPILATION_UNIT,
+    CONSTRUCTOR,
+    ENUM,
+    ENUM_CONSTANT,
+    FIELD,
+    FILE,
+    FUNCTION,
+    FUNCTION_TYPE_ALIAS,
+    GETTER,
+    LABEL,
+    LIBRARY,
+    LOCAL_VARIABLE,
+    METHOD,
+    PARAMETER,
+    PREFIX,
+    SETTER,
+    TOP_LEVEL_VARIABLE,
+    TYPE_PARAMETER,
+    UNKNOWN
+  ];
 
   @override
   final String name;
 
   const ElementKind._(this.name);
 
   factory ElementKind(String name) {
     switch (name) {
       case "CLASS":
         return CLASS;
@@ skipping 34 matching lines @@
       case "TOP_LEVEL_VARIABLE":
         return TOP_LEVEL_VARIABLE;
       case "TYPE_PARAMETER":
         return TYPE_PARAMETER;
       case "UNKNOWN":
         return UNKNOWN;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory ElementKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ElementKind.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new ElementKind(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "ElementKind", json);
   }
 
   @override
   String toString() => "ElementKind.$name";
 
   String toJson() => name;
@@ skipping 91 matching lines @@
    * The lengths of the expressions that would be replaced by a reference to
    * the variable. The lengths correspond to the offsets. In other words, for a
    * given expression, if the offset of that expression is offsets[i], then the
    * length of that expression is lengths[i].
    */
   void set lengths(List<int> value) {
     assert(value != null);
     this._lengths = value;
   }
 
-  ExtractLocalVariableFeedback(List<String> names, List<int> offsets, List<int> lengths, {List<int> coveringExpressionOffsets, List<int> coveringExpressionLengths}) {
+  ExtractLocalVariableFeedback(
+      List<String> names, List<int> offsets, List<int> lengths,
+      {List<int> coveringExpressionOffsets,
+      List<int> coveringExpressionLengths}) {
     this.coveringExpressionOffsets = coveringExpressionOffsets;
     this.coveringExpressionLengths = coveringExpressionLengths;
     this.names = names;
     this.offsets = offsets;
     this.lengths = lengths;
   }
 
-  factory ExtractLocalVariableFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExtractLocalVariableFeedback.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<int> coveringExpressionOffsets;
       if (json.containsKey("coveringExpressionOffsets")) {
-        coveringExpressionOffsets = jsonDecoder.decodeList(jsonPath + ".coveringExpressionOffsets", json["coveringExpressionOffsets"], jsonDecoder.decodeInt);
+        coveringExpressionOffsets = jsonDecoder.decodeList(
+            jsonPath + ".coveringExpressionOffsets",
+            json["coveringExpressionOffsets"],
+            jsonDecoder.decodeInt);
       }
       List<int> coveringExpressionLengths;
       if (json.containsKey("coveringExpressionLengths")) {
-        coveringExpressionLengths = jsonDecoder.decodeList(jsonPath + ".coveringExpressionLengths", json["coveringExpressionLengths"], jsonDecoder.decodeInt);
+        coveringExpressionLengths = jsonDecoder.decodeList(
+            jsonPath + ".coveringExpressionLengths",
+            json["coveringExpressionLengths"],
+            jsonDecoder.decodeInt);
       }
       List<String> names;
       if (json.containsKey("names")) {
-        names = jsonDecoder.decodeList(jsonPath + ".names", json["names"], jsonDecoder.decodeString);
+        names = jsonDecoder.decodeList(
+            jsonPath + ".names", json["names"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "names");
       }
       List<int> offsets;
       if (json.containsKey("offsets")) {
-        offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt);
+        offsets = jsonDecoder.decodeList(
+            jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offsets");
       }
       List<int> lengths;
       if (json.containsKey("lengths")) {
-        lengths = jsonDecoder.decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder.decodeInt);
+        lengths = jsonDecoder.decodeList(
+            jsonPath + ".lengths", json["lengths"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "lengths");
       }
-      return new ExtractLocalVariableFeedback(names, offsets, lengths, coveringExpressionOffsets: coveringExpressionOffsets, coveringExpressionLengths: coveringExpressionLengths);
+      return new ExtractLocalVariableFeedback(names, offsets, lengths,
+          coveringExpressionOffsets: coveringExpressionOffsets,
+          coveringExpressionLengths: coveringExpressionLengths);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable feedback", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "extractLocalVariable feedback", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (coveringExpressionOffsets != null) {
       result["coveringExpressionOffsets"] = coveringExpressionOffsets;
     }
     if (coveringExpressionLengths != null) {
       result["coveringExpressionLengths"] = coveringExpressionLengths;
     }
     result["names"] = names;
     result["offsets"] = offsets;
     result["lengths"] = lengths;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ExtractLocalVariableFeedback) {
-      return listEqual(coveringExpressionOffsets, other.coveringExpressionOffsets, (int a, int b) => a == b) &&
-          listEqual(coveringExpressionLengths, other.coveringExpressionLengths, (int a, int b) => a == b) &&
+      return listEqual(coveringExpressionOffsets,
+              other.coveringExpressionOffsets, (int a, int b) => a == b) &&
+          listEqual(coveringExpressionLengths, other.coveringExpressionLengths,
+              (int a, int b) => a == b) &&
           listEqual(names, other.names, (String a, String b) => a == b) &&
           listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
           listEqual(lengths, other.lengths, (int a, int b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
@@ skipping 51 matching lines @@
   void set extractAll(bool value) {
     assert(value != null);
     this._extractAll = value;
   }
 
   ExtractLocalVariableOptions(String name, bool extractAll) {
     this.name = name;
     this.extractAll = extractAll;
   }
 
-  factory ExtractLocalVariableOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExtractLocalVariableOptions.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "name");
       }
       bool extractAll;
       if (json.containsKey("extractAll")) {
-        extractAll = jsonDecoder.decodeBool(jsonPath + ".extractAll", json["extractAll"]);
+        extractAll = jsonDecoder.decodeBool(
+            jsonPath + ".extractAll", json["extractAll"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "extractAll");
       }
       return new ExtractLocalVariableOptions(name, extractAll);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable options", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "extractLocalVariable options", json);
     }
   }
 
-  factory ExtractLocalVariableOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
+  factory ExtractLocalVariableOptions.fromRefactoringParams(
+      EditGetRefactoringParams refactoringParams, Request request) {
     return new ExtractLocalVariableOptions.fromJson(
         new RequestDecoder(request), "options", refactoringParams.options);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["name"] = name;
     result["extractAll"] = extractAll;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ExtractLocalVariableOptions) {
-      return name == other.name &&
-          extractAll == other.extractAll;
+      return name == other.name && extractAll == other.extractAll;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, name.hashCode);
     hash = JenkinsSmiHash.combine(hash, extractAll.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 144 matching lines @@
    * invocation of the method. The lengths correspond to the offsets. In other
    * words, for a given expression (or block of statements), if the offset of
    * that expression is offsets[i], then the length of that expression is
    * lengths[i].
    */
   void set lengths(List<int> value) {
     assert(value != null);
     this._lengths = value;
   }
 
-  ExtractMethodFeedback(int offset, int length, String returnType, List<String> names, bool canCreateGetter, List<RefactoringMethodParameter> parameters, List<int> offsets, List<int> lengths) {
+  ExtractMethodFeedback(
+      int offset,
+      int length,
+      String returnType,
+      List<String> names,
+      bool canCreateGetter,
+      List<RefactoringMethodParameter> parameters,
+      List<int> offsets,
+      List<int> lengths) {
     this.offset = offset;
     this.length = length;
     this.returnType = returnType;
     this.names = names;
     this.canCreateGetter = canCreateGetter;
     this.parameters = parameters;
     this.offsets = offsets;
     this.lengths = lengths;
   }
 
-  factory ExtractMethodFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExtractMethodFeedback.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       String returnType;
       if (json.containsKey("returnType")) {
-        returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["returnType"]);
+        returnType = jsonDecoder.decodeString(
+            jsonPath + ".returnType", json["returnType"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "returnType");
       }
       List<String> names;
       if (json.containsKey("names")) {
-        names = jsonDecoder.decodeList(jsonPath + ".names", json["names"], jsonDecoder.decodeString);
+        names = jsonDecoder.decodeList(
+            jsonPath + ".names", json["names"], jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "names");
       }
       bool canCreateGetter;
       if (json.containsKey("canCreateGetter")) {
-        canCreateGetter = jsonDecoder.decodeBool(jsonPath + ".canCreateGetter", json["canCreateGetter"]);
+        canCreateGetter = jsonDecoder.decodeBool(
+            jsonPath + ".canCreateGetter", json["canCreateGetter"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "canCreateGetter");
       }
       List<RefactoringMethodParameter> parameters;
       if (json.containsKey("parameters")) {
-        parameters = jsonDecoder.decodeList(jsonPath + ".parameters", json["parameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJson(jsonDecoder, jsonPath, json));
+        parameters = jsonDecoder.decodeList(
+            jsonPath + ".parameters",
+            json["parameters"],
+            (String jsonPath, Object json) =>
+                new RefactoringMethodParameter.fromJson(
+                    jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "parameters");
       }
       List<int> offsets;
       if (json.containsKey("offsets")) {
-        offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt);
+        offsets = jsonDecoder.decodeList(
+            jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offsets");
       }
       List<int> lengths;
       if (json.containsKey("lengths")) {
-        lengths = jsonDecoder.decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder.decodeInt);
+        lengths = jsonDecoder.decodeList(
+            jsonPath + ".lengths", json["lengths"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "lengths");
       }
-      return new ExtractMethodFeedback(offset, length, returnType, names, canCreateGetter, parameters, offsets, lengths);
+      return new ExtractMethodFeedback(offset, length, returnType, names,
+          canCreateGetter, parameters, offsets, lengths);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractMethod feedback", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     result["returnType"] = returnType;
     result["names"] = names;
     result["canCreateGetter"] = canCreateGetter;
-    result["parameters"] = parameters.map((RefactoringMethodParameter value) => value.toJson()).toList();
+    result["parameters"] = parameters
+        .map((RefactoringMethodParameter value) => value.toJson())
+        .toList();
     result["offsets"] = offsets;
     result["lengths"] = lengths;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ExtractMethodFeedback) {
       return offset == other.offset &&
           length == other.length &&
           returnType == other.returnType &&
           listEqual(names, other.names, (String a, String b) => a == b) &&
           canCreateGetter == other.canCreateGetter &&
-          listEqual(parameters, other.parameters, (RefactoringMethodParameter a, RefactoringMethodParameter b) => a == b) &&
+          listEqual(
+              parameters,
+              other.parameters,
+              (RefactoringMethodParameter a, RefactoringMethodParameter b) =>
+                  a == b) &&
           listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
           listEqual(lengths, other.lengths, (int a, int b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, offset.hashCode);
@@ skipping 114 matching lines @@
   /**
    * True if all occurrences of the expression or statements should be replaced
    * by an invocation of the method. The expression or statements used to
    * initiate the refactoring will always be replaced.
    */
   void set extractAll(bool value) {
     assert(value != null);
     this._extractAll = value;
   }
 
-  ExtractMethodOptions(String returnType, bool createGetter, String name, List<RefactoringMethodParameter> parameters, bool extractAll) {
+  ExtractMethodOptions(String returnType, bool createGetter, String name,
+      List<RefactoringMethodParameter> parameters, bool extractAll) {
     this.returnType = returnType;
     this.createGetter = createGetter;
     this.name = name;
     this.parameters = parameters;
     this.extractAll = extractAll;
   }
 
-  factory ExtractMethodOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory ExtractMethodOptions.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String returnType;
       if (json.containsKey("returnType")) {
-        returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["returnType"]);
+        returnType = jsonDecoder.decodeString(
+            jsonPath + ".returnType", json["returnType"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "returnType");
       }
       bool createGetter;
       if (json.containsKey("createGetter")) {
-        createGetter = jsonDecoder.decodeBool(jsonPath + ".createGetter", json["createGetter"]);
+        createGetter = jsonDecoder.decodeBool(
+            jsonPath + ".createGetter", json["createGetter"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "createGetter");
       }
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "name");
       }
       List<RefactoringMethodParameter> parameters;
       if (json.containsKey("parameters")) {
-        parameters = jsonDecoder.decodeList(jsonPath + ".parameters", json["parameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJson(jsonDecoder, jsonPath, json));
+        parameters = jsonDecoder.decodeList(
+            jsonPath + ".parameters",
+            json["parameters"],
+            (String jsonPath, Object json) =>
+                new RefactoringMethodParameter.fromJson(
+                    jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "parameters");
       }
       bool extractAll;
       if (json.containsKey("extractAll")) {
-        extractAll = jsonDecoder.decodeBool(jsonPath + ".extractAll", json["extractAll"]);
+        extractAll = jsonDecoder.decodeBool(
+            jsonPath + ".extractAll", json["extractAll"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "extractAll");
       }
-      return new ExtractMethodOptions(returnType, createGetter, name, parameters, extractAll);
+      return new ExtractMethodOptions(
+          returnType, createGetter, name, parameters, extractAll);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractMethod options", json);
     }
   }
 
-  factory ExtractMethodOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
+  factory ExtractMethodOptions.fromRefactoringParams(
+      EditGetRefactoringParams refactoringParams, Request request) {
     return new ExtractMethodOptions.fromJson(
         new RequestDecoder(request), "options", refactoringParams.options);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["returnType"] = returnType;
     result["createGetter"] = createGetter;
     result["name"] = name;
-    result["parameters"] = parameters.map((RefactoringMethodParameter value) => value.toJson()).toList();
+    result["parameters"] = parameters
+        .map((RefactoringMethodParameter value) => value.toJson())
+        .toList();
     result["extractAll"] = extractAll;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is ExtractMethodOptions) {
       return returnType == other.returnType &&
           createGetter == other.createGetter &&
           name == other.name &&
-          listEqual(parameters, other.parameters, (RefactoringMethodParameter a, RefactoringMethodParameter b) => a == b) &&
+          listEqual(
+              parameters,
+              other.parameters,
+              (RefactoringMethodParameter a, RefactoringMethodParameter b) =>
+                  a == b) &&
           extractAll == other.extractAll;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, returnType.hashCode);
     hash = JenkinsSmiHash.combine(hash, createGetter.hashCode);
@@ skipping 17 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class FoldingKind implements Enum {
   static const FoldingKind COMMENT = const FoldingKind._("COMMENT");
 
   static const FoldingKind CLASS_MEMBER = const FoldingKind._("CLASS_MEMBER");
 
   static const FoldingKind DIRECTIVES = const FoldingKind._("DIRECTIVES");
 
-  static const FoldingKind DOCUMENTATION_COMMENT = const FoldingKind._("DOCUMENTATION_COMMENT");
+  static const FoldingKind DOCUMENTATION_COMMENT =
+      const FoldingKind._("DOCUMENTATION_COMMENT");
 
-  static const FoldingKind TOP_LEVEL_DECLARATION = const FoldingKind._("TOP_LEVEL_DECLARATION");
+  static const FoldingKind TOP_LEVEL_DECLARATION =
+      const FoldingKind._("TOP_LEVEL_DECLARATION");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<FoldingKind> VALUES = const <FoldingKind>[COMMENT, CLASS_MEMBER, DIRECTIVES, DOCUMENTATION_COMMENT, TOP_LEVEL_DECLARATION];
+  static const List<FoldingKind> VALUES = const <FoldingKind>[
+    COMMENT,
+    CLASS_MEMBER,
+    DIRECTIVES,
+    DOCUMENTATION_COMMENT,
+    TOP_LEVEL_DECLARATION
+  ];
 
   @override
   final String name;
 
   const FoldingKind._(this.name);
 
   factory FoldingKind(String name) {
     switch (name) {
       case "COMMENT":
         return COMMENT;
       case "CLASS_MEMBER":
         return CLASS_MEMBER;
       case "DIRECTIVES":
         return DIRECTIVES;
       case "DOCUMENTATION_COMMENT":
         return DOCUMENTATION_COMMENT;
       case "TOP_LEVEL_DECLARATION":
         return TOP_LEVEL_DECLARATION;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory FoldingKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory FoldingKind.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new FoldingKind(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "FoldingKind", json);
   }
 
   @override
   String toString() => "FoldingKind.$name";
 
   String toJson() => name;
@@ skipping 55 matching lines @@
     assert(value != null);
     this._length = value;
   }
 
   FoldingRegion(FoldingKind kind, int offset, int length) {
     this.kind = kind;
     this.offset = offset;
     this.length = length;
   }
 
-  factory FoldingRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory FoldingRegion.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       FoldingKind kind;
       if (json.containsKey("kind")) {
-        kind = new FoldingKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
+        kind = new FoldingKind.fromJson(
+            jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "kind");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
@@ skipping 14 matching lines @@
     result["kind"] = kind.toJson();
     result["offset"] = offset;
     result["length"] = length;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is FoldingRegion) {
       return kind == other.kind &&
           offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 61 matching lines @@
     assert(value != null);
     this._length = value;
   }
 
   HighlightRegion(HighlightRegionType type, int offset, int length) {
     this.type = type;
     this.offset = offset;
     this.length = length;
   }
 
-  factory HighlightRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory HighlightRegion.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       HighlightRegionType type;
       if (json.containsKey("type")) {
-        type = new HighlightRegionType.fromJson(jsonDecoder, jsonPath + ".type", json["type"]);
+        type = new HighlightRegionType.fromJson(
+            jsonDecoder, jsonPath + ".type", json["type"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "type");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
@@ skipping 14 matching lines @@
     result["type"] = type.toJson();
     result["offset"] = offset;
     result["length"] = length;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is HighlightRegion) {
       return type == other.type &&
           offset == other.offset &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 80 matching lines @@
  *   TOP_LEVEL_VARIABLE_DECLARATION
  *   TYPE_NAME_DYNAMIC
  *   TYPE_PARAMETER
  *   UNRESOLVED_INSTANCE_MEMBER_REFERENCE
  *   VALID_STRING_ESCAPE
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class HighlightRegionType implements Enum {
-  static const HighlightRegionType ANNOTATION = const HighlightRegionType._("ANNOTATION");
+  static const HighlightRegionType ANNOTATION =
+      const HighlightRegionType._("ANNOTATION");
 
-  static const HighlightRegionType BUILT_IN = const HighlightRegionType._("BUILT_IN");
+  static const HighlightRegionType BUILT_IN =
+      const HighlightRegionType._("BUILT_IN");
 
   static const HighlightRegionType CLASS = const HighlightRegionType._("CLASS");
 
-  static const HighlightRegionType COMMENT_BLOCK = const HighlightRegionType._("COMMENT_BLOCK");
+  static const HighlightRegionType COMMENT_BLOCK =
+      const HighlightRegionType._("COMMENT_BLOCK");
 
-  static const HighlightRegionType COMMENT_DOCUMENTATION = const HighlightRegionType._("COMMENT_DOCUMENTATION");
+  static const HighlightRegionType COMMENT_DOCUMENTATION =
+      const HighlightRegionType._("COMMENT_DOCUMENTATION");
 
-  static const HighlightRegionType COMMENT_END_OF_LINE = const HighlightRegionType._("COMMENT_END_OF_LINE");
+  static const HighlightRegionType COMMENT_END_OF_LINE =
+      const HighlightRegionType._("COMMENT_END_OF_LINE");
 
-  static const HighlightRegionType CONSTRUCTOR = const HighlightRegionType._("CONSTRUCTOR");
+  static const HighlightRegionType CONSTRUCTOR =
+      const HighlightRegionType._("CONSTRUCTOR");
 
-  static const HighlightRegionType DIRECTIVE = const HighlightRegionType._("DIRECTIVE");
+  static const HighlightRegionType DIRECTIVE =
+      const HighlightRegionType._("DIRECTIVE");
 
   /**
    * Only for version 1 of highlight.
    */
-  static const HighlightRegionType DYNAMIC_TYPE = const HighlightRegionType._("DYNAMIC_TYPE");
+  static const HighlightRegionType DYNAMIC_TYPE =
+      const HighlightRegionType._("DYNAMIC_TYPE");
 
   /**
    * Only for version 2 of highlight.
    */
-  static const HighlightRegionType DYNAMIC_LOCAL_VARIABLE_DECLARATION = const HighlightRegionType._("DYNAMIC_LOCAL_VARIABLE_DECLARATION");
+  static const HighlightRegionType DYNAMIC_LOCAL_VARIABLE_DECLARATION =
+      const HighlightRegionType._("DYNAMIC_LOCAL_VARIABLE_DECLARATION");
 
   /**
    * Only for version 2 of highlight.
    */
-  static const HighlightRegionType DYNAMIC_LOCAL_VARIABLE_REFERENCE = const HighlightRegionType._("DYNAMIC_LOCAL_VARIABLE_REFERENCE");
+  static const HighlightRegionType DYNAMIC_LOCAL_VARIABLE_REFERENCE =
+      const HighlightRegionType._("DYNAMIC_LOCAL_VARIABLE_REFERENCE");
 
   /**
    * Only for version 2 of highlight.
    */
-  static const HighlightRegionType DYNAMIC_PARAMETER_DECLARATION = const HighlightRegionType._("DYNAMIC_PARAMETER_DECLARATION");
+  static const HighlightRegionType DYNAMIC_PARAMETER_DECLARATION =
+      const HighlightRegionType._("DYNAMIC_PARAMETER_DECLARATION");
 
   /**
    * Only for version 2 of highlight.
    */
-  static const HighlightRegionType DYNAMIC_PARAMETER_REFERENCE = const HighlightRegionType._("DYNAMIC_PARAMETER_REFERENCE");
+  static const HighlightRegionType DYNAMIC_PARAMETER_REFERENCE =
+      const HighlightRegionType._("DYNAMIC_PARAMETER_REFERENCE");
 
   static const HighlightRegionType ENUM = const HighlightRegionType._("ENUM");
 
-  static const HighlightRegionType ENUM_CONSTANT = const HighlightRegionType._("ENUM_CONSTANT");
+  static const HighlightRegionType ENUM_CONSTANT =
+      const HighlightRegionType._("ENUM_CONSTANT");
 
   /**
    * Only for version 1 of highlight.
    */
   static const HighlightRegionType FIELD = const HighlightRegionType._("FIELD");
 
   /**
    * Only for version 1 of highlight.
    */
-  static const HighlightRegionType FIELD_STATIC = const HighlightRegionType._("FIELD_STATIC");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType FUNCTION = const HighlightRegionType._("FUNCTION");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType FUNCTION_DECLARATION = const HighlightRegionType._("FUNCTION_DECLARATION");
-
-  static const HighlightRegionType FUNCTION_TYPE_ALIAS = const HighlightRegionType._("FUNCTION_TYPE_ALIAS");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType GETTER_DECLARATION = const HighlightRegionType._("GETTER_DECLARATION");
-
-  static const HighlightRegionType IDENTIFIER_DEFAULT = const HighlightRegionType._("IDENTIFIER_DEFAULT");
-
-  static const HighlightRegionType IMPORT_PREFIX = const HighlightRegionType._("IMPORT_PREFIX");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType INSTANCE_FIELD_DECLARATION = const HighlightRegionType._("INSTANCE_FIELD_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType INSTANCE_FIELD_REFERENCE = const HighlightRegionType._("INSTANCE_FIELD_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType INSTANCE_GETTER_DECLARATION = const HighlightRegionType._("INSTANCE_GETTER_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType INSTANCE_GETTER_REFERENCE = const HighlightRegionType._("INSTANCE_GETTER_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType INSTANCE_METHOD_DECLARATION = const HighlightRegionType._("INSTANCE_METHOD_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType INSTANCE_METHOD_REFERENCE = const HighlightRegionType._("INSTANCE_METHOD_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType INSTANCE_SETTER_DECLARATION = const HighlightRegionType._("INSTANCE_SETTER_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType INSTANCE_SETTER_REFERENCE = const HighlightRegionType._("INSTANCE_SETTER_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType INVALID_STRING_ESCAPE = const HighlightRegionType._("INVALID_STRING_ESCAPE");
-
-  static const HighlightRegionType KEYWORD = const HighlightRegionType._("KEYWORD");
+  static const HighlightRegionType FIELD_STATIC =
+      const HighlightRegionType._("FIELD_STATIC");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType FUNCTION =
+      const HighlightRegionType._("FUNCTION");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType FUNCTION_DECLARATION =
+      const HighlightRegionType._("FUNCTION_DECLARATION");
+
+  static const HighlightRegionType FUNCTION_TYPE_ALIAS =
+      const HighlightRegionType._("FUNCTION_TYPE_ALIAS");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType GETTER_DECLARATION =
+      const HighlightRegionType._("GETTER_DECLARATION");
+
+  static const HighlightRegionType IDENTIFIER_DEFAULT =
+      const HighlightRegionType._("IDENTIFIER_DEFAULT");
+
+  static const HighlightRegionType IMPORT_PREFIX =
+      const HighlightRegionType._("IMPORT_PREFIX");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType INSTANCE_FIELD_DECLARATION =
+      const HighlightRegionType._("INSTANCE_FIELD_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType INSTANCE_FIELD_REFERENCE =
+      const HighlightRegionType._("INSTANCE_FIELD_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType INSTANCE_GETTER_DECLARATION =
+      const HighlightRegionType._("INSTANCE_GETTER_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType INSTANCE_GETTER_REFERENCE =
+      const HighlightRegionType._("INSTANCE_GETTER_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType INSTANCE_METHOD_DECLARATION =
+      const HighlightRegionType._("INSTANCE_METHOD_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType INSTANCE_METHOD_REFERENCE =
+      const HighlightRegionType._("INSTANCE_METHOD_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType INSTANCE_SETTER_DECLARATION =
+      const HighlightRegionType._("INSTANCE_SETTER_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType INSTANCE_SETTER_REFERENCE =
+      const HighlightRegionType._("INSTANCE_SETTER_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType INVALID_STRING_ESCAPE =
+      const HighlightRegionType._("INVALID_STRING_ESCAPE");
+
+  static const HighlightRegionType KEYWORD =
+      const HighlightRegionType._("KEYWORD");
 
   static const HighlightRegionType LABEL = const HighlightRegionType._("LABEL");
 
   /**
    * Only for version 2 of highlight.
    */
-  static const HighlightRegionType LIBRARY_NAME = const HighlightRegionType._("LIBRARY_NAME");
-
-  static const HighlightRegionType LITERAL_BOOLEAN = const HighlightRegionType._("LITERAL_BOOLEAN");
-
-  static const HighlightRegionType LITERAL_DOUBLE = const HighlightRegionType._("LITERAL_DOUBLE");
-
-  static const HighlightRegionType LITERAL_INTEGER = const HighlightRegionType._("LITERAL_INTEGER");
-
-  static const HighlightRegionType LITERAL_LIST = const HighlightRegionType._("LITERAL_LIST");
-
-  static const HighlightRegionType LITERAL_MAP = const HighlightRegionType._("LITERAL_MAP");
-
-  static const HighlightRegionType LITERAL_STRING = const HighlightRegionType._("LITERAL_STRING");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType LOCAL_FUNCTION_DECLARATION = const HighlightRegionType._("LOCAL_FUNCTION_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType LOCAL_FUNCTION_REFERENCE = const HighlightRegionType._("LOCAL_FUNCTION_REFERENCE");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType LOCAL_VARIABLE = const HighlightRegionType._("LOCAL_VARIABLE");
-
-  static const HighlightRegionType LOCAL_VARIABLE_DECLARATION = const HighlightRegionType._("LOCAL_VARIABLE_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType LOCAL_VARIABLE_REFERENCE = const HighlightRegionType._("LOCAL_VARIABLE_REFERENCE");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType METHOD = const HighlightRegionType._("METHOD");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType METHOD_DECLARATION = const HighlightRegionType._("METHOD_DECLARATION");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType METHOD_DECLARATION_STATIC = const HighlightRegionType._("METHOD_DECLARATION_STATIC");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType METHOD_STATIC = const HighlightRegionType._("METHOD_STATIC");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType PARAMETER = const HighlightRegionType._("PARAMETER");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType SETTER_DECLARATION = const HighlightRegionType._("SETTER_DECLARATION");
-
-  /**
-   * Only for version 1 of highlight.
-   */
-  static const HighlightRegionType TOP_LEVEL_VARIABLE = const HighlightRegionType._("TOP_LEVEL_VARIABLE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType PARAMETER_DECLARATION = const HighlightRegionType._("PARAMETER_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType PARAMETER_REFERENCE = const HighlightRegionType._("PARAMETER_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType STATIC_FIELD_DECLARATION = const HighlightRegionType._("STATIC_FIELD_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType STATIC_GETTER_DECLARATION = const HighlightRegionType._("STATIC_GETTER_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType STATIC_GETTER_REFERENCE = const HighlightRegionType._("STATIC_GETTER_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType STATIC_METHOD_DECLARATION = const HighlightRegionType._("STATIC_METHOD_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType STATIC_METHOD_REFERENCE = const HighlightRegionType._("STATIC_METHOD_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType STATIC_SETTER_DECLARATION = const HighlightRegionType._("STATIC_SETTER_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType STATIC_SETTER_REFERENCE = const HighlightRegionType._("STATIC_SETTER_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType TOP_LEVEL_FUNCTION_DECLARATION = const HighlightRegionType._("TOP_LEVEL_FUNCTION_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType TOP_LEVEL_FUNCTION_REFERENCE = const HighlightRegionType._("TOP_LEVEL_FUNCTION_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType TOP_LEVEL_GETTER_DECLARATION = const HighlightRegionType._("TOP_LEVEL_GETTER_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType TOP_LEVEL_GETTER_REFERENCE = const HighlightRegionType._("TOP_LEVEL_GETTER_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType TOP_LEVEL_SETTER_DECLARATION = const HighlightRegionType._("TOP_LEVEL_SETTER_DECLARATION");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType TOP_LEVEL_SETTER_REFERENCE = const HighlightRegionType._("TOP_LEVEL_SETTER_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType TOP_LEVEL_VARIABLE_DECLARATION = const HighlightRegionType._("TOP_LEVEL_VARIABLE_DECLARATION");
-
-  static const HighlightRegionType TYPE_NAME_DYNAMIC = const HighlightRegionType._("TYPE_NAME_DYNAMIC");
-
-  static const HighlightRegionType TYPE_PARAMETER = const HighlightRegionType._("TYPE_PARAMETER");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType UNRESOLVED_INSTANCE_MEMBER_REFERENCE = const HighlightRegionType._("UNRESOLVED_INSTANCE_MEMBER_REFERENCE");
-
-  /**
-   * Only for version 2 of highlight.
-   */
-  static const HighlightRegionType VALID_STRING_ESCAPE = const HighlightRegionType._("VALID_STRING_ESCAPE");
+  static const HighlightRegionType LIBRARY_NAME =
+      const HighlightRegionType._("LIBRARY_NAME");
+
+  static const HighlightRegionType LITERAL_BOOLEAN =
+      const HighlightRegionType._("LITERAL_BOOLEAN");
+
+  static const HighlightRegionType LITERAL_DOUBLE =
+      const HighlightRegionType._("LITERAL_DOUBLE");
+
+  static const HighlightRegionType LITERAL_INTEGER =
+      const HighlightRegionType._("LITERAL_INTEGER");
+
+  static const HighlightRegionType LITERAL_LIST =
+      const HighlightRegionType._("LITERAL_LIST");
+
+  static const HighlightRegionType LITERAL_MAP =
+      const HighlightRegionType._("LITERAL_MAP");
+
+  static const HighlightRegionType LITERAL_STRING =
+      const HighlightRegionType._("LITERAL_STRING");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType LOCAL_FUNCTION_DECLARATION =
+      const HighlightRegionType._("LOCAL_FUNCTION_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType LOCAL_FUNCTION_REFERENCE =
+      const HighlightRegionType._("LOCAL_FUNCTION_REFERENCE");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType LOCAL_VARIABLE =
+      const HighlightRegionType._("LOCAL_VARIABLE");
+
+  static const HighlightRegionType LOCAL_VARIABLE_DECLARATION =
+      const HighlightRegionType._("LOCAL_VARIABLE_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType LOCAL_VARIABLE_REFERENCE =
+      const HighlightRegionType._("LOCAL_VARIABLE_REFERENCE");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType METHOD =
+      const HighlightRegionType._("METHOD");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType METHOD_DECLARATION =
+      const HighlightRegionType._("METHOD_DECLARATION");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType METHOD_DECLARATION_STATIC =
+      const HighlightRegionType._("METHOD_DECLARATION_STATIC");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType METHOD_STATIC =
+      const HighlightRegionType._("METHOD_STATIC");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType PARAMETER =
+      const HighlightRegionType._("PARAMETER");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType SETTER_DECLARATION =
+      const HighlightRegionType._("SETTER_DECLARATION");
+
+  /**
+   * Only for version 1 of highlight.
+   */
+  static const HighlightRegionType TOP_LEVEL_VARIABLE =
+      const HighlightRegionType._("TOP_LEVEL_VARIABLE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType PARAMETER_DECLARATION =
+      const HighlightRegionType._("PARAMETER_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType PARAMETER_REFERENCE =
+      const HighlightRegionType._("PARAMETER_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType STATIC_FIELD_DECLARATION =
+      const HighlightRegionType._("STATIC_FIELD_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType STATIC_GETTER_DECLARATION =
+      const HighlightRegionType._("STATIC_GETTER_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType STATIC_GETTER_REFERENCE =
+      const HighlightRegionType._("STATIC_GETTER_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType STATIC_METHOD_DECLARATION =
+      const HighlightRegionType._("STATIC_METHOD_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType STATIC_METHOD_REFERENCE =
+      const HighlightRegionType._("STATIC_METHOD_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType STATIC_SETTER_DECLARATION =
+      const HighlightRegionType._("STATIC_SETTER_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType STATIC_SETTER_REFERENCE =
+      const HighlightRegionType._("STATIC_SETTER_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType TOP_LEVEL_FUNCTION_DECLARATION =
+      const HighlightRegionType._("TOP_LEVEL_FUNCTION_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType TOP_LEVEL_FUNCTION_REFERENCE =
+      const HighlightRegionType._("TOP_LEVEL_FUNCTION_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType TOP_LEVEL_GETTER_DECLARATION =
+      const HighlightRegionType._("TOP_LEVEL_GETTER_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType TOP_LEVEL_GETTER_REFERENCE =
+      const HighlightRegionType._("TOP_LEVEL_GETTER_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType TOP_LEVEL_SETTER_DECLARATION =
+      const HighlightRegionType._("TOP_LEVEL_SETTER_DECLARATION");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType TOP_LEVEL_SETTER_REFERENCE =
+      const HighlightRegionType._("TOP_LEVEL_SETTER_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType TOP_LEVEL_VARIABLE_DECLARATION =
+      const HighlightRegionType._("TOP_LEVEL_VARIABLE_DECLARATION");
+
+  static const HighlightRegionType TYPE_NAME_DYNAMIC =
+      const HighlightRegionType._("TYPE_NAME_DYNAMIC");
+
+  static const HighlightRegionType TYPE_PARAMETER =
+      const HighlightRegionType._("TYPE_PARAMETER");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType UNRESOLVED_INSTANCE_MEMBER_REFERENCE =
+      const HighlightRegionType._("UNRESOLVED_INSTANCE_MEMBER_REFERENCE");
+
+  /**
+   * Only for version 2 of highlight.
+   */
+  static const HighlightRegionType VALID_STRING_ESCAPE =
+      const HighlightRegionType._("VALID_STRING_ESCAPE");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<HighlightRegionType> VALUES = const <HighlightRegionType>[ANNOTATION, BUILT_IN, CLASS, COMMENT_BLOCK, COMMENT_DOCUMENTATION, COMMENT_END_OF_LINE, CONSTRUCTOR, DIRECTIVE, DYNAMIC_TYPE, DYNAMIC_LOCAL_VARIABLE_DECLARATION, DYNAMIC_LOCAL_VARIABLE_REFERENCE, DYNAMIC_PARAMETER_DECLARATION, DYNAMIC_PARAMETER_REFERENCE, ENUM, ENUM_CONSTANT, FIELD, FIELD_STATIC, FUNCTION, FUNCTION_DECLARATION, FUNCTION_TYPE_ALIAS, GETTER_DECLARATION, IDENTIFIER_DEFAULT, IMPORT_PREFIX, INSTANCE_FIELD_DECLARATION, INSTANCE_FIELD_REFERENCE, INSTANCE_GETTER_DECLARATION, INSTANCE_GETTER_REFERENCE, INSTANCE_METHOD_DECLARATION, INSTANCE_METHOD_REFERENCE, INSTANCE_SETTER_DECLARATION, INSTANCE_SETTER_REFERENCE, INVALID_STRING_ESCAPE, KEYWORD, LABEL, LIBRARY_NAME, LITERAL_BOOLEAN, LITERAL_DOUBLE, LITERAL_INTEGER, LITERAL_LIST, LITERAL_MAP, LITERAL_STRING, LOCAL_FUNCTION_DECLARATION, LOCAL_FUNCTION_REFERENCE, LOCAL_VARIABLE, LOCAL_VARIABLE_DECLARATION, LOCAL_VARIABLE_REFERENCE, METHOD, METHOD_DECLARATION, METHOD_DECLARATION_STATIC, METHOD_STATIC, PARAMETER, SETTER_DECLARATION, TOP_LEVEL_VARIABLE, PARAMETER_DECLARATION, PARAMETER_REFERENCE, STATIC_FIELD_DECLARATION, STATIC_GETTER_DECLARATION, STATIC_GETTER_REFERENCE, STATIC_METHOD_DECLARATION, STATIC_METHOD_REFERENCE, STATIC_SETTER_DECLARATION, STATIC_SETTER_REFERENCE, TOP_LEVEL_FUNCTION_DECLARATION, TOP_LEVEL_FUNCTION_REFERENCE, TOP_LEVEL_GETTER_DECLARATION, TOP_LEVEL_GETTER_REFERENCE, TOP_LEVEL_SETTER_DECLARATION, TOP_LEVEL_SETTER_REFERENCE, TOP_LEVEL_VARIABLE_DECLARATION, TYPE_NAME_DYNAMIC, TYPE_PARAMETER, UNRESOLVED_INSTANCE_MEMBER_REFERENCE, VALID_STRING_ESCAPE];
+  static const List<HighlightRegionType> VALUES = const <HighlightRegionType>[
+    ANNOTATION,
+    BUILT_IN,
+    CLASS,
+    COMMENT_BLOCK,
+    COMMENT_DOCUMENTATION,
+    COMMENT_END_OF_LINE,
+    CONSTRUCTOR,
+    DIRECTIVE,
+    DYNAMIC_TYPE,
+    DYNAMIC_LOCAL_VARIABLE_DECLARATION,
+    DYNAMIC_LOCAL_VARIABLE_REFERENCE,
+    DYNAMIC_PARAMETER_DECLARATION,
+    DYNAMIC_PARAMETER_REFERENCE,
+    ENUM,
+    ENUM_CONSTANT,
+    FIELD,
+    FIELD_STATIC,
+    FUNCTION,
+    FUNCTION_DECLARATION,
+    FUNCTION_TYPE_ALIAS,
+    GETTER_DECLARATION,
+    IDENTIFIER_DEFAULT,
+    IMPORT_PREFIX,
+    INSTANCE_FIELD_DECLARATION,
+    INSTANCE_FIELD_REFERENCE,
+    INSTANCE_GETTER_DECLARATION,
+    INSTANCE_GETTER_REFERENCE,
+    INSTANCE_METHOD_DECLARATION,
+    INSTANCE_METHOD_REFERENCE,
+    INSTANCE_SETTER_DECLARATION,
+    INSTANCE_SETTER_REFERENCE,
+    INVALID_STRING_ESCAPE,
+    KEYWORD,
+    LABEL,
+    LIBRARY_NAME,
+    LITERAL_BOOLEAN,
+    LITERAL_DOUBLE,
+    LITERAL_INTEGER,
+    LITERAL_LIST,
+    LITERAL_MAP,
+    LITERAL_STRING,
+    LOCAL_FUNCTION_DECLARATION,
+    LOCAL_FUNCTION_REFERENCE,
+    LOCAL_VARIABLE,
+    LOCAL_VARIABLE_DECLARATION,
+    LOCAL_VARIABLE_REFERENCE,
+    METHOD,
+    METHOD_DECLARATION,
+    METHOD_DECLARATION_STATIC,
+    METHOD_STATIC,
+    PARAMETER,
+    SETTER_DECLARATION,
+    TOP_LEVEL_VARIABLE,
+    PARAMETER_DECLARATION,
+    PARAMETER_REFERENCE,
+    STATIC_FIELD_DECLARATION,
+    STATIC_GETTER_DECLARATION,
+    STATIC_GETTER_REFERENCE,
+    STATIC_METHOD_DECLARATION,
+    STATIC_METHOD_REFERENCE,
+    STATIC_SETTER_DECLARATION,
+    STATIC_SETTER_REFERENCE,
+    TOP_LEVEL_FUNCTION_DECLARATION,
+    TOP_LEVEL_FUNCTION_REFERENCE,
+    TOP_LEVEL_GETTER_DECLARATION,
+    TOP_LEVEL_GETTER_REFERENCE,
+    TOP_LEVEL_SETTER_DECLARATION,
+    TOP_LEVEL_SETTER_REFERENCE,
+    TOP_LEVEL_VARIABLE_DECLARATION,
+    TYPE_NAME_DYNAMIC,
+    TYPE_PARAMETER,
+    UNRESOLVED_INSTANCE_MEMBER_REFERENCE,
+    VALID_STRING_ESCAPE
+  ];
 
   @override
   final String name;
 
   const HighlightRegionType._(this.name);
 
   factory HighlightRegionType(String name) {
     switch (name) {
       case "ANNOTATION":
         return ANNOTATION;
@@ skipping 138 matching lines @@
       case "TYPE_PARAMETER":
         return TYPE_PARAMETER;
       case "UNRESOLVED_INSTANCE_MEMBER_REFERENCE":
         return UNRESOLVED_INSTANCE_MEMBER_REFERENCE;
       case "VALID_STRING_ESCAPE":
         return VALID_STRING_ESCAPE;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory HighlightRegionType.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory HighlightRegionType.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new HighlightRegionType(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "HighlightRegionType", json);
   }
 
   @override
   String toString() => "HighlightRegionType.$name";
 
   String toJson() => name;
@@ skipping 38 matching lines @@
   void set occurrences(int value) {
     assert(value != null);
     this._occurrences = value;
   }
 
   InlineLocalVariableFeedback(String name, int occurrences) {
     this.name = name;
     this.occurrences = occurrences;
   }
 
-  factory InlineLocalVariableFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory InlineLocalVariableFeedback.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "name");
       }
       int occurrences;
       if (json.containsKey("occurrences")) {
-        occurrences = jsonDecoder.decodeInt(jsonPath + ".occurrences", json["occurrences"]);
+        occurrences = jsonDecoder.decodeInt(
+            jsonPath + ".occurrences", json["occurrences"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "occurrences");
       }
       return new InlineLocalVariableFeedback(name, occurrences);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "inlineLocalVariable feedback", json);
+      throw jsonDecoder.mismatch(
+          jsonPath, "inlineLocalVariable feedback", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["name"] = name;
     result["occurrences"] = occurrences;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is InlineLocalVariableFeedback) {
-      return name == other.name &&
-          occurrences == other.occurrences;
+      return name == other.name && occurrences == other.occurrences;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, name.hashCode);
     hash = JenkinsSmiHash.combine(hash, occurrences.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * inlineLocalVariable options
  *
  * Clients may not extend, implement or mix-in this class.
  */
-class InlineLocalVariableOptions extends RefactoringOptions implements HasToJson {
+class InlineLocalVariableOptions extends RefactoringOptions
+    implements HasToJson {
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is InlineLocalVariableOptions) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 540364977;
   }
@@ skipping 52 matching lines @@
 
   /**
    * True if the declaration of the method is selected and all references
    * should be inlined.
    */
   void set isDeclaration(bool value) {
     assert(value != null);
     this._isDeclaration = value;
   }
 
-  InlineMethodFeedback(String methodName, bool isDeclaration, {String className}) {
+  InlineMethodFeedback(String methodName, bool isDeclaration,
+      {String className}) {
     this.className = className;
     this.methodName = methodName;
     this.isDeclaration = isDeclaration;
   }
 
-  factory InlineMethodFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory InlineMethodFeedback.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String className;
       if (json.containsKey("className")) {
-        className = jsonDecoder.decodeString(jsonPath + ".className", json["className"]);
+        className = jsonDecoder.decodeString(
+            jsonPath + ".className", json["className"]);
       }
       String methodName;
       if (json.containsKey("methodName")) {
-        methodName = jsonDecoder.decodeString(jsonPath + ".methodName", json["methodName"]);
+        methodName = jsonDecoder.decodeString(
+            jsonPath + ".methodName", json["methodName"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "methodName");
       }
       bool isDeclaration;
       if (json.containsKey("isDeclaration")) {
-        isDeclaration = jsonDecoder.decodeBool(jsonPath + ".isDeclaration", json["isDeclaration"]);
+        isDeclaration = jsonDecoder.decodeBool(
+            jsonPath + ".isDeclaration", json["isDeclaration"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "isDeclaration");
       }
-      return new InlineMethodFeedback(methodName, isDeclaration, className: className);
+      return new InlineMethodFeedback(methodName, isDeclaration,
+          className: className);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "inlineMethod feedback", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (className != null) {
       result["className"] = className;
     }
     result["methodName"] = methodName;
     result["isDeclaration"] = isDeclaration;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is InlineMethodFeedback) {
       return className == other.className &&
           methodName == other.methodName &&
           isDeclaration == other.isDeclaration;
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 48 matching lines @@
   void set inlineAll(bool value) {
     assert(value != null);
     this._inlineAll = value;
   }
 
   InlineMethodOptions(bool deleteSource, bool inlineAll) {
     this.deleteSource = deleteSource;
     this.inlineAll = inlineAll;
   }
 
-  factory InlineMethodOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory InlineMethodOptions.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       bool deleteSource;
       if (json.containsKey("deleteSource")) {
-        deleteSource = jsonDecoder.decodeBool(jsonPath + ".deleteSource", json["deleteSource"]);
+        deleteSource = jsonDecoder.decodeBool(
+            jsonPath + ".deleteSource", json["deleteSource"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "deleteSource");
       }
       bool inlineAll;
       if (json.containsKey("inlineAll")) {
-        inlineAll = jsonDecoder.decodeBool(jsonPath + ".inlineAll", json["inlineAll"]);
+        inlineAll =
+            jsonDecoder.decodeBool(jsonPath + ".inlineAll", json["inlineAll"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "inlineAll");
       }
       return new InlineMethodOptions(deleteSource, inlineAll);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "inlineMethod options", json);
     }
   }
 
-  factory InlineMethodOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
+  factory InlineMethodOptions.fromRefactoringParams(
+      EditGetRefactoringParams refactoringParams, Request request) {
     return new InlineMethodOptions.fromJson(
         new RequestDecoder(request), "options", refactoringParams.options);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["deleteSource"] = deleteSource;
     result["inlineAll"] = inlineAll;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is InlineMethodOptions) {
-      return deleteSource == other.deleteSource &&
-          inlineAll == other.inlineAll;
+      return deleteSource == other.deleteSource && inlineAll == other.inlineAll;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, deleteSource.hashCode);
     hash = JenkinsSmiHash.combine(hash, inlineAll.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 52 matching lines @@
 
   /**
    * Pre-computed suggestions for what every region might want to be changed
    * to.
    */
   void set suggestions(List<LinkedEditSuggestion> value) {
     assert(value != null);
     this._suggestions = value;
   }
 
-  LinkedEditGroup(List<Position> positions, int length, List<LinkedEditSuggestion> suggestions) {
+  LinkedEditGroup(List<Position> positions, int length,
+      List<LinkedEditSuggestion> suggestions) {
     this.positions = positions;
     this.length = length;
     this.suggestions = suggestions;
   }
 
-  factory LinkedEditGroup.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory LinkedEditGroup.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<Position> positions;
       if (json.containsKey("positions")) {
-        positions = jsonDecoder.decodeList(jsonPath + ".positions", json["positions"], (String jsonPath, Object json) => new Position.fromJson(jsonDecoder, jsonPath, json));
+        positions = jsonDecoder.decodeList(
+            jsonPath + ".positions",
+            json["positions"],
+            (String jsonPath, Object json) =>
+                new Position.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "positions");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       List<LinkedEditSuggestion> suggestions;
       if (json.containsKey("suggestions")) {
-        suggestions = jsonDecoder.decodeList(jsonPath + ".suggestions", json["suggestions"], (String jsonPath, Object json) => new LinkedEditSuggestion.fromJson(jsonDecoder, jsonPath, json));
+        suggestions = jsonDecoder.decodeList(
+            jsonPath + ".suggestions",
+            json["suggestions"],
+            (String jsonPath, Object json) =>
+                new LinkedEditSuggestion.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "suggestions");
       }
       return new LinkedEditGroup(positions, length, suggestions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "LinkedEditGroup", json);
     }
   }
 
   /**
    * Construct an empty LinkedEditGroup.
    */
   LinkedEditGroup.empty() : this(<Position>[], 0, <LinkedEditSuggestion>[]);
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["positions"] = positions.map((Position value) => value.toJson()).toList();
+    result["positions"] =
+        positions.map((Position value) => value.toJson()).toList();
     result["length"] = length;
-    result["suggestions"] = suggestions.map((LinkedEditSuggestion value) => value.toJson()).toList();
+    result["suggestions"] = suggestions
+        .map((LinkedEditSuggestion value) => value.toJson())
+        .toList();
     return result;
   }
 
   /**
    * Add a new position and change the length.
    */
   void addPosition(Position position, int length) {
     positions.add(position);
     this.length = length;
   }
 
   /**
    * Add a new suggestion.
    */
   void addSuggestion(LinkedEditSuggestion suggestion) {
     suggestions.add(suggestion);
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is LinkedEditGroup) {
-      return listEqual(positions, other.positions, (Position a, Position b) => a == b) &&
+      return listEqual(
+              positions, other.positions, (Position a, Position b) => a == b) &&
           length == other.length &&
-          listEqual(suggestions, other.suggestions, (LinkedEditSuggestion a, LinkedEditSuggestion b) => a == b);
+          listEqual(suggestions, other.suggestions,
+              (LinkedEditSuggestion a, LinkedEditSuggestion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, positions.hashCode);
     hash = JenkinsSmiHash.combine(hash, length.hashCode);
     hash = JenkinsSmiHash.combine(hash, suggestions.hashCode);
@@ skipping 40 matching lines @@
   void set kind(LinkedEditSuggestionKind value) {
     assert(value != null);
     this._kind = value;
   }
 
   LinkedEditSuggestion(String value, LinkedEditSuggestionKind kind) {
     this.value = value;
     this.kind = kind;
   }
 
-  factory LinkedEditSuggestion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory LinkedEditSuggestion.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String value;
       if (json.containsKey("value")) {
         value = jsonDecoder.decodeString(jsonPath + ".value", json["value"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "value");
       }
       LinkedEditSuggestionKind kind;
       if (json.containsKey("kind")) {
-        kind = new LinkedEditSuggestionKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
+        kind = new LinkedEditSuggestionKind.fromJson(
+            jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "kind");
       }
       return new LinkedEditSuggestion(value, kind);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "LinkedEditSuggestion", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["value"] = value;
     result["kind"] = kind.toJson();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is LinkedEditSuggestion) {
-      return value == other.value &&
-          kind == other.kind;
+      return value == other.value && kind == other.kind;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, value.hashCode);
     hash = JenkinsSmiHash.combine(hash, kind.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * LinkedEditSuggestionKind
  *
  * enum {
  *   METHOD
  *   PARAMETER
  *   TYPE
  *   VARIABLE
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class LinkedEditSuggestionKind implements Enum {
-  static const LinkedEditSuggestionKind METHOD = const LinkedEditSuggestionKind._("METHOD");
+  static const LinkedEditSuggestionKind METHOD =
+      const LinkedEditSuggestionKind._("METHOD");
 
-  static const LinkedEditSuggestionKind PARAMETER = const LinkedEditSuggestionKind._("PARAMETER");
+  static const LinkedEditSuggestionKind PARAMETER =
+      const LinkedEditSuggestionKind._("PARAMETER");
 
-  static const LinkedEditSuggestionKind TYPE = const LinkedEditSuggestionKind._("TYPE");
+  static const LinkedEditSuggestionKind TYPE =
+      const LinkedEditSuggestionKind._("TYPE");
 
-  static const LinkedEditSuggestionKind VARIABLE = const LinkedEditSuggestionKind._("VARIABLE");
+  static const LinkedEditSuggestionKind VARIABLE =
+      const LinkedEditSuggestionKind._("VARIABLE");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<LinkedEditSuggestionKind> VALUES = const <LinkedEditSuggestionKind>[METHOD, PARAMETER, TYPE, VARIABLE];
+  static const List<LinkedEditSuggestionKind> VALUES =
+      const <LinkedEditSuggestionKind>[METHOD, PARAMETER, TYPE, VARIABLE];
 
   @override
   final String name;
 
   const LinkedEditSuggestionKind._(this.name);
 
   factory LinkedEditSuggestionKind(String name) {
     switch (name) {
       case "METHOD":
         return METHOD;
       case "PARAMETER":
         return PARAMETER;
       case "TYPE":
         return TYPE;
       case "VARIABLE":
         return VARIABLE;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory LinkedEditSuggestionKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory LinkedEditSuggestionKind.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new LinkedEditSuggestionKind(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "LinkedEditSuggestionKind", json);
   }
 
   @override
   String toString() => "LinkedEditSuggestionKind.$name";
 
   String toJson() => name;
@@ skipping 85 matching lines @@
 
   /**
    * The one-based index of the column containing the first character of the
    * range.
    */
   void set startColumn(int value) {
     assert(value != null);
     this._startColumn = value;
   }
 
-  Location(String file, int offset, int length, int startLine, int startColumn) {
+  Location(
+      String file, int offset, int length, int startLine, int startColumn) {
     this.file = file;
     this.offset = offset;
     this.length = length;
     this.startLine = startLine;
     this.startColumn = startColumn;
   }
 
-  factory Location.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory Location.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       int startLine;
       if (json.containsKey("startLine")) {
-        startLine = jsonDecoder.decodeInt(jsonPath + ".startLine", json["startLine"]);
+        startLine =
+            jsonDecoder.decodeInt(jsonPath + ".startLine", json["startLine"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "startLine");
       }
       int startColumn;
       if (json.containsKey("startColumn")) {
-        startColumn = jsonDecoder.decodeInt(jsonPath + ".startColumn", json["startColumn"]);
+        startColumn = jsonDecoder.decodeInt(
+            jsonPath + ".startColumn", json["startColumn"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "startColumn");
       }
       return new Location(file, offset, length, startLine, startColumn);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Location", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     result["length"] = length;
     result["startLine"] = startLine;
     result["startColumn"] = startColumn;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is Location) {
       return file == other.file &&
           offset == other.offset &&
           length == other.length &&
           startLine == other.startLine &&
           startColumn == other.startColumn;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, file.hashCode);
     hash = JenkinsSmiHash.combine(hash, offset.hashCode);
     hash = JenkinsSmiHash.combine(hash, length.hashCode);
     hash = JenkinsSmiHash.combine(hash, startLine.hashCode);
     hash = JenkinsSmiHash.combine(hash, startColumn.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * moveFile feedback
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class MoveFileFeedback extends RefactoringFeedback implements HasToJson {
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is MoveFileFeedback) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 438975893;
   }
@@ skipping 21 matching lines @@
    */
   void set newFile(String value) {
     assert(value != null);
     this._newFile = value;
   }
 
   MoveFileOptions(String newFile) {
     this.newFile = newFile;
   }
 
-  factory MoveFileOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory MoveFileOptions.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String newFile;
       if (json.containsKey("newFile")) {
-        newFile = jsonDecoder.decodeString(jsonPath + ".newFile", json["newFile"]);
+        newFile =
+            jsonDecoder.decodeString(jsonPath + ".newFile", json["newFile"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "newFile");
       }
       return new MoveFileOptions(newFile);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "moveFile options", json);
     }
   }
 
-  factory MoveFileOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
+  factory MoveFileOptions.fromRefactoringParams(
+      EditGetRefactoringParams refactoringParams, Request request) {
     return new MoveFileOptions.fromJson(
         new RequestDecoder(request), "options", refactoringParams.options);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["newFile"] = newFile;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is MoveFileOptions) {
       return newFile == other.newFile;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, newFile.hashCode);
@@ skipping 61 matching lines @@
     assert(value != null);
     this._targets = value;
   }
 
   NavigationRegion(int offset, int length, List<int> targets) {
     this.offset = offset;
     this.length = length;
     this.targets = targets;
   }
 
-  factory NavigationRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory NavigationRegion.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       List<int> targets;
       if (json.containsKey("targets")) {
-        targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], jsonDecoder.decodeInt);
+        targets = jsonDecoder.decodeList(
+            jsonPath + ".targets", json["targets"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "targets");
       }
       return new NavigationRegion(offset, length, targets);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "NavigationRegion", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     result["targets"] = targets;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is NavigationRegion) {
       return offset == other.offset &&
           length == other.length &&
           listEqual(targets, other.targets, (int a, int b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 109 matching lines @@
 
   /**
    * The one-based index of the column containing the first character of the
    * region.
    */
   void set startColumn(int value) {
     assert(value != null);
     this._startColumn = value;
   }
 
-  NavigationTarget(ElementKind kind, int fileIndex, int offset, int length, int startLine, int startColumn) {
+  NavigationTarget(ElementKind kind, int fileIndex, int offset, int length,
+      int startLine, int startColumn) {
     this.kind = kind;
     this.fileIndex = fileIndex;
     this.offset = offset;
     this.length = length;
     this.startLine = startLine;
     this.startColumn = startColumn;
   }
 
-  factory NavigationTarget.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory NavigationTarget.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       ElementKind kind;
       if (json.containsKey("kind")) {
-        kind = new ElementKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
+        kind = new ElementKind.fromJson(
+            jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "kind");
       }
       int fileIndex;
       if (json.containsKey("fileIndex")) {
-        fileIndex = jsonDecoder.decodeInt(jsonPath + ".fileIndex", json["fileIndex"]);
+        fileIndex =
+            jsonDecoder.decodeInt(jsonPath + ".fileIndex", json["fileIndex"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "fileIndex");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       int startLine;
       if (json.containsKey("startLine")) {
-        startLine = jsonDecoder.decodeInt(jsonPath + ".startLine", json["startLine"]);
+        startLine =
+            jsonDecoder.decodeInt(jsonPath + ".startLine", json["startLine"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "startLine");
       }
       int startColumn;
       if (json.containsKey("startColumn")) {
-        startColumn = jsonDecoder.decodeInt(jsonPath + ".startColumn", json["startColumn"]);
+        startColumn = jsonDecoder.decodeInt(
+            jsonPath + ".startColumn", json["startColumn"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "startColumn");
       }
-      return new NavigationTarget(kind, fileIndex, offset, length, startLine, startColumn);
+      return new NavigationTarget(
+          kind, fileIndex, offset, length, startLine, startColumn);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "NavigationTarget", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["kind"] = kind.toJson();
     result["fileIndex"] = fileIndex;
     result["offset"] = offset;
     result["length"] = length;
     result["startLine"] = startLine;
     result["startColumn"] = startColumn;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is NavigationTarget) {
       return kind == other.kind &&
           fileIndex == other.fileIndex &&
           offset == other.offset &&
           length == other.length &&
           startLine == other.startLine &&
           startColumn == other.startColumn;
     }
     return false;
   }
@@ skipping 67 matching lines @@
     assert(value != null);
     this._length = value;
   }
 
   Occurrences(Element element, List<int> offsets, int length) {
     this.element = element;
     this.offsets = offsets;
     this.length = length;
   }
 
-  factory Occurrences.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory Occurrences.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       Element element;
       if (json.containsKey("element")) {
-        element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
+        element = new Element.fromJson(
+            jsonDecoder, jsonPath + ".element", json["element"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "element");
       }
       List<int> offsets;
       if (json.containsKey("offsets")) {
-        offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt);
+        offsets = jsonDecoder.decodeList(
+            jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offsets");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       return new Occurrences(element, offsets, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Occurrences", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["element"] = element.toJson();
     result["offsets"] = offsets;
     result["length"] = length;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is Occurrences) {
       return element == other.element &&
           listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
           length == other.length;
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 85 matching lines @@
     this._children = value;
   }
 
   Outline(Element element, int offset, int length, {List<Outline> children}) {
     this.element = element;
     this.offset = offset;
     this.length = length;
     this.children = children;
   }
 
-  factory Outline.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory Outline.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       Element element;
       if (json.containsKey("element")) {
-        element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
+        element = new Element.fromJson(
+            jsonDecoder, jsonPath + ".element", json["element"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "element");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       List<Outline> children;
       if (json.containsKey("children")) {
-        children = jsonDecoder.decodeList(jsonPath + ".children", json["children"], (String jsonPath, Object json) => new Outline.fromJson(jsonDecoder, jsonPath, json));
+        children = jsonDecoder.decodeList(
+            jsonPath + ".children",
+            json["children"],
+            (String jsonPath, Object json) =>
+                new Outline.fromJson(jsonDecoder, jsonPath, json));
       }
       return new Outline(element, offset, length, children: children);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Outline", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["element"] = element.toJson();
     result["offset"] = offset;
     result["length"] = length;
     if (children != null) {
-      result["children"] = children.map((Outline value) => value.toJson()).toList();
+      result["children"] =
+          children.map((Outline value) => value.toJson()).toList();
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is Outline) {
       return element == other.element &&
           offset == other.offset &&
           length == other.length &&
           listEqual(children, other.children, (Outline a, Outline b) => a == b);
     }
     return false;
   }
 
   @override
@@ skipping 71 matching lines @@
     assert(value != null);
     this._stackTrace = value;
   }
 
   PluginErrorParams(bool isFatal, String message, String stackTrace) {
     this.isFatal = isFatal;
     this.message = message;
     this.stackTrace = stackTrace;
   }
 
-  factory PluginErrorParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory PluginErrorParams.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       bool isFatal;
       if (json.containsKey("isFatal")) {
-        isFatal = jsonDecoder.decodeBool(jsonPath + ".isFatal", json["isFatal"]);
+        isFatal =
+            jsonDecoder.decodeBool(jsonPath + ".isFatal", json["isFatal"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "isFatal");
       }
       String message;
       if (json.containsKey("message")) {
-        message = jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
+        message =
+            jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "message");
       }
       String stackTrace;
       if (json.containsKey("stackTrace")) {
-        stackTrace = jsonDecoder.decodeString(jsonPath + ".stackTrace", json["stackTrace"]);
+        stackTrace = jsonDecoder.decodeString(
+            jsonPath + ".stackTrace", json["stackTrace"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "stackTrace");
       }
       return new PluginErrorParams(isFatal, message, stackTrace);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "plugin.error params", json);
     }
   }
 
   factory PluginErrorParams.fromNotification(Notification notification) {
@@ skipping 11 matching lines @@
   }
 
   Notification toNotification() {
     return new Notification("plugin.error", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is PluginErrorParams) {
       return isFatal == other.isFatal &&
           message == other.message &&
           stackTrace == other.stackTrace;
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 13 matching lines @@
 class PluginShutdownParams implements RequestParams {
   @override
   Map<String, dynamic> toJson() => <String, dynamic>{};
 
   @override
   Request toRequest(String id) {
     return new Request(id, "plugin.shutdown", null);
   }
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is PluginShutdownParams) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 478064585;
   }
 }
 
 /**
  * plugin.shutdown result
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class PluginShutdownResult implements ResponseResult {
   @override
   Map<String, dynamic> toJson() => <String, dynamic>{};
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: null);
   }
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is PluginShutdownResult) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     return 9389109;
   }
@@ skipping 42 matching lines @@
   void set version(String value) {
     assert(value != null);
     this._version = value;
   }
 
   PluginVersionCheckParams(String byteStorePath, String version) {
     this.byteStorePath = byteStorePath;
     this.version = version;
   }
 
-  factory PluginVersionCheckParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory PluginVersionCheckParams.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String byteStorePath;
       if (json.containsKey("byteStorePath")) {
-        byteStorePath = jsonDecoder.decodeString(jsonPath + ".byteStorePath", json["byteStorePath"]);
+        byteStorePath = jsonDecoder.decodeString(
+            jsonPath + ".byteStorePath", json["byteStorePath"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "byteStorePath");
       }
       String version;
       if (json.containsKey("version")) {
-        version = jsonDecoder.decodeString(jsonPath + ".version", json["version"]);
+        version =
+            jsonDecoder.decodeString(jsonPath + ".version", json["version"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "version");
       }
       return new PluginVersionCheckParams(byteStorePath, version);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "plugin.versionCheck params", json);
     }
   }
 
   factory PluginVersionCheckParams.fromRequest(Request request) {
@@ skipping 11 matching lines @@
 
   @override
   Request toRequest(String id) {
     return new Request(id, "plugin.versionCheck", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is PluginVersionCheckParams) {
-      return byteStorePath == other.byteStorePath &&
-          version == other.version;
+      return byteStorePath == other.byteStorePath && version == other.version;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, byteStorePath.hashCode);
     hash = JenkinsSmiHash.combine(hash, version.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 97 matching lines @@
    * The glob patterns of the files for which the plugin will provide
    * information. This value is ignored if the isCompatible field is false.
    * Otherwise, it will be used to identify the files for which the plugin
    * should be notified of changes.
    */
   void set interestingFiles(List<String> value) {
     assert(value != null);
     this._interestingFiles = value;
   }
 
-  PluginVersionCheckResult(bool isCompatible, String name, String version, List<String> interestingFiles, {String contactInfo}) {
+  PluginVersionCheckResult(bool isCompatible, String name, String version,
+      List<String> interestingFiles,
+      {String contactInfo}) {
     this.isCompatible = isCompatible;
     this.name = name;
     this.version = version;
     this.contactInfo = contactInfo;
     this.interestingFiles = interestingFiles;
   }
 
-  factory PluginVersionCheckResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory PluginVersionCheckResult.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       bool isCompatible;
       if (json.containsKey("isCompatible")) {
-        isCompatible = jsonDecoder.decodeBool(jsonPath + ".isCompatible", json["isCompatible"]);
+        isCompatible = jsonDecoder.decodeBool(
+            jsonPath + ".isCompatible", json["isCompatible"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "isCompatible");
       }
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "name");
       }
       String version;
       if (json.containsKey("version")) {
-        version = jsonDecoder.decodeString(jsonPath + ".version", json["version"]);
+        version =
+            jsonDecoder.decodeString(jsonPath + ".version", json["version"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "version");
       }
       String contactInfo;
       if (json.containsKey("contactInfo")) {
-        contactInfo = jsonDecoder.decodeString(jsonPath + ".contactInfo", json["contactInfo"]);
+        contactInfo = jsonDecoder.decodeString(
+            jsonPath + ".contactInfo", json["contactInfo"]);
       }
       List<String> interestingFiles;
       if (json.containsKey("interestingFiles")) {
-        interestingFiles = jsonDecoder.decodeList(jsonPath + ".interestingFiles", json["interestingFiles"], jsonDecoder.decodeString);
+        interestingFiles = jsonDecoder.decodeList(
+            jsonPath + ".interestingFiles",
+            json["interestingFiles"],
+            jsonDecoder.decodeString);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "interestingFiles");
       }
-      return new PluginVersionCheckResult(isCompatible, name, version, interestingFiles, contactInfo: contactInfo);
+      return new PluginVersionCheckResult(
+          isCompatible, name, version, interestingFiles,
+          contactInfo: contactInfo);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "plugin.versionCheck result", json);
     }
   }
 
   factory PluginVersionCheckResult.fromResponse(Response response) {
     return new PluginVersionCheckResult.fromJson(
-        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response.result);
+        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)),
+        "result",
+        response.result);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["isCompatible"] = isCompatible;
     result["name"] = name;
     result["version"] = version;
     if (contactInfo != null) {
       result["contactInfo"] = contactInfo;
     }
     result["interestingFiles"] = interestingFiles;
     return result;
   }
 
   @override
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is PluginVersionCheckResult) {
       return isCompatible == other.isCompatible &&
           name == other.name &&
           version == other.version &&
           contactInfo == other.contactInfo &&
-          listEqual(interestingFiles, other.interestingFiles, (String a, String b) => a == b);
+          listEqual(interestingFiles, other.interestingFiles,
+              (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, isCompatible.hashCode);
     hash = JenkinsSmiHash.combine(hash, name.hashCode);
     hash = JenkinsSmiHash.combine(hash, version.hashCode);
@@ skipping 42 matching lines @@
   void set offset(int value) {
     assert(value != null);
     this._offset = value;
   }
 
   Position(String file, int offset) {
     this.file = file;
     this.offset = offset;
   }
 
-  factory Position.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory Position.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
@@ skipping 14 matching lines @@
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is Position) {
-      return file == other.file &&
-          offset == other.offset;
+      return file == other.file && offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, file.hashCode);
     hash = JenkinsSmiHash.combine(hash, offset.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 41 matching lines @@
   void set change(SourceChange value) {
     assert(value != null);
     this._change = value;
   }
 
   PrioritizedSourceChange(int priority, SourceChange change) {
     this.priority = priority;
     this.change = change;
   }
 
-  factory PrioritizedSourceChange.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory PrioritizedSourceChange.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int priority;
       if (json.containsKey("priority")) {
-        priority = jsonDecoder.decodeInt(jsonPath + ".priority", json["priority"]);
+        priority =
+            jsonDecoder.decodeInt(jsonPath + ".priority", json["priority"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "priority");
       }
       SourceChange change;
       if (json.containsKey("change")) {
-        change = new SourceChange.fromJson(jsonDecoder, jsonPath + ".change", json["change"]);
+        change = new SourceChange.fromJson(
+            jsonDecoder, jsonPath + ".change", json["change"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "change");
       }
       return new PrioritizedSourceChange(priority, change);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "PrioritizedSourceChange", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["priority"] = priority;
     result["change"] = change.toJson();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is PrioritizedSourceChange) {
-      return priority == other.priority &&
-          change == other.change;
+      return priority == other.priority && change == other.change;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, priority.hashCode);
     hash = JenkinsSmiHash.combine(hash, change.hashCode);
     return JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * RefactoringFeedback
  *
  * {
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class RefactoringFeedback implements HasToJson {
   RefactoringFeedback();
 
-  factory RefactoringFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json, Map responseJson) {
-    return refactoringFeedbackFromJson(jsonDecoder, jsonPath, json, responseJson);
+  factory RefactoringFeedback.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json, Map responseJson) {
+    return refactoringFeedbackFromJson(
+        jsonDecoder, jsonPath, json, responseJson);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is RefactoringFeedback) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     return JenkinsSmiHash.finish(hash);
@@ skipping 11 matching lines @@
  *   INLINE_LOCAL_VARIABLE
  *   INLINE_METHOD
  *   MOVE_FILE
  *   RENAME
  *   SORT_MEMBERS
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class RefactoringKind implements Enum {
-  static const RefactoringKind CONVERT_GETTER_TO_METHOD = const RefactoringKind._("CONVERT_GETTER_TO_METHOD");
+  static const RefactoringKind CONVERT_GETTER_TO_METHOD =
+      const RefactoringKind._("CONVERT_GETTER_TO_METHOD");
 
-  static const RefactoringKind CONVERT_METHOD_TO_GETTER = const RefactoringKind._("CONVERT_METHOD_TO_GETTER");
+  static const RefactoringKind CONVERT_METHOD_TO_GETTER =
+      const RefactoringKind._("CONVERT_METHOD_TO_GETTER");
 
-  static const RefactoringKind EXTRACT_LOCAL_VARIABLE = const RefactoringKind._("EXTRACT_LOCAL_VARIABLE");
+  static const RefactoringKind EXTRACT_LOCAL_VARIABLE =
+      const RefactoringKind._("EXTRACT_LOCAL_VARIABLE");
 
-  static const RefactoringKind EXTRACT_METHOD = const RefactoringKind._("EXTRACT_METHOD");
+  static const RefactoringKind EXTRACT_METHOD =
+      const RefactoringKind._("EXTRACT_METHOD");
 
-  static const RefactoringKind INLINE_LOCAL_VARIABLE = const RefactoringKind._("INLINE_LOCAL_VARIABLE");
+  static const RefactoringKind INLINE_LOCAL_VARIABLE =
+      const RefactoringKind._("INLINE_LOCAL_VARIABLE");
 
-  static const RefactoringKind INLINE_METHOD = const RefactoringKind._("INLINE_METHOD");
+  static const RefactoringKind INLINE_METHOD =
+      const RefactoringKind._("INLINE_METHOD");
 
   static const RefactoringKind MOVE_FILE = const RefactoringKind._("MOVE_FILE");
 
   static const RefactoringKind RENAME = const RefactoringKind._("RENAME");
 
-  static const RefactoringKind SORT_MEMBERS = const RefactoringKind._("SORT_MEMBERS");
+  static const RefactoringKind SORT_MEMBERS =
+      const RefactoringKind._("SORT_MEMBERS");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<RefactoringKind> VALUES = const <RefactoringKind>[CONVERT_GETTER_TO_METHOD, CONVERT_METHOD_TO_GETTER, EXTRACT_LOCAL_VARIABLE, EXTRACT_METHOD, INLINE_LOCAL_VARIABLE, INLINE_METHOD, MOVE_FILE, RENAME, SORT_MEMBERS];
+  static const List<RefactoringKind> VALUES = const <RefactoringKind>[
+    CONVERT_GETTER_TO_METHOD,
+    CONVERT_METHOD_TO_GETTER,
+    EXTRACT_LOCAL_VARIABLE,
+    EXTRACT_METHOD,
+    INLINE_LOCAL_VARIABLE,
+    INLINE_METHOD,
+    MOVE_FILE,
+    RENAME,
+    SORT_MEMBERS
+  ];
 
   @override
   final String name;
 
   const RefactoringKind._(this.name);
 
   factory RefactoringKind(String name) {
     switch (name) {
       case "CONVERT_GETTER_TO_METHOD":
         return CONVERT_GETTER_TO_METHOD;
@@ skipping 10 matching lines @@
       case "MOVE_FILE":
         return MOVE_FILE;
       case "RENAME":
         return RENAME;
       case "SORT_MEMBERS":
         return SORT_MEMBERS;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory RefactoringKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory RefactoringKind.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new RefactoringKind(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "RefactoringKind", json);
   }
 
   @override
   String toString() => "RefactoringKind.$name";
 
   String toJson() => name;
@@ skipping 87 matching lines @@
 
   /**
    * The parameter list of the parameter's function type. If the parameter is
    * not of a function type, this field will not be defined. If the function
    * type has zero parameters, this field will have a value of '()'.
    */
   void set parameters(String value) {
     this._parameters = value;
   }
 
-  RefactoringMethodParameter(RefactoringMethodParameterKind kind, String type, String name, {String id, String parameters}) {
+  RefactoringMethodParameter(
+      RefactoringMethodParameterKind kind, String type, String name,
+      {String id, String parameters}) {
     this.id = id;
     this.kind = kind;
     this.type = type;
     this.name = name;
     this.parameters = parameters;
   }
 
-  factory RefactoringMethodParameter.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory RefactoringMethodParameter.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"]);
       }
       RefactoringMethodParameterKind kind;
       if (json.containsKey("kind")) {
-        kind = new RefactoringMethodParameterKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
+        kind = new RefactoringMethodParameterKind.fromJson(
+            jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "kind");
       }
       String type;
       if (json.containsKey("type")) {
         type = jsonDecoder.decodeString(jsonPath + ".type", json["type"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "type");
       }
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "name");
       }
       String parameters;
       if (json.containsKey("parameters")) {
-        parameters = jsonDecoder.decodeString(jsonPath + ".parameters", json["parameters"]);
+        parameters = jsonDecoder.decodeString(
+            jsonPath + ".parameters", json["parameters"]);
       }
-      return new RefactoringMethodParameter(kind, type, name, id: id, parameters: parameters);
+      return new RefactoringMethodParameter(kind, type, name,
+          id: id, parameters: parameters);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameter", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (id != null) {
       result["id"] = id;
     }
     result["kind"] = kind.toJson();
     result["type"] = type;
     result["name"] = name;
     if (parameters != null) {
       result["parameters"] = parameters;
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is RefactoringMethodParameter) {
       return id == other.id &&
           kind == other.kind &&
           type == other.type &&
           name == other.name &&
           parameters == other.parameters;
     }
     return false;
   }
 
@@ skipping 14 matching lines @@
  *
  * enum {
  *   REQUIRED
  *   POSITIONAL
  *   NAMED
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class RefactoringMethodParameterKind implements Enum {
-  static const RefactoringMethodParameterKind REQUIRED = const RefactoringMethodParameterKind._("REQUIRED");
+  static const RefactoringMethodParameterKind REQUIRED =
+      const RefactoringMethodParameterKind._("REQUIRED");
 
-  static const RefactoringMethodParameterKind POSITIONAL = const RefactoringMethodParameterKind._("POSITIONAL");
+  static const RefactoringMethodParameterKind POSITIONAL =
+      const RefactoringMethodParameterKind._("POSITIONAL");
 
-  static const RefactoringMethodParameterKind NAMED = const RefactoringMethodParameterKind._("NAMED");
+  static const RefactoringMethodParameterKind NAMED =
+      const RefactoringMethodParameterKind._("NAMED");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<RefactoringMethodParameterKind> VALUES = const <RefactoringMethodParameterKind>[REQUIRED, POSITIONAL, NAMED];
+  static const List<RefactoringMethodParameterKind> VALUES =
+      const <RefactoringMethodParameterKind>[REQUIRED, POSITIONAL, NAMED];
 
   @override
   final String name;
 
   const RefactoringMethodParameterKind._(this.name);
 
   factory RefactoringMethodParameterKind(String name) {
     switch (name) {
       case "REQUIRED":
         return REQUIRED;
       case "POSITIONAL":
         return POSITIONAL;
       case "NAMED":
         return NAMED;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory RefactoringMethodParameterKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory RefactoringMethodParameterKind.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new RefactoringMethodParameterKind(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameterKind", json);
+    throw jsonDecoder.mismatch(
+        jsonPath, "RefactoringMethodParameterKind", json);
   }
 
   @override
   String toString() => "RefactoringMethodParameterKind.$name";
 
   String toJson() => name;
 }
 
 /**
  * RefactoringOptions
  *
  * {
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class RefactoringOptions implements HasToJson {
   RefactoringOptions();
 
-  factory RefactoringOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json, RefactoringKind kind) {
+  factory RefactoringOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath,
+      Object json, RefactoringKind kind) {
     return refactoringOptionsFromJson(jsonDecoder, jsonPath, json, kind);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is RefactoringOptions) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     return JenkinsSmiHash.finish(hash);
@@ skipping 53 matching lines @@
 
   /**
    * The location of the problem being represented. This field is omitted
    * unless there is a specific location associated with the problem (such as a
    * location where an element being renamed will be shadowed).
    */
   void set location(Location value) {
     this._location = value;
   }
 
-  RefactoringProblem(RefactoringProblemSeverity severity, String message, {Location location}) {
+  RefactoringProblem(RefactoringProblemSeverity severity, String message,
+      {Location location}) {
     this.severity = severity;
     this.message = message;
     this.location = location;
   }
 
-  factory RefactoringProblem.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory RefactoringProblem.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       RefactoringProblemSeverity severity;
       if (json.containsKey("severity")) {
-        severity = new RefactoringProblemSeverity.fromJson(jsonDecoder, jsonPath + ".severity", json["severity"]);
+        severity = new RefactoringProblemSeverity.fromJson(
+            jsonDecoder, jsonPath + ".severity", json["severity"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "severity");
       }
       String message;
       if (json.containsKey("message")) {
-        message = jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
+        message =
+            jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "message");
       }
       Location location;
       if (json.containsKey("location")) {
-        location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
+        location = new Location.fromJson(
+            jsonDecoder, jsonPath + ".location", json["location"]);
       }
       return new RefactoringProblem(severity, message, location: location);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "RefactoringProblem", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["severity"] = severity.toJson();
     result["message"] = message;
     if (location != null) {
       result["location"] = location.toJson();
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is RefactoringProblem) {
       return severity == other.severity &&
           message == other.message &&
           location == other.location;
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 14 matching lines @@
  *   ERROR
  *   FATAL
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class RefactoringProblemSeverity implements Enum {
   /**
    * A minor code problem. No example, because it is not used yet.
    */
-  static const RefactoringProblemSeverity INFO = const RefactoringProblemSeverity._("INFO");
+  static const RefactoringProblemSeverity INFO =
+      const RefactoringProblemSeverity._("INFO");
 
   /**
    * A minor code problem. For example names of local variables should be camel
    * case and start with a lower case letter. Staring the name of a variable
    * with an upper case is OK from the language point of view, but it is nice
    * to warn the user.
    */
-  static const RefactoringProblemSeverity WARNING = const RefactoringProblemSeverity._("WARNING");
+  static const RefactoringProblemSeverity WARNING =
+      const RefactoringProblemSeverity._("WARNING");
 
   /**
    * The refactoring technically can be performed, but there is a logical
    * problem. For example the name of a local variable being extracted
    * conflicts with another name in the scope, or duplicate parameter names in
    * the method being extracted, or a conflict between a parameter name and a
    * local variable, etc. In some cases the location of the problem is also
    * provided, so the IDE can show user the location and the problem, and let
    * the user decide whether they want to perform the refactoring. For example
    * the name conflict might be expected, and the user wants to fix it
    * afterwards.
    */
-  static const RefactoringProblemSeverity ERROR = const RefactoringProblemSeverity._("ERROR");
+  static const RefactoringProblemSeverity ERROR =
+      const RefactoringProblemSeverity._("ERROR");
 
   /**
    * A fatal error, which prevents performing the refactoring. For example the
    * name of a local variable being extracted is not a valid identifier, or
    * selection is not a valid expression.
    */
-  static const RefactoringProblemSeverity FATAL = const RefactoringProblemSeverity._("FATAL");
+  static const RefactoringProblemSeverity FATAL =
+      const RefactoringProblemSeverity._("FATAL");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<RefactoringProblemSeverity> VALUES = const <RefactoringProblemSeverity>[INFO, WARNING, ERROR, FATAL];
+  static const List<RefactoringProblemSeverity> VALUES =
+      const <RefactoringProblemSeverity>[INFO, WARNING, ERROR, FATAL];
 
   @override
   final String name;
 
   const RefactoringProblemSeverity._(this.name);
 
   factory RefactoringProblemSeverity(String name) {
     switch (name) {
       case "INFO":
         return INFO;
       case "WARNING":
         return WARNING;
       case "ERROR":
         return ERROR;
       case "FATAL":
         return FATAL;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory RefactoringProblemSeverity.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory RefactoringProblemSeverity.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new RefactoringProblemSeverity(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "RefactoringProblemSeverity", json);
   }
 
   /**
    * Returns the [RefactoringProblemSeverity] with the maximal severity.
    */
-  static RefactoringProblemSeverity max(RefactoringProblemSeverity a, RefactoringProblemSeverity b) =>
+  static RefactoringProblemSeverity max(
+          RefactoringProblemSeverity a, RefactoringProblemSeverity b) =>
       maxRefactoringProblemSeverity(a, b);
 
   @override
   String toString() => "RefactoringProblemSeverity.$name";
 
   String toJson() => name;
 }
 
 /**
  * RemoveContentOverlay
  *
  * {
  *   "type": "remove"
  * }
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class RemoveContentOverlay implements HasToJson {
   RemoveContentOverlay();
 
-  factory RemoveContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory RemoveContentOverlay.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       if (json["type"] != "remove") {
         throw jsonDecoder.mismatch(jsonPath, "equal " + "remove", json);
       }
       return new RemoveContentOverlay();
     } else {
       throw jsonDecoder.mismatch(jsonPath, "RemoveContentOverlay", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["type"] = "remove";
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is RemoveContentOverlay) {
       return true;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, 114870849);
@@ skipping 69 matching lines @@
   String get oldName => _oldName;
 
   /**
    * The old name of the element before the refactoring.
    */
   void set oldName(String value) {
     assert(value != null);
     this._oldName = value;
   }
 
-  RenameFeedback(int offset, int length, String elementKindName, String oldName) {
+  RenameFeedback(
+      int offset, int length, String elementKindName, String oldName) {
     this.offset = offset;
     this.length = length;
     this.elementKindName = elementKindName;
     this.oldName = oldName;
   }
 
-  factory RenameFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory RenameFeedback.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       String elementKindName;
       if (json.containsKey("elementKindName")) {
-        elementKindName = jsonDecoder.decodeString(jsonPath + ".elementKindName", json["elementKindName"]);
+        elementKindName = jsonDecoder.decodeString(
+            jsonPath + ".elementKindName", json["elementKindName"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "elementKindName");
       }
       String oldName;
       if (json.containsKey("oldName")) {
-        oldName = jsonDecoder.decodeString(jsonPath + ".oldName", json["oldName"]);
+        oldName =
+            jsonDecoder.decodeString(jsonPath + ".oldName", json["oldName"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "oldName");
       }
       return new RenameFeedback(offset, length, elementKindName, oldName);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "rename feedback", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     result["elementKindName"] = elementKindName;
     result["oldName"] = oldName;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is RenameFeedback) {
       return offset == other.offset &&
           length == other.length &&
           elementKindName == other.elementKindName &&
           oldName == other.oldName;
     }
     return false;
   }
 
   @override
@@ skipping 29 matching lines @@
    */
   void set newName(String value) {
     assert(value != null);
     this._newName = value;
   }
 
   RenameOptions(String newName) {
     this.newName = newName;
   }
 
-  factory RenameOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory RenameOptions.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String newName;
       if (json.containsKey("newName")) {
-        newName = jsonDecoder.decodeString(jsonPath + ".newName", json["newName"]);
+        newName =
+            jsonDecoder.decodeString(jsonPath + ".newName", json["newName"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "newName");
       }
       return new RenameOptions(newName);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "rename options", json);
     }
   }
 
-  factory RenameOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
+  factory RenameOptions.fromRefactoringParams(
+      EditGetRefactoringParams refactoringParams, Request request) {
     return new RenameOptions.fromJson(
         new RequestDecoder(request), "options", refactoringParams.options);
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["newName"] = newName;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is RenameOptions) {
       return newName == other.newName;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, newName.hashCode);
@@ skipping 58 matching lines @@
   void set stackTrace(String value) {
     this._stackTrace = value;
   }
 
   RequestError(RequestErrorCode code, String message, {String stackTrace}) {
     this.code = code;
     this.message = message;
     this.stackTrace = stackTrace;
   }
 
-  factory RequestError.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory RequestError.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       RequestErrorCode code;
       if (json.containsKey("code")) {
-        code = new RequestErrorCode.fromJson(jsonDecoder, jsonPath + ".code", json["code"]);
+        code = new RequestErrorCode.fromJson(
+            jsonDecoder, jsonPath + ".code", json["code"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "code");
       }
       String message;
       if (json.containsKey("message")) {
-        message = jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
+        message =
+            jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "message");
       }
       String stackTrace;
       if (json.containsKey("stackTrace")) {
-        stackTrace = jsonDecoder.decodeString(jsonPath + ".stackTrace", json["stackTrace"]);
+        stackTrace = jsonDecoder.decodeString(
+            jsonPath + ".stackTrace", json["stackTrace"]);
       }
       return new RequestError(code, message, stackTrace: stackTrace);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "RequestError", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["code"] = code.toJson();
     result["message"] = message;
     if (stackTrace != null) {
       result["stackTrace"] = stackTrace;
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is RequestError) {
       return code == other.code &&
           message == other.message &&
           stackTrace == other.stackTrace;
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 20 matching lines @@
 class RequestErrorCode implements Enum {
   /**
    * An "analysis.updateContent" request contained a ChangeContentOverlay
    * object that can't be applied. This can happen for two reasons:
    *
    * - there was no preceding AddContentOverlay and hence no content to which
    *   the edits could be applied, or
    * - one or more of the specified edits have an offset or length that is out
    *   of range.
    */
-  static const RequestErrorCode INVALID_OVERLAY_CHANGE = const RequestErrorCode._("INVALID_OVERLAY_CHANGE");
+  static const RequestErrorCode INVALID_OVERLAY_CHANGE =
+      const RequestErrorCode._("INVALID_OVERLAY_CHANGE");
 
   /**
    * One of the method parameters was invalid.
    */
-  static const RequestErrorCode INVALID_PARAMETER = const RequestErrorCode._("INVALID_PARAMETER");
+  static const RequestErrorCode INVALID_PARAMETER =
+      const RequestErrorCode._("INVALID_PARAMETER");
 
   /**
    * An internal error occurred in the plugin while attempting to respond to a
    * request. Also see the plugin.error notification for errors that occur
    * outside of handling a request.
    */
-  static const RequestErrorCode PLUGIN_ERROR = const RequestErrorCode._("PLUGIN_ERROR");
+  static const RequestErrorCode PLUGIN_ERROR =
+      const RequestErrorCode._("PLUGIN_ERROR");
 
   /**
    * A request was received that the plugin does not recognize, or cannot
    * handle in its current configuration.
    */
-  static const RequestErrorCode UNKNOWN_REQUEST = const RequestErrorCode._("UNKNOWN_REQUEST");
+  static const RequestErrorCode UNKNOWN_REQUEST =
+      const RequestErrorCode._("UNKNOWN_REQUEST");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<RequestErrorCode> VALUES = const <RequestErrorCode>[INVALID_OVERLAY_CHANGE, INVALID_PARAMETER, PLUGIN_ERROR, UNKNOWN_REQUEST];
+  static const List<RequestErrorCode> VALUES = const <RequestErrorCode>[
+    INVALID_OVERLAY_CHANGE,
+    INVALID_PARAMETER,
+    PLUGIN_ERROR,
+    UNKNOWN_REQUEST
+  ];
 
   @override
   final String name;
 
   const RequestErrorCode._(this.name);
 
   factory RequestErrorCode(String name) {
     switch (name) {
       case "INVALID_OVERLAY_CHANGE":
         return INVALID_OVERLAY_CHANGE;
       case "INVALID_PARAMETER":
         return INVALID_PARAMETER;
       case "PLUGIN_ERROR":
         return PLUGIN_ERROR;
       case "UNKNOWN_REQUEST":
         return UNKNOWN_REQUEST;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory RequestErrorCode.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory RequestErrorCode.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new RequestErrorCode(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "RequestErrorCode", json);
   }
 
   @override
   String toString() => "RequestErrorCode.$name";
 
   String toJson() => name;
@@ skipping 66 matching lines @@
    */
   Position get selection => _selection;
 
   /**
    * The position that should be selected after the edits have been applied.
    */
   void set selection(Position value) {
     this._selection = value;
   }
 
-  SourceChange(String message, {List<SourceFileEdit> edits, List<LinkedEditGroup> linkedEditGroups, Position selection}) {
+  SourceChange(String message,
+      {List<SourceFileEdit> edits,
+      List<LinkedEditGroup> linkedEditGroups,
+      Position selection}) {
     this.message = message;
     if (edits == null) {
       this.edits = <SourceFileEdit>[];
     } else {
       this.edits = edits;
     }
     if (linkedEditGroups == null) {
       this.linkedEditGroups = <LinkedEditGroup>[];
     } else {
       this.linkedEditGroups = linkedEditGroups;
     }
     this.selection = selection;
   }
 
-  factory SourceChange.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory SourceChange.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String message;
       if (json.containsKey("message")) {
-        message = jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
+        message =
+            jsonDecoder.decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "message");
       }
       List<SourceFileEdit> edits;
       if (json.containsKey("edits")) {
-        edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceFileEdit.fromJson(jsonDecoder, jsonPath, json));
+        edits = jsonDecoder.decodeList(
+            jsonPath + ".edits",
+            json["edits"],
+            (String jsonPath, Object json) =>
+                new SourceFileEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "edits");
       }
       List<LinkedEditGroup> linkedEditGroups;
       if (json.containsKey("linkedEditGroups")) {
-        linkedEditGroups = jsonDecoder.decodeList(jsonPath + ".linkedEditGroups", json["linkedEditGroups"], (String jsonPath, Object json) => new LinkedEditGroup.fromJson(jsonDecoder, jsonPath, json));
+        linkedEditGroups = jsonDecoder.decodeList(
+            jsonPath + ".linkedEditGroups",
+            json["linkedEditGroups"],
+            (String jsonPath, Object json) =>
+                new LinkedEditGroup.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "linkedEditGroups");
       }
       Position selection;
       if (json.containsKey("selection")) {
-        selection = new Position.fromJson(jsonDecoder, jsonPath + ".selection", json["selection"]);
+        selection = new Position.fromJson(
+            jsonDecoder, jsonPath + ".selection", json["selection"]);
       }
-      return new SourceChange(message, edits: edits, linkedEditGroups: linkedEditGroups, selection: selection);
+      return new SourceChange(message,
+          edits: edits,
+          linkedEditGroups: linkedEditGroups,
+          selection: selection);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SourceChange", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["message"] = message;
-    result["edits"] = edits.map((SourceFileEdit value) => value.toJson()).toList();
-    result["linkedEditGroups"] = linkedEditGroups.map((LinkedEditGroup value) => value.toJson()).toList();
+    result["edits"] =
+        edits.map((SourceFileEdit value) => value.toJson()).toList();
+    result["linkedEditGroups"] = linkedEditGroups
+        .map((LinkedEditGroup value) => value.toJson())
+        .toList();
     if (selection != null) {
       result["selection"] = selection.toJson();
     }
     return result;
   }
 
   /**
    * Adds [edit] to the [FileEdit] for the given [file].
    */
   void addEdit(String file, int fileStamp, SourceEdit edit) =>
       addEditToSourceChange(this, file, fileStamp, edit);
 
   /**
    * Adds the given [FileEdit].
    */
   void addFileEdit(SourceFileEdit edit) {
     edits.add(edit);
   }
 
   /**
    * Adds the given [LinkedEditGroup].
    */
   void addLinkedEditGroup(LinkedEditGroup linkedEditGroup) {
     linkedEditGroups.add(linkedEditGroup);
   }
 
   /**
    * Returns the [FileEdit] for the given [file], maybe `null`.
    */
-  SourceFileEdit getFileEdit(String file) =>
-      getChangeFileEdit(this, file);
+  SourceFileEdit getFileEdit(String file) => getChangeFileEdit(this, file);
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is SourceChange) {
       return message == other.message &&
-          listEqual(edits, other.edits, (SourceFileEdit a, SourceFileEdit b) => a == b) &&
-          listEqual(linkedEditGroups, other.linkedEditGroups, (LinkedEditGroup a, LinkedEditGroup b) => a == b) &&
+          listEqual(edits, other.edits,
+              (SourceFileEdit a, SourceFileEdit b) => a == b) &&
+          listEqual(linkedEditGroups, other.linkedEditGroups,
+              (LinkedEditGroup a, LinkedEditGroup b) => a == b) &&
           selection == other.selection;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, message.hashCode);
     hash = JenkinsSmiHash.combine(hash, edits.hashCode);
@@ skipping 96 matching lines @@
     this._id = value;
   }
 
   SourceEdit(int offset, int length, String replacement, {String id}) {
     this.offset = offset;
     this.length = length;
     this.replacement = replacement;
     this.id = id;
   }
 
-  factory SourceEdit.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory SourceEdit.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder.decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "length");
       }
       String replacement;
       if (json.containsKey("replacement")) {
-        replacement = jsonDecoder.decodeString(jsonPath + ".replacement", json["replacement"]);
+        replacement = jsonDecoder.decodeString(
+            jsonPath + ".replacement", json["replacement"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "replacement");
       }
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]);
       }
       return new SourceEdit(offset, length, replacement, id: id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SourceEdit", json);
@@ skipping 19 matching lines @@
 
   /**
    * Get the result of applying the edit to the given [code].
    */
   String apply(String code) => applyEdit(code, this);
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is SourceEdit) {
       return offset == other.offset &&
           length == other.length &&
           replacement == other.replacement &&
           id == other.id;
     }
     return false;
   }
 
   @override
@@ skipping 75 matching lines @@
   SourceFileEdit(String file, int fileStamp, {List<SourceEdit> edits}) {
     this.file = file;
     this.fileStamp = fileStamp;
     if (edits == null) {
       this.edits = <SourceEdit>[];
     } else {
       this.edits = edits;
     }
   }
 
-  factory SourceFileEdit.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory SourceFileEdit.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"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "file");
       }
       int fileStamp;
       if (json.containsKey("fileStamp")) {
-        fileStamp = jsonDecoder.decodeInt(jsonPath + ".fileStamp", json["fileStamp"]);
+        fileStamp =
+            jsonDecoder.decodeInt(jsonPath + ".fileStamp", json["fileStamp"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "fileStamp");
       }
       List<SourceEdit> edits;
       if (json.containsKey("edits")) {
-        edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
+        edits = jsonDecoder.decodeList(
+            jsonPath + ".edits",
+            json["edits"],
+            (String jsonPath, Object json) =>
+                new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.mismatch(jsonPath, "edits");
       }
       return new SourceFileEdit(file, fileStamp, edits: edits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SourceFileEdit", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["fileStamp"] = fileStamp;
     result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList();
     return result;
   }
 
   /**
    * Adds the given [Edit] to the list.
    */
   void add(SourceEdit edit) => addEditForSource(this, edit);
 
   /**
    * Adds the given [Edit]s.
    */
-  void addAll(Iterable<SourceEdit> edits) =>
-      addAllEditsForSource(this, edits);
+  void addAll(Iterable<SourceEdit> edits) => addAllEditsForSource(this, edits);
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is SourceFileEdit) {
       return file == other.file &&
           fileStamp == other.fileStamp &&
           listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
@@ skipping 44 matching lines @@
   void set path(String value) {
     assert(value != null);
     this._path = value;
   }
 
   WatchEvent(WatchEventType type, String path) {
     this.type = type;
     this.path = path;
   }
 
-  factory WatchEvent.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory WatchEvent.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       WatchEventType type;
       if (json.containsKey("type")) {
-        type = new WatchEventType.fromJson(jsonDecoder, jsonPath + ".type", json["type"]);
+        type = new WatchEventType.fromJson(
+            jsonDecoder, jsonPath + ".type", json["type"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "type");
       }
       String path;
       if (json.containsKey("path")) {
         path = jsonDecoder.decodeString(jsonPath + ".path", json["path"]);
       } else {
         throw jsonDecoder.mismatch(jsonPath, "path");
       }
       return new WatchEvent(type, path);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "WatchEvent", json);
     }
   }
 
   @override
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["type"] = type.toJson();
     result["path"] = path;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is WatchEvent) {
-      return type == other.type &&
-          path == other.path;
+      return type == other.type && path == other.path;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = JenkinsSmiHash.combine(hash, type.hashCode);
     hash = JenkinsSmiHash.combine(hash, path.hashCode);
     return JenkinsSmiHash.finish(hash);
@@ skipping 23 matching lines @@
   static const WatchEventType MODIFY = const WatchEventType._("MODIFY");
 
   /**
    * An indication that the file or directory was removed.
    */
   static const WatchEventType REMOVE = const WatchEventType._("REMOVE");
 
   /**
    * A list containing all of the enum values that are defined.
    */
-  static const List<WatchEventType> VALUES = const <WatchEventType>[ADD, MODIFY, REMOVE];
+  static const List<WatchEventType> VALUES = const <WatchEventType>[
+    ADD,
+    MODIFY,
+    REMOVE
+  ];
 
   @override
   final String name;
 
   const WatchEventType._(this.name);
 
   factory WatchEventType(String name) {
     switch (name) {
       case "ADD":
         return ADD;
       case "MODIFY":
         return MODIFY;
       case "REMOVE":
         return REMOVE;
     }
     throw new Exception('Illegal enum value: $name');
   }
 
-  factory WatchEventType.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+  factory WatchEventType.fromJson(
+      JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new WatchEventType(json);
-      } catch(_) {
+      } catch (_) {
         // Fall through
       }
     }
     throw jsonDecoder.mismatch(jsonPath, "WatchEventType", json);
   }
 
   @override
   String toString() => "WatchEventType.$name";
 
   String toJson() => name;
 }