v/vlib/compiler/table.v

// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.

module compiler

import os
import strings

struct Table {
mut:
	typesmap     map[string]Type
	consts       []Var
	fns          map[string]Fn
	generic_fns  []GenTable //map[string]GenTable // generic_fns['listen_and_serve'] == ['Blog', 'Forum']
	obf_ids      map[string]int // obf_ids['myfunction'] == 23
	modules      []string // List of all modules registered by the application
	imports      []string // List of all imports
	file_imports map[string]FileImportTable // List of imports for file
	cflags       []CFlag  // ['-framework Cocoa', '-lglfw3']
	fn_cnt       int //atomic
	obfuscate    bool
	varg_access  []VargAccess
	//names        []Name
}

struct VargAccess {
	fn_name string
	tok_idx int
	index   int
}

enum NameCategory {
	constant
	mod
	var
	typ
}

struct Name {
	cat NameCategory
	idx int // e.g. typ := types[name.idx]
}	

struct GenTable {
	fn_name string
mut:
	types []string
}

// Holds import information scoped to the parsed file
struct FileImportTable {
mut:
	module_name    string
	file_path_id   string 			 // file path or id
	imports        map[string]string // alias => module
	used_imports   []string          // alias
	import_tok_idx map[string]int    // module => idx
}

enum AccessMod {
	private        // private immutable
	private_mut    // private mutable
	public         // public immutable (readonly)
	public_mut     // public, but mutable only in this module
	public_mut_mut // public and mutable both inside and outside (not recommended to use, that's why it's so verbose)
}

enum TypeCategory {
	builtin
	struct_
	func // 2
	interface_
	enum_
	union_ // 5
	c_struct
	c_typedef
	objc_interface // 8 Objective C @interface
	array
	alias // `type myint int`
}

struct Var {
mut:
	typ             string
	name            string
	idx             int // index in the local_vars array
	is_arg          bool
	is_const        bool
	args            []Var // function args
	attr            string //  [json] etc
	is_mut          bool
	is_alloc        bool
	is_returned     bool
	ptr             bool
	ref             bool
	parent_fn       string // Variables can only be defined in functions
	mod             string // module where this var is stored
	access_mod      AccessMod
	is_global       bool // __global (translated from C only)
	is_used         bool
	is_changed      bool
	scope_level     int
	is_c            bool // todo remove once `typ` is `Type`, not string
	is_moved        bool
	line_nr         int
	token_idx       int // this is a token index, which will be used by error reporting
}

struct Type {
mut:
	mod            string
	name           string
	cat            TypeCategory
	fields         []Var
	methods        []Fn
	parent         string
	func           Fn // For cat == FN (type myfn fn())
	is_c           bool // `C.FILE`
	enum_vals []string
	gen_types []string
	// This field is used for types that are not defined yet but are known to exist.
	// It allows having things like `fn (f Foo) bar()` before `Foo` is defined.
	// This information is needed in the first pass.
	is_placeholder bool
	gen_str	       bool  // needs `.str()` method generation
	
}

struct TypeNode {
	mut:
	next &TypeNode
	typ Type
}

/*
// For debugging types
fn (t Type) str() string {
	mut s := 'type "$t.name" {'
	if t.fields.len > 0 {
		// s += '\n    $t.fields.len fields:\n'
		for field in t.fields {
			s += '\n    $field.name $field.typ'
		}
		s += '\n'
	}
	if t.methods.len > 0 {
		// s += '\n    $t.methods.len methods:\n'
		for method in t.methods {
			s += '\n    ${method.str()}'
		}
		s += '\n'
	}
	s += '}\n'
	return s
}
*/

const (
	CReserved = [
		'delete',
		'exit',
		'unix',
		//'print',
		// 'ok',
		'error',
		'malloc',
		'calloc',
		'free',
		'panic',

		// Full list of C reserved words, from: https://en.cppreference.com/w/c/keyword
		'auto',
		'char',
		'default',
		'do',
		'double',
		'extern',
		'float',
		'inline',
		'int',
		'long',
		'register',
		'restrict',
		'short',
		'signed',
		'sizeof',
		'static',
		'switch',
		'typedef',
		'union',
		'unsigned',
		'void',
		'volatile',
		'while',
	]

)

// This is used for debugging only
fn (f Fn) str() string {
	t := Table{}
	str_args := f.str_args(t)
	return '$f.name($str_args) $f.typ'
}

