Complete for-statement

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 19 matching lines @@
   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_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_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 122 matching lines @@
           error.offset <= node.offset + node.length) {
         if (error.errorCode is! HintCode) {
           errors.add(error);
         }
       }
     }
 
     // TODO(messick) Consider changing (some of) this to a visitor.
     if (_complete_ifStatement() ||
         _complete_doStatement() ||
+        _complete_forStatement() ||
+        _complete_forEachStatement() ||
+        _complete_switchStatement() ||
+        _complete_tryStatement() ||
         _complete_whileStatement() ||
         _complete_simpleSemicolon() ||
         _complete_simpleEnter()) {
       return completion;
     }
     return NO_COMPLETION;
   }
 
-  void _addIndentEdit(SourceRange range, String oldIndent, String newIndent) {
-    SourceEdit edit = utils.createIndentEdit(range, oldIndent, newIndent);
-    doSourceChange_addElementEdit(change, unitElement, edit);
-  }
-
   void _addInsertEdit(int offset, String text) {
     SourceEdit edit = new SourceEdit(offset, 0, text);
     doSourceChange_addElementEdit(change, unitElement, edit);
   }
 
   void _addReplaceEdit(SourceRange range, String text) {
     SourceEdit edit = new SourceEdit(range.offset, range.length, text);
     doSourceChange_addElementEdit(change, unitElement, edit);
   }
 
@@ skipping 26 matching lines @@
       text = text.substring(0, text.length - eol.length);
     }
     return text;
   }
 
   bool _complete_doStatement() {
     if (errors.isEmpty || node is! DoStatement) {
       return false;
     }
     DoStatement statement = node;
-    var stmt = new _DoIfWhileStructure(
-        statement.whileKeyword,
-        statement.leftParenthesis,
-        statement.condition,
-        statement.rightParenthesis,
-        null);
     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);
       int delta = 0;
       if (text.startsWith(';')) {
         delta = 1;
         _addReplaceEdit(rangeStartLength(statement.body.offset, delta), '');
         if (hasWhileKeyword) {
           text = utils.getNodeText(statement);
           if (text.indexOf(new RegExp(r'do\s*;\s*while')) == 0) {
             int end = text.indexOf('while');
             int start = text.indexOf(';') + 1;
             delta += end - start - 1;
             _addReplaceEdit(
                 rangeStartLength(start + statement.offset, end - start), ' ');
           }
         }
         sb = new SourceBuilder(file, sb.offset + delta);
         sb.append(' ');
       }
