* Emitcontext

	Do we really need to instanciate this variable all the time?

	It could be static for all we care, and just use it for making
	sure that there are no recursive invocations on it.

* Static-ization

	Since AppDomain exists, maybe we can get rid of all the stuff
	that is part of the `compiler instance' and just use globals
	everywhere.

* FindMembers

	Move our utility FindMembers from TypeContainer to Decl, because interfaces
	are also scanned with it.

* Visibility

	I am not reporting errors on visibility yet.

* Enumerations

	Currently I am not resolving enumerations.

	Either I track them with `RecordEnum' as I do with classes,
	structs and interfaces or I rewrite the code to visit type
	containers and `walk' the enums with this process. 

* Known problems:

  Cast expressions

	They should should use:

		OPEN_PARENS type CLOSE_PARENS

	instead of the current production which is wrong, because it
	only handles a few cases.

	Complex casts like:

		Array r = (string []) object

	Wont be parsed.
  
* Interfaces

	For indexers, the output of ix2.cs is different from our
	compiler and theirs.  They use a DefaultMemberAttribute, which
	I have yet to figure out:

	.class interface private abstract auto ansi INTERFACE
	{
		.custom instance void [mscorlib]System.Reflection.DefaultMemberAttribute::.ctor(string) 
		= ( 01 00 04 49 74 65 6D 00 00 )                      // ...Item..
		...
	}

* Interface indexers

	I have not figured out why the Microsoft version puts an
	`instance' attribute, and I am not generating this `instance' attribute.

	Explanation: The reason for the `instance' attribute on
	indexers is that indexers only apply to instances

* Constructors

	Currently it calls the parent constructor before initializing fields.
	It should do it the other way around.

* Use of EmitBranchable

	Currently I use brfalse/brtrue in the code for statements, instead of
	using the EmitBranchable function that lives in Binary

* Create an UnimplementedExpcetion

  	And use that instead of plain Exceptions to flag compiler errors.

* ConvertImplicit

	Currently ConvertImplicit will not catch things like:

	- IntLiteral in a float context to generate a -FloatLiteral.
	Instead it will perform an integer load followed by a conversion.

* In class.cs: Method.Define

	Need to use FindMembers to lookup the member for reporting
	whether a new is needed or not.  

* virtual-method.cs breaks

	It breaks on the call to: new B ();

	Where B is a class defined in the source code, my guess is that
	the look for ".ctor" fails

* Foreach on structure returns does not work

	I am generating invalid code instead of calling ldarga for the
	structure, I am calling ldarg:

	struct X {
		public IEnumerator GetEnumerator ();
	}

	X x;

	foreach (object a in x){
		...
	}

	I need to get the address of that bad boy

* Using Alias

	Need to reset the aliases for each compilation unit, so an
	alias defined in a file does not have any effect on another one:

	File.cs
	=======
	namespace A {
		using X = Blah;

		class Z : X {           <-- This X is `Blah' 
	}

	File2.cs
	namespace {
		class Y : X {		<-- This X Is not `Blah' 
		}
	}

	I think we can implement Aliases by having an `Alias' context in all
	the toplevel TypeContainers of a compilation unit.  The children typecontainers
	just chain to the parents to resolve the information.

	The driver advances the Alias for each file compiled, so that each file
	has its own alias set.

* Tests

	Write tests for the various reference conversions.  We have
	test for all the numeric conversions.

* Handle destructors specially

	Turn ~X () { a () } into:
	void Finalize () { try { a (); } finally { base.Finalize (); } }

* Handle volatile

* Support Re-Throw exceptions:

	try {
		X ();
	} catch (SomeException e){
		LogIt ();
		throw;
	}

* Remove the tree dumper

	And make all the stuff which is `public readonly' be private unless
	required.

* Use of lexer.Location in the parser

	Currently we do:

	TOKEN nt TERMINAL nt TERMINAL nt3 {
		$$ = new Blah ($2, $4, $6, lexer.Location);
	}

	This is bad, because the lexer.Location is for the last item in `nt3'

	We need to change that to use this pattern:

	TOKEN { $$ = lexer.Location } nt TERMINAL nt TERMINAL nt3 {
		$$ = new Blah ($3, $5, $7, (Location) $2);
	}

	Notice how numbering of the arguments changes, as the { $$ =
	lexer.Location } takes up a number

* Method Names

	Method names could be; `IFACE.NAME' in the method declaration,
	stating that they implement a specific interface method.

	We currently fail to parse it.

* Namespaces

	Apparently:

		namespace X {
		}

		namespace X {
		}

	Is failing to create a single namespace

* Arrays

	We need to make sure at *compile time* that the arguments in
	the expression list of an array creation are always positive.

* Fix the new parameter mess that we introduced to support ref/outo

* Reducer and -Literal

	Maybe we should never handle -Literal in Unary expressions and let
	the reducer take care of it always?

* Implement dead code elimination in statement.cs

	It is pretty simple to implement dead code elimination in 
	if/do/while

* Implement short circuit evaluation.

	Currently our and/or operations do not implement short circuit
	evaluation.  

* Foreach and arrays

	Support foreach (T t in Array)

	And optimize to deal with the array rather than getting the enumerator
	out of it.

* Indexer bugs:

	the following wont work:

	x [0] = x [1] = N

	if x has indexers, the value of x [N] set is set to void.  This needs to be
	fixed.

* Preincrement/pre-decrement is not working on array elements. 

	We are catching this now.  But it does not work.

* local_variable_declaration

	Not sure that this grammar is correct, we might have to
	resolve this during semantic analysis.