Refatoração de código legado em Rust: guia passo a passo

Introdução: por que refatorar código legado em Rust é um desafio e uma necessidade

Trabalhar com código legado é uma parte inevitável da vida de qualquer desenvolvedor. No ecossistema Rust, conhecido por seu rigor e segurança, a refatoração de código legado adquire uma especificidade particular. Por um lado, o compilador Rust é seu melhor amigo, capturando muitos erros em tempo de compilação. Por outro lado, o legado pode incluir blocos unsafe, lógica de ownership confusa ou expressões idiomáticas desatualizadas que não estão alinhadas com as práticas modernas.

Neste artigo, vamos analisar uma abordagem prática para refatorar código legado em Rust. Você aprenderá como transformar, passo a passo, "código espaguete" em um sistema limpo, seguro e sustentável, usando o poder do sistema de tipos e das ferramentas do Rust.

Passo 1: Análise e isolamento — antes de tocar no código

O primeiro e mais importante passo é entender com o que você está lidando. Não tente refatorar tudo de uma vez. Use a estratégia da "regra do escoteiro": deixe o código mais limpo do que estava antes.

Use cargo e ferramentas de análise estática

Execute cargo check e cargo clippy. Clippy é um linter que sugerirá várias melhorias, desde estilísticas até semânticas. Por exemplo, ele pode apontar clonagens desnecessárias ou variáveis não utilizadas.

// Exemplo: antes da refatoraçãofn process_data(data: &Vec<i32>) -> i32 {    let mut sum = 0;    for i in 0..data.len() {        sum += data[i];    }    sum}

// Clippy sugerirá usar iteradores:fn process_data(data: &[i32]) -> i32 {    data.iter().sum()}

Escreva testes para o comportamento atual

Antes de alterar a lógica, cubra o código existente com testes unitários. Esta é sua rede de segurança. Use cargo test e, se necessário, módulos #[cfg(test)].

#[cfg(test)]mod tests {    use super::*;

    #[test]    fn test_process_data() {        let data = vec![1, 2, 3];        assert_eq!(process_data(&data), 6);    }}

Passo 2: Substituição de blocos unsafe por abstrações seguras

O código legado em Rust frequentemente abusa de unsafe para "otimização" ou por falta de compreensão do sistema de ownership. Seu objetivo é minimizar o unsafe ao mínimo absoluto.

Isole unsafe em funções separadas

Se um bloco unsafe não puder ser removido imediatamente, isole-o em uma função pequena com um nome claro e documentação (seção Safety).

// Ruim: unsafe espalhado por todo o códigofn legacy_unsafe(data: &mut [u8]) {    unsafe {        let ptr = data.as_mut_ptr();        // ... muitas operações unsafe    }}

// Bom: isolamento/// # Safety/// `data` deve ser válida e não deve se sobrepor a outras referências mutáveis.unsafe fn copy_inner(data: &mut [u8], src: *const u8, len: usize) {    std::ptr::copy_nonoverlapping(src, data.as_mut_ptr(), len);}

fn safe_wrapper(data: &mut [u8], src: &[u8]) {    assert!(data.len() >= src.len());    unsafe { copy_inner(data, src.as_ptr(), src.len()) };}

Passo 3: Refatoração usando expressões idiomáticas modernas do Rust

Após o isolamento e os testes, passe para a melhoria da arquitetura. É aqui que traits, generics e o estilo funcional entram em ação.

De structs com campos públicos para encapsulamento

O código legado frequentemente contém structs com campos pub, o que viola o encapsulamento. Substitua-os por getters/setters ou métodos.

// Legadopub struct Config {    pub timeout: u64,    pub retries: u32,}

// Refatoraçãopub struct Config {    timeout: u64,    retries: u32,}

impl Config {    pub fn new(timeout: u64, retries: u32) -> Self {        Self { timeout, retries }    }    pub fn timeout(&self) -> u64 { self.timeout }    pub fn retries(&self) -> u32 { self.retries }}