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

pkg/analyzer/lib/src/task/strong/checker.dart

 // Copyright (c) 2015, 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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'dart:collection';
 import 'package:analyzer/analyzer.dart';
@@ skipping 179 matching lines @@
       if (element == null) {
         // We found an argument mismatch, the analyzer will report this too,
         // so no need to insert an error for this here.
         continue;
       }
       checkArgument(arg, _elementType(element));
     }
   }
 
   void checkAssignment(Expression expr, DartType type) {
+    checkForCast(expr, type);
+  }
+
+  void checkDeclarationCast(Expression expr, DartType type) {
+    checkForCast(expr, type, isDeclarationCast: true);
+  }
+
+  void checkForCast(Expression expr, DartType type,
+      {bool isDeclarationCast = false}) {
     if (expr is ParenthesizedExpression) {
-      checkAssignment(expr.expression, type);
+      checkForCast(expr.expression, type);
     } else {
-      _checkImplicitCast(expr, type);
+      _checkImplicitCast(expr, type, isDeclarationCast: isDeclarationCast);
     }
   }
 
   /// Analyzer checks boolean conversions, but we need to check too, because
   /// it uses the default assignability rules that allow `dynamic` and `Object`
   /// to be assigned to bool with no message.
   void checkBoolean(Expression expr) =>
       checkAssignment(expr, typeProvider.boolType);
 
   void _checkFunctionApplication(InvocationExpression node) {
@@ skipping 211 matching lines @@
           elementType = DynamicTypeImpl.instance;
         }
       }
 
       // If the sequence doesn't implement the interface at all, [ErrorVerifier]
       // will report the error, so ignore it here.
       if (elementType != null) {
         // Insert a cast from the sequence's element type to the loop variable's
         // if needed.
         _checkImplicitCast(loopVariable, _getDefiniteType(loopVariable),
-            from: elementType);
+            from: elementType, isDeclarationCast: true);
       }
     }
 
     node.visitChildren(this);
   }
 
   @override
   void visitForStatement(ForStatement node) {
     if (node.condition != null) {
       checkBoolean(node.condition);
@@ skipping 231 matching lines @@
   }
 
   @override
   void visitVariableDeclarationList(VariableDeclarationList node) {
     TypeAnnotation type = node.type;
 
     for (VariableDeclaration variable in node.variables) {
       var initializer = variable.initializer;
       if (initializer != null) {
         if (type != null) {
-          checkAssignment(initializer, type.type);
+          checkDeclarationCast(initializer, type.type);
         }
       }
     }
 
     node.visitChildren(this);
   }
 
   @override
   void visitWhileStatement(WhileStatement node) {
     checkBoolean(node.condition);
@@ skipping 55 matching lines @@
   }
 
   /// Checks if an implicit cast of [expr] from [from] type to [to] type is
   /// needed, and if so records it.
   ///
   /// If [from] is omitted, uses the static type of [expr].
   ///
   /// If [expr] does not require an implicit cast because it is not related to
   /// [to] or is already a subtype of it, does nothing.
   void _checkImplicitCast(Expression expr, DartType to,
-      {DartType from, bool opAssign: false}) {
+      {DartType from, bool opAssign: false, bool isDeclarationCast: false}) {
     from ??= _getDefiniteType(expr);
 
-    if (_needsImplicitCast(expr, to, from: from) == true) {
+    if (_needsImplicitCast(expr, to,
+            from: from, isDeclarationCast: isDeclarationCast) ==
+        true) {
       _recordImplicitCast(expr, to, from: from, opAssign: opAssign);
     }
   }
 
   /// Checks if the assignment is valid with respect to non-nullable types.
   /// Returns `false` if a nullable expression is assigned to a variable of
   /// non-nullable type and `true` otherwise.
   bool _checkNonNullAssignment(
       Expression expression, DartType to, DartType from) {
     if (rules.isNonNullableType(to) && rules.isNullableType(from)) {
@@ skipping 278 matching lines @@
       return false;
     }
     return rules.anyParameterType(ft, (pt) => pt.isDynamic);
   }
 
   /// Returns true if we need an implicit cast of [expr] from [from] type to
   /// [to] type, returns false if no cast is needed, and returns null if the
   /// types are statically incompatible.
   ///
   /// If [from] is omitted, uses the static type of [expr]
-  bool _needsImplicitCast(Expression expr, DartType to, {DartType from}) {
+  bool _needsImplicitCast(Expression expr, DartType to,
+      {DartType from, bool isDeclarationCast: false}) {
     from ??= _getDefiniteType(expr);
 
     if (!_checkNonNullAssignment(expr, to, from)) return false;
 
     // We can use anything as void.
     if (to.isVoid) return false;
 
     // fromT <: toT, no coercion needed.
     if (rules.isSubtypeOf(from, to)) return false;
 
     // Down cast or legal sideways cast, coercion needed.
-    if (rules.isAssignableTo(from, to)) return true;
+    if (rules.isAssignableTo(from, to, isDeclarationCast: isDeclarationCast))
+      return true;
 
     // Special case for FutureOr to handle returned values from async functions.
     // In this case, we're more permissive than assignability.
     if (to.element == typeProvider.futureOrType.element) {
       var to1 = (to as InterfaceType).typeArguments[0];
       var to2 = typeProvider.futureType.instantiate([to1]);
       return _needsImplicitCast(expr, to1, from: from) == true ||
           _needsImplicitCast(expr, to2, from: from) == true;
     }
 
@@ skipping 913 matching lines @@
   }
 
   /// If node is a [ClassDeclaration] returns its members, otherwise if node is
   /// a [ClassTypeAlias] this returns an empty list.
   WithClause _withClause(Declaration node) {
     return node is ClassDeclaration
         ? node.withClause
         : (node as ClassTypeAlias).withClause;
   }
 }