Compute covering offsets/lengths.

pkg/analysis_server/test/services/refactoring/extract_local_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.extract_local;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/services/correction/status.dart';
@@ skipping 64 matching lines @@
   main();
 }
 ''');
     _createRefactoringWithSuffix('main', '();');
     // check conditions
     RefactoringStatus status = await refactoring.checkAllConditions();
     assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
         expectedMessage: 'Cannot extract a single method name.');
   }
 
-  test_checkInitialConditions_nameOfProperty_prefixedIdentifier() async {
-    indexTestUnit('''
-main(p) {
-  p.value; // marker
-}
-''');
-    _createRefactoringWithSuffix('value', '; // marker');
-    // check conditions
-    RefactoringStatus status = await refactoring.checkAllConditions();
-    assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
-        expectedMessage: 'Cannot extract name part of a property access.');
-  }
-
-  test_checkInitialConditions_nameOfProperty_propertyAccess() async {
-    indexTestUnit('''
-main() {
-  foo().length; // marker
-}
-String foo() => '';
-''');
-    _createRefactoringWithSuffix('length', '; // marker');
-    // check conditions
-    RefactoringStatus status = await refactoring.checkAllConditions();
-    assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
-        expectedMessage: 'Cannot extract name part of a property access.');
-  }
-
   test_checkInitialConditions_namePartOfDeclaration_variable() async {
     indexTestUnit('''
 main() {
   int vvv = 0;
 }
 ''');
     _createRefactoringWithSuffix('vvv', ' = 0;');
     // check conditions
     RefactoringStatus status = await refactoring.checkAllConditions();
     assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
         expectedMessage: 'Cannot extract the name part of a declaration.');
   }
 
+  test_checkInitialConditions_noExpression() async {
+    indexTestUnit('''
+main() {
+  // abc
+}
+''');
+    _createRefactoringForString('abc');
+    // check conditions
+    _assertInitialConditions_fatal_selection();
+  }
+
   test_checkInitialConditions_notPartOfFunction() async {
     indexTestUnit('''
 int a = 1 + 2;
 ''');
     _createRefactoringForString('1 + 2');
     // check conditions
     RefactoringStatus status = await refactoring.checkAllConditions();
     assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
         expectedMessage:
             'Expression inside of function must be selected to activate this refactoring.');
   }
 
   test_checkInitialConditions_stringSelection_leadingQuote() async {
     indexTestUnit('''
 main() {
   var vvv = 'abc';
 }
 ''');
     _createRefactoringForString("'a");
-    // check conditions
-    RefactoringStatus status = await refactoring.checkAllConditions();
-    assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
-        expectedMessage:
-            'Cannot extract only leading or trailing quote of string literal.');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main() {
+  var res = 'abc';
+  var vvv = res;
+}
+''');
   }
 
   test_checkInitialConditions_stringSelection_trailingQuote() async {
     indexTestUnit('''
 main() {
   var vvv = 'abc';
 }
 ''');
     _createRefactoringForString("c'");
-    // check conditions
-    RefactoringStatus status = await refactoring.checkAllConditions();
-    assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
-        expectedMessage:
-            'Cannot extract only leading or trailing quote of string literal.');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main() {
+  var res = 'abc';
+  var vvv = res;
+}
+''');
   }
 
   test_checkLocalName() {
     indexTestUnit('''
 main() {
   int a = 1 + 2;
 }
 ''');
     _createRefactoringForString('1 + 2');
     expect(refactoring.refactoringName, 'Extract Local Variable');
@@ skipping 154 matching lines @@
     _createRefactoringForString('2');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   const res = 2;
   const {1: res};
 }
 ''');
   }
 
+  test_coveringExpressions() async {
+    indexTestUnit('''
+main() {
+  int aaa = 1;
+  int bbb = 2;
+  var c = aaa + bbb * 2 + 3;
+}
+''');
+    _createRefactoring(testCode.indexOf('bb * 2'), 0);
+    // check conditions
+    await refactoring.checkInitialConditions();
+    List<String> subExpressions = <String>[];
+    for (int i = 0; i < refactoring.coveringExpressionOffsets.length; i++) {
+      int offset = refactoring.coveringExpressionOffsets[i];
+      int length = refactoring.coveringExpressionLengths[i];
+      subExpressions.add(testCode.substring(offset, offset + length));
+    }
+    expect(subExpressions,
+        ['bbb', 'bbb * 2', 'aaa + bbb * 2', 'aaa + bbb * 2 + 3']);
+  }
+
   test_fragmentExpression() {
     indexTestUnit('''
 main() {
   int a = 1 + 2 + 3 + 4;
 }
 ''');
     _createRefactoringForString('2 + 3');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
-  var res = 2 + 3;
-  int a = 1 + res + 4;
+  var res = 1 + 2 + 3;
+  int a = res + 4;
 }
 ''');
   }
 
   test_fragmentExpression_leadingNotWhitespace() {
     indexTestUnit('''
 main() {
   int a = 1 + 2 + 3 + 4;
 }
 ''');
     _createRefactoringForString('+ 2');
-    // check conditions
-    return _assertInitialConditions_fatal_selection();
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main() {
+  var res = 1 + 2;
+  int a = res + 3 + 4;
+}
+''');
   }
 
   test_fragmentExpression_leadingPartialSelection() {
     indexTestUnit('''
 main() {
   int a = 111 + 2 + 3 + 4;
 }
 ''');
     _createRefactoringForString('11 + 2');
-    // check conditions
-    return _assertInitialConditions_fatal_selection();
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main() {
+  var res = 111 + 2;
+  int a = res + 3 + 4;
+}
+''');
   }
 
   test_fragmentExpression_leadingWhitespace() {
     indexTestUnit('''
 main() {
   int a = 1 + 2 + 3 + 4;
 }
 ''');
     _createRefactoringForString(' 2 + 3');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
-  var res =  2 + 3;
-  int a = 1 +res + 4;
+  var res = 1 + 2 + 3;
+  int a = res + 4;
 }
 ''');
   }
 
   test_fragmentExpression_notAssociativeOperator() {
     indexTestUnit('''
 main() {
   int a = 1 - 2 - 3 - 4;
 }
 ''');
     _createRefactoringForString('2 - 3');
-    // check conditions
-    return _assertInitialConditions_fatal_selection();
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main() {
+  var res = 1 - 2 - 3;
+  int a = res - 4;
+}
+''');
   }
 
   test_fragmentExpression_trailingNotWhitespace() {
     indexTestUnit('''
 main() {
   int a = 1 + 2 + 3 + 4;
 }
 ''');
-    _createRefactoringForString('2 + 3 +');
-    // check conditions
-    return _assertInitialConditions_fatal_selection();
+    _createRefactoringForString('1 + 2 +');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main() {
+  var res = 1 + 2 + 3;
+  int a = res + 4;
+}
+''');
   }
 
   test_fragmentExpression_trailingPartialSelection() {
     indexTestUnit('''
 main() {
-  int a = 1 + 2 + 3 + 444;
+  int a = 1 + 2 + 333 + 4;
 }
 ''');
-    _createRefactoringForString('2 + 3 + 44');
-    // check conditions
-    return _assertInitialConditions_fatal_selection();
+    _createRefactoringForString('2 + 33');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main() {
+  var res = 1 + 2 + 333;
+  int a = res + 4;
+}
+''');
   }
 
   test_fragmentExpression_trailingWhitespace() {
     indexTestUnit('''
 main() {
   int a = 1 + 2 + 3 + 4;
 }
 ''');
     _createRefactoringForString('2 + 3 ');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
-  var res = 2 + 3 ;
-  int a = 1 + res+ 4;
+  var res = 1 + 2 + 3;
+  int a = res + 4;
 }
 ''');
   }
 
   test_guessNames_fragmentExpression() async {
     indexTestUnit('''
 main() {
   var a = 111 + 222 + 333 + 444;
 }
 ''');
     _createRefactoringForString('222 + 333');
     // check guesses
     await refactoring.checkInitialConditions();
-    expect(refactoring.names, isEmpty);
+    expect(refactoring.names, unorderedEquals(['i']));
   }
 
   test_guessNames_singleExpression() async {
     indexTestUnit('''
 class TreeItem {}
 TreeItem getSelectedItem() => null;
 process(my) {}
 main() {
   process(getSelectedItem()); // marker
 }
@@ skipping 10 matching lines @@
 main() {
   var s = 'Hello Bob... welcome to Dart!';
 }
 ''');
     _createRefactoringForString('Hello Bob');
     // check guesses
     await refactoring.checkInitialConditions();
     expect(refactoring.names, unorderedEquals(['helloBob', 'bob']));
   }
 
