checker, cgen: fix three interface regressions (#27960)

Author: medvednikov

vlib/v/ast/table.v

@@ -268,8 +268,165 @@ pub fn (t &Table) fn_type_source_signature(f &Fn) string {
 	return sig
 }
 
+fn fn_type_calling_convention(f &Fn) string {
+	for attr in f.attrs {
+		if attr.name == 'callconv' {
+			return attr.arg
+		}
+	}
+	return 'cdecl'
+}
+
+fn (t &Table) fn_types_are_compatible(left &Fn, right &Fn, depth int) bool {
+	if left.params.len != right.params.len || left.is_variadic != right.is_variadic
+		|| left.is_c_variadic != right.is_c_variadic
+		|| fn_type_calling_convention(left) != fn_type_calling_convention(right) {
+		return false
+	}
+	if depth >= max_alias_chain_depth {
+		return false
+	}
+	for i, param in left.params {
+		right_param := right.params[i]
+		if param.is_mut != right_param.is_mut || param.is_shared != right_param.is_shared
+			|| param.is_atomic != right_param.is_atomic
+			|| !t.fn_type_components_are_compatible(param.typ, right_param.typ, depth + 1) {
+			return false
+		}
+	}
+	return t.fn_type_components_are_compatible(left.return_type, right.return_type, depth + 1)
+}
+
+fn (t &Table) fn_type_components_are_compatible(left_type Type, right_type Type, depth int) bool {
+	if left_type == right_type {
+		return true
+	}
+	left := t.fully_unaliased_type(left_type)
+	right := t.fully_unaliased_type(right_type)
+	if left.has_option_or_result() || right.has_option_or_result() {
+		return false
+	}
+	if left == right {
+		return true
+	}
+	if depth >= max_alias_chain_depth {
+		return false
+	}
+	if left.flags() != right.flags() {
+		return false
+	}
+	left_sym := t.sym(left)
+	right_sym := t.sym(right)
+	if left_sym.kind != right_sym.kind {
+		return false
+	}
+	if left_sym.info is FnType {
+		if right_sym.info !is FnType {
+			return false
+		}
+		left_info := left_sym.info as FnType
+		right_info := right_sym.info as FnType
+		return t.fn_types_are_compatible(left_info.func, right_info.func, depth)
+	}
+	if left_sym.info is Array {
+		if right_sym.info !is Array {
+			return false
+		}
+		left_info := left_sym.info as Array
+		right_info := right_sym.info as Array
+		return left_info.nr_dims == right_info.nr_dims
+			&& t.fn_type_components_are_compatible(left_info.elem_type, right_info.elem_type, depth + 1)
+	}
+	if left_sym.info is ArrayFixed {
+		if right_sym.info !is ArrayFixed {
+			return false
+		}
+		left_info := left_sym.info as ArrayFixed
+		right_info := right_sym.info as ArrayFixed
+		return left_info.size == right_info.size
+			&& t.fn_type_components_are_compatible(left_info.elem_type, right_info.elem_type, depth + 1)
+	}
+	if left_sym.info is Map {
+		if right_sym.info !is Map {
+			return false
+		}
+		left_info := left_sym.info as Map
+		right_info := right_sym.info as Map
+		return
+			t.fn_type_components_are_compatible(left_info.key_type, right_info.key_type, depth + 1)
+			&& t.fn_type_components_are_compatible(left_info.value_type, right_info.value_type, depth + 1)
+	}
+	if left_sym.info is Chan {
+		if right_sym.info !is Chan {
+			return false
+		}
+		left_info := left_sym.info as Chan
+		right_info := right_sym.info as Chan
+		return left_info.is_mut == right_info.is_mut
+			&& t.fn_type_components_are_compatible(left_info.elem_type, right_info.elem_type, depth + 1)
+	}
+	if left_sym.info is Thread {
+		if right_sym.info !is Thread {
+			return false
+		}
+		left_info := left_sym.info as Thread
+		right_info := right_sym.info as Thread
+		return_type_matches := t.fn_type_components_are_compatible(left_info.return_type,
+			right_info.return_type, depth + 1)
+		return return_type_matches
+	}
+	if left_sym.info is MultiReturn {
+		if right_sym.info !is MultiReturn {
+			return false
+		}
+		left_info := left_sym.info as MultiReturn
+		right_info := right_sym.info as MultiReturn
+		if left_info.types.len != right_info.types.len {
+			return false
+		}
+		for i, typ in left_info.types {
+			if !t.fn_type_components_are_compatible(typ, right_info.types[i], depth + 1) {
+				return false
+			}
+		}
+		return true
+	}
+	if left_sym.info is GenericInst {
+		if right_sym.info !is GenericInst {
+			return false
+		}
+		left_info := left_sym.info as GenericInst
+		right_info := right_sym.info as GenericInst
+		if left_info.parent_idx != right_info.parent_idx
+			|| left_info.concrete_types.len != right_info.concrete_types.len {
+			return false
+		}
+		for i, typ in left_info.concrete_types {
+			if !t.fn_type_components_are_compatible(typ, right_info.concrete_types[i], depth + 1) {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}
+
 pub fn (t &Table) is_same_method(f &Fn, func &Fn) string {
-	if f.return_type != func.return_type {
+	mut same_return_type := f.return_type == func.return_type
+	if !same_return_type {
+		f_return_type := t.fully_unaliased_type(f.return_type)
+		func_return_type := t.fully_unaliased_type(func.return_type)
+		if !f_return_type.has_option_or_result() && !func_return_type.has_option_or_result()
+			&& f_return_type.nr_muls() == func_return_type.nr_muls() {
+			f_return_sym := t.sym(f_return_type)
+			func_return_sym := t.sym(func_return_type)
+			if f_return_sym.info is FnType && func_return_sym.info is FnType {
+				same_return_type = t.fn_types_are_compatible(f_return_sym.info.func,
+					func_return_sym.info.func, 0)
+			}
+		}
+	}
+	if !same_return_type {
 		s := t.type_to_str(f.return_type)
 		return 'expected return type `${s}`'
 	}

vlib/v/checker/containers.v

@@ -1169,6 +1169,8 @@ fn (mut c Checker) check_append(mut node ast.InfixExpr, left_type ast.Type, righ
 		}
 	}
 	if left_value_sym.kind == .interface {
+		is_empty_interface := left_value_sym.info is ast.Interface
+			&& left_value_sym.info.methods.len == 0 && left_value_sym.info.fields.len == 0
 		if right is ast.ArrayInit && right.is_fixed {
 			c.error('cannot append `${right_sym.name}` to `${left_sym.name}`', right_pos)
 			return ast.void_type
@@ -1177,7 +1179,7 @@ fn (mut c Checker) check_append(mut node ast.InfixExpr, left_type ast.Type, righ
 			left_value_type)
 		if right_is_interface_value {
 			if !right_type.is_any_kind_of_pointer() && !c.inside_unsafe
-				&& right_sym.kind != .interface {
+				&& right_sym.kind != .interface && !is_empty_interface {
 				c.mark_as_referenced(mut &node.right, true)
 			}
 		} else if right_final_sym.kind == .array {
@@ -1187,7 +1189,7 @@ fn (mut c Checker) check_append(mut node ast.InfixExpr, left_type ast.Type, righ
 			// []Animal << Cat
 			if c.type_implements(right_type, left_value_type, right_pos) {
 				if !right_type.is_any_kind_of_pointer() && !c.inside_unsafe
-					&& right_sym.kind != .interface {
+					&& right_sym.kind != .interface && !is_empty_interface {
 					c.mark_as_referenced(mut &node.right, true)
 				}
 			}

vlib/v/checker/tests/interface_method_fn_type_alias_callconv_mismatch_err.out

@@ -0,0 +1,14 @@
+vlib/v/checker/tests/interface_method_fn_type_alias_callconv_mismatch_err.vv:20:7: error: `CdeclProvider` incorrectly implements method `callback` of interface `CallbackProvider`: expected return type `fn (int) int`
+   18 |
+   19 | fn main() {
+   20 |     _ := CallbackProvider(CdeclProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   21 | }
+Details: main.CallbackProvider has `fn callback(x main.CallbackProvider) fn (int) int`
+         main.CdeclProvider has `fn callback(_ main.CdeclProvider) fn (int) int`
+vlib/v/checker/tests/interface_method_fn_type_alias_callconv_mismatch_err.vv:20:7: error: `CdeclProvider` does not implement interface `CallbackProvider`, cannot cast `CdeclProvider` to interface `CallbackProvider`
+   18 |
+   19 | fn main() {
+   20 |     _ := CallbackProvider(CdeclProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   21 | }

vlib/v/checker/tests/interface_method_fn_type_alias_callconv_mismatch_err.vv

@@ -0,0 +1,21 @@
+@[callconv: stdcall]
+type StdcallCallback = fn (int) int
+
+@[callconv: cdecl]
+type CdeclCallback = fn (int) int
+
+interface CallbackProvider {
+	callback() StdcallCallback
+}
+
+struct CdeclProvider {}
+
+fn (_ CdeclProvider) callback() CdeclCallback {
+	return fn (value int) int {
+		return value
+	}
+}
+
+fn main() {
+	_ := CallbackProvider(CdeclProvider{})
+}

vlib/v/checker/tests/interface_method_fn_type_nested_option_result_alias_mismatch_err.out

@@ -0,0 +1,30 @@
+vlib/v/checker/tests/interface_method_fn_type_nested_option_result_alias_mismatch_err.vv:36:7: error: `OptionalIntCallbackProvider` incorrectly implements method `callback` of interface `OptionalCallbackProvider`: expected return type `fn () ?MyInt`
+   34 |
+   35 | fn main() {
+   36 |     _ := OptionalCallbackProvider(OptionalIntCallbackProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   37 |     _ := ResultCallbackProvider(ResultIntCallbackProvider{})
+   38 | }
+Details: main.OptionalCallbackProvider has `fn callback(x main.OptionalCallbackProvider) fn () ?main.MyInt`
+         main.OptionalIntCallbackProvider has `fn callback(_ main.OptionalIntCallbackProvider) fn () ?int`
+vlib/v/checker/tests/interface_method_fn_type_nested_option_result_alias_mismatch_err.vv:36:7: error: `OptionalIntCallbackProvider` does not implement interface `OptionalCallbackProvider`, cannot cast `OptionalIntCallbackProvider` to interface `OptionalCallbackProvider`
+   34 |
+   35 | fn main() {
+   36 |     _ := OptionalCallbackProvider(OptionalIntCallbackProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   37 |     _ := ResultCallbackProvider(ResultIntCallbackProvider{})
+   38 | }
+vlib/v/checker/tests/interface_method_fn_type_nested_option_result_alias_mismatch_err.vv:37:7: error: `ResultIntCallbackProvider` incorrectly implements method `callback` of interface `ResultCallbackProvider`: expected return type `fn () !MyInt`
+   35 | fn main() {
+   36 |     _ := OptionalCallbackProvider(OptionalIntCallbackProvider{})
+   37 |     _ := ResultCallbackProvider(ResultIntCallbackProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   38 | }
+Details: main.ResultCallbackProvider has `fn callback(x main.ResultCallbackProvider) fn () !main.MyInt`
+         main.ResultIntCallbackProvider has `fn callback(_ main.ResultIntCallbackProvider) fn () !int`
+vlib/v/checker/tests/interface_method_fn_type_nested_option_result_alias_mismatch_err.vv:37:7: error: `ResultIntCallbackProvider` does not implement interface `ResultCallbackProvider`, cannot cast `ResultIntCallbackProvider` to interface `ResultCallbackProvider`
+   35 | fn main() {
+   36 |     _ := OptionalCallbackProvider(OptionalIntCallbackProvider{})
+   37 |     _ := ResultCallbackProvider(ResultIntCallbackProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   38 | }

vlib/v/checker/tests/interface_method_fn_type_nested_option_result_alias_mismatch_err.vv

@@ -0,0 +1,38 @@
+type MyInt = int
+
+type OptionalAliasCallback = fn () ?MyInt
+
+type OptionalIntCallback = fn () ?int
+
+interface OptionalCallbackProvider {
+	callback() OptionalAliasCallback
+}
+
+struct OptionalIntCallbackProvider {}
+
+fn (_ OptionalIntCallbackProvider) callback() OptionalIntCallback {
+	return fn () ?int {
+		return 1
+	}
+}
+
+type ResultAliasCallback = fn () !MyInt
+
+type ResultIntCallback = fn () !int
+
+interface ResultCallbackProvider {
+	callback() ResultAliasCallback
+}
+
+struct ResultIntCallbackProvider {}
+
+fn (_ ResultIntCallbackProvider) callback() ResultIntCallback {
+	return fn () !int {
+		return 2
+	}
+}
+
+fn main() {
+	_ := OptionalCallbackProvider(OptionalIntCallbackProvider{})
+	_ := ResultCallbackProvider(ResultIntCallbackProvider{})
+}

vlib/v/checker/tests/interface_method_nested_fn_type_alias_callconv_mismatch_err.out

@@ -0,0 +1,14 @@
+vlib/v/checker/tests/interface_method_nested_fn_type_alias_callconv_mismatch_err.vv:28:7: error: `CdeclFactoryProvider` incorrectly implements method `factory` of interface `FactoryProvider`: expected return type `fn () fn (int) int`
+   26 |
+   27 | fn main() {
+   28 |     _ := FactoryProvider(CdeclFactoryProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   29 | }
+Details: main.FactoryProvider has `fn factory(x main.FactoryProvider) fn () fn (int) int`
+         main.CdeclFactoryProvider has `fn factory(_ main.CdeclFactoryProvider) fn () fn (int) int`
+vlib/v/checker/tests/interface_method_nested_fn_type_alias_callconv_mismatch_err.vv:28:7: error: `CdeclFactoryProvider` does not implement interface `FactoryProvider`, cannot cast `CdeclFactoryProvider` to interface `FactoryProvider`
+   26 |
+   27 | fn main() {
+   28 |     _ := FactoryProvider(CdeclFactoryProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   29 | }

vlib/v/checker/tests/interface_method_nested_fn_type_alias_callconv_mismatch_err.vv

@@ -0,0 +1,29 @@
+@[callconv: stdcall]
+type StdcallNestedCallback = fn (int) int
+
+@[callconv: cdecl]
+type CdeclNestedCallback = fn (int) int
+
+@[callconv: cdecl]
+type StdcallFactory = fn () StdcallNestedCallback
+
+@[callconv: cdecl]
+type CdeclFactory = fn () CdeclNestedCallback
+
+interface FactoryProvider {
+	factory() StdcallFactory
+}
+
+struct CdeclFactoryProvider {}
+
+fn (_ CdeclFactoryProvider) factory() CdeclFactory {
+	return fn () CdeclNestedCallback {
+		return fn (value int) int {
+			return value
+		}
+	}
+}
+
+fn main() {
+	_ := FactoryProvider(CdeclFactoryProvider{})
+}

vlib/v/checker/tests/interface_method_option_result_alias_return_mismatch_err.out

@@ -0,0 +1,30 @@
+vlib/v/checker/tests/interface_method_option_result_alias_return_mismatch_err.vv:24:7: error: `OptionalIntProvider` incorrectly implements method `value` of interface `OptionalProvider`: expected return type `?MyInt`
+   22 |
+   23 | fn main() {
+   24 |     _ := OptionalProvider(OptionalIntProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   25 |     _ := ResultProvider(ResultIntProvider{})
+   26 | }
+Details: main.OptionalProvider has `fn value(x main.OptionalProvider) ?main.MyInt`
+         main.OptionalIntProvider has `fn value(_ main.OptionalIntProvider) ?int`
+vlib/v/checker/tests/interface_method_option_result_alias_return_mismatch_err.vv:24:7: error: `OptionalIntProvider` does not implement interface `OptionalProvider`, cannot cast `OptionalIntProvider` to interface `OptionalProvider`
+   22 |
+   23 | fn main() {
+   24 |     _ := OptionalProvider(OptionalIntProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   25 |     _ := ResultProvider(ResultIntProvider{})
+   26 | }
+vlib/v/checker/tests/interface_method_option_result_alias_return_mismatch_err.vv:25:7: error: `ResultIntProvider` incorrectly implements method `value` of interface `ResultProvider`: expected return type `!MyInt`
+   23 | fn main() {
+   24 |     _ := OptionalProvider(OptionalIntProvider{})
+   25 |     _ := ResultProvider(ResultIntProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   26 | }
+Details: main.ResultProvider has `fn value(x main.ResultProvider) !main.MyInt`
+         main.ResultIntProvider has `fn value(_ main.ResultIntProvider) !int`
+vlib/v/checker/tests/interface_method_option_result_alias_return_mismatch_err.vv:25:7: error: `ResultIntProvider` does not implement interface `ResultProvider`, cannot cast `ResultIntProvider` to interface `ResultProvider`
+   23 | fn main() {
+   24 |     _ := OptionalProvider(OptionalIntProvider{})
+   25 |     _ := ResultProvider(ResultIntProvider{})
+      |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   26 | }