Add some new classes/enums/delegates for 2.0 and some new CAS unit tests

[mono.git] / mcs / mcs / TODO

diff --git a/mcs/mcs/TODO b/mcs/mcs/TODO
index ffd84a2154da679706605522b1ec8484b7605c7a..3545196fc9266498142c7c420ab9ec202c1ccc9d 100644 (file)
--- a/mcs/mcs/TODO
+++ b/mcs/mcs/TODO
@@ -1,102 +1,166 @@
-Major tasks:
-------------
+* Value Parameter

 
 

-       Apply the method verification process to indexers and properties as well.
+       I believe that `Value Parameter' might have been introduced
+       after C# 1.0, also notice than in the treatment of Value Parameter
+       the parameters are defined in four categories:

 
 

-       Properties and 17.6.3: Finish it.
+       Section 9.3 in the latest spec.

 
 

-       Finish pre-processor (and, or and nested expressions not yet supported).

 
 

-BUGS
-----
+* Review
+--------
+
+       Reference type equality operators (15.9.6) introduced
+       operator == (C x, C y) where C is a reference type.
+
+       Our compiler used:
+
+       operator == (object a, object b)
+
+       Review our implementation.
+
+New
+---
+
+       It would be nice to optimize the case of:
+
+               Method (new ValueType ())
+
+       So that no temporary is created, and we only use a newobj call
+       that remains on the stack, as opposed to ldloca, initobj, ldloc
+       call.
+
+NEW NOTES:
+----------
+
+       ImplicitStandardConversionExists and ImplicitStandardConversion
+       should always be the same, but there are a few diverging lines that
+       must be studied:
+
+                       if (expr_type == target_type && !(expr is NullLiteral))
+                               return expr;
+
+       vs:
+
+                       if (expr_type == target_type)
+                               return true;
+
+
+Null Type
+---------

 
 

-* Major bug:
+       Need to introduce the NullType concept into the compiler, to address a 
+       few small buglets and remove the hardcoded values for NullLiteral.

 
 

-       Since I added the support for the dual interpreatation of names, I dont
-       catch this error:
+       NullLiteral will be the only expression that has the NullType as its type.

 
 

-       class X { int i;  static void a () { i = 1; } }
+       This is what must be used to test for Null literals, instead of `is NullLiteral',
+       and this will introduce a couple of fixes to the rules.

 
 

-* 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.
+       Revert Martin's patch to Conditional expression that worked around this bug:

 
 

-* Emit warning on hiding members without NEW not only in members.
+               Reference r = xx ? null : null

 
 

-* Implement visibility.
+       The right fix is to introduce NullType
+
+****************************************************************************************
+* 
+*   The information on the rest of this file is mostly outdated, and its kept here for
+*   historical reasons
+*
+****************************************************************************************

  
  

-* Adding variables.
+Error Reporting:
+----------------

 
 

-       We do add variables in a number of places, and this is erroneous:
+       * Make yyerror show a nice syntax error, instead of the current mess.

 
 

-       void a (int b)
-       {
-               int b;
-       }
+Iterators
+---------
+       * Reset should throw not implemented now.

 
 

-       Also:
+Optimization ideas
+------------------

 
 

-       void a (int b)
-       {
-               foreach (int b ...)
-                       ;
-       }
+       Currently when we build a type cache, it contains private members,
+       internal members, and internal protected members;   We should trim
+       these out, as it shows up on the profile.
+
+       We create too many Arraylists;  When we know the size, we should create
+       an array;

 
 

-* Visibility
+       During parsing we use arraylists to accumulate data, like this:

 
 

-       I am not reporting errors on visibility yet.
+               thing:
+               
+               thing_list
+                       : thing { $$ =new ArrayList (); $$.Add ($1); }
+                       | thing_list thing { ArrayList a = $1; a.Add ($2); $$ = a; }

 
 

-* Interfaces
+       We probably could start using "Pairs" there:

 
 

-       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:
+               thing_list
+                       : thing { $$ = new Pair ($1, null); }
+                       | thing_list thing { Pair p = $1; $$ = new Pair ($2, $1); }

 
 

-       .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
+EmitContext.ResolveTypeTree
+---------------------------
+
+       We should investigate its usage.  The problem is that by default
+       this will be set when calling FindType, that triggers a more expensive
+       lookup.

 
 

-       I have not figured out why the Microsoft version puts an
-       `instance' attribute, and I am not generating this `instance' attribute.
+       I believe we should pass the current EmitContext (which has this turned off
+       by default) to ResolveType/REsolveTypeExpr and then have the routines that
+       need ResolveType to pass null as the emit context.

 
 

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

 
 

-* Handle destructors specially
+       DeclareLocal is used in various statements.  The audit should be done
+       in two steps:

 
 

-       Turn ~X () { a () } into:
-       void Finalize () { try { a (); } finally { base.Finalize (); } }
+               * Identify all the declare locals.

 
 

