Complete declarations; detect invalid blocks

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/protocol/protocol_generated.dart';
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
@@ skipping 15 matching lines @@
 /**
  * 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_CLASS_DECLARATION = const StatementCompletionKind(
+      'COMPLETE_CLASS_DECLARATION', "Complete class declaration");
   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_FUNCTION_DECLARATION = const StatementCompletionKind(
+      'COMPLETE_FUNCTION_DECLARATION', "Complete function declaration");
   static const COMPLETE_SWITCH_STMT = const StatementCompletionKind(
       'COMPLETE_SWITCH_STMT', "Complete switch-statement");
   static const COMPLETE_TRY_STMT = const StatementCompletionKind(
       'COMPLETE_TRY_STMT', "Complete try-statement");
+  static const COMPLETE_VARIABLE_DECLARATION = const StatementCompletionKind(
+      'COMPLETE_VARIABLE_DECLARATION', "Complete variable declaration");
   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 101 matching lines @@
   CompilationUnit get unit => statementContext.unit;
 
   CompilationUnitElement get unitElement => statementContext.unitElement;
 
   Future<StatementCompletion> compute() async {
     // If the source was changed between the constructor and running
     // this asynchronous method, it is not safe to use the unit.
     if (analysisContext.getModificationStamp(source) != fileStamp) {
       return NO_COMPLETION;
     }
-    node = new NodeLocator(selectionOffset).searchWithin(unit);
+    node = _selectedNode();
     if (node == null) {
       return NO_COMPLETION;
     }
-    // TODO(messick): This needs to work for declarations.
-    AstNode newNode = node.getAncestor((n) => n is Statement);
-    if (newNode is Block) {
-      Block blockNode = newNode;
+    node = node
+        .getAncestor((n) => n is Statement || _isNonStatementDeclaration(n));
+    if (node == null) {
+      return _complete_simpleEnter() ? completion : NO_COMPLETION;
+    }
+    if (node is Block) {
+      Block blockNode = node;
       if (blockNode.statements.isNotEmpty) {
         node = blockNode.statements.last;
-      } else {
-        node = newNode;
       }
-    } else {
-      node = newNode;
     }
     if (_isEmptyStatement(node)) {
       node = node.parent;
     }
     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_controlFlowBlock() || _complete_simpleEnter()) {
-        return completion;
+    if (node is Statement) {
+      if (errors.isEmpty) {
+        if (_complete_ifStatement() ||
+            _complete_forStatement() ||
+            _complete_forEachStatement() ||
+            _complete_whileStatement() ||
+            _complete_controlFlowBlock()) {
+          return completion;
+        }
+      } else {
+        if (_complete_ifStatement() ||
+            _complete_doStatement() ||
+            _complete_forStatement() ||
+            _complete_forEachStatement() ||
+            _complete_functionDeclarationStatement() ||
+            _complete_switchStatement() ||
+            _complete_tryStatement() ||
+            _complete_whileStatement() ||
+            _complete_controlFlowBlock() ||
+            _complete_simpleSemicolon() ||
+            _complete_methodCall()) {
+          return completion;
+        }
       }
-    } else {
-      if (_complete_ifStatement() ||
-          _complete_doStatement() ||
-          _complete_forStatement() ||
-          _complete_forEachStatement() ||
-          _complete_switchStatement() ||
-          _complete_tryStatement() ||
-          _complete_whileStatement() ||
-          _complete_controlFlowBlock() ||
-          _complete_simpleSemicolon() ||
-          _complete_simpleEnter()) {
-        return completion;
+    } else if (node is Declaration) {
+      if (errors.isNotEmpty) {
+        if (_complete_classDeclaration() ||
+            _complete_functionDeclaration() ||
+            _complete_variableDeclaration()) {
+          return completion;
+        }
       }
     }
+    if (_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);
   }
 
   void _addReplaceEdit(SourceRange range, String text) {
     SourceEdit edit = new SourceEdit(range.offset, range.length, text);
@@ skipping 28 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_classDeclaration() {
+    if (node is! ClassDeclaration) {
+      return false;
+    }
+    ClassDeclaration decl = node;
+    if (decl.leftBracket.isSynthetic && errors.length == 1) {
+      // The space before the left brace is assumed to exist, even if it does not.
+      SourceBuilder sb = new SourceBuilder(file, decl.end - 1);
+      sb.append(' ');
+      _appendEmptyBraces(sb, true);
+      _insertBuilder(sb);
+      _setCompletion(DartStatementCompletion.COMPLETE_CLASS_DECLARATION);
+      return true;
+    }
+    return false;
+  }
+
   bool _complete_controlFlowBlock() {
     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) {
@@ skipping 40 matching lines @@
   }
 
   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;
-    if (statement.body is EmptyStatement) {
+    if (!_statementHasValidBody(statement.doKeyword, statement.body)) {
       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;
@@ skipping 87 matching lines @@
     } 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)) {
+    if (!_statementHasValidBody(forNode.forKeyword, forNode.body)) {
       sb.append(' ');
       _appendEmptyBraces(sb, exitPosition == null);
     }
     _insertBuilder(sb);
     _setCompletion(DartStatementCompletion.COMPLETE_FOR_EACH_STMT);
     return true;
   }
 
   bool _complete_forStatement() {
     if (node is! ForStatement) {
@@ skipping 55 matching lines @@
           _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
+    if (!_statementHasValidBody(forNode.forKeyword, forNode.body)) {
+      // keywordOnly, noError
       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_functionDeclaration() {
+    if (node is! MethodDeclaration && node is! FunctionDeclaration) {
+      return false;
+    }
+    SourceBuilder sb = new SourceBuilder(file, node.end - 1);
+    sb.append(' ');
+    _appendEmptyBraces(sb, true);
+    _insertBuilder(sb);
+    _setCompletion(DartStatementCompletion.COMPLETE_FUNCTION_DECLARATION);
+    return true;
+  }
+
+  bool _complete_functionDeclarationStatement() {
+    if (node is! FunctionDeclarationStatement) {
+      return false;
+    }
+    var error = _findError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "';'");
+    if (error != null) {
+      FunctionDeclarationStatement stmt = node;
+      String src = utils.getNodeText(stmt);
+      int insertOffset = stmt.functionDeclaration.end - 1;
+      if (stmt.functionDeclaration.functionExpression.body
+          is ExpressionFunctionBody) {
+        ExpressionFunctionBody fnb =
+            stmt.functionDeclaration.functionExpression.body;
+        int fnbOffset = fnb.functionDefinition.offset;
+        String fnSrc = src.substring(fnbOffset - stmt.offset);
+        if (!fnSrc.startsWith('=>')) {
+          return false;
+        }
+        int delta = 0;
+        if (fnb.expression.isSynthetic) {
+          if (!fnSrc.startsWith('=> ')) {
+            _addInsertEdit(insertOffset, ' ');
+            delta = 1;
+          }
+          _addInsertEdit(insertOffset, ';');
+          _appendNewlinePlusIndentAt(insertOffset);
+        } else {
+          delta = 1;
+          _addInsertEdit(insertOffset, ';');
+          insertOffset = _appendNewlinePlusIndent();
+        }
+        _setCompletionAt(
+            DartStatementCompletion.SIMPLE_SEMICOLON, insertOffset + delta);
+        return true;
+      }
+    }
+    return false;
+  }
+
   bool _complete_ifOrWhileStatement(
       _KeywordConditionBlockStructure statement, StatementCompletionKind kind) {
+    if (_statementHasValidBody(statement.keyword, statement.block)) {
+      return false;
+    }
     SourceBuilder sb = _complete_keywordCondition(statement);
     if (sb == null) {
       return false;
     }
-    if (statement.block is EmptyStatement) {
-      sb.append(' ');
-      _appendEmptyBraces(sb, exitPosition == null);
-    }
+    sb.append(' ');
+    _appendEmptyBraces(sb, exitPosition == null);
     _insertBuilder(sb);
     _setCompletion(kind);
     return true;
   }
 
   bool _complete_ifStatement() {
     if (node is! IfStatement) {
       return false;
     }
     IfStatement ifNode = node;
-    if (ifNode != null) {
-      if (ifNode.elseKeyword != null) {
-        return false;
-      }
-      var stmt = new _KeywordConditionBlockStructure(
-          ifNode.ifKeyword,
-          ifNode.leftParenthesis,
-          ifNode.condition,
-          ifNode.rightParenthesis,
-          ifNode.thenStatement);
-      return _complete_ifOrWhileStatement(
-          stmt, DartStatementCompletion.COMPLETE_IF_STMT);
+    if (ifNode.elseKeyword != null) {
+      return false;
     }
-    return false;
+    var stmt = new _KeywordConditionBlockStructure(
+        ifNode.ifKeyword,
+        ifNode.leftParenthesis,
+        ifNode.condition,
+        ifNode.rightParenthesis,
+        ifNode.thenStatement);
+    return _complete_ifOrWhileStatement(
+        stmt, DartStatementCompletion.COMPLETE_IF_STMT);
   }
 
   SourceBuilder _complete_keywordCondition(
       _KeywordConditionBlockStructure statement) {
     SourceBuilder sb;
     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 (_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_methodCall() {
+    var parenError =
+        _findError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "')'");
+    if (parenError == null) {
+      return false;
+    }
+    AstNode argList = _selectedNode(at: parenError.offset - 1)
+        .getAncestor((n) => n is ArgumentList);
+    if (argList?.getAncestor((n) => n == node) == null) {
+      return false;
+    }
+    int loc = argList.end - 1;
+    int delta = 1;
+    var semicolonError =
+        _findError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "';'");
+    if (semicolonError == null) {
+      loc += 1;
+      delta = 0;
+    }
+    _addInsertEdit(loc, ')');
+    if (semicolonError != null) {
+      _addInsertEdit(loc, ';');
+    }
+    String indent = utils.getLinePrefix(selectionOffset);
+    int exit = utils.getLineNext(selectionOffset);
+    _addInsertEdit(exit, indent + eol);
+    exit += indent.length + eol.length;
+
+    _setCompletionAt(DartStatementCompletion.SIMPLE_ENTER, exit + delta);
+    return true;
+  }
+
   bool _complete_simpleEnter() {
     int offset;
     if (!errors.isEmpty) {
       offset = selectionOffset;
     } else {
       String indent = utils.getLinePrefix(selectionOffset);
       int loc = utils.getLineNext(selectionOffset);
       _addInsertEdit(loc, indent + eol);
       offset = loc + indent.length + eol.length;
     }
@@ skipping 149 matching lines @@
         sb = new SourceBuilder(file, tryNode.finallyKeyword.end);
         sb.append(' ');
         _appendEmptyBraces(sb, true);
         _insertBuilder(sb);
       }
     }
     _setCompletion(DartStatementCompletion.COMPLETE_TRY_STMT);
     return true;
   }
 
+  bool _complete_variableDeclaration() {
+    if (node is! VariableDeclaration) {
+      return false;
+    }
+    _addInsertEdit(node.end, ';');
+    exitPosition = new Position(file, _appendNewlinePlusIndentAt(node.end) + 1);
+    _setCompletion(DartStatementCompletion.COMPLETE_VARIABLE_DECLARATION);
+    return true;
+  }
+
   bool _complete_whileStatement() {
     if (node is! WhileStatement) {
       return false;
     }
     WhileStatement whileNode = node;
     if (whileNode != null) {
       var stmt = new _KeywordConditionBlockStructure(
           whileNode.whileKeyword,
           whileNode.leftParenthesis,
           whileNode.condition,
           whileNode.rightParenthesis,
           whileNode.body);
       return _complete_ifOrWhileStatement(
           stmt, DartStatementCompletion.COMPLETE_WHILE_STMT);
     }
     return false;
   }
 
   engine.AnalysisError _findError(ErrorCode code, {partialMatch: null}) {
-    var error =
-        errors.firstWhere((err) => err.errorCode == code, orElse: () => null);
-    if (error != null) {
-      if (partialMatch != null) {
-        return error.message.contains(partialMatch) ? error : null;
-      }
-      return error;
-    }
-    return null;
+    return errors.firstWhere(
+        (err) =>
+            err.errorCode == code &&
+            (partialMatch == null ? true : err.message.contains(partialMatch)),
+        orElse: () => null);
   }
 
   T _findInvalidElement<T extends AstNode>(NodeList<T> list) {
     return list.firstWhere(
-        (catchClause) =>
-            selectionOffset >= catchClause.offset &&
-            selectionOffset <= catchClause.end,
+        (item) => selectionOffset >= item.offset && selectionOffset <= item.end,
         orElse: () => null);
   }
 
   LinkedEditGroup _getLinkedPosition(String groupId) {
     LinkedEditGroup group = linkedPositionGroups[groupId];
     if (group == null) {
       group = new LinkedEditGroup.empty();
       linkedPositionGroups[groupId] = group;
     }
     return group;
@@ skipping 25 matching lines @@
   }
 
   bool _isEmptyBlock(AstNode stmt) {
     return stmt is Block && stmt.statements.isEmpty;
   }
 
   bool _isEmptyStatement(AstNode stmt) {
     return stmt is EmptyStatement || _isEmptyBlock(stmt);
   }
 
+  bool _isNonStatementDeclaration(AstNode n) {
+    if (n is! Declaration) {
+      return false;
+    }
+    if (n is! VariableDeclaration && n is! FunctionDeclaration) {
+      return true;
+    }
+    AstNode p = n.parent;
+    return p is! Statement && p?.parent is! Statement;
+  }
+
   bool _isSyntheticExpression(Expression expr) {
     return expr is SimpleIdentifier && expr.isSynthetic;
   }
 
   Position _newPosition(int offset) {
     return new Position(file, offset);
   }
 
+  AstNode _selectedNode({int at: null}) =>
+      new NodeLocator(at == null ? selectionOffset : at).searchWithin(unit);
+
   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));
     completion = new StatementCompletion(kind, change);
   }
 
   void _setCompletionAt(StatementCompletionKind kind, int offset, [List args]) {
     exitPosition = _newPosition(offset);
     _setCompletion(kind, args);
   }
 
   SourceBuilder _sourceBuilderAfterKeyword(Token keyword) {
     SourceBuilder sb;
     String text = _baseNodeText(node);
     text = text.substring(keyword.offset - node.offset);
     int len = keyword.length;
     if (text.length == len ||
         !text.substring(len, len + 1).contains(new RegExp(r'\s'))) {
       sb = new SourceBuilder(file, keyword.offset + len);
       sb.append(' ');
     } else {
       sb = new SourceBuilder(file, keyword.offset + len + 1);
     }
     return sb;
   }
+
+  bool _statementHasValidBody(Token keyword, Statement body) {
+    // A "valid" body is either a non-synthetic block or a single statement
+    // on the same line as the parent statement, similar to dart_style.
+    if (body.isSynthetic) {
+      return false;
+    }
+    if (body is Block) {
+      Block block = body;
+      return (!(block.leftBracket.isSynthetic));
+    }
+    return (lineInfo.getLocation(keyword.offset) ==
+        lineInfo.getLocation(body.offset));
+  }
 }
 
 // Encapsulate common structure of if-statement and while-statement.
 class _KeywordConditionBlockStructure {
   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;
 }