fn (t &Table) debug_fns() string {
	mut s := strings.new_builder(1000)
	for _, f in t.fns {
		s.writeln(f.name)
	}
	return s.str()
}

// fn (types array_Type) print_to_file(f string)  {
// }
const (
	number_types = ['number', 'int', 'i8', 'i16', 'u16', 'u32', 'byte', 'i64', 'u64', 'f32', 'f64']
	float_types  = ['f32', 'f64']
)

fn is_number_type(typ string) bool {
	return typ in number_types
}

fn is_float_type(typ string) bool {
	return typ in float_types
}

fn is_primitive_type(typ string) bool {
	return is_number_type(typ) || typ == 'string'
}

fn new_table(obfuscate bool) &Table {
	mut t := &Table {
		obfuscate: obfuscate
	}
	t.register_type('int')
	t.register_type('size_t')
	t.register_type_with_parent('i8', 'int')
	t.register_type_with_parent('byte', 'int')
	t.register_type_with_parent('char', 'int') // for C functions only, to avoid warnings
	t.register_type_with_parent('i16', 'int')
	t.register_type_with_parent('u16', 'u32')
	t.register_type_with_parent('u32', 'int')
	t.register_type_with_parent('i64', 'int')
	t.register_type_with_parent('u64', 'u32')
	t.register_type('byteptr')
	t.register_type('intptr')
	t.register_type('f32')
	t.register_type('f64')
	t.register_type('rune')
	t.register_type('bool')
	t.register_type('void')
	t.register_type('voidptr')
	t.register_type('T')
	t.register_type('va_list')
	t.register_const('stdin', 'int', 'main')
	t.register_const('stdout', 'int', 'main')
	t.register_const('stderr', 'int', 'main')
	t.register_const('errno', 'int', 'main')
	t.register_type_with_parent('map_string', 'map')
	t.register_type_with_parent('map_int', 'map')
	return t
}

// If `name` is a reserved C keyword, returns `v_name` instead.
fn (t &Table) var_cgen_name(name string) string {
	if name in CReserved {
		return 'v_$name'
	}
	else {
		return name
	}
}

fn (t mut Table) register_module(mod string) {
	if mod in t.modules {
		return
	}
	t.modules << mod
}

fn (p mut Parser) register_array(typ string) {
	if typ.contains('*') {
		println('bad arr $typ')
		return
	}
	if !p.table.known_type(typ) {
		p.register_type_with_parent(typ, 'array')
		p.cgen.typedefs << 'typedef array $typ;'
	}
}

fn (p mut Parser) register_map(typ string) {
	if typ.contains('*') {
		println('bad map $typ')
		return
	}
	if !p.table.known_type(typ) {
		p.register_type_with_parent(typ, 'map')
		p.cgen.typedefs << 'typedef map $typ;'
	}
}

fn (table &Table) known_mod(mod string) bool {
	return mod in table.modules
}

fn (t mut Table) register_const(name, typ, mod string) {
	t.consts << Var {
		name: name
		typ: typ
		is_const: true
		mod: mod
		idx: -1
	}
}

// Only for translated code
fn (p mut Parser) register_global(name, typ string) {
	p.table.consts << Var {
		name: name
		typ: typ
		is_const: true
		is_global: true
		mod: p.mod
		is_mut: true
		idx: -1
	}
}

// Only for module functions, not methods.
// That's why searching by fn name works.
fn (t mut Table) register_fn(new_fn Fn) {
	t.fns[new_fn.name] = new_fn
}

fn (table &Table) known_type(typ_ string) bool {
	mut typ := typ_
	// vararg
	if typ.starts_with('...') && typ.len > 3 {
		typ = typ.right(3)
	}
	// 'byte*' => look up 'byte', but don't mess up fns
	if typ.ends_with('*') && !typ.contains(' ') {
		typ = typ.left(typ.len - 1)
	}
	t := table.typesmap[typ]
	return t.name.len > 0 && !t.is_placeholder
}

fn (table &Table) known_type_fast(t &Type) bool {
	return t.name != '' && !t.is_placeholder
}

fn (t &Table) find_fn(name string) ?Fn {
	f := t.fns[name]
	if f.name.str != 0 { // TODO
		return f
	}
	return none
}

fn (t &Table) known_fn(name string) bool {
	_ = t.find_fn(name) or { return false }
	return true
}

fn (t &Table) known_const(name string) bool {
	_ = t.find_const(name) or { return false }
	return true
}

