parser: disallow untyped chan used as a fn parameter type (fix #25818) (#25854)

Author: dy-tea

vlib/v/parser/fn.v

@@ -1047,6 +1047,10 @@ fn (mut p Parser) fn_params() ([]ast.Param, bool, bool, bool) {
 				// error is added in parse_type
 				return []ast.Param{}, false, false, false
 			}
+			if param_type == ast.chan_type {
+				p.chan_type_error()
+				return []ast.Param{}, false, false, false
+			}
 			if is_mut {
 				if !param_type.has_flag(.generic) {
 					if is_variadic {
@@ -1177,6 +1181,10 @@ fn (mut p Parser) fn_params() ([]ast.Param, bool, bool, bool) {
 				// error is added in parse_type
 				return []ast.Param{}, false, false, false
 			}
+			if typ == ast.chan_type {
+				p.chan_type_error()
+				return []ast.Param{}, false, false, false
+			}
 			if is_mut {
 				if !typ.has_flag(.generic) {
 					if is_variadic {

vlib/v/parser/messages.v

@@ -220,3 +220,8 @@ fn (mut p Parser) unexpected_with_pos(pos token.Pos, params ParamsForUnexpected)
 	}
 	return p.error_with_pos(msg, pos)
 }
+
+fn (mut p Parser) chan_type_error() {
+	p.error_with_pos('`chan` has no type specified. Use `chan Type` instead of `chan`',
+		p.prev_tok.pos())
+}

vlib/v/parser/parse_type.v

@@ -124,6 +124,10 @@ fn (mut p Parser) parse_array_type(expecting token.Kind, is_option bool) ast.Typ
 			// error is handled by parse_type
 			return 0
 		}
+		if elem_type == ast.chan_type {
+			p.chan_type_error()
+			return 0
+		}
 		// has been explicitly resolved, but size is 0
 		if fixed_size <= 0 && !size_unresolved {
 			p.error_with_pos('fixed size cannot be zero or negative', size_expr.pos())
@@ -142,6 +146,10 @@ fn (mut p Parser) parse_array_type(expecting token.Kind, is_option bool) ast.Typ
 		// error is set in parse_type
 		return 0
 	}
+	if elem_type == ast.chan_type {
+		p.chan_type_error()
+		return 0
+	}
 	if elem_type.idx() == ast.thread_type_idx {
 		p.register_auto_import('sync.threads')
 	}
@@ -201,6 +209,10 @@ fn (mut p Parser) parse_map_type() ast.Type {
 		// error is reported in parse_type
 		return 0
 	}
+	if value_type == ast.chan_type {
+		p.chan_type_error()
+		return 0
+	}
 	if value_type.idx() == ast.void_type_idx {
 		p.error_with_pos('map value type is missing: use `map[KeyType]ValueType`', p.tok.pos())
 		return 0
@@ -293,6 +305,10 @@ fn (mut p Parser) parse_multi_return_type() ast.Type {
 		if mr_type.idx() == 0 {
 			break
 		}
+		if mr_type == ast.chan_type {
+			p.chan_type_error()
+			break
+		}
 		if mr_type.has_flag(.generic) {
 			has_generic = true
 		}
@@ -568,6 +584,11 @@ fn (mut p Parser) parse_type() ast.Type {
 			// error is set in parse_type
 			return 0
 		}
+		// !p.inside_receiver_param check can be removed once (ch chan) functions are removed
+		if typ == ast.chan_type && !p.inside_receiver_param {
+			p.chan_type_error()
+			return 0
+		}
 		if typ == ast.void_type {
 			p.error_with_pos('use `?` instead of `?void`', pos)
 			return 0

vlib/v/parser/tests/chan_no_type_array_fn_arg_err.out

@@ -0,0 +1,3 @@
+vlib/v/parser/tests/chan_no_type_array_fn_arg_err.vv:1:24: error: `chan` has no type specified. Use `chan Type` instead of `chan`
+    1 | fn takes_array(chans []chan) {}
+      |                        ~~~~

vlib/v/parser/tests/chan_no_type_array_fn_arg_err.vv

@@ -0,0 +1 @@
+fn takes_array(chans []chan) {}

vlib/v/parser/tests/chan_no_type_err.out

@@ -0,0 +1,3 @@
+vlib/v/parser/tests/chan_no_type_err.vv:1:6: error: `chan` has no type specified. Use `chan Type{}` instead of `chan{}`
+    1 | a := chan{}
+      |      ~~~~~~

vlib/v/parser/tests/chan_no_type_err.vv

@@ -0,0 +1 @@
+a := chan{}

vlib/v/parser/tests/chan_no_type_fn_arg_err.out

@@ -0,0 +1,3 @@
+vlib/v/parser/tests/chan_no_type_fn_arg_err.vv:1:12: error: `chan` has no type specified. Use `chan Type` instead of `chan`
+    1 | fn takes(c chan) {}
+      |            ~~~~

vlib/v/parser/tests/chan_no_type_fn_arg_err.vv

@@ -0,0 +1 @@
+fn takes(c chan) {}

vlib/v/parser/tests/chan_no_type_map_fn_arg_err.out

@@ -0,0 +1,3 @@
+vlib/v/parser/tests/chan_no_type_map_fn_arg_err.vv:1:31: error: `chan` has no type specified. Use `chan Type` instead of `chan`
+    1 | fn takes_map(chans map[string]chan) {}
+      |                               ~~~~