Do not use erroneouselement unless the member is static

tests/compiler/dart2js/resolver_test.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.
 
 import "package:expect/expect.dart";
 import 'dart:async';
 import "package:async_helper/async_helper.dart";
 import 'dart:collection';
 
 import "package:compiler/src/resolution/resolution.dart";
@@ skipping 1127 matching lines @@
     expect(compiler,
         [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS],
         [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD]);
   }));
 }
 
 testCantAssignMethods() {
-  checkWarningOn(String script, List<String> errorLocations) {
+  checkWarningOn(String script, List<MessageKind> warnings) {
+    Expect.isTrue(warnings.length >= 0 && warnings.length <= 2);
     asyncTest(() => compileScript(script).then((compiler) {
       Expect.equals(0, compiler.errors.length);
-      Expect.equals(errorLocations.length, compiler.warnings.length);
-      for (var i = 0; i < errorLocations.length; i++) {
-        Expect.equals(MessageKind.ASSIGNING_METHOD,
-            compiler.warnings[i].message.kind);
-        Expect.equals(script.indexOf(errorLocations[i]),
-            compiler.warnings[i].node.getBeginToken().charOffset);
+      Expect.equals(warnings.length, compiler.warnings.length);
+      for (int i = 0; i < warnings.length; i++) {
+        Expect.equals(warnings[i], compiler.warnings[i].message.kind);
       }
     }));
   }
 
   // Can't override local functions
   checkWarningOn('''
       main() {
         mname() { mname = 2; };
         mname();
       }
-      ''', ['mname = 2']);
+      ''', [MessageKind.ASSIGNING_METHOD]);
 
   checkWarningOn('''
       main() {
         mname() { };
         mname = 3;
       }
-      ''', ['mname = 3']);
+      ''', [MessageKind.ASSIGNING_METHOD]);
 
   // Can't override top-level functions
   checkWarningOn('''
       m() {}
       main() { m = 4; }
-      ''', ['m = 4']);
+      ''', [MessageKind.ASSIGNING_METHOD]);
 
   // Can't override instance methods
   checkWarningOn('''
       main() { new B().bar(); }
       class B {
         mname() {}
         bar() {
           mname = () => null;
         }
       }
-      ''', ['mname = () => null']);
+      ''', [MessageKind.ASSIGNING_METHOD, MessageKind.SETTER_NOT_FOUND]);

[Siggi Cherem (dart-lang), 2015/04/15 01:38:04]

I'm not happy with the second error (which is currently generated from
typechecker.dart), but I guess we can address that separately

[Johnni Winther, 2015/04/15 08:58:03]

Actually should not resolve [target] to an instance member (in ResolverVisitor)
and therefore only observe the case in typechecker.dart (where a better message
could be used).

[Siggi Cherem (dart-lang), 2015/04/15 22:39:46]

Good point - I changed it so that the checker reports its error, but we don't
report one in the resolver in this case. Now all the tests have a single
warning.

 
   // Can't override super methods
   checkWarningOn('''
       main() { new B().bar(); }
       class A {
         mname() {}
       }
       class B extends A {
         bar() {
           super.mname = () => 6;
         }
       }
-      ''', ['mname = () => 6']);
+      ''', [MessageKind.ASSIGNING_METHOD, MessageKind.SETTER_NOT_FOUND]);
 
   // But fields are OK:
   checkWarningOn('''
       main() { new B().bar(); }
       class A {
         int fname;
       }
       class B extends A {
         bar() {
           super.fname = 3;
@@ skipping 16 matching lines @@
       class A {
         operator[]=(x, y) {}
       }
       class B extends A {
         bar() {
           super[1] = 3; // This is OK
         }
       }
       ''', []);
 }