+Error Reporting:
+----------------
+
+ * Make yyerror show a nice syntax error, instead of the current mess.
+
+Iterators
+---------
+ * `yield' is no longer a keyword, it only has special
+ meaning before a return or break keywords.
+
+ * Study side effects with assign
+ * Study TemporaryStorage/LocalStorage -> Merge/rename
+
+ * Reset should throw not implemented now.
+
+Instance idea
+-------------
+
+ It would be nice to have things that can be "instances" to have an
+ EmitInstance method (this would default to nothing).
+
+ The idea is to be able to use efficiently the instance data on stack
+ manipulations, as opposed to the current scheme, where we basically have
+ a few special cases.
+
+Optimization ideas
+------------------
+
+ 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;
+
+ During parsing we use arraylists to accumulate data, like this:
+
+ thing:
+
+ thing_list
+ : thing { $$ =new ArrayList (); $$.Add ($1); }
+ | thing_list thing { ArrayList a = $1; a.Add ($2); $$ = a; }
+
+ We probably could start using "Pairs" there:
+
+ thing_list
+ : thing { $$ = new Pair ($1, null); }
+ | thing_list thing { Pair p = $1; $$ = new Pair ($2, $1); }
+
+
+Anonymous Methods
+-----------------
+
+ Plan:
+
+ * Resolve anonymous methods before.
+ * Each time a Local matches, if the mode is `InAnonymous', flag
+ the VariableInfo for `proxying'.
+ * During Resolve track the depth required for local variables.
+ * Before Emit, create proxy classes with proper depth.
+ * Emit.
+
+Open question:
+ Create a toplevel block for anonymous methods?
+
+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 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.
+
+DeclareLocal audit
+------------------
+
+ DeclareLocal is used in various statements. The audit should be done
+ in two steps:
+
+ * Identify all the declare locals.
+
+ * Identify its uses.
+
+ * Find if we can make wrapper functions for all of them.
+
+ Then we can move DeclareLocal into a helper class.
+
+ This is required to fix foreach in iterators.
+
+Large project:
+--------------
+
+ 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.
+
+ Martin has some some of this work with his TypeHandle code
+ that we could use for this.
+
+Notes on memory allocation
+--------------------------
+
+ Outdated:
+
+ A run of the AllocationProfile shows that the compiler allocates roughly
+ 30 megabytes of strings. From those, 20 megabytes come from
+ LookupType.
+
+ See the notes on current_container problems below on memory usage.
+
+LookupTypeReflection:
+---------------------
+
+ With something like `System.Object', LookupTypeReflection will be called
+ twice: once to find out that `System' is not a type and once
+ for System.Object.
+
+ This is required because System.Reflection requires that the type/nested types are
+ not separated by a dot but by a plus sign.
+
+ A nested class would be My+Class (My being the toplevel, Class the nested one).
+
+ It is interesting to look at the most called lookups when bootstrapping MCS:
+
+ 647 LTR: ArrayList
+ 713 LTR: System.Globalization
+ 822 LTR: System.Object+Expression
+ 904 LTR: Mono.CSharp.ArrayList
+ 976 LTR: System.Runtime.CompilerServices
+ 999 LTR: Type
+ 1118 LTR: System.Runtime
+ 1208 LTR: Mono.CSharp.Type
+ 1373 LTR: Mono.Languages
+ 1599 LTR: System.Diagnostics
+ 2036 LTR: System.Text
+ 2302 LTR: System.Reflection.Emit
+ 2515 LTR: System.Collections
+ 4527 LTR: System.Reflection
+ 22273 LTR: Mono.CSharp
+ 24245 LTR: System
+ 27005 LTR: Mono
+
+ Analysis:
+ The top 9 lookups are done for things which are not types.
+
+ Mono.CSharp.Type happens to be a common lookup: the class Type
+ used heavily in the compiler in the default namespace.
+
+ RED FLAG:
+
+ Then `Type' is looked up alone a lot of the time, this happens
+ in parameter declarations and am not entirely sure that this is
+ correct (FindType will pass to LookupInterfaceOrClass a the current_type.FullName,
+ which for some reason is null!). This seems to be a problem with a lost
+ piece of context during FindType.
+
+ System.Object is also used a lot as a toplevel class, and we assume it will
+ have children, we should just shortcut this.
+
+ A cache:
+
+ Adding a cache and adding a catch for `System.Object' to flag that it wont be the
+ root of a hierarchy reduced the MCS bootstrap time from 10.22 seconds to 8.90 seconds.
+
+ This cache is currently enabled with SIMPLE_SPEEDUP in typemanager.cs. Memory consumption
+ went down from 74 megs to 65 megs with this change.
+
+Ideas:
+------
+
+ 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.
+
+The use of DottedName
+---------------------
+
+ We could probably use a different system to represent names, like this:
+
+ class Name {
+ string simplename;
+ Name parent;
+ }
+
+ So `System.ComponentModel' becomes:
+
+ x: (System, null)
+ y: (ComponentModel, x)
+
+ The problem is that we would still need to construct the name to pass to
+ GetType.
+
+ This has been now implemented, its called "QualifiedIdentifier"
+
+current_container/current_namespace and the DeclSpace
+-----------------------------------------------------
+
+ We are storing fully qualified names in the DeclSpace instead of the node,
+ this is because `current_namespace' (Namepsace) is not a DeclSpace like
+ `current_container'.
+
+ The reason for storing the full names today is this:
+
+ namespace X {
+ class Y {
+ }
+ }
+
+ namespace A {
+ class Y {
+ }
+ }
+
+ The problem is that we only use the namespace stack to track the "prefix"
+ for typecontainers, but they are not typecontainers themselves, so we have
+ to use fully qualified names, because both A.X and A.Y would be entered
+ in the toplevel type container. If we use the short names, there would be
+ a name clash.
+
+ To fix this problem, we have to make namespaces DeclSpaces.
+
+ The full size, contrasted with the size that could be stored is:
+ corlib:
+ Size of strings held: 368901
+ Size of strings short: 147863
+
+ System:
+ Size of strings held: 212677
+ Size of strings short: 97521
+
+ System.XML:
+ Size of strings held: 128055
+ Size of strings short: 35782
+
+ System.Data:
+ Size of strings held: 117896
+ Size of strings short: 36153
+
+ System.Web:
+ Size of strings held: 194527
+ Size of strings short: 58064
+
+ System.Windows.Forms:
+ Size of strings held: 220495
+ Size of strings short: 64923
+
+
TODO:
1. Create a "partial" emit context for each TypeContainer..
2. EmitContext should be partially constructed. No IL Generator.
- Optimize the internal type expressions in the parser (system_object, etc)
- to be something other than DecomposeQI-based expressions.
-
interface_type review.
parameter_array, line 952: `note: must be a single dimension array type'. Validate this
BUGS
----
-* We suck at reporting what turns out to be error -6. Use the standard error message
- instead.
-
-* Explicit indexer implementation is missing.
-
* Check for Final when overriding, if the parent is Final, then we cant
allow an override.
Explanation: The reason for the `instance' attribute on
indexers is that indexers only apply to instances
-* 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
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 {
PENDING TASKS
-------------
-* IMprove error handling here:
-
- public static Process ()
-
- 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.
-
* Merge test 89 and test-34
* Revisit
Primary-expression, as it has now been split into
non-array-creation-expression and array-creation-expression.
-* Static flow analysis
-
- Required to warn about reachability of code and definite
- assignemt as well as missing returns on functions.
-
* Code cleanup
The information when registering a method in InternalParameters
* Make sure that we are pinning the right variable
-* Maybe track event usage? Currently I am not tracking these, although they
- are fields.
-
* Merge tree.cs, rootcontext.cs
OPTIMIZATIONS
-------------
-* Implement loop inversion for `For' as well.
-
-* 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
* Add test case for destructors
The only pending problem is that the code that implements Aliases
is on TypeContainer, and probably should go in DeclSpace.
-* Casts need to trigger a name resolution against types only.
-
- currently we use a secret hand shake, probably we should use
- a differen path, and only expressions (memberaccess, simplename)
- would participate in this protocol.
-
* Use of local temporary in UnaryMutator
We should get rid of the Localtemporary there for some cases
-* Emitcontext
+ This turns out to be very complex, at least for the post-version,
+ because this case:
- Do we really need to instanciate this variable all the time?
+ a = i++
- It could be static for all we care, and just use it for making
- sure that there are no recursive invocations on it.
-
-* Use of EmitBranchable
-
- Currently I use brfalse/brtrue in the code for statements, instead of
- using the EmitBranchable function that lives in Binary
-
-* ConvertImplicit
-
- Currently ConvertImplicit will not catch things like:
-
- - IntLiteral in a float context to generate a -FloatLiteral.
- Instead it will perform an integer load followed by a conversion.
+ To produce optimal code, it is necessary for UnaryMutator to know
+ that it is being assigned to a variable (the way the stack is laid
+ out using dup requires the store to happen inside UnaryMutator).
* Tests
* Add a cache for the various GetArrayMethod operations.
-* 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.
-
* 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.
-* Factor all the FindMembers in all the FindMembers providers.
-
* Factor the lookup code for class declarations an interfaces
(interface.cs:GetInterfaceByName)
Not sure that this grammar is correct, we might have to
resolve this during semantic analysis.
-* Idea
-
- MethodGroupExpr
-
- These guys should only appear as part of an Invocation, so we
- probably can afford to have a special callback:
-
- Expression.ResolveAllowMemberGroups
-
- This is only called by Invocation (or anyone that consumes
- MethodGroupExprs)
-
- 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.