Port and test more assists.

pkg/analysis_services/test/correction/assist_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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library test.services.correction.assist;
 
 import 'package:analysis_services/correction/assist.dart';
@@ skipping 883 matching lines @@
   void test_exchangeBinaryExpressionArguments_wrong_selectionWithBinary() {
     _indexTestUnit('''
 main() {
   1 + 2 + 3;
 }
 ''');
     length = '1 + 2 + 3'.length;
     assertNoAssistAt('1 + 2 + 3', AssistKind.EXCHANGE_OPERANDS);
   }
 
+  void test_importAddShow_BAD_hasShow() {
+    _indexTestUnit('''
+import 'dart:math' show PI;
+main() {
+  PI;
+}
+''');
+    assertNoAssistAt('import ', AssistKind.IMPORT_ADD_SHOW);
+  }
+
+  void test_importAddShow_BAD_unused() {
+    _indexTestUnit('''
+import 'dart:math';
+''');
+    assertNoAssistAt('import ', AssistKind.IMPORT_ADD_SHOW);
+  }
+
+  void test_importAddShow_OK_onDirective() {
+    _indexTestUnit('''
+import 'dart:math';
+main() {
+  PI;
+  E;
+  max(1, 2);
+}
+''');
+    assertHasAssistAt('import ', AssistKind.IMPORT_ADD_SHOW, '''
+import 'dart:math' show E, PI, max;
+main() {
+  PI;
+  E;
+  max(1, 2);
+}
+''');
+  }
+
+  void test_importAddShow_OK_onUri() {
+    _indexTestUnit('''
+import 'dart:math';
+main() {
+  PI;
+  E;
+  max(1, 2);
+}
+''');
+    assertHasAssistAt('art:math', AssistKind.IMPORT_ADD_SHOW, '''
+import 'dart:math' show E, PI, max;
+main() {
+  PI;
+  E;
+  max(1, 2);
+}
+''');
+  }
+
+  void test_invertIfStatement_blocks() {
+    _indexTestUnit('''
+main() {
+  if (true) {
+    0;
+  } else {
+    1;
+  }
+}
+''');
+    assertHasAssistAt('if (', AssistKind.INVERT_IF_STATEMENT, '''
+main() {
+  if (false) {
+    1;
+  } else {
+    0;
+  }
+}
+''');
+  }
+
+  void test_invertIfStatement_statements() {
+    _indexTestUnit('''
+main() {
+  if (true)
+    0;
+  else
+    1;
+}
+''');
+    assertHasAssistAt('if (', AssistKind.INVERT_IF_STATEMENT, '''
+main() {
+  if (false)
+    1;
+  else
+    0;
+}
+''');
+  }
+
+  void test_joinIfStatementInner_OK_conditionAndOr() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2 || 3 == 3) {
+      print(0);
+    }
+  }
+}
+''');
+    assertHasAssistAt('if (1 ==', AssistKind.JOIN_IF_WITH_INNER, '''
+main() {
+  if (1 == 1 && (2 == 2 || 3 == 3)) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementInner_OK_conditionInvocation() {
+    _indexTestUnit('''
+main() {
+  if (isCheck()) {
+    if (2 == 2) {
+      print(0);
+    }
+  }
+}
+bool isCheck() => false;
+''');
+    assertHasAssistAt('if (isCheck', AssistKind.JOIN_IF_WITH_INNER, '''
+main() {
+  if (isCheck() && 2 == 2) {
+    print(0);
+  }
+}
+bool isCheck() => false;
+''');
+  }
+
+  void test_joinIfStatementInner_OK_conditionOrAnd() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1 || 2 == 2) {
+    if (3 == 3) {
+      print(0);
+    }
+  }
+}
+''');
+    assertHasAssistAt('if (1 ==', AssistKind.JOIN_IF_WITH_INNER, '''
+main() {
+  if ((1 == 1 || 2 == 2) && 3 == 3) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementInner_OK_onCondition() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2) {
+      print(0);
+    }
+  }
+}
+''');
+    assertHasAssistAt('1 ==', AssistKind.JOIN_IF_WITH_INNER, '''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementInner_OK_simpleConditions_block_block() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2) {
+      print(0);
+    }
+  }
+}
+''');
+    assertHasAssistAt('if (1 ==', AssistKind.JOIN_IF_WITH_INNER, '''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementInner_OK_simpleConditions_block_single() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2)
+      print(0);
+  }
+}
+''');
+    assertHasAssistAt('if (1 ==', AssistKind.JOIN_IF_WITH_INNER, '''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementInner_OK_simpleConditions_single_blockMulti() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2) {
+      print(1);
+      print(2);
+      print(3);
+    }
+  }
+}
+''');
+    assertHasAssistAt('if (1 ==', AssistKind.JOIN_IF_WITH_INNER, '''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(1);
+    print(2);
+    print(3);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementInner_OK_simpleConditions_single_blockOne() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1)
+    if (2 == 2) {
+      print(0);
+    }
+}
+''');
+    assertHasAssistAt('if (1 ==', AssistKind.JOIN_IF_WITH_INNER, '''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementInner_wrong_innerNotIf() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    print(0);
+  }
+}
+''');
+    assertNoAssistAt('if (1 ==', AssistKind.JOIN_IF_WITH_INNER);
+  }
+
+  void test_joinIfStatementInner_wrong_innerWithElse() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2) {
+      print(0);
+    } else {
+      print(1);
+    }
+  }
+}
+''');
+    assertNoAssistAt('if (1 ==', AssistKind.JOIN_IF_WITH_INNER);
+  }
+
+  void test_joinIfStatementInner_wrong_targetNotIf() {
+    _indexTestUnit('''
+main() {
+  print(0);
+}
+''');
+    assertNoAssistAt('print', AssistKind.JOIN_IF_WITH_INNER);
+  }
+
+  void test_joinIfStatementInner_wrong_targetWithElse() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2) {
+      print(0);
+    }
+  } else {
+    print(1);
+  }
+}
+''');
+    assertNoAssistAt('if (1 ==', AssistKind.JOIN_IF_WITH_INNER);
+  }
+
+  void test_joinIfStatementOuter_OK_conditionAndOr() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2 || 3 == 3) {
+      print(0);
+    }
+  }
+}
+''');
+    assertHasAssistAt('if (2 ==', AssistKind.JOIN_IF_WITH_OUTER, '''
+main() {
+  if (1 == 1 && (2 == 2 || 3 == 3)) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementOuter_OK_conditionInvocation() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (isCheck()) {
+      print(0);
+    }
+  }
+}
+bool isCheck() => false;
+''');
+    assertHasAssistAt('if (isCheck', AssistKind.JOIN_IF_WITH_OUTER, '''
+main() {
+  if (1 == 1 && isCheck()) {
+    print(0);
+  }
+}
+bool isCheck() => false;
+''');
+  }
+
+  void test_joinIfStatementOuter_OK_conditionOrAnd() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1 || 2 == 2) {
+    if (3 == 3) {
+      print(0);
+    }
+  }
+}
+''');
+    assertHasAssistAt('if (3 == 3', AssistKind.JOIN_IF_WITH_OUTER, '''
+main() {
+  if ((1 == 1 || 2 == 2) && 3 == 3) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementOuter_OK_onCondition() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2) {
+      print(0);
+    }
+  }
+}
+''');
+    assertHasAssistAt('if (2 == 2', AssistKind.JOIN_IF_WITH_OUTER, '''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementOuter_OK_simpleConditions_block_block() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2) {
+      print(0);
+    }
+  }
+}
+''');
+    assertHasAssistAt('if (2 == 2', AssistKind.JOIN_IF_WITH_OUTER, '''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementOuter_OK_simpleConditions_block_single() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2)
+      print(0);
+  }
+}
+''');
+    assertHasAssistAt('if (2 == 2', AssistKind.JOIN_IF_WITH_OUTER, '''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementOuter_OK_simpleConditions_single_blockMulti() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2) {
+      print(1);
+      print(2);
+      print(3);
+    }
+  }
+}
+''');
+    assertHasAssistAt('if (2 == 2', AssistKind.JOIN_IF_WITH_OUTER, '''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(1);
+    print(2);
+    print(3);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementOuter_OK_simpleConditions_single_blockOne() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1)
+    if (2 == 2) {
+      print(0);
+    }
+}
+''');
+    assertHasAssistAt('if (2 == 2', AssistKind.JOIN_IF_WITH_OUTER, '''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(0);
+  }
+}
+''');
+  }
+
+  void test_joinIfStatementOuter_wrong_outerNotIf() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    print(0);
+  }
+}
+''');
+    assertNoAssistAt('if (1 == 1', AssistKind.JOIN_IF_WITH_OUTER);
+  }
+
+  void test_joinIfStatementOuter_wrong_outerWithElse() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2) {
+      print(0);
+    }
+  } else {
+    print(1);
+  }
+}
+''');
+    assertNoAssistAt('if (2 == 2', AssistKind.JOIN_IF_WITH_OUTER);
+  }
+
+  void test_joinIfStatementOuter_wrong_targetNotIf() {
+    _indexTestUnit('''
+main() {
+  print(0);
+}
+''');
+    assertNoAssistAt('print', AssistKind.JOIN_IF_WITH_OUTER);
+  }
+
+  void test_joinIfStatementOuter_wrong_targetWithElse() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1) {
+    if (2 == 2) {
+      print(0);
+    } else {
+      print(1);
+    }
+  }
+}
+''');
+    assertNoAssistAt('if (2 == 2', AssistKind.JOIN_IF_WITH_OUTER);
+  }
+
   void test_joinVariableDeclaration_onAssignment_OK() {
     _indexTestUnit('''
 main() {
   var v;
   v = 1;
 }
 ''');
     assertHasAssistAt('v =', AssistKind.JOIN_VARIABLE_DECLARATION, '''
 main() {
   var v = 1;
@@ skipping 286 matching lines @@
   int a = 1, vvv, b = 2;
   if (true) {
     vvv = 111;
   } else {
     vvv = 222;
   }
 }
 ''');
   }
 
