Issue 27903. Use shared logic for computing new method location.

pkg/analysis_server/test/services/correction/fix_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.correction.fix;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/edit/fix/fix_core.dart';
 import 'package:analysis_server/plugin/edit/fix/fix_dart.dart';
@@ skipping 4583 matching lines @@
         '''
 class A<T> {
   B b;
   Map<int, T> items;
   main() {
     b.process(items);
   }
 }
 
 class B {
-  void process(Map items) {
-  }
+  void process(Map items) {}

[Brian Wilkerson, 2016/11/30 18:22:57]

It would be good to have some tests in which there is extra whitespace in order
to make sure those don't regress. Maybe there are already such tests, but I
can't easily tell.

 }
 ''');
   }
 
   test_undefinedMethod_create_generic_BAD_returnType() async {
     resolveTestUnit('''
 class A<T> {
   main() {
     T t = new B().compute();
   }
 }
 
 class B {
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A<T> {
   main() {
     T t = new B().compute();
   }
 }
 
 class B {
-  dynamic compute() {
-  }
+  dynamic compute() {}
 }
 ''');
   }
 
   test_undefinedMethod_create_generic_OK_literal() async {
     resolveTestUnit('''
 class A {
   B b;
   List<int> items;
   main() {
     b.process(items);
   }
 }
 
-class B {
-}
+class B {}
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A {
   B b;
   List<int> items;
   main() {
     b.process(items);
   }
 }
 
 class B {
-  void process(List<int> items) {
-  }
+  void process(List<int> items) {}
 }
 ''');
   }
 
   test_undefinedMethod_create_generic_OK_local() async {
     resolveTestUnit('''
 class A<T> {
   List<T> items;
   main() {
     process(items);
   }
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A<T> {
   List<T> items;
   main() {
     process(items);
   }
 
-  void process(List<T> items) {
-  }
+  void process(List<T> items) {}
 }
 ''');
   }
+
+  test_undefinedMethod_createQualified_emptyClassBody() async {
+    resolveTestUnit('''
+class A {}
+main() {
+  A.myUndefinedMethod();
+}
+''');
+    await assertHasFix(
+        DartFixKind.CREATE_METHOD,
+        '''
+class A {
+  static void myUndefinedMethod() {}
+}
+main() {
+  A.myUndefinedMethod();
+}
+''');
+  }
 
   test_undefinedMethod_createQualified_fromClass() async {
     resolveTestUnit('''
 class A {
 }
 main() {
   A.myUndefinedMethod();
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A {
-  static void myUndefinedMethod() {
-  }
+  static void myUndefinedMethod() {}
 }
 main() {
   A.myUndefinedMethod();
 }
 ''');
   }
 
   test_undefinedMethod_createQualified_fromClass_hasOtherMember() async {
     resolveTestUnit('''
 class A {
   foo() {}
 }
 main() {
   A.myUndefinedMethod();
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A {
   foo() {}
 
-  static void myUndefinedMethod() {
-  }
+  static void myUndefinedMethod() {}
 }
 main() {
   A.myUndefinedMethod();
 }
 ''');
   }
 
   test_undefinedMethod_createQualified_fromInstance() async {
     resolveTestUnit('''
 class A {
 }
 main(A a) {
   a.myUndefinedMethod();
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A {
-  void myUndefinedMethod() {
-  }
+  void myUndefinedMethod() {}
 }
 main(A a) {
   a.myUndefinedMethod();
 }
 ''');
   }
 
   test_undefinedMethod_createQualified_targetIsFunctionType() async {
     resolveTestUnit('''
 typedef A();
@@ skipping 29 matching lines @@
         '''
 class C {
   int x;
 }
 
 class D {
   foo(C c1, C c2) {
     bar(c1.x, c2.x);
   }
 
-  void bar(int x, int x2) {
-  }
+  void bar(int x, int x2) {}
 }''');
   }
 
   test_undefinedMethod_createUnqualified_parameters() async {
     resolveTestUnit('''
 class A {
   main() {
     myUndefinedMethod(0, 1.0, '3');
   }
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A {
   main() {
     myUndefinedMethod(0, 1.0, '3');
   }
 
-  void myUndefinedMethod(int i, double d, String s) {
-  }
+  void myUndefinedMethod(int i, double d, String s) {}
 }
 ''');
     // linked positions
     int index = 0;
     _assertLinkedGroup(
         change.linkedEditGroups[index++], ['void myUndefinedMethod(']);
     _assertLinkedGroup(change.linkedEditGroups[index++],
         ['myUndefinedMethod(0', 'myUndefinedMethod(int']);
     _assertLinkedGroup(
         change.linkedEditGroups[index++],
@@ skipping 24 matching lines @@
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A {
   main() {
     myUndefinedMethod(0, bbb: 1.0, ccc: '2');
   }
 
-  void myUndefinedMethod(int i, {double bbb, String ccc}) {
-  }
+  void myUndefinedMethod(int i, {double bbb, String ccc}) {}
 }
 ''');
     // linked positions
     int index = 0;
     _assertLinkedGroup(
         change.linkedEditGroups[index++], ['void myUndefinedMethod(']);
     _assertLinkedGroup(change.linkedEditGroups[index++],
         ['myUndefinedMethod(0', 'myUndefinedMethod(int']);
     _assertLinkedGroup(
         change.linkedEditGroups[index++],
@@ skipping 22 matching lines @@
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A {
   main() {
     int v = myUndefinedMethod();
   }
 
-  int myUndefinedMethod() {
-  }
+  int myUndefinedMethod() {}
 }
 ''');
     // linked positions
     _assertLinkedGroup(change.linkedEditGroups[0], ['int myUndefinedMethod(']);
     _assertLinkedGroup(change.linkedEditGroups[1],
         ['myUndefinedMethod();', 'myUndefinedMethod() {']);
   }
 
   test_undefinedMethod_createUnqualified_staticFromField() async {
     resolveTestUnit('''
 class A {
   static var f = myUndefinedMethod();
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A {
   static var f = myUndefinedMethod();
 
-  static myUndefinedMethod() {
-  }
+  static myUndefinedMethod() {}
 }
 ''');
   }
 
   test_undefinedMethod_createUnqualified_staticFromMethod() async {
     resolveTestUnit('''
 class A {
   static main() {
     myUndefinedMethod();
   }
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A {
   static main() {
     myUndefinedMethod();
   }
 
-  static void myUndefinedMethod() {
-  }
+  static void myUndefinedMethod() {}
 }
 ''');
   }
 
   test_undefinedMethod_hint_createQualified_fromInstance() async {
     resolveTestUnit('''
 class A {
 }
 main() {
   var a = new A();
   a.myUndefinedMethod();
 }
 ''');
     await assertHasFix(
         DartFixKind.CREATE_METHOD,
         '''
 class A {
-  void myUndefinedMethod() {
-  }
+  void myUndefinedMethod() {}
 }
 main() {
   var a = new A();
   a.myUndefinedMethod();
 }
 ''');
   }
 
   test_undefinedMethod_parameterType_differentPrefixInTargetUnit() async {
     String code2 = r'''
@@ skipping 25 matching lines @@
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/test2.dart');
     expect(
         SourceEdit.applySequence(code2, fileEdit.edits),
         r'''
 library test2;
 import 'test3.dart' as bbb;
 export 'test3.dart';
 class D {
-  void foo(bbb.E e) {
-  }
+  void foo(bbb.E e) {}
 }
 ''');
   }
 
   test_undefinedMethod_parameterType_inTargetUnit() async {
     String code2 = r'''
 library test2;
 class D {
 }
 class E {}
@@ skipping 12 matching lines @@
     // apply to "test2.dart"
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     SourceFileEdit fileEdit = change.edits[0];
     expect(fileEdit.file, '/test2.dart');
     expect(
         SourceEdit.applySequence(code2, fileEdit.edits),
         r'''
 library test2;
 class D {
-  void foo(E e) {
-  }
+  void foo(E e) {}
 }
 class E {}
 ''');
   }
 
   test_undefinedMethod_useSimilar_ignoreOperators() async {
     resolveTestUnit('''
 main(Object object) {
   object.then();
 }
@@ skipping 409 matching lines @@
   var v = 42;
   print('v: $v');
 }
 ''');
   }
 
   void verifyResult(String expectedResult) {
     expect(resultCode, expectedResult);
   }
 }