suggest keywords for switch statement and expressions

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 60 matching lines @@
     Keyword.PART,
     Keyword.TYPEDEF,
     Keyword.VAR,
     Keyword.VOID
   ];
 
   static const List<String> NO_PSEUDO_KEYWORDS = const [];
 
   static const List<Keyword> STMT_START_IN_CLASS = const [
     Keyword.ASSERT,
-    Keyword.CASE,
     Keyword.CONTINUE,
     Keyword.DO,
     Keyword.FINAL,
     Keyword.FOR,
+    Keyword.IF,
+    Keyword.NEW,
+    Keyword.RETHROW,
+    Keyword.RETURN,
+    Keyword.SUPER,
+    Keyword.SWITCH,
+    Keyword.THIS,
+    Keyword.THROW,
+    Keyword.TRY,
+    Keyword.VAR,
+    Keyword.VOID,
+    Keyword.WHILE
+  ];
+
+  static const List<Keyword> STMT_START_IN_SWITCH_IN_CLASS = const [
+    Keyword.ASSERT,
+    Keyword.CASE,
+    Keyword.CONTINUE,
+    Keyword.DEFAULT,
+    Keyword.DO,
+    Keyword.FINAL,
+    Keyword.FOR,
     Keyword.IF,
     Keyword.NEW,
     Keyword.RETHROW,
     Keyword.RETURN,
     Keyword.SUPER,
     Keyword.SWITCH,
     Keyword.THIS,
     Keyword.THROW,
     Keyword.TRY,
     Keyword.VAR,
     Keyword.VOID,
     Keyword.WHILE
   ];
 
+  static const List<Keyword> STMT_START_IN_SWITCH_OUTSIDE_CLASS = const [
+    Keyword.ASSERT,
+    Keyword.CASE,
+    Keyword.CONTINUE,
+    Keyword.DEFAULT,
+    Keyword.DO,
+    Keyword.FINAL,
+    Keyword.FOR,
+    Keyword.IF,
+    Keyword.NEW,
+    Keyword.RETHROW,
+    Keyword.RETURN,
+    Keyword.SWITCH,
+    Keyword.THROW,
+    Keyword.TRY,
+    Keyword.VAR,
+    Keyword.VOID,
+    Keyword.WHILE
+  ];
+
   static const List<Keyword> STMT_START_OUTSIDE_CLASS = const [
     Keyword.ASSERT,
-    Keyword.CASE,
     Keyword.CONTINUE,
     Keyword.DO,
     Keyword.FINAL,
     Keyword.FOR,
     Keyword.IF,
     Keyword.NEW,
     Keyword.RETHROW,
     Keyword.RETURN,
     Keyword.SWITCH,
     Keyword.THROW,
     Keyword.TRY,
     Keyword.VAR,
     Keyword.VOID,
     Keyword.WHILE
   ];
 
