Update TODO to reflect all the new improvements

[mono.git] / mcs / mcs / TODO

diff --git a/mcs/mcs/TODO b/mcs/mcs/TODO
index caafabf90e88e40114fc11eabd7558cca4495047..3ba5a205382a30085b6ad872fcfa90fe2021be94 100644 (file)
--- a/mcs/mcs/TODO
+++ b/mcs/mcs/TODO
@@ -1,44 +1,40 @@
-BUGS
-----
+TODO:

 
 

-* While reworking the return system
+       1. Create a "partial" emit context for each TypeContainer..

 
 

-       I might have dropped a few features from EmitTopBlock return
-       code path.
+       2. EmitContext should be partially constructed.  No IL Generator.

 
 

-* Adding variables.
+       interface_type review.

 
 

-       We do add variables in a number of places, and this is erroneous:
+       parameter_array, line 952: `note: must be a single dimension array type'.  Validate this

 
 

-       void a (int b)
-       {
-               int b;
-       }
+Dead Code Elimination bugs:
+---------------------------

 
 

-       Also:
+       I should also resolve all the children expressions in Switch, Fixed, Using.

 
 

-       void a (int b)
-       {
-               foreach (int b ...)
-                       ;
-       }
+Major tasks:
+------------

 
 

-* Visibility
+       Pinned and volatile require type modifiers that can not be encoded
+       with Reflection.Emit.

 
 

-       I am not reporting errors on visibility yet.
+       Properties and 17.6.3: Finish it.
+
+       Implement base indexer access.
+
+readonly variables and ref/out
+       
+BUGS
+----

 
 

-* Interfaces
+* We suck at reporting what turns out to be error -6.  Use the standard error message
+  instead.

 
 

-       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:
+* Explicit indexer implementation is missing.

 
 

-       .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
 
 
 * Interface indexers
 


@@ -48,44 +44,6 @@ BUGS
        Explanation: The reason for the `instance' attribute on
        indexers is that indexers only apply to instances
 
        Explanation: The reason for the `instance' attribute on
        indexers is that indexers only apply to instances
 

-* Handle destructors specially
-
-       Turn ~X () { a () } into:
-       void Finalize () { try { a (); } finally { base.Finalize (); } }
-
-       The code is mostly done, but `base' is missing.  The reason it is 
-       missing is because we have to implement visibility first.
-
-* 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.
-
-* 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
 * Break/Continue statements
 
        A finally block should reset the InLoop/LoopBegin/LoopEnd, as


@@ -96,11 +54,21 @@ BUGS
        They should transfer control to the finally block if inside a try/catch
        block.
 
        They should transfer control to the finally block if inside a try/catch
        block.
 

-* Conversions and overflow
+* 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:

 
 

-       I am not using the checked state while doing type casts,
-       they should result in conv.ovf.XXX
+       extern string Property {
+               get { } 
+       }

 
 

