v2: move lots of logic from cleanc to transformer

Author: medvednikov

cmd/v2/test.v

@@ -545,6 +545,37 @@ fn flag_enum_check_int_args() int {
 	return simple_two_arg(3, 4) // Expected: 304
 }
 
+fn test_flag_enum_set_clear() {
+	mut p := Permissions.read
+	// .set() adds a flag
+	p.set(.write)
+	assert p.has(.read)
+	assert p.has(.write)
+	assert !p.has(.execute)
+	print_int(int(p)) // 3 (read=1 | write=2)
+
+	// .set() another flag
+	p.set(.execute)
+	assert p.has(.execute)
+	assert p.all(Permissions.read | Permissions.write | Permissions.execute)
+	print_int(int(p)) // 7 (1|2|4)
+
+	// .clear() removes a flag
+	p.clear(.write)
+	assert p.has(.read)
+	assert !p.has(.write)
+	assert p.has(.execute)
+	print_int(int(p)) // 5 (read=1 | execute=4)
+
+	// .clear() then .set() same flag
+	p.clear(.read)
+	p.set(.write)
+	assert !p.has(.read)
+	assert p.has(.write)
+	assert p.has(.execute)
+	print_int(int(p)) // 6 (write=2 | execute=4)
+}
+
 // ===================== IF-GUARD HELPERS =====================
 
 // Returns the value if positive, none otherwise
@@ -1268,6 +1299,146 @@ fn test_map_or_array_value() {
 	print_str('map or-block array value type: ok')
 }
 
+fn test_interface_fn_pointer_dispatch() {
+	// Interface method calls are lowered by the transformer into fn-pointer
+	// field calls: iface.method(iface._object, args...).
+	// cleanc handles these through the generic fn-pointer call path.
+
+	// 93.1 Drawable interface - zero-arg method
+	pt1 := Point{
+		x: 8
+		y: 2
+	}
+	d1 := Drawable(pt1)
+	print_int(d1.draw()) // 8*1000 + 2 = 8002
+
+	// 93.2 Calculator interface - multi-arg method
+	pt2 := Point{
+		x: 10
+		y: 5
+	}
+	calc := Calculator(pt2)
+	print_int(calc.add(3, 7)) // 10 + 5 + 3 + 7 = 25
+	print_int(calc.multiply(4)) // (10 + 5) * 4 = 60
+
+	// 93.3 Shape interface - multiple methods
+	rect := Rectangle{
+		width:  6
+		height: 4
+		origin: Point{
+			x: 0
+			y: 0
+		}
+	}
+	shape := Shape(rect)
+	print_int(shape.area()) // 6 * 4 = 24
+	print_int(shape.perimeter()) // 2 * (6 + 4) = 20
+
+	// 93.4 Sum of interface method results
+	pt3 := Point{
+		x: 3
+		y: 7
+	}
+	d2 := Drawable(pt3)
+	pt4 := Point{
+		x: 1
+		y: 9
+	}
+	d3 := Drawable(pt4)
+	print_int(d2.draw() + d3.draw()) // 3007 + 1009 = 4016
+}
+
+fn test_sumtype_type_name() {
+	// Test .type_name() on sumtype with struct variants
+	s1 := Stmt89(AssignStmt89{
+		value: 42
+	})
+	assert s1.type_name() == 'AssignStmt89'
+
+	s2 := Stmt89(ExprStmt89{
+		value: 7
+	})
+	assert s2.type_name() == 'ExprStmt89'
+
+	s3 := Stmt89(BlockStmt89{
+		stmts: []
+	})
+	assert s3.type_name() == 'BlockStmt89'
+
+	// Test .type_name() on sumtype with primitive variants
+	v1 := InnerSumType(123)
+	assert v1.type_name() == 'int'
+
+	v2 := InnerSumType('hello')
+	assert v2.type_name() == 'string'
+
+	// Test .type_name() on nested sumtype
+	v3 := OuterSumType(true)
+	assert v3.type_name() == 'bool'
+
+	print_str('sumtype type_name: ok')
+}
+
+// ==== Test 95: Method call resolution ====
+// Tests that the transformer correctly resolves receiver.method(args) -> Type__method(receiver, args)
+
+struct Counter95 {
+mut:
+	value int
+}
+
+fn (c &Counter95) get() int {
+	return c.value
+}
+
+fn (mut c Counter95) add(n int) {
+	c.value += n
+}
+
+fn (c &Counter95) sum_with(other &Counter95) int {
+	return c.value + other.value
+}
+
+fn test_method_call_resolution() {
+	// 95.1 Struct method call (immutable receiver)
+	c1 := Counter95{
+		value: 42
+	}
+	assert c1.get() == 42
+
+	// 95.2 Struct method call (mutable receiver)
+	mut c2 := Counter95{
+		value: 10
+	}
+	c2.add(5)
+	assert c2.get() == 15
+
+	// 95.3 Method call with struct argument
+	c3 := Counter95{
+		value: 20
+	}
+	assert c2.sum_with(c3) == 35
+
+	// 95.4 Array method (push + len chain)
+	mut arr := []int{}
+	arr << 1
+	arr << 2
+	arr << 3
+	assert arr.len == 3
+
+	// 95.5 String method call
+	s := 'hello world'
+	assert s.contains('world')
+	assert s.replace('world', 'v') == 'hello v'
+
+	// 95.6 Chained method calls
+	s2 := 'Hello World'
+	result := s2.replace('World', 'V').replace('Hello', 'Hi')
+	assert result == 'Hi V'
+
+	print_str('method call resolution: ok')
+}
+
 // ===================== MAIN TEST FUNCTION =====================
 
 fn main() {
@@ -3804,6 +3975,18 @@ fn main() {
 	small_nums := filter_arr.filter(it <= 6)
 	print_int(small_nums.len) // 6
 
+	// 56.5 Filter as function argument (non-assignment context)
+	print_int(filter_arr.filter(it > 3).len) // 3
+
+	// 56.6 Map in assignment context
+	mapped := filter_arr.map(it * 2)
+	print_int(mapped.len) // 6
+	print_int(mapped[0]) // 2
+	print_int(mapped[5]) // 12
+
+	// 56.7 Map as function argument (non-assignment context)
+	print_int(filter_arr.map(it + 10).len) // 6
+
 	// ==================== 57. ARRAY STR (auto-generated) ====================
 	print_str('--- 57. Array str ---')
 
@@ -4791,5 +4974,22 @@ fn main() {
 	print_str('--- Test 91: Map or-block with array value ---')
 	test_map_or_array_value()
 
+	// ==================== 92. FLAG ENUM SET/CLEAR ====================
+	// Tests flag enum .set() and .clear() methods (transformer lowering to |= and &=~)
+	print_str('--- Test 92: Flag enum set/clear ---')
+	test_flag_enum_set_clear()
+
+	print_str('--- Test 93: Interface method dispatch via fn-pointer ---')
+	test_interface_fn_pointer_dispatch()
+
+	print_str('--- Test 94: Sumtype .type_name() ---')
+	test_sumtype_type_name()
+
+	// ==================== 95. METHOD CALL RESOLUTION ====================
+	// Tests transformer-based method resolution: receiver.method(args) -> Type__method(receiver, args)
+	// Exercises struct methods, array methods, and chained calls.
+	print_str('--- Test 95: Method call resolution ---')
+	test_method_call_resolution()
+
 	print_str('=== All tests completed ===')
 }