// 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 v.ast
import v.token

const max_expr_level = 100

@[inline]
fn (mut p Parser) check_expr_level() ! {
	if p.expr_level > max_expr_level {
		return error('expr level > ${max_expr_level}')
	}
}

fn (mut p Parser) expr_no_value(precedence int) ast.Expr {
	old_expecting_value := p.expecting_value
	p.expecting_value = false
	defer {
		p.expecting_value = old_expecting_value
	}
	return p.check_expr(precedence) or {
		if token.is_decl(p.tok.kind) && p.disallow_declarations_in_script_mode() {
			return ast.empty_expr
		}
		p.unexpected(prepend_msg: 'invalid expression:')
	}
}

fn (mut p Parser) expr(precedence int) ast.Expr {
	old_expecting_value := p.expecting_value
	p.expecting_value = true
	defer {
		p.expecting_value = old_expecting_value
	}
	return p.check_expr(precedence) or {
		if token.is_decl(p.tok.kind) && p.disallow_declarations_in_script_mode() {
			return ast.empty_expr
		}
		p.unexpected(prepend_msg: 'invalid expression:')
	}
}

fn (mut p Parser) check_expr(precedence int) !ast.Expr {
	p.trace_parser('expr(${precedence})')
	p.expr_level++
	defer {
		p.expr_level--
	}
	p.check_expr_level()!
	mut node := ast.empty_expr
	is_stmt_ident := p.is_stmt_ident
	p.is_stmt_ident = false
	if !p.pref.is_fmt {
		p.eat_comments()
	}
	if p.inside_if_cond {
		p.if_cond_comments << p.eat_comments()
	}
	// Prefix
	match p.tok.kind {
		.key_mut, .key_shared, .key_atomic, .key_static, .key_volatile {
			if p.peek_tok.kind in [.lpar, .lsbr] && p.peek_tok.is_next_to(p.tok) {
				node = p.call_expr(p.language, p.mod)
			} else {
				ident := p.ident(.v)
				node = ident
				if p.peek_tok.kind != .assign && (p.inside_if_cond || p.inside_match) {
					p.scope.mark_var_as_used(ident.name)
				}
				p.add_defer_var(ident)
				p.is_stmt_ident = is_stmt_ident
			}
		}
		.name, .question {
			if p.peek_tok.kind == .name && p.tok.lit == 'sql' {
				node = p.sql_expr()
			} else if p.peek_tok.kind == .lcbr && p.tok.lit == 'map' && !(p.builtin_mod
				&& p.file_base in ['map.v', 'map_d_gcboehm_opt.v']) {
				p.error_with_pos("deprecated map syntax, use syntax like `{'age': 20}`",
					p.tok.pos())
			} else if p.tok.kind == .question && p.peek_tok.kind == .amp {
				node = p.prefix_expr()
			} else if p.inside_for_expr && p.tok.kind == .name && ((p.tok.lit[0].is_capital()
				&& p.peek_tok.kind == .lcbr && p.peek_token(2).kind in [.rcbr, .name])
				|| (p.inside_array_lit && p.peek_tok.kind == .dot && p.peek_token(2).kind == .name
				&& p.peek_token(2).lit[0].is_capital() && p.peek_token(3).kind == .lcbr
				&& p.peek_token(4).kind in [.rcbr, .name])) {
				node = p.struct_init(p.mod + '.' + p.tok.lit, .normal, false)
			} else if p.is_generic_name() && p.peek_tok.kind == .lcbr
				&& p.peek_token(2).kind == .rcbr && p.peek_token(2).line_nr == p.tok.line_nr {
				node = p.struct_init(p.mod + '.' + p.tok.lit, .normal, false)
			} else {
				if p.inside_comptime_if && p.is_generic_name() && p.peek_tok.kind != .dot {
					// $if T is string {}
					p.expecting_type = true
				}
				node = p.name_expr()
				p.is_stmt_ident = is_stmt_ident
			}
		}
		.string {
			node = p.string_expr()
		}
		.comment {
			node = p.comment()
			return node
		}
		.dot {
			// .enum_val
			node = p.enum_val()
		}
		.at {
			node = p.at()
		}
		.dollar {
			match p.peek_tok.kind {
				.key_typeof, .key_sizeof, .key_isreftype, .key_dump, .key_offsetof {
					start_pos := p.tok.pos()
					p.check(.dollar)
					match p.tok.kind {
						.key_typeof {
							node = p.parse_typeof_expr(start_pos)
						}
						.key_sizeof, .key_isreftype {
							node = p.parse_sizeof_or_isreftype_expr()
						}
						.key_dump {
							node = p.parse_dump_expr(start_pos)
						}
						.key_offsetof {
							node = p.parse_offsetof_expr(start_pos)
						}
						else {}
					}

					p.is_stmt_ident = is_stmt_ident
				}
				.name, .key_struct, .key_enum, .key_interface, .key_shared {
					if p.peek_tok.lit in comptime_types {
						node = p.parse_comptime_type()
					} else {
						node = p.comptime_call()
					}
					p.is_stmt_ident = is_stmt_ident
				}
				.key_if {
					mut is_expr := false
					if p.prev_tok.kind.is_assign() {
						is_expr = true
					}
					return p.if_expr(true, is_expr)
				}
				.key_match {
					return p.match_expr(true, p.prev_tok.kind.is_assign())
				}
				else {
					return p.unexpected_with_pos(p.peek_tok.pos(),
						got: '`$`'
					)
				}
			}
		}
		.chartoken {
			node = ast.CharLiteral{
				val: p.tok.lit
				pos: p.tok.pos()
			}
			p.next()
		}
		.amp, .mul, .not, .bit_not, .arrow {
			// &x, *x, !x, ~x, <-x
			node = p.prefix_expr()
		}
		.power {
			node = p.power_prefix_expr()
		}
		.plus {
			// +1, +a
			node = p.prefix_expr()
		}
		.minus {
			// -1, -a
			if p.peek_tok.kind == .number && !(p.peek_token(2).kind == .power
				&& p.peek_token(2).line_nr == p.tok.line_nr) {
				node = p.parse_number_literal()
			} else {
				node = p.prefix_expr()
			}
		}
		.key_go, .key_spawn {
			if p.peek_tok.kind in [.lpar, .lsbr] && p.peek_tok.is_next_to(p.tok) {
				node = p.call_expr(p.language, p.mod)
			} else {
				if (p.pref.use_coroutines || p.pref.is_fmt) && p.tok.kind == .key_go {
					mut go_expr := p.go_expr()
					go_expr.is_expr = true
					node = go_expr
				} else {
					mut spawn_expr := p.spawn_expr()
					spawn_expr.is_expr = true
					node = spawn_expr
				}
			}
		}
		.key_true, .key_false {
			if p.peek_tok.kind in [.lpar, .lsbr] && p.peek_tok.is_next_to(p.tok) {
				node = p.call_expr(p.language, p.mod)
			} else {
				node = ast.BoolLiteral{
					val: p.tok.kind == .key_true
					pos: p.tok.pos()
				}
				p.next()
			}
		}
		.key_match {
			node = if p.peek_tok.kind in [.lpar, .lsbr] && p.peek_tok.is_next_to(p.tok) {
				p.call_expr(p.language, p.mod)
			} else {
				p.match_expr(false, false)
			}
		}
		.key_select {
			if p.peek_tok.kind in [.lpar, .lsbr] && p.peek_tok.is_next_to(p.tok) {
				node = p.call_expr(p.language, p.mod)
			} else {
				node = p.select_expr()
			}
		}
		.key_nil {
			node = ast.Nil{
				pos: p.tok.pos()
			}
			p.next()
		}
		.number {
			node = p.parse_number_literal()
		}
		.lpar {
			mut pos := p.tok.pos()
			p.check(.lpar)
			mut comments := p.eat_comments()
			node = p.expr(0)
			comments << p.eat_comments()
			p.check(.rpar)
			rpar_pos := p.prev_tok.pos()
			p.attach_or_block_to_parenthesized_expr(mut node)
			node = ast.ParExpr{
				expr:     node
				pos:      pos.extend(rpar_pos)
				comments: comments
			}
		}
		.key_if {
			if p.peek_tok.kind in [.lpar, .lsbr] && p.peek_tok.is_next_to(p.tok) {
				node = p.call_expr(p.language, p.mod)
			} else {
				mut is_expr := false
				if p.prev_tok.kind.is_assign() {
					is_expr = true
				}
				node = p.if_expr(false, is_expr)
			}
		}
		.key_unsafe {
			// unsafe {
			mut pos := p.tok.pos()
			p.next()
			if p.inside_unsafe {
				err := p.error_with_pos('already inside `unsafe` block', pos)
				if p.tok.kind != .eof {
					p.recover_until_closing_rcbr()
				}
				return err
			}
			p.inside_unsafe = true
			p.check(.lcbr)
			e := p.expr(0)
			p.check(.rcbr)
			pos.update_last_line(p.prev_tok.line_nr)
			node = ast.UnsafeExpr{
				expr: e
				pos:  pos
			}
			p.inside_unsafe = false
		}
		.pipe, .logical_or {
			if nnn := p.lambda_expr() {
				node = nnn
			} else {
				return error('unexpected lambda expression')
			}
		}
		.key_lock, .key_rlock {
			if p.peek_tok.kind in [.lpar, .lsbr] && p.peek_tok.is_next_to(p.tok) {
				node = p.call_expr(p.language, p.mod)
			} else {
				node = p.lock_expr()
			}
		}
		.lsbr {
			if p.expecting_type {
				// parse json.decode type (`json.decode([]User, s)`)
				node = p.name_expr()
			} else {
				// check is `cast_expr` or `array_init`
				// [name.name][]a{}  => array_init
				// [name.name][]a(expr) => cast_expr, same line
				line_nr := p.tok.line_nr
				mut n := 1
				mut prev_n_tok := p.tok
				mut peek_n_tok := p.peek_token(n)
				mut sbr_level := 1
				for peek_n_tok.kind in [.name, .dot, .lsbr, .rsbr, .number] {
					if peek_n_tok.kind == .rsbr {
						sbr_level--
					} else if peek_n_tok.kind == .lsbr {
						sbr_level++
					}
					if peek_n_tok.kind == .dot && prev_n_tok.kind != .name {
						// [xxx].method()
						break
					}
					n++
					prev_n_tok = peek_n_tok
					peek_n_tok = p.peek_token(n)
				}
				mut is_cast_expr := peek_n_tok.kind == .lpar && sbr_level == 0
					&& peek_n_tok.line_nr == line_nr
				// If the matching `)` is followed by `{`, this can still be an array init when
				// the element type itself contains parentheses, e.g. `[](?Type){}` or
				// `[]thread (T1, T2){}`.
				if is_cast_expr && (prev_n_tok.kind == .rsbr || prev_n_tok.lit == 'thread') {
					mut par_level := 0
					for i := n; true; i++ {
						tk := p.peek_token(i)
						if tk.kind == .eof {
							break
						}
						if tk.kind == .lpar {
							par_level++
						} else if tk.kind == .rpar {
							par_level--
							if par_level == 0 {
								if p.peek_token(i + 1).kind == .lcbr {
									is_cast_expr = false
								}
								break
							}
						}
					}
				}
				if is_cast_expr {
					pos := p.tok.pos()
					typ := p.parse_type()
					typname := p.table.sym(typ).name
					p.check(.lpar)
					expr := p.expr(0)
					p.check(.rpar)
					node = ast.CastExpr{
						typ:     typ
						typname: typname
						expr:    expr
						pos:     pos
					}
				} else {
					node = p.array_init(false, ast.void_type)
				}
			}
		}
		.key_none {
			pos := p.tok.pos()
			p.next()
			node = ast.None{
				pos: pos
			}
		}
		.key_typeof {
			node = p.parse_typeof_expr(p.tok.pos())
		}
		.key_sizeof, .key_isreftype {
			node = p.parse_sizeof_or_isreftype_expr()
		}
		.key_dump {
			node = p.parse_dump_expr(p.tok.pos())
		}
		.key_offsetof {
			node = p.parse_offsetof_expr(p.tok.pos())
		}
		.key_likely, .key_unlikely {
			is_likely := p.tok.kind == .key_likely
			p.next()
			p.check(.lpar)
			lpos := p.tok.pos()
			expr := p.expr(0)
			p.check(.rpar)
			node = ast.Likely{
				expr:      expr
				pos:       lpos
				is_likely: is_likely
			}
		}
		.lcbr {
			if p.is_sql_query_data_expr() {
				node = p.sql_query_data_expr()
			} else {
				// Map `{"age": 20}`
				p.next()
				node = p.map_init()
				p.check(.rcbr)
			}
		}
		.key_fn {
			if p.expecting_type {
				// Anonymous function type
				start_pos := p.tok.pos()
				return ast.TypeNode{
					typ: p.parse_type()
					pos: start_pos.extend(p.prev_tok.pos())
				}
			} else {
				// Anonymous function
				node = p.anon_fn()
				if p.file_backend_mode == .v || p.file_backend_mode == .c {
					p.register_auto_import('builtin.closure')
				}
				// its a call
				// NOTE: this could be moved to just before the pratt loop
				// then anything can be a call, eg. `index[2]()` or `struct.field()`
				// but this would take a bit of modification
				if p.tok.kind == .lpar {
					p.next()
					pos := p.tok.pos()
					args := p.call_args()
					p.check(.rpar)
					or_block := p.gen_or_block()
					node = ast.CallExpr{
						name:           'anon'
						left:           node
						args:           args
						pos:            pos
						or_block:       or_block
						scope:          p.scope
						is_return_used: p.expecting_value
					}
				}
				return node
			}
		}
		.inc, .dec {
			same_line_with_next := p.tok.line_nr == p.peek_tok.line_nr
			next_tok_name := p.peek_tok.kind == .name

			if next_tok_name && same_line_with_next {
				p.prefix_inc_dec_error()
			}
		}
		else {
			if p.tok.kind == .key_struct && p.peek_tok.kind == .lcbr {
				if p.expecting_type && p.inside_call_args {
					// Anonymous struct	for json.decode
					tok_pos := p.tok.pos()
					return ast.TypeNode{
						stmt: p.struct_decl(true)
						pos:  tok_pos
						typ:  ast.void_type
					}
				} else {
					// Anonymous struct
					if !p.is_explicit_anon_struct_init() {
						p.next()
					}
					return p.struct_init('', .anon, false)
				}
			} else if p.tok.kind == .key_type {
				// variable name: type
				ident := p.ident(.v)
				node = ident
				p.scope.mark_var_as_used(ident.name)
				p.add_defer_var(ident)
				p.is_stmt_ident = is_stmt_ident
			} else if p.tok.kind != .eof && !(p.tok.kind == .rsbr && p.inside_asm) {
				// eof should be handled where it happens
				return error('none')
				// return p.unexpected(prepend_msg: 'invalid expression: ')
			}
		}
	}

	if p.inside_array_lit {
		if p.tok.kind in [.minus, .mul, .amp, .arrow] && p.tok.pos + 1 == p.peek_tok.pos
			&& p.prev_tok.pos + p.prev_tok.len + 1 != p.peek_tok.pos {
			return node
		}
	}
	if p.inside_if_cond {
		p.if_cond_comments << p.eat_comments()
	}
	if p.pref.is_fmt && p.tok.kind == .comment && p.peek_tok.kind.is_infix() && !p.inside_map_init
		&& !(p.peek_tok.kind == .mul && p.peek_tok.pos().line_nr != p.tok.pos().line_nr) {
		p.left_comments = p.eat_comments()
	}
	return p.expr_with_left(node, precedence, is_stmt_ident)
}

