compiler: fix generic sumtype aliases and duplicate imports

Author: medvednikov

vlib/v/builder/builder.v

@@ -284,6 +284,7 @@ pub fn (mut b Builder) parse_imports() {
 		util.timing_measure(@METHOD)
 	}
 	mut done_imports := []string{}
+	mut done_import_paths := map[string]bool{}
 	if b.pref.is_vsh {
 		done_imports << 'os'
 	}
@@ -331,6 +332,11 @@ pub fn (mut b Builder) parse_imports() {
 					ast_file.path, imp.pos)
 				break
 			}
+			import_path_key := comparable_real_path(import_path)
+			if import_path_key in done_import_paths {
+				done_imports << mod
+				continue
+			}
 			v_files := b.v_files_from_dir(import_path)
 			if v_files.len == 0 {
 				// v.parsers[i].error_with_token_index('cannot import module "${mod}" (no .v files in "${import_path}")', v.parsers[i].import_ast.get_import_tok_idx(mod))
@@ -358,6 +364,7 @@ pub fn (mut b Builder) parse_imports() {
 				return
 			}
 			done_imports << mod
+			done_import_paths[import_path_key] = true
 		}
 	}
 	b.resolve_deps()

vlib/v/builder/builder_test.v

@@ -216,6 +216,45 @@ fn test_empty_local_dir_does_not_shadow_vlib_module() {
 	assert res.output.trim_space() == 'true'
 }
 
+fn test_imports_with_same_resolved_path_are_parsed_once() {
+	os.chdir(test_path)!
+	workspace := os.join_path(test_path, 'run_duplicate_resolved_import_path')
+	project_dir := os.join_path(workspace, 'dupmod')
+	defer {
+		os.chdir(test_path) or {}
+		os.rmdir_all(workspace) or {}
+	}
+	os.mkdir_all(os.join_path(project_dir, 'providers'))!
+	os.write_file(os.join_path(project_dir, 'v.mod'), "Module {\n\tname: 'dupmod'\n}\n")!
+	os.write_file(os.join_path(project_dir, 'dupmod.v'), 'module dupmod
+
+import providers
+
+pub fn make_client() providers.Client {
+	return providers.Client{}
+}
+')!
+	os.write_file(os.join_path(project_dir, 'main_test.v'), 'module main
+
+import dupmod
+import dupmod.providers
+
+fn test_client() {
+	_ := dupmod.make_client()
+	_ := providers.Client{}
+}
+')!
+	os.write_file(os.join_path(project_dir, 'providers', 'client.v'), 'module providers
+
+pub struct Client {}
+')!
+	os.chdir(project_dir)!
+
+	res := os.execute('${os.quoted_path(vexe)} -check main_test.v')
+	assert res.exit_code == 0, res.output
+	assert !res.output.contains('cannot register struct')
+}
+
 fn test_removed_src_layout_error_mentions_vmod_subdirs() {
 	os.chdir(test_path)!
 	project_dir := os.join_path(test_path, 'run_removed_src_project')

vlib/v/checker/check_types.v

@@ -1908,8 +1908,9 @@ fn (mut c Checker) infer_fn_generic_types(func &ast.Fn, mut node ast.CallExpr) {
 			s := c.table.type_to_str(typ)
 			println('inferred `${func.name}[${s}]`')
 		}
-		inferred_types << c.unwrap_generic(typ)
-		node.concrete_types << typ
+		concrete_typ := ast.mktyp(c.unwrap_generic(typ))
+		inferred_types << concrete_typ
+		node.concrete_types << concrete_typ
 	}
 
 	if c.table.register_fn_concrete_types(func.fkey(), inferred_types) {

vlib/v/checker/match.v

@@ -684,6 +684,49 @@ fn (mut c Checker) get_match_case_literal_value(mut expr ast.Expr) ?i64 {
 	return none
 }
 
+fn (mut c Checker) match_sumtype_has_variant(parent ast.Type, variant ast.Type) bool {
+	if c.table.sumtype_has_variant_recursive(parent, variant, true) {
+		return true
+	}
+	if c.table.sym(parent).kind == .sum_type {
+		return false
+	}
+	for candidate in c.concrete_sumtype_variants(parent) {
+		if c.match_sumtype_variant_is_handled(candidate, variant) {
+			return true
+		}
+	}
+	return false
+}
+
+fn (mut c Checker) match_sumtype_missing_variants(parent ast.Type, handled []ast.Type) []ast.Type {
+	if c.table.sym(parent).kind == .sum_type {
+		return c.table.sumtype_missing_variants(parent, handled)
+	}
+	mut missing := []ast.Type{}
+	for variant in c.concrete_sumtype_variants(parent) {
+		mut is_handled := false
+		for handled_variant in handled {
+			if c.match_sumtype_variant_is_handled(variant, handled_variant) {
+				is_handled = true
+				break
+			}
+		}
+		if !is_handled {
+			missing << variant
+		}
+	}
+	return missing
+}
+
+fn (mut c Checker) match_sumtype_variant_is_handled(variant ast.Type, handled ast.Type) bool {
+	unaliased_variant := c.table.fully_unaliased_type(variant)
+	unaliased_handled := c.table.fully_unaliased_type(handled)
+	return unaliased_variant.idx() == unaliased_handled.idx()
+		&& unaliased_variant.has_flag(.option) == unaliased_handled.has_flag(.option)
+		&& unaliased_variant.nr_muls() == unaliased_handled.nr_muls()
+}
+
 fn (mut c Checker) match_exprs(mut node ast.MatchExpr, cond_type_sym ast.TypeSymbol, cond_final_sym ast.TypeSymbol) {
 	c.expected_type = node.expected_type
 	if node.cond_type.idx() == 0 {
@@ -694,6 +737,8 @@ fn (mut c Checker) match_exprs(mut node ast.MatchExpr, cond_type_sym ast.TypeSym
 	is_alias_to_matchable_type := cond_type_sym.kind == .alias
 		&& cond_final_sym.kind in [.interface, .sum_type]
 	cond_match_sym := if is_alias_to_matchable_type { cond_final_sym } else { cond_type_sym }
+	sumtype_match_variants := c.concrete_sumtype_variants(cond_match_type)
+	is_cond_match_sumtype := sumtype_match_variants.len > 0
 	mut enum_ref_checked := false
 	mut is_comptime_value_match := false
 	// branch_exprs is a histogram of how many times
@@ -908,12 +953,12 @@ fn (mut c Checker) match_exprs(mut node ast.MatchExpr, cond_type_sym ast.TypeSym
 							}
 						}
 					}
-				} else if cond_match_sym.info is ast.SumType {
-					if !c.table.sumtype_has_variant_recursive(cond_match_type, expr_type, true) {
+				} else if is_cond_match_sumtype {
+					if !c.match_sumtype_has_variant(cond_match_type, expr_type) {
 						expr_str := c.table.type_to_str(expr_type)
 						expect_str := c.table.type_to_str(node.cond_type)
 						sumtype_variant_names :=
-							c.table.sumtype_matchable_variants(cond_match_type).map(c.table.type_to_str_using_aliases(it, {}))
+							sumtype_match_variants.map(c.table.type_to_str_using_aliases(it, {}))
 						suggestion := util.new_suggestion(expr_str, sumtype_variant_names)
 						c.error(suggestion.say('`${expect_str}` has no variant `${expr_str}`'),
 							expr.pos())
@@ -941,7 +986,7 @@ fn (mut c Checker) match_exprs(mut node ast.MatchExpr, cond_type_sym ast.TypeSym
 		}
 		// when match is type matching, then register smart cast for every branch
 		if expr_types.len > 0 {
-			if cond_match_sym.kind in [.sum_type, .interface] {
+			if is_cond_match_sumtype || cond_match_sym.kind == .interface {
 				mut expr_type := ast.no_type
 				if expr_types.len > 1 {
 					mut agg_name := strings.new_builder(20)
@@ -999,34 +1044,34 @@ fn (mut c Checker) match_exprs(mut node ast.MatchExpr, cond_type_sym ast.TypeSym
 			}
 		}
 	} else {
-		match cond_match_sym.info {
-			ast.SumType {
-				for v in c.table.sumtype_missing_variants(cond_match_type, branch_expr_types) {
-					is_exhaustive = false
-					unhandled << '`${c.table.type_to_str(v)}`'
-				}
+		if is_cond_match_sumtype {
+			for v in c.match_sumtype_missing_variants(cond_match_type, branch_expr_types) {
+				is_exhaustive = false
+				unhandled << '`${c.table.type_to_str(v)}`'
 			}
-			//
-			ast.Enum {
-				for v in cond_match_sym.info.vals {
-					mut is_handled := v in branch_exprs
-					if !is_handled && is_multi_allowed_enum_match {
-						if enum_val := c.table.find_enum_field_val(cond_match_sym.name, v) {
-							is_handled = enum_val in branch_enum_values
+		} else {
+			match cond_match_sym.info {
+				ast.Enum {
+					for v in cond_match_sym.info.vals {
+						mut is_handled := v in branch_exprs
+						if !is_handled && is_multi_allowed_enum_match {
+							if enum_val := c.table.find_enum_field_val(cond_match_sym.name, v) {
+								is_handled = enum_val in branch_enum_values
+							}
+						}
+						if !is_handled {
+							is_exhaustive = false
+							unhandled << '`.${v}`'
 						}
 					}
-					if !is_handled {
+					if cond_match_sym.info.is_flag {
 						is_exhaustive = false
-						unhandled << '`.${v}`'
 					}
 				}
-				if cond_match_sym.info.is_flag {
+				else {
 					is_exhaustive = false
 				}
 			}
-			else {
-				is_exhaustive = false
-			}
 		}
 	}
 	if node.branches.len == 0 {

vlib/v/gen/c/fn.v

@@ -410,8 +410,9 @@ fn (mut g Gen) resolve_current_fn_generic_type(typ ast.Type) ast.Type {
 	if generic_names.len == 0 || g.cur_concrete_types.len == 0 {
 		return g.unwrap_generic(typ)
 	}
+	concrete_types := g.cur_concrete_types.map(ast.mktyp(it))
 	mut muttable := unsafe { &ast.Table(g.table) }
-	if resolved := muttable.convert_generic_type(typ, generic_names, g.cur_concrete_types) {
+	if resolved := muttable.convert_generic_type(typ, generic_names, concrete_types) {
 		return g.unwrap_generic(resolved)
 	}
 	return g.unwrap_generic(g.recheck_concrete_type(typ))
@@ -2017,7 +2018,13 @@ fn (mut g Gen) fn_decl_params(params []ast.Param, scope &ast.Scope, is_variadic
 		if i >= param_count {
 			break
 		}
-		mut typ := g.unwrap_generic(param.typ)
+		mut typ := if !param.typ.has_flag(.variadic) && g.cur_concrete_types.len > 0
+			&& param.orig_typ != 0 && (param.orig_typ.has_flag(.generic)
+			|| g.type_has_unresolved_generic_parts(param.orig_typ)) {
+			g.resolve_current_fn_generic_type(param.orig_typ)
+		} else {
+			g.unwrap_generic(param.typ)
+		}
 		if g.pref.translated && g.file.is_translated && param.typ.has_flag(.variadic) {
 			typ = g.table.sym(typ).array_info().elem_type.set_flag(.variadic)
 		}

vlib/v/tests/sumtypes/generic_sumtype_alias_match_regression_test.v

@@ -0,0 +1,15 @@
+struct GenericSumtypeAliasMatchItem {}
+
+type GenericSumtypeAliasMatchValue[T] = string | int | T
+
+fn generic_sumtype_alias_match_exhaustive[T](value GenericSumtypeAliasMatchValue[T]) int {
+	return match value {
+		string { 1 }
+		int { 2 }
+		T { 3 }
+	}
+}
+
+fn test_generic_sumtype_alias_match_with_generic_variant_is_exhaustive() {
+	assert generic_sumtype_alias_match_exhaustive(GenericSumtypeAliasMatchItem{}) == 3
+}

vlib/v/tests/sumtypes/generic_sumtype_alias_regression_test.v

@@ -0,0 +1,10 @@
+type GenericSumtypeAliasValue[T] = string | int | T
+
+fn generic_sumtype_alias_accepts_int_literal[T](value GenericSumtypeAliasValue[T]) int {
+	_ = value
+	return 0
+}
+
+fn test_generic_sumtype_alias_accepts_int_literal() {
+	assert generic_sumtype_alias_accepts_int_literal(5) == 0
+}

vlib/v/util/module.v

@@ -28,7 +28,7 @@ pub fn qualify_import(pref_ &pref.Preferences, mod string, file_path string) str
 	for search_path in mod_paths {
 		try_path := os.join_path_single(search_path, mod_path)
 		if os.is_dir(try_path) {
-			if m1 := mod_path_to_full_name(pref_, mod, try_path) {
+			if m1 := import_path_to_full_name(pref_, mod, try_path) {
 				trace_qualify(@FN, mod, file_path, 'import_res 1', m1, try_path)
 				// >  qualify_import: term | file_path: /v/vls/server/diagnostics.v | => import_res 1: term  ; /v/cleanv/vlib/term
 				return m1
@@ -41,7 +41,7 @@ pub fn qualify_import(pref_ &pref.Preferences, mod string, file_path string) str
 	} else {
 		os.join_path_single(os.getwd(), file_path)
 	}
-	if m1 := mod_path_to_full_name(pref_, mod, abs_file_path) {
+	if m1 := import_path_to_full_name(pref_, mod, abs_file_path) {
 		trace_qualify(@FN, mod, file_path, 'import_res 2', m1, abs_file_path)
 		// >  qualify_module: analyzer           | file_path: /v/vls/analyzer/store.v  | =>   module_res 2: analyzer           ; clean_file_path - getwd == mod
 		// >  qualify_import: analyzer.depgraph  | file_path: /v/vls/analyzer/store.v  | =>   import_res 2: analyzer.depgraph  ; /v/vls/analyzer/store.v
@@ -116,6 +116,14 @@ pub fn qualify_module(pref_ &pref.Preferences, mod string, file_path string) str
 // 2022-01-30 it leads to path differences, and the / version on windows triggers a module lookip bug,
 // 2022-01-30 leading to completely different errors)
 fn mod_path_to_full_name(pref_ &pref.Preferences, mod string, path string) !string {
+	return mod_path_to_full_name_with_options(pref_, mod, path, false)
+}
+
+fn import_path_to_full_name(pref_ &pref.Preferences, mod string, path string) !string {
+	return mod_path_to_full_name_with_options(pref_, mod, path, true)
+}
+
+fn mod_path_to_full_name_with_options(pref_ &pref.Preferences, mod string, path string, allow_shorter_name bool) !string {
 	// TODO: explore using `pref.lookup_path` & `os.vmodules_paths()`
 	// absolute paths instead of 'vlib' & '.vmodules'
 	mut vmod_folders := ['vlib', '.vmodules', 'modules']
@@ -169,7 +177,7 @@ fn mod_path_to_full_name(pref_ &pref.Preferences, mod string, path string) !stri
 						relative_parts := real_try_path.all_after(prefix).split(os.path_separator)
 						mod_full_name := normalize_base_url_mod_name(relative_parts.join('.'),
 							try_path)
-						if mod_full_name.len < mod.len {
+						if !allow_shorter_name && mod_full_name.len < mod.len {
 							return mod
 						}
 						if !module_name_has_empty_part(mod_full_name) {
@@ -197,7 +205,7 @@ fn mod_path_to_full_name(pref_ &pref.Preferences, mod string, path string) !stri
 				if last_v_mod > -1 {
 					mod_full_name := normalize_base_url_mod_name(try_path_parts[last_v_mod..].join('.'),
 						try_path)
-					if mod_full_name.len < mod.len {
+					if !allow_shorter_name && mod_full_name.len < mod.len {
 						return mod
 					}
 					if !module_name_has_empty_part(mod_full_name) {