fn (t mut Table) register_type(typ string) {
	if typ.len == 0 {
		return
	}
	if typ in t.typesmap {
		return
	}
	t.typesmap[typ] = Type{name:typ}
}

fn (p mut Parser) register_type_with_parent(strtyp, parent string) {
	typ := Type {
		name: strtyp
		parent: parent
		mod: p.mod
	}
	p.table.register_type2(typ)
}

fn (t mut Table) register_type_with_parent(typ, parent string) {
	if typ.len == 0 {
		return
	}
	t.typesmap[typ] = Type {
		name: typ
		parent: parent
		//mod: mod
	}
}

fn (t mut Table) register_type2(typ Type) {
	if typ.name.len == 0 {
		return
	}
	t.typesmap[typ.name] = typ
}

fn (t mut Table) rewrite_type(typ Type) {
	if typ.name.len == 0 {
		return
	}
	t.typesmap[typ.name]  = typ
}

fn (table mut Table) add_field(type_name, field_name, field_type string, is_mut bool, attr string, access_mod AccessMod) {
	if type_name == '' {
		print_backtrace()
		verror('add_field: empty type')
	}
	mut t := table.typesmap[type_name]
	t.fields << Var {
		name: field_name
		typ: field_type
		is_mut: is_mut
		attr: attr
		parent_fn: type_name   // Name of the parent type
		access_mod: access_mod
	}
	table.typesmap[type_name] = t
}

fn (t &Type) has_field(name string) bool {
	_ = t.find_field(name) or { return false }
	return true
}

fn (t &Type) has_enum_val(name string) bool {
	return name in t.enum_vals
}

fn (t &Type) find_field(name string) ?Var {
	for field in t.fields {
		if field.name == name {
			return field
		}
	}
	return none
}

fn (table &Table) type_has_field(typ &Type, name string) bool {
	_ = table.find_field(typ, name) or { return false }
	return true
}

fn (table &Table) find_field(typ &Type, name string) ?Var {
	for field in typ.fields {
		if field.name == name {
			return field
		}
	}
	if typ.parent != '' {
		parent := table.find_type(typ.parent)
		for field in parent.fields {
			if field.name == name {
				return field
			}
		}
	}
	return none
}

fn (p mut Parser) add_method(type_name string, f Fn) {
	if !p.first_pass() && f.name != 'str' {
		return
	}
	if type_name == '' {
		print_backtrace()
		verror('add_method: empty type')
	}
	// TODO table.typesmap[type_name].methods << f
	mut t := p.table.typesmap[type_name]
	if f.name != 'str' && f in t.methods  {
		p.error('redefinition of method `${type_name}.$f.name`')
	}
	t.methods << f
	p.table.typesmap[type_name] = t
}

fn (t &Type) has_method(name string) bool {
	_ = t.find_method(name) or { return false }
	return true
}

fn (table &Table) type_has_method(typ &Type, name string) bool {
	_ = table.find_method(typ, name) or { return false }
	return true
}

fn (table &Table) find_method(typ &Type, name string) ?Fn {
	t := table.typesmap[typ.name]
	for method in t.methods {
		if method.name == name {
			return method
		}
	}
	if typ.parent != '' {
		parent := table.find_type(typ.parent)
		for method in parent.methods {
			if method.name == name {
				return method
			}
		}
		return none
	}
	return none
}

fn (t &Type) find_method(name string) ?Fn {
	// println('$t.name find_method($name) methods.len=$t.methods.len')
	for method in t.methods {
		// println('method=$method.name')
		if method.name == name {
			return method
		}
	}
	return none
}

/*
// TODO
fn (t mutt Type) add_gen_type(type_name string) {
	// println('add_gen_type($s)')
	if t.gen_types.contains(type_name) {
		return
	}
	t.gen_types << type_name
}
*/

fn (p &Parser) find_type(name string) Type {
	typ := p.table.find_type(name)
	if typ.name == '' {
		return p.table.find_type(p.prepend_mod(name))
	}
	return typ
}

fn (t &Table) find_type(name_ string) Type {
	mut name := name_
	if name.ends_with('*') && !name.contains(' ') {
		name = name.left(name.len - 1)
	}
	if !(name in t.typesmap) {
		//println('ret Type')
		return Type{}
	}
	return t.typesmap[name]
}