fn (p &Parser) is_explicit_anon_struct_init() bool {
	mut n := 2
	mut curlies := 1
	for curlies > 0 {
		tok := p.peek_token(n)
		if tok.kind == .eof {
			return false
		}
		if tok.kind == .lcbr {
			curlies++
		} else if tok.kind == .rcbr {
			curlies--
		}
		n++
	}
	return p.peek_token(n).kind == .lcbr
}

fn (mut p Parser) parse_typeof_expr(start_pos token.Pos) ast.Expr {
	p.next() // typeof
	if p.tok.kind == .lsbr {
		p.check(.lsbr)
		type_pos := p.tok.pos()
		typ := p.parse_type()
		p.check(.rsbr)
		p.check(.lpar)
		p.check(.rpar)
		return ast.TypeOf{
			is_type: true
			typ:     typ
			pos:     type_pos.extend(p.tok.pos())
		}
	}
	p.check(.lpar)
	expr := p.expr(0)
	p.check(.rpar)
	if p.tok.kind != .dot && p.tok.line_nr == p.prev_tok.line_nr && !p.inside_array_init_type_expr {
		if !p.inside_unsafe {
			p.warn_with_pos('use e.g. `typeof(expr).name` or `sum_type_instance.type_name()` instead',
				start_pos)
		}
	}
	return ast.TypeOf{
		is_type: false
		expr:    expr
		pos:     start_pos.extend(p.tok.pos())
	}
}

