Eliminate unnecessary covariance checks.

lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 1637 matching lines @@
             paramName,
             _defaultParamValue(param),
           ]));
         } else if (param.kind == ParameterKind.POSITIONAL) {
           body.add(js.statement('if (# === void 0) # = #;',
               [jsParam, jsParam, _defaultParamValue(param)]));
         }
       }
 
       // TODO(jmesserly): various problems here, see:
-      // https://github.com/dart-lang/dev_compiler/issues/161
+      // https://github.com/dart-lang/dev_compiler/issues/116
       var paramType = param.element.type;
-      if (!constructor && _hasUnsoundTypeParameter(paramType)) {
+      if (node is MethodDeclaration && _unsoundCovariant(paramType, true)) {
         body.add(
             js.statement('dart.as(#, #);', [jsParam, _emitType(paramType)]));
       }
     }
     return body.isEmpty ? null : _statement(body);
   }
 
-  bool _isUnsoundTypeParameter(DartType t) =>
-      t is TypeParameterType && t.element.enclosingElement is ClassElement;
-
-  bool _hasUnsoundTypeParameter(DartType t) =>
-      _isUnsoundTypeParameter(t) ||
-      t is ParameterizedType && t.typeArguments.any(_hasUnsoundTypeParameter);
+  /// Given a type [t], return whether or not t is unsoundly covariant.
+  /// If [contravariant] is true, then t appears in a contravariant
+  /// position.
+  bool _unsoundCovariant(DartType t, bool contravariant) {
+    if (t is TypeParameterType) {
+      return contravariant && t.element.enclosingElement is ClassElement;
+    }
+    if (t is FunctionType) {
+      if (_unsoundCovariant(t.returnType, contravariant)) return true;
+      var parameters = t.parameters.map((p) => p.type);

[Jennifer Messerly, 2016/05/17 18:09:04]

probably a bit faster to merge this with the .any below?

    t.parameters.any((p) => _unsoundCovariant(p.type, !contravariant));

I don't mind either way though :)

[Leaf, 2016/05/17 18:15:36]

Done.

+      return parameters.any((t) => _unsoundCovariant(t, !contravariant));
+    }
+    if (t is ParameterizedType) {
+      return t.typeArguments.any((t) => _unsoundCovariant(t, contravariant));
+    }
+    return false;
+  }
 
   JS.Expression _defaultParamValue(FormalParameter param) {
     if (param is DefaultFormalParameter && param.defaultValue != null) {
       return _visit(param.defaultValue);
     } else {
       return new JS.LiteralNull();
     }
   }
 
   JS.Fun _emitNativeFunctionBody(MethodDeclaration node) {
@@ skipping 2787 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';