// vtest build: macos
module builder

import os
import v2.ast
import v2.pref

fn parse_files_for_parse_test(mut b Builder, paths []string) []ast.File {
    b.parse_files(paths)
    b.flat = b.flat_builder.flat
    return b.flat.to_files()
}

fn test_parse_files_keeps_single_file_inputs_isolated() {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_parse_single_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    entry_file := os.join_path(tmp_dir, 'hello.v')
    sibling_file := os.join_path(tmp_dir, 'extra.v')
    os.write_file(entry_file, 'module main\nfn main() {}\n') or { panic(err) }
    os.write_file(sibling_file, 'module main\nfn extra() {}\n') or { panic(err) }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    prefs.skip_imports = true
    mut b := new_builder(&prefs)
    files := parse_files_for_parse_test(mut b, [entry_file])

    assert files.len == 1
}

fn test_parse_files_expands_directory_inputs() {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_parse_dir_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    entry_file := os.join_path(tmp_dir, 'hello.v')
    sibling_file := os.join_path(tmp_dir, 'extra.v')
    os.write_file(entry_file, 'module main\nfn main() {}\n') or { panic(err) }
    os.write_file(sibling_file, 'module main\nfn extra() {}\n') or { panic(err) }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    prefs.skip_imports = true
    mut b := new_builder(&prefs)
    files := parse_files_for_parse_test(mut b, [tmp_dir])

    assert files.len == 2
}

fn test_parse_files_expands_same_module_subdirectories() {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_parse_dir_recursive_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(os.join_path(tmp_dir, 'user')) or { panic(err) }
    os.mkdir_all(os.join_path(tmp_dir, 'api')) or { panic(err) }
    os.mkdir_all(os.join_path(tmp_dir, 'nested_app')) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    entry_file := os.join_path(tmp_dir, 'main.v')
    user_file := os.join_path(tmp_dir, 'user', 'user.v')
    api_file := os.join_path(tmp_dir, 'api', 'api.v')
    nested_file := os.join_path(tmp_dir, 'nested_app', 'main.v')
    os.write_file(entry_file, 'module main\nfn main() {}\n') or { panic(err) }
    os.write_file(user_file, 'module main\nstruct User {}\n') or { panic(err) }
    os.write_file(api_file, 'module api\nstruct Payload {}\n') or { panic(err) }
    os.write_file(os.join_path(tmp_dir, 'nested_app', 'v.mod'), 'Module { name: "nested" }\n') or {
        panic(err)
    }
    os.write_file(nested_file, 'module main\nfn nested_main() {}\n') or { panic(err) }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    prefs.skip_imports = true
    mut b := new_builder(&prefs)
    files := parse_files_for_parse_test(mut b, [tmp_dir])
    names := files.map(os.file_name(it.name))

    assert files.len == 2
    assert 'main.v' in names
    assert 'user.v' in names
}

fn test_parse_files_expands_implicit_main_subdirectories() {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_parse_dir_implicit_main_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(os.join_path(tmp_dir, 'heroes')) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    entry_file := os.join_path(tmp_dir, 'main.v')
    hero_file := os.join_path(tmp_dir, 'heroes', 'hero.v')
    os.write_file(entry_file, 'fn main() {}\n') or { panic(err) }
    os.write_file(hero_file, 'struct HeroEffect {}\n') or { panic(err) }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    prefs.skip_imports = true
    mut b := new_builder(&prefs)
    files := parse_files_for_parse_test(mut b, [tmp_dir])
    names := files.map(os.file_name(it.name))

    assert files.len == 2
    assert 'main.v' in names
    assert 'hero.v' in names
}

fn test_parse_files_skips_block_commented_non_main_subdirectories() {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_parse_dir_block_comment_mod_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(os.join_path(tmp_dir, 'api')) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    entry_file := os.join_path(tmp_dir, 'main.v')
    api_file := os.join_path(tmp_dir, 'api', 'api.v')
    os.write_file(entry_file, 'module main\nfn main() {}\n') or { panic(err) }
    os.write_file(api_file, '/* license header */\nmodule api\nstruct Payload {}\n') or {
        panic(err)
    }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    prefs.skip_imports = true
    mut b := new_builder(&prefs)
    files := parse_files_for_parse_test(mut b, [tmp_dir])
    names := files.map(os.file_name(it.name))

    assert files.len == 1
    assert 'main.v' in names
    assert 'api.v' !in names
}