fn (mut p Parser) parse_sizeof_or_isreftype_expr() ast.Expr {
	is_reftype := p.tok.kind == .key_isreftype
	p.next() // sizeof or isreftype
	if p.tok.kind == .lsbr {
		// parse sizeof[T]() and isreftype[T]() without guessing:
		p.check(.lsbr)
		mut type_pos := p.tok.pos()
		typ := p.parse_type()
		type_pos = type_pos.extend(p.tok.pos())
		p.check(.rsbr)
		p.check(.lpar)
		p.check(.rpar)
		if is_reftype {
			return ast.IsRefType{
				is_type: true
				typ:     typ
				pos:     type_pos
			}
		}
		return ast.SizeOf{
			is_type: true
			typ:     typ
			pos:     type_pos
		}
	}
	p.check(.lpar)
	pos := p.tok.pos()
	mut is_known_var := p.scope.mark_var_as_used(p.tok.lit)
		|| p.table.global_scope.known_const(p.mod + '.' + p.tok.lit)
	//|| p.table.known_fn(p.mod + '.' + p.tok.lit)
	// assume `mod.` prefix leads to a type
	mut is_type := p.known_import(p.tok.lit) || p.tok.kind.is_start_of_type()
		|| (p.tok.lit.len > 0 && p.tok.lit[0].is_capital())
	if p.peek_tok.kind == .string && p.tok.lit in ['c', 'r'] {
		is_known_var = false
		is_type = false
	}
	if is_known_var || !is_type {
		expr := p.expr(0)
		if is_reftype {
			result := ast.IsRefType{
				is_type: false
				expr:    expr
				pos:     pos
			}
			p.check(.rpar)
			return result
		}
		result := ast.SizeOf{
			is_type: false
			expr:    expr
			pos:     pos
		}
		p.check(.rpar)
		return result
	}
	if p.tok.kind == .name {
		p.register_used_import(p.tok.lit)
	}
	save_expr_mod := p.expr_mod
	p.expr_mod = ''
	arg_type := p.parse_type()
	p.expr_mod = save_expr_mod
	p.check(.rpar)
	if is_reftype {
		return ast.IsRefType{
			guessed_type: true
			is_type:      true
			typ:          arg_type
			pos:          pos
		}
	}
	return ast.SizeOf{
		guessed_type: true
		is_type:      true
		typ:          arg_type
		pos:          pos
	}
}

