Decode RefactoringFeedback automatically.

pkg/analysis_server/lib/src/generated_protocol.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analysis_server/spec/generate_files".
 
 part of protocol;
 /**
@@ skipping 45 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "version");
       }
       return new ServerGetVersionResult(version);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.getVersion result");
     }
   }
 
   factory ServerGetVersionResult.fromResponse(Response response) {
     return new ServerGetVersionResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["version"] = version;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 221 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "stackTrace");
       }
       return new ServerErrorParams(isFatal, message, stackTrace);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.error params");
     }
   }
 
   factory ServerErrorParams.fromNotification(Notification notification) {
     return new ServerErrorParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["isFatal"] = isFatal;
     result["message"] = message;
     result["stackTrace"] = stackTrace;
     return result;
   }
 
@@ skipping 50 matching lines @@
         analysis = new AnalysisStatus.fromJson(jsonDecoder, jsonPath + ".analysis", json["analysis"]);
       }
       return new ServerStatusParams(analysis: analysis);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.status params");
     }
   }
 
   factory ServerStatusParams.fromNotification(Notification notification) {
     return new ServerStatusParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (analysis != null) {
       result["analysis"] = analysis.toJson();
     }
     return result;
   }
 
@@ skipping 113 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "errors");
       }
       return new AnalysisGetErrorsResult(errors);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors result");
     }
   }
 
   factory AnalysisGetErrorsResult.fromResponse(Response response) {
     return new AnalysisGetErrorsResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["errors"] = errors.map((AnalysisError value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 130 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "hovers");
       }
       return new AnalysisGetHoverResult(hovers);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getHover result");
     }
   }
 
   factory AnalysisGetHoverResult.fromResponse(Response response) {
     return new AnalysisGetHoverResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["hovers"] = hovers.map((HoverInformation value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 552 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "errors");
       }
       return new AnalysisErrorsParams(file, errors);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.errors params");
     }
   }
 
   factory AnalysisErrorsParams.fromNotification(Notification notification) {
     return new AnalysisErrorsParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["errors"] = errors.map((AnalysisError value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 48 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "files");
       }
       return new AnalysisFlushResultsParams(files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.flushResults params");
     }
   }
 
   factory AnalysisFlushResultsParams.fromNotification(Notification notification) {
     return new AnalysisFlushResultsParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["files"] = files;
     return result;
   }
 
   Notification toNotification() {
     return new Notification("analysis.flushResults", toJson());
@@ skipping 57 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "regions");
       }
       return new AnalysisFoldingParams(file, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.folding params");
     }
   }
 
   factory AnalysisFoldingParams.fromNotification(Notification notification) {
     return new AnalysisFoldingParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["regions"] = regions.map((FoldingRegion value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 64 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "regions");
       }
       return new AnalysisHighlightsParams(file, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params");
     }
   }
 
   factory AnalysisHighlightsParams.fromNotification(Notification notification) {
     return new AnalysisHighlightsParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["regions"] = regions.map((HighlightRegion value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 65 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "regions");
       }
       return new AnalysisNavigationParams(file, regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params");
     }
   }
 
   factory AnalysisNavigationParams.fromNotification(Notification notification) {
     return new AnalysisNavigationParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["regions"] = regions.map((NavigationRegion value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 60 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "occurrences");
       }
       return new AnalysisOccurrencesParams(file, occurrences);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params");
     }
   }
 
   factory AnalysisOccurrencesParams.fromNotification(Notification notification) {
     return new AnalysisOccurrencesParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["occurrences"] = occurrences.map((Occurrences value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 60 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "outline");
       }
       return new AnalysisOutlineParams(file, outline);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.outline params");
     }
   }
 
   factory AnalysisOutlineParams.fromNotification(Notification notification) {
     return new AnalysisOutlineParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["outline"] = outline.toJson();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 60 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "overrides");
       }
       return new AnalysisOverridesParams(file, overrides);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.overrides params");
     }
   }
 
   factory AnalysisOverridesParams.fromNotification(Notification notification) {
     return new AnalysisOverridesParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["overrides"] = overrides.map((Override value) => value.toJson()).toList();
     return result;
   }
 
   Notification toNotification() {
@@ skipping 129 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new CompletionGetSuggestionsResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions result");
     }
   }
 
   factory CompletionGetSuggestionsResult.fromResponse(Response response) {
     return new CompletionGetSuggestionsResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 103 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "isLast");
       }
       return new CompletionResultsParams(id, replacementOffset, replacementLength, results, isLast);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "completion.results params");
     }
   }
 
   factory CompletionResultsParams.fromNotification(Notification notification) {
     return new CompletionResultsParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     result["replacementOffset"] = replacementOffset;
     result["replacementLength"] = replacementLength;
     result["results"] = results.map((CompletionSuggestion value) => value.toJson()).toList();
     result["isLast"] = isLast;
     return result;
@@ skipping 169 matching lines @@
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
       }
       return new SearchFindElementReferencesResult(id: id, element: element);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences result");
     }
   }
 
   factory SearchFindElementReferencesResult.fromResponse(Response response) {
     return new SearchFindElementReferencesResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (id != null) {
       result["id"] = id;
     }
     if (element != null) {
       result["element"] = element.toJson();
     }
@@ skipping 118 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new SearchFindMemberDeclarationsResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations result");
     }
   }
 
   factory SearchFindMemberDeclarationsResult.fromResponse(Response response) {
     return new SearchFindMemberDeclarationsResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 111 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new SearchFindMemberReferencesResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences result");
     }
   }
 
   factory SearchFindMemberReferencesResult.fromResponse(Response response) {
     return new SearchFindMemberReferencesResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 112 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new SearchFindTopLevelDeclarationsResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations result");
     }
   }
 
   factory SearchFindTopLevelDeclarationsResult.fromResponse(Response response) {
     return new SearchFindTopLevelDeclarationsResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 139 matching lines @@
         hierarchyItems = <TypeHierarchyItem>[];
       }
       return new SearchGetTypeHierarchyResult(hierarchyItems: hierarchyItems);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy result");
     }
   }
 
   factory SearchGetTypeHierarchyResult.fromResponse(Response response) {
     return new SearchGetTypeHierarchyResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (hierarchyItems.isNotEmpty) {
       result["hierarchyItems"] = hierarchyItems.map((TypeHierarchyItem value) => value.toJson()).toList();
     }
     return result;
   }
 
@@ skipping 72 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "isLast");
       }
       return new SearchResultsParams(id, results, isLast);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.results params");
     }
   }
 
   factory SearchResultsParams.fromNotification(Notification notification) {
     return new SearchResultsParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     result["results"] = results.map((SearchResult value) => value.toJson()).toList();
     result["isLast"] = isLast;
     return result;
   }
 
@@ skipping 147 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "assists");
       }
       return new EditGetAssistsResult(assists);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAssists result");
     }
   }
 
   factory EditGetAssistsResult.fromResponse(Response response) {
     return new EditGetAssistsResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["assists"] = assists.map((SourceChange value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 141 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "kinds");
       }
       return new EditGetAvailableRefactoringsResult(kinds);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings result");
     }
   }
 
   factory EditGetAvailableRefactoringsResult.fromResponse(Response response) {
     return new EditGetAvailableRefactoringsResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["kinds"] = kinds.map((RefactoringKind value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 131 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "fixes");
       }
       return new EditGetFixesResult(fixes);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result");
     }
   }
 
   factory EditGetFixesResult.fromResponse(Response response) {
     return new EditGetFixesResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["fixes"] = fixes.map((AnalysisErrorFixes value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 107 matching lines @@
       if (json.containsKey("options")) {
         options = new RefactoringOptions.fromJson(jsonDecoder, jsonPath + ".options", json["options"], kind);
       }
       return new EditGetRefactoringParams(kind, file, offset, length, validateOnly, options: options);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring params");
     }
   }
 
   factory EditGetRefactoringParams.fromRequest(Request request) {
-    return new EditGetRefactoringParams.fromJson(
+    var params = new EditGetRefactoringParams.fromJson(
         new RequestDecoder(request), "params", request._params);
+    REQUEST_ID_REFACTORING_KINDS[request.id] = params.kind;
+    return params;
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["kind"] = kind.toJson();
     result["file"] = file;
     result["offset"] = offset;
     result["length"] = length;
     result["validateOnly"] = validateOnly;
     if (options != null) {
@@ skipping 33 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, options.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getRefactoring result
  *
  * {
  *   "problems": List<RefactoringProblem>
- *   "feedback": optional object
+ *   "feedback": optional RefactoringFeedback
  *   "change": optional SourceChange
  *   "potentialEdits": optional List<String>
  * }
  */
 class EditGetRefactoringResult implements HasToJson {
   /**
    * The status of the refactoring. The array will be empty if there are no
    * known problems.
    */
   List<RefactoringProblem> problems;
 
   /**
    * Data used to provide feedback to the user. The structure of the data is
    * dependent on the kind of refactoring being created. The data that is
    * returned is documented in the section titled Refactorings, labeled as
    * “Feedback”.
    */
-  Map feedback;
+  RefactoringFeedback feedback;
 
   /**
    * The changes that are to be applied to affect the refactoring. This field
    * will be omitted if there are problems that prevent a set of changes from
    * being computed, such as having no options specified for a refactoring that
    * requires them, or if only validation was requested.
    */
   SourceChange change;
 
   /**
@@ skipping 16 matching lines @@
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<RefactoringProblem> problems;
       if (json.containsKey("problems")) {
         problems = jsonDecoder._decodeList(jsonPath + ".problems", json["problems"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "problems");
       }
-      Map feedback;
+      RefactoringFeedback feedback;
       if (json.containsKey("feedback")) {
-        feedback = json["feedback"];
+        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"]);
       }
       List<String> potentialEdits;
       if (json.containsKey("potentialEdits")) {
         potentialEdits = jsonDecoder._decodeList(jsonPath + ".potentialEdits", json["potentialEdits"], jsonDecoder._decodeString);
       } else {
         potentialEdits = <String>[];
       }
       return new EditGetRefactoringResult(problems, feedback: feedback, change: change, potentialEdits: potentialEdits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result");
     }
   }
 
   factory EditGetRefactoringResult.fromResponse(Response response) {
     return new EditGetRefactoringResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["problems"] = problems.map((RefactoringProblem value) => value.toJson()).toList();
     if (feedback != null) {
-      result["feedback"] = feedback;
+      result["feedback"] = feedback.toJson();
     }
     if (change != null) {
       result["change"] = change.toJson();
     }
     if (potentialEdits.isNotEmpty) {
       result["potentialEdits"] = potentialEdits;
     }
     return result;
   }
 
@@ skipping 119 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       return new DebugCreateContextResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.createContext result");
     }
   }
 
   factory DebugCreateContextResult.fromResponse(Response response) {
     return new DebugCreateContextResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
@@ skipping 238 matching lines @@
         uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]);
       }
       return new DebugMapUriResult(file: file, uri: uri);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.mapUri result");
     }
   }
 
   factory DebugMapUriResult.fromResponse(Response response) {
     return new DebugMapUriResult.fromJson(
-        new ResponseDecoder(), "result", response._result);
+        new ResponseDecoder(response), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (file != null) {
       result["file"] = file;
     }
     if (uri != null) {
       result["uri"] = uri;
     }
@@ skipping 166 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "htmlToDart");
       }
       return new DebugLaunchDataParams(executables, dartToHtml, htmlToDart);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.launchData params");
     }
   }
 
   factory DebugLaunchDataParams.fromNotification(Notification notification) {
     return new DebugLaunchDataParams.fromJson(
-        new ResponseDecoder(), "params", notification._params);
+        new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["executables"] = executables.map((ExecutableFile value) => value.toJson()).toList();
     result["dartToHtml"] = dartToHtml;
     result["htmlToDart"] = htmlToDart;
     return result;
   }
 
@@ skipping 3479 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, id.hashCode);
     hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
     hash = _JenkinsSmiHash.combine(hash, type.hashCode);
     hash = _JenkinsSmiHash.combine(hash, name.hashCode);
     hash = _JenkinsSmiHash.combine(hash, parameters.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
+ * RefactoringFeedback
+ *
+ * {
+ * }
+ */
+class RefactoringFeedback implements HasToJson {
+  RefactoringFeedback();
+
+  factory RefactoringFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json, Map responseJson) {
+    return _refactoringFeedbackFromJson(jsonDecoder, jsonPath, json, responseJson);
+  }
+
+  Map<String, dynamic> toJson() {
+    Map<String, dynamic> result = {};
+    return result;
+  }
+
+  @override
+  String toString() => JSON.encode(toJson());
+
+  @override
+  bool operator==(other) {
+    if (other is RefactoringFeedback) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    int hash = 0;
+    return _JenkinsSmiHash.finish(hash);
+  }
+}
+
+/**
  * RefactoringOptions
  *
  * {
  * }
  */
 class RefactoringOptions implements HasToJson {
   RefactoringOptions();
 
   factory RefactoringOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json, RefactoringKind kind) {
     return _refactoringOptionsFromJson(jsonDecoder, jsonPath, json, kind);
@@ skipping 1304 matching lines @@
 
 /**
  * extractLocalVariable feedback
  *
  * {
  *   "names": List<String>
  *   "offsets": List<int>
  *   "lengths": List<int>
  * }
  */
-class ExtractLocalVariableFeedback implements HasToJson {
+class ExtractLocalVariableFeedback extends RefactoringFeedback implements HasToJson {
   /**
    * The proposed names for the local variable.
    */
   List<String> names;
 
   /**
    * The offsets of the expressions that would be replaced by a reference to
    * the variable.
    */
   List<int> offsets;
@@ skipping 30 matching lines @@
         lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder._decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "lengths");
       }
       return new ExtractLocalVariableFeedback(names, offsets, lengths);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable feedback");
     }
   }
 
