Allow injecting arbitrary code

[davdroman]

Hello,

I want to be able to use @MemberwiseInit to do this:

class ViewController: UIViewController {
	init() {
		super.init(nibName: nil, bundle: nil)
	}

	@available(*, unavailable)
	required init?(coder: NSCoder) {
		fatalError()
	}
}

@MemberwiseInit(end: "super.init()")
class FooViewController: ViewController {
	var foo: String
	var bar: Int
	var baz: Bool

	// synthesized
	init(foo: String, bar: Int, baz: Bool) {
		self.foo = foo
		self.bar = bar
		self.baz = baz
		super.init()
	}
}

Potentially allow both @MemberwiseInit(start:) and @MemberwiseInit(end:) to inject code on either end of the init, but I haven't thought it through too much.

I'd love to hear your thoughts on this @gohanlon.

[gohanlon]

I think the main issue is that class initialization is hard. 😆

So far, the solutions that I've explored leave me questioning whether the added complexity justifies itself. Here are a few of the challenges in designing a good solution:

• Balancing flexibility with predictable behavior
• Handling various superclass initialization scenarios without overly complicating the API (and especially how a larger API would impact the common usage)
• Maintaining type safety and compile-time checks (ergonomics)
• Keeping the syntax intuitive and aligned with Swift's design principles

I've considered approaches like code injection, builder patterns, and protocol-based solutions, and each introduced its own complexities and potential drawbacks. For classes, custom initializers may ultimately be the clearest and most maintainable approach—certainly I haven't yet figured out something better!

Perhaps a path forward could be to gather more use cases and then design a class-specific experimental macro (i.e. _ClassMemberwiseInit)?