Remove unnecessary casts and general code clean-up

pkg/analyzer/lib/src/dart/ast/utilities.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.dart.ast.utilities;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 915 matching lines @@
    * into [_clonedTokens].
    *
    * We cannot clone tokens as we visit nodes because not every token is a part
    * of a node, E.g. commas in argument lists are not represented in AST. But
    * we need to the sequence of tokens that is identical to the original one.
    */
   void _cloneTokens(Token token, int stopAfter) {
     if (token == null) {
       return;
     }
-    if (token is CommentToken) {
-      token = (token as CommentToken).parent;
+    Token nonComment(Token token) {
+      return token is CommentToken ? token.parent : token;
     }
+    token = nonComment(token);
     if (_lastCloned == null) {
       _lastCloned = new Token(TokenType.EOF, -1);
       _lastCloned.setNext(_lastCloned);
     }
     while (token != null) {
       Token clone = token.copy();
       {
         CommentToken c1 = token.precedingComments;
         CommentToken c2 = clone.precedingComments;
         while (c1 != null && c2 != null) {
@@ skipping 1312 matching lines @@
       } else if (node.operator.type == TokenType.SLASH) {
         // numeric or {@code null}
         if (leftOperand is num && rightOperand is num) {
           return leftOperand / rightOperand;
         }
       } else if (node.operator.type == TokenType.TILDE_SLASH) {
         // numeric or {@code null}
         if (leftOperand is num && rightOperand is num) {
           return leftOperand ~/ rightOperand;
         }
-      } else {}
+      }
       break;
     }
     // TODO(brianwilkerson) This doesn't handle numeric conversions.
     return visitExpression(node);
   }
 
   @override
   Object visitBooleanLiteral(BooleanLiteral node) => node.value ? true : false;
 
   @override
@@ skipping 122 matching lines @@
     }
     return buffer.toString();
   }
 
   /**
    * Return the constant value of the static constant represented by the given
    * [element].
    */
   Object _getConstantValue(Element element) {
     // TODO(brianwilkerson) Implement this
-    if (element is FieldElement) {
-      FieldElement field = element;
-      if (field.isStatic && field.isConst) {
-        //field.getConstantValue();
-      }
-      //    } else if (element instanceof VariableElement) {
-      //      VariableElement variable = (VariableElement) element;
-      //      if (variable.isStatic() && variable.isConst()) {
-      //        //variable.getConstantValue();
-      //      }
-    }
+//    if (element is FieldElement) {
+//      FieldElement field = element;
+//      if (field.isStatic && field.isConst) {
+//        //field.getConstantValue();
+//      }
+//      //    } else if (element instanceof VariableElement) {
+//      //      VariableElement variable = (VariableElement) element;
+//      //      if (variable.isStatic() && variable.isConst()) {
+//      //        //variable.getConstantValue();
+//      //      }
+//    }
     return NOT_A_CONSTANT;
   }
 }
 
 /**
  * A recursive AST visitor that is used to run over [Expression]s to determine
  * whether the expression is composed by at least one deferred
  * [PrefixedIdentifier].
  *
  * See [PrefixedIdentifier.isDeferred].
@@ skipping 62 matching lines @@
   @override
   Element visitConstructorDeclaration(ConstructorDeclaration node) =>
       node.element;
 
   @override
   Element visitFunctionDeclaration(FunctionDeclaration node) => node.element;
 
   @override
   Element visitIdentifier(Identifier node) {
     AstNode parent = node.parent;
-    // Type name in Annotation
     if (parent is Annotation) {
-      Annotation annotation = parent;
-      if (identical(annotation.name, node) &&
-          annotation.constructorName == null) {
-        return annotation.element;
+      // Type name in Annotation
+      if (identical(parent.name, node) && parent.constructorName == null) {
+        return parent.element;
       }
-    }
-    // Extra work to map Constructor Declarations to their associated
-    // Constructor Elements
-    if (parent is ConstructorDeclaration) {
+    } else if (parent is ConstructorDeclaration) {
+      // Extra work to map Constructor Declarations to their associated
+      // Constructor Elements
       Identifier returnType = parent.returnType;
       if (identical(returnType, node)) {
         SimpleIdentifier name = parent.name;
         if (name != null) {
           return name.bestElement;
         }
         Element element = node.bestElement;
         if (element is ClassElement) {
           return element.unnamedConstructor;
         }
       }
-    }
-    if (parent is LibraryIdentifier) {
+    } else if (parent is LibraryIdentifier) {
       AstNode grandParent = parent.parent;
       if (grandParent is PartOfDirective) {
         Element element = grandParent.element;
         if (element is LibraryElement) {
           return element.definingCompilationUnit;
         }
       }
     }
     return node.bestElement;
   }
@@ skipping 5244 matching lines @@
    * Safely visit the given [token], printing the [suffix] after the token if it
    * is non-`null`.
    */
   void _visitTokenWithSuffix(Token token, String suffix) {
     if (token != null) {
       _writer.print(token.lexeme);
       _writer.print(suffix);
     }
   }
 }