+  static const List<Keyword> EXPRESSION_START_INSTANCE = const [
+    Keyword.FALSE,
+    Keyword.NEW,
+    Keyword.NULL,
+    Keyword.SUPER,
+    Keyword.THIS,
+    Keyword.TRUE,
+  ];
+
+  static const List<Keyword> EXPRESSION_START_NO_INSTANCE = const [
+    Keyword.FALSE,
+    Keyword.NEW,
+    Keyword.NULL,
+    Keyword.TRUE,
+  ];
+
   void assertSuggestKeywords(Iterable<Keyword> expectedKeywords,
       {List<String> pseudoKeywords: NO_PSEUDO_KEYWORDS,
       int relevance: DART_RELEVANCE_KEYWORD}) {
     Set<String> expectedCompletions = new Set<String>();
     Set<String> actualCompletions = new Set<String>();
     expectedCompletions.addAll(expectedKeywords.map((k) => k.syntax));
     expectedCompletions.addAll(pseudoKeywords);
     for (CompletionSuggestion s in request.suggestions) {
       if (s.kind == CompletionSuggestionKind.KEYWORD) {
         Keyword k = Keyword.keywords[s.completion];
         if (k == null && !pseudoKeywords.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);
+      _appendCompletions(msg, expectedCompletions, actualCompletions);
       msg.writeln('but found:');
-      _appendCompletions(msg, actualCompletions);
+      _appendCompletions(msg, actualCompletions, expectedCompletions);
       fail(msg.toString());
     }
     for (CompletionSuggestion s in request.suggestions) {
       if (s.kind == CompletionSuggestionKind.KEYWORD) {
         expect(s.relevance, equals(relevance), reason: s.completion);
         expect(s.selectionOffset, equals(s.completion.length));
         expect(s.selectionLength, equals(0));
         expect(s.isDeprecated, equals(false));
         expect(s.isPotential, equals(false));
       }
@@ skipping 24 matching lines @@
         relevance: DART_RELEVANCE_HIGH);
   }
 
   test_after_import2() {
     addTestSource('import "foo"; c^');
     expect(computeFast(), isTrue);
     assertSuggestKeywords(DIRECTIVE_AND_DECLARATION_KEYWORDS,
         relevance: DART_RELEVANCE_HIGH);
   }
 
+  test_argument() {
+    addTestSource('main() {foo(^);}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_argument2() {
+    addTestSource('main() {foo(n^);}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_argument_literal() {
+    addTestSource('main() {foo("^");}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords([]);
+  }
+
+  test_argument_named() {
+    addTestSource('main() {foo(bar: ^);}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_argument_named2() {
+    addTestSource('main() {foo(bar: n^);}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_argument_named_literal() {
+    addTestSource('main() {foo(bar: "^");}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords([]);
+  }
+
+  test_assignment_field() {
+    addTestSource('class A {var foo = ^}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_assignment_field2() {
+    addTestSource('class A {var foo = n^}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_assignment_local() {
+    addTestSource('main() {var foo = ^}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_assignment_local2() {
+    addTestSource('main() {var foo = n^}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_assignment_local2_async() {
+    addTestSource('main() async {var foo = n^}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE,
+        pseudoKeywords: ['await']);
+  }
+
+  test_assignment_local_async() {
+    addTestSource('main() async {var foo = ^}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE,
+        pseudoKeywords: ['await']);
+  }
+
   test_before_import() {
     addTestSource('^ import foo;');
     expect(computeFast(), isTrue);
     assertSuggestKeywords(
         [Keyword.EXPORT, Keyword.IMPORT, Keyword.LIBRARY, Keyword.PART],
         relevance: DART_RELEVANCE_HIGH);
   }
 
   test_class() {
     addTestSource('class A e^ { }');
@@ skipping 191 matching lines @@
 foo(p) {}
 class A {
   final f;
   A() : f = foo(() {^});
 }
 ''');
     expect(computeFast(), isTrue);
     assertSuggestKeywords(STMT_START_OUTSIDE_CLASS);
   }
 
+  test_function_body_inClass_constructorInitializer_async() {
+    addTestSource(r'''
+foo(p) {}
+class A {
+  final f;
+  A() : f = foo(() async {^});
+}
+''');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(STMT_START_OUTSIDE_CLASS, pseudoKeywords: ['await']);
+  }
+
   test_function_body_inClass_field() {
     addTestSource(r'''
 class A {
   var f = () {^};
 }
 ''');
     expect(computeFast(), isTrue);
     assertSuggestKeywords(STMT_START_OUTSIDE_CLASS);
   }
 
@@ skipping 16 matching lines @@
     f() {
       f2() {^};
     };
   }
 }
 ''');
     expect(computeFast(), isTrue);
     assertSuggestKeywords(STMT_START_IN_CLASS);
   }
 
+  test_function_body_inClass_methodBody_inFunction_async() {
+    addTestSource(r'''
+class A {
+  m() {
+    f() {
+      f2() async {^};
+    };
+  }
+}
+''');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(STMT_START_IN_CLASS, pseudoKeywords: ['await']);
+  }
+
   test_function_body_inUnit() {
     addTestSource('main() {^}');
     expect(computeFast(), isTrue);
     assertSuggestKeywords(STMT_START_OUTSIDE_CLASS);
   }
 
   test_function_body_inUnit_afterBlock() {
     addTestSource('main() {{}^}');
     expect(computeFast(), isTrue);
     assertSuggestKeywords(STMT_START_OUTSIDE_CLASS);
@@ skipping 216 matching lines @@
 
   test_method_body() {
     addTestSource('class A { foo() {^}}');
     expect(computeFast(), isTrue);
     assertSuggestKeywords(STMT_START_IN_CLASS);
   }
 
   test_method_body2() {
     addTestSource('class A { foo() => ^}');
     expect(computeFast(), isTrue);
-    assertSuggestKeywords(STMT_START_IN_CLASS);
+    assertSuggestKeywords(EXPRESSION_START_INSTANCE);
   }
 
   test_method_body3() {
     addTestSource('class A { foo() => ^ Foo foo;}');
     expect(computeFast(), isTrue);
-    assertSuggestKeywords(STMT_START_IN_CLASS);
+    assertSuggestKeywords(EXPRESSION_START_INSTANCE);
   }
 
   test_method_body4() {
     addTestSource('class A { foo() => ^;}');
     expect(computeFast(), isTrue);
-    assertSuggestKeywords(STMT_START_IN_CLASS);
+    assertSuggestKeywords(EXPRESSION_START_INSTANCE);
   }
 
   test_method_body_async() {
     addTestSource('class A { foo() async {^}}');
     expect(computeFast(), isTrue);
     assertSuggestKeywords(STMT_START_IN_CLASS, pseudoKeywords: ['await']);
   }
 
   test_method_body_async2() {
     addTestSource('class A { foo() async => ^}');
     expect(computeFast(), isTrue);
-    assertSuggestKeywords(STMT_START_IN_CLASS, pseudoKeywords: ['await']);
+    assertSuggestKeywords(EXPRESSION_START_INSTANCE, pseudoKeywords: ['await']);
   }
 
   test_method_body_async3() {
     addTestSource('class A { foo() async => ^ Foo foo;}');
     expect(computeFast(), isTrue);
-    assertSuggestKeywords(STMT_START_IN_CLASS, pseudoKeywords: ['await']);
+    assertSuggestKeywords(EXPRESSION_START_INSTANCE, pseudoKeywords: ['await']);
   }
 
   test_method_body_async4() {
     addTestSource('class A { foo() async => ^;}');
     expect(computeFast(), isTrue);
-    assertSuggestKeywords(STMT_START_IN_CLASS, pseudoKeywords: ['await']);
+    assertSuggestKeywords(EXPRESSION_START_INSTANCE, pseudoKeywords: ['await']);
   }
 
   test_method_param() {
     addTestSource('class A { foo(^) {});}');
     expect(computeFast(), isTrue);
     assertNoSuggestions();
   }
 
   test_method_param2() {
     addTestSource('class A { foo(t^) {});}');
@@ skipping 21 matching lines @@
         relevance: DART_RELEVANCE_HIGH);
   }
 
   test_partial_class2() {
     addTestSource('library a; cl^');
     expect(computeFast(), isTrue);
     assertSuggestKeywords(DIRECTIVE_AND_DECLARATION_KEYWORDS,
         relevance: DART_RELEVANCE_HIGH);
   }
 
-  void _appendCompletions(StringBuffer msg, Iterable<String> completions) {
+  test_switch_expression() {
+    addTestSource('main() {switch(^) {}}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_switch_expression2() {
+    addTestSource('main() {switch(n^) {}}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_switch_expression3() {
+    addTestSource('main() {switch(n^)}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(EXPRESSION_START_NO_INSTANCE);
+  }
+
+  test_switch_start() {
+    addTestSource('main() {switch(1) {^}}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords([Keyword.CASE, Keyword.DEFAULT],
+        relevance: DART_RELEVANCE_HIGH);
+  }
+
+  test_switch_start2() {
+    addTestSource('main() {switch(1) {^ case 1:}}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords([Keyword.CASE, Keyword.DEFAULT],
+        relevance: DART_RELEVANCE_HIGH);
+  }
+
+  test_switch_start3() {
+    addTestSource('main() {switch(1) {^default:}}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords([Keyword.CASE, Keyword.DEFAULT],
+        relevance: DART_RELEVANCE_HIGH);
+  }
+
+  test_switch_start4() {
+    addTestSource('main() {switch(1) {^ default:}}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords([Keyword.CASE, Keyword.DEFAULT],
+        relevance: DART_RELEVANCE_HIGH);
+  }
+
+  test_switch_statement() {
+    addTestSource('main() {switch(1) {case 1:^}}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(STMT_START_IN_SWITCH_OUTSIDE_CLASS);
+  }
+
+  test_switch_statement2() {
+    addTestSource('class A{foo() {switch(1) {case 1:^}}}');
+    expect(computeFast(), isTrue);
+    assertSuggestKeywords(STMT_START_IN_SWITCH_IN_CLASS);
+  }
+
+  void _appendCompletions(
+      StringBuffer msg, Iterable<String> completions, Iterable<String> other) {
     List<String> sorted = completions.toList();
     sorted.sort((c1, c2) => c1.compareTo(c2));
-    sorted.forEach((c) => msg.writeln('  $c,'));
+    sorted.forEach(
+        (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;
   }
 }