fn (p mut Parser) check_types2(got_, expected_ string, throw bool) bool {
	mut got := got_
	mut expected := expected_
	//p.log('check types got="$got" exp="$expected"  ')
	if p.pref.translated {
		return true
	}
	// variadic
	if expected.starts_with('...') {
		expected = expected.right(3)
	}
	if got.starts_with('...') {
		got = got.right(3)
	}
	// Allow ints to be used as floats
	if got == 'int' && expected == 'f32' {
		return true
	}
	if got == 'int' && expected == 'f64' {
		return true
	}
	if got == 'f64' && expected == 'f32' {
		return true
	}
	if got == 'f32' && expected == 'f64' {
		return true
	}
	// Allow ints to be used as longs
	if got=='int' && expected=='i64' {
		return true
	}
	if got == 'void*' && expected.starts_with('fn ') {
		return true
	}
	if got.starts_with('[') && expected == 'byte*' {
		return true
	}
	// Todo void* allows everything right now
	if got=='void*' || expected=='void*' {// || got == 'cvoid' || expected == 'cvoid' {
		return true
	}
	// TODO only allow numeric consts to be assigned to bytes, and
	// throw an error if they are bigger than 255
	if got=='int' && expected=='byte' {
		return true
	}
	if got=='byteptr' && expected=='byte*' {
		return true
	}
	if got=='byte*' && expected=='byteptr' {
		return true
	}
	if got=='int' && expected=='byte*' {
		return true
	}
	//if got=='int' && expected=='voidptr*' {
		//return true
	//}
	// byteptr += int
	if got=='int' && expected=='byteptr' {
		return true
	}
	if got == 'Option' && expected.starts_with('Option_') {
		return true
	}
	// lines := new_array
	if got == 'array' && expected.starts_with('array_') {
		return true
	}
	// Expected type "Option_os__File", got "os__File"
	if expected.starts_with('Option_') && expected.ends_with(got) {
		return true
	}
	// NsColor* return 0
	if expected.ends_with('*') && got == 'int' {
		return true
	}
	// if got == 'T' || got.contains('<T>') {
	// return true
	// }
	// if expected == 'T' || expected.contains('<T>') {
	// return true
	// }
	// TODO fn hack
	if got.starts_with('fn ') && (expected.ends_with('fn') ||
	expected.ends_with('Fn')) {
		return true
	}	
	// Allow pointer arithmetic
	if expected=='void*' && got=='int' {
		return true
	}
	// Allow `myu64 == 1`
	//if p.fileis('_test') && is_number_type(got) && is_number_type(expected)  {
		//p.warn('got=$got exp=$expected $p.is_const_literal')
	//}
	if is_number_type(got) && is_number_type(expected) && p.is_const_literal {
		return true
	}	
	expected = expected.replace('*', '')
	got = got.replace('*', '')
	if got != expected {
		// Interface check
		if expected.ends_with('er') {
			if p.satisfies_interface(expected, got, throw) {
				return true
			}
		}
		if !throw {
			return false
		}
		else {
			p.error('expected type `$expected`, but got `$got`')
		}
	}
	return true
}

// throw by default
fn (p mut Parser) check_types(got, expected string) bool {
	if p.first_pass() { return true }
	return p.check_types2(got, expected, true)
}

fn (p mut Parser) check_types_no_throw(got, expected string) bool {
	return p.check_types2(got, expected, false)
}

fn (p mut Parser) check_types_with_token_index(got, expected string, var_token_idx int) {
	if !p.check_types2(got, expected, false) {
		p.error_with_token_index('expected type `$expected`, but got `$got`', var_token_idx)
	}
}

fn (p mut Parser) satisfies_interface(interface_name, _typ string, throw bool) bool {
	int_typ := p.table.find_type(interface_name)
	typ := p.table.find_type(_typ)
	for method in int_typ.methods {
		if !typ.has_method(method.name) {
			// if throw {
			p.error('Type "$_typ" doesn\'t satisfy interface "$interface_name" (method "$method.name" is not implemented)')
			// }
			return false
		}
	}
	return true
}


fn (table &Table) is_interface(name string) bool {
	if !(name in table.typesmap) {
		return false
	}
	t := table.typesmap[name]
	return t.cat == .interface_
}

// Do we have fn main()?
fn (t &Table) main_exists() bool {
	for _, f in t.fns {
		if f.name == 'main__main' {
			return true
		}
	}
	return false
}

fn (t &Table) has_at_least_one_test_fn() bool {
	for _, f in t.fns {
		if f.name.starts_with('main__test_') {
			return true
		}	
	}
	return false
}