-       The code is mostly done, but `base' is missing.  The reason it is 
-       missing is because we have to implement visibility first.
+               * Identify its uses.

 
 

-* Arrays
+               * Find if we can make wrapper functions for all of them.

 
 

-       We need to make sure at *compile time* that the arguments in
-       the expression list of an array creation are always positive.
+       Then we can move DeclareLocal into a helper class.

 
 

-* Implement dead code elimination in statement.cs
+       This is required to fix foreach in iterators.

 
 

-       It is pretty simple to implement dead code elimination in 
-       if/do/while
+Large project:
+--------------

 
 

-* Indexer bugs:
+       Drop FindMembers as our API and instead extract all the data
+       out of a type the first time into our own datastructures, and
+       use that to navigate and search the type instead of the
+       callback based FindMembers.     

 
 

-       the following wont work:
+       Martin has some some of this work with his TypeHandle code
+       that we could use for this.

 
 

-       x [0] = x [1] = N
+Ideas:
+------

 
 

-       if x has indexers, the value of x [N] set is set to void.  This needs to be
-       fixed.
+       Instead of the hack that *knows* about System.Object not having any children classes,
+       we should just make it simple for a probe to know that there is no need for it.

 
 

-* Array declarations
+Dead Code Elimination bugs:
+---------------------------

 
 

-       Multi-dim arrays are declared as [,] instead of [0..,0..]
+       I should also resolve all the children expressions in Switch, Fixed, Using.
+
+Major tasks:
+------------
+       Properties and 17.6.3: Finish it.
+
+readonly variables and ref/out
+       
+BUGS
+----

 
 * Break/Continue statements
 
 
 * Break/Continue statements
 


@@ -108,11 +172,6 @@ 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
-
-       I am not using the checked state while doing type casts,
-       they should result in conv.ovf.XXX
-

 * Method Registration and error CS111
 
        The way we use the method registration to signal 111 is wrong.
 * Method Registration and error CS111
 
        The way we use the method registration to signal 111 is wrong.


@@ -120,14 +179,6 @@ BUGS
        Method registration should only be used to register methodbuilders,
        we need an alternate method of checking for duplicates.
 
        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 {
 *
 > // CSC sets beforefieldinit
 > class X {


@@ -140,88 +191,45 @@ BUGS
 PENDING TASKS
 -------------
 
 PENDING TASKS
 -------------
 

-       * Implement Goto.
-
-       * Unsafe code.
-               Making the parser accept unsafe code.
-               
-       * Implement `base' (BaseAccess class)
-
-       * Implement constant folding.  We might need to implement
-         a new `Constant' class and derive Literal from it.
-
-* OUT Variables passed as OUT variables.
-
-       Currently we pass the pointer to the pointer (see expression.cs:Argument.Emit)
-
-* Make the rules for inheritance/overriding apply to 
-  properties, operators and indexers (currently we only do this
-  on methods).
-
-* Handle volatile
-
-* Static flow analysis
-
-       Required to warn about reachability of code and definite
-       assignemt as well as missing returns on functions.
+* Merge test 89 and test-34

 
 * Code cleanup
 
        The information when registering a method in InternalParameters
        is duplicated, you can always get the types from the InternalParameters
 
 
 * Code cleanup
 
        The information when registering a method in InternalParameters
        is duplicated, you can always get the types from the InternalParameters
 

-OPTIMIZATIONS
--------------
-
-* Emitcontext
+* Emit modreq for volatiles

 
 

-       Do we really need to instanciate this variable all the time?
+       Handle modreq from public apis.

 
 

-       It could be static for all we care, and just use it for making
-       sure that there are no recursive invocations on it.
+* Merge tree.cs, rootcontext.cs

 
 

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

 
 

-       Currently it calls the parent constructor before initializing fields.
-       It should do it the other way around.
+* User Defined Conversions is doing way too many calls to do union sets that are not needed

 
 

-* Use of EmitBranchable
+* Add test case for destructors

 
 

-       Currently I use brfalse/brtrue in the code for statements, instead of
-       using the EmitBranchable function that lives in Binary
+* 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).

 
 

-* ConvertImplicit
+* Dropping TypeContainer as an argument to EmitContext

 
 

-       Currently ConvertImplicit will not catch things like:
+       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).  

 
 

-       - IntLiteral in a float context to generate a -FloatLiteral.
-       Instead it will perform an integer load followed by a conversion.
+       The only pending problem is that the code that implements Aliases
+       is on TypeContainer, and probably should go in DeclSpace.

 
 * Tests
 
        Write tests for the various reference conversions.  We have
        test for all the numeric conversions.
 
 
 * 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
 * Optimizations: variable allocation.
 
        When local variables of a type are required, we should request


@@ -230,17 +238,13 @@ OPTIMIZATIONS
 
 * Add a cache for the various GetArrayMethod operations.
 
 
 * Add a cache for the various GetArrayMethod operations.
 

-* Optimization:
+* MakeUnionSet Callers

 
 

-       Do not use StatementCollections, use ArrayLists of Statements,
-       and then "copy" it out to arrays.  Then reuse the existing
-       Statement structures.
+       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.

 
 

-* 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.
+* Factor the lookup code for class declarations an interfaces
+  (interface.cs:GetInterfaceByName)

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


@@ -264,39 +268,4 @@ RECOMMENDATIONS
        Notice how numbering of the arguments changes as the
        { oob_stack.Push (lexer.Location) } takes a "slot"  in the productions.
 
        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 () {}
-}
\ No newline at end of file