Краткий ответ

Метод, возвращающий Self, обычно запрещает использовать трейт как trait object, потому что конкретный тип результата неизвестен через динамический интерфейс. Для вызова через dyn Trait компилятор должен заранее понимать размер и способ размещения возвращаемого значения, а Self может быть любым типом, реализующим трейт.

Такой метод можно сохранить в трейте, если ограничить его bound Self: Sized: тогда он будет доступен для конкретных типов, но не через dyn Trait.

Исторический контекст

Trait objects решают задачу динамического полиморфизма: программа может работать с разными конкретными типами через единый интерфейс, не выбирая реализацию метода на этапе компиляции. Для этого Rust использует указатель на данные и таблицу виртуальных методов — vtable.

Однако не каждый трейт можно представить такой парой. Для динамического вызова все операции интерфейса должны иметь представимое ABI: в частности, компилятор должен знать, как передать аргументы и получить результат без знания конкретного типа.

Постановка проблемы

Рассмотрим трейт с методом, возвращающим Self. При работе с конкретным типом компилятор знает, что именно возвращает метод. Но у значения типа dyn Trait конкретная реализация скрыта, а разные реализации могут возвращать значения разного размера и с разным способом хранения.

Если разрешить такой метод через trait object без дополнительных ограничений, вызывающий код не смог бы корректно зарезервировать место под результат. Это нарушило бы требование безопасного и однозначного динамического вызова.

Подробное решение

trait Factory {
    fn make(&self) -> Self;
}

struct Document;

impl Factory for Document {
    fn make(&self) -> Self {
        Document
    }
}

fn create(factory: &dyn Factory) {
    // factory.make(); // ошибка: трейт не совместим с dyn Trait
}

У dyn Factory нет единственного известного конкретного типа, который можно было бы подставить вместо Self. Поэтому Rust не разрешает создать объект такого трейта: трейт не является dyn-compatible.

Исключение — ограничение Self: Sized:

trait Factory {
    fn make(&self) -> Self
    where
        Self: Sized;
}

Теперь трейт можно использовать как dyn Factory, но метод make исключён из динамического интерфейса. Он вызывается только для конкретного типа, для которого размер Self известен на этапе компиляции.

Это компромисс: Self: Sized сохраняет удобный метод для статической диспетчеризации, но не делает его доступным через trait object. Если операция действительно нужна через динамический интерфейс, обычно возвращают другой объект с заранее известным представлением, например Box<dyn Factory>, либо используют отдельный объект результата.

Ситуация из практики

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

Вариант с методом, возвращающим Self, удобен для generic-кода: конкретный тип результата сохраняется, нет лишнего выделения памяти и виртуального вызова. Но такой трейт нельзя поместить в коллекцию вида Vec<Box<dyn Factory>>.

Вариант с Self: Sized позволяет сделать сам трейт объектным, но метод создания нельзя вызвать через элемент коллекции. Это подходит, если trait object нужен только для других операций.

Если создание должно выполняться именно через коллекцию, практичнее изменить интерфейс и возвращать унифицированный результат, например Box<dyn Document>. Цена решения — динамическая диспетчеризация результата и, возможно, выделение памяти в куче. Зато все фабрики получают совместимый динамический интерфейс, и коллекция может обрабатывать их единообразно.

Что кандидаты часто упускают

Запрещён ли любой метод с Self в сигнатуре?

Нет. Запрещающий фактор — не само упоминание Self, а его использование в позиции, требующей динамически представимого типа результата или аргумента. Метод можно сделать совместимым с trait object, добавив where Self: Sized, но тогда он исчезает из набора методов, доступных через dyn Trait.

Например, метод, принимающий &Self, также не становится автоматически доступным через trait object: размер и конкретный тип Self не известны, а метод не может быть вызван через обычный динамический интерфейс без специального ограничения. При проверке dyn-совместимости нужно анализировать каждую сигнатуру метода, а не только его возвращаемый тип.

Почему возвращаемый Box<dyn Trait> обычно допустим, хотя он тоже связан с Self?

Box<dyn Trait> имеет известное представление: это указатель на данные и vtable. Размер конкретного значения внутри коробки не требуется знать вызывающему коду, поэтому такой результат можно передать через динамический интерфейс.

Это отличается от прямого возврата Self: при прямом возврате вызывающий должен разместить само значение, размер которого может зависеть от конкретной реализации. Упаковка в Box переносит неопределённый размер за уровень указателя.

Можно ли вызвать метод с Self: Sized через generic-параметр?

Да. Если функция принимает параметр T, где T: Factory, то для обычного T размер типа по умолчанию известен, и метод с ограничением Self: Sized может участвовать в статической диспетчеризации.

Но если generic-параметр дополнительно допускает нес Sized-типы, например ограничен как T: Factory + ?Sized, вызов такого метода потребует доказать T: Sized. Для T = dyn Factory это невозможно, поэтому метод остаётся недоступным. Таким образом, Self: Sized не запрещает метод вообще — оно ограничивает только множество типов и способ вызова.