Pull Members Up, Push Members Down
Basics
The Pull Members Up refactoring allows you to move class members to a base class.
The Push Members Down refactoring helps clean up the class hierarchy by moving class members to a subclass. The members are then relocated into the direct subclasses only.
Pulling members up
- Select the class to be moved to a superclass.
- On the main menu or on the context menu, choose . The Pull Members Up dialog box appears.
- Select the destination object (superclass).
- In the Members section, select the members you want to move.
- Click Refactor to pull the selected members to their destination.
Examples
| Before | After |
|---|---|
class BaseClass{
int d1 = 0;
static const int d2 = 1;
};
class ChildClass: public BaseClass{
char SomeChar = 'a';
long d22;
void exFunc(int); //This method will be pulled up
};
void ChildClass::exFunc(int) {}; | class BaseClass{
int d1 = 0;
static const int d2 = 1;
void exFunc(int);
};
class ChildClass: public BaseClass{
char SomeChar = 'a';
long d22;
};
void BaseClass::exFunc(int) {}; |
| Before | After |
|---|---|
@interface SampleClass:NSObject
/* This method will be pulled up */
- (int)IntSum:(int)num1 andNum2:(int)num2;
@end
@implementation SampleClass
- (int)IntSum:(int)num1 andNum2:(int)num2{
int result = num1 = num2;
return result;
}
@end | @interface BaseClass : NSObject
- (int)IntSum:(int)num1 andNum2:(int)num2;
@end
@interface SampleClass : BaseClass
@end
@implementation BaseClass
- (int)IntSum:(int)num1 andNum2:(int)num2{
int result = num1 = num2;
return result;
}
@end |
| Before | After |
|---|---|
class SuperClass:
def super_method(self):
pass
class SubClassOne(SuperClass):
# This function will be pulled up
def my_method(self):
pass | class SuperClass:
def super_method(self):
pass
def my_method(self):
pass
class SubClassOne(SuperClass):
pass |
Pulling up the dependent members
Let's consider the following sample of C++ code:
d1 and d3. If you apply Pull Members Up refactoring to class ChildClass and try to select d3 to be moved, and leave d1 in the class, CLion highlights the problem member in Pull Members Up dialog, as following: 
Trying to proceed with extract, you will get the following warning message:
Choose Continue to ignore the problem and proceed with refactoring, or Cancel to return back and resolve it. Also you can observe the conflict in Find Tool Window.
Pushing members down
- In the editor, open the class whose members you need to push down.
- On the main menu or on the context menu, choose . Push Members Down dialog box displays the list of members to be pushed down.
- In the Members to be pushed down area, select the members you want to move. Note that the member at caret is already selected.
If pushing a member might cause problems, you will be notified with red highlighting. It means that, if the situation is unattended, an error will emerge after refactoring. CLion prompts you with a Problems Detected dialog, where you can opt to ignore or fix the problem.
- Preview and apply changes.
Examples
| Before | After |
|---|---|
class BaseClass{
int d1 = 0;
static const int d2 = 1;
void exFunc(int); //This method will be pushed down
};
class ChildClass: public BaseClass{
char SomeChar = 'a';
long d22;
};
void BaseClass::exFunc(int) {}; | class BaseClass{
int d1 = 0;
};
class ChildClass: public BaseClass{
char SomeChar = 'a';
long d22;
static const int d2 = 1;
void exFunc(int);
};
void ChildClass::exFunc(int) {}; |
| Before | After |
|---|---|
@interface Superclass : NSObject {
int v;
int w; //This variable will be pushed down
}
- (void)initV;
@end
@implementation Superclass
- (void)initV {
v = 20;
}
@end
@interface Subclass : Superclass | @interface Superclass : NSObject {
int v;
}
- (void)initV;
@end
@implementation Superclass
- (void)initV {
v = 20;
}
@end
@interface Subclass : Superclass { int w; } |
| Before | After |
|---|---|
class SuperClass:
# This function will be pushed down
def super_method(self):
pass
class SubClassOne(SuperClass):
def my_method(self):
pass
class SubClassTwo(SuperClass):
def my_method(self):
pass | class SuperClass:
pass
class SubClassOne(SuperClass):
def my_method(self):
pass
def super_method(self):
pass
class SubClassTwo(SuperClass):
def my_method(self):
pass
def super_method(self):
pass |
Pushing down the dependant members
Let's consider the following sample of C++ code:
d2 here depends on array a. If you apply Push Members Down refactoring to the above class and try to select a to be moved, and leave d2 in the base class class, CLion highlights the problem member in Pull Members Down dialog, as following: 
Trying to proceed with extract, you will get the following warning message:
Choose Continue to ignore the problem and proceed with refactoring, or Cancel to return back and resolve it. Also you can observe the conflict in Find Tool Window.