Can you tell me what is wrong with this code?

let mut text = "";
if text.is_empty() {
  let new_text = String::from("hello");
  text = &new_text;
}
call_function(text); 

The problem with your code is related to variable ownership and lifetime in Rust. When assigning text = &new_text;, you are trying to create a reference (&new_text) to a variable new_text that is created inside the if block. This will lead to a problem because new_text's scope is limited to the if block and it will be dropped once the execution leaves this scope. The text variable then ends up referencing a value that no longer exists. A potential way to fix this is to make the new_text variable outside of the if block and assign the value inside the if block:

let mut text = String::new();
let mut new_text = String::new();

if text.is_empty() {
    new_text = String::from("hello");
    text = new_text;
}

call_function(&text);

Now, the new_text has a scope that extends to the end of the current function, not just the if block, so text will be a valid reference when it is passed into call_function. The reference being passed to call_function needs to be a &String instead of String.

Can we use &str instead of string here?

Yes, you can use str instead of String in certain cases, but the &str type would need to refer to a string literal or a String that lives long enough. Here's how you modify your initial code to use &str:

let mut text: &str = "";
if text.is_empty() {
    let new_text: &str = "hello";
    text = new_text;
}
call_function(text);

This code works because the string "hello" is a string literal, which is stored directly in the compiled program, and its lifetime is the duration of the program. Hence text refers to a valid string when you call call_function. But please note that if you tried to convert a String variable to a &str inside the if block, and assigned it to text, you would run into ownership and lifetime issues, because the String variable will be dropped at the end of the if block.