Complete declarations; detect invalid blocks

pkg/analysis_server/test/services/completion/statement/statement_completion_test.dart

 // Copyright (c) 2017, 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.completion.statement;
 
 import 'package:analysis_server/src/protocol_server.dart';
 import 'package:analysis_server/src/services/completion/statement/statement_completion.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../../abstract_single_unit.dart';
 
 main() {
   defineReflectiveSuite(() {
+    defineReflectiveTests(_DeclarationCompletionTest);
     defineReflectiveTests(_ControlFlowCompletionTest);
     defineReflectiveTests(_DoCompletionTest);
     defineReflectiveTests(_ForCompletionTest);
     defineReflectiveTests(_ForEachCompletionTest);
     defineReflectiveTests(_IfCompletionTest);
     defineReflectiveTests(_SimpleCompletionTest);
     defineReflectiveTests(_SwitchCompletionTest);
     defineReflectiveTests(_TryCompletionTest);
     defineReflectiveTests(_WhileCompletionTest);
   });
@@ skipping 14 matching lines @@
     if (change.message == message) {
       if (!change.edits.isEmpty) {
         String resultCode =
             SourceEdit.applySequence(testCode, change.edits[0].edits);
         expect(resultCode, expectedCode.replaceAll('////', ''));
         if (cmp != null) {
           int offset = cmp(resultCode);
           expect(change.selection.offset, offset);
         }
       } else {
+        expect(testCode, expectedCode.replaceAll('////', ''));
         if (cmp != null) {
           int offset = cmp(testCode);
           expect(change.selection.offset, offset);
         }
       }
       return;
     }
     fail("Expected to find |$message| but got: " + change.message);
   }
 
@@ skipping 123 matching lines @@
 ex(e) {
   for (int i = 0; i < 3; i++) {
     throw e;
   }
   ////
 }
 ''',
         (s) => _afterLast(s, '  '));
   }
 
+  test_ifNoBlock() async {
+    await _prepareCompletion(
+        'return',
+        '''
+ex(e) {
+  if (true) return 0
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Add a semicolon and newline',
+        '''
+ex(e) {
+  if (true) return 0;
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
   test_ifThrow() async {
     await _prepareCompletion(
         'throw e;',
         '''
 ex(e) {
   if (true) {
     throw e;
   }
 }
 ''',
@@ skipping 54 matching lines @@
     return 3 + 4;
   }
   ////
 }
 ''',
         (s) => _afterLast(s, '  '));
   }
 }
 
 @reflectiveTest
