Fix hints

pkg/analyzer/lib/src/generated/resolver.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;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 222 matching lines @@
     }
     String rhsNameStr = typeName.name.name;
     // if x is dynamic
     if (rhsType.isDynamic && rhsNameStr == sc.Keyword.DYNAMIC.syntax) {
       if (node.notOperator == null) {
         // the is case
         _errorReporter.reportErrorForNode(
             HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
       } else {
         // the is not case
-        _errorReporter
-            .reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
+        _errorReporter.reportErrorForNode(
+            HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
       }
       return true;
     }
     Element rhsElement = rhsType.element;
     LibraryElement libraryElement =
         rhsElement != null ? rhsElement.library : null;
     if (libraryElement != null && libraryElement.isDartCore) {
       // if x is Object or null is Null
       if (rhsType.isObject ||
           (expression is NullLiteral && rhsNameStr == _NULL_TYPE_NAME)) {
         if (node.notOperator == null) {
           // the is case
           _errorReporter.reportErrorForNode(
               HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
         } else {
           // the is not case
-          _errorReporter
-              .reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
+          _errorReporter.reportErrorForNode(
+              HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
         }
         return true;
       } else if (rhsNameStr == _NULL_TYPE_NAME) {
         if (node.notOperator == null) {
           // the is case
           _errorReporter.reportErrorForNode(HintCode.TYPE_CHECK_IS_NULL, node);
         } else {
           // the is not case
-          _errorReporter
-              .reportErrorForNode(HintCode.TYPE_CHECK_IS_NOT_NULL, node);
+          _errorReporter.reportErrorForNode(
+              HintCode.TYPE_CHECK_IS_NOT_NULL, node);
         }
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
@@ skipping 252 matching lines @@
    * See [CompileTimeErrorCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION].
    */
   bool _checkForLoadLibraryFunction(
       ImportDirective node, ImportElement importElement) {
     LibraryElement importedLibrary = importElement.importedLibrary;
     if (importedLibrary == null) {
       return false;
     }
     if (importedLibrary.hasLoadLibraryFunction) {
       _errorReporter.reportErrorForNode(
-          HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION, node, [
-        importedLibrary.name
-      ]);
+          HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION, node,
+          [importedLibrary.name]);
       return true;
     }
     return false;
   }
 
   /**
    * Generate a hint for functions or methods that have a return type, but do not have a return
    * statement on all branches. At the end of blocks with no return, Dart implicitly returns
    * `null`, avoiding these implicit returns is considered a best practice.
    *
@@ skipping 179 matching lines @@
     }
     _defineMembers(typeElement);
   }
 
   @override
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PropertyAccessorElement && duplicate is MethodElement) {
       if (existing.nameOffset < duplicate.nameOffset) {
         return new AnalysisError.con2(duplicate.source, duplicate.nameOffset,
             duplicate.displayName.length,
-            CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME, [
-          existing.displayName
-        ]);
+            CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME,
+            [existing.displayName]);
       } else {
         return new AnalysisError.con2(existing.source, existing.nameOffset,
             existing.displayName.length,
-            CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME, [
-          existing.displayName
-        ]);
+            CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME,
+            [existing.displayName]);
       }
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
 
   /**
    * Define the instance members defined by the class.
    *
    * @param typeElement the element representing the type represented by this scope
    */
@@ skipping 752 matching lines @@
           _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.value.isTrue) {
           // report error on else block: true ? 1 : !2!
           _errorReporter.reportErrorForNode(
               HintCode.DEAD_CODE, node.elseExpression);
           _safelyVisit(node.thenExpression);
           return null;
         } else {
           // report error on if block: false ? !1! : 2
-          _errorReporter
-              .reportErrorForNode(HintCode.DEAD_CODE, node.thenExpression);
+          _errorReporter.reportErrorForNode(
+              HintCode.DEAD_CODE, node.thenExpression);
           _safelyVisit(node.elseExpression);
           return null;
         }
       }
     }
     return super.visitConditionalExpression(node);
   }
 
   @override
   Object visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
     _safelyVisit(conditionExpression);
     if (!_isDebugConstant(conditionExpression)) {
       EvaluationResultImpl result =
           _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.value.isTrue) {
           // report error on else block: if(true) {} else {!}
           Statement elseStatement = node.elseStatement;
           if (elseStatement != null) {
             _errorReporter.reportErrorForNode(
                 HintCode.DEAD_CODE, elseStatement);
             _safelyVisit(node.thenStatement);
             return null;
           }
         } else {
           // report error on if block: if (false) {!} else {}
-          _errorReporter
-              .reportErrorForNode(HintCode.DEAD_CODE, node.thenStatement);
+          _errorReporter.reportErrorForNode(
+              HintCode.DEAD_CODE, node.thenStatement);
           _safelyVisit(node.elseStatement);
           return null;
         }
       }
     }
     return super.visitIfStatement(node);
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
@@ skipping 165 matching lines @@
   bool _isDebugConstant(Expression expression) {
     Element element = null;
     if (expression is Identifier) {
       Identifier identifier = expression;
       element = identifier.staticElement;
     } else if (expression is PropertyAccess) {
       PropertyAccess propertyAccess = expression;
       element = propertyAccess.propertyName.staticElement;
     }
     if (element is PropertyAccessorElement) {
-      PropertyAccessorElement pae = element as PropertyAccessorElement;
-      PropertyInducingElement variable = pae.variable;
+      PropertyInducingElement variable = element.variable;
       return variable != null && variable.isConst;
     }
     return false;
   }
 
   /**
    * If the given node is not `null`, visit this instance of the dead code verifier.
    *
    * @param node the node to be visited
    */
@@ skipping 1351 matching lines @@
       FunctionElementImpl initializer =
           new FunctionElementImpl.forOffset(node.initializer.beginToken.offset);
       initializer.functions = holder.functions;
       initializer.labels = holder.labels;
       initializer.localVariables = holder.localVariables;
       initializer.synthetic = true;
       element.initializer = initializer;
       holder.validate();
     }
     if (element is PropertyInducingElementImpl) {
-      PropertyInducingElementImpl variable =
-          element as PropertyInducingElementImpl;
       if (_inFieldContext) {
-        (variable as FieldElementImpl).static =
+        (element as FieldElementImpl).static =
             (node.parent.parent as FieldDeclaration).isStatic;
       }
       PropertyAccessorElementImpl getter =
-          new PropertyAccessorElementImpl.forVariable(variable);
+          new PropertyAccessorElementImpl.forVariable(element);
       getter.getter = true;
       _currentHolder.addAccessor(getter);
-      variable.getter = getter;
+      element.getter = getter;
       if (!isConst && !isFinal) {
         PropertyAccessorElementImpl setter =
-            new PropertyAccessorElementImpl.forVariable(variable);
+            new PropertyAccessorElementImpl.forVariable(element);
         setter.setter = true;
         ParameterElementImpl parameter =
-            new ParameterElementImpl("_${variable.name}", variable.nameOffset);
+            new ParameterElementImpl("_${element.name}", element.nameOffset);
         parameter.synthetic = true;
         parameter.parameterKind = ParameterKind.REQUIRED;
         setter.parameters = <ParameterElement>[parameter];
         _currentHolder.addAccessor(setter);
-        variable.setter = setter;
+        element.setter = setter;
       }
     }
     return null;
   }
 
   /**
    * Build the table mapping field names to field elements for the fields defined in the current
    * class.
    *
    * @param fields the field elements defined in the current class
@@ skipping 51 matching lines @@
    * Return the body of the function that contains the given parameter, or `null` if no
    * function body could be found.
    *
    * @param node the parameter contained in the function whose body is to be returned
    * @return the body of the function that contains the given parameter
    */
   FunctionBody _getFunctionBody(FormalParameter node) {
     AstNode parent = node.parent;
     while (parent != null) {
       if (parent is ConstructorDeclaration) {
-        return (parent as ConstructorDeclaration).body;
+        return parent.body;
       } else if (parent is FunctionExpression) {
-        return (parent as FunctionExpression).body;
+        return parent.body;
       } else if (parent is MethodDeclaration) {
-        return (parent as MethodDeclaration).body;
+        return parent.body;
       }
       parent = parent.parent;
     }
     return null;
   }
 
   /**
    * Sets the visible source range for formal parameter.
    */
   void _setParameterVisibleRange(
@@ skipping 1509 matching lines @@
             // can report the problem.
             parseUriWithException(scriptSourcePath);
             Source scriptSource =
                 _context.sourceFactory.resolveUri(htmlSource, scriptSourcePath);
             script.scriptSource = scriptSource;
             if (!_context.exists(scriptSource)) {
               _reportValueError(HtmlWarningCode.URI_DOES_NOT_EXIST,
                   scriptAttribute, [scriptSourcePath]);
             }
           } on URISyntaxException catch (exception) {
-            _reportValueError(HtmlWarningCode.INVALID_URI, scriptAttribute, [
-              scriptSourcePath
-            ]);
+            _reportValueError(HtmlWarningCode.INVALID_URI, scriptAttribute,
+                [scriptSourcePath]);
           }
         }
         node.scriptElement = script;
         _scripts.add(script);
       }
     } finally {
       _parentNodes.remove(node);
     }
     return null;
   }
@@ skipping 2633 matching lines @@
               _definingLibrary.context, foundElement, element);
         }
       }
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       foundElement = _removeSdkElements(
           identifier, name, foundElement as MultiplyDefinedElementImpl);
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       String foundEltName = foundElement.displayName;
-      List<Element> conflictingMembers =
-          (foundElement as MultiplyDefinedElementImpl).conflictingElements;
+      List<Element> conflictingMembers = foundElement.conflictingElements;
       int count = conflictingMembers.length;
       List<String> libraryNames = new List<String>(count);
       for (int i = 0; i < count; i++) {
         libraryNames[i] = _getLibraryName(conflictingMembers[i]);
       }
       libraryNames.sort();
       errorListener.onError(new AnalysisError.con2(getSource(identifier),
           identifier.offset, identifier.length,
           StaticWarningCode.AMBIGUOUS_IMPORT, [
         foundEltName,
@@ skipping 566 matching lines @@
                   exportedLibrary.libraryElement;
               if (exportedLibraryElement != null) {
                 exportElement.exportedLibrary = exportedLibraryElement;
               }
               directive.element = exportElement;
               exports.add(exportElement);
               if (analysisContext.computeKindOf(exportedSource) !=
                   SourceKind.LIBRARY) {
                 _errorListener.onError(new AnalysisError.con2(
                     library.librarySource, uriLiteral.offset, uriLiteral.length,
-                    CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [
-                  uriLiteral.toSource()
-                ]));
+                    CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
+                    [uriLiteral.toSource()]));
               }
             }
           }
         }
       }
       Source librarySource = library.librarySource;
       if (!library.explicitlyImportsCore &&
           _coreLibrarySource != librarySource) {
         ImportElementImpl importElement = new ImportElementImpl(-1);
         importElement.importedLibrary = _coreLibrary.libraryElement;
@@ skipping 684 matching lines @@
                   exportedLibrary.libraryElement;
               if (exportedLibraryElement != null) {
                 exportElement.exportedLibrary = exportedLibraryElement;
               }
               directive.element = exportElement;
               exports.add(exportElement);
               if (analysisContext.computeKindOf(exportedSource) !=
                   SourceKind.LIBRARY) {
                 _errorListener.onError(new AnalysisError.con2(
                     library.librarySource, uriLiteral.offset, uriLiteral.length,
-                    CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [
-                  uriLiteral.toSource()
-                ]));
+                    CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
+                    [uriLiteral.toSource()]));
               }
             }
           }
         }
       }
       Source librarySource = library.librarySource;
       if (!library.explicitlyImportsCore &&
           _coreLibrarySource != librarySource) {
         ImportElementImpl importElement = new ImportElementImpl(-1);
         importElement.importedLibrary = _coreLibrary.libraryElement;
@@ skipping 53 matching lines @@
    */
   void _buildImplicitConstructors() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       ImplicitConstructorComputer computer =
           new ImplicitConstructorComputer(_typeProvider);
       for (ResolvableLibrary library in _librariesInCycle) {
         for (ResolvableCompilationUnit unit
             in library.resolvableCompilationUnits) {
           Source source = unit.source;
           CompilationUnit ast = unit.compilationUnit;
-          computer
-              .add(ast, source, library.libraryElement, library.libraryScope);
+          computer.add(
+              ast, source, library.libraryElement, library.libraryScope);
         }
       }
       computer.compute();
     });
   }
 
   HashMap<Source, ResolvableLibrary> _buildLibraryMap() {
     HashMap<Source, ResolvableLibrary> libraryMap =
         new HashMap<Source, ResolvableLibrary>();
     int libraryCount = _librariesInCycle.length;
@@ skipping 235 matching lines @@
       // synthetic accessor
       int offset = duplicate.nameOffset;
       if (duplicate is PropertyAccessorElement) {
         PropertyAccessorElement accessor = duplicate;
         if (accessor.isSynthetic) {
           offset = accessor.variable.nameOffset;
         }
       }
       return new AnalysisError.con2(duplicate.source, offset,
           duplicate.displayName.length,
-          CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER, [
-        existing.displayName
-      ]);
+          CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER,
+          [existing.displayName]);
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
 
   /**
    * Add to this scope all of the public top-level names that are defined in the given compilation
    * unit.
    *
    * @param compilationUnit the compilation unit defining the top-level names to be added to this
    *          scope
@@ skipping 1278 matching lines @@
   VariableElement getOverridablePropagatedElement(Expression expression) {
     Element element = null;
     if (expression is SimpleIdentifier) {
       element = expression.propagatedElement;
     } else if (expression is PrefixedIdentifier) {
       element = expression.propagatedElement;
     } else if (expression is PropertyAccess) {
       element = expression.propertyName.propagatedElement;
     }
     if (element is VariableElement) {
-      return element as VariableElement;
+      return element;
     }
     return null;
   }
 
   /**
    * Return the static element associated with the given expression whose type can be overridden, or
    * `null` if there is no element whose type can be overridden.
    *
    * @param expression the expression with which the element is associated
    * @return the element associated with the given expression
    */
   VariableElement getOverridableStaticElement(Expression expression) {
     Element element = null;
     if (expression is SimpleIdentifier) {
       element = expression.staticElement;
     } else if (expression is PrefixedIdentifier) {
       element = expression.staticElement;
     } else if (expression is PropertyAccess) {
       element = expression.propertyName.staticElement;
     }
     if (element is VariableElement) {
-      return element as VariableElement;
+      return element;
     }
     return null;
   }
 
   /**
    * Return the static element associated with the given expression whose type can be promoted, or
    * `null` if there is no element whose type can be promoted.
    *
    * @param expression the expression with which the element is associated
    * @return the element associated with the given expression
@@ skipping 1891 matching lines @@
     } else {
       Scope outerScope = _nameScope;
       try {
         ExecutableElement functionElement = node.element;
         if (functionElement == null) {
           StringBuffer buffer = new StringBuffer();
           buffer.write("Missing element for function ");
           AstNode parent = node.parent;
           while (parent != null) {
             if (parent is Declaration) {
-              Element parentElement = (parent as Declaration).element;
+              Element parentElement = parent.element;
               buffer.write(parentElement == null
                   ? "<unknown> "
                   : "${parentElement.name} ");
             }
             parent = parent.parent;
           }
           buffer.write("in ");
           buffer.write(definingLibrary.source.fullName);
           AnalysisEngine.instance.logger.logInformation(buffer.toString(),
               new CaughtException(new AnalysisException(), null));
@@ skipping 1752 matching lines @@
                 (parent.parent as InstanceCreationExpression).isConst) {
               // If, if this is a const expression, then generate a
               // CompileTimeErrorCode.CONST_WITH_NON_TYPE error.
               reportErrorForNode(CompileTimeErrorCode.CONST_WITH_NON_TYPE,
                   prefixedIdentifier.identifier,
                   [prefixedIdentifier.identifier.name]);
             } else {
               // Else, if this expression is a new expression, report a
               // NEW_WITH_NON_TYPE warning.
               reportErrorForNode(StaticWarningCode.NEW_WITH_NON_TYPE,
-                  prefixedIdentifier.identifier, [
-                prefixedIdentifier.identifier.name
-              ]);
+                  prefixedIdentifier.identifier,
+                  [prefixedIdentifier.identifier.name]);
             }
             _setElement(prefix, element);
             return null;
           } else if (element != null) {
             //
             // Rewrite the constructor name. The parser, when it sees a
             // constructor named "a.b", cannot tell whether "a" is a prefix and
             // "b" is a class name, or whether "a" is a class name and "b" is a
             // constructor name. It arbitrarily chooses the former, but in this
             // case was wrong.
@@ skipping 78 matching lines @@
       } else {
         _setElement(typeName, _dynamicType.element);
       }
       typeName.staticType = _undefinedType;
       node.type = _undefinedType;
       return null;
     }
     DartType type = null;
     if (element is ClassElement) {
       _setElement(typeName, element);
-      type = (element as ClassElement).type;
+      type = element.type;
     } else if (element is FunctionTypeAliasElement) {
       _setElement(typeName, element);
-      type = (element as FunctionTypeAliasElement).type;
+      type = element.type;
     } else if (element is TypeParameterElement) {
       _setElement(typeName, element);
-      type = (element as TypeParameterElement).type;
+      type = element.type;
       if (argumentList != null) {
         // Type parameters cannot have type arguments.
         // TODO(brianwilkerson) Report this error.
         //      resolver.reportError(ResolverErrorCode.?, keyType);
       }
     } else if (element is MultiplyDefinedElement) {
-      List<Element> elements =
-          (element as MultiplyDefinedElement).conflictingElements;
+      List<Element> elements = element.conflictingElements;
       type = _getTypeWhenMultiplyDefined(elements);
       if (type != null) {
         node.type = type;
       }
     } else {
       // The name does not represent a type.
       RedirectingConstructorKind redirectingConstructorKind;
       if (_isTypeNameInCatchClause(node)) {
         reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName,
             [typeName.name]);
@@ skipping 215 matching lines @@
    *
    * @param node the type name with the wrong number of type arguments
    * @return the error code that should be used to report that the wrong number of type arguments
    *         were provided
    */
   ErrorCode _getInvalidTypeParametersErrorCode(TypeName node) {
     AstNode parent = node.parent;
     if (parent is ConstructorName) {
       parent = parent.parent;
       if (parent is InstanceCreationExpression) {
-        if ((parent as InstanceCreationExpression).isConst) {
+        if (parent.isConst) {
           return CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS;
         } else {
           return StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS;
         }
       }
     }
     return StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
   }
 
   /**
    * Checks if the given type name is the target in a redirected constructor.
    *
    * @param typeName the type name to analyze
    * @return some [RedirectingConstructorKind] if the given type name is used as the type in a
    *         redirected constructor, or `null` otherwise
    */
   RedirectingConstructorKind _getRedirectingConstructorKind(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is ConstructorName) {
       ConstructorName constructorName = parent as ConstructorName;
       parent = constructorName.parent;
       if (parent is ConstructorDeclaration) {
-        ConstructorDeclaration constructorDeclaration =
-            parent as ConstructorDeclaration;
-        if (identical(
-            constructorDeclaration.redirectedConstructor, constructorName)) {
-          if (constructorDeclaration.constKeyword != null) {
+        if (identical(parent.redirectedConstructor, constructorName)) {
+          if (parent.constKeyword != null) {
             return RedirectingConstructorKind.CONST;
           }
           return RedirectingConstructorKind.NORMAL;
         }
       }
     }
     return null;
   }
 
   /**
@@ skipping 970 matching lines @@
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 }