Add --no-declaration-casts option to analyzer.

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 analyzer.src.generated.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1187 matching lines @@
   Object visitTypeParameterList(TypeParameterList node) {
     _checkDuplicateDefinitionInTypeParameterList(node);
     return super.visitTypeParameterList(node);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     SimpleIdentifier nameNode = node.name;
     Expression initializerNode = node.initializer;
     // do checks
-    _checkForInvalidAssignment(nameNode, initializerNode);
+    _checkForInvalidAssignment(nameNode, initializerNode,
+        isDeclarationCast: true);
     _checkForImplicitDynamicIdentifier(node, nameNode);
     // visit name
     nameNode.accept(this);
     // visit initializer
     String name = nameNode.name;
     _namesForReferenceToDeclaredVariableInInitializer.add(name);
     bool wasInInstanceVariableInitializer = _isInInstanceVariableInitializer;
     _isInInstanceVariableInitializer = _isInInstanceVariableDeclaration;
     try {
       if (initializerNode != null) {
@@ skipping 1278 matching lines @@
     if (expressionType == null) {
       return;
     }
     if (_expressionIsAssignableAtType(expression, expressionType, type)) {
       return;
     }
     _errorReporter.reportErrorForNode(errorCode, expression, arguments);
   }
 
   bool _checkForAssignableExpression(
-      Expression expression, DartType expectedStaticType, ErrorCode errorCode) {
+      Expression expression, DartType expectedStaticType, ErrorCode errorCode,
+      {bool isDeclarationCast = false}) {
     DartType actualStaticType = getStaticType(expression);
     return actualStaticType != null &&
         _checkForAssignableExpressionAtType(
-            expression, actualStaticType, expectedStaticType, errorCode);
+            expression, actualStaticType, expectedStaticType, errorCode,
+            isDeclarationCast: isDeclarationCast);
   }
 
   bool _checkForAssignableExpressionAtType(
       Expression expression,
       DartType actualStaticType,
       DartType expectedStaticType,
-      ErrorCode errorCode) {
+      ErrorCode errorCode,
+      {bool isDeclarationCast = false}) {
     if (!_expressionIsAssignableAtType(
-        expression, actualStaticType, expectedStaticType)) {
+        expression, actualStaticType, expectedStaticType,
+        isDeclarationCast: isDeclarationCast)) {
       _errorReporter.reportTypeErrorForNode(
           errorCode, expression, [actualStaticType, expectedStaticType]);
       return false;
     }
     return true;
   }
 
   /**
    * Verify that the given [expression] is not final.
    *
@@ skipping 1734 matching lines @@
       if (_typeSystem.isSubtypeOf(loopType, iterableType)) {
         bestIterableType = DynamicTypeImpl.instance;
       }
     }
 
     if (bestIterableType == null) {
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.FOR_IN_OF_INVALID_TYPE,
           node.iterable,
           [iterableType, loopTypeName]);
-    } else if (!_typeSystem.isAssignableTo(bestIterableType, variableType)) {
+    } else if (!_typeSystem.isAssignableTo(bestIterableType, variableType,
+        isDeclarationCast: true)) {
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE,
           node.iterable,
           [iterableType, loopTypeName, variableType]);
     }
   }
 
   /**
    * Check that the given [typeReference] is not a type reference and that then
    * the [name] is reference to an instance member.
@@ skipping 133 matching lines @@
           annotation.name);
     }
   }
 
   /**
    * Verify that the given left hand side ([lhs]) and right hand side ([rhs])
    * represent a valid assignment.
    *
    * See [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
-  void _checkForInvalidAssignment(Expression lhs, Expression rhs) {
+  void _checkForInvalidAssignment(Expression lhs, Expression rhs,
+      {bool isDeclarationCast = false}) {
     if (lhs == null || rhs == null) {
       return;
     }
     VariableElement leftVariableElement = getVariableElement(lhs);
     DartType leftType = (leftVariableElement == null)
         ? getStaticType(lhs)
         : leftVariableElement.type;
     _checkForAssignableExpression(
-        rhs, leftType, StaticTypeWarningCode.INVALID_ASSIGNMENT);
+        rhs, leftType, StaticTypeWarningCode.INVALID_ASSIGNMENT,
+        isDeclarationCast: isDeclarationCast);
   }
 
   /**
    * Given an [assignment] using a compound assignment operator, this verifies
    * that the given assignment is valid. The [lhs] is the left hand side
    * expression. The [rhs] is the right hand side expression.
    *
    * See [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
   void _checkForInvalidCompoundAssignment(
@@ skipping 1862 matching lines @@
     }
     DartType staticReturnType = getStaticType(returnExpression);
     if (staticReturnType != null && _enclosingFunction.isAsynchronous) {
       return _typeProvider.futureType.instantiate(
           <DartType>[staticReturnType.flattenFutures(_typeSystem)]);
     }
     return staticReturnType;
   }
 
   bool _expressionIsAssignableAtType(Expression expression,
-      DartType actualStaticType, DartType expectedStaticType) {
+      DartType actualStaticType, DartType expectedStaticType,
+      {isDeclarationCast: false}) {
     bool concrete = _options.strongMode && checker.hasStrictArrow(expression);
     if (concrete && actualStaticType is FunctionType) {
       actualStaticType =
           _typeSystem.functionTypeToConcreteType(actualStaticType);
     }
-    return _typeSystem.isAssignableTo(actualStaticType, expectedStaticType);
+    return _typeSystem.isAssignableTo(actualStaticType, expectedStaticType,
+        isDeclarationCast: isDeclarationCast);
   }
 
   MethodElement _findOverriddenMemberThatMustCallSuper(MethodDeclaration node) {
     ExecutableElement overriddenMember = _getOverriddenMember(node.element);
     List<ExecutableElement> seen = <ExecutableElement>[];
     while (
         overriddenMember is MethodElement && !seen.contains(overriddenMember)) {
       for (ElementAnnotation annotation in overriddenMember.metadata) {
         if (annotation.isMustCallSuper) {
           return overriddenMember;
@@ skipping 810 matching lines @@
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }