// Copyright (c) 2020-2024 Joe Conigliaro. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module builder

import v2.ast
import v2.pref
import v2.token

fn (b &Builder) validate_freestanding_cleanc_contract() bool {
    if b.pref == unsafe { nil } || !b.pref.is_freestanding() {
        return true
    }
    mut diagnostics := []string{}
    mut seen := map[string]bool{}
    target_os := b.pref.target_os_or_host()
    if b.pref.prealloc {
        msg := 'error: freestanding target cannot use -prealloc because it requires hosted allocation support'
        diagnostics << msg
        seen[msg] = true
    }
    if b.pref.is_shared_lib {
        msg := 'error: freestanding target cannot use -shared because dynamic library output requires hosted loader support'
        if !seen[msg] {
            diagnostics << msg
            seen[msg] = true
        }
    }
    if b.pref.hot_fn.len > 0 {
        msg := 'error: freestanding target cannot use -hot-fn because live code reload needs hosted OS services'
        if !seen[msg] {
            diagnostics << msg
            seen[msg] = true
        }
    }
    if b.pref.has_freestanding_hooks() && (!b.pref.skip_builtin || !b.pref.skip_type_check) {
        msg := 'error: freestanding target platform hooks currently require --skip-builtin and --skip-type-check until cleanc builtin hook signatures are implemented'
        if !seen[msg] {
            diagnostics << msg
            seen[msg] = true
        }
    }
    scan_ctx := freestanding_scan_context(b.pref, target_os)
    allow_pkgconfig_imports := !b.pref.is_cross_target()
    for i, ff in b.flat.files {
        if !b.should_scan_freestanding_diagnostic_file(b.flat.file_name(ff)) {
            continue
        }
        for imported in active_file_imports_from_flat_with_options(&b.flat, ff,
            b.pref.user_defines, b.pref.explicit_user_defines, target_os, allow_pkgconfig_imports) {
            if msg := freestanding_restricted_import_diagnostic(imported.name) {
                if !seen[msg] {
                    diagnostics << msg
                    seen[msg] = true
                }
            }
        }
        call_name := freestanding_restricted_call_in_cursor_stmts(b.flat.file_cursor(i).stmts(),
            scan_ctx)
        if call_name != '' {
            msg := freestanding_restricted_call_diagnostic(call_name)
            if !seen[msg] {
                diagnostics << msg
                seen[msg] = true
            }
        }
    }
    for msg in diagnostics {
        eprintln(msg)
    }
    if diagnostics.len > 0 {
        eprintln('hint: provide platform bindings or build without -freestanding')
        return false
    }
    return true
}

fn (b &Builder) should_scan_freestanding_diagnostic_file(file_name string) bool {
    if file_name == '' || b.pref == unsafe { nil } || b.pref.vroot == '' {
        return true
    }
    path := file_name.replace('\\', '/')
    vroot := b.pref.vroot.replace('\\', '/').trim_right('/')
    return !path.starts_with('${vroot}/vlib/')
}

fn freestanding_restricted_import_diagnostic(import_name string) ?string {
    root := import_name.all_before('.')
    return match root {
        'os' {
            'error: freestanding target cannot use module os without a platform implementation'
        }
        'time' {
            'error: freestanding target cannot use module time without a platform time source'
        }
        'term' {
            'error: freestanding target cannot use module term without terminal support'
        }
        'net' {
            'error: freestanding target cannot use module net without platform networking support'
        }
        'sync' {
            'error: freestanding target cannot use module sync without threading/locking support'
        }
        else {
            none
        }
    }
}

fn freestanding_restricted_call_diagnostic(call_name string) string {
    return match call_name {
        'panic' {
            'error: freestanding target cannot use builtin panic without panic platform hook'
        }
        'spawn' {
            'error: freestanding target cannot use spawn because threading support is not provided'
        }
        'go' {
            'error: freestanding target cannot use go because threading support is not provided'
        }
        'lock' {
            'error: freestanding target cannot use lock/rlock because locking support is not provided'
        }
        'shared' {
            'error: freestanding target cannot use shared data because locking support is not provided'
        }
        'live' {
            'error: freestanding target cannot use @[live] because live reload needs hosted OS services'
        }
        'assert' {
            'error: freestanding target cannot use assert because failed assertions need hosted output/exit support'
        }
        else {
            'error: freestanding target cannot use builtin ${call_name} without output platform hook'
        }
    }
}

struct FreestandingScanContext {
    user_defines       []string
    explicit_defines   []string
    target_os          string
    freestanding_hooks []string
}

fn freestanding_scan_context(p &pref.Preferences, target_os string) FreestandingScanContext {
    return FreestandingScanContext{
        user_defines:       p.user_defines
        explicit_defines:   p.explicit_user_defines
        target_os:          target_os
        freestanding_hooks: p.freestanding_hook_list()
    }
}

fn (ctx FreestandingScanContext) has_hook(hook string) bool {
    return hook in ctx.freestanding_hooks
}

fn freestanding_output_builtin_call_name(name string, ctx FreestandingScanContext) string {
    if name in ['print', 'println', 'eprint', 'eprintln'] && !ctx.has_hook('output') {
        return name
    }
    if name == 'panic' && !ctx.has_hook('panic') {
        return name
    }
    return ''
}

fn freestanding_attributes_are_inactive(attributes []ast.Attribute, ctx FreestandingScanContext) bool {
    for attr in attributes {
        if attr.comptime_cond !is ast.EmptyExpr
            && !ast_comptime_cond_matches_with_explicit(attr.comptime_cond, ctx.user_defines, ctx.explicit_defines, ctx.target_os) {
            return true
        }
    }
    return false
}

fn freestanding_channel_scan_options(ctx FreestandingScanContext) ChannelScanOptions {
    return ChannelScanOptions{
        user_defines:          ctx.user_defines
        explicit_user_defines: ctx.explicit_defines
        target_os:             ctx.target_os
        allow_pkgconfig:       true
        filter_comptime:       true
    }
}

fn freestanding_cursor_attributes_are_inactive(attributes ast.CursorList, ctx FreestandingScanContext) bool {
    options := freestanding_channel_scan_options(ctx)
    for i in 0 .. attributes.len() {
        attr := attributes.at(i)
        if !attr.is_valid() || attr.kind() != .aux_attribute {
            continue
        }
        cond := attr.edge(1)
        if cond.is_valid() && cond.kind() != .expr_empty
            && !flat_comptime_cond_matches(cond, options) {
            return true
        }
    }
    return false
}

fn freestanding_cursor_attributes_has(attributes ast.CursorList, name string) bool {
    for i in 0 .. attributes.len() {
        attr := attributes.at(i)
        if !attr.is_valid() || attr.kind() != .aux_attribute {
            continue
        }
        if attr.name() == name {
            return true
        }
        value := attr.edge(0)
        if attr.name() == '' && value.is_valid() && value.kind() == .expr_ident
            && value.name() == name {
            return true
        }
    }
    return false
}

fn freestanding_restricted_call_in_stmts(stmts []ast.Stmt, ctx FreestandingScanContext) string {
    for stmt in stmts {
        call_name := freestanding_restricted_call_in_stmt(stmt, ctx)
        if call_name != '' {
            return call_name
        }
    }
    return ''
}

fn freestanding_restricted_call_in_cursor_stmts(stmts ast.CursorList, ctx FreestandingScanContext) string {
    for i in 0 .. stmts.len() {
        call_name := freestanding_restricted_call_in_cursor_stmt(stmts.at(i), ctx)
        if call_name != '' {
            return call_name
        }
    }
    return ''
}

