Don't call dinvoke on Object methods

lib/src/codegen/js_codegen.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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 1848 matching lines @@
       return _emitGet(node.prefix, node.identifier);
     }
   }
 
   @override
   visitPropertyAccess(PropertyAccess node) =>
       _emitGet(_getTarget(node), node.propertyName);
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   _emitGet(Expression target, SimpleIdentifier name) {
-    if (rules.isDynamicTarget(target)) {
+    if (rules.isDynamicGet(target, name)) {

[Jennifer Messerly, 2015/04/07 19:05:49]

ideally we'd only need to check one of these. Or alternatively, we could check
for PrefixElement before calling? Just trying to brainstorm a way out of this
library-prefix-is-dynamic madness. It's ironic one of the most statically known
things in the system is treated as if it's the most dynamic =)

[vsm, 2015/04/07 19:48:46]

This particular one doesn't bother me.  A get is a based on the target and the
property, so it makes sense to pass in both.  Note, isDynamicGet doesn't check
for PrefixElement.  That logic moved to the resolver.

For that in general, perhaps the cleanest solution is to replace
PrefixedIdentifier with PropertyAccess in the AST once resolved?

[Jennifer Messerly, 2015/04/07 21:49:23]

yeah, that's a good point. I just would expect that to be handled by resolution.
Resolution combines target+name and figures out if it could resolve the thing or
not. Whenever we need to do resolution-y stuff in js_codegen it makes me wonder
if it's in the right place or not.

Maybe we could set the static type of "target" to be Object so it doesn't match
"dynamic" anymore? Since we did bind it to an Object method.
yeah, that's a good idea.

[vsm, 2015/04/07 22:40:41]

I went ahead and did this and did some corresponding cleanup.

It does leave us in a weird (?) situation where a and x can have non-fuzzy
static types but a.x is dynamic.  But perhaps that is not too bad.  It means
that a.x doesn't require a dinvoke, but that we do not exactly know the result
type.

       return js.call(
           'dart.dload(#, #)', [_visit(target), js.string(name.name, "'")]);
     } else {
       var e = name.staticElement;
       var ret = js.call('#.#', [
         _visit(target),
         _emitMemberName(name.name,
             isStatic: e is ExecutableElement && e.isStatic, target: target)
       ]);
       return ret;
@@ skipping 625 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }