Make invalid to override method names for local nested functions

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 70 matching lines @@
     testThis,
     testSuperCalls,
     testSwitch,
     testTypeVariables,
     testToString,
     testIndexedOperator,
     testIncrementsAndDecrements,
     testOverrideHashCodeCheck,
     testSupertypeOrder,
     testConstConstructorAndNonFinalFields,
+    testCantAssignMethods,
   ], (f) => f()));
 }
 
 Future testSupertypeOrder() {
   return Future.wait([
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""
 class I1 {}
 class I2 {}
 class J1 extends K1 {}
@@ skipping 1034 matching lines @@
       }""";
   asyncTest(() => compileScript(script2).then((compiler) {
     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) {
+    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);
+      }
+    }));
+  }
+
+  // Can't override local functions
+  checkWarningOn('''
+      main() {
+        mname() { mname = 2; };
+        mname();
+      }
+      ''', ['mname = 2']);
+
+  checkWarningOn('''
+      main() {
+        mname() { };
+        mname = 3;
+      }
+      ''', ['mname = 3']);
+
+  // Can't override top-level functions
+  checkWarningOn('''
+      m() {}
+      main() { m = 4; }
+      ''', ['m = 4']);
+
+  // Can't override instance methods
+  checkWarningOn('''
+      main() { new B().bar(); }
+      class B {
+        mname() {}
+        bar() {
+          mname = () => null;
+        }
+      }
+      ''', ['mname = () => null']);
+
+  // Can't override super methods
+  checkWarningOn('''
+      main() { new B().bar(); }
+      class A {
+        mname() {}
+      }
+      class B extends A {
+        bar() {
+          super.mname = () => 6;
+        }
+      }
+      ''', ['mname = () => 6']);
+
+  // But fields are OK:
+  checkWarningOn('''
+      main() { new B().bar(); }
+      class A {
+        int fname;
+      }
+      class B extends A {
+        bar() {
+          super.fname = 3;
+        }
+      }
+      ''', []);
+
+  // And we shouldn't confuse index operators either:
+  checkWarningOn('''
+      main() { new B().bar(); }
+      class B {
+        operator[]=(x, y) {}
+        bar() {
+          this[1] = 3; // This is OK
+        }
+      }
+      ''', []);
+  checkWarningOn('''
+      main() { new B().bar(); }
+      class A {
+        operator[]=(x, y) {}
+      }
+      class B extends A {
+        bar() {
+          super[1] = 3; // This is OK
+        }
+      }
+      ''', []);
+}