cgen: remove unused code generated for unwrapping temp var from callexpr (detect unused return value from CallExpr), fix parser bugs (#22769)

Author: felipensp

cmd/tools/vast/vast.v

@@ -1559,6 +1559,7 @@ fn (t Tree) call_expr(node ast.CallExpr) &Node {
 	obj.add('is_keep_alive', t.bool_node(node.is_keep_alive))
 	obj.add_terse('is_noreturn', t.bool_node(node.is_noreturn))
 	obj.add_terse('is_ctor_new', t.bool_node(node.is_ctor_new))
+	obj.add_terse('is_return_used', t.bool_node(node.is_return_used))
 	obj.add('should_be_skipped', t.bool_node(node.should_be_skipped))
 	obj.add_terse('free_receiver', t.bool_node(node.free_receiver))
 	obj.add('scope', t.number_node(int(node.scope)))

vlib/v/ast/ast.v

@@ -827,6 +827,7 @@ pub mut:
 	scope                  &Scope = unsafe { nil }
 	from_embed_types       []Type // holds the type of the embed that the method is called from
 	comments               []Comment
+	is_return_used         bool // return value is used for another expr
 	//
 	is_expand_simple_interpolation bool // true, when the function/method is marked as @[expand_simple_interpolation]
 	// Calls to it with an interpolation argument like `b.f('x ${y}')`, will be converted to `b.f('x ')` followed by `b.f(y)`.

vlib/v/checker/assign.v

@@ -580,13 +580,14 @@ or use an explicit `unsafe{ a[..] }`, if you do not want a copy of the slice.',
 							right.pos())
 						c.note('an implicit clone of the slice was done here', right.pos())
 						right = ast.CallExpr{
-							name:          'clone'
-							left:          right
-							left_type:     left_type
-							is_method:     true
-							receiver_type: left_type
-							return_type:   left_type
-							scope:         c.fn_scope
+							name:           'clone'
+							left:           right
+							left_type:      left_type
+							is_method:      true
+							receiver_type:  left_type
+							return_type:    left_type
+							scope:          c.fn_scope
+							is_return_used: true
 						}
 						right_type = c.expr(mut right)
 						node.right[i] = right

vlib/v/checker/checker.v

@@ -1371,7 +1371,6 @@ fn (mut c Checker) check_or_last_stmt(mut stmt ast.Stmt, ret_type ast.Type, expr
 				c.expected_type = ret_type
 				c.expected_or_type = ret_type.clear_option_and_result()
 				last_stmt_typ := c.expr(mut stmt.expr)
-
 				if last_stmt_typ.has_flag(.option) || last_stmt_typ == ast.none_type {
 					if stmt.expr in [ast.Ident, ast.SelectorExpr, ast.CallExpr, ast.None, ast.CastExpr] {
 						expected_type_name := c.table.type_to_str(ret_type.clear_option_and_result())

vlib/v/checker/struct.v

@@ -733,13 +733,14 @@ or use an explicit `unsafe{ a[..] }`, if you do not want a copy of the slice.',
 							init_field.expr.pos())
 						c.note('an implicit clone of the slice was done here', init_field.expr.pos())
 						mut right := ast.CallExpr{
-							name:          'clone'
-							left:          init_field.expr
-							left_type:     got_type
-							is_method:     true
-							receiver_type: got_type.ref()
-							return_type:   got_type
-							scope:         c.fn_scope
+							name:           'clone'
+							left:           init_field.expr
+							left_type:      got_type
+							is_method:      true
+							receiver_type:  got_type.ref()
+							return_type:    got_type
+							scope:          c.fn_scope
+							is_return_used: true
 						}
 						got_type = c.expr(mut right)
 						node.init_fields[i].expr = right

vlib/v/checker/tests/enum_redeclare_err.vv

@@ -1,9 +1,9 @@
 @[flag]
 pub enum Enum {
-    a
+	a
 }
 
 @[flag]
 pub enum Enum {
-    a
-}
+	a
+}

vlib/v/gen/c/assign.v

@@ -1041,7 +1041,7 @@ fn (mut g Gen) gen_cross_var_assign(node &ast.AssignStmt) {
 						g.write(' = *(voidptr*)array_get(')
 					} else {
 						styp := g.styp(info.elem_type)
-						string_clone := if needs_clone { '/*1*/string_clone(' } else { '' }
+						string_clone := if needs_clone { 'string_clone(' } else { '' }
 
 						g.write('${styp} _var_${left.pos.pos} = ${string_clone}*(${styp}*)array_get(')
 					}

vlib/v/gen/c/cgen.v

@@ -2158,7 +2158,11 @@ fn (mut g Gen) stmt(node ast.Stmt) {
 			eprintln('cgen: ${g.file.path:-30} | pos: ${node.pos.line_str():-39} | node: ${ntype} | ${node}')
 		}
 	}
+	old_inside_call := g.inside_call
 	g.inside_call = false
+	defer {
+		g.inside_call = old_inside_call
+	}
 	if !g.skip_stmt_pos {
 		g.set_current_pos_as_last_stmt_pos()
 	}
@@ -7140,6 +7144,10 @@ fn (mut g Gen) gen_or_block_stmts(cvar_name string, cast_typ string, stmts []ast
 								&& expr_stmt.expr.or_block.kind == .absent {
 								g.write('${cvar_name} = ')
 								return_wrapped = true
+							} else if expr_stmt.expr is ast.CallExpr {
+								if expr_stmt.expr.is_return_used {
+									g.write('*(${cast_typ}*) ${cvar_name}.data = ')
+								}
 							} else {
 								g.write('*(${cast_typ}*) ${cvar_name}.data = ')
 							}

vlib/v/gen/c/fn.v

@@ -1021,7 +1021,12 @@ fn (mut g Gen) call_expr(node ast.CallExpr) {
 					&& unwrapped_styp.starts_with('_v_') {
 					unwrapped_styp = unwrapped_styp[3..]
 				}
-				g.write('\n ${cur_line} (*(${unwrapped_styp}*)${tmp_opt}.data)')
+				if node.is_return_used {
+					// return value is used, so we need to write the unwrapped temporary var
+					g.write('\n ${cur_line} (*(${unwrapped_styp}*)${tmp_opt}.data)')
+				} else {
+					g.write('\n ${cur_line}')
+				}
 			} else {
 				g.write('\n ${cur_line} ${tmp_opt}')
 			}

vlib/v/gen/wasm/gen.v

@@ -631,12 +631,13 @@ pub fn (mut g Gen) call_expr(node ast.CallExpr, expected ast.Type, existing_rvar
 			}
 
 			expr = ast.CallExpr{
-				name:          'str'
-				left:          expr
-				left_type:     typ
-				receiver_type: typ
-				return_type:   ast.string_type
-				is_method:     true
+				name:           'str'
+				left:           expr
+				left_type:      typ
+				receiver_type:  typ
+				return_type:    ast.string_type
+				is_method:      true
+				is_return_used: true
 			}
 		}