fix #26896, mark all @proxy ops as dynamic

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 1011 matching lines @@
 
   /// Returns `true` if the target expression is dynamic.
   bool _isDynamicTarget(Expression node) {
     if (node == null) return false;
 
     if (_isLibraryPrefix(node)) return false;
 
     // Null type happens when we have unknown identifiers, like a dart: import
     // that doesn't resolve.
     var type = node.staticType;
-    return type == null || type.isDynamic;
+    var element = type?.element;
+    return type == null ||
+        type.isDynamic ||
+        (element is ClassElement && element.isOrInheritsProxy);

[vsm, 2016/08/09 15:20:51]

Is this too conservative if there is an actual method on the class?

E.g., foo vs bar below:

@Proxy()
class A {
  void foo(int x) { ... }
  noSuchMethod(...) { ... }
}

var a = new A();
a.foo(42); // Not dynamic
a.bar(42); // Dynamic

[Jennifer Messerly, 2016/08/09 15:31:11]

This path actually only handles operators. Method/function calls were already
handled by _isDynamicCall, and they use the absence of an Element to figure out
that it must be a dynamic call.

For operators we might be able to use a similar technique. It would mean
reworking _isDynamicTarget, removing it and treating operators as dynamic calls.
Not sure how well that would work but it is the only approach I think that would
address your concern here. But you're right, we're a tad conservative on using
operators on @proxy classes.

   }
 
   bool _isLibraryPrefix(Expression node) =>
       node is SimpleIdentifier && node.staticElement is PrefixElement;
 
   bool _isObjectGetter(Expression target, SimpleIdentifier id) {
     PropertyAccessorElement element =
         typeProvider.objectType.element.getGetter(id.name);
     return (element != null && !element.isStatic);
   }
@@ skipping 471 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));
   }
 }