module checker

import v.ast

@[inline]
fn (mut c Checker) mark_fn_decl_as_referenced(fkey string) {
    if fkey == '' {
        return
    }
    c.table.used_features.referenced_fns[fkey] = true
}

@[inline]
fn (mut c Checker) mark_const_decl_as_referenced(name string) {
    if name == '' {
        return
    }
    c.table.used_features.referenced_consts[name] = true
}

fn (mut c Checker) mark_type_str_method_as_referenced(typ ast.Type) {
    sym := c.table.sym(c.unwrap_generic(typ))
    if method := sym.find_method_with_generic_parent('str') {
        c.mark_fn_decl_as_referenced(method.fkey())
    }
}

fn (c &Checker) module_qualified_selector_const_name(node ast.SelectorExpr) string {
    if root_ident := node.root_ident() {
        if root_ident.name == c.mod {
            return '${c.mod}.${node.field_name}'
        }
        for import_sym in c.file.imports {
            alias := if import_sym.alias == '' {
                import_sym.mod.all_after_last('.')
            } else {
                import_sym.alias
            }
            if root_ident.name == alias {
                return '${import_sym.mod}.${node.field_name}'
            }
        }
    }
    return ''
}

fn (mut c Checker) check_unused_declarations(ast_files []&ast.File) {
    if c.pref.is_repl || c.pref.is_test || c.pref.check_only || c.pref.only_check_syntax
        || c.pref.translated || c.nr_errors > 0 || c.main_fn_decl_node.name == '' {
        return
    }
    saved_file := c.file
    for file in ast_files {
        if file.mod.name != 'main' || file.is_test || file.is_generated || file.is_translated {
            continue
        }
        c.change_current_file(file)
        c.check_unused_declarations_in_stmts(file.stmts)
        if c.should_abort {
            break
        }
    }
    if saved_file != unsafe { nil } {
        c.change_current_file(saved_file)
    }
}

fn (mut c Checker) check_unused_declarations_in_stmts(stmts []ast.Stmt) {
    for stmt in stmts {
        match stmt {
            ast.ConstDecl {
                for field in stmt.fields {
                    if c.should_warn_about_unused_const(field) {
                        c.note('unused constant: `${stripped_name(field.name)}`', field.pos)
                    }
                }
            }
            ast.FnDecl {
                if c.should_warn_about_unused_fn(stmt) {
                    name := if stmt.short_name != '' { stmt.short_name } else { stmt.get_name() }
                    c.note('unused function: `${name}`', stmt.name_pos)
                }
            }
            ast.ExprStmt {
                match stmt.expr {
                    ast.IfExpr {
                        if stmt.expr.is_comptime {
                            for branch in stmt.expr.branches {
                                if c.is_active_comptime_branch(branch.id) {
                                    c.check_unused_declarations_in_stmts(branch.stmts)
                                }
                            }
                        }
                    }
                    ast.MatchExpr {
                        if stmt.expr.is_comptime {
                            for branch in stmt.expr.branches {
                                if c.is_active_comptime_branch(branch.id) {
                                    c.check_unused_declarations_in_stmts(branch.stmts)
                                }
                            }
                        }
                    }
                    else {}
                }
            }
            else {}
        }

        if c.should_abort {
            return
        }
    }
}

fn (c &Checker) is_active_comptime_branch(branch_id int) bool {
    if branch_id == 0 {
        return true
    }
    if result := c.table.comptime_is_true['|id=${branch_id}|'] {
        return result.val
    }
    return true
}

fn (c &Checker) should_warn_about_unused_const(field ast.ConstField) bool {
    if field.is_pub || field.is_markused || field.is_exported || field.is_virtual_c {
        return false
    }
    return field.name !in c.table.used_features.referenced_consts
}

fn (c &Checker) should_warn_about_unused_fn(node ast.FnDecl) bool {
    if node.is_pub || node.is_markused || node.is_exported || node.no_body || node.is_main
        || node.is_test || node.is_method || node.is_static_type_method || node.should_be_skipped
        || node.short_name in ['init', 'cleanup'] {
        return false
    }
    return node.fkey() !in c.table.used_features.referenced_fns
}