Committing Miguel's type lookup patch.
[mono.git] / mcs / mcs / TODO
index 68634b6e0f52c7b471c85b4b15357360f50bba66..31311aef1af00413f7a999b701377ab65d9fe8f5 100644 (file)
@@ -1,62 +1,43 @@
-* 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.
+TODO:
 
-* Static-ization
+       1. Create a "partial" emit context for each TypeContainer..
 
-       Since AppDomain exists, maybe we can get rid of all the stuff
-       that is part of the `compiler instance' and just use globals
-       everywhere.
+       2. EmitContext should be partially constructed.  No IL Generator.
 
-* FindMembers
+       Optimize the internal type expressions in the parser (system_object, etc)
+       to be something other than DecomposeQI-based expressions.
 
-       Move our utility FindMembers from TypeContainer to Decl, because interfaces
-       are also scanned with it.
+       interface_type review.
 
-* Visibility
+       parameter_array, line 952: `note: must be a single dimension array type'.  Validate this
 
-       I am not reporting errors on visibility yet.
+Dead Code Elimination bugs:
+---------------------------
 
-* Enumerations
+       I should also resolve all the children expressions in Switch, Fixed, Using.
 
-       Currently I am not resolving enumerations.
+Major tasks:
+------------
 
-       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. 
+       Pinned and volatile require type modifiers that can not be encoded
+       with Reflection.Emit.
 
-* Known problems:
+       Properties and 17.6.3: Finish it.
 
-  Cast expressions
+       Implement base indexer access.
 
-       They should should use:
+readonly variables and ref/out
+       
+BUGS
+----
 
-               OPEN_PARENS type CLOSE_PARENS
+* We suck at reporting what turns out to be error -6.  Use the standard error message
+  instead.
 
-       instead of the current production which is wrong, because it
-       only handles a few cases.
+* Explicit indexer implementation is missing.
 
-       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..
-               ...
-       }
+* Check for Final when overriding, if the parent is Final, then we cant
+  allow an override.
 
 * Interface indexers
 
        Explanation: The reason for the `instance' attribute on
        indexers is that indexers only apply to instances
 
-* Constructors
+* Indexer bugs:
 
-       Currently it calls the parent constructor before initializing fields.
-       It should do it the other way around.
+       the following wont work:
 
-* Use of EmitBranchable
+       x [0] = x [1] = N
 
-       Currently I use brfalse/brtrue in the code for statements, instead of
-       using the EmitBranchable function that lives in Binary
+       if x has indexers, the value of x [N] set is set to void.  This needs to be
+       fixed.
 
-* Create an UnimplementedExpcetion
+* Array declarations
 
-       And use that instead of plain Exceptions to flag compiler errors.
+       Multi-dim arrays are declared as [,] instead of [0..,0..]
 
-* ConvertImplicit
+* Break/Continue statements
 
-       Currently ConvertImplicit will not catch things like:
+       A finally block should reset the InLoop/LoopBegin/LoopEnd, as
+       they are logically outside the scope of the loop.
 
-       - IntLiteral in a float context to generate a -FloatLiteral.
-       Instead it will perform an integer load followed by a conversion.
+* Break/continue part 2.
 
-* In class.cs: Method.Define
+       They should transfer control to the finally block if inside a try/catch
+       block.
 
-       Need to use FindMembers to lookup the member for reporting
-       whether a new is needed or not.  
+* Method Registration and error CS111
 
-* virtual-method.cs breaks
+       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.
 
-       It breaks on the call to: new B ();
+* We need to catch:
 
-       Where B is a class defined in the source code, my guess is that
-       the look for ".ctor" fails
+       extern string Property {
+               get { } 
+       }
 
-* Foreach on structure returns does not work
+       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 () {}
+> }
+> 
 
-       I am generating invalid code instead of calling ldarga for the
-       structure, I am calling ldarg:
+PENDING TASKS
+-------------
 
-       struct X {
-               public IEnumerator GetEnumerator ();
-       }
+* IMprove error handling here:
 
-       X x;
+       public static Process ()
 
-       foreach (object a in x){
-               ...
-       }
+       THat assumes that it is a constructor, check if its the same name
+       as the class, if not report a different error than the one we use now.
 
-       I need to get the address of that bad boy
+* Merge test 89 and test-34
 
-* Using Alias
+* Revisit
 
-       Need to reset the aliases for each compilation unit, so an
-       alias defined in a file does not have any effect on another one:
+       Primary-expression, as it has now been split into 
+       non-array-creation-expression and array-creation-expression.
+               
+* Static flow analysis
 
-       File.cs
-       =======
-       namespace A {
-               using X = Blah;
+       Required to warn about reachability of code and definite
+       assignemt as well as missing returns on functions.
 
-               class Z : X {           <-- This X is `Blah' 
-       }
+* Code cleanup
 