+  void test_replaceConditionalWithIfElse_wrong_noEnclosingStatement() {
+    _indexTestUnit('''
+var v = true ? 111 : 222;
+''');
+    assertNoAssistAt('? 111', AssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE);
+  }
+
+  void test_replaceIfElseWithConditional_OK_assignment() {
+    _indexTestUnit('''
+main() {
+  int vvv;
+  if (true) {
+    vvv = 111;
+  } else {
+    vvv = 222;
+  }
+}
+''');
+    assertHasAssistAt(
+        'if (true)',
+        AssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL,
+        '''
+main() {
+  int vvv;
+  vvv = true ? 111 : 222;
+}
+''');
+  }
+
+  void test_replaceIfElseWithConditional_OK_return() {
+    _indexTestUnit('''
+main() {
+  if (true) {
+    return 111;
+  } else {
+    return 222;
+  }
+}
+''');
+    assertHasAssistAt(
+        'if (true)',
+        AssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL,
+        '''
+main() {
+  return true ? 111 : 222;
+}
+''');
+  }
+
+  void test_replaceIfElseWithConditional_wrong_notIfStatement() {
+    _indexTestUnit('''
+main() {
+  print(0);
+}
+''');
+    assertNoAssistAt('print', AssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL);
+  }
+
+  void test_replaceIfElseWithConditional_wrong_notSingleStatememt() {
+    _indexTestUnit('''
+main() {
+  int vvv;
+  if (true) {
+    print(0);
+    vvv = 111;
+  } else {
+    print(0);
+    vvv = 222;
+  }
+}
+''');
+    assertNoAssistAt('if (true)', AssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL);
+  }
+
+  void test_splitAndCondition_OK_innerAndExpression() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1 && 2 == 2 && 3 == 3) {
+    print(0);
+  }
+}
+''');
+    assertHasAssistAt('&& 2 == 2', AssistKind.SPLIT_AND_CONDITION, '''
+main() {
+  if (1 == 1) {
+    if (2 == 2 && 3 == 3) {
+      print(0);
+    }
+  }
+}
+''');
+  }
+
+  void test_splitAndCondition_OK_thenBlock() {
+    _indexTestUnit('''
+main() {
+  if (true && false) {
+    print(0);
+    if (3 == 3) {
+      print(1);
+    }
+  }
+}
+''');
+    assertHasAssistAt('&& false', AssistKind.SPLIT_AND_CONDITION, '''
+main() {
+  if (true) {
+    if (false) {
+      print(0);
+      if (3 == 3) {
+        print(1);
+      }
+    }
+  }
+}
+''');
+  }
+
+  void test_splitAndCondition_OK_thenBlock_elseBlock() {
+    _indexTestUnit('''
+main() {
+  if (true && false) {
+    print(0);
+  } else {
+    print(1);
+    if (2 == 2) {
+      print(2);
+    }
+  }
+}
+''');
+    assertHasAssistAt('&& false', AssistKind.SPLIT_AND_CONDITION, '''
+main() {
+  if (true) {
+    if (false) {
+      print(0);
+    } else {
+      print(1);
+      if (2 == 2) {
+        print(2);
+      }
+    }
+  }
+}
+''');
+  }
+
+  void test_splitAndCondition_OK_thenStatement() {
+    _indexTestUnit('''
+main() {
+  if (true && false)
+    print(0);
+}
+''');
+    assertHasAssistAt('&& false', AssistKind.SPLIT_AND_CONDITION, '''
+main() {
+  if (true)
+    if (false)
+      print(0);
+}
+''');
+  }
+
+  void test_splitAndCondition_OK_thenStatement_elseStatement() {
+    _indexTestUnit('''
+main() {
+  if (true && false)
+    print(0);
+  else
+    print(1);
+}
+''');
+    assertHasAssistAt('&& false', AssistKind.SPLIT_AND_CONDITION, '''
+main() {
+  if (true)
+    if (false)
+      print(0);
+    else
+      print(1);
+}
+''');
+  }
+
+  void test_splitAndCondition_wrong() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1 && 2 == 2) {
+    print(0);
+  }
+  print(3 == 3 && 4 == 4);
+}
+''');
+    // not binary expression
+    assertNoAssistAt('main() {', AssistKind.SPLIT_AND_CONDITION);
+    // selection is not empty and includes more than just operator
+    {
+      length = 5;
+      assertNoAssistAt('&& 2 == 2', AssistKind.SPLIT_AND_CONDITION);
+    }
+  }
+
+  void test_splitAndCondition_wrong_notAnd() {
+    _indexTestUnit('''
+main() {
+  if (1 == 1 || 2 == 2) {
+    print(0);
+  }
+}
+''');
+    assertNoAssistAt('|| 2', AssistKind.SPLIT_AND_CONDITION);
+  }
+
+  void test_splitAndCondition_wrong_notPartOfIf() {
+    _indexTestUnit('''
+main() {
+  print(1 == 1 && 2 == 2);
+}
+''');
+    assertNoAssistAt('&& 2', AssistKind.SPLIT_AND_CONDITION);
+  }
+
+  void test_splitAndCondition_wrong_notTopLevelAnd() {
+    _indexTestUnit('''
+main() {
+  if (true || (1 == 1 && 2 == 2)) {
+    print(0);
+  }
+  if (true && (3 == 3 && 4 == 4)) {
+    print(0);
+  }
+}
+''');
+    assertNoAssistAt('&& 2', AssistKind.SPLIT_AND_CONDITION);
+    assertNoAssistAt('&& 4', AssistKind.SPLIT_AND_CONDITION);
+  }
+
+  void test_splitVariableDeclaration_OK_onName() {
+    _indexTestUnit('''
+main() {
+  var v = 1;
+}
+''');
+    assertHasAssistAt('v =', AssistKind.SPLIT_VARIABLE_DECLARATION, '''
+main() {
+  var v;
+  v = 1;
+}
+''');
+  }
+
+  void test_splitVariableDeclaration_OK_onType() {
+    _indexTestUnit('''
+main() {
+  int v = 1;
+}
+''');
+    assertHasAssistAt('int ', AssistKind.SPLIT_VARIABLE_DECLARATION, '''
+main() {
+  int v;
+  v = 1;
+}
+''');
+  }
+
+  void test_splitVariableDeclaration_OK_onVar() {
+    _indexTestUnit('''
+main() {
+  var v = 1;
+}
+''');
+    assertHasAssistAt('var ', AssistKind.SPLIT_VARIABLE_DECLARATION, '''
+main() {
+  var v;
+  v = 1;
+}
+''');
+  }
+
+  void test_splitVariableDeclaration_wrong_notOneVariable() {
+    _indexTestUnit('''
+main() {
+  var v = 1, v2;
+}
+''');
+    assertNoAssistAt('v = 1', AssistKind.SPLIT_VARIABLE_DECLARATION);
+  }
+
   String _applyEdits(String code, List<Edit> edits) {
     edits.sort((a, b) => b.offset - a.offset);
     edits.forEach((Edit edit) {
       code = code.substring(0, edit.offset) +
           edit.replacement +
           code.substring(edit.end);
     });
     return code;
   }
 
@@ skipping 43 matching lines @@
       positions.add(new Position(testFile, offset, length));
     }
     return positions;
   }
 
   void _indexTestUnit(String code) {
     resolveTestUnit(code);
     index.indexUnit(context, testUnit);
   }
 }