mcs/mcs/TODO

   1 Major tasks:
   2 ------------
   3
   4         Properties and 17.6.3: Finish it.
   5
   6         Implement base indexer access.
   7
   8 MethodGroupExpr
   9
  10         These guys should only appear as part of an Invocation, so we
  11         probably can afford to have a special callback:
  12
  13                 Expression.ResolveAllowMemberGroups
  14
  15         This is only called by Invocation (or anyone that consumes
  16         MethodGroupExprs)
  17
  18         And the regular DoResolve and DoResolveLValue do emit the error
  19         654 `Method referenced without argument list'.
  20
  21         Otherwise, a resolution will return a MethodGroupExpr which is
  22         not guaranteed to have set its `Expression.Type' to a non-null
  23         value.
  24
  25 AddressOf
  26         Needs an extra argument: `set' or `read', this will help
  27         to track usage errors in variables (since AddressOf does not
  28         really know what is it being used for, it could be either)
  29
  30 BUGS
  31 ----
  32
  33 * Check for Final when overriding, if the parent is Final, then we cant
  34   allow an override.
  35
  36 * Add test case for destructors
  37
  38 * Do not declare a .property on things that are just implementations, that
  39   comes from the parent, just do the method.
  40
  41 * Currently the code path for 108/109 reporting is not being ran for methods
  42   as we need to compare method signatures.  But since we retrieve the expensive
  43   method arguments in the method, we probably should do 108/109 processing there.
  44
  45 * Emit warning on hiding members without NEW not only in members.
  46
  47 * Implement visibility.
  48
  49 * Adding variables.
  50
  51         We do add variables in a number of places, and this is erroneous:
  52
  53         void a (int b)
  54         {
  55                 int b;
  56         }
  57
  58         Also:
  59
  60         void a (int b)
  61         {
  62                 foreach (int b ...)
  63                         ;
  64         }
  65
  66 * Visibility
  67
  68         I am not reporting errors on visibility yet.
  69
  70 * Interface indexers
  71
  72         I have not figured out why the Microsoft version puts an
  73         `instance' attribute, and I am not generating this `instance' attribute.
  74
  75         Explanation: The reason for the `instance' attribute on
  76         indexers is that indexers only apply to instances
  77
  78 * Arrays
  79
  80         We need to make sure at *compile time* that the arguments in
  81         the expression list of an array creation are always positive.
  82
  83 * Implement dead code elimination in statement.cs
  84
  85         It is pretty simple to implement dead code elimination in
  86         if/do/while
  87
  88 * Indexer bugs:
  89
  90         the following wont work:
  91
  92         x [0] = x [1] = N
  93
  94         if x has indexers, the value of x [N] set is set to void.  This needs to be
  95         fixed.
  96
  97 * Array declarations
  98
  99         Multi-dim arrays are declared as [,] instead of [0..,0..]
 100
 101 * Break/Continue statements
 102
 103         A finally block should reset the InLoop/LoopBegin/LoopEnd, as
 104         they are logically outside the scope of the loop.
 105
 106 * Break/continue part 2.
 107
 108         They should transfer control to the finally block if inside a try/catch
 109         block.
 110
 111 * Method Registration and error CS111
 112
 113         The way we use the method registration to signal 111 is wrong.
 114
 115         Method registration should only be used to register methodbuilders,
 116         we need an alternate method of checking for duplicates.
 117
 118 * We need to catch:
 119
 120         extern string Property {
 121                 get { }
 122         }
 123
 124         The get there should only have a semicolon
 125
 126 *
 127 > // CSC sets beforefieldinit
 128 > class X {
 129 >   // .cctor will be generated by compiler
 130 >   public static readonly object O = new System.Object ();
 131 >   public static void Main () {}
 132 > }
 133 >
 134
 135 PENDING TASKS
 136 -------------
 137
 138 * Unsafe contexts:
 139         Done: class, struct, interface
 140         Everywhere where we lookup a type, we should test for unsafe pointers.
 141
 142
 143 * Static flow analysis
 144
 145         Required to warn about reachability of code and definite
 146         assignemt as well as missing returns on functions.
 147
 148 * Code cleanup
 149
 150         The information when registering a method in InternalParameters
 151         is duplicated, you can always get the types from the InternalParameters
 152
 153 * Emit modreq for volatiles
 154
 155         Handle modreq from public apis.
 156
 157 OPTIMIZATIONS
 158 -------------
 159
 160 * Emitcontext
 161
 162         Do we really need to instanciate this variable all the time?
 163
 164         It could be static for all we care, and just use it for making
 165         sure that there are no recursive invocations on it.
 166
 167 * Static-ization
 168
 169         Since AppDomain exists, maybe we can get rid of all the stuff
 170         that is part of the `compiler instance' and just use globals
 171         everywhere.
 172
 173
 174 * Constructors
 175
 176         Currently it calls the parent constructor before initializing fields.
 177         It should do it the other way around.
 178
 179 * Use of EmitBranchable
 180
 181         Currently I use brfalse/brtrue in the code for statements, instead of
 182         using the EmitBranchable function that lives in Binary
 183
 184 * ConvertImplicit
 185
 186         Currently ConvertImplicit will not catch things like:
 187
 188         - IntLiteral in a float context to generate a -FloatLiteral.
 189         Instead it will perform an integer load followed by a conversion.
 190
 191 * Tests
 192
 193         Write tests for the various reference conversions.  We have
 194         test for all the numeric conversions.
 195
 196 * Remove the tree dumper, cleanup `public readonly'
 197
 198         And make all the stuff which is `public readonly' be private unless
 199         required.
 200
 201 * Optimizations
 202
 203         In Indexers and Properties, probably support an EmitWithDup
 204         That emits the code to call Get and then leaves a this pointer
 205         in the stack, so that later a Store can be emitted using that
 206         this pointer (consider Property++ or Indexer++)
 207
 208
 209 * Optimizations: variable allocation.
 210
 211         When local variables of a type are required, we should request
 212         the variable and later release it when we are done, so that
 213         the same local variable slot can be reused later on.
 214
 215 * Add a cache for the various GetArrayMethod operations.
 216
 217 * Optimization:
 218
 219         Do not use StatementCollections, use ArrayLists of Statements,
 220         and then "copy" it out to arrays.  Then reuse the existing
 221         Statement structures.
 222
 223 * TypeManager.FindMembers:
 224
 225         Instead of having hundreds of builder_to_blah hash table, have
 226         a single one that maps a TypeBuilder `t' to a set of classes
 227         that implement an interface that supports FindMembers.
 228
 229 RECOMMENDATIONS
 230 ---------------
 231
 232 * Use of lexer.Location in the parser
 233
 234         Currently we do:
 235
 236         TOKEN nt TERMINAL nt TERMINAL nt3 {
 237                 $$ = new Blah ($2, $4, $6, lexer.Location);
 238         }
 239
 240         This is bad, because the lexer.Location is for the last item in `nt3'
 241
 242         We need to change that to use this pattern:
 243
 244         TOKEN { oob_stack.Push (lexer.Location) } nt TERMINAL nt TERMINAL nt3 {
 245                 $$ = new Blah ($3, $5, $7, (Location) oob_stack.Pop ());
 246         }
 247
 248         Notice how numbering of the arguments changes as the
 249         { oob_stack.Push (lexer.Location) } takes a "slot"  in the productions.
 250
 251 * local_variable_declaration
 252
 253         Not sure that this grammar is correct, we might have to
 254         resolve this during semantic analysis.
 255
 256
 257 * Try/Catch
 258
 259         Investigate what is  the right value to return  from `Emit' in
 260         there (ie, for the `all code paths return')
 261
 262
 263 * Optimizations
 264
 265         Only create one `This' instance per class, and reuse it.
 266
 267         Maybe keep a pool of constants/literals (zero, 1)?
 268
 269 ************
 270 Potential bug:
 271
 272         We would need to decode the shortname before we lookup members?
 273
 274         Maybe not.
 275
 276 interface I {
 277         void A ();
 278 }
 279
 280 class X : I {
 281         void I.A ();
 282 }
 283
 284 class Y : X, I {
 285         void I.A () {}
 286 }
 287
 288
 289
 290 *************
 291