-       File2.cs
-       namespace {
-               class Y : X {           <-- This X Is not `Blah' 
-               }
-       }
+       The information when registering a method in InternalParameters
+       is duplicated, you can always get the types from the InternalParameters
 
-       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.
+* Emit modreq for volatiles
 
-       The driver advances the Alias for each file compiled, so that each file
-       has its own alias set.
+       Handle modreq from public apis.
 
-* Tests
+* Emit `pinned' for pinned local variables.
 
-       Write tests for the various reference conversions.  We have
-       test for all the numeric conversions.
+       Both `modreq' and pinned will require special hacks in the compiler.
 
-* Handle destructors specially
+* Make sure that we are pinning the right variable
 
-       Turn ~X () { a () } into:
-       void Finalize () { try { a (); } finally { base.Finalize (); } }
+* Maybe track event usage?  Currently I am not tracking these, although they
+  are fields.
 
-* Handle volatile
+* Merge tree.cs, rootcontext.cs
 
-* Support Re-Throw exceptions:
+OPTIMIZATIONS
+-------------
 
-       try {
-               X ();
-       } catch (SomeException e){
-               LogIt ();
-               throw;
-       }
+* Implement loop inversion for `For' as well.
 
-* Remove the tree dumper
+* There is too much unshared code between MemberAccess.Resolve and SimpleName
+  resolve.  
+* User Defined Conversions is doing way too many calls to do union sets that are not needed
 
-       And make all the stuff which is `public readonly' be private unless
-       required.
+* Add test case for destructors
 
-* Use of lexer.Location in the parser
+* Places that use `Ldelema' are basically places where I will be
+  initializing a value type.  I could apply an optimization to 
+  disable the implicit local temporary from being created (by using
+  the method in New).
 
-       Currently we do:
+* Dropping TypeContainer as an argument to EmitContext
 
-       TOKEN nt TERMINAL nt TERMINAL nt3 {
-               $$ = new Blah ($2, $4, $6, lexer.Location);
-       }
+       My theory is that I can get rid of the TypeBuilder completely from
+       the EmitContext, and have typecasts where it is used (from
+       DeclSpace to where it matters).  
 
-       This is bad, because the lexer.Location is for the last item in `nt3'
+       The only pending problem is that the code that implements Aliases
+       is on TypeContainer, and probably should go in DeclSpace.
 
-       We need to change that to use this pattern:
+* Casts need to trigger a name resolution against types only.
 
-       TOKEN { $$ = lexer.Location } nt TERMINAL nt TERMINAL nt3 {
-               $$ = new Blah ($3, $5, $7, (Location) $2);
-       }
+       currently we use a secret hand shake, probably we should use
+       a differen path, and only expressions (memberaccess, simplename)
+       would participate in this protocol.
+
+* Use of local temporary in UnaryMutator
+
+       We should get rid of the Localtemporary there for some cases
+
+* Emitcontext
 
-       Notice how numbering of the arguments changes, as the { $$ =
-       lexer.Location } takes up a number
+       Do we really need to instanciate this variable all the time?
 
-* Method Names
+       It could be static for all we care, and just use it for making
+       sure that there are no recursive invocations on it.
 
-       Method names could be; `IFACE.NAME' in the method declaration,
-       stating that they implement a specific interface method.
+* Use of EmitBranchable
 
-       We currently fail to parse it.
+       Currently I use brfalse/brtrue in the code for statements, instead of
+       using the EmitBranchable function that lives in Binary
 
-* Namespaces
+* ConvertImplicit
 
-       Apparently:
+       Currently ConvertImplicit will not catch things like:
 
-               namespace X {
-               }
+       - IntLiteral in a float context to generate a -FloatLiteral.
+       Instead it will perform an integer load followed by a conversion.
 
-               namespace X {
-               }
+* Tests
 
-       Is failing to create a single namespace
+       Write tests for the various reference conversions.  We have
+       test for all the numeric conversions.
 
-* Arrays
+* Optimizations
 
-       We need to make sure at *compile time* that the arguments in
-       the expression list of an array creation are always positive.
+       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++)
 
-* Fix the new parameter mess that we introduced to support ref/outo
+* Optimizations: variable allocation.
 
-* Reducer and -Literal
+       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.
 
-       Maybe we should never handle -Literal in Unary expressions and let
-       the reducer take care of it always?
+* Add a cache for the various GetArrayMethod operations.
 
-* Implement dead code elimination in statement.cs
+* TypeManager.FindMembers:
 
-       It is pretty simple to implement dead code elimination in 
-       if/do/while
+       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.
 
-* Implement short circuit evaluation.
+* MakeUnionSet Callers
 
-       Currently our and/or operations do not implement short circuit
-       evaluation.  
+       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.
 
-* Foreach and arrays
+* Factor all the FindMembers in all the FindMembers providers.
 
-       Support foreach (T t in Array)
+* Factor the lookup code for class declarations an interfaces
+  (interface.cs:GetInterfaceByName)
 
-       And optimize to deal with the array rather than getting the enumerator
-       out of it.
+RECOMMENDATIONS
+---------------
 
-* Indexer bugs:
+* Use of lexer.Location in the parser
 
-       the following wont work:
+       Currently we do:
 
-       x [0] = x [1] = N
+       TOKEN nt TERMINAL nt TERMINAL nt3 {
+               $$ = new Blah ($2, $4, $6, lexer.Location);
+       }
 
-       if x has indexers, the value of x [N] set is set to void.  This needs to be
-       fixed.
+       This is bad, because the lexer.Location is for the last item in `nt3'
 
-* Preincrement/pre-decrement is not working on array elements. 
+       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 ());
+       }
 
-       We are catching this now.  But it does not work.
+       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.
 
-* Optimizations
+* Idea
 
-       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++)
+       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.