Make Change implementation consistent with the server spec.

pkg/analysis_services/test/correction/fix_test.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 code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library test.services.correction.fix;
 
 import 'package:analysis_services/correction/change.dart';
@@ skipping 32 matching lines @@
     change = fix.change;
     // apply to "file"
     List<FileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     resultCode = _applyEdits(testCode, change.edits[0].edits);
     // verify
     expect(resultCode, expected);
   }
 
   void assertHasPositionGroup(String id, List<Position> expectedPositions) {
-    List<LinkedPositionGroup> linkedPositionGroups =
-        change.linkedPositionGroups;
-    for (LinkedPositionGroup group in linkedPositionGroups) {
+    List<LinkedEditGroup> linkedPositionGroups = change.linkedEditGroups;
+    for (LinkedEditGroup group in linkedPositionGroups) {
       if (group.id == id) {
         expect(group.positions, unorderedEquals(expectedPositions));
         return;
       }
     }
     fail('No PositionGroup with id=$id found in $linkedPositionGroups');
   }
 
   void assertNoFix(FixKind kind) {
     AnalysisError error = _findErrorToFix();
@@ skipping 19 matching lines @@
 }
 
 bool test() {
 }
 ''');
   }
 
   Position expectedPosition(String search) {
     int offset = resultCode.indexOf(search);
     int length = getLeadingIdentifierLength(search);
-    return new Position(testFile, offset, length);
+    return new Position(testFile, offset);
   }
 
   List<Position> expectedPositions(List<String> patterns) {
     List<Position> positions = <Position>[];
     patterns.forEach((String search) {
       positions.add(expectedPosition(search));
     });
     return positions;
   }
 
@@ skipping 1495 matching lines @@
         'NAME',
         ['myUndefinedMethod(0', 'myUndefinedMethod(int']);
     _assertHasLinkedPositions('RETURN_TYPE', ['void myUndefinedMethod(']);
     _assertHasLinkedPositions('TYPE0', ['int i']);
     _assertHasLinkedPositions('TYPE1', ['double d']);
     _assertHasLinkedPositions('TYPE2', ['String s']);
     _assertHasLinkedPositions('ARG0', ['i,']);
     _assertHasLinkedPositions('ARG1', ['d,']);
     _assertHasLinkedPositions('ARG2', ['s)']);
     // linked proposals
-    _assertHasLinkedProposals('TYPE0', ['int', 'num', 'Object', 'Comparable']);
-    _assertHasLinkedProposals(
+    _assertHasLinkedSuggestions(
+        'TYPE0',
+        expectedSuggestions(
+            LinkedEditSuggestionKind.TYPE,
+            ['int', 'num', 'Object', 'Comparable']));
+    _assertHasLinkedSuggestions(
         'TYPE1',
-        ['double', 'num', 'Object', 'Comparable']);
-    _assertHasLinkedProposals('TYPE2', ['String', 'Object', 'Comparable']);
+        expectedSuggestions(
+            LinkedEditSuggestionKind.TYPE,
+            ['double', 'num', 'Object', 'Comparable']));
+    _assertHasLinkedSuggestions(
+        'TYPE2',
+        expectedSuggestions(
+            LinkedEditSuggestionKind.TYPE,
+            ['String', 'Object', 'Comparable']));
+  }
+
+  List<LinkedEditSuggestion> expectedSuggestions(LinkedEditSuggestionKind kind,
+      List<String> values) {
+    return values.map((value) {
+      return new LinkedEditSuggestion(kind, value);
+    }).toList();
   }
 
   void test_undefinedMethod_createUnqualified_returnType() {
     _indexTestUnit('''
 class A {
   main() {
     int v = myUndefinedMethod();
   }
 }
 ''');
@@ skipping 178 matching lines @@
     for (Fix fix in fixes) {
       if (fix.kind == kind) {
         return fix;
       }
     }
     throw fail('Expected to find fix $kind in\n${fixes.join('\n')}');
   }
 
   void _assertHasLinkedPositions(String groupId, List<String> expectedStrings) {
     List<Position> expectedPositions = _findResultPositions(expectedStrings);
-    List<LinkedPositionGroup> groups = change.linkedPositionGroups;
-    for (LinkedPositionGroup group in groups) {
+    List<LinkedEditGroup> groups = change.linkedEditGroups;
+    for (LinkedEditGroup group in groups) {
       if (group.id == groupId) {
         List<Position> actualPositions = group.positions;
         expect(actualPositions, unorderedEquals(expectedPositions));
         return;
       }
     }
     fail('No group with ID=$groupId foind in\n${groups.join('\n')}');
   }
 
-  void _assertHasLinkedProposals(String groupId, List<String> expected) {
-    List<LinkedPositionGroup> groups = change.linkedPositionGroups;
-    for (LinkedPositionGroup group in groups) {
+  void _assertHasLinkedSuggestions(String groupId,
+      List<LinkedEditSuggestion> expected) {
+    List<LinkedEditGroup> groups = change.linkedEditGroups;
+    for (LinkedEditGroup group in groups) {
       if (group.id == groupId) {
-        expect(group.proposals, expected);
+        expect(group.suggestions, expected);
         return;
       }
     }
     fail('No group with ID=$groupId foind in\n${groups.join('\n')}');
   }
 
   /**
    * We search for elements only already resolved lbiraries, and we use
    * `dart:async` elements in tests.
    */
@@ skipping 17 matching lines @@
         reason: 'Exactly 1 error expected, but ${errors.length} found:\n' +
             errors.join('\n'));
     return errors[0];
   }
 
   List<Position> _findResultPositions(List<String> searchStrings) {
     List<Position> positions = <Position>[];
     for (String search in searchStrings) {
       int offset = resultCode.indexOf(search);
       int length = getLeadingIdentifierLength(search);
-      positions.add(new Position(testFile, offset, length));
+      positions.add(new Position(testFile, offset));
     }
     return positions;
   }
 
   void _indexTestUnit(String code) {
     resolveTestUnit(code);
     index.indexUnit(context, testUnit);
   }
 }