Use toList to copy lists and clean up errors and warnings

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:meta/meta.dart';
 
 /**
@@ skipping 29 matching lines @@
       buffer.write(error.correction);
       return buffer.toString();
     }
 
     int count = partialResultList.length;
     if (count == 0) {
       return <AnalysisErrorFixes>[];
     } else if (count == 1) {
       return partialResultList[0];
     }
-    List<AnalysisErrorFixes> mergedFixes =
-        new List<AnalysisErrorFixes>.from(partialResultList[0]);
+    List<AnalysisErrorFixes> mergedFixes = partialResultList[0].toList();
     Map<String, AnalysisErrorFixes> fixesMap = <String, AnalysisErrorFixes>{};
     for (AnalysisErrorFixes fix in mergedFixes) {
       fixesMap[computeKey(fix.error)] = fix;
     }
     for (int i = 1; i < count; i++) {
       for (AnalysisErrorFixes fix in partialResultList[i]) {
         String key = computeKey(fix.error);
         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 =
-              new List<SourceChange>.from(mergedFix.fixes);
+          List<SourceChange> mergedChanges = mergedFix.fixes.toList();
           mergedChanges.addAll(fix.fixes);
           AnalysisErrorFixes copiedFix =
               new AnalysisErrorFixes(mergedFix.error, fixes: mergedChanges);
           mergedFixes[mergedFixes.indexOf(mergedFix)] = copiedFix;
           fixesMap[key] = copiedFix;
         }
       }
     }
     return mergedFixes;
   }
@@ skipping 58 matching lines @@
    * considered to be overlapping.)
    */
   List<FoldingRegion> mergeFoldingRegions(
       List<List<FoldingRegion>> partialResultList) {
     int count = partialResultList.length;
     if (count == 0) {
       return <FoldingRegion>[];
     } else if (count == 1) {
       return partialResultList[0];
     }
-    List<FoldingRegion> mergedRegions =
-        new List<FoldingRegion>.from(partialResultList[0]);
+    List<FoldingRegion> mergedRegions = partialResultList[0].toList();
 
     /**
      * Return `true` if the [newRegion] does not overlap any of the regions in
      * the collection of [mergedRegions].
      */
     bool isNonOverlapping(FoldingRegion newRegion) {
       int newStart = newRegion.offset;
       int newEnd = newStart + newRegion.length;
       for (FoldingRegion existingRegion in mergedRegions) {
         int existingStart = existingRegion.offset;
@@ skipping 52 matching lines @@
   AnalysisNavigationParams mergeNavigation(
       List<AnalysisNavigationParams> partialResultList) {
     int count = partialResultList.length;
     if (count == 0) {
       return null;
     } else if (count == 1) {
       return partialResultList[0];
     }
     AnalysisNavigationParams base = partialResultList[0];
     String file = base.file;
-    List<NavigationRegion> mergedRegions =
-        new List<NavigationRegion>.from(base.regions);
-    List<NavigationTarget> mergedTargets =
-        new List<NavigationTarget>.from(base.targets);
-    List<String> mergedFiles = new List<String>.from(base.files);
+    List<NavigationRegion> mergedRegions = base.regions.toList();
+    List<NavigationTarget> mergedTargets = base.targets.toList();
+    List<String> mergedFiles = base.files.toList();
 
     /**
      * Return `true` if the [newRegion] does not overlap any of the regions in
      * the collection of [mergedRegions].
      */
     bool isNonOverlapping(NavigationRegion newRegion) {
       int newStart = newRegion.offset;
       int newEnd = newStart + newRegion.length;
       for (NavigationRegion mergedRegion in mergedRegions) {
         int mergedStart = mergedRegion.offset;
@@ skipping 85 matching lines @@
             if (!mergedTargets.contains(target)) {
               if (added) {
                 mergedTargets.add(target);
               } else {
                 //
                 // This is potentially inefficient. If a merged region matches
                 // regions from multiple plugins it will be copied multiple
                 // times. The likelihood seems small enough to not warrant
                 // optimizing this further.
                 //
-                mergedTargets = new List<int>.from(mergedTargets);
+                mergedTargets = mergedTargets.toList();
                 mergedTargets.add(target);
                 mergedRegion = new NavigationRegion(
                     mergedRegion.offset, mergedRegion.length, mergedTargets);
                 mergedRegions[index] = mergedRegion;
                 added = true;
               }
             }
           }
           if (added) {
             mergedTargets.sort();
@@ skipping 73 matching lines @@
       buffer.write(element.kind.name);
       return buffer.toString();
     }
 
     int count = partialResultList.length;
     if (count == 0) {
       return <Outline>[];
     } else if (count == 1) {
       return partialResultList[0];
     }
-    List<Outline> mergedOutlines = new List<Outline>.from(partialResultList[0]);
+    List<Outline> mergedOutlines = partialResultList[0].toList();
     Map<String, Outline> outlineMap = <String, Outline>{};
     Map<Outline, Outline> copyMap = <Outline, Outline>{};
 
     /**
      * Add the given [outline] and all of its children to the [outlineMap].
      */
     void addToMap(Outline outline) {
       String key = computeKey(outline.element);
       if (outlineMap.containsKey(key)) {
         // TODO(brianwilkerson) Decide how to handle this more gracefully.
         throw new StateError('Inconsistent outlines');
       }
       outlineMap[key] = outline;
       outline.children?.forEach(addToMap);
     }
 
     /**
      * Merge the children of the [newOutline] into the list of children of the
      * [mergedOutline].
      */
     void mergeChildren(Outline mergedOutline, Outline newOutline) {
       for (Outline newChild in newOutline.children) {
         Outline mergedChild = outlineMap[computeKey(newChild.element)];
         if (mergedChild == null) {
           // The [newChild] isn't in the existing list.
           Outline copiedOutline = copyMap.putIfAbsent(
               mergedOutline,
               () => new Outline(mergedOutline.element, mergedOutline.offset,
                   mergedOutline.length,
-                  children: new List<Outline>.from(mergedOutline.children)));
+                  children: mergedOutline.children.toList()));
           copiedOutline.children.add(newChild);
           addToMap(newChild);
         } else {
           mergeChildren(mergedChild, newChild);
         }
       }
     }
 
     mergedOutlines.forEach(addToMap);
     for (int i = 1; i < count; i++) {
@@ skipping 17 matching lines @@
      * been updated by the merge process.
      */
     Outline traverse(Outline outline) {
       Outline copiedOutline = copyMap[outline];
       bool isCopied = copiedOutline != null;
       copiedOutline ??= outline;
       List<Outline> currentChildren = copiedOutline.children;
       if (currentChildren.isEmpty) {
         return outline;
       }
-      Iterable<Outline> updatedChildren =
-          currentChildren.map((Outline child) => traverse(child));
+      List<Outline> updatedChildren =
+          currentChildren.map((Outline child) => traverse(child)).toList();
       if (currentChildren != updatedChildren) {
         if (!isCopied) {
           return new Outline(
               copiedOutline.element, copiedOutline.offset, copiedOutline.length,
-              children: updatedChildren.toList());
+              children: updatedChildren);
         }
-        copiedOutline.children = updatedChildren.toList();
+        copiedOutline.children = updatedChildren;
         return copiedOutline;
       }
       return outline;
     }
 
     for (int i = 0; i < mergedOutlines.length; i++) {
       mergedOutlines[i] = traverse(mergedOutlines[i]);
     }
     return mergedOutlines;
   }
@@ skipping 22 matching lines @@
     if (first is ConvertGetterToMethodFeedback) {
       // The feedbacks are empty, so there's nothing to merge.
       return first;
     } else if (first is ConvertMethodToGetterFeedback) {
       // The feedbacks are empty, so there's nothing to merge.
       return first;
     } else if (first is ExtractLocalVariableFeedback) {
       List<int> coveringExpressionOffsets =
           first.coveringExpressionOffsets == null
               ? <int>[]
-              : new List<int>.from(first.coveringExpressionOffsets);
+              : first.coveringExpressionOffsets.toList();
       List<int> coveringExpressionLengths =
           first.coveringExpressionLengths == null
               ? <int>[]
-              : new List<int>.from(first.coveringExpressionLengths);
-      List<String> names = new List<String>.from(first.names);
-      List<int> offsets = new List<int>.from(first.offsets);
-      List<int> lengths = new List<int>.from(first.lengths);
+              : first.coveringExpressionLengths.toList();
+      List<String> names = first.names.toList();
+      List<int> offsets = first.offsets.toList();
+      List<int> lengths = first.lengths.toList();
       for (int i = 1; i < count; i++) {
         ExtractLocalVariableFeedback feedback = feedbacks[i];
         // TODO(brianwilkerson) This doesn't ensure that the covering data is in
         // the right order and consistent.
         if (feedback.coveringExpressionOffsets != null) {
           coveringExpressionOffsets.addAll(feedback.coveringExpressionOffsets);
         }
         if (feedback.coveringExpressionLengths != null) {
           coveringExpressionLengths.addAll(feedback.coveringExpressionLengths);
         }
         for (String name in feedback.names) {
           if (!names.contains(name)) {
             names.add(name);
           }
         }
         offsets.addAll(feedback.offsets);
         lengths.addAll(feedback.lengths);
       }
       return new ExtractLocalVariableFeedback(names.toList(), offsets, lengths,
           coveringExpressionOffsets: (coveringExpressionOffsets.isEmpty
               ? null
               : coveringExpressionOffsets),
           coveringExpressionLengths: (coveringExpressionLengths.isEmpty
               ? null
               : coveringExpressionLengths));
     } else if (first is ExtractMethodFeedback) {
       int offset = first.offset;
       int length = first.length;
       String returnType = first.returnType;
-      List<String> names = new List<String>.from(first.names);
+      List<String> names = first.names.toList();
       bool canCreateGetter = first.canCreateGetter;
       List<RefactoringMethodParameter> parameters = first.parameters;
-      List<int> offsets = new List<int>.from(first.offsets);
-      List<int> lengths = new List<int>.from(first.lengths);
+      List<int> offsets = first.offsets.toList();
+      List<int> lengths = first.lengths.toList();
       for (int i = 1; i < count; i++) {
         ExtractMethodFeedback feedback = feedbacks[i];
         if (returnType.isEmpty) {
           returnType = feedback.returnType;
         }
         for (String name in feedback.names) {
           if (!names.contains(name)) {
             names.add(name);
           }
         }
@@ skipping 86 matching lines @@
         return null;
       } else if (count == 1) {
         return changes[0];
       }
       SourceChange first = changes[0];
       String message = first.message;
       Map<String, SourceFileEdit> editMap = <String, SourceFileEdit>{};
       for (SourceFileEdit edit in first.edits) {
         editMap[edit.file] = edit;
       }
-      List<LinkedEditGroup> linkedEditGroups =
-          new List<LinkedEditGroup>.from(first.linkedEditGroups);
+      List<LinkedEditGroup> linkedEditGroups = first.linkedEditGroups.toList();
       Position selection = first.selection;
       for (int i = 1; i < count; i++) {
         SourceChange change = changes[i];
         for (SourceFileEdit edit in change.edits) {
           SourceFileEdit mergedEdit = editMap[edit.file];
           if (mergedEdit == null) {
             editMap[edit.file] = edit;
           } else {
             // This doesn't detect if multiple plugins contribute the same (or
             // conflicting) edits.
-            List<SourceEdit> edits =
-                new List<SourceEdit>.from(mergedEdit.edits);
+            List<SourceEdit> edits = mergedEdit.edits.toList();
             edits.addAll(edit.edits);
             editMap[edit.file] = new SourceFileEdit(
                 mergedEdit.file, mergedEdit.fileStamp,
                 edits: edits);
           }
         }
         linkedEditGroups.addAll(change.linkedEditGroups);
         message ??= change.message;
         selection ??= change.selection;
       }
       return new SourceChange(message,
           edits: editMap.values.toList(),
           linkedEditGroups: linkedEditGroups,
           selection: selection);
     }
 
     int count = partialResultList.length;
     if (count == 0) {
       return null;
     } else if (count == 1) {
       return partialResultList[0];
     }
     EditGetRefactoringResult result = partialResultList[0];
-    List<RefactoringProblem> initialProblems =
-        new List<RefactoringProblem>.from(result.initialProblems);
-    List<RefactoringProblem> optionsProblems =
-        new List<RefactoringProblem>.from(result.optionsProblems);
-    List<RefactoringProblem> finalProblems =
-        new List<RefactoringProblem>.from(result.finalProblems);
+    List<RefactoringProblem> initialProblems = result.initialProblems.toList();
+    List<RefactoringProblem> optionsProblems = result.optionsProblems.toList();
+    List<RefactoringProblem> finalProblems = result.finalProblems.toList();
     List<RefactoringFeedback> feedbacks = <RefactoringFeedback>[];
     if (result.feedback != null) {
       feedbacks.add(result.feedback);
     }
     List<SourceChange> changes = <SourceChange>[];
     if (result.change != null) {
       changes.add(result.change);
     }
-    List<String> potentialEdits = new List<String>.from(result.potentialEdits);
+    List<String> potentialEdits = result.potentialEdits.toList();
     for (int i = 1; i < count; i++) {
       EditGetRefactoringResult result = partialResultList[1];
       initialProblems.addAll(result.initialProblems);
       optionsProblems.addAll(result.optionsProblems);
       finalProblems.addAll(result.finalProblems);
       if (result.feedback != null) {
         feedbacks.add(result.feedback);
       }
       if (result.change != null) {
         changes.add(result.change);
@@ skipping 43 matching lines @@
     if (leftEnd < rightStart || leftStart > rightEnd) {
       return false;
     }
     if (!allowNesting) {
       return true;
     }
     return !((leftStart <= rightStart && rightEnd <= leftEnd) ||
         (rightStart <= leftStart && leftEnd <= rightEnd));
   }
 }