add for() keyword suggestion

pkg/analysis_server/test/services/completion/keyword_contributor_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.
 
 library test.services.completion.dart.keyword;
 
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analysis_server/src/services/completion/keyword_contributor.dart';
 import 'package:analyzer/src/generated/scanner.dart';
@@ skipping 154 matching lines @@
     Keyword.TRUE,
   ];
 
   static const List<Keyword> EXPRESSION_START_NO_INSTANCE = const [
     Keyword.FALSE,
     Keyword.NEW,
     Keyword.NULL,
     Keyword.TRUE,
   ];
 
+  static final Map<String, List<String>> keywordTemplates =
+      <String, List<String>>{
+    Keyword.IMPORT.syntax: [
+      "import '^';",
+      "import '^' as ;",
+      "import '^' hide ;",
+      "import '^' show ;"
+    ],
+    Keyword.FOR.syntax: ['for (^)']
+  };
+
   void assertSuggestKeywords(Iterable<Keyword> expectedKeywords,
       {List<String> pseudoKeywords: NO_PSEUDO_KEYWORDS,
       int relevance: DART_RELEVANCE_KEYWORD}) {
     Set<String> expectedCompletions = new Set<String>();
+    Map<String, int> expectedOffsets = <String, int>{};
     Set<String> actualCompletions = new Set<String>();
     expectedCompletions.addAll(expectedKeywords.map((k) => k.syntax));
     expectedCompletions.addAll(pseudoKeywords);
-    if (expectedCompletions.contains(Keyword.IMPORT.syntax)) {
-      expectedCompletions.remove(Keyword.IMPORT.syntax);
-      expectedCompletions.add("import '';");
-      expectedCompletions.add("import '' as ;");
-      expectedCompletions.add("import '' hide ;");
-      expectedCompletions.add("import '' show ;");
-    }
+    keywordTemplates.forEach((String key, List<String> templates) {
+      if (expectedCompletions.remove(key)) {
+        for (String t in templates) {
+          int offset = t.indexOf('^');
+          if (offset != -1) {
+            t = '${t.substring(0, offset)}${t.substring(offset + 1)}';
+            expectedOffsets[t] = offset;
+          }
+          expectedCompletions.add(t);
+        }
+      }
+    });
     for (CompletionSuggestion s in request.suggestions) {
       if (s.kind == CompletionSuggestionKind.KEYWORD) {
         Keyword k = Keyword.keywords[s.completion];
         if (k == null && !expectedCompletions.contains(s.completion)) {
           fail('Invalid keyword suggested: ${s.completion}');
         } else {
           if (!actualCompletions.add(s.completion)) {
             fail('Duplicate keyword suggested: ${s.completion}');
           }
         }
       }
     }
     if (!_equalSets(expectedCompletions, actualCompletions)) {
       StringBuffer msg = new StringBuffer();
       msg.writeln('Expected:');
       _appendCompletions(msg, expectedCompletions, actualCompletions);
       msg.writeln('but found:');
       _appendCompletions(msg, actualCompletions, expectedCompletions);
       fail(msg.toString());
     }
     for (CompletionSuggestion s in request.suggestions) {
       if (s.kind == CompletionSuggestionKind.KEYWORD) {
         if (s.completion.startsWith(Keyword.IMPORT.syntax)) {
           int importRelevance = relevance;
           if (importRelevance == DART_RELEVANCE_HIGH &&
               s.completion == "import '';") {
             ++importRelevance;
           }
           expect(s.relevance, equals(importRelevance), reason: s.completion);
-          expect(s.selectionOffset, equals(Keyword.IMPORT.syntax.length + 2));
         } else {
           if (s.completion == Keyword.RETHROW.syntax) {
             expect(s.relevance, equals(relevance - 1), reason: s.completion);
           } else {
             expect(s.relevance, equals(relevance), reason: s.completion);
           }
-          expect(s.selectionOffset, equals(s.completion.length));
         }
+        int expectedOffset = expectedOffsets[s.completion];
+        if (expectedOffset == null) {
+          expectedOffset = s.completion.length;
+        }
+        expect(s.selectionOffset, equals(expectedOffset));
         expect(s.selectionLength, equals(0));
         expect(s.isDeprecated, equals(false));
         expect(s.isPotential, equals(false));
       }
     }
   }
 
   @override
   void setUpContributor() {
     contributor = new KeywordContributor();
@@ skipping 891 matching lines @@
         (c) => msg.writeln('  $c, ${other.contains(c) ? '' : '<<<<<<<<<<<'}'));
   }
 
   bool _equalSets(Iterable<String> iter1, Iterable<String> iter2) {
     if (iter1.length != iter2.length) return false;
     if (iter1.any((c) => !iter2.contains(c))) return false;
     if (iter2.any((c) => !iter1.contains(c))) return false;
     return true;
   }
 }