-      _appendEmptyBraces(
-          sb, !(hasWhileKeyword && _isEmptyExpression(statement.condition)));
+      _appendEmptyBraces(sb,
+          !(hasWhileKeyword && _isSyntheticExpression(statement.condition)));
       if (delta != 0) {
         exitDelta = sb.length - delta;
       }
     } else if (_isEmptyBlock(statement.body)) {
       sb = new SourceBuilder(sb.file, statement.body.end);
     }
     SourceBuilder sb2;
     if (hasWhileKeyword) {
+      var stmt = new _KeywordConditionBlockStructure(
+          statement.whileKeyword,
+          statement.leftParenthesis,
+          statement.condition,
+          statement.rightParenthesis,
+          null);
       sb2 = _complete_keywordCondition(stmt);
       if (sb2.length == 0) {
         // true if condition is '()'
         if (exitPosition != null) {
-          if (statement.semicolon.lexeme.isEmpty) {
+          if (statement.semicolon.isSynthetic) {
             _insertBuilder(sb);
             sb = new SourceBuilder(file, exitPosition.offset + 1);
             sb.append(';');
           }
         }
       } else {
         if (sb.exitOffset == null && sb2?.exitOffset != null) {
           _insertBuilder(sb);
           sb = sb2;
           sb.append(';');
         } else {
           sb.append(sb2.toString());
         }
       }
     } else {
       sb.append(" while (");
       sb.setExitOffset();
       sb.append(");");
     }
     _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;
+  }
+
+  bool _complete_forStatement() {
+    if (errors.isEmpty || node is! ForStatement) {
+      return false;
+    }
+    ForStatement forNode = node;
+    SourceBuilder sb;
+    int delta = 0;
+    if (forNode.leftParenthesis.isSynthetic) {
+      if (!forNode.rightParenthesis.isSynthetic) {
+        return false;
+      }
+      // keywordOnly (unit test name suffix that exercises this branch)
+      sb = _sourceBuilderAfterKeyword(forNode.forKeyword);
+      sb.append('(');
+      sb.setExitOffset();
+      sb.append(')');
+    } else {
+      if (!forNode.rightSeparator.isSynthetic) {
+        // Fully-defined init, cond, updaters so nothing more needed here.
+        // emptyParts
+        sb = new SourceBuilder(file, forNode.rightParenthesis.offset + 1);
+      } else if (!forNode.leftSeparator.isSynthetic) {
+        if (_isSyntheticExpression(forNode.condition)) {
+          exitPosition = _newPosition(forNode.leftSeparator.offset + 1);
+          String text = utils
+              .getNodeText(forNode)
+              .substring(forNode.leftSeparator.offset - forNode.offset);
+          if (text.startsWith(new RegExp(r';\s*\)'))) {
+            // emptyCondition
+            int end = text.indexOf(')');
+            sb = new SourceBuilder(file, forNode.leftSeparator.offset);
+            // TODO(messick) Consider adding two semicolons here.
+            _addReplaceEdit(rangeStartLength(sb.offset, end), '; ');
+            delta = end - '; '.length;
+          } else {
+            // emptyInitializersEmptyCondition
+            exitPosition = _newPosition(forNode.rightParenthesis.offset);
+            sb = new SourceBuilder(file, forNode.rightParenthesis.offset);
+          }
+        } else {
+          // emptyUpdaters
+          exitPosition = _newPosition(forNode.rightSeparator.offset);
+          sb = new SourceBuilder(file, forNode.rightSeparator.offset);
+          _addReplaceEdit(rangeStartLength(sb.offset, 0), '; ');
+          delta = -'; '.length;
+        }
+      } else if (_isSyntheticExpression(forNode.initialization)) {
+        // emptyInitializers
+        exitPosition = _newPosition(forNode.rightParenthesis.offset);
+        sb = new SourceBuilder(file, forNode.rightParenthesis.offset);
+      } else {
+        int start = forNode.condition.offset + forNode.condition.length;
+        String text =
+            utils.getNodeText(forNode).substring(start - forNode.offset);
+        if (text.startsWith(new RegExp(r'\s*\)'))) {
+          // missingLeftSeparator
+          int end = text.indexOf(')');
+          sb = new SourceBuilder(file, start);
+          _addReplaceEdit(rangeStartLength(start, end), '; ');
+          delta = end - '; '.length;
+          exitPosition = new Position(file, start);
+        } else {
+          // Not possible; any comment following init is attached to init.
+          exitPosition = _newPosition(forNode.rightParenthesis.offset);
+          sb = new SourceBuilder(file, forNode.rightParenthesis.offset);
+        }
+      }
+    }
+    if (forNode.body is EmptyStatement) {
+      // keywordOnly
+      sb.append(' ');
+      _appendEmptyBraces(sb, exitPosition == null);
+    }
+    if (delta != 0 && exitPosition != null) {
+      // missingLeftSeparator
+      exitPosition = new Position(file, exitPosition.offset - delta);
+    }
+    _insertBuilder(sb);
+    _setCompletion(DartStatementCompletion.COMPLETE_FOR_STMT);
+    return true;
+  }
+
   bool _complete_ifOrWhileStatement(
-      _DoIfWhileStructure statement, StatementCompletionKind kind) {
+      _KeywordConditionBlockStructure statement, StatementCompletionKind kind) {
     SourceBuilder sb = _complete_keywordCondition(statement);
     if (statement.block is EmptyStatement) {
       sb.append(' ');
       _appendEmptyBraces(sb, exitPosition == null);
     }
     _insertBuilder(sb);
     _setCompletion(kind);
     return true;
   }
 
   bool _complete_ifStatement() {
     if (errors.isEmpty || node is! IfStatement) {
       return false;
     }
     IfStatement ifNode = node;
     if (ifNode != null) {
       if (ifNode.elseKeyword != null) {
         return false;
       }
-      var stmt = new _DoIfWhileStructure(
+      var stmt = new _KeywordConditionBlockStructure(
           ifNode.ifKeyword,
           ifNode.leftParenthesis,
           ifNode.condition,
           ifNode.rightParenthesis,
           ifNode.thenStatement);
       return _complete_ifOrWhileStatement(
           stmt, DartStatementCompletion.COMPLETE_IF_STMT);
     }
     return false;
   }
 
-  SourceBuilder _complete_keywordCondition(_DoIfWhileStructure statement) {
+  SourceBuilder _complete_keywordCondition(
+      _KeywordConditionBlockStructure statement) {
     SourceBuilder sb;
-    String text = _baseNodeText(node);
-    if (statement.leftParenthesis.lexeme.isEmpty) {
-      if (!statement.rightParenthesis.lexeme.isEmpty) {
+    if (statement.leftParenthesis.isSynthetic) {
+      if (!statement.rightParenthesis.isSynthetic) {
         // Quite unlikely to see this so don't try to fix it.
         return null;
       }
       sb = _sourceBuilderAfterKeyword(statement.keyword);
       sb.append('(');
       sb.setExitOffset();
       sb.append(')');
     } else {
-      if (_isEmptyExpression(statement.condition)) {
+      if (_isSyntheticExpression(statement.condition)) {
         exitPosition = _newPosition(statement.leftParenthesis.offset + 1);
         sb = new SourceBuilder(file, statement.rightParenthesis.offset + 1);
       } else {
         sb = new SourceBuilder(file, statement.rightParenthesis.offset + 1);
       }
     }
     return sb;
   }
 
   bool _complete_simpleEnter() {
@@ skipping 18 matching lines @@
     if (error != null) {
       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;
+  }
+
+  bool _complete_tryStatement() {
+    // TODO(messick) Implement _complete_tryStatement
+    return false;
+  }
+
   bool _complete_whileStatement() {
     if (errors.isEmpty || node is! WhileStatement) {
       return false;
     }
     WhileStatement whileNode = node;
     if (whileNode != null) {
-      var stmt = new _DoIfWhileStructure(
+      var stmt = new _KeywordConditionBlockStructure(
           whileNode.whileKeyword,
           whileNode.leftParenthesis,
           whileNode.condition,
           whileNode.rightParenthesis,
           whileNode.body);
       return _complete_ifOrWhileStatement(
           stmt, DartStatementCompletion.COMPLETE_WHILE_STMT);
     }
     return false;
   }
@@ skipping 41 matching lines @@
       if (exitOffset != null) {
         exitPosition = _newPosition(exitOffset);
       }
     }
   }
 
   bool _isEmptyBlock(AstNode stmt) {
     return stmt is Block && stmt.statements.isEmpty;
   }
 
-  bool _isEmptyExpression(Expression expr) {
-    if (expr is! SimpleIdentifier) {
-      return false;
-    }
-    SimpleIdentifier id = expr as SimpleIdentifier;
-    return id.length == 0;
+  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);
   }
 
@@ skipping 21 matching lines @@
       sb = new SourceBuilder(file, keyword.offset + len);
       sb.append(' ');
     } else {
       sb = new SourceBuilder(file, keyword.offset + len + 1);
     }
     return sb;
   }
 }
 
 // Encapsulate common structure of if-statement and while-statement.
-class _DoIfWhileStructure {
+class _KeywordConditionBlockStructure {
   final Token keyword;
   final Token leftParenthesis, rightParenthesis;
   final Expression condition;
   final Statement block;
 
-  _DoIfWhileStructure(this.keyword, this.leftParenthesis, this.condition,
-      this.rightParenthesis, this.block);
+  _KeywordConditionBlockStructure(this.keyword, this.leftParenthesis,
+      this.condition, this.rightParenthesis, this.block);
 
   int get offset => keyword.offset;
 }