Rename class to constructor, add dotted class

In an effort to come back into line with the language design, and given
that the existing 'classes' were not really classes, the 'dotted class'
syntax has been added to the language as sugar for a single-method
object. The old class syntax is now available with the 'constructor'
keyword, and the tests have been updated accordingly.
Move internal error handling into report method

It was possible for a JavaScript error to make it into the error
reporting method in the interpreter. Now one custom use of the internal
error handler has been removed, and the error reporter handles all
internal errors itself.
Strip leading whitespace from the lexer

The dialect and import keywords weren't capable of dealing with leading
whitespace in the input. The parser now removes all whitespace from the
lexer at the start to avoid this issue.
Make boolean literals self-delimiting

Boolean literals no longer require parentheses when they are the only
argument to a method part. The generic request parsing has been updated
to reflect this, and also to avoid generic requests failing in the
return type of a method that has annotations.
Allow modules in a dialect to export definitions

Using a dialect in a module was causing the module to not export any
definitions. Now the scoping of the dialect takes into account the
presence of a module and places it above the module scope.
Add a missing call in the inequality method

The inequality operator was returning the 'prefix!' method rather than
calling it. Now it is properly invoked, and the result is checked to
ensure that it is a boolean.
Update runtime part and inheritance definitions

A variable part count to a method creation wasn't being processed
correctly when it was the only part information. The newClass helper in
the runtime was also using an outdated semantics for inherits.
Handle internal errors after a request

The update to the report method didn't take into account that there is a
separate reporting mechanism for requests. The request reporting now
also handles internal errors and will also check to see if there is
anything in the stack trace before attempting to modify it.
Correct hoisting behaviour to only evaluate once

The variable hoisting method was not checking if the variable was being
hoisted before evaluating it, which was causing it to be evaluated
twice. Now it is not evaluated during the hoisting phase.
Ensure that inherit is also a valid Grace method

The inheritance method that was generated by the interpreter was just a
regular function, which confused that part inspector of the runtime. Now
the interpreter generates a runtime method with the same parts as the
original method.
Fold comments into preceding newlines

Comments broke up the new line folding and produced more than one new
line at a time. Now the newline folding has been tidied up and can
account for comments. The leading character of a comment is no longer
temporarily lexed as a symbol when the second character is present.
Allow error writing to process non-Grace objects

The toString helper in bin/write assumed that its argument was a Grace
object, but it was being passed objects such as strings as well. Now it
checks to see if its argument is a Grace object and performs a normal
toString if it is not.
Rewrite variables to better understand inheritance

Variables were fickle in the presence of inheritance. They are now
hoisted and maintain a super reference in the same way as methods, but
raise an undefined error if they are touched in any way until the
lowest-most field has actually been encountered in the initialisation
code, including assignment. The latter case is achieved by hot-swapping
the variable's pattern from one that raises the desired error to the
real pattern.

Searching for definitions in scope now searches in self before searching
locally when it reaches the scope where self is defined. Searching in
self can be entirely disabled, however.
Compare pretty method names when validating super

The test that two methods had the same name when validating a super call
was comparing a pretty name to an uglified name. Now the two pretty
forms are compared.
Reprocess indentation after block parameters

Previously indentation could only occur after an opening brace, which
resulted in parameters preventing a block from gaining an indent. Now
the indentation process is run again after block parameters.
Additionally, the indentation is not required to be greater after an
opening brace, allowing more flexible layouts with parameters.
Run dialect and imports before hoisting anything

The dialect and imports were being run after hoisted code. Now they are
run first, before type declarations.
Adjust signature lookahead to include operators

The lookahead on signatures only tested for identifiers, which prevented
operators from appearing in types. Now the lookahead will test for
either an identifier or an operator. The branching for parsing various
types of signatures has also been tidied up, and a test for an
assignment method has been added.
Standardise method creation names in runtime

The methods 'newMethod' and 'newClass' did not match with the standard
for names set by the rest of the methods in the runtime. They have been
renamed to 'method' and 'constructor'.
Allow inheritance of booleans

The methods that return true and false now have companion inheritance
methods that allow objects to inherit from them.
Add at() and size methods to string

There was no way to retrieve characters or the size of a string without
using the primitive interface. The at() and size methods almost brings
strings in line with the list type sans doForEach(), but this will soon
be moved into the prelude. A hidden bug where a block was returning
undefined instead of done in the list implementation has also been
resolved.