// Copyright (c) 2019-2024 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 parser

import os
import v.ast
import v.token
import v.errors
import v.util
import v.vmod

const supported_comptime_calls = ['html', 'tmpl', 'env', 'embed_file', 'pkgconfig', 'compile_error',
    'compile_warn', 'd', 'res', 'zero', 'new']
const supported_comptime_for_kinds = ['methods', 'fields', 'values', 'variants', 'attributes',
    'params']
const comptime_types = ['map', 'array', 'array_dynamic', 'array_fixed', 'int', 'float', 'struct',
    'interface', 'enum', 'sumtype', 'alias', 'function', 'option', 'shared', 'string', 'pointer',
    'voidptr']

fn find_veb_template_relative_to_vmod(compiled_vfile_path string, relative_path string) ?string {
    mut mcache := vmod.get_cache()
    vmod_file_location := mcache.get_by_file(compiled_vfile_path)
    if vmod_file_location.vmod_file == '' {
        return none
    }
    vmod_template_path := os.join_path(vmod_file_location.vmod_folder, relative_path)
    if !os.exists(vmod_template_path) {
        return none
    }
    return os.real_path(vmod_template_path)
}

fn find_existing_veb_template_in_vmod(compiled_vfile_path string, relative_paths []string) ?string {
    for relative_path in relative_paths {
        if path := find_veb_template_relative_to_vmod(compiled_vfile_path, relative_path) {
            return path
        }
    }
    return none
}

@[inline]
fn is_supported_comptime_for_kind(name string) bool {
    return name in supported_comptime_for_kinds
}

fn (mut p Parser) parse_comptime_type() ast.ComptimeType {
    pos := p.tok.pos()
    p.check(.dollar)
    name := p.check_name()
    if name !in comptime_types {
        p.error('unsupported compile-time type `${name}`: only ${comptime_types} are supported')
    }
    mut kind := ast.ComptimeTypeKind.unknown
    kind = match name {
        'map' {
            .map
        }
        'struct' {
            .struct
        }
        'interface' {
            .iface
        }
        'int' {
            .int
        }
        'float' {
            .float
        }
        'alias' {
            .alias
        }
        'function' {
            .function
        }
        'array' {
            .array
        }
        'array_fixed' {
            .array_fixed
        }
        'array_dynamic' {
            .array_dynamic
        }
        'enum' {
            .enum
        }
        'sumtype' {
            .sum_type
        }
        'option' {
            .option
        }
        'shared' {
            .shared
        }
        'string' {
            .string
        }
        'pointer' {
            .pointer
        }
        'voidptr' {
            .voidptr
        }
        else {
            .unknown
        }
    }

    return ast.ComptimeType{
        kind: kind
        pos:  pos
    }
}

// // #include, #flag, #v
fn (mut p Parser) hash() ast.HashStmt {
    pos := p.tok.pos()
    val := p.tok.lit
    kind := val.all_before(' ')
    attrs := p.attrs
    p.next()
    mut main_str := ''
    mut msg := ''
    mut ct_low_level_cond := ''
    content := val.all_after('${kind} ').all_before('//')
    if content.contains(' #') {
        main_str = content.all_before(' #').trim_space()
        msg = content.all_after(' #').trim_space()
    } else {
        main_str = content.trim_space()
        msg = ''
    }

    // Detect OS-specific conditions like `#include linux <pty.h>` or `#include darwin "util.h"`.
    // The condition is the first word before the actual include path.
    if kind in ['include', 'preinclude', 'postinclude', 'insert'] {
        first_space := main_str.index_u8(` `)
        if first_space > 0 {
            maybe_cond := main_str[..first_space]
            if maybe_cond in ast.valid_comptime_not_user_defined {
                ct_low_level_cond = maybe_cond
                main_str = main_str[first_space + 1..].trim_space()
            }
        }
    }

    mut is_use_once := false
    for fna in attrs {
        match fna.name {
            'use_once' { is_use_once = true }
            else {}
        }
    }

    return ast.HashStmt{
        mod:               p.mod
        source_file:       p.file_path
        val:               val
        kind:              kind
        main:              main_str
        msg:               msg
        pos:               pos
        attrs:             attrs
        is_use_once:       is_use_once
        ct_low_level_cond: ct_low_level_cond
    }
}

const error_msg = 'only `\$tmpl()`, `\$env()`, `\$embed_file()`, `\$pkgconfig()`, `\$veb.html()`, `\$compile_error()`, `\$compile_warn()`, `\$d()`, `\$res()`, `\$zero()` and `\$new()` comptime functions are supported right now'

fn (p &Parser) resolve_tmpl_path_expr(expr ast.Expr) ?string {
    return p.resolve_tmpl_path_expr_with_depth(expr, 0)
}

fn (p &Parser) resolve_tmpl_path_expr_with_depth(expr ast.Expr, depth int) ?string {
    if depth > 50 {
        return none
    }
    match expr {
        ast.AtExpr {
            return expr.name
        }
        ast.CallExpr {
            match expr.name {
                'os.join_path' {
                    if expr.args.len == 0 {
                        return ''
                    }
                    mut path := p.resolve_tmpl_path_expr_with_depth(expr.args[0].expr, depth + 1)?
                    for arg in expr.args[1..] {
                        path = os.join_path_single(path, p.resolve_tmpl_path_expr_with_depth(arg.expr,

                            depth + 1)?)
                    }
                    return path
                }
                'os.join_path_single' {
                    if expr.args.len != 2 {
                        return none
                    }
                    return os.join_path_single(p.resolve_tmpl_path_expr_with_depth(expr.args[0].expr,

                        depth + 1)?, p.resolve_tmpl_path_expr_with_depth(expr.args[1].expr, depth +
                        1)?)
                }
                else {
                    return none
                }
            }
        }
        ast.Ident {
            if var := p.scope.find_var(expr.name) {
                return p.resolve_tmpl_path_expr_with_depth(var.expr, depth + 1)
            }
            if expr.name == 'os.path_separator' {
                return os.path_separator
            }
            if imported_name := p.imported_symbols[expr.name] {
                if const_field := p.table.global_scope.find_const(imported_name) {
                    return p.resolve_tmpl_path_expr_with_depth(const_field.expr, depth + 1)
                }
            }
            if const_field := p.table.global_scope.find_const(expr.name) {
                return p.resolve_tmpl_path_expr_with_depth(const_field.expr, depth + 1)
            }
            if const_field := p.table.global_scope.find_const('${expr.mod}.${expr.name}') {
                return p.resolve_tmpl_path_expr_with_depth(const_field.expr, depth + 1)
            }
            if const_field := p.table.global_scope.find_const('${p.mod}.${expr.name}') {
                return p.resolve_tmpl_path_expr_with_depth(const_field.expr, depth + 1)
            }
            return none
        }
        ast.InfixExpr {
            if expr.op != .plus {
                return none
            }
            return p.resolve_tmpl_path_expr_with_depth(expr.left, depth + 1)? +
                p.resolve_tmpl_path_expr_with_depth(expr.right, depth + 1)?
        }
        ast.ParExpr {
            return p.resolve_tmpl_path_expr_with_depth(expr.expr, depth + 1)
        }
        ast.SelectorExpr {
            module_name := p.resolve_tmpl_path_module_name(expr.expr) or { return none }
            if module_name == 'os' && expr.field_name == 'path_separator' {
                return os.path_separator
            }
            if const_field := p.table.global_scope.find_const('${module_name}.${expr.field_name}') {
                return p.resolve_tmpl_path_expr_with_depth(const_field.expr, depth + 1)
            }
            return none
        }
        ast.StringLiteral {
            return expr.val
        }
        else {
            return none
        }
    }
}

fn (p &Parser) resolve_tmpl_path_module_name(expr ast.Expr) ?string {
    match expr {
        ast.Ident {
            if module_name := p.imports[expr.name] {
                return module_name
            }
            return expr.name
        }
        ast.SelectorExpr {
            return '${p.resolve_tmpl_path_module_name(expr.expr)?}.${expr.field_name}'
        }
        else {
            return none
        }
    }
}

fn (mut p Parser) resolve_tmpl_pseudo_variables(path string, pos token.Pos) ?string {
    mut resolved := path
    source_path := os.real_path(p.scanner.file_path)
    if resolved.contains('@VEXEROOT') {
        resolved = resolved.replace('@VEXEROOT', p.pref.vroot)
    }
    if resolved.contains('@VMODROOT') {
        resolved = util.resolve_vmodroot(resolved, source_path) or {
            p.error_with_pos(err.msg(), pos)
            return none
        }
    }
    if resolved.contains('@DIR') {
        resolved = resolved.replace('@DIR', os.dir(source_path))
    }
    return resolved
}

fn (p &Parser) is_comptime_type_selector_at(offset int) bool {
    if p.peek_token(offset).kind == .key_typeof {
        return true
    }
    if p.peek_token(offset).kind != .name {
        return false
    }
    mut n := offset + 1
    for p.peek_token(n).kind == .dot && p.peek_token(n + 1).kind == .name {
        if is_array_init_type_expr_field(p.peek_token(n + 1).lit) {
            return true
        }
        n += 2
    }
    return false
}

fn (p &Parser) is_comptime_type_expr_arg() bool {
    if p.tok.kind in [.key_typeof, .dollar] {
        return true
    }
    if p.tok.kind == .lsbr && p.peek_tok.kind == .rsbr {
        return p.is_comptime_type_selector_at(2)
    }
    return p.is_comptime_type_selector_at(0)
}

fn (mut p Parser) comptime_call_type_arg() ast.Expr {
    arg_pos := p.tok.pos()
    if p.is_comptime_type_expr_arg() {
        old_inside_array_init_type_expr := p.inside_array_init_type_expr
        p.inside_array_init_type_expr = true
        expr := p.expr(0)
        p.inside_array_init_type_expr = old_inside_array_init_type_expr
        return expr
    }
    typ := p.parse_type()
    return ast.TypeNode{
        typ: typ
        pos: arg_pos.extend(p.prev_tok.pos())
    }
}

