Use static dispatch for dynamic on Object methods

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 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 3112 matching lines @@
     if (node is PropertyAccess) {
       return AstBuilder.propertyAccess(newTarget, node.propertyName);
     } else {
       var invoke = node as MethodInvocation;
       return AstBuilder.methodInvoke(
           newTarget, invoke.methodName, invoke.argumentList.arguments);
     }
   }
 
   bool _requiresStaticDispatch(Expression target, String memberName) {
-    var type = getStaticType(target);
+    var type = target.propagatedType ?? getStaticType(target);

[Harry Terkelsen, 2016/04/26 20:51:55]

btw, this is the only use of propagatedType in ddc... I wasn't sure if the
analyzer API changed and getStaticType should give propagatedType if it is set
or if there was a reason not to use it?

[Jennifer Messerly, 2016/04/26 21:04:56]

yeah we never to use it. It's the old Analyzer inference, it's unsound and it's
also something we hope to remove from Strong Mode Analyzer in the near future
(we waste time in some cases inferring things twice, the old way and the new
way).

... so I don't think this is the right fix, but it's a great find :). So what
this means is old-Analyzer inferred something different than new-Strong-Mode
did. We should have a look into the example and the Analyzer code and figure out
why this happened & fix it over there.

This is the function that's supposed to be inferring the correct type for us:
https://github.com/dart-lang/sdk/blob/2bd7317edee49e5365e593e22dee52d95ed7356...

Maybe the logic got broken somehow, but it used to work.

     if (!isObjectProperty(memberName)) {
       return false;
     }
 
     // If the target could be `null`, we need static dispatch.
     // If the target may be an extension type, we also use static dispatch
     // as we don't symbolize object properties like hashCode.
     return isNullable(target) ||
         (_extensionTypes.contains(type.element) && target is! SuperExpression);
   }
@@ skipping 716 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';