fn freestanding_restricted_call_in_cursor_stmt(stmt ast.Cursor, ctx FreestandingScanContext) string {
    if !stmt.is_valid() {
        return ''
    }
    return match stmt.kind() {
        .stmt_assert {
            expr_call :=
                freestanding_restricted_call_in_cursor_edges(stmt, 0, stmt.edge_count(), ctx)
            if expr_call != '' {
                expr_call
            } else {
                'assert'
            }
        }
        .stmt_assign {
            freestanding_restricted_call_in_cursor_edges(stmt, 0, stmt.edge_count(), ctx)
        }
        .stmt_block, .stmt_defer {
            freestanding_restricted_call_in_cursor_stmt_edges(stmt, 0, stmt.edge_count(), ctx)
        }
        .stmt_comptime {
            freestanding_restricted_call_in_cursor_stmt(stmt.edge(0), ctx)
        }
        .stmt_const_decl {
            freestanding_restricted_call_in_cursor_field_inits(stmt.list_at(0), ctx)
        }
        .stmt_expr {
            freestanding_restricted_call_in_cursor_expr(stmt.edge(0), ctx)
        }
        .stmt_fn_decl {
            attributes := stmt.list_at(2)
            if freestanding_cursor_attributes_are_inactive(attributes, ctx) {
                ''
            } else if freestanding_cursor_attributes_has(attributes, 'live') {
                'live'
            } else {
                freestanding_restricted_call_in_cursor_stmts(stmt.list_at(3), ctx)
            }
        }
        .stmt_for_in {
            freestanding_restricted_call_in_cursor_edges(stmt, 0, stmt.edge_count(), ctx)
        }
        .stmt_for {
            init_call := freestanding_restricted_call_in_cursor_stmt(stmt.edge(0), ctx)
            if init_call != '' {
                init_call
            } else {
                cond_call := freestanding_restricted_call_in_cursor_expr(stmt.edge(1), ctx)
                if cond_call != '' {
                    cond_call
                } else {
                    post_call := freestanding_restricted_call_in_cursor_stmt(stmt.edge(2), ctx)
                    if post_call != '' {
                        post_call
                    } else {
                        freestanding_restricted_call_in_cursor_stmts(stmt.for_body_list(), ctx)
                    }
                }
            }
        }
        .stmt_global_decl {
            freestanding_restricted_call_in_cursor_field_decls(stmt.list_at(1), ctx)
        }
        .stmt_interface_decl {
            freestanding_restricted_call_in_cursor_field_decls(stmt.list_at(3), ctx)
        }
        .stmt_label {
            freestanding_restricted_call_in_cursor_stmt(stmt.edge(0), ctx)
        }
        .stmt_return {
            freestanding_restricted_call_in_cursor_edges(stmt, 0, stmt.edge_count(), ctx)
        }
        .stmt_struct_decl {
            freestanding_restricted_call_in_cursor_field_decls(stmt.list_at(4), ctx)
        }
        else {
            ''
        }
    }
}

fn freestanding_restricted_call_in_cursor_stmt_edges(stmt ast.Cursor, start int, end int, ctx FreestandingScanContext) string {
    for i in start .. end {
        call_name := freestanding_restricted_call_in_cursor_stmt(stmt.edge(i), ctx)
        if call_name != '' {
            return call_name
        }
    }
    return ''
}

fn freestanding_restricted_call_in_cursor_edges(expr_parent ast.Cursor, start int, end int, ctx FreestandingScanContext) string {
    for i in start .. end {
        call_name := freestanding_restricted_call_in_cursor_expr(expr_parent.edge(i), ctx)
        if call_name != '' {
            return call_name
        }
    }
    return ''
}

fn freestanding_restricted_call_in_cursor_expr_list(exprs ast.CursorList, ctx FreestandingScanContext) string {
    for i in 0 .. exprs.len() {
        call_name := freestanding_restricted_call_in_cursor_expr(exprs.at(i), ctx)
        if call_name != '' {
            return call_name
        }
    }
    return ''
}

fn freestanding_restricted_call_in_stmt(stmt ast.Stmt, ctx FreestandingScanContext) string {
    return match stmt {
        ast.AssertStmt {
            expr_call := freestanding_restricted_call_in_exprs([stmt.expr, stmt.extra], ctx)
            if expr_call != '' {
                expr_call
            } else {
                'assert'
            }
        }
        ast.AssignStmt {
            lhs_call := freestanding_restricted_call_in_exprs(stmt.lhs, ctx)
            if lhs_call != '' {
                lhs_call
            } else {
                freestanding_restricted_call_in_exprs(stmt.rhs, ctx)
            }
        }
        ast.BlockStmt {
            freestanding_restricted_call_in_stmts(stmt.stmts, ctx)
        }
        ast.ComptimeStmt {
            freestanding_restricted_call_in_stmt(stmt.stmt, ctx)
        }
        ast.ConstDecl {
            freestanding_restricted_call_in_field_inits(stmt.fields, ctx)
        }
        ast.DeferStmt {
            freestanding_restricted_call_in_stmts(stmt.stmts, ctx)
        }
        ast.ExprStmt {
            freestanding_restricted_call_in_expr(stmt.expr, ctx)
        }
        ast.FnDecl {
            if freestanding_attributes_are_inactive(stmt.attributes, ctx) {
                ''
            } else if stmt.attributes.has('live') {
                'live'
            } else {
                freestanding_restricted_call_in_stmts(stmt.stmts, ctx)
            }
        }
        ast.ForInStmt {
            freestanding_restricted_call_in_exprs([stmt.key, stmt.value, stmt.expr], ctx)
        }
        ast.ForStmt {
            init_call := freestanding_restricted_call_in_stmt(stmt.init, ctx)
            if init_call != '' {
                init_call
            } else {
                cond_call := freestanding_restricted_call_in_expr(stmt.cond, ctx)
                if cond_call != '' {
                    cond_call
                } else {
                    post_call := freestanding_restricted_call_in_stmt(stmt.post, ctx)
                    if post_call != '' {
                        post_call
                    } else {
                        freestanding_restricted_call_in_stmts(stmt.stmts, ctx)
                    }
                }
            }
        }
        ast.GlobalDecl {
            freestanding_restricted_call_in_field_decls(stmt.fields, ctx)
        }
        ast.InterfaceDecl {
            freestanding_restricted_call_in_field_decls(stmt.fields, ctx)
        }
        ast.LabelStmt {
            freestanding_restricted_call_in_stmt(stmt.stmt, ctx)
        }
        ast.ReturnStmt {
            freestanding_restricted_call_in_exprs(stmt.exprs, ctx)
        }
        ast.StructDecl {
            freestanding_restricted_call_in_field_decls(stmt.fields, ctx)
        }
        else {
            ''
        }
    }
}

fn freestanding_restricted_call_in_exprs(exprs []ast.Expr, ctx FreestandingScanContext) string {
    for expr in exprs {
        call_name := freestanding_restricted_call_in_expr(expr, ctx)
        if call_name != '' {
            return call_name
        }
    }
    return ''
}

fn freestanding_restricted_call_in_cursor_field_inits(fields ast.CursorList, ctx FreestandingScanContext) string {
    for i in 0 .. fields.len() {
        call_name := freestanding_restricted_call_in_cursor_expr(fields.at(i).edge(0), ctx)
        if call_name != '' {
            return call_name
        }
    }
    return ''
}

fn freestanding_restricted_call_in_field_inits(fields []ast.FieldInit, ctx FreestandingScanContext) string {
    for field in fields {
        call_name := freestanding_restricted_call_in_expr(field.value, ctx)
        if call_name != '' {
            return call_name
        }
    }
    return ''
}

fn freestanding_restricted_call_in_cursor_field_decls(fields ast.CursorList, ctx FreestandingScanContext) string {
    for i in 0 .. fields.len() {
        field := fields.at(i)
        typ_call := freestanding_restricted_call_in_cursor_expr(field.edge(0), ctx)
        if typ_call != '' {
            return typ_call
        }
        value_call := freestanding_restricted_call_in_cursor_expr(field.edge(1), ctx)
        if value_call != '' {
            return value_call
        }
    }
    return ''
}

fn freestanding_restricted_call_in_field_decls(fields []ast.FieldDecl, ctx FreestandingScanContext) string {
    for field in fields {
        typ_call := freestanding_restricted_call_in_expr(field.typ, ctx)
        if typ_call != '' {
            return typ_call
        }
        value_call := freestanding_restricted_call_in_expr(field.value, ctx)
        if value_call != '' {
            return value_call
        }
    }
    return ''
}

fn freestanding_restricted_call_in_cursor_expr(expr ast.Cursor, ctx FreestandingScanContext) string {
    if !expr.is_valid() {
        return ''
    }
    return match expr.kind() {
        .expr_array_init {
            meta_call := freestanding_restricted_call_in_cursor_edges(expr, 0, 5, ctx)
            if meta_call != '' {
                meta_call
            } else {
                freestanding_restricted_call_in_cursor_edges(expr, 5, expr.edge_count(), ctx)
            }
        }
        .expr_as_cast {
            freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
        }
        .expr_cast {
            freestanding_restricted_call_in_cursor_expr(expr.edge(1), ctx)
        }
        .expr_assoc {
            base_call := freestanding_restricted_call_in_cursor_expr(expr.edge(1), ctx)
            if base_call != '' {
                base_call
            } else {
                freestanding_restricted_call_in_cursor_field_inits(ast.CursorList{
                    flat:      expr.flat
                    parent_id: expr.id
                    offset:    2
                }, ctx)
            }
        }
        .expr_call {
            call_name := freestanding_restricted_builtin_call_name_cursor(expr.edge(0), ctx)
            if call_name != '' {
                call_name
            } else {
                lhs_call := freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
                if lhs_call != '' {
                    lhs_call
                } else {
                    freestanding_restricted_call_in_cursor_edges(expr, 1, expr.edge_count(), ctx)
                }
            }
        }
        .expr_call_or_cast {
            call_name := freestanding_restricted_builtin_call_name_cursor(expr.edge(0), ctx)
            if call_name != '' {
                call_name
            } else {
                lhs_call := freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
                if lhs_call != '' {
                    lhs_call
                } else {
                    freestanding_restricted_call_in_cursor_expr(expr.edge(1), ctx)
                }
            }
        }
        .expr_comptime {
            freestanding_restricted_call_in_cursor_comptime_expr(expr, ctx)
        }
        .expr_fn_literal {
            captured_len := expr.extra_int()
            capture_call :=
                freestanding_restricted_call_in_cursor_edges(expr, 1, 1 + captured_len, ctx)
            if capture_call != '' {
                capture_call
            } else {
                freestanding_restricted_call_in_cursor_stmt_edges(expr, 1 + captured_len,
                    expr.edge_count(), ctx)
            }
        }
        .expr_generic_arg_or_index, .expr_index, .expr_infix {
            lhs_call := freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
            if lhs_call != '' {
                lhs_call
            } else {
                freestanding_restricted_call_in_cursor_expr(expr.edge(1), ctx)
            }
        }
        .expr_generic_args {
            lhs_call := freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
            if lhs_call != '' {
                lhs_call
            } else {
                freestanding_restricted_call_in_cursor_edges(expr, 1, expr.edge_count(), ctx)
            }
        }
        .expr_if {
            cond_call := freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
            if cond_call != '' {
                cond_call
            } else {
                stmts_call := freestanding_restricted_call_in_cursor_stmt_edges(expr, 2,
                    expr.edge_count(), ctx)
                if stmts_call != '' {
                    stmts_call
                } else {
                    freestanding_restricted_call_in_cursor_expr(expr.edge(1), ctx)
                }
            }
        }
        .expr_if_guard {
            freestanding_restricted_call_in_cursor_stmt(expr.edge(0), ctx)
        }
        .expr_init {
            typ_call := freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
            if typ_call != '' {
                typ_call
            } else {
                freestanding_restricted_call_in_cursor_field_inits(ast.CursorList{
                    flat:      expr.flat
                    parent_id: expr.id
                    offset:    1
                }, ctx)
            }
        }
        .expr_keyword_operator {
            op := unsafe { token.Token(int(expr.aux())) }
            if op in [.key_go, .key_spawn] {
                op.str()
            } else {
                freestanding_restricted_call_in_cursor_edges(expr, 0, expr.edge_count(), ctx)
            }
        }
        .expr_lambda, .expr_paren, .expr_postfix, .expr_prefix, .expr_selector {
            freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
        }
        .expr_lock {
            'lock'
        }
        .expr_map_init {
            keys_len := expr.extra_int()
            key_call := freestanding_restricted_call_in_cursor_edges(expr, 1, 1 + keys_len, ctx)
            if key_call != '' {
                key_call
            } else {
                freestanding_restricted_call_in_cursor_edges(expr, 1 + keys_len, expr.edge_count(),
                    ctx)
            }
        }
        .expr_match {
            expr_call := freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
            if expr_call != '' {
                expr_call
            } else {
                freestanding_restricted_call_in_cursor_match_branch_edges(expr, 1,
                    expr.edge_count(), ctx)
            }
        }
        .expr_modifier {
            kind := unsafe { token.Token(int(expr.aux())) }
            if kind == .key_shared {
                'shared'
            } else {
                freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
            }
        }
        .expr_or {
            expr_call := freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
            if expr_call != '' {
                expr_call
            } else {
                freestanding_restricted_call_in_cursor_stmt_edges(expr, 1, expr.edge_count(), ctx)
            }
        }
        .expr_range {
            start_call := freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
            if start_call != '' {
                start_call
            } else {
                freestanding_restricted_call_in_cursor_expr(expr.edge(1), ctx)
            }
        }
        .expr_select {
            stmt_call := freestanding_restricted_call_in_cursor_stmt(expr.edge(0), ctx)
            if stmt_call != '' {
                stmt_call
            } else {
                freestanding_restricted_call_in_cursor_stmt_edges(expr, 2, expr.edge_count(), ctx)
            }
        }
        .expr_string_inter {
            freestanding_restricted_call_in_cursor_string_inters(expr.list_at(1), ctx)
        }
        .expr_tuple {
            freestanding_restricted_call_in_cursor_edges(expr, 0, expr.edge_count(), ctx)
        }
        .expr_unsafe {
            freestanding_restricted_call_in_cursor_stmt_edges(expr, 0, expr.edge_count(), ctx)
        }
        .aux_field_init {
            freestanding_restricted_call_in_cursor_expr(expr.edge(0), ctx)
        }
        else {
            ''
        }
    }
}