fn (mut p Parser) parse_dump_expr(start_pos token.Pos) ast.Expr {
	p.next() // dump
	p.check(.lpar)
	expr := p.expr(0)
	if p.tok.kind == .comma && p.peek_tok.kind == .rpar {
		p.next()
	}
	p.check(.rpar)
	mut pos := p.tok.pos()
	pos.update_last_line(p.prev_tok.line_nr)
	return ast.DumpExpr{
		expr: expr
		pos:  start_pos.extend(pos)
	}
}

fn (mut p Parser) parse_offsetof_expr(start_pos token.Pos) ast.Expr {
	p.next() // __offsetof
	p.check(.lpar)
	st := p.parse_type()
	p.check(.comma)
	if p.tok.kind != .name {
		return p.unexpected(got: '`${p.tok.lit}`', additional_msg: 'expecting struct field')
	}
	field := p.tok.lit
	p.next()
	p.check(.rpar)
	return ast.OffsetOf{
		struct_type: st
		field:       field
		pos:         start_pos
	}
}

fn (p &Parser) can_use_expr_as_struct_init_type(expr ast.Expr) bool {
	return match expr {
		ast.ParExpr {
			p.can_use_expr_as_struct_init_type(expr.expr)
		}
		ast.SelectorExpr {
			expr.expr is ast.TypeOf
				&& expr.field_name in ['idx', 'typ', 'unaliased_typ', 'key_type', 'value_type', 'element_type', 'pointee_type', 'payload_type']
		}
		else {
			false
		}
	}
}

fn (mut p Parser) expr_with_left(left ast.Expr, precedence int, is_stmt_ident bool) ast.Expr {
	mut node := left
	if p.inside_asm && p.prev_tok.pos().line_nr < p.tok.pos().line_nr {
		return node
	}

	p.process_custom_orm_operators()

	// Infix
	for {
		if p.tok.kind == .lpar && p.tok.line_nr == p.prev_tok.line_nr
			&& node in [ast.CallExpr, ast.IndexExpr, ast.ParExpr, ast.SelectorExpr] {
			p.promote_if_expr_to_value(mut node)
			node = p.call_expr_with_left(node)
			p.is_stmt_ident = is_stmt_ident
			continue
		}
		if !p.inside_array_init_type_expr && p.tok.kind == .lcbr && p.tok.is_next_to(p.prev_tok)
			&& p.can_use_expr_as_struct_init_type(node) {
			node = p.struct_init_with_type_expr(node, .normal)
			p.is_stmt_ident = is_stmt_ident
			continue
		}
		if precedence >= p.tok.kind.precedence() {
			return node
		}
		if p.tok.kind == .dot {
			// no spaces or line break before dot in map_init
			if (p.inside_map_init || p.inside_array_lit)
				&& p.tok.pos - p.prev_tok.pos > p.prev_tok.len {
				return node
			}
			p.promote_if_expr_to_value(mut node)
			node = p.dot_expr(node)
			if p.name_error {
				return node
			}
			p.is_stmt_ident = is_stmt_ident
		} else if left !is ast.IntegerLiteral && p.tok.kind in [.lsbr, .nilsbr]
			&& (p.tok.line_nr == p.prev_tok.line_nr || (p.prev_tok.kind == .string
			&& p.tok.line_nr == p.prev_tok.line_nr + p.prev_tok.lit.count('\n'))) {
			p.promote_if_expr_to_value(mut node)
			if p.peek_tok.kind == .question && p.peek_token(2).kind == .name {
				p.next()
				p.error_with_pos('cannot use Option type name as concrete type', p.tok.pos())
			} else if p.tok.kind == .nilsbr {
				node = p.index_expr(node, true)
			} else {
				node = p.index_expr(node, false)
			}
			p.is_stmt_ident = is_stmt_ident
		} else if p.tok.kind == .key_as && p.tok.line_nr == p.prev_tok.line_nr {
			// sum type as cast `x := SumType as Variant`
			if !p.inside_asm {
				pos := p.tok.pos()
				p.promote_if_expr_to_value(mut node)
				p.next()
				typ := p.parse_type()
				node = ast.AsCast{
					expr: node
					typ:  typ
					pos:  pos
				}
			} else {
				return node
			}
		} else if node !is ast.CastExpr && p.tok.kind == .left_shift && p.is_stmt_ident {
			// arr << elem
			tok := p.tok
			mut pos := tok.pos()
			p.next()
			old_assign_rhs := p.inside_assign_rhs
			p.inside_assign_rhs = true
			right := p.expr(precedence - 1)
			p.inside_assign_rhs = old_assign_rhs
			pos.update_last_line(p.prev_tok.line_nr)
			if mut node is ast.IndexExpr {
				node.recursive_arraymap_set_is_setter()
			}
			node = ast.InfixExpr{
				left:    node
				right:   right
				op:      tok.kind
				pos:     pos
				is_stmt: true
			}
		} else if p.tok.kind.is_infix()
			&& !(p.tok.kind in [.minus, .amp, .mul, .arrow, .key_as, .key_in, .key_is]
			&& p.tok.line_nr != p.prev_tok.line_nr) {
			// continue on infix expr
			p.promote_if_expr_to_value(mut node)
			node = p.infix_expr(node)
			// return early `if bar is SumType as b {`
			if p.tok.kind == .key_as && p.inside_if {
				return node
			}
		} else if p.tok.kind in [.inc, .dec] || (p.tok.kind == .question && p.inside_ct_if_expr) {
			// Postfix
			// detect `f(x++)`, `a[x++]`
			if p.peek_tok.kind in [.rpar, .rsbr] {
				if !p.inside_ct_if_expr {
					if !p.pref.translated && !p.is_translated {
						p.warn_with_pos('`${p.tok.kind}` operator can only be used as a statement',
							p.tok.pos())
					}
				}
			}

			inc_dec_tok := p.tok.kind in [.inc, .dec]
			same_line_with_prev := p.tok.line_nr == p.prev_tok.line_nr
			same_line_with_next := p.tok.line_nr == p.peek_tok.line_nr
			next_tok_name := p.peek_tok.kind == .name

			// 1. name
			// 2. ++
			//    ^^ current token
			if inc_dec_tok && !same_line_with_prev && !next_tok_name {
				p.error_with_pos('${p.tok} must be on the same line as the previous token',
					p.tok.pos())
			}

			// a++ a--
			//  ^^ current token
			// a[i]++ a--
			//     ^^ current token
			// check if op attached to previous name
			prev_name_or_rsbr := p.prev_tok.kind in [.name, .rsbr]
			// 1. ++name
			//    ^^ current token
			if inc_dec_tok && same_line_with_next && next_tok_name
				&& (!prev_name_or_rsbr || !same_line_with_prev) {
				p.prefix_inc_dec_error()
			}

			if mut node is ast.IndexExpr {
				node.recursive_mapset_is_setter(true)
			}
			is_c2v_prefix := p.peek_tok.kind == .dollar && p.peek_tok.is_next_to(p.tok)
			node = ast.PostfixExpr{
				op:            p.tok.kind
				expr:          node
				pos:           p.tok.pos()
				is_c2v_prefix: is_c2v_prefix
			}
			if is_c2v_prefix {
				p.next()
			}
			p.next()
			// return node // TODO: bring back, only allow ++/-- in exprs in translated code
		} else {
			return node
		}
	}
	return node
}

fn (mut p Parser) promote_if_expr_to_value(mut expr ast.Expr) {
	match mut expr {
		ast.IfExpr {
			expr.is_expr = true
			expr.force_expr = true
		}
		else {}
	}
}

fn unwrap_parenthesized_call_left(expr ast.Expr) ast.Expr {
	return match expr {
		ast.ParExpr { unwrap_parenthesized_call_left(expr.expr) }
		else { expr }
	}
}

fn (mut p Parser) call_expr_with_left(left ast.Expr) ast.CallExpr {
	p.next()
	pos := p.tok.pos()
	args := p.call_args()
	p.check(.rpar)
	or_block := p.gen_or_block()
	unwrapped_left := unwrap_parenthesized_call_left(left)
	mut name := ''
	mut name_pos := token.Pos{}
	mut mod := ''
	mut kind := ast.CallKind.unknown
	if unwrapped_left is ast.Ident {
		ident := unwrapped_left as ast.Ident
		mut fn_name := ident.name
		if p.is_imported_symbol(fn_name) {
			check := !p.imported_symbols_used[fn_name]
			fn_name = p.imported_symbols[fn_name]
			if check {
				p.register_used_import_for_symbol_name(fn_name)
			}
		}
		name = fn_name
		name_pos = ident.pos
		mod = p.mod
		kind = p.call_kind(fn_name)
	}
	return ast.CallExpr{
		name:                  name
		name_pos:              name_pos
		mod:                   mod
		kind:                  kind
		left:                  unwrapped_left
		args:                  args
		pos:                   pos
		scope:                 p.scope
		or_block:              or_block
		is_return_used:        p.expecting_value
		is_paren_wrapped_call: left is ast.ParExpr
	}
}

fn (mut p Parser) gen_or_block() ast.OrExpr {
	if p.tok.kind == .key_orelse {
		// `foo() or {}``
		or_stmts, or_pos, or_scope := p.or_block(.with_err_var)
		return ast.OrExpr{
			kind:  ast.OrKind.block
			stmts: or_stmts
			pos:   or_pos
			scope: or_scope
		}
	} else if p.tok.kind in [.question, .not] {
		or_pos := p.tok.pos()
		is_not := p.tok.kind == .not
		// `foo()?`
		p.next()
		if p.inside_defer {
			p.error_with_pos('error propagation not allowed inside `defer` blocks',
				p.prev_tok.pos())
		}
		return ast.OrExpr{
			kind:  if is_not { ast.OrKind.propagate_result } else { ast.OrKind.propagate_option }
			scope: p.scope
			pos:   or_pos
		}
	} else {
		return ast.OrExpr{
			kind:  ast.OrKind.absent
			scope: ast.empty_scope
			pos:   p.tok.pos()
		}
	}
}

fn (mut p Parser) attach_or_block_to_parenthesized_expr(mut expr ast.Expr) bool {
	if p.tok.kind != .key_orelse {
		return false
	}
	match mut expr {
		ast.CallExpr {
			if expr.or_block.kind == .block {
				return false
			}
			or_stmts, or_pos, or_scope := p.or_block(.with_err_var)
			expr.or_block = ast.OrExpr{
				kind:  .block
				stmts: or_stmts
				pos:   or_pos
				scope: or_scope
			}
			return true
		}
		ast.ComptimeCall {
			if expr.or_block.kind == .block {
				return false
			}
			or_stmts, or_pos, or_scope := p.or_block(.with_err_var)
			expr.or_block = ast.OrExpr{
				kind:  .block
				stmts: or_stmts
				pos:   or_pos
				scope: or_scope
			}
			return true
		}
		ast.Ident {
			if expr.or_expr.kind == .block {
				return false
			}
			err_var_mode := if expr.or_expr.kind in [.propagate_option, .propagate_result] {
				OrBlockErrVarMode.with_err_var
			} else {
				OrBlockErrVarMode.no_err_var
			}
			or_stmts, or_pos, or_scope := p.or_block(err_var_mode)
			expr.or_expr = ast.OrExpr{
				kind:  .block
				stmts: or_stmts
				pos:   or_pos
				scope: or_scope
			}
			return true
		}
		ast.IndexExpr {
			if expr.or_expr.kind == .block {
				return false
			}
			err_var_mode := if expr.or_expr.kind in [.propagate_option, .propagate_result] {
				OrBlockErrVarMode.with_err_var
			} else {
				OrBlockErrVarMode.no_err_var
			}
			or_stmts, or_pos, or_scope := p.or_block(err_var_mode)
			expr.or_expr = ast.OrExpr{
				kind:  .block
				stmts: or_stmts
				pos:   or_pos
				scope: or_scope
			}
			return true
		}
		ast.InfixExpr {
			if expr.op != .arrow || expr.or_block.kind == .block {
				return false
			}
			or_stmts, or_pos, or_scope := p.or_block(.with_err_var)
			expr.or_block = ast.OrExpr{
				kind:  .block
				stmts: or_stmts
				pos:   or_pos
				scope: or_scope
			}
			return true
		}
		ast.ParExpr {
			return p.attach_or_block_to_parenthesized_expr(mut expr.expr)
		}
		ast.PrefixExpr {
			if expr.op != .arrow || expr.or_block.kind == .block {
				return false
			}
			or_stmts, or_pos, or_scope := p.or_block(.with_err_var)
			expr.or_block = ast.OrExpr{
				kind:  .block
				stmts: or_stmts
				pos:   or_pos
				scope: or_scope
			}
			return true
		}
		ast.SelectorExpr {
			if expr.or_block.kind == .block {
				return false
			}
			or_stmts, or_pos, or_scope := p.or_block(.with_err_var)
			expr.or_block = ast.OrExpr{
				kind:  .block
				stmts: or_stmts
				pos:   or_pos
				scope: or_scope
			}
			return true
		}
		else {
			return false
		}
	}
}

fn (mut p Parser) infix_expr(left ast.Expr) ast.Expr {
	prev_inside_infix := p.inside_infix
	p.inside_infix = true
	defer {
		p.inside_infix = prev_inside_infix
	}
	op := p.tok.kind
	if op == .arrow {
		p.or_is_handled = true
		p.register_auto_import('sync')
	} else if op == .power {
		p.register_auto_import('math')
	}
	precedence := p.tok.kind.precedence()
	mut pos := p.tok.pos()
	p.next()
	if p.inside_if_cond {
		p.if_cond_comments << p.eat_comments()
	}
	mut before_op_comments := []ast.Comment{}
	if p.pref.is_fmt && p.left_comments.len > 0 {
		before_op_comments = p.left_comments.clone()
		p.left_comments = []
	}
	p.left_comments = []
	after_op_comments := p.eat_comments()
	mut right := ast.empty_expr
	prev_expecting_type := p.expecting_type
	if op in [.key_is, .not_is] {
		p.expecting_type = true
	}
	is_key_in := op in [.key_in, .not_in]
	if is_key_in {
		p.inside_in_array = true
	}

	right_op_pos := p.tok.pos()
	old_assign_rhs := p.inside_assign_rhs
	if op in [.decl_assign, .assign] {
		p.inside_assign_rhs = true
	}
	if p.inside_match_case && p.tok.kind == .lcbr {
		// In a match branch, a bare `{` opens the branch body; it is not the rhs of
		// the infix operator.
		p.unexpected(prepend_msg: 'invalid expression:')
	} else {
		right = p.expr(if op == .power { precedence - 1 } else { precedence })
	}
	p.inside_assign_rhs = old_assign_rhs
	// Keep rejecting doubled operator forms like `5 - - -5`, but allow valid
	// infix rhs expressions such as `a == -(-2)` and `a == +2`.
	if op in [.plus, .minus, .mul] && mut right is ast.PrefixExpr {
		mut right_expr := right.right
		right_expr = right_expr.remove_par()
		if right.op == op && right_expr.is_pure_literal() {
			p.error_with_pos('invalid expression: unexpected token `${op}`', right_op_pos)
		}
	}
	if is_key_in {
		if p.tok.kind == .dotdot {
			p.check(.dotdot)
			pos_high := p.tok.pos()
			right = ast.RangeExpr{
				low:      right
				has_low:  true
				high:     p.expr(int(token.Precedence.in_as))
				has_high: true
				pos:      pos_high
				is_gated: false
			}
		}
		p.inside_in_array = false
	}
	p.expecting_type = prev_expecting_type
	mut or_stmts := []ast.Stmt{}
	mut or_kind := ast.OrKind.absent
	mut or_pos := p.tok.pos()
	mut or_scope := ast.empty_scope
	// allow `x := <-ch or {...}` to handle closed channel
	if op == .arrow {
		if mut right is ast.SelectorExpr {
			or_kind = right.or_block.kind
			or_stmts = right.or_block.stmts.clone()
			right.or_block = ast.OrExpr{}
		}
		if mut right is ast.CallExpr {
			or_kind = right.or_block.kind
			or_stmts = right.or_block.stmts.clone()
			or_scope = right.or_block.scope
			right.or_block = ast.OrExpr{}
		}
		if p.tok.kind == .key_orelse {
			or_kind = .block
			or_stmts, or_pos, or_scope = p.or_block(.with_err_var)
		}
		if p.tok.kind == .question {
			p.next()
			or_kind = .propagate_option
			or_scope = p.scope
		}
		p.or_is_handled = false
	}
	pos.update_last_line(p.prev_tok.line_nr)
	return ast.InfixExpr{
		left:               left
		right:              right
		op:                 op
		pos:                pos
		is_stmt:            p.is_stmt_ident
		before_op_comments: before_op_comments
		after_op_comments:  after_op_comments
		or_block:           ast.OrExpr{
			stmts: or_stmts
			kind:  or_kind
			pos:   or_pos
			scope: or_scope
		}
	}
}

fn (p &Parser) fileis(s string) bool {
	return p.file_path.contains(s)
}

fn (mut p Parser) prefix_expr() ast.Expr {
	mut pos := p.tok.pos()
	is_option := p.tok.kind == .question
	if is_option {
		p.next()
	}
	op := p.tok.kind
	if op == .amp {
		p.is_amp = true
	}
	if op == .arrow {
		p.or_is_handled = true
		p.register_auto_import('sync')
	}
	// if op == .mul && !p.inside_unsafe {
	// p.warn('unsafe')
	// }
	p.next()
	mut right := p.expr(int(token.Precedence.prefix))
	p.is_amp = false
	if op == .amp {
		if mut right is ast.CastExpr {
			// Handle &Type(x), as well as &&Type(x) etc:
			p.recast_as_pointer(mut right, pos)
			if is_option {
				right.typ = right.typ.set_flag(.option)
			}
			return right
		}
		if mut right is ast.SelectorExpr {
			// Handle &Type(x).name :
			if mut right.expr is ast.CastExpr {
				p.recast_as_pointer(mut right.expr, pos)
				return right
			}
		}
		if mut right is ast.IndexExpr {
			// Handle &u64(x)[idx] :
			if mut right.left is ast.CastExpr {
				p.recast_as_pointer(mut right.left, pos)
				return right
			}
		}
		mut unwrapped_right := ast.Expr(ast.EmptyExpr{})
		if mut right is ast.ParExpr {
			if right.expr is ast.StructInit {
				p.note_with_pos('unnecessary `()`, use `&${ast.Expr(right.expr)}` instead of `&(${ast.Expr(right.expr)})`',
					right.pos)
				unwrapped_right = right.expr
			}
		}
		if unwrapped_right !is ast.EmptyExpr {
			right = unwrapped_right
		}
		if mut right is ast.TypeNode {
			right.typ = right.typ.ref()
			return right
		}
	}
	mut or_stmts := []ast.Stmt{}
	mut or_kind := ast.OrKind.absent
	mut or_pos := p.tok.pos()
	mut or_scope := ast.empty_scope
	// allow `x := <-ch or {...}` to handle closed channel
	if op == .arrow {
		if mut right is ast.SelectorExpr {
			or_kind = right.or_block.kind
			or_stmts = right.or_block.stmts.clone()
			right.or_block = ast.OrExpr{}
		} else if p.tok.kind == .key_orelse {
			or_kind = .block
			or_stmts, or_pos, or_scope = p.or_block(.with_err_var)
		} else if p.tok.kind == .question {
			p.next()
			or_kind = .propagate_option
			or_scope = p.scope
		}
		p.or_is_handled = false
	}
	pos.update_last_line(p.prev_tok.line_nr)
	return ast.PrefixExpr{
		op:       op
		right:    right
		pos:      pos
		or_block: ast.OrExpr{
			stmts: or_stmts
			kind:  or_kind
			pos:   or_pos
			scope: or_scope
		}
	}
}

fn (mut p Parser) power_prefix_expr() ast.Expr {
	pos := p.tok.pos()
	p.next()
	mut right := p.expr(int(token.Precedence.prefix))
	for _ in 0 .. 2 {
		right = ast.PrefixExpr{
			op:    .mul
			right: right
			pos:   pos
		}
	}
	return right
}

fn (mut p Parser) recast_as_pointer(mut cast_expr ast.CastExpr, pos token.Pos) {
	cast_expr.typ = cast_expr.typ.ref()
	cast_expr.typname = if cast_expr.typ == 0 {
		p.table.sym(cast_expr.typ).name
	} else {
		'unknown type name'
	}
	cast_expr.pos = pos.extend(cast_expr.pos)
}

// prefix_inc_dec_error reports an error for a prefix increment or decrement.
// prefix increments and decrements are not allowed in V.
fn (mut p Parser) prefix_inc_dec_error() {
	op := if p.tok.kind == .inc { '++' } else { '--' }
	op_pos := p.tok.pos()

	p.next()
	expr := p.expr(0) // expression `mp["name"]` after `--` in `--mp["name"]`
	full_expr_pos := op_pos.extend(expr.pos()) // position of full `--mp["name"]`

	p.error_with_pos('prefix `${op}${expr}` is unsupported, use suffix form `${expr}${op}`',
		full_expr_pos)
}

// process_custom_orm_operators checks whether a word in infix expressions is an ORM operator.
// If it is, then a new kind is assigned to it, so that the parser will process it as a keyword.
// This is necessary to ensure that parts of the ORM expression do not function
// outside of the ORM and are not recognized as keywords in the language.
// For example, there is a `like` operator in ORM, which should be used
// in expressions like `name like 'M%'`, but it should not be used in V directly.
@[inline]
fn (mut p Parser) process_custom_orm_operators() {
	if !p.inside_orm {
		return
	}

	is_like_operator := p.tok.kind == .name && p.tok.lit == 'like'
	is_ilike_operator := p.tok.kind == .name && p.tok.lit == 'ilike'

	if is_like_operator {
		p.tok = token.Token{
			...p.tok
			kind: .key_like
		}
	} else if is_ilike_operator {
		p.tok = token.Token{
			...p.tok
			kind: .key_ilike
		}
	}
}

fn (mut p Parser) lambda_expr() ?ast.LambdaExpr {
	// a) `f(||expr)` for a callback lambda expression with 0 arguments
	// b) `f(|a_1,...,a_n| expr_with_a_1_etc_till_a_n)` for a callback with several arguments
	if !(p.tok.kind == .logical_or
		|| (p.peek_token(1).kind == .key_mut && p.peek_token(2).kind == .name)
		|| (p.peek_token(1).kind == .name && p.peek_token(2).kind == .pipe)
		|| (p.peek_token(1).kind == .name && p.peek_token(2).kind == .comma)) {
		return none
	}

	p.open_scope()
	defer {
		p.close_scope()
	}
	p.scope.detached_from_parent = true

	mut pos := p.tok.pos()
	mut params := []ast.Ident{}
	if p.tok.kind == .logical_or {
		p.check(.logical_or)
	} else {
		p.check(.pipe)
		for {
			if p.tok.kind == .eof {
				break
			}
			ident := p.ident(.v)
			if p.scope.known_var(ident.name) {
				p.error_with_pos('redefinition of parameter `${ident.name}`', ident.pos)
			}
			params << ident

			p.scope.register(ast.Var{
				name:         ident.name
				is_mut:       p.scope_var_is_mut(ident.is_mut)
				is_stack_obj: true
				pos:          ident.pos
				is_used:      true
				is_arg:       true
			})

			if p.tok.kind == .pipe {
				p.next()
				break
			}
			p.check(.comma)
		}
	}
	pos_expr := p.tok.pos()
	e := p.expr(0)
	pos_end := p.tok.pos()
	return ast.LambdaExpr{
		pos:      pos.extend(e.pos())
		pos_expr: pos_expr
		pos_end:  pos_end
		params:   params
		expr:     e
		scope:    p.scope
	}
}