-  test_occurences_differentVariable() {
+  test_occurrences_differentVariable() {
     indexTestUnit('''
 main() {
   {
     int v = 1;
     print(v + 1); // marker
     print(v + 1);
   }
   {
     int v = 2;
     print(v + 1);
@@ skipping 11 matching lines @@
     print(res);
   }
   {
     int v = 2;
     print(v + 1);
   }
 }
 ''');
   }
 
-  test_occurences_disableOccurences() {
+  test_occurrences_disableOccurrences() {
     indexTestUnit('''
 int foo() => 42;
 main() {
   int a = 1 + foo();
   int b = 2 + foo(); // marker
 }
 ''');
     _createRefactoringWithSuffix('foo()', '; // marker');
     refactoring.extractAll = false;
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 int foo() => 42;
 main() {
   int a = 1 + foo();
   var res = foo();
   int b = 2 + res; // marker
 }
 ''');
   }
 
-  test_occurences_ignore_assignmentLeftHandSize() {
+  test_occurrences_ignore_assignmentLeftHandSize() {
     indexTestUnit('''
 main() {
   int v = 1;
   v = 2;
   print(() {v = 2;});
   print(1 + (() {v = 2; return 3;})());
   print(v); // marker
 }
 ''');
     _createRefactoringWithSuffix('v', '); // marker');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int v = 1;
   v = 2;
   print(() {v = 2;});
   print(1 + (() {v = 2; return 3;})());
   var res = v;
   print(res); // marker
 }
 ''');
   }
 
-  test_occurences_ignore_nameOfVariableDeclariton() {
+  test_occurrences_ignore_nameOfVariableDeclaration() {
     indexTestUnit('''
 main() {
   int v = 1;
   print(v); // marker
 }
 ''');
     _createRefactoringWithSuffix('v', '); // marker');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   int v = 1;
   var res = v;
   print(res); // marker
 }
 ''');
   }
 
-  test_occurences_singleExpression() {
+  test_occurrences_singleExpression() {
     indexTestUnit('''
 int foo() => 42;
 main() {
   int a = 1 + foo();
   int b = 2 +  foo(); // marker
 }
 ''');
     _createRefactoringWithSuffix('foo()', '; // marker');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 int foo() => 42;
 main() {
   var res = foo();
   int a = 1 + res;
   int b = 2 +  res; // marker
 }
 ''');
   }
 
-  test_occurences_useDominator() {
+  test_occurrences_useDominator() {
     indexTestUnit('''
 main() {
   if (true) {
     print(42);
   } else {
     print(42);
   }
 }
 ''');
     _createRefactoringForString('42');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   var res = 42;
   if (true) {
     print(res);
   } else {
     print(res);
   }
 }
 ''');
   }
 
-  test_occurences_whenComment() {
+  test_occurrences_whenComment() {
     indexTestUnit('''
 int foo() => 42;
 main() {
   /*int a = 1 + foo();*/
   int b = 2 + foo(); // marker
 }
 ''');
     _createRefactoringWithSuffix('foo()', '; // marker');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 int foo() => 42;
 main() {
   /*int a = 1 + foo();*/
   var res = foo();
   int b = 2 + res; // marker
 }
 ''');
   }
 
