Fix hints

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import "dart:math" as math;
@@ skipping 2201 matching lines @@
     _inInitializer = false;
     try {
       Expression argument = parseArgument();
       arguments.add(argument);
       bool foundNamedArgument = argument is NamedExpression;
       bool generatedError = false;
       while (_optional(TokenType.COMMA)) {
         argument = parseArgument();
         arguments.add(argument);
         if (foundNamedArgument) {
-          bool blankArgument = argument is SimpleIdentifier &&
-              (argument as SimpleIdentifier).name.isEmpty;
+          bool blankArgument =
+              argument is SimpleIdentifier && argument.name.isEmpty;
           if (!generatedError &&
               !(argument is NamedExpression && !blankArgument)) {
             // Report the error, once, but allow the arguments to be in any
             // order in the AST.
             _reportErrorForCurrentToken(
                 ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT);
             generatedError = true;
           }
         } else if (argument is NamedExpression) {
           foundNamedArgument = true;
@@ skipping 444 matching lines @@
             partOfDirectiveFound = true;
           }
         } else {
           if (partOfDirectiveFound) {
             _reportErrorForToken(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART,
                 directive.keyword);
           }
         }
         directives.add(directive);
       } else if (_matches(TokenType.SEMICOLON)) {
-        _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken, [
-          _currentToken.lexeme
-        ]);
+        _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken,
+            [_currentToken.lexeme]);
         _advance();
       } else {
         CompilationUnitMember member =
             _parseCompilationUnitMember(commentAndMetadata);
         if (member != null) {
           declarations.add(member);
         }
       }
       if (identical(_currentToken, memberStart)) {
-        _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken, [
-          _currentToken.lexeme
-        ]);
+        _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken,
+            [_currentToken.lexeme]);
         _advance();
         while (!_matches(TokenType.EOF) &&
             !_couldBeStartOfCompilationUnitMember()) {
           _advance();
         }
       }
       memberStart = _currentToken;
     }
     return new CompilationUnit(
         firstToken, scriptTag, directives, declarations, _currentToken);
@@ skipping 262 matching lines @@
         rightSquareBracket = getAndAdvance();
         currentParameters = normalParameters;
         if (leftSquareBracket == null) {
           if (leftCurlyBracket != null) {
             _reportErrorForCurrentToken(
                 ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP, ["}"]);
             rightCurlyBracket = rightSquareBracket;
             rightSquareBracket = null;
           } else {
             _reportErrorForCurrentToken(
-                ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP, [
-              "["
-            ]);
+                ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP,
+                ["["]);
           }
         }
         kind = ParameterKind.REQUIRED;
       } else if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
         rightCurlyBracket = getAndAdvance();
         currentParameters = normalParameters;
         if (leftCurlyBracket == null) {
           if (leftSquareBracket != null) {
             _reportErrorForCurrentToken(
                 ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP, ["]"]);
             rightSquareBracket = rightCurlyBracket;
             rightCurlyBracket = null;
           } else {
             _reportErrorForCurrentToken(
-                ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP, [
-              "{"
-            ]);
+                ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP,
+                ["{"]);
           }
         }
         kind = ParameterKind.REQUIRED;
       }
     } while (!_matches(TokenType.CLOSE_PAREN) &&
         !identical(initialToken, _currentToken));
     Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
     //
     // Check that the groups were closed correctly.
     //
