Fix hints

pkg/analyzer/lib/src/generated/error_verifier.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 engine.resolver.error_verifier;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
@@ skipping 1943 matching lines @@
       PropertyAccess propertyAccess = expression;
       element = propertyAccess.propertyName.staticElement;
       highlightedNode = propertyAccess.propertyName;
     }
     // check if element is assignable
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement accessor = element as PropertyAccessorElement;
       element = accessor.variable;
     }
     if (element is VariableElement) {
-      VariableElement variable = element as VariableElement;
-      if (variable.isConst) {
+      if (element.isConst) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.ASSIGNMENT_TO_CONST, expression);
         return true;
       }
-      if (variable.isFinal) {
-        if (variable is FieldElementImpl &&
-            variable.setter == null &&
-            variable.isSynthetic) {
+      if (element.isFinal) {
+        if (element is FieldElementImpl &&
+            element.setter == null &&
+            element.isSynthetic) {
           _errorReporter.reportErrorForNode(
               StaticWarningCode.ASSIGNMENT_TO_FINAL_NO_SETTER, highlightedNode,
-              [variable.name, variable.enclosingElement.displayName]);
+              [element.name, element.enclosingElement.displayName]);
           return true;
         }
         _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_FINAL,
-            highlightedNode, [variable.name]);
+            highlightedNode, [element.name]);
         return true;
       }
       return false;
     }
     if (element is FunctionElement) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.ASSIGNMENT_TO_FUNCTION, expression);
       return true;
     }
     if (element is MethodElement) {
@@ skipping 3949 matching lines @@
   /**
    * @param node the 'this' expression to analyze
    * @return `true` if the given 'this' expression is in the valid context
    */
   bool _isThisInValidContext(ThisExpression node) {
     for (AstNode n = node; n != null; n = n.parent) {
       if (n is CompilationUnit) {
         return false;
       }
       if (n is ConstructorDeclaration) {
-        ConstructorDeclaration constructor = n as ConstructorDeclaration;
-        return constructor.factoryKeyword == null;
+        return n.factoryKeyword == null;
       }
       if (n is ConstructorInitializer) {
         return false;
       }
       if (n is MethodDeclaration) {
-        MethodDeclaration method = n as MethodDeclaration;
-        return !method.isStatic;
+        return !n.isStatic;
       }
     }
     return false;
   }
 
   /**
    * Return `true` if the given identifier is in a location where it is allowed to resolve to
    * a static member of a supertype.
    *
    * @param node the node being tested
@@ skipping 175 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }