Início / coding / Perguntas / 79595543
Accepted
SneakyTactician2
Asked: 2025-04-28 06:09:56 +0800 CST

Rust - Como reexportar uma caixa de terceiros

  • 772

Estou tentando reexportar uma caixa de terceiros para que os consumidores da minha biblioteca não precisem adicionar manualmente todas as dependências necessárias para algum código gerado via macro proc.

No entanto, não consigo encontrar o caminho para resolver o compilador, mesmo obtendo conclusões de código para navegar até esse caminho.

Como posso reexportar corretamente caixas de terceiros de uma caixa minha, para que os consumidores das minhas caixas que utilizam minhas macros proc não precisem adicionar manualmente caixas de terceiros para dar suporte ao código gerado?

Abaixo está um exemplo simplificado que deve ser equivalente ao meu problema, embora meu projeto real tenha problemas para resolver esse caminho no código gerado pela minha própria macro proc.

Estrutura do arquivo:

│   Cargo.lock
│   Cargo.toml
│   rust-toolchain.toml
│
├───consumer
│   │   .gitignore
│   │   Cargo.toml
│   │
│   └───src
│           main.rs
│
└───exporter
    │   .gitignore
    │   Cargo.toml
    │
    └───src
            lib.rs

Na minha caixa "consumidor", tentei usar a Debugmacro derive fornecida pela derive_morecaixa.

Main.rs no consumidor:

#[derive(exporter::reexports::derive_more::Debug)]
pub struct Foo {
    x: u64
}


fn main() {
    println!("Hello, world!");
}

Cargo.toml no consumidor:

[package]
name = "consumer"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
exporter = { path = "../exporter" }

lib.rs no exportador:

pub mod reexports {
    pub use derive_more;
}

Cargo.toml no exportador:

[package]
name = "exporter"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
derive_more = { version = "2", features = ["full"] }
rust

1 respostas

  1. Best Answer

    Os erros aqui não são um problema de reexportação em si — o compilador consegue encontrar e executar a Debugmacro derive-more sem problemas. O problema é a saída gerada pela macro.

    A Debugmacro derive irá gerar isto:

    #[allow(unreachable_code)]
#[automatically_derived]
impl derive_more::core::fmt::Debug for Foo {
    #[inline]
    fn fmt(
        &self,
        __derive_more_f: &mut derive_more::core::fmt::Formatter<'_>,
    ) -> derive_more::core::fmt::Result {
        let x = &self.x;
        derive_more::core::fmt::DebugStruct::finish(derive_more::core::fmt::DebugStruct::field(
            &mut derive_more::core::fmt::Formatter::debug_struct(__derive_more_f, "Foo"),      
            "x",
            &x,
        ))
    }
}

    Como você pode ver, ele emite código que espera derive_moreestar no escopo, pois depende de suas próprias reexportações. Infelizmente, no seu caso, como a caixa do consumidor não depende diretamente de derive-more, ela não está automaticamente no escopo como normalmente estaria.

    A solução seria também incluir derive_moreno escopo, por meio da reexportação:

    use exporter::reexports::derive_more; // <--------

#[derive(exporter::reexports::derive_more::Debug)]
pub struct Foo {
    x: u64,
}

    Algumas caixas, como serde, permitem que você especifique um caminho diferente para usar serde(como #[serde(crate = "exporter::reexports::serde")]), mas nem todas as caixas fazem isso e é apenas uma maneira diferente de resolver o problema acima.

    Infelizmente, é assim que as macros procedurais funcionam. É uma questão em aberto fornecer às macros procedurais uma maneira de evitar esse problema (observe que elas podem se referir inequivocamente a si mesmas , mas não à caixa de macros não procedurais que acompanham).

    • 2

relate perguntas