Почему я могу вернуть ссылку на принадлежащее значение функции?

struct Context<'s>(&'s str);

→ Значения типа Context содержат строку с некоторым временем жизни 's. Это время жизни неявно, по крайней мере, равно времени жизни контекста, но может быть и дольше.

struct Parser<'c, 's>
{
    context: &'c Context<'s>,
}

→ Значения типа Parser содержат ссылку на контекст с некоторым временем жизни 'c. Этот контекст содержит строку с некоторым другим временем жизни 's.

impl<'c, 's> Parser<'c, 's>
{
    fn parse(&self) -> Result<(), &'s str>
    {
        Err(self.context.0)
    }
}

→ Функция parse возвращает значение с временем жизни 's, т.е. с тем же временем жизни, что и у строки, хранящейся внутри контекста, который не совпадает со временем жизни самого контекста.

fn parse_context(context: Context) -> Result<(), &str>
{
    Parser { context: &context }.parse()
}

→ Я не уверен, где именно это указано, но, очевидно, компилятор делает вывод, что время жизни возвращаемой строки такое же, как параметр 's, используемый для контекста. Обратите внимание, что даже если сам контекст перемещен в parse_context, это влияет только на сам контекст, а не на содержащуюся в нем строку.

fn main()
{
    let mut s = String::new();

→ Создать новую строку, действительную до конца main

    s += "Avail";
    s += "able?";
    if let Err(text) = parse_context(Context(&s))

→ Создайте новый контекст и переместите его в parse_context. Он будет автоматически удален в конце parse_context. Он содержит ссылку на строку s, которая действительна до конца main, а parse_context возвращает строку с тем же временем жизни, что и s ⇒ text, действительна до конца main.

    {
        println!("{}", text);
    }
}

→ Нет проблем: text действительно до конца main.

Вы не возвращаете ссылку на собственное значение функции. Вы возвращаете копию переданной ссылки.

Ваша функция - это усовершенствованная версия функции идентификации:

fn parse_context(s: &str) -> &str {
    s
}

В вашем реальном коде вы берете ссылку на структуру, содержащую строковый фрагмент, затем другую ссылку на строковый фрагмент, но все эти ссылки отбрасываются.

Например, в parse есть ненужная ссылка:

fn parse(&self) -> Result<(), &'s str> {
    Err( self.context.0)
    //  ^ no & needed
}

Кроме того, если вы включите еще несколько линтов, вы будете вынуждены добавить больше времени жизни к своей сигнатуре функции, что может прояснить ситуацию:

#![deny(rust_2018_idioms)]

fn parse_context(context: Context<'_>) -> Result<(), &'_ str> {
    Parser { context: &context }.parse()
}

Смотрите также:

• Каковы точные правила автоматического разыменования в Rust?

Хотя я не смог найти подробного объяснения этого нового правила исключения,

T: 'a вывод в структурах в руководстве по выпуску.

Благодаря комментариям Jmb и некоторым фрагментам ответа Шепмастера теперь мне действительно ясно, что мое замешательство было связано с правилами RAII и правом собственности.

То есть строка была создана в области main, анонимный Context экземпляр не принимает владение строкой, он только заимствует ссылку, поэтому даже когда экземпляр отбрасывается в конце parse_context вдоль с заимствованной ссылкой ссылка, скопированная на объект Err, все еще существует и указывает на существующую строку - следовательно, мы используем ограниченные переменные времени жизни, и компилятор может определить время жизни внутренней ссылки на строку.