mcs/mcs/TODO

   1 TODO:
   2
   3         1. Create a "partial" emit context for each TypeContainer..
   4
   5         2. EmitContext should be partially constructed.  No IL Generator.
   6
   7         interface_type review.
   8
   9         parameter_array, line 952: `note: must be a single dimension array type'.  Validate this
  10
  11 Dead Code Elimination bugs:
  12 ---------------------------
  13
  14         I should also resolve all the children expressions in Switch, Fixed, Using.
  15
  16 Major tasks:
  17 ------------
  18
  19         Pinned and volatile require type modifiers that can not be encoded
  20         with Reflection.Emit.
  21
  22         Properties and 17.6.3: Finish it.
  23
  24         Implement base indexer access.
  25
  26 readonly variables and ref/out
  27
  28 BUGS
  29 ----
  30
  31 * We suck at reporting what turns out to be error -6.  Use the standard error message
  32   instead.
  33
  34 * Check for Final when overriding, if the parent is Final, then we cant
  35   allow an override.
  36
  37 * Interface indexers
  38
  39         I have not figured out why the Microsoft version puts an
  40         `instance' attribute, and I am not generating this `instance' attribute.
  41
  42         Explanation: The reason for the `instance' attribute on
  43         indexers is that indexers only apply to instances
  44
  45 * Break/Continue statements
  46
  47         A finally block should reset the InLoop/LoopBegin/LoopEnd, as
  48         they are logically outside the scope of the loop.
  49
  50 * Break/continue part 2.
  51
  52         They should transfer control to the finally block if inside a try/catch
  53         block.
  54
  55 * Method Registration and error CS111
  56
  57         The way we use the method registration to signal 111 is wrong.
  58
  59         Method registration should only be used to register methodbuilders,
  60         we need an alternate method of checking for duplicates.
  61
  62 *
  63 > // CSC sets beforefieldinit
  64 > class X {
  65 >   // .cctor will be generated by compiler
  66 >   public static readonly object O = new System.Object ();
  67 >   public static void Main () {}
  68 > }
  69 >
  70
  71 PENDING TASKS
  72 -------------
  73
  74 * IMprove error handling here:
  75
  76         public static Process ()
  77
  78         THat assumes that it is a constructor, check if its the same name
  79         as the class, if not report a different error than the one we use now.
  80
  81 * Merge test 89 and test-34
  82
  83 * Revisit
  84
  85         Primary-expression, as it has now been split into
  86         non-array-creation-expression and array-creation-expression.
  87
  88 * Static flow analysis
  89
  90         Required to warn about reachability of code and definite
  91         assignemt as well as missing returns on functions.
  92
  93 * Code cleanup
  94
  95         The information when registering a method in InternalParameters
  96         is duplicated, you can always get the types from the InternalParameters
  97
  98 * Emit modreq for volatiles
  99
 100         Handle modreq from public apis.
 101
 102 * Emit `pinned' for pinned local variables.
 103
 104         Both `modreq' and pinned will require special hacks in the compiler.
 105
 106 * Make sure that we are pinning the right variable
 107
 108 * Maybe track event usage?  Currently I am not tracking these, although they
 109   are fields.
 110
 111 * Merge tree.cs, rootcontext.cs
 112
 113 OPTIMIZATIONS
 114 -------------
 115
 116 * User Defined Conversions is doing way too many calls to do union sets that are not needed
 117
 118 * Add test case for destructors
 119
 120 * Places that use `Ldelema' are basically places where I will be
 121   initializing a value type.  I could apply an optimization to
 122   disable the implicit local temporary from being created (by using
 123   the method in New).
 124
 125 * Dropping TypeContainer as an argument to EmitContext
 126
 127         My theory is that I can get rid of the TypeBuilder completely from
 128         the EmitContext, and have typecasts where it is used (from
 129         DeclSpace to where it matters).
 130
 131         The only pending problem is that the code that implements Aliases
 132         is on TypeContainer, and probably should go in DeclSpace.
 133
 134 * Casts need to trigger a name resolution against types only.
 135
 136         currently we use a secret hand shake, probably we should use
 137         a differen path, and only expressions (memberaccess, simplename)
 138         would participate in this protocol.
 139
 140 * Use of local temporary in UnaryMutator
 141
 142         We should get rid of the Localtemporary there for some cases
 143
 144 * Emitcontext
 145
 146         Do we really need to instanciate this variable all the time?
 147
 148         It could be static for all we care, and just use it for making
 149         sure that there are no recursive invocations on it.
 150
 151 * ConvertImplicit
 152
 153         Currently ConvertImplicit will not catch things like:
 154
 155         - IntLiteral in a float context to generate a -FloatLiteral.
 156         Instead it will perform an integer load followed by a conversion.
 157
 158 * Tests
 159
 160         Write tests for the various reference conversions.  We have
 161         test for all the numeric conversions.
 162
 163 * Optimizations
 164
 165         In Indexers and Properties, probably support an EmitWithDup
 166         That emits the code to call Get and then leaves a this pointer
 167         in the stack, so that later a Store can be emitted using that
 168         this pointer (consider Property++ or Indexer++)
 169
 170 * Optimizations: variable allocation.
 171
 172         When local variables of a type are required, we should request
 173         the variable and later release it when we are done, so that
 174         the same local variable slot can be reused later on.
 175
 176 * Add a cache for the various GetArrayMethod operations.
 177
 178 * TypeManager.FindMembers:
 179
 180         Instead of having hundreds of builder_to_blah hash table, have
 181         a single one that maps a TypeBuilder `t' to a set of classes
 182         that implement an interface that supports FindMembers.
 183
 184 * MakeUnionSet Callers
 185
 186         If the types are the same, there is no need to compute the unionset,
 187         we can just use the list from one of the types.
 188
 189 * Factor all the FindMembers in all the FindMembers providers.
 190
 191 * Factor the lookup code for class declarations an interfaces
 192   (interface.cs:GetInterfaceByName)
 193
 194 RECOMMENDATIONS
 195 ---------------
 196
 197 * Use of lexer.Location in the parser
 198
 199         Currently we do:
 200
 201         TOKEN nt TERMINAL nt TERMINAL nt3 {
 202                 $$ = new Blah ($2, $4, $6, lexer.Location);
 203         }
 204
 205         This is bad, because the lexer.Location is for the last item in `nt3'
 206
 207         We need to change that to use this pattern:
 208
 209         TOKEN { oob_stack.Push (lexer.Location) } nt TERMINAL nt TERMINAL nt3 {
 210                 $$ = new Blah ($3, $5, $7, (Location) oob_stack.Pop ());
 211         }
 212
 213         Notice how numbering of the arguments changes as the
 214         { oob_stack.Push (lexer.Location) } takes a "slot"  in the productions.
 215
 216 * local_variable_declaration
 217
 218         Not sure that this grammar is correct, we might have to
 219         resolve this during semantic analysis.
 220