fn test_virtual_main_modules_skip_groups_with_executable_main_from_paths() {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_virtual_paths_main_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(os.join_path(tmp_dir, 'admin')) or { panic(err) }
    os.mkdir_all(os.join_path(tmp_dir, 'tests')) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    main_file := os.join_path(tmp_dir, 'main.v')
    admin_file := os.join_path(tmp_dir, 'admin', 'admin.v')
    test_file := os.join_path(tmp_dir, 'tests', 'first_run.v')
    os.write_file(main_file, 'module main\nfn main() {}\n') or { panic(err) }
    os.write_file(admin_file, 'module main\nfn admin_route() {}\n') or { panic(err) }
    os.write_file(test_file, 'module main\nfn main() {}\n') or { panic(err) }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    prefs.skip_imports = true
    mut b := new_builder(&prefs)
    b.user_files = [tmp_dir]
    groups := b.collect_virtual_main_modules_from_paths([main_file, admin_file, test_file])
    names := groups.map(it.name)

    assert names == ['admin']
}

fn test_virtual_main_modules_skip_groups_with_attributed_executable_main_from_paths() {
    tmp_dir := os.join_path(os.temp_dir(),
        'v2_builder_virtual_paths_attributed_main_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(os.join_path(tmp_dir, 'admin')) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    main_file := os.join_path(tmp_dir, 'main.v')
    admin_file := os.join_path(tmp_dir, 'admin', 'admin.v')
    os.write_file(main_file, 'module main\nfn main() {}\n') or { panic(err) }
    os.write_file(admin_file, 'module main\n@[console] fn main() {}\n') or { panic(err) }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    prefs.skip_imports = true
    mut b := new_builder(&prefs)
    b.user_files = [tmp_dir]
    groups := b.collect_virtual_main_modules_from_paths([main_file, admin_file])

    assert groups.len == 0
}

fn test_virtual_main_modules_skip_groups_with_executable_main_from_ast() {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_virtual_ast_main_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(os.join_path(tmp_dir, 'admin')) or { panic(err) }
    os.mkdir_all(os.join_path(tmp_dir, 'tests')) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    os.write_file(os.join_path(tmp_dir, 'main.v'), 'module main\nfn main() {}\n') or { panic(err) }
    os.write_file(os.join_path(tmp_dir, 'admin', 'admin.v'), 'module main\nfn admin_route() {}\n') or {
        panic(err)
    }
    os.write_file(os.join_path(tmp_dir, 'tests', 'first_run.v'), 'module main\nfn main() {}\n') or {
        panic(err)
    }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    prefs.skip_imports = true
    mut b := new_builder(&prefs)
    b.user_files = [tmp_dir]
    b.files = parse_files_for_parse_test(mut b, [tmp_dir])
    groups := b.collect_virtual_main_modules()
    names := groups.map(it.name)

    assert names == ['admin']
}

fn test_parse_files_expands_non_main_module_files() {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_parse_module_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    entry_file := os.join_path(tmp_dir, 'math_test.v')
    sibling_file := os.join_path(tmp_dir, 'math.v')
    os.write_file(entry_file, 'module math\nconst x = twice(21)\n') or { panic(err) }
    os.write_file(sibling_file, 'module math\nfn twice(v int) int { return v * 2 }\n') or {
        panic(err)
    }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    prefs.skip_imports = true
    mut b := new_builder(&prefs)
    files := parse_files_for_parse_test(mut b, [entry_file])

    assert files.len == 2
}

fn test_parse_files_resolves_project_root_sibling_import_from_nested_module_file() {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_parse_nested_import_${os.getpid()}')
    flags_dir := os.join_path(tmp_dir, 'core', 'flags')
    ignore_dir := os.join_path(tmp_dir, 'ignore')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(flags_dir) or { panic(err) }
    os.mkdir_all(ignore_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    entry_file := os.join_path(flags_dir, 'complete_test.v')
    ignore_file := os.join_path(ignore_dir, 'lib.v')
    os.write_file(os.join_path(tmp_dir, 'v.mod'), "Module { name: 'nested_import' }\n") or {
        panic(err)
    }
    os.write_file(entry_file, 'module flags\nimport ignore\nfn test_use_import() {}\n') or {
        panic(err)
    }
    os.write_file(ignore_file, 'module ignore\npub struct Marker {}\n') or { panic(err) }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    mut b := new_builder(&prefs)
    files := parse_files_for_parse_test(mut b, [entry_file])
    names := files.map(os.file_name(it.name))

    assert 'complete_test.v' in names
    assert 'lib.v' in names
}

fn test_parse_files_prefers_project_root_module_over_vlib_module() {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_parse_local_shadow_${os.getpid()}')
    app_dir := os.join_path(tmp_dir, 'app')
    regex_dir := os.join_path(tmp_dir, 'regex')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(app_dir) or { panic(err) }
    os.mkdir_all(regex_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }

    entry_file := os.join_path(app_dir, 'main.v')
    local_regex_file := os.join_path(regex_dir, 'local_regex.v')
    os.write_file(os.join_path(tmp_dir, 'v.mod'), "Module { name: 'local_shadow' }\n") or {
        panic(err)
    }
    os.write_file(entry_file, 'module main\nimport regex\nfn main() {}\n') or { panic(err) }
    os.write_file(local_regex_file, 'module regex\npub struct RegexMatcher {}\n') or { panic(err) }

    mut prefs := pref.new_preferences()
    prefs.skip_builtin = true
    mut b := new_builder(&prefs)
    files := parse_files_for_parse_test(mut b, [entry_file])

    assert files.any(it.name == local_regex_file)
}

fn test_active_file_imports_follow_comptime_else_branch() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.ComptimeExpr{
                    expr: ast.IfExpr{
                        cond:      ast.Ident{
                            name: 'linux'
                        }
                        stmts:     [
                            ast.Stmt(ast.ImportStmt{
                                name:  'net.openssl'
                                alias: 'openssl'
                            }),
                        ]
                        else_expr: ast.IfExpr{
                            cond:  ast.empty_expr
                            stmts: [
                                ast.Stmt(ast.ImportStmt{
                                    name:  'net.mbedtls'
                                    alias: 'mbedtls'
                                }),
                            ]
                        }
                    }
                }
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.len == 1
    assert imports[0].name == 'net.mbedtls'
}

fn test_active_file_imports_skips_sync_for_channel_in_inactive_comptime_branch() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.ComptimeExpr{
                    expr: ast.IfExpr{
                        cond:  ast.Ident{
                            name: 'windows'
                        }
                        stmts: [
                            ast.Stmt(ast.ExprStmt{
                                expr: ast.Type(ast.ChannelType{
                                    elem_type: ast.Expr(ast.Ident{
                                        name: 'int'
                                    })
                                })
                            }),
                        ]
                    }
                }
            }),
        ]
    }
    linux_imports := active_file_imports(file, [], 'linux').map(it.name)
    windows_imports := active_file_imports(file, [], 'windows').map(it.name)

    assert 'sync' !in linux_imports
    assert 'sync' in windows_imports
}

