Major tasks: ------------ Pinned and volatile require type modifiers that can not be encoded with Reflection.Emit. Properties and 17.6.3: Finish it. Implement base indexer access. MethodGroupExpr These guys should only appear as part of an Invocation, so we probably can afford to have a special callback: Expression.ResolveAllowMemberGroups This is only called by Invocation (or anyone that consumes MethodGroupExprs) And the regular DoResolve and DoResolveLValue do emit the error 654 `Method referenced without argument list'. Otherwise, a resolution will return a MethodGroupExpr which is not guaranteed to have set its `Expression.Type' to a non-null value. readonly variables and ref/out BUGS ---- * Check for Final when overriding, if the parent is Final, then we cant allow an override. * Add test case for destructors * Do not declare a .property on things that are just implementations, that comes from the parent, just do the method. * Currently the code path for 108/109 reporting is not being ran for methods as we need to compare method signatures. But since we retrieve the expensive method arguments in the method, we probably should do 108/109 processing there. * Emit warning on hiding members without NEW not only in members. * Implement visibility. * Adding variables. We do add variables in a number of places, and this is erroneous: void a (int b) { int b; } Also: void a (int b) { foreach (int b ...) ; } * Visibility I am not reporting errors on visibility yet. * 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 * Arrays We need to make sure at *compile time* that the arguments in the expression list of an array creation are always positive. * Implement dead code elimination in statement.cs It is pretty simple to implement dead code elimination in if/do/while * 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. * Array declarations Multi-dim arrays are declared as [,] instead of [0..,0..] * Break/Continue statements A finally block should reset the InLoop/LoopBegin/LoopEnd, as they are logically outside the scope of the loop. * Break/continue part 2. They should transfer control to the finally block if inside a try/catch block. * Method Registration and error CS111 The way we use the method registration to signal 111 is wrong. Method registration should only be used to register methodbuilders, we need an alternate method of checking for duplicates. * We need to catch: extern string Property { get { } } The get there should only have a semicolon * > // CSC sets beforefieldinit > class X { > // .cctor will be generated by compiler > public static readonly object O = new System.Object (); > public static void Main () {} > } > PENDING TASKS ------------- * Constant Folding Constant Folding does not take into account Enumerations, we should maybe extract the underlying value, and constant fold on it. * Revisit Primary-expression, as it has now been split into non-array-creation-expression and array-creation-expression. * Static flow analysis Required to warn about reachability of code and definite assignemt as well as missing returns on functions. * Code cleanup The information when registering a method in InternalParameters is duplicated, you can always get the types from the InternalParameters * Emit modreq for volatiles Handle modreq from public apis. * Emit `pinned' for pinned local variables. Both `modreq' and pinned will require special hacks in the compiler. * Make sure that we are pinning the right variable OPTIMIZATIONS ------------- * Use of local temporary in UnaryMutator We should get rid of the Localtemporary there for some cases * 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. * 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 * 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. * Tests Write tests for the various reference conversions. We have test for all the numeric conversions. * Remove the tree dumper, cleanup `public readonly' And make all the stuff which is `public readonly' be private unless required. * Optimizations In Indexers and Properties, probably support an EmitWithDup That emits the code to call Get and then leaves a this pointer in the stack, so that later a Store can be emitted using that this pointer (consider Property++ or Indexer++) * Optimizations: variable allocation. When local variables of a type are required, we should request the variable and later release it when we are done, so that the same local variable slot can be reused later on. * Add a cache for the various GetArrayMethod operations. * Optimization: Do not use StatementCollections, use ArrayLists of Statements, and then "copy" it out to arrays. Then reuse the existing Statement structures. * TypeManager.FindMembers: Instead of having hundreds of builder_to_blah hash table, have a single one that maps a TypeBuilder `t' to a set of classes that implement an interface that supports FindMembers. * MakeUnionSet Callers If the types are the same, there is no need to compute the unionset, we can just use the list from one of the types. RECOMMENDATIONS --------------- * 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 { oob_stack.Push (lexer.Location) } nt TERMINAL nt TERMINAL nt3 { $$ = new Blah ($3, $5, $7, (Location) oob_stack.Pop ()); } Notice how numbering of the arguments changes as the { oob_stack.Push (lexer.Location) } takes a "slot" in the productions. * local_variable_declaration Not sure that this grammar is correct, we might have to resolve this during semantic analysis. * Try/Catch Investigate what is the right value to return from `Emit' in there (ie, for the `all code paths return') * Optimizations Only create one `This' instance per class, and reuse it. Maybe keep a pool of constants/literals (zero, 1)? ************ Potential bug: We would need to decode the shortname before we lookup members? Maybe not. interface I { void A (); } class X : I { void I.A (); } class Y : X, I { void I.A () {} } *************