import Testing

@Suite
struct CallAsFunctionAfterImplicitInit {
	struct Example {
		var value: Int = 0

		// init() {
		// 	self.init(value: 0)
		// }
		//
		// init(value: Int) {
		// 	self.value = value
		// }

		func incremented() -> Self {
			.init(value: value + 1)
		}

		func callAsFunction(modify modified: (Self) -> Self) -> Self {
			modified(self)
		}
	}

	@Test
	func example() async throws {
		do { // base case
			let bug: Example = .init() { $0.incremented() }
			#expect(bug.value == 1) // ❌ Expectation failed: (bug.value → 0) == 1
		}

		do { // explicit type also fails
			let bug = Example.init() { $0.incremented() }
			#expect(bug.value == 1) // ❌ Expectation failed: (bug.value → 0) == 1
		}

		do { // using init with args also fails
			let bug: Example = .init(value: 1) { $0.incremented() }
			#expect(bug.value == 2) // ❌ Expectation failed: (bug.value → 1) == 2
		}

		// Workarounds

		do { // use explicit type on rhs
			let workaround = Example() { $0.incremented() }
			#expect(workaround.value == 1) // ✅
		}

		do { // use closure as argument
			let workaround: Example = .init()(modify: { $0.incremented() })
			#expect(workaround.value == 1) // ✅
		}

		do { // use `self` with trailing closure
			let workaround: Example = .init().self { $0.incremented() }
			#expect(workaround.value == 1) // ✅
		}

		do { // use explicit call with trailing closure
			let workaround: Example = .init().callAsFunction { $0.incremented() }
			#expect(workaround.value == 1) // ✅
		}
	}
}