vieter-v
/
v
2
0
Fork 0
Code Issues Pull Requests Releases Activity

all: cleanup/rename all `comp_` names to be `comptime_` (#12467)

pull/12474/head
yuyi 2021-11-15 21:47:29 +08:00 committed by GitHub
parent 1d003228cb
commit c28041cecc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 115 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -405,7 +405,7 @@ fn (t Tree) stmt(node ast.Stmt) &Node {
ast.EnumDecl { return t.enum_decl(node) }
ast.InterfaceDecl { return t.interface_decl(node) }
ast.HashStmt { return t.hash_stmt(node) }
ast.CompFor { return t.comp_for(node) }
ast.CompFor { return t.comptime_for(node) }
ast.GlobalDecl { return t.global_decl(node) }
ast.DeferStmt { return t.defer_stmt(node) }
ast.TypeDecl { return t.type_decl(node) }
@ -700,7 +700,7 @@ fn (t Tree) hash_stmt(node ast.HashStmt) &Node {
return obj
}
fn (t Tree) comp_for(node ast.CompFor) &Node {
fn (t Tree) comptime_for(node ast.CompFor) &Node {
mut obj := new_object()
obj.add('ast_type', t.string_node('CompFor'))
obj.add('val_var', t.string_node(node.val_var))

2
vlib/builtin/js/string_test.js.v
View File

@ -764,7 +764,7 @@ fn test_c_r() {
println('$r')
}
fn test_inter_before_comp_if() {
fn test_inter_before_comptime_if() {
s := '123'
// This used to break ('123 $....')
$if linux {

2
vlib/builtin/string_test.v
View File

@ -781,7 +781,7 @@ fn test_c_r() {
println('$r')
}
fn test_inter_before_comp_if() {
fn test_inter_before_comptime_if() {
s := '123'
// This used to break ('123 $....')
$if linux {

70
vlib/v/checker/checker.v
View File

@ -20,29 +20,29 @@ const int_min = int(0x80000000)
const int_max = int(0x7FFFFFFF)
const (
valid_comp_if_os = ['windows', 'ios', 'macos', 'mach', 'darwin', 'hpux', 'gnu',
valid_comptime_if_os = ['windows', 'ios', 'macos', 'mach', 'darwin', 'hpux', 'gnu',
'qnx', 'linux', 'freebsd', 'openbsd', 'netbsd', 'bsd', 'dragonfly', 'android', 'solaris',
'haiku', 'serenity', 'vinix']
valid_comp_if_compilers = ['gcc', 'tinyc', 'clang', 'mingw', 'msvc', 'cplusplus']
valid_comp_if_platforms = ['amd64', 'i386', 'aarch64', 'arm64', 'arm32', 'rv64', 'rv32']
valid_comp_if_cpu_features = ['x64', 'x32', 'little_endian', 'big_endian']
valid_comp_if_other = ['js', 'debug', 'prod', 'test', 'glibc', 'prealloc',
valid_comptime_if_compilers = ['gcc', 'tinyc', 'clang', 'mingw', 'msvc', 'cplusplus']
valid_comptime_if_platforms = ['amd64', 'i386', 'aarch64', 'arm64', 'arm32', 'rv64', 'rv32']
valid_comptime_if_cpu_features = ['x64', 'x32', 'little_endian', 'big_endian']
valid_comptime_if_other = ['js', 'debug', 'prod', 'test', 'glibc', 'prealloc',
'no_bounds_checking', 'freestanding', 'threads', 'js_node', 'js_browser', 'js_freestanding']
valid_comp_not_user_defined = all_valid_comptime_idents()
array_builtin_methods = ['filter', 'clone', 'repeat', 'reverse', 'map', 'slice', 'sort',
'contains', 'index', 'wait', 'any', 'all', 'first', 'last', 'pop']
reserved_type_names = ['bool', 'i8', 'i16', 'int', 'i64', 'byte', 'u16', 'u32', 'u64',
'f32', 'f64', 'string', 'rune']
valid_comptime_not_user_defined = all_valid_comptime_idents()
array_builtin_methods = ['filter', 'clone', 'repeat', 'reverse', 'map', 'slice',
'sort', 'contains', 'index', 'wait', 'any', 'all', 'first', 'last', 'pop']
reserved_type_names = ['bool', 'i8', 'i16', 'int', 'i64', 'byte', 'u16', 'u32',
'u64', 'f32', 'f64', 'string', 'rune']
vroot_is_deprecated_message = '@VROOT is deprecated, use @VMODROOT or @VEXEROOT instead'
)
fn all_valid_comptime_idents() []string {
mut res := []string{}
res << checker.valid_comp_if_os
res << checker.valid_comp_if_compilers
res << checker.valid_comp_if_platforms
res << checker.valid_comp_if_cpu_features
res << checker.valid_comp_if_other
res << checker.valid_comptime_if_os
res << checker.valid_comptime_if_compilers
res << checker.valid_comptime_if_platforms
res << checker.valid_comptime_if_cpu_features
res << checker.valid_comptime_if_other
return res
}
@ -4596,7 +4596,7 @@ fn (mut c Checker) stmt(node ast.Stmt) {
c.branch_stmt(node)
}
ast.CompFor {
c.comp_for(node)
c.comptime_for(node)
}
ast.ConstDecl {
c.inside_const = true
@ -4614,7 +4614,7 @@ fn (mut c Checker) stmt(node ast.Stmt) {
for i, ident in node.defer_vars {
mut id := ident
if id.info is ast.IdentVar {
if id.comptime && id.name in checker.valid_comp_not_user_defined {
if id.comptime && id.name in checker.valid_comptime_not_user_defined {
node.defer_vars[i] = ast.Ident{
scope: 0
name: ''
@ -4772,7 +4772,7 @@ fn (mut c Checker) for_c_stmt(node ast.ForCStmt) {
c.in_for_count--
}
fn (mut c Checker) comp_for(node ast.CompFor) {
fn (mut c Checker) comptime_for(node ast.CompFor) {
typ := c.unwrap_generic(node.typ)
sym := c.table.get_type_symbol(typ)
if sym.kind == .placeholder || typ.has_flag(.generic) {
@ -6725,7 +6725,7 @@ pub fn (mut c Checker) if_expr(mut node ast.IfExpr) ast.Type {
}
if !node.has_else || i < node.branches.len - 1 {
if node.is_comptime {
should_skip = c.comp_if_branch(branch.cond, branch.pos)
should_skip = c.comptime_if_branch(branch.cond, branch.pos)
node.branches[i].pkg_exist = !should_skip
} else {
// check condition type is boolean
@ -6922,22 +6922,22 @@ pub fn (mut c Checker) if_expr(mut node ast.IfExpr) ast.Type {
return node.typ
}
// comp_if_branch checks the condition of a compile-time `if` branch. It returns `true`
// comptime_if_branch checks the condition of a compile-time `if` branch. It returns `true`
// if that branch's contents should be skipped (targets a different os for example)
fn (mut c Checker) comp_if_branch(cond ast.Expr, pos token.Position) bool {
fn (mut c Checker) comptime_if_branch(cond ast.Expr, pos token.Position) bool {
// TODO: better error messages here
match cond {
ast.BoolLiteral {
return !cond.val
}
ast.ParExpr {
return c.comp_if_branch(cond.expr, pos)
return c.comptime_if_branch(cond.expr, pos)
}
ast.PrefixExpr {
if cond.op != .not {
c.error('invalid `\$if` condition', cond.pos)
}
return !c.comp_if_branch(cond.right, cond.pos)
return !c.comptime_if_branch(cond.right, cond.pos)
}
ast.PostfixExpr {
if cond.op != .question {
@ -6951,13 +6951,13 @@ fn (mut c Checker) comp_if_branch(cond ast.Expr, pos token.Position) bool {
ast.InfixExpr {
match cond.op {
.and {
l := c.comp_if_branch(cond.left, cond.pos)
r := c.comp_if_branch(cond.right, cond.pos)
l := c.comptime_if_branch(cond.left, cond.pos)
r := c.comptime_if_branch(cond.right, cond.pos)
return l || r // skip (return true) if at least one should be skipped
}
.logical_or {
l := c.comp_if_branch(cond.left, cond.pos)
r := c.comp_if_branch(cond.right, cond.pos)
l := c.comptime_if_branch(cond.left, cond.pos)
r := c.comptime_if_branch(cond.right, cond.pos)
return l && r // skip (return true) only if both should be skipped
}
.key_is, .not_is {
@ -7011,16 +7011,16 @@ fn (mut c Checker) comp_if_branch(cond ast.Expr, pos token.Position) bool {
}
ast.Ident {
cname := cond.name
if cname in checker.valid_comp_if_os {
if cname in checker.valid_comptime_if_os {
mut is_os_target_different := false
if !c.pref.output_cross_c {
target_os := c.pref.os.str().to_lower()
is_os_target_different = cname != target_os
}
return is_os_target_different
} else if cname in checker.valid_comp_if_compilers {
} else if cname in checker.valid_comptime_if_compilers {
return pref.cc_from_string(cname) != c.pref.ccompiler_type
} else if cname in checker.valid_comp_if_platforms {
} else if cname in checker.valid_comptime_if_platforms {
if cname == 'aarch64' {
c.note('use `arm64` instead of `aarch64`', pos)
}
@ -7034,9 +7034,9 @@ fn (mut c Checker) comp_if_branch(cond ast.Expr, pos token.Position) bool {
'rv32' { return c.pref.arch != .rv32 }
else { return false }
}
} else if cname in checker.valid_comp_if_cpu_features {
} else if cname in checker.valid_comptime_if_cpu_features {
return false
} else if cname in checker.valid_comp_if_other {
} else if cname in checker.valid_comptime_if_other {
match cname {
'js' { return !c.pref.backend.is_js() }
'debug' { return !c.pref.is_debug }
@ -8020,7 +8020,7 @@ fn (mut c Checker) evaluate_once_comptime_if_attribute(mut node ast.Attr) bool {
}
if node.ct_expr is ast.Ident {
if node.ct_opt {
if node.ct_expr.name in checker.valid_comp_not_user_defined {
if node.ct_expr.name in checker.valid_comptime_not_user_defined {
c.error('optional `[if expression ?]` tags, can be used only for user defined identifiers',
node.pos)
node.ct_skip = true
@ -8030,7 +8030,7 @@ fn (mut c Checker) evaluate_once_comptime_if_attribute(mut node ast.Attr) bool {
node.ct_evaled = true
return node.ct_skip
} else {
if node.ct_expr.name !in checker.valid_comp_not_user_defined {
if node.ct_expr.name !in checker.valid_comptime_not_user_defined {
c.note('`[if $node.ct_expr.name]` is deprecated. Use `[if $node.ct_expr.name ?]` instead',
node.pos)
node.ct_skip = node.ct_expr.name !in c.pref.compile_defines
@ -8047,7 +8047,7 @@ fn (mut c Checker) evaluate_once_comptime_if_attribute(mut node ast.Attr) bool {
}
}
c.inside_ct_attr = true
node.ct_skip = c.comp_if_branch(node.ct_expr, node.pos)
node.ct_skip = c.comptime_if_branch(node.ct_expr, node.pos)
c.inside_ct_attr = false
node.ct_evaled = true
return node.ct_skip

4
vlib/v/fmt/fmt.v
View File

@ -431,7 +431,7 @@ pub fn (mut f Fmt) stmt(node ast.Stmt) {
f.branch_stmt(node)
}
ast.CompFor {
f.comp_for(node)
f.comptime_for(node)
}
ast.ConstDecl {
f.const_decl(node)
@ -762,7 +762,7 @@ pub fn (mut f Fmt) branch_stmt(node ast.BranchStmt) {
f.writeln(node.str())
}
pub fn (mut f Fmt) comp_for(node ast.CompFor) {
pub fn (mut f Fmt) comptime_for(node ast.CompFor) {
typ := f.no_cur_mod(f.table.type_to_str_using_aliases(node.typ, f.mod2alias))
f.write('\$for $node.val_var in ${typ}.$node.kind.str() {')
f.mark_types_import_as_used(node.typ)

32
vlib/v/gen/c/cgen.v
View File

@ -149,10 +149,10 @@ mut:
inside_call bool
has_main bool
inside_const bool
comp_for_method string // $for method in T.methods {}
comp_for_field_var string // $for field in T.fields {}; the variable name
comp_for_field_value ast.StructField // value of the field variable
comp_for_field_type ast.Type // type of the field variable inferred from `$if field.typ is T {}`
comptime_for_method string // $for method in T.methods {}
comptime_for_field_var string // $for field in T.fields {}; the variable name
comptime_for_field_value ast.StructField // value of the field variable
comptime_for_field_type ast.Type // type of the field variable inferred from `$if field.typ is T {}`
comptime_var_type_map map[string]ast.Type
// tmp_arg_vars_to_free []string
// autofree_pregen map[string]string
@ -1569,7 +1569,7 @@ fn (mut g Gen) stmt(node ast.Stmt) {
// }
}
ast.CompFor {
g.comp_for(node)
g.comptime_for(node)
}
ast.DeferStmt {
mut defer_stmt := node
@ -1689,7 +1689,7 @@ fn (mut g Gen) stmt(node ast.Stmt) {
if node.ct_conds.len > 0 {
ct_condition_start := g.out.len
for idx, ct_expr in node.ct_conds {
g.comp_if_cond(ct_expr, false)
g.comptime_if_cond(ct_expr, false)
if idx < node.ct_conds.len - 1 {
g.write(' && ')
}
@ -3720,7 +3720,7 @@ fn (mut g Gen) expr(node ast.Expr) {
g.assoc(node)
}
ast.AtExpr {
g.comp_at(node)
g.comptime_at(node)
}
ast.BoolLiteral {
g.write(node.val.str())
@ -3877,7 +3877,11 @@ fn (mut g Gen) expr(node ast.Expr) {
}
}
ast.IsRefType {
typ := if node.typ == g.field_data_type { g.comp_for_field_value.typ } else { node.typ }
typ := if node.typ == g.field_data_type {
g.comptime_for_field_value.typ
} else {
node.typ
}
node_typ := g.unwrap_generic(typ)
sym := g.table.get_type_symbol(node_typ)
if sym.language == .v && sym.kind in [.placeholder, .any] {
@ -3997,7 +4001,11 @@ fn (mut g Gen) expr(node ast.Expr) {
g.selector_expr(node)
}
ast.SizeOf {
typ := if node.typ == g.field_data_type { g.comp_for_field_value.typ } else { node.typ }
typ := if node.typ == g.field_data_type {
g.comptime_for_field_value.typ
} else {
node.typ
}
node_typ := g.unwrap_generic(typ)
sym := g.table.get_type_symbol(node_typ)
if sym.language == .v && sym.kind in [.placeholder, .any] {
@ -4046,7 +4054,7 @@ fn (mut g Gen) expr(node ast.Expr) {
// T.name, typeof(expr).name
fn (mut g Gen) type_name(raw_type ast.Type) {
typ := if raw_type == g.field_data_type { g.comp_for_field_value.typ } else { raw_type }
typ := if raw_type == g.field_data_type { g.comptime_for_field_value.typ } else { raw_type }
sym := g.table.get_type_symbol(typ)
mut s := ''
if sym.kind == .function {
@ -4063,7 +4071,7 @@ fn (mut g Gen) type_name(raw_type ast.Type) {
fn (mut g Gen) typeof_expr(node ast.TypeOf) {
typ := if node.expr_type == g.field_data_type {
g.comp_for_field_value.typ
g.comptime_for_field_value.typ
} else {
node.expr_type
}
@ -5181,7 +5189,7 @@ fn (mut g Gen) need_tmp_var_in_if(node ast.IfExpr) bool {
fn (mut g Gen) if_expr(node ast.IfExpr) {
if node.is_comptime {
g.comp_if(node)
g.comptime_if(node)
return
}
// For simpe if expressions we can use C's `?:`

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

@ -18,9 +18,9 @@ fn (mut g Gen) comptime_selector(node ast.ComptimeSelector) {
// check for field.name
if node.field_expr is ast.SelectorExpr {
if node.field_expr.expr is ast.Ident {
if node.field_expr.expr.name == g.comp_for_field_var
if node.field_expr.expr.name == g.comptime_for_field_var
&& node.field_expr.field_name == 'name' {
g.write(c_name(g.comp_for_field_value.name))
g.write(c_name(g.comptime_for_field_value.name))
return
}
}
@ -79,7 +79,7 @@ fn (mut g Gen) comptime_call(node ast.ComptimeCall) {
g.trace_autofree('// \$method call. sym="$node.sym.name"')
if node.method_name == 'method' {
// `app.$method()`
m := node.sym.find_method(g.comp_for_method) or { return }
m := node.sym.find_method(g.comptime_for_method) or { return }
/*
vals := m.attrs[0].split('/')
args := vals.filter(it.starts_with(':')).map(it[1..])
@ -107,7 +107,7 @@ fn (mut g Gen) comptime_call(node ast.ComptimeCall) {
return
}
// TODO: check argument types
g.write('${util.no_dots(node.sym.name)}_${g.comp_for_method}(')
g.write('${util.no_dots(node.sym.name)}_${g.comptime_for_method}(')
// try to see if we need to pass a pointer
if node.left is ast.Ident {
@ -192,7 +192,7 @@ fn cgen_attrs(attrs []ast.Attr) []string {
return res
}
fn (mut g Gen) comp_at(node ast.AtExpr) {
fn (mut g Gen) comptime_at(node ast.AtExpr) {
if node.kind == .vmod_file {
val := cnewlines(node.val.replace('\r', ''))
g.write('_SLIT("$val")')
@ -202,7 +202,7 @@ fn (mut g Gen) comp_at(node ast.AtExpr) {
}
}
fn (mut g Gen) comp_if(node ast.IfExpr) {
fn (mut g Gen) comptime_if(node ast.IfExpr) {
if !node.is_expr && !node.has_else && node.branches.len == 1 {
if node.branches[0].stmts.len == 0 {
// empty ifdef; result of target OS != conditional => skip
@ -231,7 +231,7 @@ fn (mut g Gen) comp_if(node ast.IfExpr) {
} else {
''
}
mut comp_if_stmts_skip := false // don't write any statements if the condition is false
mut comptime_if_stmts_skip := false // don't write any statements if the condition is false
// (so that for example windows calls don't get generated inside `$if macos` which
// will lead to compilation errors)
@ -239,14 +239,14 @@ fn (mut g Gen) comp_if(node ast.IfExpr) {
start_pos := g.out.len
if i == node.branches.len - 1 && node.has_else {
g.writeln('#else')
comp_if_stmts_skip = false
comptime_if_stmts_skip = false
} else {
if i == 0 {
g.write('#if ')
} else {
g.write('#elif ')
}
comp_if_stmts_skip = !g.comp_if_cond(branch.cond, branch.pkg_exist)
comptime_if_stmts_skip = !g.comptime_if_cond(branch.cond, branch.pkg_exist)
g.writeln('')
}
expr_str := g.out.last_n(g.out.len - start_pos).trim_space()
@ -278,7 +278,7 @@ fn (mut g Gen) comp_if(node ast.IfExpr) {
if should_create_scope {
g.writeln('{')
}
if !comp_if_stmts_skip {
if !comptime_if_stmts_skip {
g.stmts(branch.stmts)
}
if should_create_scope {
@ -294,7 +294,7 @@ fn (mut g Gen) comp_if(node ast.IfExpr) {
// returning `false` means the statements inside the $if can be skipped
*/
// returns the value of the bool comptime expression
fn (mut g Gen) comp_if_cond(cond ast.Expr, pkg_exist bool) bool {
fn (mut g Gen) comptime_if_cond(cond ast.Expr, pkg_exist bool) bool {
match cond {
ast.BoolLiteral {
g.expr(cond)
@ -302,16 +302,16 @@ fn (mut g Gen) comp_if_cond(cond ast.Expr, pkg_exist bool) bool {
}
ast.ParExpr {
g.write('(')
is_cond_true := g.comp_if_cond(cond.expr, pkg_exist)
is_cond_true := g.comptime_if_cond(cond.expr, pkg_exist)
g.write(')')
return is_cond_true
}
ast.PrefixExpr {
g.write(cond.op.str())
return g.comp_if_cond(cond.right, pkg_exist)
return g.comptime_if_cond(cond.right, pkg_exist)
}
ast.PostfixExpr {
ifdef := g.comp_if_to_ifdef((cond.expr as ast.Ident).name, true) or {
ifdef := g.comptime_if_to_ifdef((cond.expr as ast.Ident).name, true) or {
verror(err.msg)
return false
}
@ -321,9 +321,9 @@ fn (mut g Gen) comp_if_cond(cond ast.Expr, pkg_exist bool) bool {
ast.InfixExpr {
match cond.op {
.and, .logical_or {
l := g.comp_if_cond(cond.left, pkg_exist)
l := g.comptime_if_cond(cond.left, pkg_exist)
g.write(' $cond.op ')
r := g.comp_if_cond(cond.right, pkg_exist)
r := g.comptime_if_cond(cond.right, pkg_exist)
return if cond.op == .and { l && r } else { l || r }
}
.key_is, .not_is {
@ -390,7 +390,7 @@ fn (mut g Gen) comp_if_cond(cond ast.Expr, pkg_exist bool) bool {
}
}
ast.Ident {
ifdef := g.comp_if_to_ifdef(cond.name, false) or { 'true' } // handled in checker
ifdef := g.comptime_if_to_ifdef(cond.name, false) or { 'true' } // handled in checker
g.write('defined($ifdef)')
return true
}
@ -406,7 +406,7 @@ fn (mut g Gen) comp_if_cond(cond ast.Expr, pkg_exist bool) bool {
}
}
fn (mut g Gen) comp_for(node ast.CompFor) {
fn (mut g Gen) comptime_for(node ast.CompFor) {
sym := g.table.get_type_symbol(g.unwrap_generic(node.typ))
g.writeln('/* \$for $node.val_var in ${sym.name}($node.kind.str()) */ {')
g.indent++
@ -426,7 +426,7 @@ fn (mut g Gen) comp_for(node ast.CompFor) {
continue
}
*/
g.comp_for_method = method.name
g.comptime_for_method = method.name
g.writeln('/* method $i */ {')
g.writeln('\t${node.val_var}.name = _SLIT("$method.name");')
if method.attrs.len == 0 {
@ -499,8 +499,8 @@ fn (mut g Gen) comp_for(node ast.CompFor) {
g.writeln('\tFieldData $node.val_var = {0};')
}
for field in fields {
g.comp_for_field_var = node.val_var
g.comp_for_field_value = field
g.comptime_for_field_var = node.val_var
g.comptime_for_field_value = field
g.writeln('/* field $i */ {')
g.writeln('\t${node.val_var}.name = _SLIT("$field.name");')
if field.attrs.len == 0 {
@ -545,7 +545,7 @@ fn (mut g Gen) comp_for(node ast.CompFor) {
g.writeln('}// \$for')
}
fn (mut g Gen) comp_if_to_ifdef(name string, is_comptime_optional bool) ?string {
fn (mut g Gen) comptime_if_to_ifdef(name string, is_comptime_optional bool) ?string {
match name {
// platforms/os-es:
'windows' {

20
vlib/v/gen/js/comptime.v
View File

@ -3,7 +3,7 @@ module js
import v.ast
import v.pref
fn (mut g JsGen) comp_if(node ast.IfExpr) {
fn (mut g JsGen) comptime_if(node ast.IfExpr) {
if !node.is_expr && !node.has_else && node.branches.len == 1 {
if node.branches[0].stmts.len == 0 {
// empty ifdef; result of target OS != conditional => skip
@ -20,7 +20,7 @@ fn (mut g JsGen) comp_if(node ast.IfExpr) {
} else {
g.write('else if (')
}
g.comp_if_cond(branch.cond, branch.pkg_exist)
g.comptime_if_cond(branch.cond, branch.pkg_exist)
g.writeln(')')
}
@ -56,7 +56,7 @@ fn (mut g JsGen) comp_if(node ast.IfExpr) {
// returning `false` means the statements inside the $if can be skipped
*/
// returns the value of the bool comptime expression
fn (mut g JsGen) comp_if_cond(cond ast.Expr, pkg_exist bool) bool {
fn (mut g JsGen) comptime_if_cond(cond ast.Expr, pkg_exist bool) bool {
match cond {
ast.BoolLiteral {
g.expr(cond)
@ -64,16 +64,16 @@ fn (mut g JsGen) comp_if_cond(cond ast.Expr, pkg_exist bool) bool {
}
ast.ParExpr {
g.write('(')
is_cond_true := g.comp_if_cond(cond.expr, pkg_exist)
is_cond_true := g.comptime_if_cond(cond.expr, pkg_exist)
g.write(')')
return is_cond_true
}
ast.PrefixExpr {
g.write(cond.op.str())
return g.comp_if_cond(cond.right, pkg_exist)
return g.comptime_if_cond(cond.right, pkg_exist)
}
ast.PostfixExpr {
ifdef := g.comp_if_to_ifdef((cond.expr as ast.Ident).name, true) or {
ifdef := g.comptime_if_to_ifdef((cond.expr as ast.Ident).name, true) or {
verror(err.msg)
return false
}
@ -83,9 +83,9 @@ fn (mut g JsGen) comp_if_cond(cond ast.Expr, pkg_exist bool) bool {
ast.InfixExpr {
match cond.op {
.and, .logical_or {
l := g.comp_if_cond(cond.left, pkg_exist)
l := g.comptime_if_cond(cond.left, pkg_exist)
g.write(' $cond.op ')
r := g.comp_if_cond(cond.right, pkg_exist)
r := g.comptime_if_cond(cond.right, pkg_exist)
return if cond.op == .and { l && r } else { l || r }
}
.key_is, .not_is {
@ -152,7 +152,7 @@ fn (mut g JsGen) comp_if_cond(cond ast.Expr, pkg_exist bool) bool {
}
}
ast.Ident {
ifdef := g.comp_if_to_ifdef(cond.name, false) or { 'true' } // handled in checker
ifdef := g.comptime_if_to_ifdef(cond.name, false) or { 'true' } // handled in checker
g.write('$ifdef')
return true
}
@ -168,7 +168,7 @@ fn (mut g JsGen) comp_if_cond(cond ast.Expr, pkg_exist bool) bool {
}
}
fn (mut g JsGen) comp_if_to_ifdef(name string, is_comptime_optional bool) ?string {
fn (mut g JsGen) comptime_if_to_ifdef(name string, is_comptime_optional bool) ?string {
match name {
// platforms/os-es:
'windows' {

2
vlib/v/gen/js/js.v
View File

@ -2525,7 +2525,7 @@ fn (mut g JsGen) need_tmp_var_in_if(node ast.IfExpr) bool {
fn (mut g JsGen) gen_if_expr(node ast.IfExpr) {
if node.is_comptime {
g.comp_if(node)
g.comptime_if(node)
return
}
// For simpe if expressions we can use C's `?:`

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

@ -39,7 +39,7 @@ fn (mut p Parser) hash() ast.HashStmt {
}
}
fn (mut p Parser) comp_call() ast.ComptimeCall {
fn (mut p Parser) comptime_call() ast.ComptimeCall {
err_node := ast.ComptimeCall{
scope: 0
}
@ -232,8 +232,8 @@ fn (mut p Parser) comp_call() ast.ComptimeCall {
}
}
fn (mut p Parser) comp_for() ast.CompFor {
// p.comp_for() handles these special forms:
fn (mut p Parser) comptime_for() ast.CompFor {
// p.comptime_for() handles these special forms:
// $for method in App(methods) {
// $for field in App(fields) {
p.next()

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

@ -82,7 +82,7 @@ pub fn (mut p Parser) check_expr(precedence int) ?ast.Expr {
.dollar {
match p.peek_tok.kind {
.name {
return p.comp_call()
return p.comptime_call()
}
.key_if {
return p.if_expr(true)

4
vlib/v/parser/if_match.v
View File

@ -106,9 +106,9 @@ fn (mut p Parser) if_expr(is_comptime bool) ast.IfExpr {
prev_guard = true
} else {
prev_guard = false
p.comp_if_cond = true
p.comptime_if_cond = true
cond = p.expr(0)
p.comp_if_cond = false
p.comptime_if_cond = false
}
comments << p.eat_comments()
end_pos := p.prev_tok.position()

14
vlib/v/parser/parser.v
View File

@ -79,7 +79,7 @@ mut:
inside_asm bool
global_labels []string
inside_defer bool
comp_if_cond bool
comptime_if_cond bool
defer_vars []ast.Ident
should_abort bool // when too many errors/warnings/notices are accumulated, should_abort becomes true, and the parser should stop
}
@ -778,11 +778,11 @@ pub fn (mut p Parser) stmt(is_top_level bool) ast.Stmt {
}
}
.key_for {
return p.comp_for()
return p.comptime_for()
}
.name {
mut pos := p.tok.position()
expr := p.comp_call()
expr := p.comptime_call()
pos.update_last_line(p.prev_tok.line_nr)
return ast.ExprStmt{
expr: expr
@ -1566,11 +1566,11 @@ fn (mut p Parser) parse_attr() ast.Attr {
if p.tok.kind == .key_if {
kind = .comptime_define
p.next()
p.comp_if_cond = true
p.comptime_if_cond = true
p.inside_if_expr = true
p.inside_ct_if_expr = true
comptime_cond = p.expr(0)
p.comp_if_cond = false
p.comptime_if_cond = false
p.inside_if_expr = false
p.inside_ct_if_expr = false
if comptime_cond is ast.PostfixExpr {
@ -1862,7 +1862,7 @@ pub fn (mut p Parser) parse_ident(language ast.Language) ast.Ident {
return ast.Ident{
tok_kind: p.tok.kind
name: '_'
comptime: p.comp_if_cond
comptime: p.comptime_if_cond
kind: .blank_ident
pos: pos
info: ast.IdentVar{
@ -1883,7 +1883,7 @@ pub fn (mut p Parser) parse_ident(language ast.Language) ast.Ident {
tok_kind: p.tok.kind
kind: .unresolved
name: name
comptime: p.comp_if_cond
comptime: p.comptime_if_cond
language: language
mod: p.mod
pos: pos

2
vlib/v/tests/comptime_attribute_selector_test.v
View File

@ -3,7 +3,7 @@
[abc]
struct Abc {}
fn test_comp_for_attributes() {
fn test_comptime_for_attributes() {
mut res := ''
mut amount := 0
$for attr in Abc.attributes {

4
vlib/v/tests/valgrind/1.strings_and_arrays.v
View File

@ -339,7 +339,7 @@ fn string_array_get() {
println(s)
}
fn comp_if() {
fn comptime_if() {
// compif pos used to be 0, if it was the first statement in a block, vars wouldn't be freed
$if macos {
println('macos')
@ -398,7 +398,7 @@ fn main() {
q := if_expr()
s := return_if_expr()
free_inside_opt_block()
comp_if()
comptime_if()
free_before_return()
free_before_return_bool()
free_before_break()