fn test_active_file_imports_skips_sync_for_channel_in_sync_module() {
    file := ast.File{
        mod:   'sync'
        name:  'cond.v'
        stmts: [
            ast.Stmt(ast.ModuleStmt{
                name: 'sync'
            }),
            ast.Stmt(ast.StructDecl{
                name:   'Cond'
                fields: [
                    ast.FieldDecl{
                        name: 'waiters'
                        typ:  ast.Type(ast.ArrayType{
                            elem_type: ast.Expr(ast.Type(ast.ChannelType{
                                elem_type: ast.Expr(ast.Ident{
                                    name: 'bool'
                                })
                            }))
                        })
                    },
                ]
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac').map(it.name)
    mut flat_builder := ast.new_flat_builder()
    flat_builder.append_file(file)
    flat_imports := active_file_imports_from_flat(&flat_builder.flat, flat_builder.flat.files[0],
        [], [], 'mac').map(it.name)

    assert 'sync' !in imports
    assert 'sync' !in flat_imports
}

fn test_active_file_imports_adds_sync_for_channel_in_if_condition() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.IfExpr{
                    cond: ast.CallExpr{
                        lhs:  ast.Expr(ast.Ident{
                            name: 'takes_chan'
                        })
                        args: [
                            ast.Expr(ast.Type(ast.ChannelType{
                                elem_type: ast.Expr(ast.Ident{
                                    name: 'int'
                                })
                            })),
                        ]
                    }
                }
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.any(it.name == 'sync')
}

fn test_active_file_imports_adds_sync_for_channel_in_for_condition() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.ForStmt{
                cond: ast.CallExpr{
                    lhs:  ast.Expr(ast.Ident{
                        name: 'takes_chan'
                    })
                    args: [
                        ast.Expr(ast.Type(ast.ChannelType{
                            elem_type: ast.Expr(ast.Ident{
                                name: 'int'
                            })
                        })),
                    ]
                }
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.any(it.name == 'sync')
}

fn test_active_file_imports_adds_sync_for_channel_in_assert_expr() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.AssertStmt{
                expr: ast.CallExpr{
                    lhs:  ast.Expr(ast.Ident{
                        name: 'takes_chan'
                    })
                    args: [
                        ast.Expr(ast.Type(ast.ChannelType{
                            elem_type: ast.Expr(ast.Ident{
                                name: 'int'
                            })
                        })),
                    ]
                }
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.any(it.name == 'sync')
}

fn test_active_file_imports_adds_sync_for_channel_in_array_literal() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.ArrayInitExpr{
                    exprs: [
                        ast.Expr(ast.Type(ast.ChannelType{
                            elem_type: ast.Expr(ast.Ident{
                                name: 'int'
                            })
                        })),
                    ]
                }
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.any(it.name == 'sync')
}

fn test_active_file_imports_adds_sync_for_channel_in_match_condition() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.MatchExpr{
                    expr:     ast.Expr(ast.Ident{
                        name: 'value'
                    })
                    branches: [
                        ast.MatchBranch{
                            cond: [
                                ast.Expr(ast.Type(ast.ChannelType{
                                    elem_type: ast.Expr(ast.Ident{
                                        name: 'int'
                                    })
                                })),
                            ]
                        },
                    ]
                }
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.any(it.name == 'sync')
}

fn test_active_file_imports_adds_sync_for_nested_channel_in_infix_expr() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.IfExpr{
                    cond: ast.InfixExpr{
                        op:  .and
                        lhs: ast.Expr(ast.Ident{
                            name: 'ok'
                        })
                        rhs: ast.Expr(ast.CallExpr{
                            lhs:  ast.Expr(ast.Ident{
                                name: 'takes_chan'
                            })
                            args: [
                                ast.Expr(ast.Type(ast.ChannelType{
                                    elem_type: ast.Expr(ast.Ident{
                                        name: 'int'
                                    })
                                })),
                            ]
                        })
                    }
                }
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.any(it.name == 'sync')
}

