Fix behavior when typed JS interop getters are called as functions.

tests/html/js_function_getter_test.dart

Index: tests/html/js_function_getter_test.dart
diff --git a/tests/html/js_function_getter_test.dart b/tests/html/js_function_getter_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..47cbdf0bf75a403bebd2d24536f363fbaf533a23
--- /dev/null
+++ b/tests/html/js_function_getter_test.dart
@@ -0,0 +1,130 @@
+// 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.
+
+@JS()
+library js_function_getter_test;
+
+import 'dart:html';
+
+import 'package:js/js.dart';
+import 'package:unittest/unittest.dart';
+import 'package:unittest/html_config.dart';
+import 'package:unittest/html_individual_config.dart';
+
+_injectJs() {
+  document.body.append(new ScriptElement()
+    ..type = 'text/javascript'
+    ..innerHtml = r"""
+  var bar = { };
+
+  bar.instanceMember = function() {
+    if (this !== bar) {
+      throw 'Unexpected this!';
+    }
+    return arguments.length;
+  };
+
+  bar.staticMember = function() {
+    return arguments.length * 2;
+  };
+
+  bar.dynamicStatic = function() {
+    return arguments.length;
+  };
+
+  bar.nonFunctionStatic = function() {
+    return arguments.length * 2;
+  };
+
+  bar.add = function(a, b) {
+    return a + b;
+  };
+
+  var foo = { 'bar' : bar };
+""");
+}
+
+typedef int AddFn(int x, int y);
+
+@JS()
+abstract class Bar {
+  external Function get staticMember;
+  external Function get instanceMember;
+  external AddFn get add;
+  external get dynamicStatic;
+  external num get nonFunctionStatic;
+}
+
+@JS()
+abstract class Foo {
+  external Bar get bar;
+}
+
+@JS()
+external Foo get foo;
+
+main() {
+  _injectJs();
+
+  useHtmlIndividualConfiguration();
+
+  group('call getter as function', () {
+    test('member function', () {
+      expect(foo.bar.instanceMember(), equals(0));
+      expect(foo.bar.instanceMember(0), equals(1));
+      expect(foo.bar.instanceMember(0,0), equals(2));
+      expect(foo.bar.instanceMember(0,0,0,0,0,0), equals(6));
+      var instanceMember = foo.bar.instanceMember;
+      expect(() => instanceMember(), throws);
+      expect(() => instanceMember(0), throws);
+      expect(() => instanceMember(0,0), throws);
+      expect(() => instanceMember(0,0,0,0,0,0), throws);
+    });
+
+    test('static function', () {
+      expect(foo.bar.staticMember(), equals(0));
+      expect(foo.bar.staticMember(0), equals(2));
+      expect(foo.bar.staticMember(0,0), equals(4));
+      expect(foo.bar.staticMember(0,0,0,0,0,0), equals(12));
+      var staticMember = foo.bar.staticMember;
+      expect(staticMember(), equals(0));
+      expect(staticMember(0), equals(2));
+      expect(staticMember(0,0), equals(4));
+      expect(staticMember(0,0,0,0,0,0), equals(12));
+    });
+
+    test('static dynamicStatic', () {
+      expect(foo.bar.dynamicStatic(), equals(0));
+      expect(foo.bar.dynamicStatic(0), equals(1));
+      expect(foo.bar.dynamicStatic(0,0), equals(2));
+      expect(foo.bar.dynamicStatic(0,0,0,0,0,0), equals(6));
+      var dynamicStatic = foo.bar.dynamicStatic;
+      expect(dynamicStatic(), equals(0));
+      expect(dynamicStatic(0), equals(1));
+      expect(dynamicStatic(0,0), equals(2));
+      expect(dynamicStatic(0,0,0,0,0,0), equals(6));
+    });
+
+    test('typedef function', () {
+      expect(foo.bar.add(4,5), equals(9));
+    });
+  });
+
+  // These tests only work with trust types enabled

[Siggi Cherem (dart-lang), 2015/10/30 20:14:57]

2 options: 
- always run this test with TT
- split the test in two, and make the expectation different when you have or
don't have the flag.

For either case, you'll need to make a test run with the flag on. You can do
that with the `//SharedOptions=` comment on your test file like here:
https://github.com/dart-lang/sdk/blob/e666436d05f64c12105b9bf0d19961f663824db...

(although you may need to disable the test for dartium in that case, not sure)

+  /*
+  group('trust types', () {
+    test('static nonFunctionStatic', () {
+      expect(() => foo.bar.nonFunctionStatic(), throws);
+      expect(() => foo.bar.nonFunctionStatic(0), throws);
+      expect(() => foo.bar.nonFunctionStatic(0,0), throws);
+      expect(() => foo.bar.nonFunctionStatic(0,0,0,0,0,0), throws);
+    });
+
+    test('typedef function', () {
+      expect(() => foo.bar.add(4), throws);
+      expect(() => foo.bar.add(4,5,10), throws);
+    });
+  });
+  */
+}