refactor duplicate code into single visitor

pkg/analysis_server/test/completion_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.completion.support;
 
 import 'dart:collection';
 
 import 'completion_test_support.dart';
 
@@ skipping 25 matching lines @@
 
     CompletionTestCase.buildTests('testCommentSnippets004', '''
 class A {!1int x; !2mth() {!3int y = this.!5x!6;}}class B{}''',
         <String>["1+A", "2+B", "3+x", "3-y", "5+mth", "6+x"]);
 
     CompletionTestCase.buildTests('testCommentSnippets005', '''
 class Date { static Date JUN, JUL;}class X { m() { return Da!1te.JU!2L; }}''',
         <String>["1+Date", "2+JUN", "2+JUL"]);
 
     CompletionTestCase.buildTests('testCommentSnippets007', '''
-class C {mth(Map x, !1) {}mtf(!2, Map x) {}m() {for (in!3t i=0; i<5; i++); A!4 x;}}class int{}class Arrays{}class bool{}''',
+class C {mth(Map x, !1) {}mtf(!2, Map x) {}m() {for (in!3t i=0; i<5; i++); A!4 x;}}class int{}class Arrays{}''',
         <String>["1+bool", "2+bool", "3+int", "4+Arrays"],
         failingTests: '3');
 
     CompletionTestCase.buildTests('testCommentSnippets008', '''
 class Date{}final num M = Dat!1''', <String>["1+Date"]);
 
     // space, char, eol are important
     CompletionTestCase.buildTests('testCommentSnippets009', '''
-class Map{}class Maps{}class x extends!5 !2M!3 !4implements!6 !1\n{}''',
+class Maps{}class x extends!5 !2M!3 !4implements!6 !1\n{}''',
         <String>[
             "1+Map",
             "2+Maps",
             "3+Maps",
             "4-Maps",
             "4+implements",
             "5-Maps",
             "6-Map",
             "6+implements"],
         failingTests: '46');
 
     // space, char, eol are important
     CompletionTestCase.buildTests('testCommentSnippets010', '''
-class Map{}class x implements !1{}''', <String>["1+Map"], failingTests: '1');
+class x implements !1{}''', <String>["1+Map"]);
 
     // space, char, eol are important
     CompletionTestCase.buildTests('testCommentSnippets011', '''
-class Map{}class x implements M!1{}''', <String>["1+Map"], failingTests: '1');
+class x implements M!1{}''', <String>["1+Map"]);
 
     // space, char, eol are important
     CompletionTestCase.buildTests('testCommentSnippets012', '''
-class Map{}class x implements M!1\n{}''', <String>["1+Map"], failingTests: '1');
+class x implements M!1\n{}''', <String>["1+Map"]);
 
     CompletionTestCase.buildTests('testCommentSnippets013', '''
-class num{}class x !2{!1}!3''',
-        <String>["1+num", "2-num", "3-num"],
-        failingTests: '1');
+class x !2{!1}!3''',
+        <String>["1+num", "2-num", "3-num"]);
 
     // trailing space is important
     CompletionTestCase.buildTests('testCommentSnippets014', '''
-class num{}typedef n!1 ;''', <String>["1+num"]);
+typedef n!1 ;''', <String>["1+num"]);
 
     CompletionTestCase.buildTests('testCommentSnippets015', '''
 class D {f(){} g(){f!1(f!2);}}''', <String>["1+f", "2+f"]);
 
     CompletionTestCase.buildTests('testCommentSnippets016', '''
 class F {m() { m(); !1}}''', <String>["1+m"]);
 
     CompletionTestCase.buildTests('testCommentSnippets017', '''
 class F {var x = !1false;}''', <String>["1+true"], failingTests: '1');
 
@@ skipping 58 matching lines @@
 class Bar<T extends Foo> {const Bar(!1T!2 k);T!3 m(T!4 a, T!5 b){}final T!6 f = null;}''',
         <String>["1+T", "2+T", "3+T", "4+T", "5+T", "6+T"],
         failingTests: '123456');
 
     CompletionTestCase.buildTests('testCommentSnippets031', '''
 class Bar<T extends Foo> {m(x){if (x is !1) return;if (x is!!!2)}}''',
         <String>["1+Bar", "1+T", "2+T", "2+Bar"],
         failingTests: '12');
 
     CompletionTestCase.buildTests('testCommentSnippets032', '''
-class Fit{}class Bar<T extends Fooa> {const F!1ara();}''',
-        <String>["1+Fit", "1+Fara", "1-Bar"]);
+class Fit{}class Bar<T extends Fooa> {const !2F!1ara();}''',
+        <String>["1+Fit", "1+Fara", "1-Bar", "2+Fit"],
+        failingTests: '1');
 
     // Type propagation
     CompletionTestCase.buildTests('testCommentSnippets033', '''
 class List{add(){}length(){}}t1() {var x;if (x is List) {x.!1add(3);}}''',
         <String>["1+add", "1+length"]);
 
     // Type propagation
     CompletionTestCase.buildTests('testCommentSnippets035', '''
 class List{clear(){}length(){}}t3() {var x=new List(), y=x.!1length();x.!2clear();}''',
         <String>["1+length", "2+clear"]);
@@ skipping 471 matching lines @@
 class List{}class Map{}typedef X = !1Lis!2t with !3Ma!4p;''',
         <String>["1+Map", "2+List", "2-Map", "3+List", "4+Map", "4-List"],
         failingTests: '1234');
 
     CompletionTestCase.buildTests('testCommentSnippets085', '''
 class List{}class Map{}class Z extends List with !1Ma!2p {}''',
         <String>["1+List", "1+Map", "2+Map", "2-List"],
         failingTests: '12');
 
     CompletionTestCase.buildTests('testCommentSnippets086', '''
-class Q{f(){xy() {!2};x!1y();}}''',
-        <String>["1+xy", "2+f", "2-xy"]);
+class Q{f(){xy() {!2};x!1y();}}''', <String>["1+xy", "2+f", "2-xy"]);
 
     CompletionTestCase.buildTests('testCommentSnippets087', '''
 class Map{}class Q extends Object with !1Map {}''',
         <String>["1+Map", "1-HashMap"],
         failingTests: '1');
 
     CompletionTestCase.buildTests('testCommentSnippets088', '''
 class A {
   int f;
   B m(){}
@@ skipping 187 matching lines @@
 import 'dart:math' show !1"''',
         <String>["1+PI", "1+sin", "1+Random", "1-String"],
         failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_combinator_usePrefix', '''
 import 'dart:math' show s!1"''',
         <String>["1+sin", "1+sqrt", "1-cos", "1-String"],
         failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_constructor_field', '''
-class X { X(this.field); int f!1ield;}''', <String>["1+field"]);
+class X { X(this.field); int f!1ield;}''',
+        <String>["1+field"],
+        failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_constructorArguments_showOnlyCurrent',
         '''
 class A {
   A.first(int p);
   A.second(double p);
 }
 main() {
   new A.first(!1);
 }''', <String>["1+A.first", "1-A.second"], failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_constructorArguments_whenPrefixedType',
         '''
 import 'dart:math' as m;
 main() {
   new m.Random(!1);
 }''', <String>["1+Random:ARGUMENT_LIST"], failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_dartDoc_reference_forClass',
         '''
 /**
  * [int!1]
  * [method!2]
  */
 class AAA {
   methodA() {}
-}''', <String>["1+int", "1-method", "2+methodA", "2-int"], failingTests: '1');
+}''', <String>["1+int", "1-method", "2+methodA", "2-int"]);
 
     CompletionTestCase.buildTests(
         'testCompletion_dartDoc_reference_forConstructor',
         '''
 class A {
   /**
    * [aa!1]
    * [int!2]
    * [method!3]
    */
   A.named(aaa, bbb) {}
   methodA() {}
 }''',
         <String>["1+aaa", "1-bbb", "2+int", "2-double", "3+methodA"],
-        failingTests: '12');
+        failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_dartDoc_reference_forFunction',
         '''
 /**
  * [aa!1]
  * [int!2]
  * [function!3]
  */
 functionA(aaa, bbb) {}
 functionB() {}''',
         <String>[
             "1+aaa",
             "1-bbb",
             "2+int",
             "2-double",
             "3+functionA",
             "3+functionB",
             "3-int"],
-        failingTests: '12');
+        failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_dartDoc_reference_forFunctionTypeAlias',
         '''
 /**
  * [aa!1]
  * [int!2]
  * [Function!3]
  */
 typedef FunctionA(aaa, bbb) {}
 typedef FunctionB() {}''',
         <String>[
             "1+aaa",
             "1-bbb",
             "2+int",
             "2-double",
             "3+FunctionA",
             "3+FunctionB",
             "3-int"],
-        failingTests: '12');
+        failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_dartDoc_reference_forMethod',
         '''
 class A {
   /**
    * [aa!1]
    * [int!2]
    * [method!3]
    */
   methodA(aaa, bbb) {}
   methodB() {}
 }''',
         <String>[
             "1+aaa",
             "1-bbb",
             "2+int",
             "2-double",
             "3+methodA",
             "3+methodB",
-            "3-int"],
-        failingTests: '2');
+            "3-int"]);
 
     CompletionTestCase.buildTests(
         'testCompletion_dartDoc_reference_incomplete',
         '''
 /**
  * [doubl!1 some text
  * other text
  */
 class A {}
 /**
  * [!2 some text
  * other text
  */
 class B {}
 /**
  * [!3] some text
  */
 class C {}''',
-        <String>["1+double", "1-int", "2+int", "2+String", "3+int", "3+String"],
-        failingTests: '123');
+        <String>["1+double", "1-int", "2+int", "2+String", "3+int", "3+String"]);
 
     CompletionTestCase.buildTests('testCompletion_double_inFractionPart', '''
 main() {
   1.0!1
 }''', <String>["1-abs", "1-main"]);
 
     CompletionTestCase.buildTests('testCompletion_enum', '''
 enum MyEnum {A, B, C}
 main() {
   MyEnum.!1;
@@ skipping 36 matching lines @@
 import !1
 
 class A {}''', <String>["1+'dart:!';", "1+'package:!';"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_forStmt_vars', '''
 class int{}class Foo { mth() { for (in!1t i = 0; i!2 < 5; i!3++); }}''',
         <String>["1+int", "2+i", "3+i"],
         failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_function', '''
-class String{}class Foo { int boo = 7; mth() { PNGS.sort((String a, Str!1) => a.compareTo(b)); }}''',
+class Foo { int boo = 7; mth() { PNGS.sort((String a, Str!1) => a.compareTo(b)); }}''',
         <String>["1+String"]);
 
     CompletionTestCase.buildTests('testCompletion_function_partial', '''
-class String{}class Foo { int boo = 7; mth() { PNGS.sort((String a, Str!1)); }}''',
-        <String>["1+String"],
-        failingTests: '1');
+class Foo { int boo = 7; mth() { PNGS.sort((String a, Str!1)); }}''',
+        <String>["1+String"]);
 
     CompletionTestCase.buildTests(
         'testCompletion_functionTypeParameter_namedArgument',
         '''
 typedef FFF(a, b, {x1, x2, y});
 main(FFF fff) {
   fff(1, 2, !1)!2;
 }''', <String>["1+x1", "2-x2"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_ifStmt_field1', '''