@@ skipping 1346 matching lines @@
       try {
         Expression index = parseExpression2();
         Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
         expression = new IndexExpression.forCascade(
             period, leftBracket, index, rightBracket);
         period = null;
       } finally {
         _inInitializer = wasInInitializer;
       }
     } else {
-      _reportErrorForToken(ParserErrorCode.MISSING_IDENTIFIER, _currentToken, [
-        _currentToken.lexeme
-      ]);
+      _reportErrorForToken(ParserErrorCode.MISSING_IDENTIFIER, _currentToken,
+          [_currentToken.lexeme]);
       functionName = _createSyntheticIdentifier();
     }
     assert((expression == null && functionName != null) ||
         (expression != null && functionName == null));
     if (_currentToken.type == TokenType.OPEN_PAREN) {
       while (_currentToken.type == TokenType.OPEN_PAREN) {
         if (functionName != null) {
           expression = new MethodInvocation(
               expression, period, functionName, parseArgumentList());
           period = null;
@@ skipping 171 matching lines @@
    */
   List<ClassMember> _parseClassMembers(String className, Token closingBracket) {
     List<ClassMember> members = new List<ClassMember>();
     Token memberStart = _currentToken;
     while (!_matches(TokenType.EOF) &&
         !_matches(TokenType.CLOSE_CURLY_BRACKET) &&
         (closingBracket != null ||
             (!_matchesKeyword(Keyword.CLASS) &&
                 !_matchesKeyword(Keyword.TYPEDEF)))) {
       if (_matches(TokenType.SEMICOLON)) {
-        _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken, [
-          _currentToken.lexeme
-        ]);
+        _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken,
+            [_currentToken.lexeme]);
         _advance();
       } else {
         ClassMember member = parseClassMember(className);
         if (member != null) {
           members.add(member);
         }
       }
       if (identical(_currentToken, memberStart)) {
-        _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken, [
-          _currentToken.lexeme
-        ]);
+        _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken,
+            [_currentToken.lexeme]);
         _advance();
       }
       memberStart = _currentToken;
     }
     return members;
   }
 
   /**
    * Parse a class type alias. The [commentAndMetadata] is the metadata to be
    * associated with the member. The [abstractKeyword] is the token representing
@@ skipping 955 matching lines @@
           DeclaredIdentifier loopVariable = null;
           SimpleIdentifier identifier = null;
           if (variableList == null) {
             // We found: <expression> 'in'
             _reportErrorForCurrentToken(
                 ParserErrorCode.MISSING_VARIABLE_IN_FOR_EACH);
           } else {
             NodeList<VariableDeclaration> variables = variableList.variables;
             if (variables.length > 1) {
               _reportErrorForCurrentToken(
-                  ParserErrorCode.MULTIPLE_VARIABLES_IN_FOR_EACH, [
-                variables.length.toString()
-              ]);
+                  ParserErrorCode.MULTIPLE_VARIABLES_IN_FOR_EACH,
+                  [variables.length.toString()]);
             }
             VariableDeclaration variable = variables[0];
             if (variable.initializer != null) {
               _reportErrorForCurrentToken(
                   ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH);
             }
             Token keyword = variableList.keyword;
             TypeName type = variableList.type;
             if (keyword != null || type != null) {
               loopVariable = new DeclaredIdentifier(commentAndMetadata.comment,
@@ skipping 1025 matching lines @@
     if (!_currentToken.isUserDefinableOperator) {
       _reportErrorForCurrentToken(
           ParserErrorCode.NON_USER_DEFINABLE_OPERATOR, [_currentToken.lexeme]);
     }
     SimpleIdentifier name = new SimpleIdentifier(getAndAdvance());
     if (_matches(TokenType.EQ)) {
       Token previous = _currentToken.previous;
       if ((_tokenMatches(previous, TokenType.EQ_EQ) ||
               _tokenMatches(previous, TokenType.BANG_EQ)) &&
           _currentToken.offset == previous.offset + 2) {
-        _reportErrorForCurrentToken(ParserErrorCode.INVALID_OPERATOR, [
-          "${previous.lexeme}${_currentToken.lexeme}"
-        ]);
+        _reportErrorForCurrentToken(ParserErrorCode.INVALID_OPERATOR,
+            ["${previous.lexeme}${_currentToken.lexeme}"]);
         _advance();
       }
     }
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body =
         _parseFunctionBody(true, ParserErrorCode.MISSING_FUNCTION_BODY, false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_OPERATOR_WITH_BODY);
     }
@@ skipping 367 matching lines @@
    *         statement*
    */
   List<Statement> _parseStatementList() {
     List<Statement> statements = new List<Statement>();
     Token statementStart = _currentToken;
     while (!_matches(TokenType.EOF) &&
         !_matches(TokenType.CLOSE_CURLY_BRACKET) &&
         !_isSwitchMember()) {
       statements.add(parseStatement2());
       if (identical(_currentToken, statementStart)) {
-        _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken, [
-          _currentToken.lexeme
-        ]);
+        _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken,
+            [_currentToken.lexeme]);
         _advance();
       }
       statementStart = _currentToken;
     }
     return statements;
   }
 
   /**
    * Parse a string literal that contains interpolations. Return the string
    * literal that was parsed.
@@ skipping 1216 matching lines @@
         int secondDigit = lexeme.codeUnitAt(currentIndex + 1);
         int thirdDigit = lexeme.codeUnitAt(currentIndex + 2);
         int fourthDigit = lexeme.codeUnitAt(currentIndex + 3);
         if (!_isHexDigit(firstDigit) ||
             !_isHexDigit(secondDigit) ||
             !_isHexDigit(thirdDigit) ||
             !_isHexDigit(fourthDigit)) {
           // Illegal escape sequence: invalid hex digits
           _reportErrorForCurrentToken(ParserErrorCode.INVALID_UNICODE_ESCAPE);
         } else {
-          _appendScalarValue(buffer, lexeme.substring(index, currentIndex + 1),
+          _appendScalarValue(
+              buffer,
+              lexeme
+                  .substring(
+                      index,
+                      currentIndex + 1),
               (((((Character.digit(firstDigit, 16) << 4) +
                                   Character.digit(secondDigit, 16)) <<
                               4) +
                           Character.digit(thirdDigit, 16)) <<
                       4) +
-                  Character.digit(fourthDigit, 16), index, currentIndex + 3);
+                  Character
+                      .digit(fourthDigit, 16),
+              index,
+              currentIndex +
+                  3);
         }
         return currentIndex + 4;
       }
     } else {
       buffer.writeCharCode(currentChar);
     }
     return currentIndex + 1;
   }
 
   /**
@@ skipping 2284 matching lines @@
   }
 
   /**
    * Copy resolution data from the [fromNode] to the [toNode].
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }