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

Author: spytheman

cmd/tools/vast/vast.v

@@ -1072,13 +1072,13 @@ fn (t Tree) comptime_call(node ast.ComptimeCall) &Node {
 	mut obj := create_object()
 	obj.add_terse('ast_type', t.string_node('ComptimeCall'))
 	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('is_vweb', t.bool_node(node.is_vweb))
 	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('args_var', t.string_node(node.args_var))
 	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('method_pos', t.pos(node.method_pos))
 	obj.add_terse('left_type', t.type_node(node.left_type))

vlib/v/ast/ast.v

@@ -2050,21 +2050,32 @@ pub mut:
 	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]
 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_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
-	is_pkgconfig     bool
+	pos         token.Pos
+	has_parens  bool // if $() is used, for vfmt
+	method_name string
+	kind        ComptimeCallKind
+	method_pos  token.Pos
+	scope       &Scope = unsafe { nil }
+	is_vweb     bool
+	is_veb      bool
+	env_pos     token.Pos
 mut:
 	is_d_resolved bool
 pub mut:
@@ -2087,7 +2098,7 @@ pub fn (mut cc ComptimeCall) resolve_compile_value(compile_values map[string]str
 	if cc.is_d_resolved {
 		return
 	}
-	if !cc.is_compile_value {
+	if cc.kind != .d {
 		return error('ComptimeCall is not \$d()')
 	}
 	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).
 pub fn (cc ComptimeCall) expr_str() string {
 	mut str := 'ast.ComptimeCall'
-	if cc.is_compile_value {
+	if cc.kind == .d {
 		arg := cc.args[0] or { return str }
 		if arg.expr.is_pure_literal() {
 			str = "\$${cc.method_name}('${cc.args_var}', ${arg})"

vlib/v/checker/checker.v

@@ -4669,7 +4669,7 @@ fn (mut c Checker) find_obj_definition(obj ast.ScopeObject) !ast.Expr {
 	if mut expr is ast.Ident {
 		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 {
 			return ast.BoolLiteral{
 				val: expr.compile_value.bool()

vlib/v/checker/comptime.v

@@ -15,29 +15,29 @@ fn (mut c Checker) comptime_call(mut node ast.ComptimeCall) ast.Type {
 	if node.left !is ast.EmptyExpr {
 		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)
 		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)
 		return ast.void_type
 	}
-	if node.is_env {
+	if node.kind == .env {
 		env_value := util.resolve_env_value("\$env('${node.args_var}')", false) or {
 			c.error(err.msg(), node.env_pos)
 			return ast.string_type
 		}
 		node.env_value = env_value
 		return ast.string_type
 	}
-	if node.is_compile_value {
+	if node.kind == .d {
 		node.resolve_compile_value(c.pref.compile_values) or {
 			c.error(err.msg(), node.pos)
 			return ast.void_type
 		}
 		return node.result_type
 	}
-	if node.is_embed {
+	if node.kind == .embed_file {
 		if node.args.len == 1 {
 			embed_arg := node.args[0]
 			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
 	}
-	if node.method_name == 'html' {
+	if node.kind == .html {
 		ret_sym := c.table.sym(c.table.cur_fn.return_type)
 		if ret_sym.cname !in ['veb__Result', 'vweb__Result', 'x__vweb__Result'] {
 			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)
 		return c.type_resolver.get_type(node)
 	}
-	if node.method_name == 'res' {
+	if node.kind == .res {
 		if !c.inside_defer {
 			c.error('`res` can only be used in defer blocks', node.pos)
 			return ast.void_type
@@ -1096,15 +1096,15 @@ fn (mut c Checker) comptime_if_cond(mut cond ast.Expr, pos token.Pos) ComptimeBr
 			}
 		}
 		ast.ComptimeCall {
-			if cond.is_pkgconfig {
+			if cond.kind == .pkgconfig {
 				mut m := pkgconfig.main([cond.args_var]) or {
 					c.error(err.msg(), cond.pos)
 					return .skip
 				}
 				m.run() or { return .skip }
 				return .eval
 			}
-			if cond.is_compile_value {
+			if cond.kind == .d {
 				t := c.expr(mut cond)
 				if t != ast.bool_type {
 					c.error('inside \$if, only \$d() expressions that return bool are allowed',

vlib/v/checker/containers.v

@@ -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()
 			}
 			ast.ComptimeCall {
-				if size_expr.is_compile_value {
+				if size_expr.kind == .d {
 					size_expr.resolve_compile_value(c.pref.compile_values) or {
 						c.error(err.msg(), size_expr.pos)
 					}

vlib/v/checker/return.v

@@ -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',
 				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.error('cannot use `string` as type `${c.table.type_to_str(exp_type)}` in return argument',
 				exprv.pos)
@@ -351,7 +351,7 @@ fn has_top_return(stmts []ast.Stmt) bool {
 						return true
 					}
 				} else if stmt.expr is ast.ComptimeCall {
-					if stmt.expr.method_name == 'compile_error' {
+					if stmt.expr.kind == .compile_error {
 						return true
 					}
 				} else if stmt.expr is ast.LockExpr {

vlib/v/checker/struct.v

@@ -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.size_expr is ast.ComptimeCall {
 						// 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',
 								field.default_expr.pos())
 						}

vlib/v/fmt/fmt.v

@@ -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) {
 	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.is_veb {
 					f.write('\$veb.html(')
@@ -2270,21 +2270,21 @@ pub fn (mut f Fmt) comptime_call(node ast.ComptimeCall) {
 		}
 	} else {
 		match true {
-			node.is_embed {
+			node.kind == .embed_file {
 				f.write('\$embed_file(')
 				f.expr(node.args[0].expr)
 				if node.embed_file.compression_type != 'none' {
 					f.write(', .${node.embed_file.compression_type}')
 				}
 				f.write(')')
 			}
-			node.is_env {
+			node.kind == .env {
 				f.write("\$env('${node.args_var}')")
 			}
-			node.is_pkgconfig {
+			node.kind == .pkgconfig {
 				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_var.contains("'") {
 						f.write('\$${node.method_name}("${node.args_var}")')
@@ -2297,12 +2297,12 @@ pub fn (mut f Fmt) comptime_call(node ast.ComptimeCall) {
 					f.write(')')
 				}
 			}
-			node.method_name == 'd' {
+			node.kind == .d {
 				f.write("\$d('${node.args_var}', ")
 				f.expr(node.args[0].expr)
 				f.write(')')
 			}
-			node.method_name == 'res' {
+			node.kind == .res {
 				if node.args_var != '' {
 					f.write('\$res(${node.args_var})')
 				} else {

vlib/v/gen/c/comptime.v

@@ -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) {
-	if node.is_embed {
+	if node.kind == .embed_file {
 		// $embed_file('/path/to/file')
 		g.gen_embed_file_init(mut node)
 		return
 	}
-	if node.method_name == 'env' {
+	if node.kind == .env {
 		// $env('ENV_VAR_NAME')
 		// TODO: deprecate after support for $d() is stable
 		val := util.cescaped_path(os.getenv(node.args_var))
 		g.write('_S("${val}")')
 		return
 	}
-	if node.method_name == 'd' {
+	if node.kind == .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 {
@@ -69,7 +69,7 @@ fn (mut g Gen) comptime_call(mut node ast.ComptimeCall) {
 		}
 		return
 	}
-	if node.method_name == 'res' {
+	if node.kind == .res {
 		if node.args_var != '' {
 			g.write('${g.defer_return_tmp_var}.arg${node.args_var}')
 			return
@@ -79,7 +79,7 @@ fn (mut g Gen) comptime_call(mut node ast.ComptimeCall) {
 		return
 	}
 	if node.is_vweb {
-		is_html := node.method_name == 'html'
+		is_html := node.kind == .html
 		mut cur_line := ''
 
 		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
 		}
 		ast.ComptimeCall {
-			if cond.method_name == 'pkgconfig' {
+			if cond.kind == .pkgconfig {
 				g.write('${pkg_exist}')
 				return true, false
 			}
-			if cond.method_name == 'd' {
+			if cond.kind == .d {
 				if cond.result_type == ast.bool_type {
 					if cond.compile_value == 'true' {
 						g.write('1')

vlib/v/gen/c/fn.v

@@ -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)
 		return true
 	} 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))
 			if m := sym.find_method(g.comptime.comptime_for_method.name) {
 				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)
 					}
 				} 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))
 						if m := sym.find_method(g.comptime.comptime_for_method.name) {
 							typ = m.return_type