Catalog / Composites / move-multiple-methods

Move Multiple Methods

Moves several methods of a class to another type in one operation: each instance method through a field, property or parameter of the target type, each static method to the target type by name.

Recipe

For each method, callees before their callers:

move-instance-method for an instance method: "target": { "symbol": "M:Shop.Customer.Street" }, "arguments": { "via": "_address" };
move-static-method for a static method: "target": { "symbol": "M:Shop.Order.Round(System.Decimal)" }, "arguments": { "to": "Shop.Pricing" }.

Every step passes the same stub choice. Moving callees first matters without stubs: the callee's move rewrites the caller's call to go through the via (_address.Street()), and the caller's move then turns that into a call on this in the target. Methods that call each other in a cycle move in the order they were named.

Arguments

Argument	Required	Meaning
`methods`	yes	The methods to move, by name; a name moves every overload
`via`	one of `via` and `to`	The field or property to move instance methods through; static methods move to its type
`to`	one of `via` and `to`	The target type: instance methods move through the one field, property or parameter of that type, static methods to it
`stub`	no	`true` (the default) leaves a delegating method for each moved method; `false` updates the callers

The target is the class declaring the methods, by symbol: "target": { "symbol": "T:Shop.Customer" }.

Precondition

Every named method exists in the class.
Each move meets the precondition of Move Instance Method or Move Static Method, checked against the code as the earlier moves left it.

Transformation

Each method moves as its primitive moves it: uses of the via become this, uses of what stays behind go through a parameter of the old class, private members become internal, and static members the method uses are qualified by their type.
With stubs, each old method delegates to the moved one. A moved method that calls another moved method reaches it through the other's stub (customer.Street()).
Without stubs, every call is rewritten to reach the moved method.

Preserved

The behaviour of every call.
Comments and documentation of the moved methods.

Limitations

With stubs, calls between moved methods still go through the old class's stubs rather than straight to the moved methods, as the recipe leaves them.
A move that refuses part way through is reported by its step number in the callee-first order, not the order the methods were named in.

Error codes

Code	Meaning
`method-not-found`	a named method does not exist in the class
`via-not-found`	the class has no field or property with the via's name
`no-reference-to-target`	no field, property or parameter has the `to` type
`polymorphic-method`	a method is virtual, abstract, an override or an interface implementation
`uses-protected-member`	a method uses a protected member of the class
`via-not-accessible`	without stubs, a caller cannot reach the via
`member-exists`	the target already has a method with that name and parameters

A refusal in any step leaves every file as it was, and names the step that refused.

Cases

Diffs show each file from before to after. /*[*/ … /*]*/ marks a selection and /*^*/ a caret; the runner removes them before the refactoring runs.

#callees-first

Named caller first, the methods still move callee first, with the same result as the recipe

success

Targetsymbol T:Shop.Customer

Arguments

`methods`	`["Label", "Street"]`
`via`	`"_address"`

Address.csmodified

Customer.csmodified

Envelope.csunchanged

View fixture on GitHub

#method-not-found-rejected

A named method does not exist in the class

refusal

Targetsymbol T:Shop.Customer

Arguments

`methods`	`["Street", "Postcode"]`
`via`	`"_address"`

Refusesmethod-not-found mentioning “Postcode”; every file is left unchanged

Address.csinput

Customer.csinput

Envelope.csinput

View fixture on GitHub

#polymorphic-method-rejected

Label is virtual and cannot move, so its move refuses after Street has moved, and every file is put back

refusal

Targetsymbol T:Shop.Customer

Arguments

`methods`	`["Label", "Street"]`
`via`	`"_address"`

Refusespolymorphic-method mentioning “step 2 (move-instance-method)”; every file is left unchanged

Address.csinput

Customer.csinput

Envelope.csinput

View fixture on GitHub

#recipe

Moves Street, then Label which calls it, onto Address through the address field, each leaving a delegating stub, as the recipe of primitive steps

successrecipe

Recipe

move-instance-method on symbol M:Shop.Customer.Street
via "_address"
move-instance-method on symbol M:Shop.Customer.Label
via "_address"

`via`	`"_address"`

`via`	`"_address"`

Address.csmodified

Customer.csmodified

Envelope.csunchanged

View fixture on GitHub

#static-and-without-stubs

A static helper moves to the via's type by name, before the instance method that calls it moves through the via; without stubs every call is updated

success

Targetsymbol T:Shop.Order

Arguments

`methods`	`["UnitPrice", "Round"]`
`via`	`"_pricing"`
`stub`	`false`

Order.csmodified

Pricing.csmodified

View fixture on GitHub

1	1		namespace Shop
2	2		{
3	3		public class Address
4	4		{
5	5		public int Number { get; set; }
6	6
7	7		public string Road { get; set; }
8	8
9	9		public string Town { get; set; }
	10	+
	11	+	// The house number goes first.
	12	+	public string Street() => Number + " " + Road;
	13	+
	14	+	public string Label(Customer customer) => customer.Name + ", " + customer.Street() + ", " + Town;
10	15		}
11	16		}

1	1		namespace Shop
2	2		{
3	3		public class Customer
4	4		{
5	5		private readonly Address _address = new Address();
6	6
7	7		public string Name { get; set; }
8	8
9		−	public string Label() => Name + ", " + Street() + ", " + _address.Town;
	9	+	public string Label() => _address.Label(this);
10	10
11		−	// The house number goes first.
12		−	public string Street() => _address.Number + " " + _address.Road;
	11	+	public string Street() => _address.Street();
13	12		}
14	13		}

1		namespace Shop
2		{
3		public class Address
4		{
5		public int Number { get; set; }
6
7		public string Road { get; set; }
8
9		public string Town { get; set; }
10		}
11		}

1		namespace Shop
2		{
3		public class Customer
4		{
5		private readonly Address _address = new Address();
6
7		public string Name { get; set; }
8
9		public string Label() => Name + ", " + Street() + ", " + _address.Town;
10
11		// The house number goes first.
12		public string Street() => _address.Number + " " + _address.Road;
13		}
14		}

1		namespace Shop
2		{
3		public class Address
4		{
5		public int Number { get; set; }
6
7		public string Road { get; set; }
8
9		public string Town { get; set; }
10		}
11		}

1	1	namespace Shop
2	2	{
3	3	public class Envelope
4	4	{
5	5	public string Front(Customer customer) => customer.Label();
6	6	}
7	7	}

1		−	using System;
2		−
3	1		namespace Shop
4	2		{
5	3		public class Order
6	4		{
7	5		private readonly Pricing _pricing = new Pricing();
8	6
9	7		public int Quantity { get; set; }
10	8
11		−	public decimal Total() => Quantity * UnitPrice();
12		−
13		−	private decimal UnitPrice() => Round(_pricing.Base * (1 - _pricing.Discount));
14		−
15		−	private static decimal Round(decimal amount) => Math.Round(amount, 2);
	9	+	public decimal Total() => Quantity * _pricing.UnitPrice();
16	10		}
17	11		}

	1	+	using System;
	2	+
1	3		namespace Shop
2	4		{
3	5		public class Pricing
4	6		{
5	7		public decimal Base { get; set; }
6	8
7	9		public decimal Discount { get; set; }
	10	+
	11	+	internal static decimal Round(decimal amount) => Math.Round(amount, 2);
	12	+
	13	+	internal decimal UnitPrice() => Round(Base * (1 - Discount));
8	14		}
9	15		}