-  test_occurences_withSpace() {
+  test_occurrences_withSpace() {
     indexTestUnit('''
 int foo(String s) => 42;
 main() {
   int a = 1 + foo('has space');
   int b = 2 + foo('has space'); // marker
 }
 ''');
     _createRefactoringWithSuffix("foo('has space')", '; // marker');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
@@ skipping 143 matching lines @@
 ''');
   }
 
   test_singleExpression_leadingNotWhitespace() {
     indexTestUnit('''
 main() {
   int a = 12 + 345;
 }
 ''');
     _createRefactoringForString('+ 345');
-    // check conditions
-    return _assertInitialConditions_fatal_selection();
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main() {
+  var res = 12 + 345;
+  int a = res;
+}
+''');
   }
 
   test_singleExpression_leadingWhitespace() {
     indexTestUnit('''
 main() {
-  int a = 12 /*abc*/ + 345;
+  int a = 1 /*abc*/ + 2 + 345;
 }
 ''');
-    _createRefactoringForString('12 /*abc*/');
+    _createRefactoringForString('1 /*abc*/');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
-  var res = 12 /*abc*/;
+  var res = 1 /*abc*/ + 2;
   int a = res + 345;
 }
 ''');
   }
 
+  test_singleExpression_nameOfProperty_prefixedIdentifier() async {
+    indexTestUnit('''
+main(p) {
+  var v = p.value; // marker
+}
+''');
+    _createRefactoringWithSuffix('value', '; // marker');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main(p) {
+  var res = p.value;
+  var v = res; // marker
+}
+''');
+  }
+
+  test_singleExpression_nameOfProperty_propertyAccess() async {
+    indexTestUnit('''
+main() {
+  var v = foo().length; // marker
+}
+String foo() => '';
+''');
+    _createRefactoringWithSuffix('length', '; // marker');
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main() {
+  var res = foo().length;
+  var v = res; // marker
+}
+String foo() => '';
+''');
+  }
+
   /**
    * Here we use knowledge how exactly `1 + 2 + 3 + 41 is parsed. We know that
    * `1 + 2` will be a separate and complete binary expression, so it can be
    * handled as a single expression.
    */
   test_singleExpression_partOfBinaryExpression() {
     indexTestUnit('''
 main() {
   int a = 1 + 2 + 3 + 4;
 }
 ''');
     _createRefactoringForString('1 + 2');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   var res = 1 + 2;
   int a = res + 3 + 4;
 }
 ''');
   }
 
-  test_singleExpression_trailingComment() {
-    indexTestUnit('''
-main() {
-  int a =  1 + 2;
-}
-''');
-    _createRefactoringForString(' 1 + 2');
-    // apply refactoring
-    return _assertSuccessfulRefactoring('''
-main() {
-  var res =  1 + 2;
-  int a = res;
-}
-''');
-  }
-
   test_singleExpression_trailingNotWhitespace() {
     indexTestUnit('''
 main() {
   int a = 12 + 345;
 }
 ''');
     _createRefactoringForString('12 +');
-    // check conditions
-    return _assertInitialConditions_fatal_selection();
+    // apply refactoring
+    return _assertSuccessfulRefactoring('''
+main() {
+  var res = 12 + 345;
+  int a = res;
+}
+''');
   }
 
   test_singleExpression_trailingWhitespace() {
     indexTestUnit('''
 main() {
   int a = 1 + 2 ;
 }
 ''');
     _createRefactoringForString('1 + 2 ');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
-  var res = 1 + 2 ;
-  int a = res;
+  var res = 1 + 2;
+  int a = res ;
 }
 ''');
   }
 
   test_stringLiteral_part() {
     indexTestUnit('''
 main() {
   print('abcdefgh');
 }
 ''');
@@ skipping 44 matching lines @@
   }
 
   Future _assertInitialConditions_fatal_selection() async {
     RefactoringStatus status = await refactoring.checkInitialConditions();
     assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
         expectedMessage:
             'Expression must be selected to activate this refactoring.');
   }
 
   /**
-   * Checks that all conditions are OK and the result of applying the [Change]
-   * to [testUnit] is [expectedCode].
+   * Checks that all conditions are OK and the result of applying the
+   * [SourceChange] to [testUnit] is [expectedCode].
    */
   Future _assertSuccessfulRefactoring(String expectedCode) async {
     await assertRefactoringConditionsOK();
     SourceChange refactoringChange = await refactoring.createChange();
     this.refactoringChange = refactoringChange;
     assertTestChangeResult(expectedCode);
   }
 
   void _createRefactoring(int offset, int length) {
     refactoring = new ExtractLocalRefactoring(testUnit, offset, length);
     refactoring.name = 'res';
   }
 
   /**
    * Creates a new refactoring in [refactoring] for the selection range of the
    * given [search] pattern.
    */
   void _createRefactoringForString(String search) {
     int offset = findOffset(search);
     int length = search.length;
     _createRefactoring(offset, length);
   }
 
   void _createRefactoringWithSuffix(String selectionSearch, String suffix) {
     int offset = findOffset(selectionSearch + suffix);
     int length = selectionSearch.length;
     _createRefactoring(offset, length);
   }
 }