comptime: support -d ident=value and var := $d('ident', 0) (#21685)

Author: larpon

CHANGELOG.md

@@ -1,3 +1,8 @@
+## V 0.4.7 (NEXT)
+
+#### Improvements in the language
+- comptime: add support for `-d ident=value` and retrieval in code via `$d('ident', <default value>)`.
+
 ## V 0.4.6
 *20 May 2024*
 

cmd/tools/vast/vast.v

@@ -1019,6 +1019,7 @@ fn (t Tree) comptime_call(node ast.ComptimeCall) &Node {
 	obj.add_terse('result_type', t.type_node(node.result_type))
 	obj.add('scope', t.scope(node.scope))
 	obj.add_terse('env_value', t.string_node(node.env_value))
+	obj.add_terse('compile_value', t.string_node(node.compile_value))
 	obj.add('pos', t.pos(node.pos))
 	obj.add_terse('args', t.array_node_call_arg(node.args))
 	obj.add_terse('or_block', t.or_expr(node.or_block))

doc/docs.md

@@ -6120,6 +6120,67 @@ V can bring in values at compile time from environment variables.
 `$env('ENV_VAR')` can also be used in top-level `#flag` and `#include` statements:
 `#flag linux -I $env('JAVA_HOME')/include`.
 
+#### `$d`
+
+V can bring in values at compile time from `-d ident=value` flag defines, passed on
+the command line to the compiler. You can also pass `-d ident`, which will have the
+same meaning as passing `-d ident=true`.
+
+To get the value in your code, use: `$d('ident', default)`, where `default`
+can be `false` for booleans, `0` or `123` for i64 numbers, `0.0` or `113.0`
+for f64 numbers, `'a string'` for strings.
+
+When a flag is not provided via the command line, `$d()` will return the `default`
+value provided as the *second* argument.
+
+```v
+module main
+
+const my_i64 = $d('my_i64', 1024)
+
+fn main() {
+	compile_time_value := $d('my_string', 'V')
+	println(compile_time_value)
+	println(my_i64)
+}
+```
+
+Running the above with `v run .` will output:
+```
+V
+1024
+```
+
+Running the above with `v -d my_i64=4096 -d my_string="V rocks" run .` will output:
+```
+V rocks
+4096
+```
+
+Here is an example of how to use the default values, which have to be *pure* literals:
+```v
+fn main() {
+	val_str := $d('id_str', 'value') // can be changed by providing `-d id_str="my id"`
+	val_f64 := $d('id_f64', 42.0) // can be changed by providing `-d id_f64=84.0`
+	val_i64 := $d('id_i64', 56) // can be changed by providing `-d id_i64=123`
+	val_bool := $d('id_bool', false) // can be changed by providing `-d id_bool=true`
+	val_char := $d('id_char', `f`) // can be changed by providing `-d id_char=v`
+	println(val_str)
+	println(val_f64)
+	println(val_i64)
+	println(val_bool)
+	println(rune(val_char))
+}
+```
+
+`$d('ident','value')` can also be used in top-level statements like `#flag` and `#include`:
+`#flag linux -I $d('my_include','/usr')/include`. The default value for `$d` when used in these
+statements should be literal `string`s.
+
+`$d('ident', false)` can also be used inside `$if $d('ident', false) {` statements,
+granting you the ability to selectively turn on/off certain sections of code, at compile
+time, without modifying your source code, or keeping different versions of it.
+
 #### `$compile_error` and `$compile_warn`
 
 These two comptime functions are very useful for displaying custom errors/warnings during

vlib/v/ast/ast.v

@@ -1913,26 +1913,28 @@ pub mut:
 @[minify]
 pub struct ComptimeCall {
 pub:
-	pos          token.Pos
-	has_parens   bool // if $() is used, for vfmt
-	method_name  string
-	method_pos   token.Pos
-	scope        &Scope = unsafe { nil }
-	is_vweb      bool
-	is_embed     bool
-	is_env       bool
-	env_pos      token.Pos
-	is_pkgconfig bool
-pub mut:
-	vweb_tmpl   File
-	left        Expr
-	left_type   Type
-	result_type Type
-	env_value   string
-	args_var    string
-	args        []CallArg
-	embed_file  EmbeddedFile
-	or_block    OrExpr
+	pos              token.Pos
+	has_parens       bool // if $() is used, for vfmt
+	method_name      string
+	method_pos       token.Pos
+	scope            &Scope = unsafe { nil }
+	is_vweb          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
+	is_pkgconfig     bool
+pub mut:
+	vweb_tmpl     File
+	left          Expr
+	left_type     Type
+	result_type   Type
+	env_value     string
+	compile_value string
+	args_var      string
+	args          []CallArg
+	embed_file    EmbeddedFile
+	or_block      OrExpr
 }
 
 pub struct None {

vlib/v/checker/checker.v

@@ -2428,6 +2428,13 @@ fn (mut c Checker) hash_stmt(mut node ast.HashStmt) {
 				}
 				node.main = env
 			}
+			if flag.contains('\$d(') {
+				d := util.resolve_d_value(c.pref.compile_values, flag) or {
+					c.error(err.msg(), node.pos)
+					return
+				}
+				node.main = d
+			}
 			flag_no_comment := flag.all_before('//').trim_space()
 			if node.kind == 'include' || node.kind == 'preinclude' {
 				if !((flag_no_comment.starts_with('"') && flag_no_comment.ends_with('"'))
@@ -2511,6 +2518,12 @@ fn (mut c Checker) hash_stmt(mut node ast.HashStmt) {
 					return
 				}
 			}
+			if flag.contains('\$d(') {
+				flag = util.resolve_d_value(c.pref.compile_values, flag) or {
+					c.error(err.msg(), node.pos)
+					return
+				}
+			}
 			for deprecated in ['@VMOD', '@VMODULE', '@VPATH', '@VLIB_PATH'] {
 				if flag.contains(deprecated) {
 					if !flag.contains('@VMODROOT') {

vlib/v/checker/comptime.v

@@ -29,6 +29,26 @@ fn (mut c Checker) comptime_call(mut node ast.ComptimeCall) ast.Type {
 		node.env_value = env_value
 		return ast.string_type
 	}
+	if node.is_compile_value {
+		arg := node.args[0] or {
+			c.error('\$d() takes two arguments, a string and a primitive literal', node.pos)
+			return ast.void_type
+		}
+		if !arg.expr.is_pure_literal() {
+			c.error('-d values can only be pure literals', node.pos)
+			return ast.void_type
+		}
+		typ := arg.expr.get_pure_type()
+		arg_as_string := arg.str().trim('`"\'')
+		value := c.pref.compile_values[node.args_var] or { arg_as_string }
+		validate_type_string_is_pure_literal(typ, value) or {
+			c.error(err.msg(), node.pos)
+			return ast.void_type
+		}
+		node.compile_value = value
+		node.result_type = typ
+		return typ
+	}
 	if node.is_embed {
 		if node.args.len == 1 {
 			embed_arg := node.args[0]
@@ -569,6 +589,42 @@ fn (mut c Checker) eval_comptime_const_expr(expr ast.Expr, nlevel int) ?ast.Comp
 	return none
 }
 
+fn validate_type_string_is_pure_literal(typ ast.Type, str string) ! {
+	if typ == ast.bool_type {
+		if !(str == 'true' || str == 'false') {
+			return error('bool literal `true` or `false` expected, found "${str}"')
+		}
+	} else if typ == ast.char_type {
+		if str.starts_with('\\') {
+			if str.len <= 1 {
+				return error('empty escape sequence found')
+			}
+			if !is_escape_sequence(str[1]) {
+				return error('char literal escape sequence expected, found "${str}"')
+			}
+		} else if str.len != 1 {
+			return error('char literal expected, found "${str}"')
+		}
+	} else if typ == ast.f64_type {
+		if str.count('.') != 1 {
+			return error('f64 literal expected, found "${str}"')
+		}
+	} else if typ == ast.string_type {
+	} else if typ == ast.i64_type {
+		if !str.is_int() {
+			return error('i64 literal expected, found "${str}"')
+		}
+	} else {
+		return error('expected pure literal, found "${str}"')
+	}
+}
+
+@[inline]
+fn is_escape_sequence(c u8) bool {
+	return c in [`x`, `u`, `e`, `n`, `r`, `t`, `v`, `a`, `f`, `b`, `\\`, `\``, `$`, `@`, `?`, `{`,
+		`}`, `'`, `"`, `U`]
+}
+
 fn (mut c Checker) verify_vweb_params_for_method(node ast.Fn) (bool, int, int) {
 	margs := node.params.len - 1 // first arg is the receiver/this
 	// if node.attrs.len == 0 || (node.attrs.len == 1 && node.attrs[0].name == 'post') {
@@ -969,6 +1025,16 @@ fn (mut c Checker) comptime_if_branch(mut cond ast.Expr, pos token.Pos) Comptime
 					return .skip
 				}
 				m.run() or { return .skip }
+				return .eval
+			}
+			if cond.is_compile_value {
+				t := c.expr(mut cond)
+				if t != ast.bool_type {
+					c.error('inside \$if, only \$d() expressions that return bool are allowed',
+						cond.pos)
+					return .skip
+				}
+				return .unknown // always fully generate the code for that branch
 			}
 			return .eval
 		}

vlib/v/checker/tests/comptime_value_d_in_include_errors.out

@@ -0,0 +1 @@
+builder error: Header file "/opt/invalid/include/stdio.h", needed for module `main` was not found. Please install the corresponding development headers.

vlib/v/checker/tests/comptime_value_d_in_include_errors.vv

@@ -0,0 +1 @@
+#include "$d('my_include','/opt/invalid/include')/stdio.h"

vlib/v/checker/tests/comptime_value_d_values_can_only_be_pure_literals.out

@@ -0,0 +1,3 @@
+vlib/v/checker/tests/comptime_value_d_values_can_only_be_pure_literals.vv:1:16: error: -d values can only be pure literals
+    1 | const my_f32 = $d('my_f32', f32(42.0))
+      |                ~~~~~~~~~~~~~~~~~~~~~~~

vlib/v/checker/tests/comptime_value_d_values_can_only_be_pure_literals.vv

@@ -0,0 +1 @@
+const my_f32 = $d('my_f32', f32(42.0))

vlib/v/checker/tests/run/using_comptime_d_value.run.out

@@ -0,0 +1,3 @@
+42.0
+false
+done

vlib/v/checker/tests/run/using_comptime_d_value.vv

@@ -0,0 +1,11 @@
+#flag -I $d('my_flag','flag_value')/xyz
+#include "@VMODROOT/$d('my_include','vlib/v')/tests/project_with_c_code/mod1/c/header.h"
+
+const my_f64 = $d('my_f64', 42.0)
+
+fn main() {
+	println(my_f64)
+	cv_bool := $d('my_bool', false)
+	println(cv_bool)
+	println('done')
+}

vlib/v/compiler_errors_test.v

@@ -237,13 +237,15 @@ fn (mut tasks Tasks) run() {
 		// cleaner error message, than a generic C error, but without the explanation.
 		m_skip_files << 'vlib/v/checker/tests/missing_c_lib_header_1.vv'
 		m_skip_files << 'vlib/v/checker/tests/missing_c_lib_header_with_explanation_2.vv'
+		m_skip_files << 'vlib/v/checker/tests/comptime_value_d_in_include_errors.vv'
 	}
 	$if msvc {
 		m_skip_files << 'vlib/v/checker/tests/asm_alias_does_not_exist.vv'
 		m_skip_files << 'vlib/v/checker/tests/asm_immutable_err.vv'
 		// TODO: investigate why MSVC regressed
 		m_skip_files << 'vlib/v/checker/tests/missing_c_lib_header_1.vv'
 		m_skip_files << 'vlib/v/checker/tests/missing_c_lib_header_with_explanation_2.vv'
+		m_skip_files << 'vlib/v/checker/tests/comptime_value_d_in_include_errors.vv'
 	}
 	$if windows {
 		m_skip_files << 'vlib/v/checker/tests/modules/deprecated_module'

vlib/v/fmt/fmt.v

@@ -2186,6 +2186,11 @@ pub fn (mut f Fmt) comptime_call(node ast.ComptimeCall) {
 					f.write("\$${node.method_name}('${node.args_var}')")
 				}
 			}
+			node.method_name == 'd' {
+				f.write("\$d('${node.args_var}', ")
+				f.expr(node.args[0].expr)
+				f.write(')')
+			}
 			node.method_name == 'res' {
 				if node.args_var != '' {
 					f.write('\$res(${node.args_var})')

vlib/v/fmt/tests/comptime_value_keep.vv

@@ -0,0 +1,7 @@
+fn main() {
+	val_str := $d('key_str', 'value')
+	val_f64 := $d('key_f64', 42.0)
+	val_int := $d('key_int', 56)
+	val_bool := $d('key_bool', false)
+	val_char := $d('key_char', `f`)
+}

vlib/v/gen/c/comptime.v

@@ -48,10 +48,23 @@ fn (mut g Gen) comptime_call(mut node ast.ComptimeCall) {
 	}
 	if node.method_name == 'env' {
 		// $env('ENV_VAR_NAME')
+		// TODO: deprecate after support for $d() is stable
 		val := util.cescaped_path(os.getenv(node.args_var))
 		g.write('_SLIT("${val}")')
 		return
 	}
+	if node.method_name == 'd' {
+		// $d('some_string',<default value>), affected by `-d some_string=actual_value`
+		val := util.cescaped_path(node.compile_value)
+		if node.result_type == ast.string_type {
+			g.write('_SLIT("${val}")')
+		} else if node.result_type == ast.char_type {
+			g.write("'${val}'")
+		} else {
+			g.write('${val}')
+		}
+		return
+	}
 	if node.method_name == 'res' {
 		if node.args_var != '' {
 			g.write('${g.defer_return_tmp_var}.arg${node.args_var}')
@@ -677,7 +690,22 @@ fn (mut g Gen) comptime_if_cond(cond ast.Expr, pkg_exist bool) (bool, bool) {
 			return true, false
 		}
 		ast.ComptimeCall {
-			g.write('${pkg_exist}')
+			if cond.method_name == 'pkgconfig' {
+				g.write('${pkg_exist}')
+				return true, false
+			}
+			if cond.method_name == 'd' {
+				if cond.result_type == ast.bool_type {
+					if cond.compile_value == 'true' {
+						g.write('1')
+					} else {
+						g.write('0')
+					}
+				} else {
+					g.write('defined(CUSTOM_DEFINE_${cond.args_var})')
+				}
+				return true, false
+			}
 			return true, false
 		}
 		ast.SelectorExpr {

vlib/v/gen/c/testdata/use_flag_comptime_values.out

@@ -0,0 +1,5 @@
+2.0
+3
+a four
+true
+g

vlib/v/gen/c/testdata/use_flag_comptime_values.vv

@@ -0,0 +1,20 @@
+// This file should pass if compiled/run with:
+// vtest vflags: -d my_f64=2.0 -d my_i64=3 -d my_string="a four" -d my_bool -d my_char=g
+const my_f64 = $d('my_f64', 1.0)
+const my_i64 = $d('my_i64', 2)
+const my_string = $d('my_string', 'three')
+const my_bool = $d('my_bool', false)
+const my_char = $d('my_char', `f`)
+
+fn main() {
+	assert my_f64 == 2.0
+	assert my_i64 == 3
+	assert my_string == 'a four'
+	assert my_bool == true
+	assert my_char == `g`
+	println(my_f64)
+	println(my_i64)
+	println(my_string)
+	println(my_bool)
+	println(rune(my_char))
+}