hg/stx-libbasic: comparison Metaclass.st

equal deleted inserted replaced

-:be947d4e7fb2
+:514c749165c3
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
-All Rights Reserved
+	      All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 category:'Kernel-Classes'
 !
 Metaclass comment:'
 COPYRIGHT (c) 1988 by Claus Gittinger
-All Rights Reserved
+	      All Rights Reserved
-$Header: /cvs/stx/stx/libbasic/Metaclass.st,v 1.14 1994-08-05 00:58:57 claus Exp $
+$Header: /cvs/stx/stx/libbasic/Metaclass.st,v 1.15 1994-10-10 00:26:39 claus Exp $
 '!
 !Metaclass class methodsFor:'documentation'!
 copyright
 "
 COPYRIGHT (c) 1988 by Claus Gittinger
-All Rights Reserved
+	      All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 "
 !
 version
 "
-$Header: /cvs/stx/stx/libbasic/Metaclass.st,v 1.14 1994-08-05 00:58:57 claus Exp $
+$Header: /cvs/stx/stx/libbasic/Metaclass.st,v 1.15 1994-10-10 00:26:39 claus Exp $
 "
 !
 documentation
 "
 ! !
 !Metaclass methodsFor:'creating classes'!
 name:newName inEnvironment:aSystemDictionary
-subclassOf:aClass
+	     subclassOf:aClass
-instanceVariableNames:stringOfInstVarNames
+	     instanceVariableNames:stringOfInstVarNames
-variable:variableBoolean
+	     variable:variableBoolean
-words:wordsBoolean
+	     words:wordsBoolean
-pointers:pointersBoolean
+	     pointers:pointersBoolean
-classVariableNames:stringOfClassVarNames
+	     classVariableNames:stringOfClassVarNames
-poolDictionaries:stringOfPoolNames
+	     poolDictionaries:stringOfPoolNames
-category:categoryString
+	     category:categoryString
-comment:commentString
+	     comment:commentString
-changed:changed
+	     changed:changed
 "this is the main workhorse for installing new classes - special care
 has to be taken, when changing an existing classes definition. In this
 case, some or all of the methods and subclasses methods have to be
 recompiled.
 changeSet1 changeSet2 offset oldOffsets newOffsets addedNames
 anyChange oldInstVars newInstVars oldClassVars newClassVars upd superFlags newFlags|
 "NOTICE:
 this method is too complex and should be splitted into managable pieces ...
 I dont like it anymore :-)