fn (mut p Parser) comptime_call() ast.ComptimeCall {
    err_node := ast.ComptimeCall{
        scope: unsafe { nil }
        kind:  .unknown
    }
    start_pos := p.tok.pos()
    p.check(.dollar)
    mut is_veb := false
    if p.peek_tok.kind == .dot {
        name := p.check_name()
        if name != 'veb' {
            p.error(error_msg)
            return err_node
        }
        import_mods := p.ast_imports.map(it.mod)
        if 'veb' !in import_mods {
            p.error_with_pos('`\$veb` cannot be used without importing veb',
                start_pos.extend(p.prev_tok.pos()))
            return err_node
        }
        p.register_used_import('veb')
        is_veb = true
        p.check(.dot)
    }
    method_name := p.check_name()
    if method_name !in supported_comptime_calls {
        p.error(error_msg)
        return err_node
    }
    is_embed_file := method_name == 'embed_file'
    is_html := method_name == 'html'
    p.check(.lpar)
    arg_pos := p.tok.pos()
    if method_name in ['env', 'pkgconfig'] {
        s := p.tok.lit
        p.check(.string)
        p.check(.rpar)
        is_env := method_name == 'env'
        return ast.ComptimeCall{
            scope:       unsafe { nil }
            method_name: method_name
            kind:        if is_env { .env } else { .pkgconfig }
            args_var:    s
            env_pos:     start_pos
            pos:         start_pos.extend(p.prev_tok.pos())
        }
    } else if method_name in ['compile_error', 'compile_warn'] {
        mut s := ''
        mut args := []ast.CallArg{}
        if p.tok.kind == .string && p.peek_tok.kind == .rpar {
            s = p.tok.lit
            p.check(.string)
        } else {
            args << ast.CallArg{
                expr:    p.string_expr()
                typ:     ast.string_type
                ct_expr: true
            }
        }
        p.check(.rpar)
        return ast.ComptimeCall{
            scope:       unsafe { nil }
            method_name: method_name
            kind:        if method_name == 'compile_error' { .compile_error } else { .compile_warn }
            args_var:    s
            env_pos:     start_pos
            pos:         start_pos.extend(p.prev_tok.pos())
            args:        args
        }
    } else if method_name == 'res' {
        mut has_args := false
        mut type_index := ''
        if p.tok.kind == .number {
            has_args = true
            type_index = p.tok.lit
            p.check(.number)
        }
        p.check(.rpar)
        if has_args {
            return ast.ComptimeCall{
                scope:       unsafe { nil }
                method_name: method_name
                kind:        .res
                args_var:    type_index
                pos:         start_pos.extend(p.prev_tok.pos())
            }
        }
        return ast.ComptimeCall{
            scope:       unsafe { nil }
            method_name: method_name
            kind:        .res
            pos:         start_pos.extend(p.prev_tok.pos())
        }
    } else if method_name == 'd' {
        const_string := p.tok.lit
        // const_name_pos := p.tok.pos()
        p.check(.string)
        p.check(.comma)
        arg_expr := p.expr(0)
        args := [
            ast.CallArg{
                expr: arg_expr
                pos:  p.tok.pos()
            },
        ]
        p.check(.rpar)
        return ast.ComptimeCall{
            scope:       unsafe { nil }
            method_name: method_name
            kind:        .d
            args_var:    const_string
            args:        args
            pos:         start_pos.extend(p.prev_tok.pos())
        }
    } else if method_name in ['zero', 'new'] {
        arg_expr := p.comptime_call_type_arg()
        p.check(.rpar)
        return ast.ComptimeCall{
            scope:       unsafe { nil }
            method_name: method_name
            kind:        if method_name == 'zero' { .zero } else { .new }
            args:        [
                ast.CallArg{
                    expr: arg_expr
                    pos:  arg_pos
                },
            ]
            pos:         start_pos.extend(p.prev_tok.pos())
        }
    }
    has_string_arg := p.tok.kind == .string
    mut literal_string_param := if is_html && !has_string_arg { '' } else { p.tok.lit }
    mut arg := ast.CallArg{}
    if is_html && !(has_string_arg || p.tok.kind == .rpar) {
        p.error('expecting `\$veb.html()` for a default template path or `\$veb.html("/path/to/template.html")`')
    }
    if is_html && p.tok.kind != .string {
        // $veb.html() can have no arguments
    } else {
        arg_expr := p.expr(0)
        if resolved_path := p.resolve_tmpl_path_expr(arg_expr) {
            literal_string_param = resolved_path
        }
        arg = ast.CallArg{
            expr: arg_expr
        }
    }
    mut embed_compression_type := 'none'
    if is_embed_file {
        if p.tok.kind == .comma {
            p.next()
            p.check(.dot)
            embed_compression_type = p.check_name()
        }
    }
    p.check(.rpar)
    // $embed_file('/path/to/file')
    if is_embed_file {
        p.register_auto_import('v.preludes.embed_file')
        if embed_compression_type == 'zlib' {
            p.register_auto_import('v.preludes.embed_file.zlib')
        }
        return ast.ComptimeCall{
            scope:       unsafe { nil }
            method_name: method_name
            kind:        .embed_file
            embed_file:  ast.EmbeddedFile{
                compression_type: embed_compression_type
            }
            args:        [arg]
            pos:         start_pos.extend(p.prev_tok.pos())
        }
    }
    // Compile veb html template to V code, parse that V code and embed the resulting V function
    // that returns an html string.
    fn_path := p.cur_fn_name.split('_')
    fn_path_joined := fn_path.join(os.path_separator)
    fn_name_html := '${p.cur_fn_name}.html'
    compiled_vfile_path := os.real_path(p.scanner.file_path.replace('/', os.path_separator))
    tmpl_path := if is_html && !has_string_arg {
        '${fn_path.last()}.html'
    } else {
        mut resolved_path := literal_string_param.replace('/', os.path_separator)
        resolved_path = p.resolve_tmpl_pseudo_variables(resolved_path, arg_pos) or {
            return err_node
        }
        resolved_path
    }
    // Looking next to the veb program
    dir := os.dir(compiled_vfile_path)
    mut path := os.join_path_single(dir, fn_path_joined)
    path += '.html'
    if !is_html || has_string_arg {
        if os.is_abs_path(tmpl_path) {
            path = tmpl_path
        } else {
            path = os.join_path_single(dir, tmpl_path)
        }
    }
    if !os.exists(path) {
        if is_html {
            if has_string_arg && !os.is_abs_path(tmpl_path) {
                path = find_veb_template_relative_to_vmod(compiled_vfile_path, tmpl_path) or {
                    path
                }
            } else {
                flat_path := os.join_path_single(dir, fn_name_html)
                if os.exists(flat_path) {
                    path = flat_path
                }
                if !os.exists(path) {
                    // can be in `templates/`
                    path = os.join_path(dir, 'templates', fn_path_joined)
                    path += '.html'
                }
                if !os.exists(path) {
                    flat_template_path := os.join_path(dir, 'templates', fn_name_html)
                    if os.exists(flat_template_path) {
                        path = flat_template_path
                    }
                }
                if !os.exists(path) {
                    // Same-module subdirs and `base_url` can place route handlers below the module
                    // root while keeping `templates/` next to `v.mod`.
                    vmod_relative_paths := [
                        os.join_path('templates', fn_path_joined) + '.html',
                        os.join_path('templates', fn_name_html),
                    ]
                    path = find_existing_veb_template_in_vmod(compiled_vfile_path,
                        vmod_relative_paths) or { path }
                }
            }
        }
        if !os.exists(path) {
            if p.pref.is_fmt {
                return ast.ComptimeCall{
                    scope:       unsafe { nil }
                    is_template: true
                    is_veb:      is_veb
                    method_name: method_name
                    kind:        if is_html { .html } else { .tmpl }
                    args_var:    literal_string_param
                    args:        [arg]
                    pos:         start_pos.extend(p.prev_tok.pos())
                }
            }
            if is_html {
                p.error_with_pos('veb HTML template "${tmpl_path}" not found', arg_pos)
            } else {
                p.error_with_pos('template file "${tmpl_path}" not found', arg_pos)
            }
            return err_node
        }
        // println('path is now "$path"')
    }
    tmp_fn_name := p.cur_fn_name.replace('.', '__').to_lower() + start_pos.pos.str()
    $if trace_comptime ? {
        println('>>> compiling comptime template file "${path}" for ${tmp_fn_name}')
    }
    v_code := p.compile_template_file(path, tmp_fn_name)
    $if print_veb_template_expansions ? {
        lines := v_code.split('\n')
        for i, line in lines {
            println('${path}:${i + 1}: ${line}')
        }
    }
    $if trace_comptime ? {
        println('')
        println('>>> template for ${path}:')
        println(v_code)
        println('>>> end of template END')
        println('')
    }
    // the tmpl inherits all parent scopes. previous functionality was just to
    // inherit the scope from which the comptime call was made and no parents.
    // this is much simpler and allows access to globals. can be changed if needed.
    p.open_scope()
    defer {
        p.close_scope()
    }
    mut file := parse_comptime(tmpl_path, v_code, mut p.table, p.pref, mut p.scope)
    file.path = tmpl_path
    template_call_stack := [
        errors.CallStackItem{
            file_path: p.file_path
            pos:       start_pos
        },
    ]
    // Store call stack info for template errors
    file.call_stack = template_call_stack
    // Transfer template paths and line mapping from parser to file for error reporting
    file.template_paths = p.template_paths
    file.template_line_map = p.template_line_map
    for i, err in file.errors {
        mut file_path := err.file_path
        mut line_nr := err.pos.line_nr
        if err.pos.line_nr >= 0 && err.pos.line_nr < file.template_line_map.len {
            line_info := file.template_line_map[err.pos.line_nr]
            file_path = line_info.tmpl_path
            line_nr = line_info.tmpl_line
        }
        file.errors[i] = errors.Error{
            message:    err.message
            details:    err.details
            file_path:  file_path
            pos:        token.Pos{
                ...err.pos
                line_nr: line_nr
            }
            reporter:   err.reporter
            call_stack: if err.call_stack.len > 0 { err.call_stack } else { template_call_stack }
        }
    }
    for i, warn in file.warnings {
        mut file_path := warn.file_path
        mut line_nr := warn.pos.line_nr
        if warn.pos.line_nr >= 0 && warn.pos.line_nr < file.template_line_map.len {
            line_info := file.template_line_map[warn.pos.line_nr]
            file_path = line_info.tmpl_path
            line_nr = line_info.tmpl_line
        }
        file.warnings[i] = errors.Warning{
            message:    warn.message
            details:    warn.details
            file_path:  file_path
            pos:        token.Pos{
                ...warn.pos
                line_nr: line_nr
            }
            reporter:   warn.reporter
            call_stack: if warn.call_stack.len > 0 { warn.call_stack } else { template_call_stack }
        }
    }
    for i, notice in file.notices {
        mut file_path := notice.file_path
        mut line_nr := notice.pos.line_nr
        if notice.pos.line_nr >= 0 && notice.pos.line_nr < file.template_line_map.len {
            line_info := file.template_line_map[notice.pos.line_nr]
            file_path = line_info.tmpl_path
            line_nr = line_info.tmpl_line
        }
        file.notices[i] = errors.Notice{
            message:    notice.message
            details:    notice.details
            file_path:  file_path
            pos:        token.Pos{
                ...notice.pos
                line_nr: line_nr
            }
            reporter:   notice.reporter
            call_stack: if notice.call_stack.len > 0 {
                notice.call_stack
            } else {
                template_call_stack
            }
        }
    }
    return ast.ComptimeCall{
        scope:       unsafe { nil }
        is_template: true
        is_veb:      is_veb
        veb_tmpl:    file
        method_name: method_name
        kind:        if is_html { .html } else { .tmpl }
        args_var:    literal_string_param
        args:        [arg]
        pos:         start_pos.extend(p.prev_tok.pos())
    }
}

fn (mut p Parser) comptime_for() ast.ComptimeFor {
    // p.comptime_for() handles these special forms:
    // `$for method in App.methods {`
    // `$for val in App.values {`
    // `$for field in App.fields {`
    // `$for attr in App.attributes {`
    // `$for variant in App.variants {`
    // `$for variant in field.typ.variants {`
    p.next()
    p.check(.key_for)
    var_pos := p.tok.pos()
    val_var := p.check_name()
    p.check(.key_in)
    mut expr := ast.empty_expr
    mut typ_pos := p.tok.pos()
    lang := p.parse_language()
    mut typ := ast.void_type

    if p.tok.lit.len == 0 {
        p.error('invalid expr, use `${p.peek_tok.lit}` instead')
        return ast.ComptimeFor{}
    }
    if p.tok.lit[0].is_capital() || p.tok.lit in p.imports {
        typ = p.parse_any_type(lang, false, true, false)
    } else {
        mut selector_expr := ast.Expr(p.ident(lang))
        p.scope.mark_var_as_used((selector_expr as ast.Ident).name)
        for p.tok.kind == .dot && p.peek_tok.kind == .name
            && !is_supported_comptime_for_kind(p.peek_tok.lit) {
            selector_expr = p.dot_expr(selector_expr)
            if p.name_error {
                return ast.ComptimeFor{}
            }
            if selector_expr !is ast.SelectorExpr {
                p.error_with_pos('invalid expr, use a selector like `field.typ`',
                    selector_expr.pos())
                return ast.ComptimeFor{}
            }
        }
        expr = selector_expr
    }
    typ_pos = typ_pos.extend(p.prev_tok.pos())
    p.check(.dot)
    for_val := p.check_name()
    mut kind := ast.ComptimeForKind.methods
    p.open_scope()
    defer {
        p.close_scope()
    }
    match for_val {
        'params' {
            p.scope.register(ast.Var{
                name: val_var
                typ:  p.table.find_type('FunctionParam')
                pos:  var_pos
            })
            kind = .params
        }
        'methods' {
            p.scope.register(ast.Var{
                name: val_var
                typ:  p.table.find_type('FunctionData')
                pos:  var_pos
            })
        }
        'values' {
            p.scope.register(ast.Var{
                name: val_var
                typ:  p.table.find_type('EnumData')
                pos:  var_pos
            })
            kind = .values
        }
        'fields' {
            p.scope.register(ast.Var{
                name: val_var
                typ:  p.table.find_type('FieldData')
                pos:  var_pos
            })
            kind = .fields
        }
        'variants' {
            p.scope.register(ast.Var{
                name: val_var
                typ:  p.table.find_type('VariantData')
                pos:  var_pos
            })
            kind = .variants
        }
        'attributes' {
            p.scope.register(ast.Var{
                name: val_var
                typ:  p.table.find_type('VAttribute')
                pos:  var_pos
            })
            kind = .attributes
        }
        else {
            p.error_with_pos('unknown kind `${for_val}`, available are: `methods`, `fields`, `values`, `variants`, `attributes` or `params`',
                p.prev_tok.pos())
            return ast.ComptimeFor{}
        }
    }

    spos := p.tok.pos()
    stmts := p.parse_block()
    return ast.ComptimeFor{
        val_var: val_var
        stmts:   stmts
        kind:    kind
        typ:     typ
        expr:    expr
        typ_pos: typ_pos
        scope:   p.scope
        pos:     spos.extend(p.tok.pos())
    }
}

// @FN, @STRUCT, @MOD etc. See full list in token.valid_at_tokens
fn (mut p Parser) at() ast.AtExpr {
    name := p.tok.lit
    kind := match name {
        '@FN' { token.AtKind.fn_name }
        '@METHOD' { token.AtKind.method_name }
        '@MOD' { token.AtKind.mod_name }
        '@STRUCT' { token.AtKind.struct_name }
        '@FILE' { token.AtKind.file_path }
        '@DIR' { token.AtKind.file_dir }
        '@LINE' { token.AtKind.line_nr }
        '@FILE_LINE' { token.AtKind.file_path_line_nr }
        '@LOCATION' { token.AtKind.location }
        '@COLUMN' { token.AtKind.column_nr }
        '@VCURRENTHASH' { token.AtKind.v_current_hash }
        '@VHASH' { token.AtKind.vhash }
        '@VMOD_FILE' { token.AtKind.vmod_file }
        '@VEXE' { token.AtKind.vexe_path }
        '@VEXEROOT' { token.AtKind.vexeroot_path }
        '@VMODROOT' { token.AtKind.vmodroot_path }
        '@VMODHASH' { token.AtKind.vmod_hash }
        '@VROOT' { token.AtKind.vroot_path } // deprecated, use @VEXEROOT or @VMODROOT
        '@BUILD_DATE' { token.AtKind.build_date }
        '@BUILD_TIME' { token.AtKind.build_time }
        '@BUILD_TIMESTAMP' { token.AtKind.build_timestamp }
        '@OS' { token.AtKind.os }
        '@CCOMPILER' { token.AtKind.ccompiler }
        '@BACKEND' { token.AtKind.backend }
        '@PLATFORM' { token.AtKind.platform }
        else { token.AtKind.unknown }
    }

    expr := ast.AtExpr{
        name: name
        pos:  p.tok.pos()
        kind: kind
    }
    p.next()
    return expr
}

fn (mut p Parser) comptime_selector(left ast.Expr) ast.Expr {
    p.check(.dollar)
    start_pos := p.prev_tok.pos()
    if p.peek_tok.kind == .lpar {
        method_pos := p.tok.pos()
        method_name := p.check_name()
        p.scope.mark_var_as_used(method_name)
        // `app.$action()` (`action` is a string)
        p.check(.lpar)
        args := p.call_args()
        p.check(.rpar)
        mut or_kind := ast.OrKind.absent
        mut or_pos := p.tok.pos()
        mut or_stmts := []ast.Stmt{}
        mut or_scope := ast.empty_scope
        if p.tok.kind == .key_orelse {
            // `$method() or {}``
            or_kind = .block
            or_stmts, or_pos, or_scope = p.or_block(.with_err_var)
        }
        return ast.ComptimeCall{
            left:        left
            method_name: method_name
            kind:        .method
            method_pos:  method_pos
            scope:       p.scope
            args_var:    ''
            args:        args
            pos:         start_pos.extend(p.prev_tok.pos())
            or_block:    ast.OrExpr{
                stmts: or_stmts
                kind:  or_kind
                pos:   or_pos
                scope: or_scope
            }
        }
    }
    mut has_parens := false
    if p.tok.kind == .lpar {
        p.next()
        has_parens = true
    } else {
        p.warn_with_pos('use brackets instead e.g. `s.$(field.name)` - run vfmt', p.tok.pos())
    }
    expr := p.expr(0)
    if has_parens {
        p.check(.rpar)
    }
    return ast.ComptimeSelector{
        has_parens: has_parens
        left:       left
        field_expr: expr
        pos:        start_pos.extend(p.prev_tok.pos())
        or_block:   ast.OrExpr{
            stmts: []ast.Stmt{}
            kind:  if p.tok.kind == .question { .propagate_option } else { .absent }
            scope: p.scope
            pos:   p.tok.pos()
        }
    }
}