At 11:32 -0700 2004.7.26, Anthony Hannan wrote:
>Hi Andrew,
>
>Sorry for the late response. Your changeset looks good. It completes the
>pattern I started with inspectorClass, thanks! The primitiveChangeClassTo:, I
>put in in Inspector>>inspect:, was only used by the debugger when inspecting a
>block closure (generated from the Closure Compiler).


As I posted previously, I finally figured this out, and removed a lot 
of method redefinitions  (in the changeset InspectorFixes) so that 
not only are the embedded inspectors changed to the specialized 
classes, they are also changed back again!

>  I now realize I should do
>this differently because I don't want Dictionaries, etc. to show as
>DictionaryInspectors but still as raw inspectors,

I was quite happy to have them show up as SetInspectors, 
DictionaryInspectors, etc.  There is always basicInspect if someone 
does not want this behavior.

>so I will change this in my
>Closure Compiler (which makes a few changes to the debugger). So you 
>may remove
>the primitiveChangeClassTo: if you want.

I now believe that we should keep it, but added a comment explaining 
why it was there.

>I think it would only be useful if the
>same Inspector was used to inspect different objects at different times.
>However, it is never used like this. And even the debugger, which does reused
>the inspector does not want this behavior.

I agree that the debugger is the only place that reuses inspectors. 
But I disagree that we don't want the enhanced behavior; I like it, 
now that it actually works.  It is however important that it does not 
apply to ContextVariablesInspector.  Thus, ContextVariablesInspector 
does get its own inspect: method.

	Andrew