Struct c2rust_refactor::transform::generics::GeneralizeItems

pub struct GeneralizeItems { /* fields omitted */ }

generalize_items Command

Usage: generalize_items VAR [TY]

Marks: target

Replace marked types with generic type parameters.

Specifically: add a new type parameter called VAR to each item marked target, replacing type annotations inside that item that are marked target with uses of the type parameter. Also update all uses of target items, passing TY as the new type argument when used inside a non-target item, and passing the type variable VAR when used inside a target item.

If TY is not provided, it defaults to a copy of the first type annotation that was replaced with VAR.

Example:

struct Foo {    // Foo: target
    x: i32,     // i32: target
    y: i32,
}

fn f(foo: Foo) { ... }  // f: target

fn main() {
    f(...);
}

After running generalize_items T:

// 1. Foo gains a new type parameter `T`
struct Foo<T> {
    // 2. Marked type annotations become `T`
    x: T,
    y: i32,
}

// 3. `f` gains a new type parameter `T`, and passes
// it through to uses of `Foo`
fn f<T>(foo: Foo<T>) { ... }
struct Bar<T> {
    foo: Foo<T>,
}

fn main() {
    // 4. Uses outside target items use `i32`, the
    // first type that was replaced with `T`.
    f::<i32>(...);
}

Trait Implementations

impl Transform for GeneralizeItems

fn transform(&self, krate: &mut Crate, st: &CommandState, cx: &RefactorCtxt)

Apply the transformation.

fn min_phase(&self) -> Phase

Return the minimum phase at which this transform can operate. See the Phase docs for details. The default is Phase2.