all: check error of generic symbol and cleanup generic symbol (fix #23072) (#23178)

Author: yuyi98

vlib/v/fmt/tests/import_selective_input.vv

@@ -76,7 +76,7 @@ fn f(v FnArg, vv ...FnArgVariadic) FnRet {
 	return FnRet{}
 }
 
-fn f2(v Generic<FnArgTypeParam1, FnArgTypeParam2>) Generic<FnRetTypeParam1, FnRetTypeParam2> {}
+fn f2(v Generic[FnArgTypeParam1, FnArgTypeParam2]) Generic[FnRetTypeParam1, FnRetTypeParam2] {}
 
 fn f_generic[T](v FnArgGeneric[T]) FnRetGeneric[T] {
 	return FnRetGeneric[T]{}

vlib/v/parser/parse_type.v

@@ -873,6 +873,9 @@ fn (mut p Parser) parse_generic_inst_type(name string) ast.Type {
 		p.error('too many levels of Parser.parse_generic_inst_type() calls: ${p.generic_type_level}, probably due to too many layers embedded generic type')
 		return ast.void_type
 	}
+	if p.tok.kind == .lt {
+		p.error('The generic symbol `<>` is obsolete, please replace it with `[]`')
+	}
 	mut bs_name := name
 	mut bs_cname := name
 	start_pos := p.tok.pos()

vlib/v/parser/parser.v

@@ -3442,10 +3442,13 @@ fn (mut p Parser) dot_expr(left ast.Expr) ast.Expr {
 fn (mut p Parser) parse_generic_types() ([]ast.Type, []string) {
 	mut types := []ast.Type{}
 	mut param_names := []string{}
-	if p.tok.kind !in [.lt, .lsbr] {
+	if p.tok.kind == .lt {
+		p.error('The generic symbol `<>` is obsolete, please replace it with `[]`')
+	}
+	if p.tok.kind != .lsbr {
 		return types, param_names
 	}
-	end_kind := if p.tok.kind == .lt { token.Kind.gt } else { token.Kind.rsbr }
+	end_kind := token.Kind.rsbr
 	p.next()
 	mut first_done := false
 	mut count := 0
@@ -3492,15 +3495,18 @@ fn (mut p Parser) parse_generic_types() ([]ast.Type, []string) {
 
 fn (mut p Parser) parse_concrete_types() []ast.Type {
 	mut types := []ast.Type{}
-	if p.tok.kind !in [.lt, .lsbr] {
+	if p.tok.kind == .lt {
+		p.error('The generic symbol `<>` is obsolete, please replace it with `[]`')
+	}
+	if p.tok.kind != .lsbr {
 		return types
 	}
 	p.inside_fn_concrete_type = true
 	defer {
 		p.inside_fn_concrete_type = false
 	}
-	end_kind := if p.tok.kind == .lt { token.Kind.gt } else { token.Kind.rsbr }
-	p.next() // `<`
+	end_kind := token.Kind.rsbr
+	p.next() // `[`
 	mut first_done := false
 	for p.tok.kind !in [.eof, end_kind] {
 		if first_done {
@@ -3509,7 +3515,7 @@ fn (mut p Parser) parse_concrete_types() []ast.Type {
 		types << p.parse_type()
 		first_done = true
 	}
-	p.check(end_kind) // `>`
+	p.check(end_kind) // `]`
 	return types
 }
 

vlib/v/parser/struct.v

@@ -668,7 +668,7 @@ fn (mut p Parser) interface_decl() ast.InterfaceDecl {
 			is_mut = true
 			mut_pos = fields.len
 		}
-		if p.peek_tok.kind in [.lt, .lsbr] && p.peek_tok.is_next_to(p.tok) {
+		if p.peek_tok.kind == .lsbr && p.peek_tok.is_next_to(p.tok) {
 			if generic_types.len == 0 {
 				p.error_with_pos('non-generic interface `${interface_name}` cannot define a generic method',
 					p.peek_tok.pos())

vlib/v/parser/tests/duplicated_generic_err.out

@@ -1,3 +1,3 @@
 vlib/v/parser/tests/duplicated_generic_err.vv:1:12: error: duplicated generic parameter `A`
-    1 | fn test<A, A>() {}
+    1 | fn test[A, A]() {}
       |            ^

vlib/v/parser/tests/duplicated_generic_err.vv

@@ -1 +1 @@
-fn test<A, A>() {}
+fn test[A, A]() {}

vlib/v/parser/tests/generic_lowercase_err.out

@@ -1,3 +1,3 @@
 vlib/v/parser/tests/generic_lowercase_err.vv:1:22: error: generic parameter needs to be uppercase
-    1 | fn lowercase_generic<a>() {}
+    1 | fn lowercase_generic[a]() {}
       |                      ^

vlib/v/parser/tests/generic_lowercase_err.vv

@@ -1 +1 @@
-fn lowercase_generic<a>() {}
+fn lowercase_generic[a]() {}

vlib/v/parser/tests/generic_struct_type_decl_err.out

@@ -1,5 +1,5 @@
 vlib/v/parser/tests/generic_struct_type_decl_err.vv:1:13: error: generic parameter name needs to be exactly one char
-    1 | struct GMap<Hashable<K>, V> {
+    1 | struct GMap[Hashable[K], V] {
       |             ~~~~~~~~
     2 |     map_ map[int]V
     3 | }

vlib/v/parser/tests/generic_struct_type_decl_err.vv

@@ -1,17 +1,17 @@
-struct GMap<Hashable<K>, V> {
+struct GMap[Hashable[K], V] {
 	map_ map[int]V
 }
 
-fn (t GMap<Hashable<K>, V>) contains(k K) bool {
+fn (t GMap[Hashable[K], V]) contains(k K) bool {
 	return true // TODO
 }
 
-fn (t GMap<Hashable<K>, V>) set(k K, v V) {
+fn (t GMap[Hashable[K], V]) set(k K, v V) {
 	// TODO
 }
 
 fn main() {
-	x := GMap<string, string>{}
+	x := GMap[string, string]{}
 	x.set("hello", "world")
 	println(x.contains("hello"))
 }