-  factory ExtractLocalVariableFeedback.fromRefactoringResult(EditGetRefactoringResult refactoringResult) {
-    return new ExtractLocalVariableFeedback.fromJson(
-        new ResponseDecoder(), "feedback", refactoringResult.feedback);
-  }
-
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["names"] = names;
     result["offsets"] = offsets;
     result["lengths"] = lengths;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
@@ skipping 105 matching lines @@
  *   "offset": int
  *   "length": int
  *   "returnType": String
  *   "names": List<String>
  *   "canCreateGetter": bool
  *   "parameters": List<RefactoringMethodParameter>
  *   "offsets": List<int>
  *   "lengths": List<int>
  * }
  */
-class ExtractMethodFeedback implements HasToJson {
+class ExtractMethodFeedback extends RefactoringFeedback implements HasToJson {
   /**
    * The offset to the beginning of the expression or statements that will be
    * extracted.
    */
   int offset;
 
   /**
    * The length of the expression or statements that will be extracted.
    */
   int length;
@@ skipping 87 matching lines @@
         lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder._decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "lengths");
       }
       return new ExtractMethodFeedback(offset, length, returnType, names, canCreateGetter, parameters, offsets, lengths);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractMethod feedback");
     }
   }
 
-  factory ExtractMethodFeedback.fromRefactoringResult(EditGetRefactoringResult refactoringResult) {
-    return new ExtractMethodFeedback.fromJson(
-        new ResponseDecoder(), "feedback", refactoringResult.feedback);
-  }
-
   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["offsets"] = offsets;
     result["lengths"] = lengths;
@@ skipping 298 matching lines @@
 }
 
 /**
  * rename feedback
  *
  * {
  *   "offset": int
  *   "length": int
  * }
  */
-class RenameFeedback implements HasToJson {
+class RenameFeedback extends RefactoringFeedback implements HasToJson {
   /**
    * The offset to the beginning of the name selected to be renamed.
    */
   int offset;
 
   /**
    * The length of the name selected to be renamed.
    */
   int length;
 
@@ skipping 15 matching lines @@
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new RenameFeedback(offset, length);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "rename feedback");
     }
   }
 
-  factory RenameFeedback.fromRefactoringResult(EditGetRefactoringResult refactoringResult) {
-    return new RenameFeedback.fromJson(
-        new ResponseDecoder(), "feedback", refactoringResult.feedback);
-  }
-
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
@@ skipping 69 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }