extract LabelContributor from local reference contributor

pkg/analysis_server/test/services/completion/local_reference_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.local;
 
 import 'package:analysis_server/plugin/protocol/protocol.dart' as protocol
     show Element, ElementKind;
 import 'package:analysis_server/plugin/protocol/protocol.dart'
     hide Element, ElementKind;
@@ skipping 156 matching lines @@
 void main() {
   foo: while (true) {
     var f = () {
       bar: while (true) { break ^ }
     };
   }
 }
 ''');
     expect(computeFast(), isTrue);
     // Labels in outer functions are never accessible.
-    assertSuggestLabel('bar');
+    assertNotSuggested('bar');
     assertNotSuggested('foo');
   }
 
   test_break_ignores_outer_functions_using_local_function() {
     addTestSource('''
 void main() {
   foo: while (true) {
     void f() {
       bar: while (true) { break ^ }
     };
   }
 }
 ''');
     expect(computeFast(), isTrue);
     // Labels in outer functions are never accessible.
-    assertSuggestLabel('bar');
+    assertNotSuggested('bar');
     assertNotSuggested('foo');
   }
 
   test_break_ignores_toplevel_variables() {
     addTestSource('''
 int x;
 void main() {
   while (true) {
     break ^
   }
@@ skipping 23 matching lines @@
     addTestSource('''
 void main() {
   foo: while (true) {
     bar: while (true) {
       break ^
     }
   }
 }
 ''');
     expect(computeFast(), isTrue);
-    assertSuggestLabel('foo');
-    assertSuggestLabel('bar');
+    assertNotSuggested('foo');
+    assertNotSuggested('bar');
   }
 
   test_constructor_parameters_mixed_required_and_named() {
     addTestSource('class A {A(x, {int y}) {^}}');
     expect(computeFast(), isTrue);
     assertSuggestParameter('x', null);
     assertSuggestParameter('y', 'int');
   }
 
   test_constructor_parameters_mixed_required_and_positional() {
@@ skipping 34 matching lines @@
       while (true) {
         continue ^;
       }
       break;
     baz: case 3:
       break;
   }
 }
 ''');
     expect(computeFast(), isTrue);
-    assertSuggestLabel('foo');
-    assertSuggestLabel('bar');
-    assertSuggestLabel('baz');
+    assertNotSuggested('foo');
+    assertNotSuggested('bar');
+    assertNotSuggested('baz');
   }
 
   test_continue_from_switch_to_loop() {
     addTestSource('''
 void main() {
   foo: while (true) {
     switch (x) {
       case 1:
         continue ^;
     }
   }
 }
 ''');
     expect(computeFast(), isTrue);
-    assertSuggestLabel('foo');
+    assertNotSuggested('foo');
   }
 
   test_continue_ignores_outer_functions_using_closure_with_loop() {
     addTestSource('''
 void main() {
   foo: while (true) {
     var f = () {
       bar: while (true) { continue ^ }
     };
   }
 }
 ''');
     expect(computeFast(), isTrue);
     // Labels in outer functions are never accessible.
-    assertSuggestLabel('bar');
+    assertNotSuggested('bar');
     assertNotSuggested('foo');
   }
 
   test_continue_ignores_outer_functions_using_closure_with_switch() {
     addTestSource('''
 void main() {
   switch (x) {
     foo: case 1:
       var f = () {
         bar: while (true) { continue ^ }
       };
   }
 }
 ''');
     expect(computeFast(), isTrue);
     // Labels in outer functions are never accessible.
-    assertSuggestLabel('bar');
+    assertNotSuggested('bar');
     assertNotSuggested('foo');
   }
 
   test_continue_ignores_outer_functions_using_local_function_with_loop() {
     addTestSource('''
 void main() {
   foo: while (true) {
     void f() {
       bar: while (true) { continue ^ }
     };
   }
 }
 ''');
     expect(computeFast(), isTrue);
     // Labels in outer functions are never accessible.
-    assertSuggestLabel('bar');
+    assertNotSuggested('bar');
     assertNotSuggested('foo');
   }
 
   test_continue_ignores_outer_functions_using_local_function_with_switch() {
     addTestSource('''
 void main() {
   switch (x) {
     foo: case 1:
       void f() {
         bar: while (true) { continue ^ }
       };
   }
 }
 ''');
     expect(computeFast(), isTrue);
     // Labels in outer functions are never accessible.
-    assertSuggestLabel('bar');
+    assertNotSuggested('bar');
     assertNotSuggested('foo');
   }
 
   test_continue_ignores_unrelated_statements() {
     addTestSource('''
 void main() {
   foo: while (true) {}
   while (true) { continue ^ }
   bar: while (true) {}
 }
@@ skipping 11 matching lines @@
 void main() {
   switch (x) {
     foo: case 1:
       break;
     case 2:
       continue ^;
     case 3:
       break;
 ''');
     expect(computeFast(), isTrue);
-    assertSuggestLabel('foo');
+    assertNotSuggested('foo');
   }
 
   test_continue_to_enclosing_loop() {
     addTestSource('''
 void main() {
   foo: while (true) {
     bar: while (true) {
       continue ^
     }
   }
 }
 ''');
     expect(computeFast(), isTrue);
-    assertSuggestLabel('foo');
-    assertSuggestLabel('bar');
+    assertNotSuggested('foo');
+    assertNotSuggested('bar');
   }
 
   test_continue_to_enclosing_switch() {
     addTestSource('''
 void main() {
   switch (x) {
     foo: case 1:
       break;
     bar: case 2:
       switch (y) {
         case 1:
           continue ^;
       }
       break;
     baz: case 3:
       break;
   }
 }
 ''');
     expect(computeFast(), isTrue);
-    assertSuggestLabel('foo');
-    assertSuggestLabel('bar');
-    assertSuggestLabel('baz');
+    assertNotSuggested('foo');
+    assertNotSuggested('bar');
+    assertNotSuggested('baz');
   }
 
   test_continue_to_later_case() {
     addTestSource('''
 void main() {
   switch (x) {
     case 1:
       break;
     case 2:
       continue ^;
     foo: case 3:
       break;
 ''');
     expect(computeFast(), isTrue);
-    assertSuggestLabel('foo');
+    assertNotSuggested('foo');
   }
 
   test_continue_to_same_case() {
     addTestSource('''
 void main() {
   switch (x) {
     case 1:
       break;
     foo: case 2:
       continue ^;
     case 3:
       break;
 ''');
     expect(computeFast(), isTrue);
-    assertSuggestLabel('foo');
+    assertNotSuggested('foo');
   }
 
   test_enum() {
     addTestSource('enum E { one, two } main() {^}');
     expect(computeFast(), isTrue);
     assertSuggestEnum('E');
     assertNotSuggested('one');
     assertNotSuggested('two');
   }
 
@@ skipping 353 matching lines @@
     assertSuggestLocalVariable('ab', null);
     assertSuggestLocalVariable('_ab', null, relevance: DART_RELEVANCE_DEFAULT);
   }
 
   test_shadowed_name() {
     addTestSource('var a; class A { var a; m() { ^ } }');
     expect(computeFast(), isTrue);
     assertSuggestLocalField('a', null);
   }
 }