fn freestanding_restricted_call_in_cursor_comptime_expr(expr ast.Cursor, ctx FreestandingScanContext) string {
    inner := expr.edge(0)
    if inner.is_valid() && inner.kind() == .expr_if {
        return freestanding_restricted_call_in_cursor_active_comptime_if(inner, ctx)
    }
    return freestanding_restricted_call_in_cursor_expr(inner, ctx)
}

fn freestanding_restricted_call_in_cursor_active_comptime_if(node ast.Cursor, ctx FreestandingScanContext) string {
    options := freestanding_channel_scan_options(ctx)
    if flat_comptime_cond_matches(node.edge(0), options) {
        return freestanding_restricted_call_in_cursor_stmt_edges(node, 2, node.edge_count(), ctx)
    }
    else_expr := node.edge(1)
    if else_expr.is_valid() && else_expr.kind() == .expr_if {
        if else_expr.edge(0).is_valid() && else_expr.edge(0).kind() == .expr_empty {
            return freestanding_restricted_call_in_cursor_stmt_edges(else_expr, 2,
                else_expr.edge_count(), ctx)
        }
        return freestanding_restricted_call_in_cursor_active_comptime_if(else_expr, ctx)
    }
    return ''
}

fn freestanding_restricted_call_in_cursor_match_branch_edges(expr ast.Cursor, start int, end int, ctx FreestandingScanContext) string {
    for i in start .. end {
        call_name := freestanding_restricted_call_in_cursor_match_branch(expr.edge(i), ctx)
        if call_name != '' {
            return call_name
        }
    }
    return ''
}

fn freestanding_restricted_call_in_cursor_match_branch(branch ast.Cursor, ctx FreestandingScanContext) string {
    if !branch.is_valid() || branch.kind() != .aux_match_branch {
        return ''
    }
    cond_call := freestanding_restricted_call_in_cursor_expr_list(branch.list_at(0), ctx)
    if cond_call != '' {
        return cond_call
    }
    return freestanding_restricted_call_in_cursor_stmts(branch.list_at(1), ctx)
}

fn freestanding_restricted_call_in_cursor_string_inters(inters ast.CursorList, ctx FreestandingScanContext) string {
    for i in 0 .. inters.len() {
        inter := inters.at(i)
        if !inter.is_valid() || inter.kind() != .aux_string_inter {
            continue
        }
        expr_call := freestanding_restricted_call_in_cursor_expr(inter.edge(0), ctx)
        if expr_call != '' {
            return expr_call
        }
        format_call := freestanding_restricted_call_in_cursor_expr(inter.edge(1), ctx)
        if format_call != '' {
            return format_call
        }
    }
    return ''
}

fn freestanding_restricted_call_in_expr(expr ast.Expr, ctx FreestandingScanContext) string {
    return match expr {
        ast.ArrayInitExpr {
            meta_call := freestanding_restricted_call_in_exprs([expr.typ, expr.init, expr.cap,
                expr.len, expr.update_expr], ctx)
            if meta_call != '' {
                meta_call
            } else {
                freestanding_restricted_call_in_exprs(expr.exprs, ctx)
            }
        }
        ast.AsCastExpr {
            freestanding_restricted_call_in_expr(expr.expr, ctx)
        }
        ast.AssocExpr {
            base_call := freestanding_restricted_call_in_expr(expr.expr, ctx)
            if base_call != '' {
                base_call
            } else {
                freestanding_restricted_call_in_field_inits(expr.fields, ctx)
            }
        }
        ast.CallExpr {
            call_name := freestanding_restricted_builtin_call_name(expr.lhs, ctx)
            if call_name != '' {
                call_name
            } else {
                lhs_call := freestanding_restricted_call_in_expr(expr.lhs, ctx)
                if lhs_call != '' {
                    lhs_call
                } else {
                    freestanding_restricted_call_in_exprs(expr.args, ctx)
                }
            }
        }
        ast.CallOrCastExpr {
            call_name := freestanding_restricted_builtin_call_name(expr.lhs, ctx)
            if call_name != '' {
                call_name
            } else {
                lhs_call := freestanding_restricted_call_in_expr(expr.lhs, ctx)
                if lhs_call != '' {
                    lhs_call
                } else {
                    freestanding_restricted_call_in_expr(expr.expr, ctx)
                }
            }
        }
        ast.CastExpr {
            freestanding_restricted_call_in_expr(expr.expr, ctx)
        }
        ast.ComptimeExpr {
            freestanding_restricted_call_in_comptime_expr(expr, ctx)
        }
        ast.FieldInit {
            freestanding_restricted_call_in_expr(expr.value, ctx)
        }
        ast.FnLiteral {
            capture_call := freestanding_restricted_call_in_exprs(expr.captured_vars, ctx)
            if capture_call != '' {
                capture_call
            } else {
                freestanding_restricted_call_in_stmts(expr.stmts, ctx)
            }
        }
        ast.GenericArgOrIndexExpr {
            lhs_call := freestanding_restricted_call_in_expr(expr.lhs, ctx)
            if lhs_call != '' {
                lhs_call
            } else {
                freestanding_restricted_call_in_expr(expr.expr, ctx)
            }
        }
        ast.GenericArgs {
            lhs_call := freestanding_restricted_call_in_expr(expr.lhs, ctx)
            if lhs_call != '' {
                lhs_call
            } else {
                freestanding_restricted_call_in_exprs(expr.args, ctx)
            }
        }
        ast.IfExpr {
            cond_call := freestanding_restricted_call_in_expr(expr.cond, ctx)
            if cond_call != '' {
                cond_call
            } else {
                stmts_call := freestanding_restricted_call_in_stmts(expr.stmts, ctx)
                if stmts_call != '' {
                    stmts_call
                } else {
                    freestanding_restricted_call_in_expr(expr.else_expr, ctx)
                }
            }
        }
        ast.IfGuardExpr {
            freestanding_restricted_call_in_stmt(ast.Stmt(expr.stmt), ctx)
        }
        ast.IndexExpr {
            lhs_call := freestanding_restricted_call_in_expr(expr.lhs, ctx)
            if lhs_call != '' {
                lhs_call
            } else {
                freestanding_restricted_call_in_expr(expr.expr, ctx)
            }
        }
        ast.InfixExpr {
            lhs_call := freestanding_restricted_call_in_expr(expr.lhs, ctx)
            if lhs_call != '' {
                lhs_call
            } else {
                freestanding_restricted_call_in_expr(expr.rhs, ctx)
            }
        }
        ast.InitExpr {
            typ_call := freestanding_restricted_call_in_expr(expr.typ, ctx)
            if typ_call != '' {
                typ_call
            } else {
                freestanding_restricted_call_in_field_inits(expr.fields, ctx)
            }
        }
        ast.KeywordOperator {
            if expr.op in [.key_go, .key_spawn] {
                expr.op.str()
            } else {
                freestanding_restricted_call_in_exprs(expr.exprs, ctx)
            }
        }
        ast.LambdaExpr {
            freestanding_restricted_call_in_expr(expr.expr, ctx)
        }
        ast.LockExpr {
            'lock'
        }
        ast.MapInitExpr {
            key_call := freestanding_restricted_call_in_exprs(expr.keys, ctx)
            if key_call != '' {
                key_call
            } else {
                freestanding_restricted_call_in_exprs(expr.vals, ctx)
            }
        }
        ast.MatchExpr {
            expr_call := freestanding_restricted_call_in_expr(expr.expr, ctx)
            if expr_call != '' {
                expr_call
            } else {
                freestanding_restricted_call_in_match_branches(expr.branches, ctx)
            }
        }
        ast.ModifierExpr {
            if expr.kind == .key_shared {
                'shared'
            } else {
                freestanding_restricted_call_in_expr(expr.expr, ctx)
            }
        }
        ast.OrExpr {
            expr_call := freestanding_restricted_call_in_expr(expr.expr, ctx)
            if expr_call != '' {
                expr_call
            } else {
                freestanding_restricted_call_in_stmts(expr.stmts, ctx)
            }
        }
        ast.ParenExpr {
            freestanding_restricted_call_in_expr(expr.expr, ctx)
        }
        ast.PostfixExpr {
            freestanding_restricted_call_in_expr(expr.expr, ctx)
        }
        ast.PrefixExpr {
            freestanding_restricted_call_in_expr(expr.expr, ctx)
        }
        ast.RangeExpr {
            start_call := freestanding_restricted_call_in_expr(expr.start, ctx)
            if start_call != '' {
                start_call
            } else {
                freestanding_restricted_call_in_expr(expr.end, ctx)
            }
        }
        ast.SelectExpr {
            stmt_call := freestanding_restricted_call_in_stmt(expr.stmt, ctx)
            if stmt_call != '' {
                stmt_call
            } else {
                freestanding_restricted_call_in_stmts(expr.stmts, ctx)
            }
        }
        ast.SelectorExpr {
            freestanding_restricted_call_in_expr(expr.lhs, ctx)
        }
        ast.StringInterLiteral {
            freestanding_restricted_call_in_string_inters(expr.inters, ctx)
        }
        ast.Tuple {
            freestanding_restricted_call_in_exprs(expr.exprs, ctx)
        }
        ast.UnsafeExpr {
            freestanding_restricted_call_in_stmts(expr.stmts, ctx)
        }
        else {
            ''
        }
    }
}

