Support merging with priority information

pkg/analysis_server/lib/src/plugin/result_merger.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.
 
 import 'dart:collection';
 
-import 'package:analysis_server/plugin/protocol/protocol.dart';
+import 'package:analysis_server/plugin/protocol/protocol.dart'
+    hide AnalysisErrorFixes;
+import 'package:analyzer_plugin/protocol/generated_protocol.dart' as plugin;
 import 'package:meta/meta.dart';
 
 /**
  * An object used to merge partial lists of results that were contributed by
  * plugins.
  *
  * All of the methods in this class assume that the contributions from the
  * analysis server are the first partial result in the list of partial results
  * to be merged.
  */
 class ResultMerger {
   /**
    * Return a list of fixes composed by merging the lists of fixes in the
    * [partialResultList].
    *
    * The resulting list of fixes will contain exactly one fix for every analysis
    * error for which there are fixes. If two or more plugins contribute the same
    * fix for a given error, the resulting list will contain duplications.
    */
-  List<AnalysisErrorFixes> mergeAnalysisErrorFixes(
-      List<List<AnalysisErrorFixes>> partialResultList) {
+  List<plugin.AnalysisErrorFixes> mergeAnalysisErrorFixes(
+      List<List<plugin.AnalysisErrorFixes>> partialResultList) {
     /**
      * Return a key encoding the unique attributes of the given [error].
      */
-    String computeKey(AnalysisError error) {
+    String computeKey(plugin.AnalysisError error) {
       StringBuffer buffer = new StringBuffer();
       buffer.write(error.location.offset);
       buffer.write(';');
       buffer.write(error.code);
       buffer.write(';');
       buffer.write(error.message);
       buffer.write(';');
       buffer.write(error.correction);
       return buffer.toString();
     }
 
     int count = partialResultList.length;
     if (count == 0) {
-      return <AnalysisErrorFixes>[];
+      return <plugin.AnalysisErrorFixes>[];
     } else if (count == 1) {
       return partialResultList[0];
     }
-    List<AnalysisErrorFixes> mergedFixes = partialResultList[0].toList();
-    Map<String, AnalysisErrorFixes> fixesMap = <String, AnalysisErrorFixes>{};
-    for (AnalysisErrorFixes fix in mergedFixes) {
+    Map<String, plugin.AnalysisErrorFixes> fixesMap =
+        <String, plugin.AnalysisErrorFixes>{};
+    for (plugin.AnalysisErrorFixes fix in partialResultList[0]) {
       fixesMap[computeKey(fix.error)] = fix;
     }
     for (int i = 1; i < count; i++) {
-      for (AnalysisErrorFixes fix in partialResultList[i]) {
+      for (plugin.AnalysisErrorFixes fix in partialResultList[i]) {
         String key = computeKey(fix.error);
-        AnalysisErrorFixes mergedFix = fixesMap[key];
+        plugin.AnalysisErrorFixes mergedFix = fixesMap[key];
         if (mergedFix == null) {
-          mergedFixes.add(fix);
           fixesMap[key] = fix;
         } else {
           // If more than two plugins contribute fixes for the same error, this
           // will result in extra copy operations.
-          List<SourceChange> mergedChanges = mergedFix.fixes.toList();
+          List<plugin.PrioritizedSourceChange> mergedChanges =
+              mergedFix.fixes.toList();
           mergedChanges.addAll(fix.fixes);
-          AnalysisErrorFixes copiedFix =
-              new AnalysisErrorFixes(mergedFix.error, fixes: mergedChanges);
-          mergedFixes[mergedFixes.indexOf(mergedFix)] = copiedFix;
+          plugin.AnalysisErrorFixes copiedFix = new plugin.AnalysisErrorFixes(
+              mergedFix.error,
+              fixes: mergedChanges);
           fixesMap[key] = copiedFix;
         }
       }
     }
+    List<plugin.AnalysisErrorFixes> mergedFixes = fixesMap.values.toList();
+    for (plugin.AnalysisErrorFixes fixes in mergedFixes) {
+      fixes.fixes.sort((first, second) => first.priority - second.priority);
+    }
     return mergedFixes;
   }
 
   /**
    * Return a list of errors composed by merging the lists of errors in the
    * [partialResultList].
    *
    * The resulting list will contain all of the analysis errors from all of the
    * plugins. If two or more plugins contribute the same error the resulting
    * list will contain duplications.
@@ skipping 667 matching lines @@
   }
 
   /**
    * Return a list of source changes composed by merging the lists of source
    * changes in the [partialResultList].
    *
    * The resulting list will contain all of the source changes from all of the
    * plugins. If two or more plugins contribute the same source change the
    * resulting list will contain duplications.
    */
+  List<plugin.PrioritizedSourceChange> mergePrioritizedSourceChanges(
+      List<List<plugin.PrioritizedSourceChange>> partialResultList) {
+    int count = partialResultList.length;
+    if (count == 0) {
+      return <plugin.PrioritizedSourceChange>[];
+    } else if (count == 1) {
+      return partialResultList[0];
+    }
+    List<plugin.PrioritizedSourceChange> mergedChanges = <plugin.PrioritizedSourceChange>[];
+    for (List<plugin.PrioritizedSourceChange> partialResults in partialResultList) {
+      mergedChanges.addAll(partialResults);
+    }
+    mergedChanges.sort((first, second) => first.priority - second.priority);
+    return mergedChanges;
+  }
+
+  /**
+   * Return a list of source changes composed by merging the lists of source
+   * changes in the [partialResultList].
+   *
+   * The resulting list will contain all of the source changes from all of the
+   * plugins. If two or more plugins contribute the same source change the
+   * resulting list will contain duplications.
+   */
   List<SourceChange> mergeSourceChanges(
       List<List<SourceChange>> partialResultList) {
     int count = partialResultList.length;
     if (count == 0) {
       return <SourceChange>[];
     } else if (count == 1) {
       return partialResultList[0];
     }
     List<SourceChange> mergedChanges = <SourceChange>[];
     for (List<SourceChange> partialResults in partialResultList) {
@@ skipping 15 matching lines @@
     if (leftEnd < rightStart || leftStart > rightEnd) {
       return false;
     }
     if (!allowNesting) {
       return true;
     }
     return !((leftStart <= rightStart && rightEnd <= leftEnd) ||
         (rightStart <= leftStart && leftEnd <= rightEnd));
   }
 }