Allow "@method()" syntax for explicit self sends, like CoffeeScript.

test/language/constructor/no_parameter_list.wren

@@ -1,5 +1,5 @@
 class Foo {
-  this new { // expect error
+  construct new { // expect error
     System.print("ok")
   }
 }

test/language/self_call/ignores_locals.wren

@@ -0,0 +1,12 @@
+class Foo {
+  construct new() {}
+
+  bar { "getter" }
+
+  test() {
+    var bar = "local"
+    System.print(@bar) // expect: getter
+  }
+}
+
+Foo.new().test()

test/language/self_call/in_closure.wren

@@ -0,0 +1,13 @@
+class Foo {
+  construct new(field) {
+    _field = field
+  }
+
+  method() {
+    System.print(_field)
+  }
+
+  makeClosure() { Fn.new { @method() } }
+}
+
+Foo.new("value").makeClosure().call() // expect: value

test/language/self_call/inherited_methods.wren

@@ -0,0 +1,27 @@
+class Foo {
+  construct new() {}
+
+  getter {
+    System.print("getter")
+  }
+
+  setter=(value) {
+    System.print("setter")
+  }
+
+  method(a) {
+    System.print("method")
+  }
+}
+
+class Bar is Foo {
+  construct new() {}
+
+  test() {
+    @getter            // expect: getter
+    @setter = "value"  // expect: setter
+    @method("arg")     // expect: method
+  }
+}
+
+Bar.new().test()

test/language/self_call/instance_methods.wren

@@ -0,0 +1,25 @@
+class Foo {
+  construct new() {}
+
+  getter {
+    System.print("getter")
+  }
+
+  setter=(value) {
+    System.print("setter")
+  }
+
+  method(a) {
+    System.print("method")
+  }
+
+  test() {
+    @getter            // expect: getter
+    @setter = "value"  // expect: setter
+    @method("arg")     // expect: method
+  }
+}
+
+Foo.new().test()
+
+// TODO: Operators.

test/language/self_call/nested_class.wren

@@ -0,0 +1,51 @@
+class Outer {
+  construct new() {}
+
+  getter {
+    System.print("outer getter")
+  }
+
+  setter=(value) {
+    System.print("outer setter")
+  }
+
+  method(a) {
+    System.print("outer method")
+  }
+
+  test() {
+    @getter            // expect: outer getter
+    @setter = "value"  // expect: outer setter
+    @method("arg")     // expect: outer method
+
+    class Inner {
+      construct new() {}
+
+      getter {
+        System.print("inner getter")
+      }
+
+      setter=(value) {
+        System.print("inner setter")
+      }
+
+      method(a) {
+        System.print("inner method")
+      }
+
+      test() {
+        @getter            // expect: inner getter
+        @setter = "value"  // expect: inner setter
+        @method("arg")     // expect: inner method
+      }
+    }
+
+    Inner.new().test()
+
+    @getter            // expect: outer getter
+    @setter = "value"  // expect: outer setter
+    @method("arg")     // expect: outer method
+  }
+}
+
+Outer.new().test()

test/language/self_call/outside_class.wren

@@ -0,0 +1 @@
+@method() // expect error

test/language/self_call/static_methods.wren

@@ -0,0 +1,21 @@
+class Foo {
+  static getter {
+    System.print("getter")
+  }
+
+  static setter=(value) {
+    System.print("setter")
+  }
+
+  static method(a) {
+    System.print("method")
+  }
+
+  static test() {
+    @getter            // expect: getter
+    @setter = "value"  // expect: setter
+    @method("arg")     // expect: method
+  }
+}
+
+Foo.test()

test/language/this/closure.wren

@@ -1,8 +1,8 @@
 class Foo {
   construct new() {}
-  getClosure { Fn.new { toString } }
+  getClosure() { Fn.new { toString } }
   toString { "Foo" }
 }
 
-var closure = Foo.new().getClosure
+var closure = Foo.new().getClosure()
 System.print(closure.call()) // expect: Foo