Issue 19800. Support for inlining getters/setters.

pkg/analysis_server/test/services/refactoring/inline_method_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.refactoring.inline_method;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart' hide Element;
 import 'package:analysis_server/src/services/refactoring/inline_method.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring.dart';
-import '../../reflective_tests.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:unittest/unittest.dart';
 
+import '../../reflective_tests.dart';
 import 'abstract_refactoring.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(InlineMethodTest);
 }
 
 
 @ReflectiveTestCase()
@@ skipping 59 matching lines @@
     return refactoring.checkAllConditions().then((status) {
       var location = new SourceRange(findOffset('..test()'), '..test()'.length);
       assertRefactoringStatus(
           status,
           RefactoringProblemSeverity.ERROR,
           expectedMessage: 'Cannot inline cascade invocation.',
           expectedContextRange: location);
     });
   }
 
+  test_bad_constructor() {
+    indexTestUnit(r'''
+class A {
+  A.named() {}
+}
+''');
+    _createRefactoring('named() {}');
+    // error
+    return _assertInvalidSelection();
+  }
+
   test_bad_deleteSource_inlineOne() {
     indexTestUnit(r'''
 test(a, b) {
   return a + b;
 }
 main() {
   var res1 = test(1, 2);
   var res2 = test(10, 20);
 }
 ''');
@@ skipping 12 matching lines @@
     });
   }
 
   test_bad_notExecutableElement() {
     indexTestUnit(r'''
 main() {
 }
 ''');
     _createRefactoring(') {');
     // error
-    return _assertConditionsFatal(
-        'Method declaration or reference must be selected to activate this refactoring.');
+    return _assertInvalidSelection();
   }
 
   test_bad_notSimpleIdentifier() {
     indexTestUnit(r'''
 main() {
   var test = 42;
   var res = test;
 }
 ''');
     _createRefactoring('test;');
     // error
-    return _assertConditionsFatal(
-        'Method declaration or reference must be selected to activate this refactoring.');
+    return _assertInvalidSelection();
   }
 
   test_bad_operator() {
     indexTestUnit(r'''
 class A {
   operator -(other) => this;
 }
 ''');
     _createRefactoring('-(other)');
     // error
@@ skipping 535 matching lines @@
     _createRefactoring('test() {');
     // validate change
     return _assertSuccessfulRefactoring(r'''
 var topLevelField = 0;
 main() {
   print(topLevelField);
 }
 ''');
   }
 
+  test_getter_classMember_instance() {
+    indexTestUnit(r'''
+class A {
+  int f;
+  int get result => f + 1;
+}
+main(A a) {
+  print(a.result);
+}
+''');
+    _createRefactoring('result =>');
+    // validate change
+    return _assertSuccessfulRefactoring(r'''
+class A {
+  int f;
+}
+main(A a) {
+  print(a.f + 1);
+}
+''');
+  }
+
+  test_getter_classMember_static() {
+    indexTestUnit(r'''
+class A {
+  static int get result => 1 + 2;
+}
+main() {
+  print(A.result);
+}
+''');
+    _createRefactoring('result =>');
+    // validate change
+    return _assertSuccessfulRefactoring(r'''
+class A {
+}
+main() {
+  print(1 + 2);
+}
+''');
+  }
+
+  test_getter_topLevel() {
+    indexTestUnit(r'''
+String get message => 'Hello, World!';
+main() {
+  print(message);
+}
+''');
+    _createRefactoring('message =>');
+    // validate change
+    return _assertSuccessfulRefactoring(r'''
+main() {
+  print('Hello, World!');
+}
+''');
+  }
+
   test_initialMode_all() {
     indexTestUnit(r'''
 test(a, b) {
   return a + b;
 }
 main() {
   var res = test(1, 2);
 }
 ''');
     _createRefactoring('test(a, b)');
@@ skipping 217 matching lines @@
     _createRefactoring('test({');
     // validate change
     return _assertSuccessfulRefactoring(r'''
 main() {
   print(10 + 20);
   print(10 + 20);
 }
 ''');
   }
 
+  test_reference_expressionBody() {
+    indexTestUnit(r'''
+String message() => 'Hello, World!';
+main() {
+  print(message);
+}
+''');
+    _createRefactoring('message()');
+    // validate change
+    return _assertSuccessfulRefactoring(r'''
+main() {
+  print(() => 'Hello, World!');
+}
+''');
+  }
+
   test_reference_noStatement() {
     indexTestUnit(r'''
 test(a, b) {
   return a || b;
 }
 foo(p1, p2, p3) => p1 && test(p2, p3);
 bar() => {
   'name' : baz(test)
 };
 baz(x) {}
@@ skipping 48 matching lines @@
     return _assertSuccessfulRefactoring(r'''
 main() {
   print((a, b) {
     print(a);
     print(b);
   });
 }
 ''');
   }
 
-  test_reference_expressionBody() {
+  test_setter_classMember_instance() {
     indexTestUnit(r'''
-String message() => 'Hello, World!';
-main() {
-  print(message);
+class A {
+  int f;
+  void set result(x) {
+    f = x + 1;
+  }
+}
+main(A a) {
+  a.result = 5;
 }
 ''');
-    _createRefactoring('message()');
+    _createRefactoring('result(x)');
+    // validate change
+    return _assertSuccessfulRefactoring(r'''
+class A {
+  int f;
+}
+main(A a) {
+  a.f = 5 + 1;
+}
+''');
+  }
+
+  test_setter_topLevel() {
+    indexTestUnit(r'''
+void set result(x) {
+  print(x + 1);
+}
+main() {
+  result = 5;
+}
+''');
+    _createRefactoring('result(x)');
     // validate change
     return _assertSuccessfulRefactoring(r'''
 main() {
-  print(() => 'Hello, World!');
+  print(5 + 1);
 }
 ''');
   }
 
   test_singleExpression_oneUsage() {
     indexTestUnit(r'''
 test(a, b) {
   return a + b;
 }
 main() {
@@ skipping 143 matching lines @@
 
   Future _assertConditionsFatal(String message) {
     return refactoring.checkAllConditions().then((status) {
       assertRefactoringStatus(
           status,
           RefactoringProblemSeverity.FATAL,
           expectedMessage: message);
     });
   }
 
+  Future _assertInvalidSelection() {
+    return _assertConditionsFatal(
+        'Method declaration or reference must be selected to activate this refactoring.');
+  }
+
   Future _assertSuccessfulRefactoring(String expectedCode) {
     return refactoring.checkInitialConditions().then((status) {
       assertRefactoringStatusOK(status);
       if (deleteSource != null) {
         refactoring.deleteSource = deleteSource;
       }
       if (inlineAll != null) {
         refactoring.inlineAll = inlineAll;
       }
       return refactoring.checkFinalConditions().then((status) {
         assertRefactoringStatusOK(status);
         return refactoring.createChange().then((SourceChange change) {
           this.refactoringChange = change;
           assertTestChangeResult(expectedCode);
         });
       });
     });
   }
 
   void _createRefactoring(String search) {
     int offset = findOffset(search);
     refactoring = new InlineMethodRefactoring(searchEngine, testUnit, offset);
   }
 }