Complete for-each and switch statements

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;
@@ skipping 21 matching lines @@
   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_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");
   static const COMPLETE_WHILE_STMT = const StatementCompletionKind(
       'COMPLETE_WHILE_STMT', "Complete while-statement");
 }
 
 /**
  * A description of a statement completion.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class StatementCompletion {
@@ skipping 175 matching lines @@
   }
 
   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.
+    //TODO(messick) Move has-errors checking into dispatch method.
+    return false;
+  }
+
   bool _complete_doStatement() {
     if (errors.isEmpty || node is! DoStatement) {
       return false;
     }
     DoStatement statement = node;
     SourceBuilder sb = _sourceBuilderAfterKeyword(statement.doKeyword);
     bool hasWhileKeyword = statement.whileKeyword.lexeme == "while";
     int exitDelta = 0;
     if (statement.body is EmptyStatement) {
       String text = utils.getNodeText(statement.body);
@@ skipping 57 matching lines @@
     _insertBuilder(sb);
     if (exitDelta != 0) {
       exitPosition =
           new Position(exitPosition.file, exitPosition.offset + exitDelta);
     }
     _setCompletion(DartStatementCompletion.COMPLETE_DO_STMT);
     return true;
   }
 
   bool _complete_forEachStatement() {
-    // TODO(messick) Implement _complete_forEachStatement
-    return false;
+    if (errors.isEmpty || node is! ForEachStatement) {
+      return false;
+    }
+    ForEachStatement forNode = node;
+    if (forNode.inKeyword.isSynthetic) {
+      return false; // Can't happen -- would be parsed as a for-statement.
+    }
+    SourceBuilder sb =
+        new SourceBuilder(file, forNode.rightParenthesis.offset + 1);
+    AstNode name = forNode.identifier;
+    name ??= forNode.loopVariable;
+    String src = utils.getNodeText(forNode);
+    if (name == null) {
+      exitPosition = new Position(file, forNode.leftParenthesis.offset + 1);
+      src = src.substring(forNode.leftParenthesis.offset - forNode.offset);
+      if (src.startsWith(new RegExp(r'\(\s*in\s*\)'))) {
+        _addReplaceEdit(
+            rangeStartEnd(forNode.leftParenthesis.offset + 1,
+                forNode.rightParenthesis.offset),
+            ' in ');
+      } else if (src.startsWith(new RegExp(r'\(\s*in'))) {
+        _addReplaceEdit(
+            rangeStartEnd(
+                forNode.leftParenthesis.offset + 1, forNode.inKeyword.offset),
+            ' ');
+      }
+    } else if (_isSyntheticExpression(forNode.iterable)) {
+      exitPosition = new Position(file, forNode.rightParenthesis.offset + 1);
+      src = src.substring(forNode.inKeyword.offset - forNode.offset);
+      if (src.startsWith(new RegExp(r'in\s*\)'))) {
+        _addReplaceEdit(
+            rangeStartEnd(forNode.inKeyword.offset + forNode.inKeyword.length,
+                forNode.rightParenthesis.offset),
+            ' ');
+      }
+    }
+    if (_isEmptyStatement(forNode.body)) {
+      sb.append(' ');
+      _appendEmptyBraces(sb, exitPosition == null);
+    }
+    _insertBuilder(sb);
+    _setCompletion(DartStatementCompletion.COMPLETE_FOR_EACH_STMT);
+    return true;
   }
 
   bool _complete_forStatement() {
     if (errors.isEmpty || node is! ForStatement) {
       return false;
     }
     ForStatement forNode = node;
     SourceBuilder sb;
     int delta = 0;
     if (forNode.leftParenthesis.isSynthetic) {
@@ skipping 150 matching lines @@
       int insertOffset = error.offset + error.length;
       _addInsertEdit(insertOffset, ';');
       int offset = _appendNewlinePlusIndent() + 1 /* ';' */;
       _setCompletionAt(DartStatementCompletion.SIMPLE_SEMICOLON, offset);
       return true;
     }
     return false;
   }
 
   bool _complete_switchStatement() {
-    // TODO(messick) Implement _complete_switchStatement
-    return false;
+    if (errors.isEmpty || node is! SwitchStatement) {
+      return false;
+    }
+    SourceBuilder sb;
+    SwitchStatement switchNode = node;
+    if (switchNode.leftParenthesis.isSynthetic &&
+        switchNode.rightParenthesis.isSynthetic) {
+      exitPosition = new Position(file, switchNode.switchKeyword.end + 2);
+      String src = utils.getNodeText(switchNode);
+      if (src
+          .substring(switchNode.switchKeyword.end - switchNode.offset)
+          .startsWith(new RegExp(r'[ \t]+'))) {
+        sb = new SourceBuilder(file, switchNode.switchKeyword.end + 1);
+      } else {
+        sb = new SourceBuilder(file, switchNode.switchKeyword.end);
+        sb.append(' ');
+      }
+      sb.append('()');
+    } else if (switchNode.leftParenthesis.isSynthetic ||
+        switchNode.rightParenthesis.isSynthetic) {
+      return false;
+    } else {
+      sb = new SourceBuilder(file, switchNode.rightParenthesis.offset + 1);
+      if (_isSyntheticExpression(switchNode.expression)) {
+        exitPosition =
+            new Position(file, switchNode.leftParenthesis.offset + 1);
+      }
+    }
+    if (switchNode
+        .leftBracket.isSynthetic /*&& switchNode.rightBracket.isSynthetic*/) {
+      // See https://github.com/dart-lang/sdk/issues/29391
+      sb.append(' ');
+      _appendEmptyBraces(sb, exitPosition == null);
+    }
+    _insertBuilder(sb);
+    _setCompletion(DartStatementCompletion.COMPLETE_SWITCH_STMT);
+    return true;
   }
 
   bool _complete_tryStatement() {
     // TODO(messick) Implement _complete_tryStatement
     return false;
   }
 
   bool _complete_whileStatement() {
     if (errors.isEmpty || node is! WhileStatement) {
       return false;
@@ skipping 55 matching lines @@
       if (exitOffset != null) {
         exitPosition = _newPosition(exitOffset);
       }
     }
   }
 
   bool _isEmptyBlock(AstNode stmt) {
     return stmt is Block && stmt.statements.isEmpty;
   }
 
+  bool _isEmptyStatement(AstNode stmt) {
+    return stmt is EmptyStatement || _isEmptyBlock(stmt);
+  }
+
   bool _isSyntheticExpression(Expression expr) {
     return expr is SimpleIdentifier && expr.isSynthetic;
   }
 
-  bool _isEmptyStatement(AstNode stmt) {
-    return stmt is EmptyStatement || _isEmptyBlock(stmt);
-  }
-
   Position _newPosition(int offset) {
     return new Position(file, offset);
   }
 
   void _setCompletion(StatementCompletionKind kind, [List args]) {
     assert(exitPosition != null);
     change.selection = exitPosition;
     change.message = formatList(kind.message, args);
     linkedPositionGroups.values
         .forEach((group) => change.addLinkedEditGroup(group));
@@ skipping 26 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;
 }