+class _DeclarationCompletionTest extends StatementCompletionTest {
+  test_classNameNoBody() async {
+    await _prepareCompletion(
+        'Sample',
+        '''
+class Sample
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete class declaration',
+        '''
+class Sample {
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }

[Brian Wilkerson, 2017/05/01 15:28:32]

Perhaps add a test where there are other clauses, such as

class Sample extends Object

[messick, 2017/05/01 15:45:00]

Acknowledged.

+
+  test_functionDeclNoBody() async {
+    await _prepareCompletion(
+        'source()',
+        '''
+String source()
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete function declaration',
+        '''
+String source() {
+  ////
+}
+''',
+        (s) => _after(s, '  '));
+  }
+
+  test_methodDeclNoBody() async {
+    await _prepareCompletion(
+        'source()',
+        '''
+class Sample {
+  String source()
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete function declaration',
+        '''
+class Sample {
+  String source() {
+    ////
+  }
+}
+''',
+        (s) => _after(s, '    '));
+  }
+
+  test_variableDeclNoBody() async {
+    await _prepareCompletion(
+        'source',
+        '''
+String source
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete variable declaration',
+        '''
+String source;
+////
+''',
+        (s) => _after(s, ';\n'));
+  }
+}
+
+@reflectiveTest
 class _DoCompletionTest extends StatementCompletionTest {
   test_emptyCondition() async {
     await _prepareCompletion(
         'while ()',
         '''
 main() {
   do {
   } while ()
 }
 ''',
@@ skipping 23 matching lines @@
         '''
 main() {
   do {
     ////
   } while ();
 }
 ''',
         (s) => _after(s, 'while ('));
   }
 
+  test_keywordStatement() async {
+    await _prepareCompletion(
+        'do',
+        '''
+main() {
+  do ////
+  return;
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete do-statement',
+        '''
+main() {
+  do {
+    ////
+  } while ();
+  return;
+}
+''',
+        (s) => _after(s, 'while ('));
+  }
+
   test_noBody() async {
     await _prepareCompletion(
         'do',
         '''
 main() {
   do;
   while
 }
 ''',
         atEnd: true);
@@ skipping 69 matching lines @@
         '''
 main() {
   for (int i = 0; ; ) {
   }
 }
 ''',
         (s) => _after(s, '0; '));
   }
 
   test_emptyInitializers() async {
+    // TODO(messick) This should insert a newline and move the cursor there.

[Brian Wilkerson, 2017/05/01 15:28:32]

Consider updating the expectations as appropriate and using "@failingTest" to
mark the test as being expected to fail.

[messick, 2017/05/01 15:45:00]

Acknowledged.

     await _prepareCompletion(
         '}',
         '''
 main() {
   for () {
   }
 }
 ''',
         atEnd: true);
     _assertHasChange(
@@ skipping 104 matching lines @@
     _assertHasChange(
         'Complete for-statement',
         '''
 main() {
   for (int i = 0; ) {
   }
 }
 ''',
         (s) => _after(s, '0; '));
   }
+
+  test_noError() async {
+    await _prepareCompletion(
+        ';)',
+        '''
+main() {
+  for (;;)
+  return;
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete for-statement',
+        '''
+main() {
+  for (;;) {
+    ////
+  }
+  return;
+}
+''',
+        (s) => _after(s, '    '));
+  }
 }
 
 @reflectiveTest
 class _ForEachCompletionTest extends StatementCompletionTest {
   test_emptyIdentifier() async {
     await _prepareCompletion(
         'in xs)',
         '''
 main() {
   for (in xs)
@@ skipping 46 matching lines @@
         'Complete for-each-statement',
         '''
 main() {
   for (var x in ) {
     ////
   }
 }
 ''',
         (s) => _after(s, 'in '));
   }
+
+  test_noError() async {
+    await _prepareCompletion(
+        '])',
+        '''
+main() {
+  for (var x in [1,2])
+  return;
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete for-each-statement',
+        '''
+main() {
+  for (var x in [1,2]) {
+    ////
+  }
+  return;
+}
+''',
+        (s) => _after(s, '    '));
+  }
 }
 
 @reflectiveTest
 class _IfCompletionTest extends StatementCompletionTest {
   test_afterCondition_BAD() async {
     // TODO(messick) Stop inserting the space after the closing brace.
     await _prepareCompletion(
         'if (true) ', // Trigger completion after space.
         '''
 main() {
@@ skipping 48 matching lines @@
         '''
 main() {
   if () {
     ////
   }
 }
 ''',
         (s) => _after(s, 'if ('));
   }
 
+  test_noError() async {
+    await _prepareCompletion(
+        'if (true)',
+        '''
+main() {
+  if (true)
+  return;
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete if-statement',
+        '''
+main() {
+  if (true) {
+    ////
+  }
+  return;
+}
+''',
+        (s) => _after(s, '    '));
+  }
+
   test_withCondition() async {
     await _prepareCompletion(
         'if (tr', // Trigger completion from within expression.
         '''
 main() {
   if (true)
 }
 ''',
         atEnd: true);
     _assertHasChange(
@@ skipping 18 matching lines @@
 }
 ''',
         atEnd: true);
     _assertHasChange(
         // Note: if-statement completion should not trigger.
         'Insert a newline at the end of the current line',
         '''
 main() {
   if ()
   else
-  }
 }
 ''',
         (s) => _after(s, 'if ()'));
   }
 
   test_withinEmptyCondition() async {
     await _prepareCompletion(
         'if (',
         '''
 main() {
@@ skipping 28 matching lines @@
     _assertHasChange(
         'Insert a newline at the end of the current line',
         '''
 main() {
   int v = 1;
   ////
 }
 ''');
   }
 
-  test_semicolon() async {
+  test_noCloseParen() async {
+    await _prepareCompletion(
+        'ing(3',
+        '''
+main() {
+  var s = 'sample'.substring(3
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Insert a newline at the end of the current line',
+        '''
+main() {
+  var s = 'sample'.substring(3);
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
+  test_noCloseParenWithSemicolon() async {
+    String before = '''
+main() {
+  var s = 'sample'.substring(3;
+}
+''';
+    String after = '''
+main() {
+  var s = 'sample'.substring(3);
+  ////
+}
+''';
+    // Check completion both before and after the semicolon.
+    await _prepareCompletion('ing(3', before, atEnd: true);
+    _assertHasChange('Insert a newline at the end of the current line', after,
+        (s) => _afterLast(s, '  '));
+    await _prepareCompletion('ing(3;', before, atEnd: true);
+    _assertHasChange('Insert a newline at the end of the current line', after,
+        (s) => _afterLast(s, '  '));
+  }
+
+  test_semicolonFn() async {
+    await _prepareCompletion(
+        '=> 3',
+        '''
+main() {
+  int f() => 3
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Add a semicolon and newline',
+        '''
+main() {
+  int f() => 3;
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
+  test_semicolonFnBody() async {
+    // It would be reasonable to add braces in this case. Unfortunately,
+    // the incomplete line parses as two statements ['int;', 'f();'], not one.
+    await _prepareCompletion(
+        'f()',
+        '''
+main() {
+  int f()
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Insert a newline at the end of the current line',
+        '''
+main() {
+  int f()
+}
+''',
+        (s) => _afterLast(s, '()'));
+  }
+
+  test_semicolonFnBodyWithDef() async {
+    // This ought to be the same as test_semicolonFnBody() but the definition
+    // of f() removes an error and it appears to be a different case.
+    // Suggestions for unifying the two are welcome.
+    await _prepareCompletion(
+        'f()',
+        '''
+main() {
+  int f()
+}
+f() {}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Add a semicolon and newline',
+        '''
+main() {
+  int f();
+  ////
+}
+f() {}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
+  test_semicolonFnExpr() async {
+    await _prepareCompletion(
+        '=>',
+        '''
+main() {
+  int f() =>
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Add a semicolon and newline',
+        '''
+main() {
+  int f() => ;
+  ////
+}
+''',
+        (s) => _afterLast(s, '=> '));
+  }
+
+  test_semicolonFnSpaceExpr() async {
+    await _prepareCompletion(
+        '=>',
+        '''
+main() {
+  int f() => ////
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Add a semicolon and newline',
+        '''
+main() {
+  int f() => ;
+  ////
+}
+''',
+        (s) => _afterLast(s, '=> '));
+  }
+
+  test_semicolonVar() async {
     await _prepareCompletion(
         'v = 1',
         '''
 main() {
   int v = 1
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Add a semicolon and newline',
@@ skipping 376 matching lines @@
         '''
 main() {
   while () {
     ////
   }
 }
 ''',
         (s) => _after(s, 'while ('));
   }
 }