update statement completion for fasta scanner

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.
 
 import 'dart:async';
 import 'dart:math';
 
 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/util.dart';
@@ skipping 311 matching lines @@
         loc = newlineLoc + expr.offset;
       } else {
         // add first char of src
         delimiter = content.substring(0, 1);
         loc = expr.offset + source.length;
       }
       _removeError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL);
       _addInsertEdit(loc, delimiter);
     }
     expr = errorMatching(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "']'");
+    if (expr == null) {

[Brian Wilkerson, 2017/06/14 04:14:31]

You could also use `??` to avoid the extra weight of an `if` statement.

[danrubel, 2017/06/14 06:05:41]

Good point. Done.

+      expr =
+          errorMatching(ScannerErrorCode.EXPECTED_TOKEN, partialMatch: "']'");
+    }
     if (expr != null) {
       expr = expr.getAncestor((n) => n is ListLiteral);
       if (expr != null) {
         ListLiteral lit = expr;
         if (lit.rightBracket.isSynthetic) {
           String src = utils.getNodeText(expr).trim();
           int loc = expr.offset + src.length;
           if (src.contains(eol)) {
             String indent = utils.getNodePrefix(node);
             _addInsertEdit(loc, ',' + eol + indent + ']');
           } else {
             _addInsertEdit(loc, ']');
           }
           _removeError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "']'");
+          _removeError(ScannerErrorCode.EXPECTED_TOKEN, partialMatch: "']'");
           var ms =
               _findError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "';'");
           if (ms != null) {
             // Ensure the semicolon gets inserted in the correct location.
             ms.offset = loc - 1;
           }
         }
       }
     }
     // The following code is similar to the code for ']' but does not work well.
@@ skipping 62 matching lines @@
         outer is WhileStatement)) {
       return false;
     }
     int previousInsertions = _lengthOfInsertions();
     int delta = 0;
     if (errors.isNotEmpty) {
       var error =
           _findError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "';'");
       if (error != null) {
         int insertOffset;
-        if (expr == null || expr.isSynthetic) {
+        // Fasta scanner reports unterminated string literal errors
+        // and generates a synthetic string token with non-zero length.
+        // Because of this, check for length == 0 rather than isSynthetic.

[Brian Wilkerson, 2017/06/14 04:14:31]

If `isSynthetic` doesn't always return a valid result, then can we either (a)
fix it so that it does (my preference), or (b) remove / deprecate it so that
people won't use it incorrectly?

+        if (expr == null || expr.length == 0) {
           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.
           }
@@ skipping 384 matching lines @@
         }
       }
     }
     return sb;
   }
 
   bool _complete_methodCall() {
     var parenError =
         _findError(ParserErrorCode.EXPECTED_TOKEN, partialMatch: "')'");
     if (parenError == null) {
+      parenError =
+          _findError(ScannerErrorCode.EXPECTED_TOKEN, partialMatch: "')'");
+    }
+    if (parenError == null) {
       return false;
     }
     AstNode argList = _selectedNode(at: selectionOffset)
         .getAncestor((n) => n is ArgumentList);
     if (argList == null) {
       argList = _selectedNode(at: parenError.offset)
           .getAncestor((n) => n is ArgumentList);
     }
     if (argList?.getAncestor((n) => n == node) == null) {
       return false;
@@ skipping 390 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;
 }