Improve error recovery, so as to show as many errors as possible
before aborting.

Support UTF-8 identifiers.  This includes deciding which subset of
UTF-8 characters are valid for such use, and how to map them to
languages that only support ASCII.

Implement multi-dimensional arrays.

Delegates.

Typedefs and aliases need to support complex types (e.g. typedef
int[] intarray;).  This ties into multi-dimensional arrays above;
at the very least, it needs to be possible to declare an array
of strings.

Be consistent in whether the specified name or the fully qualified
symbol name is reported in error messages.  The former makes it more
obvious which usage is referred to in certain cases; the latter makes
it obvious which symbol was found in lookup.  Adding column
information as well as line number would address the former concern.

Check for duplicate GUIDs.

Properties with automatic getters and setters (or just getters if
read-only), which can be overridden with custom getters and setters
in the class.

Methods can be specified as read-only; a read-only version of the
interface is then generated, and a secure read-only reference to an
object can be generated that can only access read-only methods.  This
would save effort declaring a separate interface and a separate
class, and would allow the read-write interface to use the read-only
methods without retreiving the read-only object.

Implement marshalling/unmarshalling stubs.

Implement async methods.

Implement remote-only async methods; these are async only when
invoked out-of-process, and sync (and thus faster) when invoked
in-process.  Full async methods would be used when the async
semantics are truly required; remote-only async methods would be used
where async isn't required, but the method is async-safe and would
benefit from the buffering of async out-of-process methods.  This
would reduce the number of methods that are declared in both sync and
async versions (and allow the choice between them to be made
dynamically).

Possibly implement out parameters on remote-only async methods that
can only be used when invoked as a sync in-process method; the method
implementation can check to see how it was invoked, and use the out
parameters to avoid having to make a completion callback.