Add paging support

pkg/analysis_server/lib/src/generated_protocol.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analysis_server/tool/spec/generate_files".
 
 part of protocol;
 /**
@@ skipping 674 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, hovers.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
+
+/**
+ * analysis.getNavigation params
+ *
+ * {
+ *   "file": FilePath
+ *   "start": int
+ *   "end": int
+ * }
+ */
+class AnalysisGetNavigationParams implements HasToJson {
+  /**
+   * The file in which navigation information is being requested.
+   */
+  String file;
+
+  /**
+   * The offset of the start of the region for which hover information is being
+   * requested.
+   */
+  int start;
+
+  /**
+   * The offset of the end of the region for which hover information is being
+   * requested.
+   */
+  int end;
+
+  AnalysisGetNavigationParams(this.file, this.start, this.end);
+
+  factory AnalysisGetNavigationParams.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.missingKey(jsonPath, "file");
+      }
+      int start;
+      if (json.containsKey("start")) {
+        start = jsonDecoder._decodeInt(jsonPath + ".start", json["start"]);
+      } else {
+        throw jsonDecoder.missingKey(jsonPath, "start");
+      }
+      int end;
+      if (json.containsKey("end")) {
+        end = jsonDecoder._decodeInt(jsonPath + ".end", json["end"]);
+      } else {
+        throw jsonDecoder.missingKey(jsonPath, "end");
+      }
+      return new AnalysisGetNavigationParams(file, start, end);
+    } else {
+      throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation params");
+    }
+  }
+
+  factory AnalysisGetNavigationParams.fromRequest(Request request) {
+    return new AnalysisGetNavigationParams.fromJson(
+        new RequestDecoder(request), "params", request._params);
+  }
+
+  Map<String, dynamic> toJson() {
+    Map<String, dynamic> result = {};
+    result["file"] = file;
+    result["start"] = start;
+    result["end"] = end;
+    return result;
+  }
+
+  Request toRequest(String id) {
+    return new Request(id, "analysis.getNavigation", toJson());
+  }
+
+  @override
+  String toString() => JSON.encode(toJson());
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisGetNavigationParams) {
+      return file == other.file &&
+          start == other.start &&
+          end == other.end;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    int hash = 0;
+    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = _JenkinsSmiHash.combine(hash, start.hashCode);
+    hash = _JenkinsSmiHash.combine(hash, end.hashCode);
+    return _JenkinsSmiHash.finish(hash);
+  }
+}
+
+/**
+ * analysis.getNavigation result
+ *
+ * {
+ *   "files": List<FilePath>
+ *   "targets": List<NavigationTarget>
+ *   "regions": List<NavigationRegion>
+ * }
+ */
+class AnalysisGetNavigationResult implements HasToJson {
+  /**
+   * A list of the paths of files that are referenced by the navigation
+   * targets.
+   */
+  List<String> files;
+
+  /**
+   * A list of the navigation targets that are referenced by the navigation
+   * regions.
+   */
+  List<NavigationTarget> targets;
+
+  /**
+   * A list of the navigation regions within the requested region of the file.
+   */
+  List<NavigationRegion> regions;
+
+  AnalysisGetNavigationResult(this.files, this.targets, this.regions);
+
+  factory AnalysisGetNavigationResult.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);
+      } else {
+        throw jsonDecoder.missingKey(jsonPath, "files");
+      }
+      List<NavigationTarget> targets;
+      if (json.containsKey("targets")) {
+        targets = jsonDecoder._decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, jsonPath, json));
+      } else {
+        throw jsonDecoder.missingKey(jsonPath, "targets");
+      }
+      List<NavigationRegion> regions;
+      if (json.containsKey("regions")) {
+        regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, jsonPath, json));
+      } else {
+        throw jsonDecoder.missingKey(jsonPath, "regions");
+      }
+      return new AnalysisGetNavigationResult(files, targets, regions);
+    } else {
+      throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation result");
+    }
+  }
+
+  factory AnalysisGetNavigationResult.fromResponse(Response response) {
+    return new AnalysisGetNavigationResult.fromJson(
+        new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
+  }
+
+  Map<String, dynamic> toJson() {
+    Map<String, dynamic> result = {};
+    result["files"] = files;
+    result["targets"] = targets.map((NavigationTarget value) => value.toJson()).toList();
+    result["regions"] = regions.map((NavigationRegion value) => value.toJson()).toList();
+    return result;
+  }
+
+  Response toResponse(String id) {
+    return new Response(id, result: toJson());
+  }
+
+  @override
+  String toString() => JSON.encode(toJson());
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisGetNavigationResult) {
+      return _listEqual(files, other.files, (String a, String b) => a == b) &&
+          _listEqual(targets, other.targets, (NavigationTarget a, NavigationTarget b) => a == b) &&
+          _listEqual(regions, other.regions, (NavigationRegion a, NavigationRegion b) => a == b);
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    int hash = 0;
+    hash = _JenkinsSmiHash.combine(hash, files.hashCode);
+    hash = _JenkinsSmiHash.combine(hash, targets.hashCode);
+    hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
+    return _JenkinsSmiHash.finish(hash);
+  }
+}
 /**
  * analysis.reanalyze params
  */
 class AnalysisReanalyzeParams {
   Request toRequest(String id) {
     return new Request(id, "analysis.reanalyze", null);
   }
 
   @override
   bool operator==(other) {
@@ skipping 816 matching lines @@
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
+ * analysis.invalidate params
+ *
+ * {
+ *   "file": FilePath
+ *   "start": int
+ *   "end": int
+ *   "delta": int
+ * }
+ */
+class AnalysisInvalidateParams implements HasToJson {
+  /**
+   * The file whose information has been invalidated.
+   */
+  String file;
+
+  /**
+   * The offset of the start of the invalidated region.
+   */
+  int start;
+
+  /**
+   * The offset of the end of the invalidated region.
+   */
+  int end;
+
+  /**
+   * The delta to be applied to the offsets in information that follows the
+   * invalidated region in order to update it so that it doesn't need to be
+   * re-requested.
+   */
+  int delta;
+
+  AnalysisInvalidateParams(this.file, this.start, this.end, this.delta);
+
+  factory AnalysisInvalidateParams.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.missingKey(jsonPath, "file");
+      }
+      int start;
+      if (json.containsKey("start")) {
+        start = jsonDecoder._decodeInt(jsonPath + ".start", json["start"]);
+      } else {
+        throw jsonDecoder.missingKey(jsonPath, "start");
+      }
+      int end;
+      if (json.containsKey("end")) {
+        end = jsonDecoder._decodeInt(jsonPath + ".end", json["end"]);
+      } else {
+        throw jsonDecoder.missingKey(jsonPath, "end");
+      }
+      int delta;
+      if (json.containsKey("delta")) {
+        delta = jsonDecoder._decodeInt(jsonPath + ".delta", json["delta"]);
+      } else {
+        throw jsonDecoder.missingKey(jsonPath, "delta");
+      }
+      return new AnalysisInvalidateParams(file, start, end, delta);
+    } else {
+      throw jsonDecoder.mismatch(jsonPath, "analysis.invalidate params");
+    }
+  }
+
+  factory AnalysisInvalidateParams.fromNotification(Notification notification) {
+    return new AnalysisInvalidateParams.fromJson(
+        new ResponseDecoder(null), "params", notification._params);
+  }
+
+  Map<String, dynamic> toJson() {
+    Map<String, dynamic> result = {};
+    result["file"] = file;
+    result["start"] = start;
+    result["end"] = end;
+    result["delta"] = delta;
+    return result;
+  }
+
+  Notification toNotification() {
+    return new Notification("analysis.invalidate", toJson());
+  }
+
+  @override
+  String toString() => JSON.encode(toJson());
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisInvalidateParams) {
+      return file == other.file &&
+          start == other.start &&
+          end == other.end &&
+          delta == other.delta;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    int hash = 0;
+    hash = _JenkinsSmiHash.combine(hash, file.hashCode);
+    hash = _JenkinsSmiHash.combine(hash, start.hashCode);
+    hash = _JenkinsSmiHash.combine(hash, end.hashCode);
+    hash = _JenkinsSmiHash.combine(hash, delta.hashCode);
+    return _JenkinsSmiHash.finish(hash);
+  }
+}
+
+/**
  * analysis.navigation params
  *
  * {
  *   "file": FilePath
  *   "regions": List<NavigationRegion>
  *   "targets": List<NavigationTarget>
  *   "files": List<FilePath>
  * }
  */
 class AnalysisNavigationParams implements HasToJson {
@@ skipping 3466 matching lines @@
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * AnalysisService
  *
  * enum {
  *   FOLDING
  *   HIGHLIGHTS
+ *   INVALIDATE
  *   NAVIGATION
  *   OCCURRENCES
  *   OUTLINE
  *   OVERRIDES
  * }
  */
 class AnalysisService implements Enum {
   static const FOLDING = const AnalysisService._("FOLDING");
 
   static const HIGHLIGHTS = const AnalysisService._("HIGHLIGHTS");
 
+  static const INVALIDATE = const AnalysisService._("INVALIDATE");
+
   static const NAVIGATION = const AnalysisService._("NAVIGATION");
 
   static const OCCURRENCES = const AnalysisService._("OCCURRENCES");
 
   static const OUTLINE = const AnalysisService._("OUTLINE");
 
   static const OVERRIDES = const AnalysisService._("OVERRIDES");
 
   final String name;
 
   const AnalysisService._(this.name);
 
   factory AnalysisService(String name) {
     switch (name) {
       case "FOLDING":
         return FOLDING;
       case "HIGHLIGHTS":
         return HIGHLIGHTS;
+      case "INVALIDATE":
+        return INVALIDATE;
       case "NAVIGATION":
         return NAVIGATION;
       case "OCCURRENCES":
         return OCCURRENCES;
       case "OUTLINE":
         return OUTLINE;
       case "OVERRIDES":
         return OVERRIDES;
     }
     throw new Exception('Illegal enum value: $name');
@@ skipping 5339 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }