Make Change implementation consistent with the server spec.

pkg/analysis_services/test/correction/assist_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.assist;
 
 import 'package:analysis_services/correction/assist.dart';
@@ skipping 16 matching lines @@
 class AssistProcessorTest extends AbstractSingleUnitTest {
   Index index;
   SearchEngineImpl searchEngine;
 
   int offset;
   int length;
 
   Assist assist;
   Change change;
   String resultCode;
-  LinkedPositionGroup linkedPositionGroup;
+  LinkedEditGroup linkedPositionGroup;
 
   /**
    * Asserts that there is an [Assist] of the given [kind] at [offset] which
    * produces the [expected] code when applied to [testCode].
    */
   void assertHasAssist(AssistKind kind, String expected) {
     assist = _assertHasAssist(kind);
     change = assist.change;
     // apply to "file"
     List<FileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     resultCode = _applyEdits(testCode, change.edits[0].edits);
     // verify
     expect(resultCode, expected);
   }
 
   /**
    * Calls [assertHasAssist] at the offset of [offsetSearch] in [testCode].
    */
   void assertHasAssistAt(String offsetSearch, AssistKind kind,
       String expected) {
     offset = findOffset(offsetSearch);
     assertHasAssist(kind, expected);
   }
 
-  void assertHasPositionGroup(String id, List<Position> expectedPositions) {
-    List<LinkedPositionGroup> linkedPositionGroups =
-        change.linkedPositionGroups;
-    for (LinkedPositionGroup group in linkedPositionGroups) {
+  void assertHasPositionGroup(String id, int expectedLength,
+      List<Position> expectedPositions) {
+    List<LinkedEditGroup> linkedPositionGroups = change.linkedEditGroups;
+    for (LinkedEditGroup group in linkedPositionGroups) {
       if (group.id == id) {
+        expect(group.length, expectedLength);
         expect(group.positions, unorderedEquals(expectedPositions));
         linkedPositionGroup = group;
         return;
       }
     }
     fail('No PositionGroup with id=$id found in $linkedPositionGroups');
   }
 
   /**
    * Asserts that there is no [Assist] of the given [kind] at [offset].
@@ skipping 11 matching lines @@
   /**
    * Calls [assertNoAssist] at the offset of [offsetSearch] in [testCode].
    */
   void assertNoAssistAt(String offsetSearch, AssistKind kind) {
     offset = findOffset(offsetSearch);
     assertNoAssist(kind);
   }
 
   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;
   }
 
+  List<LinkedEditSuggestion> expectedSuggestions(LinkedEditSuggestionKind kind,
+      List<String> values) {
+    return values.map((value) {
+      return new LinkedEditSuggestion(kind, value);
+    }).toList();
+  }
+
   void setUp() {
     super.setUp();
     index = createLocalMemoryIndex();
     searchEngine = new SearchEngineImpl(index);
     offset = 0;
     length = 0;
   }
 
   void test_addTypeAnnotation_classField_OK_final() {
     _indexTestUnit('''
@@ skipping 177 matching lines @@
 }
 List<int> readBytes() => <int>[];
 ''');
     assertHasAssistAt('readBytes();', AssistKind.ASSIGN_TO_LOCAL_VARIABLE, '''
 main() {
   List<int> bytes;
   var readBytes = readBytes();
 }
 List<int> readBytes() => <int>[];
 ''');
-    assertHasPositionGroup('NAME', expectedPositions(['readBytes = ']));
+    assertHasPositionGroup('NAME', 9, expectedPositions(['readBytes = ']));
     expect(
-        linkedPositionGroup.proposals,
-        unorderedEquals(['list', 'bytes2', 'readBytes']));
+        linkedPositionGroup.suggestions,
+        unorderedEquals(
+            expectedSuggestions(
+                LinkedEditSuggestionKind.VARIABLE,
+                ['list', 'bytes2', 'readBytes'])));
   }
 
   void test_assignToLocalVariable_alreadyAssignment() {
     _indexTestUnit('''
 main() {
   var vvv;
   vvv = 42;
 }
 ''');
     assertNoAssistAt('vvv =', AssistKind.ASSIGN_TO_LOCAL_VARIABLE);
@@ skipping 1698 matching lines @@
     for (Assist assist in assists) {
       if (assist.kind == kind) {
         return assist;
       }
     }
     throw fail('Expected to find assist $kind in\n${assists.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) {
+    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')}');
   }
 
   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);
   }
 }