Turn off `strong_mode_down_cast_composite` warnings by default in Flutter projects.

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 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 129 matching lines @@
 }
 
 typedef FunctionType _MemberTypeGetter(InterfaceType type);
 
 /// Checks the body of functions and properties.
 class CodeChecker extends RecursiveAstVisitor {
   final StrongTypeSystemImpl rules;
   final TypeProvider typeProvider;
   final AnalysisErrorListener reporter;
   final AnalysisOptionsImpl _options;
+  final bool _hasFlutterDependency;
   _OverrideChecker _overrideChecker;
 
   bool _failure = false;
   bool _hasImplicitCasts;
 
   CodeChecker(TypeProvider typeProvider, StrongTypeSystemImpl rules,
-      AnalysisErrorListener reporter, this._options)
+      AnalysisErrorListener reporter, this._options, this._hasFlutterDependency)
       : typeProvider = typeProvider,
         rules = rules,
         reporter = reporter {
     _overrideChecker = new _OverrideChecker(this);
   }
 
   bool get failure => _failure;
 
   void checkArgument(Expression arg, DartType expectedType) {
     // Preserve named argument structure, so their immediate parent is the
@@ skipping 937 matching lines @@
         // Iterable<T> to List<T>.  The intuition here is that raw (generic)
         // casts are problematic, and we should complain about those.
         var typeArgs = from.typeArguments;
         downCastComposite =
             typeArgs.isEmpty || typeArgs.any((t) => t.isDynamic);
       } else {
         downCastComposite = !from.isDynamic;
       }
     }
 
+    // BUG(28588): The down-cast-composite warning will be turned off by
+    // default, but as a first step we're only doing this for Flutter code
+    // and we will leave it on for web projects to help with the migration
+    // to strong mode and the associate runtime type checks. Flutter projects
+    // can still turn on the warning explicitly through analysis options.
+    if (_hasFlutterDependency && downCastComposite) {
+      bool hasExplicitOption = _options.errorProcessors.any(
+          (processor) => processor.code == StrongModeCode.DOWN_CAST_COMPOSITE);
+      if (!hasExplicitOption) return;
+    }
+
     var parent = expr.parent;
     ErrorCode errorCode;
     if (downCastComposite) {
       errorCode = StrongModeCode.DOWN_CAST_COMPOSITE;
     } else if (from.isDynamic) {
       errorCode = StrongModeCode.DYNAMIC_CAST;
     } else if (parent is VariableDeclaration && parent.initializer == expr) {
       errorCode = StrongModeCode.ASSIGNMENT_CAST;
     } else {
       errorCode = opAssign
@@ skipping 369 matching lines @@
     var visited = new Set<InterfaceType>();
     do {
       visited.add(current);
       current.mixins.reversed.forEach(
           (m) => _checkIndividualOverridesFromClass(node, m, seen, true));
       _checkIndividualOverridesFromClass(node, current.superclass, seen, true);
       current = current.superclass;
     } while (!current.isObject && !visited.contains(current));
   }
 }