Refactor fuzzy arrow hints.

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 754 matching lines @@
   /// 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, bool isDeclarationCast: false}) {
     from ??= _getDefiniteType(expr);
 
+    _hintOnFuzzyArrows(expr, to, from);
+
     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.
@@ skipping 283 matching lines @@
     // Dynamic as the parameter type is treated as bottom.  A function with
     // a dynamic parameter type requires a dynamic call in general.
     // However, as an optimization, if we have an original definition, we know
     // dynamic is reified as Object - in this case a regular call is fine.
     if (hasStrictArrow(call.function)) {
       return false;
     }
     return rules.anyParameterType(ft, (pt) => pt.isDynamic);
   }
 
+  void _hintOnFuzzyArrows(Expression expr, DartType to, DartType from) {
+    // If it is a subtype with fuzzy arrows on,
+    // check to see if it still is with them off.
+    if (rules.isSubtypeOf(from, to)) {
+      // Remove fuzzy arrows
+      var cFrom = rules.typeToConcreteType(from);
+      var cTo = rules.typeToConcreteType(to);
+      // If still true, no warning needed
+      if (rules.isSubtypeOf(cFrom, cTo)) return;
+      _recordMessage(expr, HintCode.USES_DYNAMIC_AS_BOTTOM, [from, to]);
+    }
+  }
+
   /// 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 isDeclarationCast: false}) {
     from ??= _getDefiniteType(expr);
 
     if (!_checkNonNullAssignment(expr, to, from)) return false;
@@ skipping 129 matching lines @@
     var severity =
         (processor != null) ? processor.severity : errorCode.errorSeverity;
 
     if (severity == ErrorSeverity.ERROR) {
       _failure = true;
     }
     if (errorCode.type == ErrorType.HINT &&
         errorCode.name.startsWith('STRONG_MODE_TOP_LEVEL_')) {
       severity = ErrorSeverity.ERROR;
     }
-    if (severity != ErrorSeverity.INFO || _options.strongModeHints) {
+    if (severity != ErrorSeverity.INFO ||
+        _options.strongModeHints ||
+        errorCode == HintCode.USES_DYNAMIC_AS_BOTTOM) {
       int begin = node is AnnotatedNode
           ? node.firstTokenAfterCommentAndMetadata.offset
           : node.offset;
       int length = node.end - begin;
       var source = resolutionMap
           .elementDeclaredByCompilationUnit(node.root as CompilationUnit)
           .source;
       var error =
           new AnalysisError(source, begin, length, errorCode, arguments);
       reporter.onError(error);
@@ skipping 743 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;
   }
 }