fn (t &Table) find_const(name string) ?Var {
	//println('find const l=$t.consts.len')
	for c in t.consts {
		if c.name == name {
			return c
		}
	}
	return none
}

// ('s', 'string') => 'string s'
// ('nums', '[20]byte') => 'byte nums[20]'
// ('myfn', 'fn(int) string') => 'string (*myfn)(int)'
fn (table &Table) cgen_name_type_pair(name, typ string) string {
	// Special case for [10]int
	if typ.len > 0 && typ[0] == `[` {
		tmp := typ.all_after(']')
		size := typ.all_before(']')
		return '$tmp $name  $size ]'
	}
	// fn()
	else if typ.starts_with('fn (') {
		T := table.find_type(typ)
		if T.name == '' {
			println('this should never happen')
			exit(1)
		}
		str_args := T.func.str_args(table)
		return '$T.func.typ (*$name)( $str_args /*FFF*/ )'
	}
	// TODO tm hack, do this for all C struct args
	else if typ == 'tm' {
		return 'struct /*TM*/ tm $name'
	}
	return '$typ $name'
}

fn is_valid_int_const(val, typ string) bool {
	x := val.int()
	switch typ {
	case 'byte': return 0 <= x && x <= 255
	case 'u16': return 0 <= x && x <= 65535
	//case 'u32': return 0 <= x && x <= math.MaxU32
	//case 'u64': return 0 <= x && x <= math.MaxU64
	//////////////
	case 'i8': return -128 <= x && x <= 127
	/*
	case 'i16': return math.min_i16 <= x && x <= math.max_i16
	case 'int': return math.min_i32 <= x && x <= math.max_i32
	*/
	//case 'i64':
		//x64 := val.i64()
		//return i64(-(1<<63)) <= x64 && x64 <= i64((1<<63)-1)
	}
	return true
}

fn (t mut Table) register_generic_fn(fn_name string) {
	t.generic_fns << GenTable{fn_name, []string}
}

fn (t &Table) fn_gen_types(fn_name string) []string {
	for _, f in t.generic_fns {
		if f.fn_name == fn_name {
			return f.types
		}
	}
	verror('function $fn_name not found')
	return []string
}

// `foo<Bar>()`
// fn_name == 'foo'
// typ == 'Bar'
fn (t mut Table) register_generic_fn_type(fn_name, typ string) {
	for i, f in t.generic_fns {
		if f.fn_name == fn_name {
			t.generic_fns[i].types << typ
			return
		}
	}
}

fn (p mut Parser) typ_to_fmt(typ string, level int) string {
	t := p.table.find_type(typ)
	if t.cat == .enum_ {
		return '%d'
	}
	switch typ {
	case 'string': return '%.*s'
	//case 'bool': return '%.*s'
	case 'ustring': return '%.*s'
	case 'byte', 'bool', 'int', 'char', 'byte', 'i16', 'i8': return '%d'
	case 'u16', 'u32': return '%u'
	case 'f64', 'f32': return '%f'
	case 'i64': return '%lld'
	case 'u64': return '%llu'
	case 'byte*', 'byteptr': return '%s'
		// case 'array_string': return '%s'
		// case 'array_int': return '%s'
	case 'void': p.error('cannot interpolate this value')
	default:
		if typ.ends_with('*') {
			return '%p'
		}
	}
	if t.parent != '' && level == 0 {
		return p.typ_to_fmt(t.parent, level+1)
	}
	return ''
}

fn is_compile_time_const(s_ string) bool {
	s := s_.trim_space()
	if s == '' {
		return false
	}
	if s.contains('\'') {
		return true
	}
	for c in s {
		if ! ((c >= `0` && c <= `9`) || c == `.`) {
			return false
		}
	}
	return true
}

// Once we have a module format we can read from module file instead
// this is not optimal
fn (table &Table) qualify_module(mod string, file_path string) string {
	for m in table.imports {
		if m.contains('.') && m.contains(mod) {
			m_parts := m.split('.')
			m_path := m_parts.join(os.path_separator)
			if mod == m_parts[m_parts.len-1] && file_path.contains(m_path) {
				return m
			}
		}
	}
	return mod
}

fn (table &Table) get_file_import_table(file_path_id string) FileImportTable {
	if file_path_id in table.file_imports {
		return table.file_imports[file_path_id]
	}
	return new_file_import_table(file_path_id)
}

fn new_file_import_table(file_path_id string) FileImportTable {
	return FileImportTable{
		file_path_id: file_path_id
		imports:   map[string]string
	}
}

