checker,transformer: add always true/false branch detection for the if and match constructs (#25674)

Author: kbkpbot

cmd/tools/changelog_helper.v

@@ -111,9 +111,6 @@ fn main() {
 		}
 	}
 	os.write_file(log_txt, lines.join('\n'))!
-	if true {
-		// return
-	}
 	mut app := &App{
 		total_lines: lines.len
 	}
@@ -122,10 +119,6 @@ fn main() {
 		category_titles)
 	os.write_file('CHANGELOG.md', app.result)!
 	changelog_txt := os.read_file('CHANGELOG.md')!.to_lower()
-	if true {
-		// println(changelog_txt)
-		// return
-	}
 	// mut counter := 0 // to display how many commits are left
 	for line in lines {
 		s := line.trim_space()

vlib/os/filepath.v

@@ -218,18 +218,20 @@ fn clean_path(path string) string {
 
 // to_slash returns the result of replacing each separator character in path with a slash (`/`).
 pub fn to_slash(path string) string {
-	if path_separator == '/' {
-		return path
+	return $if windows {
+		path.replace(path_separator, '/')
+	} $else {
+		path
 	}
-	return path.replace(path_separator, '/')
 }
 
 // from_slash returns the result of replacing each slash (`/`) character is path with a separator character.
 pub fn from_slash(path string) string {
-	if path_separator == '/' {
-		return path
+	return $if windows {
+		path.replace('/', path_separator)
+	} $else {
+		path
 	}
-	return path.replace('/', path_separator)
 }
 
 // win_volume_len returns the length of the

vlib/os/os.v

@@ -44,7 +44,7 @@ fn executable_fallback() string {
 		}
 	}
 	if !is_abs_path(exepath) {
-		other_separator := if path_separator == '/' { '\\' } else { '/' }
+		other_separator := $if windows { '/' } $else { '\\' }
 		rexepath := exepath.replace(other_separator, path_separator)
 		if rexepath.contains(path_separator) {
 			exepath = join_path_single(wd_at_startup, exepath)
@@ -848,7 +848,7 @@ pub fn mkdir_all(opath string, params MkdirParams) ! {
 		}
 		return error('path `${opath}` already exists, and is not a folder')
 	}
-	other_separator := if path_separator == '/' { '\\' } else { '/' }
+	other_separator := $if windows { '/' } $else { '\\' }
 	path := opath.replace(other_separator, path_separator)
 	mut p := if path.starts_with(path_separator) { path_separator } else { '' }
 	path_parts := path.trim_left(path_separator).split(path_separator)

vlib/v/checker/checker.v

@@ -152,7 +152,8 @@ mut:
 	v_current_commit_hash string // same as old C.V_CURRENT_COMMIT_HASH
 	assign_stmt_attr      string // for `x := [1,2,3] @[freed]`
 
-	js_string ast.Type = ast.void_type // when `js"string literal"` is used, `js_string` will be equal to `JS.String`
+	js_string           ast.Type                 = ast.void_type // when `js"string literal"` is used, `js_string` will be equal to `JS.String`
+	checker_transformer &transformer.Transformer = unsafe { nil }
 }
 
 pub fn new_checker(table &ast.Table, pref_ &pref.Preferences) &Checker {
@@ -174,6 +175,7 @@ pub fn new_checker(table &ast.Table, pref_ &pref.Preferences) &Checker {
 		)
 		match_exhaustive_cutoff_limit: pref_.checker_match_exhaustive_cutoff_limit
 		v_current_commit_hash:         v_current_commit_hash
+		checker_transformer:           transformer.new_transformer_with_table(table, pref_)
 	}
 	checker.type_resolver = type_resolver.TypeResolver.new(table, checker)
 	checker.comptime = &checker.type_resolver.info
@@ -2109,8 +2111,7 @@ fn (mut c Checker) enum_decl(mut node ast.EnumDecl) {
 				ast.InfixExpr {
 					// Handle `enum Foo { x = 1 + 2 }`
 					c.infix_expr(mut field.expr)
-					mut t := transformer.new_transformer_with_table(c.table, c.pref)
-					folded_expr := t.infix_expr(mut field.expr)
+					folded_expr := c.checker_transformer.infix_expr(mut field.expr)
 
 					if folded_expr is ast.IntegerLiteral {
 						c.check_enum_field_integer_literal(folded_expr, signed, node.is_multi_allowed,
@@ -2120,8 +2121,7 @@ fn (mut c Checker) enum_decl(mut node ast.EnumDecl) {
 				}
 				ast.ParExpr {
 					c.expr(mut field.expr.expr)
-					mut t := transformer.new_transformer_with_table(c.table, c.pref)
-					folded_expr := t.expr(mut field.expr.expr)
+					folded_expr := c.checker_transformer.expr(mut field.expr.expr)
 
 					if folded_expr is ast.IntegerLiteral {
 						c.check_enum_field_integer_literal(folded_expr, signed, node.is_multi_allowed,
@@ -2160,9 +2160,7 @@ fn (mut c Checker) enum_decl(mut node ast.EnumDecl) {
 						if field.expr.kind == .constant && field.expr.obj.typ.is_int() {
 							// accepts int constants as enum value
 							if mut field.expr.obj is ast.ConstField {
-								mut t := transformer.new_transformer_with_table(c.table,
-									c.pref)
-								folded_expr := t.expr(mut field.expr.obj.expr)
+								folded_expr := c.checker_transformer.expr(mut field.expr.obj.expr)
 
 								if folded_expr is ast.IntegerLiteral {
 									c.check_enum_field_integer_literal(folded_expr, signed,

vlib/v/checker/if.v

@@ -156,6 +156,17 @@ fn (mut c Checker) if_expr(mut node ast.IfExpr) ast.Type {
 					c.error('non-bool type `${c.table.type_to_str(cond_typ)}` used as if condition',
 						branch.cond.pos())
 				}
+				if !c.pref.translated && !c.file.is_translated {
+					mut check_expr := branch.cond
+					t_expr := c.checker_transformer.expr(mut check_expr)
+					if t_expr is ast.BoolLiteral {
+						if t_expr.val {
+							c.note('condition is always true', branch.cond.pos())
+						} else {
+							c.note('condition is always false', branch.cond.pos())
+						}
+					}
+				}
 			}
 		} else {
 			// else branch

vlib/v/checker/match.v

@@ -235,6 +235,25 @@ fn (mut c Checker) match_expr(mut node ast.MatchExpr) ast.Type {
 			}
 		}
 
+		if !c.pref.translated && !c.file.is_translated {
+			// check for always true/false match branch
+			for mut expr in branch.exprs {
+				mut check_expr := ast.InfixExpr{
+					op:    .eq
+					left:  node.cond
+					right: expr
+				}
+				t_expr := c.checker_transformer.expr(mut check_expr)
+				if t_expr is ast.BoolLiteral {
+					if t_expr.val {
+						c.note('match is always true', expr.pos())
+					} else {
+						c.note('match is always false', expr.pos())
+					}
+				}
+			}
+		}
+
 		if !node.is_comptime || (node.is_comptime && comptime_match_branch_result) {
 			if node.is_expr {
 				c.stmts_ending_with_expression(mut branch.stmts, c.expected_or_type)