fn test_active_file_imports_adds_sync_for_channel_in_call_callee_generic_args() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.CallExpr{
                    lhs: ast.Expr(ast.GenericArgs{
                        lhs:  ast.Expr(ast.Ident{
                            name: 'make_value'
                        })
                        args: [
                            ast.Expr(ast.Type(ast.ChannelType{
                                elem_type: ast.Expr(ast.Ident{
                                    name: 'int'
                                })
                            })),
                        ]
                    })
                }
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.any(it.name == 'sync')
}

fn test_active_file_imports_adds_sync_for_channel_in_modifier_expr_operand() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.CallExpr{
                    lhs:  ast.Expr(ast.Ident{
                        name: 'use'
                    })
                    args: [
                        ast.Expr(ast.ModifierExpr{
                            kind: .key_mut
                            expr: ast.IndexExpr{
                                lhs:  ast.Expr(ast.Ident{
                                    name: 'arr'
                                })
                                expr: ast.Expr(ast.CallExpr{
                                    lhs:  ast.Expr(ast.Ident{
                                        name: 'idx'
                                    })
                                    args: [
                                        ast.Expr(ast.Type(ast.ChannelType{
                                            elem_type: ast.Expr(ast.Ident{
                                                name: 'int'
                                            })
                                        })),
                                    ]
                                })
                            }
                        }),
                    ]
                }
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.any(it.name == 'sync')
}

