Reorganize tests and benchmark scripts.

Mainly to get rid of one top level directory. But this will
also be useful when there are tests of the embedding API.

test/language/field/closure.wren

@@ -0,0 +1,16 @@
+class Foo {
+  new { _field = "Foo field" }
+
+  closeOverGet {
+    return new Fn { _field }
+  }
+
+  closeOverSet {
+    return new Fn { _field = "new value" }
+  }
+}
+
+var foo = new Foo
+IO.print(foo.closeOverGet.call()) // expect: Foo field
+foo.closeOverSet.call()
+IO.print(foo.closeOverGet.call()) // expect: new value

test/language/field/default_to_null.wren

@@ -0,0 +1,5 @@
+class Foo {
+  write { IO.print(_field) }
+}
+
+(new Foo).write // expect: null

test/language/field/in_fn_in_static_method.wren

@@ -0,0 +1,5 @@
+class Foo {
+  static bar {
+    new Fn { _field = "wat" } // expect error
+  }
+}

test/language/field/in_static_method.wren

@@ -0,0 +1,5 @@
+class Foo {
+  static bar {
+    _field = "wat" // expect error
+  }
+}

test/language/field/in_static_method_in_nested_class.wren

@@ -0,0 +1,14 @@
+// Refering to an instance method in a nested static class should *not* walk
+// out to find the nearest enclosing instance method. We could make that work,
+// but it's confusing to users, and would require some tricky work to make sure
+// the enclosing instance is closed over.
+
+class Outer {
+  foo {
+    class Inner {
+      static bar {
+        _field = "nope" // expect error
+      }
+    }
+  }
+}

test/language/field/multiple.wren

@@ -0,0 +1,26 @@
+class Foo {
+  set(a, b, c, d, e) {
+    _a = a
+    _b = b
+    _c = c
+    _d = d
+    _e = e
+  }
+
+  write {
+    IO.print(_a)
+    IO.print(_b)
+    IO.print(_c)
+    IO.print(_d)
+    IO.print(_e)
+  }
+}
+
+var foo = new Foo
+foo.set(1, 2, 3, 4, 5)
+foo.write
+// expect: 1
+// expect: 2
+// expect: 3
+// expect: 4
+// expect: 5

test/language/field/nested_class.wren

@@ -0,0 +1,18 @@
+class Outer {
+  method {
+    _field = "outer"
+    IO.print(_field) // expect: outer
+
+    class Inner {
+      method {
+        _field = "inner"
+        IO.print(_field) // expect: inner
+      }
+    }
+
+    (new Inner).method
+    IO.print(_field) // expect: outer
+  }
+}
+
+(new Outer).method

test/language/field/object_reference.wren

@@ -0,0 +1,37 @@
+// This test exists mainly to make sure the GC traces instance fields.
+class Node {
+  set(left, value, right) {
+    _left = left
+    _value = value
+    _right = right
+  }
+
+  write {
+    if (_left is Node) {
+      _left.write
+    }
+
+    IO.print(_value)
+
+    if (_right is Node) {
+      _right.write
+    }
+  }
+}
+
+var a = new Node
+a.set(null, "a", null)
+var b = new Node
+b.set(null, "b", null)
+var c = new Node
+c.set(a, "c", b)
+a = null
+b = null
+var d = new Node
+d.set(c, "d", null)
+c = null
+d.write
+// expect: a
+// expect: c
+// expect: b
+// expect: d

test/language/field/outside_class.wren

@@ -0,0 +1 @@
+_field = "wat" // expect error

test/language/field/use_before_set.wren

@@ -0,0 +1,9 @@
+class Foo {
+  write { IO.print(_field) } // Compile a use of the field...
+  init { _field = "value" }  // ...before an assignment to it.
+}
+
+var foo = new Foo
+// But invoke them in the right order.
+foo.init
+foo.write // expect: value