fn (fit &FileImportTable) known_import(mod string) bool {
	return mod in fit.imports || fit.is_aliased(mod)
}

fn (fit mut FileImportTable) register_import(mod string, tok_idx int) {
	fit.register_alias(mod, mod, tok_idx)
}

fn (fit mut FileImportTable) register_alias(alias string, mod string, tok_idx int) {
	// NOTE: come back here
	// if alias in fit.imports && fit.imports[alias] == mod {}
	if alias in fit.imports && fit.imports[alias] != mod {
		verror('cannot import $mod as $alias: import name $alias already in use in "${fit.file_path_id}"')
	}
	if mod.contains('.internal.') {
		mod_parts := mod.split('.')
		mut internal_mod_parts := []string
		for part in mod_parts {
			if part == 'internal' { break }
			internal_mod_parts << part
		}
		internal_parent := internal_mod_parts.join('.')
		if !fit.module_name.starts_with(internal_parent) {
			verror('module $mod can only be imported internally by libs')
		}
	}
	fit.imports[alias] = mod
	fit.import_tok_idx[mod] = tok_idx
}

fn (fit &FileImportTable) get_import_tok_idx(mod string) int {
	return fit.import_tok_idx[mod]
}

fn (fit &FileImportTable) known_alias(alias string) bool {
	return alias in fit.imports
}

fn (fit &FileImportTable) is_aliased(mod string) bool {
	for _, val in fit.imports {
		if val == mod {
			return true
		}
	}
	return false
}

fn (fit &FileImportTable) resolve_alias(alias string) string {
	return fit.imports[alias]
}

fn (fit mut FileImportTable) register_used_import(alias string) {
	if !(alias in fit.used_imports) {
		fit.used_imports << alias
	}
}

fn (fit &FileImportTable) is_used_import(alias string) bool {
	return alias in fit.used_imports
}

fn (t &Type) contains_field_type(typ string) bool {
	if !t.name[0].is_capital() {
		return false
	}
	for field in t.fields {
		if field.typ == typ {
			return true
		}
	}
	return false
}

// check for a function / variable / module typo in `name`
fn (p &Parser) identify_typo(name string, fit &FileImportTable) string {
	// dont check if so short
	if name.len < 2 { return '' }
	min_match := 0.50 // for dice coefficient between 0.0 - 1.0
	name_orig := mod_gen_name_rev(name.replace('__', '.'))
	mut output := ''
	// check functions
	mut n := p.table.find_misspelled_fn(name, fit, min_match)
	if n != '' {
		output += '\n  * function: `$n`'
	}
	// check function local variables
	n = p.find_misspelled_local_var(name_orig, min_match)
	if n != '' {
		output += '\n  * variable: `$n`'
	}
	// check imported modules
	n = p.table.find_misspelled_imported_mod(name_orig, fit, min_match)
	if n != '' {
		output += '\n  * module: `$n`'
	}
	return output
}

// find function with closest name to `name`
fn (table &Table) find_misspelled_fn(name string, fit &FileImportTable, min_match f32) string {
	mut closest := f32(0)
	mut closest_fn := ''
	n1 := if name.starts_with('main__') { name.right(6) } else { name }
	for _, f in table.fns {
		if n1.len - f.name.len > 2 || f.name.len - n1.len > 2 { continue }
		if !(f.mod in ['', 'main', 'builtin']) {
			mut mod_imported := false
			for _, m in fit.imports {
				if f.mod == m {
					mod_imported = true
					break
				}
			}
			if !mod_imported { continue }
		}
		p := strings.dice_coefficient(n1, f.name)
		if p > closest {
			closest = p
			closest_fn = f.name
		}
	}
	return if closest >= min_match { closest_fn } else { '' }
}

// find imported module with closest name to `name`
fn (table &Table) find_misspelled_imported_mod(name string, fit &FileImportTable, min_match f32) string {
	mut closest := f32(0)
	mut closest_mod := ''
	n1 := if name.starts_with('main.') { name.right(5) } else { name }
	for alias, mod in fit.imports {
		if (n1.len - alias.len > 2 || alias.len - n1.len > 2) { continue }
		mod_alias := if alias == mod { alias } else { '$alias ($mod)' }
		p := strings.dice_coefficient(n1, alias)
		if p > closest {
			closest = p
			closest_mod = '$mod_alias'
		}
	}
	return if closest >= min_match { closest_mod } else { '' }
}