fn test_active_file_imports_adds_sync_for_channel_in_assign_lhs() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.AssignStmt{
                lhs: [
                    ast.Expr(ast.IndexExpr{
                        lhs:  ast.Expr(ast.Ident{
                            name: 'arr'
                        })
                        expr: ast.Expr(ast.CallExpr{
                            lhs:  ast.Expr(ast.Ident{
                                name: 'idx'
                            })
                            args: [
                                ast.Expr(ast.Type(ast.ChannelType{
                                    elem_type: ast.Expr(ast.Ident{
                                        name: 'int'
                                    })
                                })),
                            ]
                        })
                    }),
                ]
                rhs: [
                    ast.Expr(ast.BasicLiteral{
                        kind:  .number
                        value: '0'
                    }),
                ]
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.any(it.name == 'sync')
}

fn test_active_file_imports_adds_sync_for_channel_in_labelled_loop() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.LabelStmt{
                name: 'outer'
                stmt: ast.Stmt(ast.ForStmt{
                    stmts: [
                        ast.Stmt(ast.AssignStmt{
                            lhs: [
                                ast.Expr(ast.Ident{
                                    name: '_'
                                }),
                            ]
                            rhs: [
                                ast.Expr(ast.Type(ast.ChannelType{
                                    elem_type: ast.Expr(ast.Ident{
                                        name: 'int'
                                    })
                                })),
                            ]
                        }),
                    ]
                })
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert imports.any(it.name == 'sync')
}

fn test_active_file_imports_ignores_channel_in_inactive_attributed_fn_body() {
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.FnDecl{
                name:       'debug'
                typ:        ast.FnType{}
                attributes: [
                    ast.Attribute{
                        name:          'if'
                        comptime_cond: ast.Expr(ast.Ident{
                            name: 'windows'
                        })
                    },
                ]
                stmts:      [
                    ast.Stmt(ast.AssignStmt{
                        lhs: [
                            ast.Expr(ast.Ident{
                                name: '_'
                            }),
                        ]
                        rhs: [
                            ast.Expr(ast.Type(ast.ChannelType{
                                elem_type: ast.Expr(ast.Ident{
                                    name: 'int'
                                })
                            })),
                        ]
                    }),
                ]
            }),
        ]
    }
    imports := active_file_imports(file, [], 'mac')

    assert !imports.any(it.name == 'sync')
}

fn test_active_file_imports_skip_pkgconfig_branch_when_disabled() {
    if !pref.comptime_pkgconfig_value('sqlite3') {
        return
    }
    file := ast.File{
        mod:   'main'
        name:  'main.v'
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.ComptimeExpr{
                    expr: ast.IfExpr{
                        cond:  ast.CallExpr{
                            lhs:  ast.Expr(ast.Ident{
                                name: 'pkgconfig'
                            })
                            args: [
                                ast.Expr(ast.StringLiteral{
                                    kind:  .v
                                    value: "'sqlite3'"
                                }),
                            ]
                        }
                        stmts: [
                            ast.Stmt(ast.ImportStmt{
                                name: 'db.sqlite'
                            }),
                        ]
                    }
                }
            }),
        ]
    }
    native_imports := active_file_imports_with_options(file, [], [], 'mac', true).map(it.name)
    cross_imports := active_file_imports_with_options(file, [], [], 'mac', false).map(it.name)

    assert 'db.sqlite' in native_imports
    assert 'db.sqlite' !in cross_imports
}