fn freestanding_restricted_call_in_comptime_expr(expr ast.ComptimeExpr, ctx FreestandingScanContext) string {
    if expr.expr is ast.IfExpr {
        return freestanding_restricted_call_in_active_comptime_if(expr.expr, ctx)
    }
    return freestanding_restricted_call_in_expr(expr.expr, ctx)
}

fn freestanding_restricted_call_in_active_comptime_if(node ast.IfExpr, ctx FreestandingScanContext) string {
    if ast_comptime_cond_matches_with_explicit(node.cond, ctx.user_defines, ctx.explicit_defines,
        ctx.target_os)
    {
        return freestanding_restricted_call_in_stmts(node.stmts, ctx)
    }
    if node.else_expr is ast.IfExpr {
        if node.else_expr.cond is ast.EmptyExpr {
            return freestanding_restricted_call_in_stmts(node.else_expr.stmts, ctx)
        }
        return freestanding_restricted_call_in_active_comptime_if(node.else_expr, ctx)
    }
    return ''
}

fn freestanding_restricted_call_in_match_branches(branches []ast.MatchBranch, ctx FreestandingScanContext) string {
    for branch in branches {
        cond_call := freestanding_restricted_call_in_exprs(branch.cond, ctx)
        if cond_call != '' {
            return cond_call
        }
        stmts_call := freestanding_restricted_call_in_stmts(branch.stmts, ctx)
        if stmts_call != '' {
            return stmts_call
        }
    }
    return ''
}

fn freestanding_restricted_call_in_string_inters(inters []ast.StringInter, ctx FreestandingScanContext) string {
    for inter in inters {
        expr_call := freestanding_restricted_call_in_expr(inter.expr, ctx)
        if expr_call != '' {
            return expr_call
        }
        format_call := freestanding_restricted_call_in_expr(inter.format_expr, ctx)
        if format_call != '' {
            return format_call
        }
    }
    return ''
}

fn freestanding_restricted_builtin_call_name(lhs ast.Expr, ctx FreestandingScanContext) string {
    if lhs is ast.Ident {
        return freestanding_output_builtin_call_name(lhs.name, ctx)
    }
    return ''
}

fn freestanding_restricted_builtin_call_name_cursor(lhs ast.Cursor, ctx FreestandingScanContext) string {
    if lhs.is_valid() && lhs.kind() == .expr_ident {
        return freestanding_output_builtin_call_name(lhs.name(), ctx)
    }
    return ''
}