Add special completion for control-flow block exits

pkg/analysis_server/lib/src/services/completion/statement/statement_completion.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 services.src.completion.statement;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
 import 'package:analysis_server/src/services/correction/source_buffer.dart';
 import 'package:analysis_server/src/services/correction/source_range.dart';
 import 'package:analysis_server/src/services/correction/util.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
-import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/error.dart' as engine;
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/error/hint_codes.dart';
 import 'package:analyzer/src/dart/error/syntactic_errors.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 /**
  * An enumeration of possible statement completion kinds.
  */
 class DartStatementCompletion {
   static const NO_COMPLETION =
       const StatementCompletionKind('No_COMPLETION', 'No completion available');
   static const SIMPLE_ENTER = const StatementCompletionKind(
       'SIMPLE_ENTER', "Insert a newline at the end of the current line");
   static const SIMPLE_SEMICOLON = const StatementCompletionKind(
       'SIMPLE_SEMICOLON', "Add a semicolon and newline");
+  static const COMPLETE_CONTROL_FLOW_BLOCK = const StatementCompletionKind(
+      'COMPLETE_CONTROL_FLOW_BLOCK', "Complete control flow block");
   static const COMPLETE_DO_STMT = const StatementCompletionKind(
       'COMPLETE_DO_STMT', "Complete do-statement");
   static const COMPLETE_IF_STMT = const StatementCompletionKind(
       'COMPLETE_IF_STMT', "Complete if-statement");
   static const COMPLETE_FOR_STMT = const StatementCompletionKind(
       'COMPLETE_FOR_STMT', "Complete for-statement");
   static const COMPLETE_FOR_EACH_STMT = const StatementCompletionKind(
       'COMPLETE_FOR_EACH_STMT', "Complete for-each-statement");
   static const COMPLETE_SWITCH_STMT = const StatementCompletionKind(
       'COMPLETE_SWITCH_STMT', "Complete switch-statement");
@@ skipping 132 matching lines @@
     for (engine.AnalysisError error in statementContext.errors) {
       if (error.offset >= node.offset &&
           error.offset <= node.offset + node.length) {
         if (error.errorCode is! HintCode) {
           errors.add(error);
         }
       }
     }
 
     if (errors.isEmpty) {
-      if (_complete_simpleEnter()) {
+      if (_complete_controlFlowBlock() || _complete_simpleEnter()) {
         return completion;
       }
     } else {
       if (_complete_ifStatement() ||
           _complete_doStatement() ||
           _complete_forStatement() ||
           _complete_forEachStatement() ||
           _complete_switchStatement() ||
           _complete_tryStatement() ||
           _complete_whileStatement() ||
+          _complete_controlFlowBlock() ||
           _complete_simpleSemicolon() ||
-          _complete_controlFlowBlock() ||
           _complete_simpleEnter()) {
         return completion;
       }
     }
     return NO_COMPLETION;
   }
 
   void _addInsertEdit(int offset, String text) {
     SourceEdit edit = new SourceEdit(offset, 0, text);
     doSourceChange_addElementEdit(change, unitElement, edit);
@@ skipping 12 matching lines @@
     sb.append(utils.getIndent(1));
     if (needsExitMark && sb.exitOffset == null) {
       sb.setExitOffset();
     }
     sb.append(eol);
     sb.append(indent);
     sb.append('}');
   }
 
   int _appendNewlinePlusIndent() {
+    return _appendNewlinePlusIndentAt(selectionOffset);
+  }
+
+  int _appendNewlinePlusIndentAt(int offset) {

[Brian Wilkerson, 2017/04/21 21:45:45]

I don't feel strongly about it, but in case you didn't think about it, you could
have a single method by writing:

int _appendNewlinePlusIndent({int offset}) {
  offset ??= selectionOffset;

     // Append a newline plus proper indent and another newline.
     // Return the position before the second newline.
-    String indent = utils.getLinePrefix(selectionOffset);
-    int loc = utils.getLineNext(selectionOffset);
+    String indent = utils.getLinePrefix(offset);
+    int loc = utils.getLineNext(offset);
     _addInsertEdit(loc, indent + eol);
     return loc + indent.length;
   }
 
   String _baseNodeText(AstNode astNode) {
     String text = utils.getNodeText(astNode);
     if (text.endsWith(eol)) {
       text = text.substring(0, text.length - eol.length);
     }
     return text;
   }
 
   bool _complete_controlFlowBlock() {
-    //TODO(messick) Implement _complete_controlFlowBlock
-    // Use statement completion to move the cursor to a new line outside the
-    // current block. The statement has no errors in this case. Used to jump
-    // out of do/for/if/while blocks.
-    return false;
+    Expression expr = (node is ExpressionStatement)
+        ? (node as ExpressionStatement).expression
+        : (node is ReturnStatement
+            ? (node as ReturnStatement).expression
+            : null);
+    if (!(node is ReturnStatement || expr is ThrowExpression)) {
+      return false;
+    }
+    if (node.parent is! Block) {
+      return false;
+    }
+    AstNode outer = node.parent.parent;
+    if (!(outer is DoStatement ||
+        outer is ForStatement ||
+        outer is ForEachStatement ||
+        outer is IfStatement ||
+        outer is WhileStatement)) {
+      return false;
+    }
+    int delta = 0;
+    if (errors.isNotEmpty) {
+      var error =
+          _findError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "';'");
+      if (error != null) {
+        int insertOffset;
+        if (expr == null || expr.isSynthetic) {
+          if (node is ReturnStatement) {
+            insertOffset = (node as ReturnStatement).returnKeyword.end;
+          } else if (node is ExpressionStatement) {
+            insertOffset =
+                ((node as ExpressionStatement).expression as ThrowExpression)
+                    .throwKeyword
+                    .end;
+          } else {
+            insertOffset = node.end; // Not reached.
+          }
+        } else {
+          insertOffset = expr.end;
+        }
+        //TODO(messick) Uncomment the following line when error location is fixed.
+        //insertOffset = error.offset + error.length;
+        _addInsertEdit(insertOffset, ';');
+        delta = 1;
+      }
+    }
+    int offset = _appendNewlinePlusIndentAt(node.parent.end);
+    exitPosition = new Position(file, offset + delta);
+    _setCompletion(DartStatementCompletion.COMPLETE_CONTROL_FLOW_BLOCK);
+    return true;
   }
 
   bool _complete_doStatement() {
     if (node is! DoStatement) {
       return false;
     }
     DoStatement statement = node;
     SourceBuilder sb = _sourceBuilderAfterKeyword(statement.doKeyword);
     bool hasWhileKeyword = statement.whileKeyword.lexeme == "while";
     int exitDelta = 0;
@@ skipping 267 matching lines @@
     _setCompletionAt(DartStatementCompletion.SIMPLE_ENTER, offset);
     return true;
   }
 
   bool _complete_simpleSemicolon() {
     if (errors.length != 1) {
       return false;
     }
     var error = _findError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "';'");
     if (error != null) {
+      // TODO(messick) Fix this to find the correct place in all cases.
       int insertOffset = error.offset + error.length;
       _addInsertEdit(insertOffset, ';');
       int offset = _appendNewlinePlusIndent() + 1 /* ';' */;
       _setCompletionAt(DartStatementCompletion.SIMPLE_SEMICOLON, offset);
       return true;
     }
     return false;
   }
 
   bool _complete_switchStatement() {
@@ skipping 253 matching lines @@
   final Token keyword;
   final Token leftParenthesis, rightParenthesis;
   final Expression condition;
   final Statement block;
 
   _KeywordConditionBlockStructure(this.keyword, this.leftParenthesis,
       this.condition, this.rightParenthesis, this.block);
 
   int get offset => keyword.offset;
 }