@@ skipping 407 matching lines @@
         'testCompletion_return_withIdentifierPrefix',
         '''
 f() { var vvv = 42; return v!1 }''', <String>["1+vvv"]);
 
     CompletionTestCase.buildTests('testCompletion_return_withoutExpression', '''
 f() { var vvv = 42; return !1 }''', <String>["1+vvv"]);
 
     CompletionTestCase.buildTests('testCompletion_staticField1', '''
 class num{}class Sunflower {static final n!2um MAX_D = 300;nu!3m xc, yc;Sun!4flower() {x!Xc = y!Yc = MA!1 }}''',
         <String>["1+MAX_D", "X+xc", "Y+yc", "2+num", "3+num", "4+Sunflower"],
-        failingTests: '23');
+        failingTests: '234');
 
     CompletionTestCase.buildTests('testCompletion_super_superType', '''
 class A {
   var fa;
   ma() {}
 }
 class B extends A {
   var fb;
   mb() {}
   main() {
@@ skipping 374 matching lines @@
   int b() => this.!1a();
 }''', <String>["1+a"]);
 
     CompletionTestCase.buildTests('test004', '''
 class A {
   int x;
   A() : this.!1x = 1;
   A.b() : this();
   A.c() : this.!2b();
   g() => new A.!3c();
-}''', <String>["1+x", "2+b", "3+c"], failingTests: '2');
+}''', <String>["1+x", "2+b", "3+c"], failingTests: '12');
 
     CompletionTestCase.buildTests('test005', '''
 class A {}
 void rr(var vim) {
   var !1vq = v!2.toString();
   var vf;
   v!3.toString();
 }''',
         <String>[
             "1-A",
@@ skipping 51 matching lines @@
             "7+Aclass",
             "7-Bclass",
             "8+Ctype",
             "9+abstract",
             "A+with",
             "B+Eclass",
             "B-Dclass",
             "B-Ctype",
             "C+Bclass",
             "C-Eclass"],
-        failingTests: '12359A');
+        failingTests: '12359AB');
 
     // keywords
     CompletionTestCase.buildTests('test009', '''
-class num{}
 typedef !1dy!2namic TestFn1();
 typedef !3vo!4id TestFn2();
 typ!7edef !5n!6''',
         <String>[
             "1+void",
             "1+TestFn2",
             "2+dynamic",
             "2-void",
             "3+dynamic",
             "4+void",
             "4-dynamic",
             "5+TestFn2",
             "6+num",
             "7+typedef"],
         failingTests: '12347');
 
     CompletionTestCase.buildTests('test010', '''
-class String{}class List{}
 class test !8<!1t !2 !3extends String,!4 List,!5 !6>!7 {}
 class tezetst !9<!BString,!C !DList>!A {}''',
         <String>[
             "1+String",
             "1+List",
             "1-test",
             "2-String",
             "2-test",
             "3+extends",
             "4+tezetst",
             "4-test",
             "5+String",
             "6+List",
             "7-List",
             "8-List",
             "9-String",
             "A-String",
             "B+String",
             "C+List",
             "C-tezetst",
             "D+List",
             "D+test"],
-        failingTests: '3');
+        failingTests: '345C');
 
     // name generation with conflicts
     CompletionTestCase.buildTests(
         'test011',
         '''r2(var object, Object object1, Object !1);''',
         <String>["1+object2"],
         failingTests: '1');
 
     // reserved words
     CompletionTestCase.buildTests('test012', '''
@@ skipping 387 matching lines @@
         'test_classMembers_inGetter',
         '''class A { var fff; get z {ff!1}}''',
         <String>["1+fff"]);
 
     CompletionTestCase.buildTests(
         'testSingle',
         '''class A {int x; !2mth() {int y = this.x;}}class B{}''',
         <String>["2+B"]);
   }
 }