TheCloud/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2025-08-05 18:57:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

parser,ast,checker,cgen: use enum comparisons instead of string ones on ast.ComptimeCall.method_name (#25003)

Browse Source
This commit is contained in:
Delyan Angelov 2025-07-30 13:59:36 +03:00 committed by GitHub
parent cd94cff219
commit b876644e82
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 88 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/tools/vast/vast.v
View File

@ -1072,13 +1072,13 @@ fn (t Tree) comptime_call(node ast.ComptimeCall) &Node {
mut obj := create_object() mut obj := create_object()
obj.add_terse('ast_type', t.string_node('ComptimeCall')) obj.add_terse('ast_type', t.string_node('ComptimeCall'))
obj.add_terse('method_name', t.string_node(node.method_name)) obj.add_terse('method_name', t.string_node(node.method_name))
obj.add_terse('kind', t.enum_node(node.kind))
obj.add_terse('left', t.expr(node.left)) obj.add_terse('left', t.expr(node.left))
obj.add_terse('is_vweb', t.bool_node(node.is_vweb)) obj.add_terse('is_vweb', t.bool_node(node.is_vweb))
obj.add_terse('is_veb', t.bool_node(node.is_veb)) obj.add_terse('is_veb', t.bool_node(node.is_veb))
obj.add_terse('veb_tmpl', t.string_node(node.veb_tmpl.path)) obj.add_terse('veb_tmpl', t.string_node(node.veb_tmpl.path))
obj.add_terse('args_var', t.string_node(node.args_var)) obj.add_terse('args_var', t.string_node(node.args_var))
obj.add_terse('has_parens', t.bool_node(node.has_parens)) obj.add_terse('has_parens', t.bool_node(node.has_parens))
obj.add_terse('is_embed', t.bool_node(node.is_embed))
obj.add_terse('embed_file', t.embed_file(node.embed_file)) obj.add_terse('embed_file', t.embed_file(node.embed_file))
obj.add('method_pos', t.pos(node.method_pos)) obj.add('method_pos', t.pos(node.method_pos))
obj.add_terse('left_type', t.type_node(node.left_type)) obj.add_terse('left_type', t.type_node(node.left_type))

23
vlib/v/ast/ast.v
View File

@ -2050,21 +2050,32 @@ pub mut:
typ_key string // `f.typ` cached key for type resolver typ_key string // `f.typ` cached key for type resolver
} }
pub enum ComptimeCallKind {
unknown
d
env
res
html
tmpl
method
pkgconfig
embed_file
compile_warn
compile_error
}
@[minify] @[minify]
pub struct ComptimeCall { pub struct ComptimeCall {
pub: pub:
pos token.Pos pos token.Pos
has_parens bool // if $() is used, for vfmt has_parens bool // if $() is used, for vfmt
method_name string method_name string
kind ComptimeCallKind
method_pos token.Pos method_pos token.Pos
scope &Scope = unsafe { nil } scope &Scope = unsafe { nil }
is_vweb bool is_vweb bool
is_veb bool is_veb bool
is_embed bool // $embed_file(...)
is_env bool // $env(...) // TODO: deprecate after $d() is stable
is_compile_value bool // $d(...)
env_pos token.Pos env_pos token.Pos
is_pkgconfig bool
mut: mut:
is_d_resolved bool is_d_resolved bool
pub mut: pub mut:
@ -2087,7 +2098,7 @@ pub fn (mut cc ComptimeCall) resolve_compile_value(compile_values map[string]str
if cc.is_d_resolved { if cc.is_d_resolved {
return return
} }
if !cc.is_compile_value { if cc.kind != .d {
return error('ComptimeCall is not \$d()') return error('ComptimeCall is not \$d()')
} }
arg := cc.args[0] or { arg := cc.args[0] or {
@ -2109,7 +2120,7 @@ pub fn (mut cc ComptimeCall) resolve_compile_value(compile_values map[string]str
// `ast.Expr`'s `str()' method (used by e.g. vfmt). // `ast.Expr`'s `str()' method (used by e.g. vfmt).
pub fn (cc ComptimeCall) expr_str() string { pub fn (cc ComptimeCall) expr_str() string {
mut str := 'ast.ComptimeCall' mut str := 'ast.ComptimeCall'
if cc.is_compile_value { if cc.kind == .d {
arg := cc.args[0] or { return str } arg := cc.args[0] or { return str }
if arg.expr.is_pure_literal() { if arg.expr.is_pure_literal() {
str = "\$${cc.method_name}('${cc.args_var}', ${arg})" str = "\$${cc.method_name}('${cc.args_var}', ${arg})"

2
vlib/v/checker/checker.v
View File

@ -4669,7 +4669,7 @@ fn (mut c Checker) find_obj_definition(obj ast.ScopeObject) !ast.Expr {
if mut expr is ast.Ident { if mut expr is ast.Ident {
return c.find_definition(expr) return c.find_definition(expr)
} }
if mut expr is ast.ComptimeCall && expr.is_compile_value { if mut expr is ast.ComptimeCall && expr.kind == .d {
if expr.result_type == ast.bool_type { if expr.result_type == ast.bool_type {
return ast.BoolLiteral{ return ast.BoolLiteral{
val: expr.compile_value.bool() val: expr.compile_value.bool()

18
vlib/v/checker/comptime.v
View File

@ -15,14 +15,14 @@ fn (mut c Checker) comptime_call(mut node ast.ComptimeCall) ast.Type {
if node.left !is ast.EmptyExpr { if node.left !is ast.EmptyExpr {
node.left_type = c.expr(mut node.left) node.left_type = c.expr(mut node.left)
} }
if node.method_name == 'compile_error' { if node.kind == .compile_error {
c.error(c.comptime_call_msg(node), node.pos) c.error(c.comptime_call_msg(node), node.pos)
return ast.void_type return ast.void_type
} else if node.method_name == 'compile_warn' { } else if node.kind == .compile_warn {
c.warn(c.comptime_call_msg(node), node.pos) c.warn(c.comptime_call_msg(node), node.pos)
return ast.void_type return ast.void_type
} }
if node.is_env { if node.kind == .env {
env_value := util.resolve_env_value("\$env('${node.args_var}')", false) or { env_value := util.resolve_env_value("\$env('${node.args_var}')", false) or {
c.error(err.msg(), node.env_pos) c.error(err.msg(), node.env_pos)
return ast.string_type return ast.string_type
@ -30,14 +30,14 @@ fn (mut c Checker) comptime_call(mut node ast.ComptimeCall) ast.Type {
node.env_value = env_value node.env_value = env_value
return ast.string_type return ast.string_type
} }
if node.is_compile_value { if node.kind == .d {
node.resolve_compile_value(c.pref.compile_values) or { node.resolve_compile_value(c.pref.compile_values) or {
c.error(err.msg(), node.pos) c.error(err.msg(), node.pos)
return ast.void_type return ast.void_type
} }
return node.result_type return node.result_type
} }
if node.is_embed { if node.kind == .embed_file {
if node.args.len == 1 { if node.args.len == 1 {
embed_arg := node.args[0] embed_arg := node.args[0]
mut raw_path := '' mut raw_path := ''
@ -111,7 +111,7 @@ fn (mut c Checker) comptime_call(mut node ast.ComptimeCall) ast.Type {
c.table.cur_fn = save_cur_fn c.table.cur_fn = save_cur_fn
} }
if node.method_name == 'html' { if node.kind == .html {
ret_sym := c.table.sym(c.table.cur_fn.return_type) ret_sym := c.table.sym(c.table.cur_fn.return_type)
if ret_sym.cname !in ['veb__Result', 'vweb__Result', 'x__vweb__Result'] { if ret_sym.cname !in ['veb__Result', 'vweb__Result', 'x__vweb__Result'] {
ct_call := if node.is_veb { 'veb' } else { 'vweb' } ct_call := if node.is_veb { 'veb' } else { 'vweb' }
@ -138,7 +138,7 @@ fn (mut c Checker) comptime_call(mut node ast.ComptimeCall) ast.Type {
c.stmts_ending_with_expression(mut node.or_block.stmts, c.expected_or_type) c.stmts_ending_with_expression(mut node.or_block.stmts, c.expected_or_type)
return c.type_resolver.get_type(node) return c.type_resolver.get_type(node)
} }
if node.method_name == 'res' { if node.kind == .res {
if !c.inside_defer { if !c.inside_defer {
c.error('`res` can only be used in defer blocks', node.pos) c.error('`res` can only be used in defer blocks', node.pos)
return ast.void_type return ast.void_type
@ -1096,7 +1096,7 @@ fn (mut c Checker) comptime_if_cond(mut cond ast.Expr, pos token.Pos) ComptimeBr
} }
} }
ast.ComptimeCall { ast.ComptimeCall {
if cond.is_pkgconfig { if cond.kind == .pkgconfig {
mut m := pkgconfig.main([cond.args_var]) or { mut m := pkgconfig.main([cond.args_var]) or {
c.error(err.msg(), cond.pos) c.error(err.msg(), cond.pos)
return .skip return .skip
@ -1104,7 +1104,7 @@ fn (mut c Checker) comptime_if_cond(mut cond ast.Expr, pos token.Pos) ComptimeBr
m.run() or { return .skip } m.run() or { return .skip }
return .eval return .eval
} }
if cond.is_compile_value { if cond.kind == .d {
t := c.expr(mut cond) t := c.expr(mut cond)
if t != ast.bool_type { if t != ast.bool_type {
c.error('inside \$if, only \$d() expressions that return bool are allowed', c.error('inside \$if, only \$d() expressions that return bool are allowed',

2
vlib/v/checker/containers.v
View File

@ -357,7 +357,7 @@ fn (mut c Checker) eval_array_fixed_sizes(mut size_expr ast.Expr, size int, elem
fixed_size = size_expr.val.int() fixed_size = size_expr.val.int()
} }
ast.ComptimeCall { ast.ComptimeCall {
if size_expr.is_compile_value { if size_expr.kind == .d {
size_expr.resolve_compile_value(c.pref.compile_values) or { size_expr.resolve_compile_value(c.pref.compile_values) or {
c.error(err.msg(), size_expr.pos) c.error(err.msg(), size_expr.pos)
} }

4
vlib/v/checker/return.v
View File

@ -208,7 +208,7 @@ fn (mut c Checker) return_stmt(mut node ast.Return) {
c.error('cannot use `${c.table.type_to_str(got_type)}` as ${c.error_type_name(exp_type)} in return argument', c.error('cannot use `${c.table.type_to_str(got_type)}` as ${c.error_type_name(exp_type)} in return argument',
exprv.pos()) exprv.pos())
} }
if exprv is ast.ComptimeCall && exprv.method_name == 'tmpl' if exprv is ast.ComptimeCall && exprv.kind == .tmpl
&& c.table.final_sym(exp_type).kind != .string { && c.table.final_sym(exp_type).kind != .string {
c.error('cannot use `string` as type `${c.table.type_to_str(exp_type)}` in return argument', c.error('cannot use `string` as type `${c.table.type_to_str(exp_type)}` in return argument',
exprv.pos) exprv.pos)
@ -351,7 +351,7 @@ fn has_top_return(stmts []ast.Stmt) bool {
return true return true
} }
} else if stmt.expr is ast.ComptimeCall { } else if stmt.expr is ast.ComptimeCall {
if stmt.expr.method_name == 'compile_error' { if stmt.expr.kind == .compile_error {
return true return true
} }
} else if stmt.expr is ast.LockExpr { } else if stmt.expr is ast.LockExpr {

2
vlib/v/checker/struct.v
View File

@ -244,7 +244,7 @@ fn (mut c Checker) struct_decl(mut node ast.StructDecl) {
if sym.info is ast.ArrayFixed && field.typ == field.default_expr_typ { if sym.info is ast.ArrayFixed && field.typ == field.default_expr_typ {
if sym.info.size_expr is ast.ComptimeCall { if sym.info.size_expr is ast.ComptimeCall {
// field [$d('x' ,2)]int = [1 ,2]! // field [$d('x' ,2)]int = [1 ,2]!
if sym.info.size_expr.method_name == 'd' { if sym.info.size_expr.kind == .d {
c.error('cannot initialize a fixed size array field that uses `\$d()` as size quantifier since the size may change via -d', c.error('cannot initialize a fixed size array field that uses `\$d()` as size quantifier since the size may change via -d',
field.default_expr.pos()) field.default_expr.pos())
} }

14
vlib/v/fmt/fmt.v
View File

@ -2247,7 +2247,7 @@ pub fn (mut f Fmt) chan_init(mut node ast.ChanInit) {
pub fn (mut f Fmt) comptime_call(node ast.ComptimeCall) { pub fn (mut f Fmt) comptime_call(node ast.ComptimeCall) {
if node.is_vweb { if node.is_vweb {
if node.method_name == 'html' { if node.kind == .html {
if node.args.len == 1 && node.args[0].expr is ast.StringLiteral { if node.args.len == 1 && node.args[0].expr is ast.StringLiteral {
if node.is_veb { if node.is_veb {
f.write('\$veb.html(') f.write('\$veb.html(')
@ -2270,7 +2270,7 @@ pub fn (mut f Fmt) comptime_call(node ast.ComptimeCall) {
} }
} else { } else {
match true { match true {
node.is_embed { node.kind == .embed_file {
f.write('\$embed_file(') f.write('\$embed_file(')
f.expr(node.args[0].expr) f.expr(node.args[0].expr)
if node.embed_file.compression_type != 'none' { if node.embed_file.compression_type != 'none' {
@ -2278,13 +2278,13 @@ pub fn (mut f Fmt) comptime_call(node ast.ComptimeCall) {
} }
f.write(')') f.write(')')
} }
node.is_env { node.kind == .env {
f.write("\$env('${node.args_var}')") f.write("\$env('${node.args_var}')")
} }
node.is_pkgconfig { node.kind == .pkgconfig {
f.write("\$pkgconfig('${node.args_var}')") f.write("\$pkgconfig('${node.args_var}')")
} }
node.method_name in ['compile_error', 'compile_warn'] { node.kind in [.compile_error, .compile_warn] {
if node.args.len == 0 { if node.args.len == 0 {
if node.args_var.contains("'") { if node.args_var.contains("'") {
f.write('\$${node.method_name}("${node.args_var}")') f.write('\$${node.method_name}("${node.args_var}")')
@ -2297,12 +2297,12 @@ pub fn (mut f Fmt) comptime_call(node ast.ComptimeCall) {
f.write(')') f.write(')')
} }
} }
node.method_name == 'd' { node.kind == .d {
f.write("\$d('${node.args_var}', ") f.write("\$d('${node.args_var}', ")
f.expr(node.args[0].expr) f.expr(node.args[0].expr)
f.write(')') f.write(')')
} }
node.method_name == 'res' { node.kind == .res {
if node.args_var != '' { if node.args_var != '' {
f.write('\$res(${node.args_var})') f.write('\$res(${node.args_var})')
} else { } else {

14
vlib/v/gen/c/comptime.v
View File

@ -45,19 +45,19 @@ fn (mut g Gen) gen_comptime_selector(expr ast.ComptimeSelector) string {
} }
fn (mut g Gen) comptime_call(mut node ast.ComptimeCall) { fn (mut g Gen) comptime_call(mut node ast.ComptimeCall) {
if node.is_embed { if node.kind == .embed_file {
// $embed_file('/path/to/file') // $embed_file('/path/to/file')
g.gen_embed_file_init(mut node) g.gen_embed_file_init(mut node)
return return
} }
if node.method_name == 'env' { if node.kind == .env {
// $env('ENV_VAR_NAME') // $env('ENV_VAR_NAME')
// TODO: deprecate after support for $d() is stable // TODO: deprecate after support for $d() is stable
val := util.cescaped_path(os.getenv(node.args_var)) val := util.cescaped_path(os.getenv(node.args_var))
g.write('_S("${val}")') g.write('_S("${val}")')
return return
} }
if node.method_name == 'd' { if node.kind == .d {
// $d('some_string',<default value>), affected by `-d some_string=actual_value` // $d('some_string',<default value>), affected by `-d some_string=actual_value`
val := util.cescaped_path(node.compile_value) val := util.cescaped_path(node.compile_value)
if node.result_type == ast.string_type { if node.result_type == ast.string_type {
@ -69,7 +69,7 @@ fn (mut g Gen) comptime_call(mut node ast.ComptimeCall) {
} }
return return
} }
if node.method_name == 'res' { if node.kind == .res {
if node.args_var != '' { if node.args_var != '' {
g.write('${g.defer_return_tmp_var}.arg${node.args_var}') g.write('${g.defer_return_tmp_var}.arg${node.args_var}')
return return
@ -79,7 +79,7 @@ fn (mut g Gen) comptime_call(mut node ast.ComptimeCall) {
return return
} }
if node.is_vweb { if node.is_vweb {
is_html := node.method_name == 'html' is_html := node.kind == .html
mut cur_line := '' mut cur_line := ''
if !is_html { if !is_html {
@ -799,11 +799,11 @@ fn (mut g Gen) comptime_if_cond(cond ast.Expr, pkg_exist bool) (bool, bool) {
return true, false return true, false
} }
ast.ComptimeCall { ast.ComptimeCall {
if cond.method_name == 'pkgconfig' { if cond.kind == .pkgconfig {
g.write('${pkg_exist}') g.write('${pkg_exist}')
return true, false return true, false
} }
if cond.method_name == 'd' { if cond.kind == .d {
if cond.result_type == ast.bool_type { if cond.result_type == ast.bool_type {
if cond.compile_value == 'true' { if cond.compile_value == 'true' {
g.write('1') g.write('1')

4
vlib/v/gen/c/fn.v
View File

@ -1335,7 +1335,7 @@ fn (mut g Gen) gen_to_str_method_call(node ast.CallExpr) bool {
g.gen_expr_to_string(left_node, rec_type) g.gen_expr_to_string(left_node, rec_type)
return true return true
} else if left_node is ast.ComptimeCall { } else if left_node is ast.ComptimeCall {
if left_node.method_name == 'method' { if left_node.kind == .method {
sym := g.table.sym(g.unwrap_generic(left_node.left_type)) sym := g.table.sym(g.unwrap_generic(left_node.left_type))
if m := sym.find_method(g.comptime.comptime_for_method.name) { if m := sym.find_method(g.comptime.comptime_for_method.name) {
rec_type = m.return_type rec_type = m.return_type
@ -2069,7 +2069,7 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
typ = g.type_resolver.get_ct_type_or_default(expr.typ_key, typ) typ = g.type_resolver.get_ct_type_or_default(expr.typ_key, typ)
} }
} else if expr is ast.ComptimeCall { } else if expr is ast.ComptimeCall {
if expr.method_name == 'method' { if expr.kind == .method {
sym := g.table.sym(g.unwrap_generic(expr.left_type)) sym := g.table.sym(g.unwrap_generic(expr.left_type))
if m := sym.find_method(g.comptime.comptime_for_method.name) { if m := sym.find_method(g.comptime.comptime_for_method.name) {
typ = m.return_type typ = m.return_type

8
vlib/v/gen/golang/golang.v
View File

@ -1542,21 +1542,21 @@ pub fn (mut f Gen) chan_init(mut node ast.ChanInit) {
pub fn (mut f Gen) comptime_call(node ast.ComptimeCall) { pub fn (mut f Gen) comptime_call(node ast.ComptimeCall) {
if node.is_vweb { if node.is_vweb {
if node.method_name == 'html' { if node.kind == .html {
f.write('\$vweb.html()') f.write('\$vweb.html()')
} else { } else {
f.write("\$tmpl('${node.args_var}')") f.write("\$tmpl('${node.args_var}')")
} }
} else { } else {
if node.is_embed { if node.kind == .embed_file {
if node.embed_file.compression_type == 'none' { if node.embed_file.compression_type == 'none' {
f.write("\$embed_file('${node.embed_file.rpath}')") f.write("\$embed_file('${node.embed_file.rpath}')")
} else { } else {
f.write("\$embed_file('${node.embed_file.rpath}', .${node.embed_file.compression_type})") f.write("\$embed_file('${node.embed_file.rpath}', .${node.embed_file.compression_type})")
} }
} else if node.is_env { } else if node.kind == .env {
f.write("\$env('${node.args_var}')") f.write("\$env('${node.args_var}')")
} else if node.is_pkgconfig { } else if node.kind == .pkgconfig {
f.write("\$pkgconfig('${node.args_var}')") f.write("\$pkgconfig('${node.args_var}')")
} else { } else {
inner_args := if node.args_var != '' { inner_args := if node.args_var != '' {

2
vlib/v/markused/walker.v
View File

@ -476,7 +476,7 @@ fn (mut w Walker) expr(node_ ast.Expr) {
if node.is_vweb { if node.is_vweb {
w.stmts(node.veb_tmpl.stmts) w.stmts(node.veb_tmpl.stmts)
} }
if node.is_embed { if node.kind == .embed_file {
w.features.used_maps++ w.features.used_maps++
} }
} }

16
vlib/v/parser/comptime.v
View File

@ -123,6 +123,7 @@ const error_msg = 'only `\$tmpl()`, `\$env()`, `\$embed_file()`, `\$pkgconfig()`
fn (mut p Parser) comptime_call() ast.ComptimeCall { fn (mut p Parser) comptime_call() ast.ComptimeCall {
err_node := ast.ComptimeCall{ err_node := ast.ComptimeCall{
scope: unsafe { nil } scope: unsafe { nil }
kind: .unknown
} }
start_pos := p.tok.pos() start_pos := p.tok.pos()
p.check(.dollar) p.check(.dollar)
@ -163,12 +164,12 @@ fn (mut p Parser) comptime_call() ast.ComptimeCall {
s := p.tok.lit s := p.tok.lit
p.check(.string) p.check(.string)
p.check(.rpar) p.check(.rpar)
is_env := method_name == 'env'
return ast.ComptimeCall{ return ast.ComptimeCall{
scope: unsafe { nil } scope: unsafe { nil }
method_name: method_name method_name: method_name
kind: if is_env { .env } else { .pkgconfig }
args_var: s args_var: s
is_env: method_name == 'env'
is_pkgconfig: method_name == 'pkgconfig'
env_pos: start_pos env_pos: start_pos
pos: start_pos.extend(p.prev_tok.pos()) pos: start_pos.extend(p.prev_tok.pos())
} }
@ -189,6 +190,7 @@ fn (mut p Parser) comptime_call() ast.ComptimeCall {
return ast.ComptimeCall{ return ast.ComptimeCall{
scope: unsafe { nil } scope: unsafe { nil }
method_name: method_name method_name: method_name
kind: if method_name == 'compile_error' { .compile_error } else { .compile_warn }
args_var: s args_var: s
env_pos: start_pos env_pos: start_pos
pos: start_pos.extend(p.prev_tok.pos()) pos: start_pos.extend(p.prev_tok.pos())
@ -207,6 +209,7 @@ fn (mut p Parser) comptime_call() ast.ComptimeCall {
return ast.ComptimeCall{ return ast.ComptimeCall{
scope: unsafe { nil } scope: unsafe { nil }
method_name: method_name method_name: method_name
kind: .res
args_var: type_index args_var: type_index
pos: start_pos.extend(p.prev_tok.pos()) pos: start_pos.extend(p.prev_tok.pos())
} }
@ -214,6 +217,7 @@ fn (mut p Parser) comptime_call() ast.ComptimeCall {
return ast.ComptimeCall{ return ast.ComptimeCall{
scope: unsafe { nil } scope: unsafe { nil }
method_name: method_name method_name: method_name
kind: .res
pos: start_pos.extend(p.prev_tok.pos()) pos: start_pos.extend(p.prev_tok.pos())
} }
} else if method_name == 'd' { } else if method_name == 'd' {
@ -231,8 +235,8 @@ fn (mut p Parser) comptime_call() ast.ComptimeCall {
p.check(.rpar) p.check(.rpar)
return ast.ComptimeCall{ return ast.ComptimeCall{
scope: unsafe { nil } scope: unsafe { nil }
is_compile_value: true
method_name: method_name method_name: method_name
kind: .d
args_var: const_string args_var: const_string
args: args args: args
pos: start_pos.extend(p.prev_tok.pos()) pos: start_pos.extend(p.prev_tok.pos())
@ -281,7 +285,8 @@ fn (mut p Parser) comptime_call() ast.ComptimeCall {
} }
return ast.ComptimeCall{ return ast.ComptimeCall{
scope: unsafe { nil } scope: unsafe { nil }
is_embed: true method_name: method_name
kind: .embed_file
embed_file: ast.EmbeddedFile{ embed_file: ast.EmbeddedFile{
compression_type: embed_compression_type compression_type: embed_compression_type
} }
@ -324,6 +329,7 @@ fn (mut p Parser) comptime_call() ast.ComptimeCall {
is_vweb: true is_vweb: true
is_veb: is_veb is_veb: is_veb
method_name: method_name method_name: method_name
kind: if is_html { .html } else { .tmpl }
args_var: literal_string_param args_var: literal_string_param
args: [arg] args: [arg]
pos: start_pos.extend(p.prev_tok.pos()) pos: start_pos.extend(p.prev_tok.pos())
@ -371,6 +377,7 @@ fn (mut p Parser) comptime_call() ast.ComptimeCall {
is_veb: is_veb is_veb: is_veb
veb_tmpl: file veb_tmpl: file
method_name: method_name method_name: method_name
kind: if is_html { .html } else { .tmpl }
args_var: literal_string_param args_var: literal_string_param
args: [arg] args: [arg]
pos: start_pos.extend(p.prev_tok.pos()) pos: start_pos.extend(p.prev_tok.pos())
@ -537,6 +544,7 @@ fn (mut p Parser) comptime_selector(left ast.Expr) ast.Expr {
return ast.ComptimeCall{ return ast.ComptimeCall{
left: left left: left
method_name: method_name method_name: method_name
kind: .method
method_pos: method_pos method_pos: method_pos
scope: p.scope scope: p.scope
args_var: '' args_var: ''

2
vlib/v/parser/parse_type.v
View File

@ -27,7 +27,7 @@ fn (mut p Parser) parse_array_type(expecting token.Kind, is_option bool) ast.Typ
size_unresolved = false size_unresolved = false
} }
ast.ComptimeCall { ast.ComptimeCall {
if size_expr.is_compile_value { if size_expr.kind == .d {
size_expr.resolve_compile_value(p.pref.compile_values) or { size_expr.resolve_compile_value(p.pref.compile_values) or {
p.error_with_pos(err.msg(), size_expr.pos) p.error_with_pos(err.msg(), size_expr.pos)
} }