-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:
-BUGS
-----
+ Section 9.3 in the latest spec.
-* Adding variables.
- We do add variables in a number of places, and this is erroneous:
+* Review
+--------
- void a (int b)
- {
- int b;
- }
+ Reference type equality operators (15.9.6) introduced
+ operator == (C x, C y) where C is a reference type.
- Also:
+ Our compiler used:
- void a (int b)
- {
- foreach (int b ...)
- ;
- }
+ operator == (object a, object b)
-* Visibility
+ Review our implementation.
- I am not reporting errors on visibility yet.
+New
+---
-* Interfaces
+ It would be nice to optimize the case of:
- 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:
+ Method (new ValueType ())
- .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..
- ...
- }
+ 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.
-* Interface indexers
+NEW NOTES:
+----------
- I have not figured out why the Microsoft version puts an
- `instance' attribute, and I am not generating this `instance' attribute.
+ ImplicitStandardConversionExists and ImplicitStandardConversion
+ should always be the same, but there are a few diverging lines that
+ must be studied:
- Explanation: The reason for the `instance' attribute on
- indexers is that indexers only apply to instances
+ if (expr_type == target_type && !(expr is NullLiteral))
+ return expr;
-* Handle destructors specially
+ vs:
- Turn ~X () { a () } into:
- void Finalize () { try { a (); } finally { base.Finalize (); } }
+ if (expr_type == target_type)
+ return true;
- The code is mostly done, but `base' is missing. The reason it is
- missing is because we have to implement visibility first.
-* Method Names
+Null Type
+---------
- Method names could be; `IFACE.NAME' in the method declaration,
- stating that they implement a specific interface method.
+ Need to introduce the NullType concept into the compiler, to address a
+ few small buglets and remove the hardcoded values for NullLiteral.
- We currently fail to parse it.
+ NullLiteral will be the only expression that has the NullType as its type.
-* Arrays
+ 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.
- We need to make sure at *compile time* that the arguments in
- the expression list of an array creation are always positive.
+ Revert Martin's patch to Conditional expression that worked around this bug:
-* Implement dead code elimination in statement.cs
+ Reference r = xx ? null : null
- It is pretty simple to implement dead code elimination in
- if/do/while
+ The right fix is to introduce NullType
-* Indexer bugs:
+****************************************************************************************
+*
+* The information on the rest of this file is mostly outdated, and its kept here for
+* historical reasons
+*
+****************************************************************************************
+
+Error Reporting:
+----------------
- the following wont work:
+ * Make yyerror show a nice syntax error, instead of the current mess.
- x [0] = x [1] = N
+Iterators
+---------
+ * Reset should throw not implemented now.
- if x has indexers, the value of x [N] set is set to void. This needs to be
- fixed.
+Optimization ideas
+------------------
-* Array declarations
+ 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.
- Multi-dim arrays are declared as [,] instead of [0..,0..]
+ We create too many Arraylists; When we know the size, we should create
+ an array;
-* Break/Continue statements
+ During parsing we use arraylists to accumulate data, like this:
- A finally block should reset the InLoop/LoopBegin/LoopEnd, as
- they are logically outside the scope of the loop.
+ thing:
+
+ thing_list
+ : thing { $$ =new ArrayList (); $$.Add ($1); }
+ | thing_list thing { ArrayList a = $1; a.Add ($2); $$ = a; }
-* Break/continue part 2.
+ We probably could start using "Pairs" there:
- They should transfer control to the finally block if inside a try/catch
- block.
+ thing_list
+ : thing { $$ = new Pair ($1, null); }
+ | thing_list thing { Pair p = $1; $$ = new Pair ($2, $1); }
-* Conversions and overflow
- I am not using the checked state while doing type casts,
- they should result in conv.ovf.XXX
+EmitContext.ResolveTypeTree
+---------------------------
-* Method Registration and error CS111
+ We should investigate its usage. The problem is that by default
+ this will be set when calling FindType, that triggers a more expensive
+ lookup.
- 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.
+ 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.
-* Mapping of methods
+DeclareLocal audit
+------------------
- Currently various hashtables fail because the Equals implementation
- for MethodBuilders is not complete enough. We could work around this
- by having our own Hashtable implementation.
-
-*
-> // CSC sets beforefieldinit
-> class X {
-> // .cctor will be generated by compiler
-> public static readonly object O = new System.Object ();
-> public static void Main () {}
-> }
->
-
-PENDING TASKS
--------------
+ DeclareLocal is used in various statements. The audit should be done
+ in two steps:
- * Implement Goto.
+ * Identify all the declare locals.
- * Unsafe code.
- Making the parser accept unsafe code.
-
- * Implement `base' (BaseAccess class)
+ * Identify its uses.
- * Implement constant folding. We might need to implement
- a new `Constant' class and derive Literal from it.
+ * Find if we can make wrapper functions for all of them.
-* OUT Variables passed as OUT variables.
+ Then we can move DeclareLocal into a helper class.
- Currently we pass the pointer to the pointer (see expression.cs:Argument.Emit)
+ This is required to fix foreach in iterators.
-* Function Declarations
+Large project:
+--------------
- Support PINvoke/Internallcall and extern declarated-functions.
+ 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.
-* Manual field layout in structures
+ Martin has some some of this work with his TypeHandle code
+ that we could use for this.
-* Make the rules for inheritance/overriding apply to
- properties, operators and indexers (currently we only do this
- on methods).
+Ideas:
+------
-* Handle volatile
+ 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.
-* Support Re-Throw exceptions:
+Dead Code Elimination bugs:
+---------------------------
- try {
- X ();
- } catch (SomeException e){
- LogIt ();
- throw;
- }
+ I should also resolve all the children expressions in Switch, Fixed, Using.
-* Static flow analysis
-
- Required to warn about reachability of code and definite
- assignemt as well as missing returns on functions.
+Major tasks:
+------------
+ Properties and 17.6.3: Finish it.
-* Implement `goto case expr'
+readonly variables and ref/out
+
+BUGS
+----
- switch (x){
- case 1: print ("1"); goto case 4;
- case 2: ...
- case 4: ...
- }
+* Break/Continue statements
-* Code cleanup
+ A finally block should reset the InLoop/LoopBegin/LoopEnd, as
+ they are logically outside the scope of the loop.
- The information when registering a method in InternalParameters
- is duplicated, you can always get the types from the InternalParameters
+* Break/continue part 2.
-OPTIMIZATIONS
--------------
+ They should transfer control to the finally block if inside a try/catch
+ block.
-* Emitcontext
+* Method Registration and error CS111
- Do we really need to instanciate this variable all the time?
+ 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 could be static for all we care, and just use it for making
- sure that there are no recursive invocations on it.
+*
+> // CSC sets beforefieldinit
+> class X {
+> // .cctor will be generated by compiler
+> public static readonly object O = new System.Object ();
+> public static void Main () {}
+> }
+>
-* Static-ization
+PENDING TASKS
+-------------
- Since AppDomain exists, maybe we can get rid of all the stuff
- that is part of the `compiler instance' and just use globals
- everywhere.
+* Merge test 89 and test-34
+* Code cleanup
-* Constructors
+ The information when registering a method in InternalParameters
+ is duplicated, you can always get the types from the InternalParameters
- Currently it calls the parent constructor before initializing fields.
- It should do it the other way around.
+* Emit modreq for volatiles
-* Reducer and -Literal
+ Handle modreq from public apis.
- Maybe we should never handle -Literal in Unary expressions and let
- the reducer take care of it always?
+* Merge tree.cs, rootcontext.cs
-* Use of EmitBranchable
+OPTIMIZATIONS
+-------------
- Currently I use brfalse/brtrue in the code for statements, instead of
- using the EmitBranchable function that lives in Binary
+* User Defined Conversions is doing way too many calls to do union sets that are not needed
-* Create an UnimplementedExpcetion
+* Add test case for destructors
- And use that instead of plain Exceptions to flag compiler errors.
+* 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.
-* Remove the tree dumper, cleanup `public readonly'
+* Optimizations: variable allocation.
- And make all the stuff which is `public readonly' be private unless
- required.
+ 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.
-* Optimizations
+* Add a cache for the various GetArrayMethod operations.
- 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++)
+* MakeUnionSet Callers
+ 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.
-* Add a cache for the various GetArrayMethod operations.
+* Factor the lookup code for class declarations an interfaces
+ (interface.cs:GetInterfaceByName)
-
RECOMMENDATIONS
---------------
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)?