Remove unnecessary casts and general code clean-up

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.
 
 library analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 4447 matching lines @@
     // A primary expression can start with an identifier. We resolve the
     // ambiguity by determining whether the primary consists of anything other
     // than an identifier and/or is followed by an assignableSelector.
     //
     Expression expression = _parsePrimaryExpression();
     bool isOptional = primaryAllowed || expression is SimpleIdentifier;
     while (true) {
       while (_isLikelyArgumentList()) {
         TypeArgumentList typeArguments = _parseOptionalTypeArguments();
         ArgumentList argumentList = parseArgumentList();
-        if (expression is SimpleIdentifier) {
-          expression = new MethodInvocation(null, null,
-              expression as SimpleIdentifier, typeArguments, argumentList);
-        } else if (expression is PrefixedIdentifier) {
-          PrefixedIdentifier identifier = expression as PrefixedIdentifier;
+        Expression currentExpression = expression;
+        if (currentExpression is SimpleIdentifier) {
           expression = new MethodInvocation(
-              identifier.prefix,
-              identifier.period,
-              identifier.identifier,
+              null, null, currentExpression, typeArguments, argumentList);
+        } else if (currentExpression is PrefixedIdentifier) {
+          expression = new MethodInvocation(
+              currentExpression.prefix,
+              currentExpression.period,
+              currentExpression.identifier,
               typeArguments,
               argumentList);
-        } else if (expression is PropertyAccess) {
-          PropertyAccess access = expression as PropertyAccess;
-          expression = new MethodInvocation(access.target, access.operator,
-              access.propertyName, typeArguments, argumentList);
+        } else if (currentExpression is PropertyAccess) {
+          expression = new MethodInvocation(
+              currentExpression.target,
+              currentExpression.operator,
+              currentExpression.propertyName,
+              typeArguments,
+              argumentList);
         } else {
           expression = new FunctionExpressionInvocation(
               expression, typeArguments, argumentList);
         }
         if (!primaryAllowed) {
           isOptional = false;
         }
       }
       Expression selectorExpression = _parseAssignableSelector(
           expression, isOptional || (expression is PrefixedIdentifier));
@@ skipping 201 matching lines @@
     assert(expression != null);
     bool progress = true;
     while (progress) {
       progress = false;
       Expression selector = _parseAssignableSelector(expression, true);
       if (!identical(selector, expression)) {
         expression = selector;
         progress = true;
         while (_isLikelyArgumentList()) {
           TypeArgumentList typeArguments = _parseOptionalTypeArguments();
-          if (expression is PropertyAccess) {
-            PropertyAccess propertyAccess = expression as PropertyAccess;
+          Expression currentExpression = expression;
+          ;

[scheglov, 2016/04/25 19:14:44]

Remove this?

[Brian Wilkerson, 2016/04/25 19:24:20]

Done

+          if (currentExpression is PropertyAccess) {
             expression = new MethodInvocation(
-                propertyAccess.target,
-                propertyAccess.operator,
-                propertyAccess.propertyName,
+                currentExpression.target,
+                currentExpression.operator,
+                currentExpression.propertyName,
                 typeArguments,
                 parseArgumentList());
           } else {
             expression = new FunctionExpressionInvocation(
                 expression, typeArguments, parseArgumentList());
           }
         }
       }
     }
     if (_currentToken.type.isAssignmentOperator) {
@@ skipping 2603 matching lines @@
     Expression operand = _parseAssignableExpression(true);
     if (_matches(TokenType.OPEN_SQUARE_BRACKET) ||
         _matches(TokenType.PERIOD) ||
         _matches(TokenType.QUESTION_PERIOD) ||
         _matches(TokenType.OPEN_PAREN) ||
         (parseGenericMethods && _matches(TokenType.LT))) {
       do {
         if (_isLikelyArgumentList()) {
           TypeArgumentList typeArguments = _parseOptionalTypeArguments();
           ArgumentList argumentList = parseArgumentList();
-          if (operand is PropertyAccess) {
-            PropertyAccess access = operand as PropertyAccess;
-            operand = new MethodInvocation(access.target, access.operator,
-                access.propertyName, typeArguments, argumentList);
+          Expression currentOperand = operand;
+          if (currentOperand is PropertyAccess) {
+            operand = new MethodInvocation(
+                currentOperand.target,
+                currentOperand.operator,
+                currentOperand.propertyName,
+                typeArguments,
+                argumentList);
           } else {
             operand = new FunctionExpressionInvocation(
                 operand, typeArguments, argumentList);
           }
         } else {
           operand = _parseAssignableSelector(operand, true);
         }
       } while (_matches(TokenType.OPEN_SQUARE_BRACKET) ||
           _matches(TokenType.PERIOD) ||
           _matches(TokenType.QUESTION_PERIOD) ||
@@ skipping 2618 matching lines @@
    */
   const ParserErrorCode(String name, String message, [String correction])
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
 
   @override
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }