The abstract instance variable refactoring is available from the "selection" menu when you have selected an instance variable. It is also available from the "variables" menu in the class definition when you have selected an instance variable. Finally, it is available from the "Class"->"Instance variables" menu
Similarly, the abstract class variable refactoring is available from the "selection" menu when you have selected a class variable. It is also available from the "variables" menu in the class definition view when you have selected a class variable. Finally, it is available from the "Class"->"Class variables" menu.
Safety: The abstract variable refactorings are safe under normal circumstances.
The add parameter refactoring is available from the "Selector"->"Other"->"Add parameter..." menu item.
Safety: The add parameter is relatively safe assuming that the code that is added as a parameter is safe (i.e., the code doesn't have side-effects). One area where it would be unsafe is to add a parameter to a method that is #perform:ed since we can't determine where the method is performed from.
This refactoring is available from "Class"->"Class"->"Other"->"Convert to sibling"
Safety: This refactoring could fail if you check the class hierarchy of the superclass, since the class hierarchy is change for the new class.
This refactoring is available when you have selected an expression that is used as part of another expression. After you have selected the expresion, the "Selection" menu will contain the "Extract to temporary" menu choice.
Safety: Since this refactoring can change the evaluation order of the overall expression, it is not safe if there are side effects between those expression that are evaluated before the selected expression and the selected expression itself.
This refactoring is available from the "Selection"->"Inline method" menu when you select a message send in the code.
Safety: This refactoring is fairly safe. If the refactoring finds something that it considers unsafe, it will warn you before performing the refactoring. If you proceed through the warning it will still inline the method.
This refactoring is available from the "Selection"->"Inline parameter" when you select an argument to the method.
Safety: This refactoring is safe except when performing methods, since we can't convert the symbols that are performed.
This refactoring is available from the "Selection"->"Inline temporary" when you have an assignment statement selected.
Safety: This refactoring can be unsafe if the code you are inlining has side-effect or if any code between the assignment statement and the references have side effects on the inlined expression.
This refactoring is available from "Selector"->"Move"->"To component".
Safety: This refactoring is safe assuming you select the correct class(es) of the variable that should contain the new method.
This refactoring is available from "Selection"->"Move to inner scope" when you have selected a temporary variable in a method.
Safety: This refactoring is safe unless someone is looking at the source code.
This refactoring is available from "Class"->"Instance variables"->"Protect/Concrete".
Safety: This refactoring is essentially an Inline All Self Sends, so it contains all the safe restrictions as Inline All Self Sends has.
The pull up instance variable refactoring is available from the "Class"->"Instance Variables"->"Pull up" menu choice. It is also available as "Push up" when you have selected the variable in either the class definition or a method under the "Variables" and "Selection" menus.
Similarly, the pull up class variable is available from the "Class"->"Class variables"->"Pull up" menu choice. It is also available as "Push up" when you have selected the variable in either the class definition or a method under the "Variables" and "Selection" menus.
Safety: This refactoring is not safe if you code that depends on the exact layout of the class. Such code normally uses the #instVarAt:{put:} methods.
The push down instance/class variable refactoring is available from "Class"->"Instance/Class variables"->"Push down" and also from "Variables"->"Push down" when the variable is selected in the class definition.
Safety: This refactoring is safe unless one is accessing the variable using the #instVarAt:{put:} methods.
The push down method refactoring is available from "Selector"->"Other"->"Push down".
Safety: This refactoring is safe assuming that every class that sends #subclassResponsibility is abstract.
The push up method refactoring is available from "Selector"->"Other"->"Push up".
Safety: This refactoring is safe assuming that every class that sends #subclassResponsibility is abstract.
The remove class refactoring is available from the "Class"->"Class"->"Safe remove" menu choice.
Safety: This refactoring is safe if they are no indirect references to the class. Such references maybe from the #subclasses method or from performing "Smalltalk at: ...".
This refactoring is available from "Selector"->"Safe remove".
Safety: This refactoring is not safe if you have constructed selectors that perform the method (e.g., "self perform: 'foo' asSymbol). However, if you have code such as "self perform: #foo" then it will consider the #foo method referenced.
This refactoring is available from the "Selection"->"Remove parameter" menu when you have selected a parameter of a method.
Safety: This refactoring is not safe when you are perform:ing the method. Also, it is not safe if the parameter that is removed, has side-effects at one of its call sites.
The remove instance variable refactoring is available from the "Class"->"Instance variable"->"Remove..." menu as well as the "Variables" menu in the class definition when a variable is selected.
Similarly, the remove class variable refactoring is available from the "Class"->"Class variable"->"Remove..." menu as well as the "Variables" menu in the class definition when a class variable is selected.
Safety: This refactoring is safe under normal circumstances. However, if you have code that depends on the layout of the classes, then it may not be safe.
This refactoring is available from "Class"->"Class"->"Rename".
Safety: This refactoring is safe except when you have indirect class references (e.g., "Smalltalk at: 'Foo' asSymbol").
This refactoring is available from "Selector"->"Rename".
Safety: This refactoring is not safe for constructed selectors that are perform:ed. Also, if you reorder the parameters, this refactoring will not be safe if the parameters have side-effects on each other.
This refactoring is available from the "Selection"->"Rename" menu when you have a temporary or argument selected.
Safety: This refactoring is completely safe, unless someone is looking at the source code for the method.
The rename instance variable refactoring is available from "Class"->"Instance variables"->"Rename". It can also be found under the "Variables" menu in the class definition view and the "Selection" menu in the method when the variable is selected.
Similarly, the rename class variable refactoring is available from "Class"->"Class variables"->"Rename". It can also be found under the "Variables" menu in the class definition view and the "Selection" menu in the method view when the variable is selected.
Safety: This refactoring is safe except for classes that depend on the class layout since the positions of the variables may change.
This refactoring is available from the "Selection"->"Convert to instance variable" menu when you have a temporary variable selected.
Safety: This refactoring is not safe if the method that defines the temporary is a recursive method.