+       The get there should only have a semicolon
+       

 *
 > // CSC sets beforefieldinit
 > class X {
 *
 > // CSC sets beforefieldinit
 > class X {


@@ -113,82 +81,85 @@ BUGS
 PENDING TASKS
 -------------
 
 PENDING TASKS
 -------------
 

-       * Implement explicit interface implemenation.
+* IMprove error handling here:

 
 

-       * Implement Goto.
+       public static Process ()

 
 

-       * Unsafe code.
+       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.

 
 

-       * Implement `base' (BaseAccess class)
+* Merge test 89 and test-34

 
 

-* OUT Variables passed as OUT variables.
+* Revisit

 
 

-       Currently we pass the pointer to the pointer (see expression.cs:Argument.Emit)
-
-* Function Declarations
+       Primary-expression, as it has now been split into 
+       non-array-creation-expression and array-creation-expression.
+               
+* Static flow analysis

 
 

-       Support PINvoke/Internallcall and extern declarated-functions.
+       Required to warn about reachability of code and definite
+       assignemt as well as missing returns on functions.

 
 

-* Manual field layout in structures
+* Code cleanup

 
 

-* Make the rules for inheritance/overriding apply to 
-  properties, operators and indexers (currently we only do this
-  on methods).
+       The information when registering a method in InternalParameters
+       is duplicated, you can always get the types from the InternalParameters

 
 

-* Handle volatile
+* Emit modreq for volatiles

 
 

-* Support Re-Throw exceptions:
+       Handle modreq from public apis.

 
 

-       try {
-               X ();
-       } catch (SomeException e){
-               LogIt ();
-               throw;
-       }
+* Emit `pinned' for pinned local variables.

 
 

-* Static flow analysis
+       Both `modreq' and pinned will require special hacks in the compiler.

 
 

-       Required to warn about reachability of code and definite
-       assignemt as well as missing returns on functions.
+* Make sure that we are pinning the right variable

 
 

-* Implement `goto case expr'
+* Maybe track event usage?  Currently I am not tracking these, although they
+  are fields.

 
 

+* Merge tree.cs, rootcontext.cs

 
 OPTIMIZATIONS
 -------------
 
 
 OPTIMIZATIONS
 -------------
 

-* Emitcontext
+* 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

 
 

-       Do we really need to instanciate this variable all the time?
+* Add test case for destructors

 
 

-       It could be static for all we care, and just use it for making
-       sure that there are no recursive invocations on it.
+* 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).

 
 

-* Static-ization
+* Dropping TypeContainer as an argument to EmitContext

 
 

-       Since AppDomain exists, maybe we can get rid of all the stuff
-       that is part of the `compiler instance' and just use globals
-       everywhere.
+       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).  

 
 

+       The only pending problem is that the code that implements Aliases
+       is on TypeContainer, and probably should go in DeclSpace.

 
 

-* Constructors
+* Casts need to trigger a name resolution against types only.

 
 

-       Currently it calls the parent constructor before initializing fields.
-       It should do it the other way around.
+       currently we use a secret hand shake, probably we should use
+       a differen path, and only expressions (memberaccess, simplename)
+       would participate in this protocol.

 
 

-* Reducer and -Literal
+* Use of local temporary in UnaryMutator

 
 

-       Maybe we should never handle -Literal in Unary expressions and let
-       the reducer take care of it always?
+       We should get rid of the Localtemporary there for some cases

 
 

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

 
 

-* Create an UnimplementedExpcetion
+       Do we really need to instanciate this variable all the time?

 
 

-       And use that instead of plain Exceptions to flag compiler errors.
+       It could be static for all we care, and just use it for making
+       sure that there are no recursive invocations on it.

 
 * ConvertImplicit
 
 
 * ConvertImplicit
 


@@ -202,11 +173,6 @@ OPTIMIZATIONS
        Write tests for the various reference conversions.  We have
        test for all the numeric conversions.
 
        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
 * Optimizations
 
        In Indexers and Properties, probably support an EmitWithDup


@@ -214,30 +180,30 @@ OPTIMIZATIONS
        in the stack, so that later a Store can be emitted using that
        this pointer (consider Property++ or Indexer++)
 
        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.
 
 
 * Add a cache for the various GetArrayMethod operations.
 

-* Use of temporary values in Assign
+* TypeManager.FindMembers:

 
 

-       We generate suboptimal code for assignments, as we always
-       store the result in a temporary.  
+       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.

 
 

-       When implenenting `using' on
+* MakeUnionSet Callers

 
 

-               using (a = new XXX)
+       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.

 
 

-       Two instances of XXX were created, we need to research this.
+* Factor all the FindMembers in all the FindMembers providers.
+
+* Factor the lookup code for class declarations an interfaces
+  (interface.cs:GetInterfaceByName)

 
 

-               //
-               // FIXME! We need a way to "probe" if the process can
-               // just use `dup' to propagate the result.
-               //
-               // I Think I figured this out, have EmitAssign take an
-               // argument: leave result on stack or not.  If true,
-               // then we can dup ahead of time if we know about this,
-               // and we get rid of the temporary value
-               // 
-  

 RECOMMENDATIONS
 ---------------
 
 RECOMMENDATIONS
 ---------------
 


@@ -265,16 +231,21 @@ RECOMMENDATIONS
        Not sure that this grammar is correct, we might have to
        resolve this during semantic analysis.
 
        Not sure that this grammar is correct, we might have to
        resolve this during semantic analysis.
 

+* Idea

 
 

-* Try/Catch
+       MethodGroupExpr

 
 

-       Investigate what is  the right value to return  from `Emit' in
-       there (ie, for the `all code paths return')
-       
+       These guys should only appear as part of an Invocation, so we
+       probably can afford to have a special callback:

 
 

-* Optimizations
+               Expression.ResolveAllowMemberGroups

 
 

-       Only create one `This' instance per class, and reuse it.
+       This is only called by Invocation (or anyone that consumes 
+       MethodGroupExprs)

 
 

-       Maybe keep a pool of constants/literals (zero, 1)?
+       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.