+(However, its a good test for the compilers ability to handle big, complex methods ;-)
 "
 newName = aClass name ifTrue:[
-self error:'trying to create circular class definition'.
+	self error:'trying to create circular class definition'.
-^ nil
+	^ nil
 ].
 "check for invalid subclassing of UndefinedObject and SmallInteger"
 aClass canBeSubclassed ifFalse:[
-self error:('it is not possible to subclass ' , aClass name).
+	self error:('it is not possible to subclass ' , aClass name).
-^ oldClass
+	^ oldClass
 ].
 nInstVars := stringOfInstVarNames countWords.
 nameString := newName asString.
 classSymbol := newName asSymbol.
 newComment := commentString.
 "look, if it already exists as a class"
 oldClass := aSystemDictionary at:classSymbol ifAbsent:[nil].
 oldClass isBehavior ifFalse:[
-oldClass := nil.
+	oldClass := nil.
 ] ifTrue:[
-oldClass superclass notNil ifTrue:[
+	oldClass superclass notNil ifTrue:[
-oldClass allSuperclasses do:[:cls |
+	    oldClass allSuperclasses do:[:cls |
-cls name = nameString ifTrue:[
+		cls name = nameString ifTrue:[
-self error:'trying to create circular class definition'.
+		    self error:'trying to create circular class definition'.
-^ nil
+		    ^ nil
-]
+		]
-]
+	    ]
-].
+	].
-aClass superclass notNil ifTrue:[
+	aClass superclass notNil ifTrue:[
-aClass allSuperclasses do:[:cls |
+	    aClass allSuperclasses do:[:cls |
-cls name = nameString ifTrue:[
+		cls name = nameString ifTrue:[
-self error:'trying to create circular class definition'.
+		    self error:'trying to create circular class definition'.
-^ nil
+		    ^ nil
-]
+		]
-].
+	    ].
-].
+	].
-newComment isNil ifTrue:[
+	newComment isNil ifTrue:[
-newComment := oldClass comment
+	    newComment := oldClass comment
-].
+	].
-"
+	"
-warn, if it exists with different category and different instvars,
+	 warn, if it exists with different category and different instvars,
-and the existing is not an autoload class.
+	 and the existing is not an autoload class.
-Usually, this indicates that someone wants to create a new class with
+	 Usually, this indicates that someone wants to create a new class with
-a name, which already exists (it happened a few times to myself, while
+	 a name, which already exists (it happened a few times to myself, while
-I wanted to create a new class called ReturnNode ...).
+	 I wanted to create a new class called ReturnNode ...).
-This will be much less of a problem, once multiple name spaces are
+	 This will be much less of a problem, once multiple name spaces are
-implemented and classes can be put into separate packages.
+	 implemented and classes can be put into separate packages.
-"
+	"
-oldClass isLoaded ifTrue:[
+	oldClass isLoaded ifTrue:[
-oldClass category ~= categoryString ifTrue:[
+	    oldClass category ~= categoryString ifTrue:[
-oldClass instanceVariableString asCollectionOfWords
+		oldClass instanceVariableString asCollectionOfWords
-~= stringOfInstVarNames asCollectionOfWords ifTrue:[
+		~= stringOfInstVarNames asCollectionOfWords ifTrue:[
-(self confirm:'a class named ' , oldClass name , ' already exists -
+		    (self confirm:'a class named ' , oldClass name , ' already exists -
 create (i.e. change) anyway ?' withCRs)
-ifFalse:[
+		    ifFalse:[
-^ nil
+			^ nil
-]
+		    ]
-]
+		]
-]
+	    ]
-]
+	]
 ].
 "
 Check for some 'considered bad-style' things, like lower case names.
 But only do these checks for new classes -
 the outer codeview a chance to highlight the error.
 (but thats how its defined in the book - maybe I will change anyway).
 "
 oldClass isNil ifTrue:[
-"let user confirm, if the classname is no good"
+	"let user confirm, if the classname is no good"
-newName first isUppercase ifFalse:[
+	newName first isUppercase ifFalse:[
-(self confirm:'classenames should start with an uppercase letter
+	    (self confirm:'classenames should start with an uppercase letter
 (by convention only)
 install anyway ?' withCRs)
-ifFalse:[
+		ifFalse:[
-^ nil
+		    ^ nil
-]
+		]
-].
+	].
-"let user confirm, if any instvarname is no good"
+	"let user confirm, if any instvarname is no good"
-(stringOfInstVarNames asCollectionOfWords
+	(stringOfInstVarNames asCollectionOfWords
-inject:true
+		  inject:true
-into:[:okSoFar :word |
+		    into:[:okSoFar :word |
-okSoFar and:[word first isLowercase]
+			     okSoFar and:[word first isLowercase]
-]
+			 ]
-) ifFalse:[
+	) ifFalse:[
-(self confirm:'instance variable names should start with a lowercase letter
+	    (self confirm:'instance variable names should start with a lowercase letter
 (by convention only)
 install anyway ?' withCRs)
-ifFalse:[
+	    ifFalse:[
-^ nil
+		^ nil
-]
+	    ]
-].
+	].
-"let user confirm, if any classvarname is no good"
+	"let user confirm, if any classvarname is no good"
-(stringOfClassVarNames asCollectionOfWords
+	(stringOfClassVarNames asCollectionOfWords
-inject:true
+		  inject:true
-into:[:okSoFar :word |
+		    into:[:okSoFar :word |
-okSoFar and:[word first isUppercase]
+			     okSoFar and:[word first isUppercase]
-]
+			 ]
-) ifFalse:[
+	) ifFalse:[
-(self confirm:'class variable names should start with an uppercase letter
+	    (self confirm:'class variable names should start with an uppercase letter
 (by convention only)
 install anyway ?' withCRs)
-ifFalse:[
+	    ifFalse:[
-^ nil
+		^ nil
-]
+	    ]
-]
+	]
 ].
 "create the metaclass first"
 newMetaclass := Metaclass new.
 newMetaclass setSuperclass:(aClass class).
 ST-80 code will pass true or false as variableBoolean,
 while ST/X also calls it with symbols such as #float, #double etc.
 "
 (variableBoolean == true) ifTrue:[
-pointersBoolean ifTrue:[
+	pointersBoolean ifTrue:[
-newFlags := Behavior flagPointers
+	    newFlags := Behavior flagPointers
-] ifFalse:[
+	] ifFalse:[
-wordsBoolean ifTrue:[
+	    wordsBoolean ifTrue:[
-newFlags := Behavior flagWords
+		newFlags := Behavior flagWords
-] ifFalse:[
+	    ] ifFalse:[
-newFlags := Behavior flagBytes
+		newFlags := Behavior flagBytes
-]
+	    ]
-]
+	]
 ] ifFalse:[
-(variableBoolean == #float) ifTrue:[
+	(variableBoolean == #float) ifTrue:[
-newFlags := Behavior flagFloats
+	    newFlags := Behavior flagFloats
-] ifFalse:[
+	] ifFalse:[
-(variableBoolean == #double) ifTrue:[
+	    (variableBoolean == #double) ifTrue:[
-newFlags := Behavior flagDoubles
+		newFlags := Behavior flagDoubles
-] ifFalse:[
+	    ] ifFalse:[
-(variableBoolean == #long) ifTrue:[
+		(variableBoolean == #long) ifTrue:[
-newFlags := Behavior flagLongs
+		    newFlags := Behavior flagLongs
-] ifFalse:[
+		] ifFalse:[
-newFlags := Behavior flagNotIndexed
+		    newFlags := Behavior flagNotIndexed
-]
+		]
-]
+	    ]
-].
+	].
 ].
 superFlags := aClass flags bitAnd:(Behavior maskIndexType bitInvert). "preserve other bits"
 oldClass notNil ifTrue:[
-oldClass isBuiltInClass ifTrue:[
+	oldClass isBuiltInClass ifTrue:[
-"
+	    "
-special care when redefining Method, Block and other built-in classes,
+	     special care when redefining Method, Block and other built-in classes,
-which might have other flag bits ...
+	     which might have other flag bits ...
-"
+	    "
-newFlags := newFlags bitOr:(oldClass flags bitAnd:(Behavior maskIndexType bitInvert))
+	    newFlags := newFlags bitOr:(oldClass flags bitAnd:(Behavior maskIndexType bitInvert))
-]
+	]
 ].
 newClass flags:(newFlags bitOr:superFlags). "preserve  inherited special bits"
 (nInstVars ~~ 0) ifTrue:[
-newClass instanceVariableString:stringOfInstVarNames
+	newClass instanceVariableString:stringOfInstVarNames
 ].
 oldClass notNil ifTrue:[
-"setting first will make new class clear obsolete classvars"
+	"setting first will make new class clear obsolete classvars"
-newClass setClassVariableString:(oldClass classVariableString)
+	newClass setClassVariableString:(oldClass classVariableString)
 ].
 newClass classVariableString:stringOfClassVarNames.
 "
 for new classes, we are almost done here
 (also for autoloaded classes)
 "
 (oldClass isNil or:[oldClass isLoaded not]) ifTrue:[
-oldClass isNil ifTrue:[
+	oldClass isNil ifTrue:[
-self addChangeRecordForClass:newClass.
+	    self addChangeRecordForClass:newClass.
-].
+	].
-commentString notNil ifTrue:[
+	commentString notNil ifTrue:[
-newClass comment:commentString
+	    newClass comment:commentString
-].
+	].
-aSystemDictionary at:classSymbol put:newClass.
+	aSystemDictionary at:classSymbol put:newClass.
-aSystemDictionary changed.
+	aSystemDictionary changed:#newClass with:newClass.
-^ newClass
+	^ newClass
 ].
 "
 here comes the hard part - we are actually changing the
 inheritance do not change.
 In this case, we can go ahead and patch the class object.
 "
 (oldClass superclass == newClass superclass) ifTrue:[
 (oldClass instSize == newClass instSize) ifTrue:[
-(oldClass flags == newClass flags) ifTrue:[
+	(oldClass flags == newClass flags) ifTrue:[
-(oldClass name = newClass name) ifTrue:[
+	  (oldClass name = newClass name) ifTrue:[
-(oldInstVars = newInstVars) ifTrue:[
+	    (oldInstVars = newInstVars) ifTrue:[
-(newComment ~= oldClass comment) ifTrue:[
+	      (newComment ~= oldClass comment) ifTrue:[
-oldClass comment:newComment.        "writes a change-chunk"
+		  oldClass setComment:newComment.        "writes a change-chunk"
-].
+		  oldClass changed:#comment with:oldClass comment.
+		  self addChangeRecordForClassComment:oldClass.
-(oldClassVars = newClassVars) ifTrue:[
+	      ].
-"
-really no change (just comment and/or category)
+	      (oldClassVars = newClassVars) ifTrue:[
-"
+		"
-anyChange := false.
+		 really no change (just comment and/or category)
+		"
-oldClass instanceVariableString:(newClass instanceVariableString).
+		anyChange := false.
-oldClass setClassVariableString:(newClass classVariableString).
+		oldClass instanceVariableString:(newClass instanceVariableString).
-oldClass category ~= categoryString ifTrue:[
+		oldClass setClassVariableString:(newClass classVariableString).
-"notify change of organization"
+		oldClass category ~= categoryString ifTrue:[
-oldClass category:categoryString.
+		    oldClass category:categoryString.
-self addChangeRecordForClass:newClass.
+		    self addChangeRecordForClass:newClass.
-aSystemDictionary changed
+		    "notify change of organization"
-].
+		    aSystemDictionary changed
-"notify change of class"
+		].
-oldClass changed.
+		"notify change of class"
-^ oldClass
+"/                oldClass changed.
-].
+		^ oldClass
+	      ].
-"
-when we arrive here, class variables have changed
+	      "
-"
+	       when we arrive here, class variables have changed
-oldClass category ~= categoryString ifTrue:[
+	      "
-"notify change of organization"
+	      oldClass category ~= categoryString ifTrue:[
-oldClass category:categoryString.
+		  "notify change of organization"
-aSystemDictionary changed
+		  oldClass category:categoryString.
-].
+		  "notify change of organization"
+		  aSystemDictionary changed
-"
+	      ].
-set class variable string;
-this also updates the set of class variables
+	      "
-by creating new / deleting obsolete ones.
+	       set class variable string;
-"
+	       this also updates the set of class variables
-oldClass classVariableString:stringOfClassVarNames.
+	       by creating new / deleting obsolete ones.
+	      "
-"
+	      oldClass classVariableString:stringOfClassVarNames.
-get the set of changed class variables
-"
+	      "
-changeSet1 := Set new.
+	       get the set of changed class variables
-oldClassVars do:[:nm |
+	      "
-(newClassVars includes:nm) ifFalse:[
+	      changeSet1 := Set new.
-changeSet1 add:nm
+	      oldClassVars do:[:nm |
-]
+		  (newClassVars includes:nm) ifFalse:[
-].
+		      changeSet1 add:nm
-newClassVars do:[:nm |
+		  ]
-(oldClassVars includes:nm) ifFalse:[
+	      ].
-changeSet1 add:nm
+	      newClassVars do:[:nm |
-]
+		  (oldClassVars includes:nm) ifFalse:[
-].
+		      changeSet1 add:nm
+		  ]
-"
+	      ].
-recompile all methods accessing set of changed classvars
-here and also in all subclasses ...
+	      "
-"
+	       recompile all methods accessing set of changed classvars
+	       here and also in all subclasses ...
-"
+	      "
-dont update change file for the recompilation
-"
+	      "
-upd := Class updateChanges:false.
+	       dont update change file for the recompilation
-[
+	      "
-" "
+	      upd := Class updateChanges:false.
-Transcript showCr:'recompiling class & inst methods accessing ' , changeSet1 printString.
+	      [
-Transcript endEntry.
+" "
-" "
+		  Transcript showCr:'recompiling class & inst methods accessing ' , changeSet1 printString.
-oldClass withAllSubclasses do:[:aClass |
+		  Transcript endEntry.
-aClass class recompileMethodsAccessingAny:changeSet1.
+" "
-aClass recompileMethodsAccessingAny:changeSet1.
+		  oldClass withAllSubclasses do:[:aClass |
-].
+		      aClass class recompileMethodsAccessingAny:changeSet1.
-] valueNowOrOnUnwindDo:[
+		      aClass recompileMethodsAccessingAny:changeSet1.
-Class updateChanges:upd.
+		  ].
-].
+	      ] valueNowOrOnUnwindDo:[
+		  Class updateChanges:upd.
-"notify change of class"
+	      ].
-self addChangeRecordForClass:oldClass.
-oldClass changed.
+	      "notify change of class"
+	      self addChangeRecordForClass:oldClass.
-^ oldClass
+	      oldClass changed:#definition.
-]
-]
+	      ^ oldClass
-]
+	    ]
+	  ]
+	]
 ]
 ].
-"tell dependents ..."
-"OLD:
-oldClass changed.
-"
 "
 here we enter the darkness of mordor ...
+since instance variable layout and/or inheritance has changed.
 "
 (newComment ~= oldClass comment) ifTrue:[
-newClass comment:newComment
+	newClass comment:newComment
 ].
 superClassChange := oldClass superclass ~~ newClass superclass.
 "
 dont allow built-in classes to be modified this way
 "
 (oldClass notNil and:[oldClass isBuiltInClass and:[superClassChange]]) ifTrue:[
-self error:'the inheritance of this class is fixed - you cannot change it'.
+	self error:'the inheritance of this class is fixed - you cannot change it'.
-^ oldClass
+	^ oldClass
 ].
 "
 catch special case, where superclass changed its layout and thus
 forced redefinition of this class;
 (superClassChange
 and:[(oldClass superclass isNil or:[oldClass superclass name = newClass superclass name])
 and:[(oldClassVars = newClassVars)
 and:[(oldInstVars = newInstVars)
 and:[newComment = oldClass comment]]]]) ifFalse:[
-self addChangeRecordForClass:newClass.
+	self addChangeRecordForClass:newClass.
 ].
 "
 care for class methods ...
 "
 changeSet1 := Set new.
 classVarChange := false.
 superClassChange ifTrue:[
-"
+	"
-superclass changed:
+	 superclass changed:
-must recompile all class methods accessing ANY classvar
+	 must recompile all class methods accessing ANY classvar
-(
+	 (
-actually, we could be less strict and handle the case where
+	  actually, we could be less strict and handle the case where
-both the old and the new superclass have a common ancestor,
+	  both the old and the new superclass have a common ancestor,
-and both have no new classvariables in between.
+	  and both have no new classvariables in between.
-This would speedup the case when a class is inserted into
+	  This would speedup the case when a class is inserted into
-the inheritance chain.
+	  the inheritance chain.
-)
+	 )
-"
+	"
-oldClass allClassVarNames do:[:nm | changeSet1 add:nm].
+	oldClass allClassVarNames do:[:nm | changeSet1 add:nm].
-newClass allClassVarNames do:[:nm | changeSet1 add:nm].
+	newClass allClassVarNames do:[:nm | changeSet1 add:nm].
 " "
-Transcript showCr:'recompiling class methods accessing any classvar'.
+	Transcript showCr:'recompiling class methods accessing any classvar'.
-Transcript endEntry.
+	Transcript endEntry.
 " "
-self copyInvalidatedMethodsFrom:(oldClass class) for:newMetaclass accessingAny:changeSet1.
+	self copyInvalidatedMethodsFrom:(oldClass class)
-newMetaclass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
+				    for:newMetaclass
+			   accessingAny:changeSet1
+				orSuper:true.
+	newMetaclass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
 ] ifFalse:[
-"
+	"
-same superclass, find out which classvars have changed
+	 same superclass, find out which classvars have changed
-"
+	"
-classVarChange := oldClassVars ~= newClassVars.
+	classVarChange := oldClassVars ~= newClassVars.
-classVarChange ifTrue:[
+	classVarChange ifTrue:[
-oldClassVars do:[:nm |
+	    oldClassVars do:[:nm |
-(newClassVars includes:nm) ifFalse:[
+		(newClassVars includes:nm) ifFalse:[
-changeSet1 add:nm
+		    changeSet1 add:nm
-]
+		]
-].
+	    ].
-newClassVars do:[:nm |
+	    newClassVars do:[:nm |
-(oldClassVars includes:nm) ifFalse:[
+		(oldClassVars includes:nm) ifFalse:[
-changeSet1 add:nm
+		    changeSet1 add:nm
-]
+		]
-].
+	    ].
-].
+	].
-classVarChange ifTrue:[
+	classVarChange ifTrue:[
-"
+	    "
-must recompile some class-methods
+	     must recompile some class-methods
-"
+	    "
 " "
-Transcript showCr:'recompiling class methods accessing ' , changeSet1 printString.
+	    Transcript showCr:'recompiling class methods accessing ' , changeSet1 printString.
-Transcript endEntry.
+	    Transcript endEntry.
 " "
-self copyInvalidatedMethodsFrom:(oldClass class) for:newMetaclass accessingAny:changeSet1.
+	    self copyInvalidatedMethodsFrom:(oldClass class) for:newMetaclass accessingAny:changeSet1.
-newMetaclass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
+	    newMetaclass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
-] ifFalse:[
+	] ifFalse:[
-"
+	    "
-class methods still work
+	     class methods still work
-"
+	    "
-self copyMethodsFrom:(oldClass class) for:newMetaclass
+	    self copyMethodsFrom:(oldClass class) for:newMetaclass
-].
+	].
 ].
 "
 care for instance methods ...
 "
 changeSet2 := Set new.
 superClassChange ifTrue:[
-"superclass changed,
+	"superclass changed,
-must recompile all methods accessing any class or instvar.
+	 must recompile all methods accessing any class or instvar.
-If number of instvars (i.e. the instances instSize) is the same,
+	 If number of instvars (i.e. the instances instSize) is the same,
-we can limit the set of recompiled instance methods to those methods,
+	 we can limit the set of recompiled instance methods to those methods,
-which refer to an instvar with a different inst-index
+	 which refer to an instvar with a different inst-index
-"
+	"
-"
+	"
-collect the instvar-indices in the old and new class
+	 collect the instvar-indices in the old and new class
-"
+	"
-offset := 0. oldOffsets := Dictionary new.
+	offset := 0. oldOffsets := Dictionary new.
-oldClass allInstVarNames do:[:nm | offset := offset + 1. oldOffsets at:nm put:offset].
+	oldClass allInstVarNames do:[:nm | offset := offset + 1. oldOffsets at:nm put:offset].
-offset := 0. newOffsets := Dictionary new.
+	offset := 0. newOffsets := Dictionary new.
-newClass allInstVarNames do:[:nm | offset := offset + 1. newOffsets at:nm put:offset].
+	newClass allInstVarNames do:[:nm | offset := offset + 1. newOffsets at:nm put:offset].
-"
+	"
-the changeset consists of instance variables,
+	 the changeset consists of instance variables,
-whith a different position
+	 whith a different position
-"
+	"
-oldOffsets associationsDo:[:a |
+	oldOffsets associationsDo:[:a |
-|k|
+	    |k|
-k := a key.
+	    k := a key.
-(newOffsets includesKey:k) ifFalse:[
+	    (newOffsets includesKey:k) ifFalse:[
-changeSet2 add:k
+		changeSet2 add:k
-] ifTrue:[
+	    ] ifTrue:[
-(a value ~~ (newOffsets at:k)) ifTrue:[
+		(a value ~~ (newOffsets at:k)) ifTrue:[
-changeSet2 add:k
+		    changeSet2 add:k
-]
+		]
-]
+	    ]
-].
+	].
-newOffsets associationsDo:[:a |
+	newOffsets associationsDo:[:a |
-|k|
+	    |k|
-k := a key.
+	    k := a key.
-(oldOffsets includesKey:k) ifFalse:[
+	    (oldOffsets includesKey:k) ifFalse:[
-changeSet2 add:k
+		changeSet2 add:k
-] ifTrue:[
+	    ] ifTrue:[
-(a value ~~ (oldOffsets at:k)) ifTrue:[
+		(a value ~~ (oldOffsets at:k)) ifTrue:[
-changeSet2 add:k
+		    changeSet2 add:k
-]
+		]
-]
+	    ]
-].
+	].
-"
+	"
-merge in the changed class variables
+	 merge in the changed class variables
-"
+	"
-changeSet1 do:[:nm | changeSet2 add:nm].
+	changeSet1 do:[:nm | changeSet2 add:nm].
 " "
-Transcript showCr:'recompiling instance methods accessing ' , changeSet2 printString , ' ...'.
+	Transcript showCr:'recompiling instance methods accessing ' , changeSet2 printString , ' ...'.
-Transcript endEntry.
+	Transcript endEntry.
 " "
-self copyInvalidatedMethodsFrom:oldClass for:newClass accessingAny:changeSet2.
+	self copyInvalidatedMethodsFrom:oldClass
-newClass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
+				    for:newClass
+			   accessingAny:changeSet2
+				orSuper:true.
+	newClass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
 ] ifFalse:[
-"
+	"
-same inheritance ...
+	 same inheritance ...
-"
+	"
-instVarChange := oldInstVars ~= newInstVars.
+	instVarChange := oldInstVars ~= newInstVars.
-instVarChange ifFalse:[
+	instVarChange ifFalse:[
-"
+	    "
-same instance variables ...
+	     same instance variables ...
-"
+	    "
-classVarChange ifTrue:[
+	    classVarChange ifTrue:[
-"recompile all inst methods accessing changed classvars"
+		"recompile all inst methods accessing changed classvars"
 " "
-Transcript showCr:'recompiling instance methods accessing ' , changeSet1 printString , ' ...'.
+		Transcript showCr:'recompiling instance methods accessing ' , changeSet1 printString , ' ...'.
-Transcript endEntry.
+		Transcript endEntry.
 " "
-self copyInvalidatedMethodsFrom:oldClass for:newClass accessingAny:changeSet1.
+		self copyInvalidatedMethodsFrom:oldClass for:newClass accessingAny:changeSet1.
-newClass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
+		newClass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
-]
+	    ]
-] ifTrue:[
+	] ifTrue:[
-"
+	    "
-dont allow built-in classes to be modified
+	     dont allow built-in classes to be modified
-"
+	    "
-(oldClass notNil and:[oldClass isBuiltInClass and:[instVarChange]]) ifTrue:[
+	    (oldClass notNil and:[oldClass isBuiltInClass and:[instVarChange]]) ifTrue:[
-self error:'the layout of this class is fixed - you cannot change it'.
+		self error:'the layout of this class is fixed - you cannot change it'.
-^ oldClass
+		^ oldClass
-].
+	    ].
-((oldInstVars size == 0)
+	    ((oldInstVars size == 0)
-or:[newInstVars startsWith:oldInstVars]) ifTrue:[
+	    or:[newInstVars startsWith:oldInstVars]) ifTrue:[
-"
+		"
-only new inst variable(s) has/have been added -
+		 only new inst variable(s) has/have been added -
-old methods still work (the existing inst-indices are still valid)
+		 old methods still work (the existing inst-indices are still valid)
-"
+		"
 " "
-Transcript showCr:'copying methods ...'.
+		Transcript showCr:'copying methods ...'.
-Transcript endEntry.
+		Transcript endEntry.
 " "
-self copyMethodsFrom:oldClass for:newClass.
+		self copyMethodsFrom:oldClass for:newClass.
-"
+		"
-but: we have to recompile all methods accessing new instars
+		 but: we have to recompile all methods accessing new instars
-(it might have been a classVar/global before ...)
+		 (it might have been a classVar/global before ...)
-"
+		"
-addedNames := newInstVars select:[:nm | (oldInstVars includes:nm) not].
+		addedNames := newInstVars select:[:nm | (oldInstVars includes:nm) not].
-"merge in class variables"
+		"merge in class variables"
-changeSet1 do:[:nm | addedNames add:nm].
+		changeSet1 do:[:nm | addedNames add:nm].
 " "
-Transcript showCr:'recompiling instance methods accessing ' , addedNames printString ,  '...'.
+		Transcript showCr:'recompiling instance methods accessing ' , addedNames printString ,  '...'.
-Transcript endEntry.
+		Transcript endEntry.
 " "
-newClass recompileMethodsAccessingAny:addedNames.
+		newClass recompileMethodsAccessingAny:addedNames.
-] ifFalse:[
+	    ] ifFalse:[
-"
+		"
-collect the instvar-indices in the old and new class
+		 collect the instvar-indices in the old and new class
-"
+		"
-offset := 0. oldOffsets := Dictionary new.
+		offset := 0. oldOffsets := Dictionary new.
-oldInstVars do:[:nm | offset := offset + 1. oldOffsets at:nm put:offset].
+		oldInstVars do:[:nm | offset := offset + 1. oldOffsets at:nm put:offset].
-offset := 0. newOffsets := Dictionary new.
+		offset := 0. newOffsets := Dictionary new.
-newInstVars do:[:nm | offset := offset + 1. newOffsets at:nm put:offset].
+		newInstVars do:[:nm | offset := offset + 1. newOffsets at:nm put:offset].
-"
+		"
-the changeset consists of instance variables,
+		 the changeset consists of instance variables,
-whith a different position
+		 whith a different position
-"
+		"
-oldOffsets associationsDo:[:a |
+		oldOffsets associationsDo:[:a |
-|k|
+		    |k|
-k := a key.
+		    k := a key.
-(newOffsets includesKey:k) ifFalse:[
+		    (newOffsets includesKey:k) ifFalse:[
-changeSet2 add:k
+			changeSet2 add:k
-] ifTrue:[
+		    ] ifTrue:[
-(a value ~~ (newOffsets at:k)) ifTrue:[
+			(a value ~~ (newOffsets at:k)) ifTrue:[
-changeSet2 add:k
+			    changeSet2 add:k
-]
+			]
-]
+		    ]
-].
+		].
-newOffsets associationsDo:[:a |
+		newOffsets associationsDo:[:a |
-|k|
+		    |k|
-k := a key.
+		    k := a key.
-(oldOffsets includesKey:k) ifFalse:[
+		    (oldOffsets includesKey:k) ifFalse:[
-changeSet2 add:k
+			changeSet2 add:k
-] ifTrue:[
+		    ] ifTrue:[
-(a value ~~ (oldOffsets at:k)) ifTrue:[
+			(a value ~~ (oldOffsets at:k)) ifTrue:[
-changeSet2 add:k
+			    changeSet2 add:k
-]
+			]
-]
+		    ]
-].
+		].
-"merge in class variables"
+		"merge in class variables"
-changeSet1 do:[:nm | changeSet2 add:nm].
+		changeSet1 do:[:nm | changeSet2 add:nm].
 " "
-Transcript showCr:'recompiling instance methods accessing ' , changeSet2 printString , ' ...'.
+		Transcript showCr:'recompiling instance methods accessing ' , changeSet2 printString , ' ...'.
-Transcript endEntry.
+		Transcript endEntry.
 " "
-self copyInvalidatedMethodsFrom:oldClass for:newClass accessingAny:changeSet2.
+		self copyInvalidatedMethodsFrom:oldClass for:newClass accessingAny:changeSet2.
-newClass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
+		newClass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
-].
+	    ].
-].
+	].
 ].
 "
 WOW, everything done for this class
 what about subclasses ?
 this forces recompilation (recursively) if needed
 (dont update change file for the subclass changes)
 "
 upd := Class updateChanges:false.
 [
-oldClass subclassesDo:[:aClass |
+	oldClass subclassesDo:[:aClass |
 " "
-Transcript showCr:'changing superclass of:' , aClass name.
+	    Transcript showCr:'changing superclass of:' , aClass name.
-Transcript endEntry.
+	    Transcript endEntry.
 " "
-aClass superclass:newClass
+	    aClass superclass:newClass
-]
+	]
 ] valueNowOrOnUnwindDo:[
-Class updateChanges:upd.
+	Class updateChanges:upd.
 ].
 "
 change category in oldClass - so we see immediately what it is ...
 "
 and make the new class globally known
 "
 aSystemDictionary at:classSymbol put:newClass.
 oldClass category ~= categoryString ifTrue:[
-"notify change of organization"
+	"notify change of organization"
-aSystemDictionary changed
+	aSystemDictionary changed
 ].
 "
 Not becoming the old class creates some update problems;
 the browsers must check carefully - a simple identity compare is
-not enought ...
+not enough ...
 QUESTION: is this a good idea ?
 "
 newClass dependents:(oldClass dependents).
 newClass changed.
-"just to make certain ... - telle dependents of oldClass, that something changed
+"just to make certain ... - tell dependents of oldClass, that something changed
 (systemBrowsers will react on this, and update their views)"
-oldClass changed:newClass.
+oldClass changed:#definition with:newClass.
 ObjectMemory flushCaches.
 ^ newClass
 !
 |newClass|
 newClass := self basicNew.
 newClass setSuperclass:(Object class)
-selectors:(Array new:0)
+		 selectors:(Array new:0)
-methods:(Array new:0)
+		   methods:(Array new:0)
-instSize:0
+		  instSize:0
-flags:(Behavior flagNotIndexed).
+		     flags:(Behavior flagNotIndexed).
 newClass setComment:(self comment) category:(self category).
 ^ newClass
 ! !
 !Metaclass methodsFor:'class instance variables'!
 "
 oldVars := self instanceVariableString.
 aString = oldVars ifTrue:[
 "
-Transcript showCr:'no change (', oldVars , ') -> (', aString , ')'.
+	Transcript showCr:'no change (', oldVars , ') -> (', aString , ')'.
 "
-^ self
+	^ self
 ].
 oldNames := oldVars asCollectionOfWords.
 newNames := aString asCollectionOfWords.
 oldNames = newNames ifTrue:[
 "
-Transcript showCr:'no real change'.
+	Transcript showCr:'no real change'.
 "
-"no real change (just formatting)"
+	"no real change (just formatting)"
-self instanceVariableString:aString.
+	self instanceVariableString:aString.
-^ self
+	^ self
 ].
 "
 let user confirm, if any name is no good (and was good before)
 "
 (oldNames inject:true
-into:[:okSoFar :word |
+		into:[:okSoFar :word |
-okSoFar and:[word first isUppercase]
+			 okSoFar and:[word first isUppercase]
-])
+		     ])
 ifTrue:[
-"was ok before"
+	"was ok before"
-(newNames inject:true
+	(newNames inject:true
-into:[:okSoFar :word |
+		    into:[:okSoFar :word |
-okSoFar and:[word first isUppercase]
+			     okSoFar and:[word first isUppercase]
-])
+			 ])
-ifFalse:[
+	ifFalse:[
-(self confirm:'class instance variable names should start with an uppercase letter
+	    (self confirm:'class instance variable names should start with an uppercase letter
 (by convention only)
 install anyway ?' withCRs)
-ifFalse:[
+	    ifFalse:[
-^ nil
+		^ nil
-]
+	    ]
-]
+	]
 ].
 nClassInstVars := newNames size.
 "
 "create the new metaclass"
 newMetaclass := Metaclass new.
 newMetaclass setSuperclass:superclass.
 newMetaclass instSize:(superclass instSize + nClassInstVars).
 (nClassInstVars ~~ 0) ifTrue:[
-newMetaclass instanceVariableString:aString
+	newMetaclass instanceVariableString:aString
 ].
 newMetaclass flags:(Behavior flagNotIndexed).
 newMetaclass setName:name.
 newMetaclass classVariableString:classvars.
 newMetaclass category:category.
 "find the class which is my sole instance"
 t := Smalltalk allClasses select:[:element | element class == self].
 (t size ~~ 1) ifTrue:[
-self error:'oops - I should have exactly one instance'.
+	self error:'oops - I should have exactly one instance'.
-^ nil
+	^ nil
 ].
 oldClass := t anElement.
 "create a new class"
 newClass := newMetaclass new.
 offset := 0. newOffsets := Dictionary new.
 newNames do:[:nm | offset := offset + 1. newOffsets at:nm put:offset].
 changeSet := Set new.
 oldOffsets associationsDo:[:a |
-|k|
+	|k|
-k := a key.
+	k := a key.
-(newOffsets includesKey:k) ifFalse:[
+	(newOffsets includesKey:k) ifFalse:[
-changeSet add:k
+	    changeSet add:k
-] ifTrue:[
+	] ifTrue:[
-(a value ~~ (newOffsets at:k)) ifTrue:[
+	    (a value ~~ (newOffsets at:k)) ifTrue:[
-changeSet add:k
+		changeSet add:k
-]
+	    ]
-]
+	]
 ].
 newOffsets associationsDo:[:a |
-|k|
+	|k|
-k := a key.
+	k := a key.
-(oldOffsets includesKey:k) ifFalse:[
+	(oldOffsets includesKey:k) ifFalse:[
-changeSet add:k
+	    changeSet add:k
-] ifTrue:[
+	] ifTrue:[
-(a value ~~ (oldOffsets at:k)) ifTrue:[
+	    (a value ~~ (oldOffsets at:k)) ifTrue:[
-changeSet add:k
+		changeSet add:k
-]
+	    ]
-]
+	]
 ].
 ((oldNames size == 0)
 or:[newNames startsWith:oldNames]) ifTrue:[
-"new variable(s) has/have been added - old methods still work"
+	"new variable(s) has/have been added - old methods still work"
 " "
-Transcript showCr:'copying methods ...'.
+	Transcript showCr:'copying methods ...'.
-Transcript endEntry.
+	Transcript endEntry.
 " "
-self copyMethodsFrom:self for:newMetaclass.
+	self copyMethodsFrom:self for:newMetaclass.
-self copyMethodsFrom:oldClass for:newClass.
+	self copyMethodsFrom:oldClass for:newClass.
-"but have to recompile methods accessing stuff now defined
+	"but have to recompile methods accessing stuff now defined
-(it might have been a global before ...)"
+	 (it might have been a global before ...)"
-addedNames := newNames select:[:nm | (oldNames includes:nm) not].
+	addedNames := newNames select:[:nm | (oldNames includes:nm) not].
 "
-Transcript showCr:'recompiling methods accessing ' , addedNames printString ,  '...'.
+	Transcript showCr:'recompiling methods accessing ' , addedNames printString ,  '...'.
-Transcript endEntry.
+	Transcript endEntry.
 "
-"recompile class-methods"
+	"recompile class-methods"
-newMetaclass recompileMethodsAccessingAny:addedNames.
+	newMetaclass recompileMethodsAccessingAny:addedNames.
 ] ifFalse:[
 "
-Transcript showCr:'recompiling methods accessing ' , changeSet printString , ' ...'.
+	Transcript showCr:'recompiling methods accessing ' , changeSet printString , ' ...'.
-Transcript endEntry.
+	Transcript endEntry.
 "
-"recompile class-methods"
+	"recompile class-methods"
-self copyInvalidatedMethodsFrom:self for:newMetaclass accessingAny:changeSet.
+	self copyInvalidatedMethodsFrom:self for:newMetaclass accessingAny:changeSet.
-newMetaclass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
+	newMetaclass recompileInvalidatedMethods:(Metaclass compiledMethodAt:#invalidMethod).
-self copyMethodsFrom:oldClass for:newClass.
+	self copyMethodsFrom:oldClass for:newClass.
 ].
 delta := newNames size - oldNames size.
 "
 get list of all subclasses - do before superclass is changed
 "
 allSubclasses := oldClass allSubclasses.
 allSubclasses := allSubclasses asSortedCollection:[:a :b |
-b isSubclassOf:a
+				b isSubclassOf:a
-].
+		     ].
 oldToNew := IdentityDictionary new.
 "create a new class tree, based on new version"
 allSubclasses do:[:aSubclass |
-oldSuper := aSubclass superclass.
+	oldSuper := aSubclass superclass.
-oldSubMeta := aSubclass class.
+	oldSubMeta := aSubclass class.
-newSubMeta := Metaclass new.
+	newSubMeta := Metaclass new.
-oldSuper == oldClass ifTrue:[
+	oldSuper == oldClass ifTrue:[
-newSubMeta setSuperclass:newMetaclass.
+	    newSubMeta setSuperclass:newMetaclass.
-] ifFalse:[
+	] ifFalse:[
-newSubMeta setSuperclass:(oldToNew at:oldSuper) class.
+	    newSubMeta setSuperclass:(oldToNew at:oldSuper) class.
-].
+	].
-newSubMeta instSize:(oldSubMeta instSize + delta).
+	newSubMeta instSize:(oldSubMeta instSize + delta).
-newSubMeta flags:(oldSubMeta flags).
+	newSubMeta flags:(oldSubMeta flags).
-newSubMeta setName:(oldSubMeta name).
+	newSubMeta setName:(oldSubMeta name).
-newSubMeta classVariableString:(oldSubMeta classVariableString).
+	newSubMeta classVariableString:(oldSubMeta classVariableString).
-newSubMeta setComment:(oldSubMeta comment).
+	newSubMeta setComment:(oldSubMeta comment).
-newSubMeta category:(oldSubMeta category).
+	newSubMeta category:(oldSubMeta category).
-newSub := newSubMeta new.
+	newSub := newSubMeta new.
-oldSuper == oldClass ifTrue:[
+	oldSuper == oldClass ifTrue:[
-newSub setSuperclass:newClass.
+	    newSub setSuperclass:newClass.
-] ifFalse:[
+	] ifFalse:[
-newSub setSuperclass:(oldToNew at:oldSuper).
+	    newSub setSuperclass:(oldToNew at:oldSuper).
-].
+	].
-newSub setSelectorArray:(aSubclass selectorArray).
+	newSub setSelectorArray:(aSubclass selectorArray).
-newSub setMethodArray:(aSubclass methodArray).
+	newSub setMethodArray:(aSubclass methodArray).
-newSub setName:(aSubclass name).
+	newSub setName:(aSubclass name).
-newSub classVariableString:(aSubclass classVariableString).
+	newSub classVariableString:(aSubclass classVariableString).
-newSub setComment:(aSubclass comment).
+	newSub setComment:(aSubclass comment).
-newSub category:(aSubclass category).
+	newSub category:(aSubclass category).
-oldToNew at:aSubclass put:newSub.
+	oldToNew at:aSubclass put:newSub.
 "
-aSubclass setName:(aSubclass name , '-old').
+	aSubclass setName:(aSubclass name , '-old').
-aSubclass category:'obsolete classes'
+	aSubclass category:'obsolete classes'
 "
-aSubclass category:'obsolete'.
+	aSubclass category:'obsolete'.
-aSubclass class category:'obsolete'.
+	aSubclass class category:'obsolete'.
 ].
 "recompile what needs to be"
 delta == 0 ifTrue:[
-"only have to recompile class methods accessing
+	"only have to recompile class methods accessing
-class instvars from changeset
+	 class instvars from changeset
-"
+	"
-allSubclasses do:[:aClass |
+	allSubclasses do:[:aClass |
-aClass class recompileMethodsAccessingAny:changeSet.
+	    aClass class recompileMethodsAccessingAny:changeSet.
-]
+	]
 ] ifFalse:[
-"
+	"
-have to recompile all class methods accessing class instvars
+	 have to recompile all class methods accessing class instvars
-"
+	"
-allSubclasses do:[:aClass |
+	allSubclasses do:[:aClass |
-|classInstVars|
+	    |classInstVars|
-classInstVars := aClass class allInstVarNames.
+	    classInstVars := aClass class allInstVarNames.
-aClass class recompileMethodsAccessingAny:classInstVars.
+	    aClass class recompileMethodsAccessingAny:classInstVars.
-]
+	]
 ].
 self addChangeRecordForClassInstvars:newClass.
 "install all new classes"
 Smalltalk at:(oldClass name asSymbol) put:newClass.
 ObjectMemory flushCachesFor:oldClass.
 allSubclasses do:[:aClass |
-Smalltalk at:(oldToNew at:aClass) name asSymbol put:(oldToNew at:aClass).
+	Smalltalk at:(oldToNew at:aClass) name asSymbol put:(oldToNew at:aClass).
-ObjectMemory flushCachesFor:aClass.
+	ObjectMemory flushCachesFor:aClass.
 ].
 "tell dependents ..."
 oldClass changed.
 self error:'invalid method - this method failed to compile when the class was changed'
 !
 copyMethodsFrom:oldClass for:newClass
-"when a class has changed, but metaclass is unaffected (i.e. classVars
+"copy all methods from oldClass to newClass.
-have not changed) there is no need to recompile them"
+This is used for class-methods when a class has changed, but metaclass is
+unaffected (i.e. classVars/inheritance have not changed) so there is no need
+to recompile the class methods."
 newClass selectors:(oldClass selectorArray copy)
-methods:(oldClass methodArray copy)
+	       methods:(oldClass methodArray copy)
 !
 copyInvalidatedMethodsFrom:oldClass for:newClass
-"when a class has been changed, copy all old methods into the new class
+"copy all methods from oldClass to newClass and change their code
-- changing code to a trap method giving an error message;
+to a trap method reporting an error.
-this allows us to keep the source while trapping uncompilable (due to
+This is used when a class has been changed its layout or inheritance,
-now undefined instvars) methods"
+for all methods; before recompilation is attempted.
+This allows us to keep the source while trapping uncompilable (due to
+now undefined instvars) methods. Compilation of these methods will show
+an error on the transcript and lead to the debugger once called."
 |trap trapCode trapByteCode newMethod oldMethodArray newMethodArray|
 trap := Metaclass compiledMethodAt:#invalidMethod.
 trapCode := trap code.
 trapByteCode := trap byteCode.
 oldMethodArray := oldClass methodArray.
 newMethodArray := Array new:(oldMethodArray size).
 newClass selectors:(oldClass selectorArray copy)
-methods:newMethodArray.
+	       methods:newMethodArray.
 1 to:oldMethodArray size do:[:i |
-newMethod := (oldMethodArray at:i) copy.
+	newMethod := (oldMethodArray at:i) copy.
-newMethod code:trapCode.
+	newMethod code:trapCode.
-newMethod literals:nil.
+	newMethod literals:nil.
-newMethod byteCode:trapByteCode.
+	newMethod byteCode:trapByteCode.
-newMethodArray at:i put:newMethod
+	newMethodArray at:i put:newMethod
 ]
 !
 copyInvalidatedMethodsFrom:oldClass for:newClass accessingAny:setOfNames
 "copy all methods from oldClass to newClass. Those methods accessing
 a variable in setOfNames will be copied as invalid method, leading to
-a trap when its executed."
+a trap when its executed. This is used when a class has changed its
+layout for all methods which are affected by the change."
+self copyInvalidatedMethodsFrom:oldClass
+				for:newClass
+		       accessingAny:setOfNames
+			    orSuper:false
+!
+copyInvalidatedMethodsFrom:oldClass for:newClass accessingAny:setOfNames orSuper:superBoolean
+"copy all methods from oldClass to newClass.
+Those methods accessing a variable in setOfNames will be copied as invalid method,
+leading to a trap when its executed. If superBoolean is true, this is also done
+for methods accessing super.  This is used when a class has changed its
+layout for all methods which are affected by the change."
 |trap trapCode trapByteCode p oldMethod newMethod oldMethodArray newMethodArray|
 trap := Metaclass compiledMethodAt:#invalidMethod.
 trapCode := trap code.
 trapByteCode := trap byteCode.
 oldMethodArray := oldClass methodArray.
 newMethodArray := Array new:(oldMethodArray size).
 newClass selectors:(oldClass selectorArray copy)
-methods:newMethodArray.
+	       methods:newMethodArray.
 1 to:oldMethodArray size do:[:i |
-oldMethod := oldMethodArray at:i.
+	oldMethod := oldMethodArray at:i.
-p := Parser parseMethod:(oldMethod source) in:newClass.
+	p := Parser parseMethod:(oldMethod source) in:newClass.
-(p isNil or:[p usedVars notNil and:[p usedVars includesAny:setOfNames]]) ifTrue:[
+	(p isNil
-newMethod := oldMethod copy.
+	 or:[(p usedVars notNil and:[p usedVars includesAny:setOfNames])
-newMethod code:trapCode.
+	 or:[superBoolean and:[p usesSuper]]]) ifTrue:[
-newMethod literals:nil.
+	    newMethod := oldMethod copy.
-newMethod byteCode:trapByteCode
+	    newMethod code:trapCode.
-] ifFalse:[
+	    newMethod literals:nil.
-newMethod := oldMethod.
+	    newMethod byteCode:trapByteCode
-].
+	] ifFalse:[
-newMethodArray at:i put:newMethod
+	    newMethod := oldMethod.
+	].
+	newMethodArray at:i put:newMethod
 ]
 !
 anyInvalidatedMethodsIn:aClass
 "return true, if aClass has any invalidated methods in it"
 trap := Metaclass compiledMethodAt:#invalidMethod.
 trapCode := trap code.
 trapByteCode := trap byteCode.
 aClass methodArray do:[:aMethod |
-trapCode notNil ifTrue:[
+	trapCode notNil ifTrue:[
-(aMethod code == trapCode) ifTrue:[^ true]
+	    (aMethod code == trapCode) ifTrue:[^ true]
-].
+	].
-trapByteCode notNil ifTrue:[
+	trapByteCode notNil ifTrue:[
-(aMethod byteCode == trapByteCode) ifTrue:[^ true]
+	    (aMethod byteCode == trapByteCode) ifTrue:[^ true]
-]
+	]
 ].
 ^ false
 ! !

changeset 159	514c749165c3
parent 93	e31220cb391f
child 175	82ba8d2e3569