fixes #314, super method tear offs

test/codegen/language/method_binding_test.dart

Index: test/codegen/language/method_binding_test.dart
diff --git a/test/codegen/language/method_binding_test.dart b/test/codegen/language/method_binding_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..454d8f1e630bd56ed275ce04c00a9d9430fbc3bb
--- /dev/null
+++ b/test/codegen/language/method_binding_test.dart
@@ -0,0 +1,149 @@
+// Copyright (c) 2011, 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";
+
+// Bind a method to a variable that can be invoked as a function
+
+class A {
+  int a;
+
+  static var func;
+
+  A(this.a) { }
+
+  static foo() { return 4; }
+
+  bar() { return a; }
+
+  int baz() { return a; }
+
+  getThis() { return this.bar; }
+
+  getNoThis() { return bar; }
+
+  methodArgs(arg) { return arg + a; }
+
+  selfReference () { return selfReference; }
+
+  invokeBaz() { return (baz)(); }
+
+  invokeBar(var obj) { return (obj.bar)(); }
+
+  invokeThisBar() { return (this.bar)(); }
+
+  implicitStaticRef() { return foo; }
+}
+
+class B {
+  static foo() { return -1; }
+}
+
+class C {
+  C() { }
+  var f;
+}
+
+topLevel99() {
+  return 99;
+}
+
+var topFunc;
+
+class D extends A {
+  D(a): super(a) { }
+  getSuper() { return super.bar; }
+}
+
+class MethodBindingTest {
+  static test() {
+
+    // Create closure from global
+    Expect.equals(99, topLevel99());
+    Function f99 = topLevel99;
+    Expect.equals(99, f99());
+
+    // Invoke closure through a global
+    topFunc = f99;
+    Expect.equals(99, topFunc());   
+
+    // Create closure from static method
+    Function f4 = A.foo;
+    Expect.equals(4, f4());
+
+    // Create closure from instance method
+    var o5 = new A(5);
+    Function f5 = o5.bar;
+    Expect.equals(5, f5());
+
+    // Assign closure to field and invoke it
+    var c = new C();
+    c.f = () => "success";
+    Expect.equals("success", c.f());
+
+    // referencing instance method with explicit 'this' qualiier
+    var o6 = new A(6);
+    var f6 = o6.getThis();
+    Expect.equals(6, f6());
+
+    // referencing an instance method with no qualifier
+    var o7 = new A(7);
+    var f7 = o7.getNoThis();
+    Expect.equals(7, f7());
+
+    // bind a method that takes arguments
+    var o8 = new A(8);
+    Function f8 = o8.methodArgs;
+    Expect.equals(9, f8(1));
+
+    // Self referential method
+    var o9 = new A(9);
+    Function f9 = o9.selfReference;
+
+    // invoking a known method as if it were a bound closure...
+    var o10 = new A(10);
+    Expect.equals(10, o10.invokeBaz());
+
+    // invoking a known method as if it were a bound closure...
+    var o11 = new A(11);
+    Expect.equals(10, o11.invokeBar(o10));
+
+    // invoking a known method as if it were a bound closure...
+    var o12 = new A(12);
+    Expect.equals(12, o12.invokeThisBar());
+
+    // bind to a static variable with no explicit class qualifier
+    var o13 = new A(13);
+    Function f13 = o13.implicitStaticRef();
+    Expect.equals(4, f13());
+
+    var o14 = new D(14);
+    Function f14 = o14.getSuper();
+    Expect.equals(14, f14());
+
+    // Assign static field to a function and invoke it.
+    A.func = A.foo;
+    Expect.equals(4, A.func());
+
+    // bind a function that is possibly native in Javascript.
+    String o15 = 'hithere';
+    var f15 = o15.substring;
+    Expect.equals('i', f15(1, 2));
+
+    var o16 = 'hithere';
+    var f16 = o16.substring;
+    Expect.equals('i', f16(1, 2));
+
+    var f17 = 'hithere'.substring;
+    Expect.equals('i', f17(1, 2));
+  }
+
+  static testMain() {
+    test();
+  }
+}
+
+main() {
+  MethodBindingTest.testMain();
+}