Turn error into warning for non-static member access through the class.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 1935 matching lines @@
       if (node.isOperator) {
         // When the resolved receiver is a class, we can have two cases:
         //  1) a static send: C.foo, or
         //  2) an operator send, where the receiver is a class literal: 'C + 1'.
         // The following code that looks up the selector on the resolved
         // receiver will treat the second as the invocation of a static operator
         // if the resolved receiver is not null.
         return null;
       }
       target = receiverClass.lookupLocalMember(name);
-      if (target == null) {
+      if (target == null || target.isInstanceMember()) {
         compiler.backend.registerThrowNoSuchMethod();
         // TODO(johnniwinther): With the simplified [TreeElements] invariant,
         // try to resolve injected elements if [currentClass] is in the patch
         // library of [receiverClass].
 
         // TODO(karlklose): this should be reported by the caller of
         // [resolveSend] to select better warning messages for getters and
         // setters.
-        return warnAndCreateErroneousElement(node, name,
-                                             MessageKind.METHOD_NOT_FOUND,
+        MessageKind kind = (target == null)
+            ? MessageKind.METHOD_NOT_FOUND
+            : MessageKind.MEMBER_NOT_STATIC;
+        return warnAndCreateErroneousElement(node, name, kind,
                                              {'className': receiverClass.name,
                                               'methodName': name});
-      } else if (target.isInstanceMember()) {
-        error(node, MessageKind.MEMBER_NOT_STATIC,
-              {'className': receiverClass.name,
-               'memberName': name});
       }
     } else if (identical(resolvedReceiver.kind, ElementKind.PREFIX)) {
       PrefixElement prefix = resolvedReceiver;
       target = prefix.lookupLocalMember(name);
       if (Elements.isUnresolved(target)) {
         compiler.backend.registerThrowNoSuchMethod();
         return warnAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_LIBRARY_MEMBER,
             {'libraryName': prefix.name, 'memberName': name});
       } else if (target.kind == ElementKind.CLASS) {
@@ skipping 1718 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }