Usage: To use the system, execute: 'WrapperTest new installWrappers'. This will install method coverage wrappers on a list of methods (about 20000 in our case, cfr. #selectedMethodsDo:). Whenever a call is made to any of these wrapped methods, the interpreter will kick in and evaluate the parse tree (parse trees are generated on demand). Each method wrapper holds on to its own parse tree. The elements in the parse tree keep track of the number activations. Run the application to be analyzed and open the coverage browser at any time. If the application is interactive, the browser can be reactivated at any time; this will automatically update the statistics. The browsers retrieves its information directly from the method wrappers. De-installing the wrappers (send #uninstallWrappers to the wrapper test instance) will discard this information. Example: | wrapper | wrapper := WrapperTest new. wrapper installWrappers. CoverageApplicationBrowser open. "no methods are marked as traced at this time" YourApplication start. .... wrapper uninstallWrappers Caveats: Apart from the obvious recursion problem (interpreting your own code), some things should currently be avoided: - primitives (in particular externals, since they require a dedicated parser) - thisContext (is currently not supported) - relying on a blockclosure's #copiedValues. Other issues will most probably arise, but this is very early pre-alpha anyway ... Some interpreter optimizations: The interpreter is currently rather pure, without many optimizations. Here are just a few suggestions to improve performance: 1. Do not perform the method lookup yourself if you do not need it. 2. Perform the lookup, but use #perform:, ... instead of #valueWithReceiver:arguments:. This also gives the opportunity to remove most instantiations of the evaluated arguments arrays (do not use in case of super sends). 3. Sometimes we do not need a context (e.g. get- and set-accessors typically only need the receiver). 4. Handle special cases in message sends (ifTrue:ifFalse:, ==, ...).