Foi lançado o Rust 1.86, uma linguagem de programação de propósito geral, originalmente desenvolvida pelo projeto Mozilla, mas agora mantida por uma organização sem fins lucrativos independente, a Rust Foundation. A linguagem foca na segurança da memória e oferece ferramentas para alcançar um alto nível de paralelismo na execução de tarefas, tudo isso sem a necessidade de coletor de lixo e runtime (o runtime se limita à inicialização básica e ao suporte da biblioteca padrão).
Os métodos de manipulação de memória em Rust protegem o desenvolvedor de erros ao trabalhar com ponteiros e evitam problemas decorrentes de manipulação de memória de baixo nível, como acesso a áreas de memória após sua liberação, desreferenciação de ponteiros nulos, e estouro de buffer, entre outros. Para distribuição de bibliotecas, construção e gerenciamento de dependências, o projeto conta com o gerenciador de pacotes Cargo. O repositório crates.io é suportado para hospedagem de bibliotecas.
A manipulação segura da memória em Rust é garantida em tempo de compilação através da verificação de referências, rastreamento de propriedade de objetos, controle do tempo de vida dos objetos (escopos) e avaliação da correção do acesso à memória durante a execução do código. Rust também oferece mecanismos para proteção contra estouros inteiros, exige a inicialização obrigatória de valores de variáveis antes do uso, trata erros de forma superior na biblioteca padrão, aplica o conceito de referências e variáveis imutáveis (immutable) por padrão e oferece uma forte tipagem estática para minimizar erros lógicos.
Principais novidades:
- Foi adicionada a suporte para o upcast de traits para supertraits, ou seja, agora é possível converter diretamente uma referência de um objeto trait em uma referência de um objeto supertrait sem precisar criar um método especial na trait que retorne a referência ao supertrait. Operações semelhantes podem ser realizadas com outros tipos de smart pointers, por exemplo, "Arc<dyn Trait> -> Arc<dyn Supertrait>" e "*const dyn Trait -> *const dyn Supertrait". trait Trait: Supertrait {} trait Supertrait {} fn upcast(x: &dyn Trait) -> &dyn Supertrait { x }
- Foi adicionado ao HashMap e aos slices o método get_disjoint_mut() para obter várias referências mutáveis simultaneamente. Anteriormente, o borrow checker não permitia o uso simultâneo de referências obtidas através do método get_mut(). let v = &mut [1, 2, 3]; if let Ok([a, b]) = v.get_disjoint_mut([0, 2]) { *a = 413; *b = 612; } assert_eq!(v, &[413, 2, 612]); if let Ok([a, b]) = v.get_disjoint_mut([0..1, 1..3]) { a[0] = 8; b[0] = 88; b[1] = 888; } assert_eq!(v, &[8, 88, 888]);
- Agora é permitido marcar funções safe com o atributo "#[target_feature]", indicando que a função utiliza determinadas funcionalidades da CPU. Uma função safe marcada com o atributo "#[target_feature]" só pode ser chamada de forma segura por outra função safe se também estiver marcada com "#[target_feature]" (caso contrário, tais funções devem ser chamadas dentro de um bloco unsafe). Além disso, não podem ser passadas para funções que aceitam parâmetros genéricos restritos a traits Fn*. Antes, o atributo "#[target_feature]" só podia ser aplicado a funções marcadas como "unsafe". #[target_feature(enable = "avx2")] fn requires_avx2() { // ... } #[target_feature(enable = "avx2")] fn safe_callsite() { requires_avx2(); } fn unsafe_callsite() { if is_x86_feature_detected!("avx2") { unsafe { requires_avx2() }; } }
- O compilador Rust inclui uma verificação de depuração (debug-assert) que garante que um ponteiro não contém o valor NULL ao ler e gravar tamanhos não nulos, assim como ao reempréstimo (reborrow) de um ponteiro para uma referência. Por exemplo, com a verificação de depuração ativada, o código abaixo agora resultará em um estado de "panic": let _x = *std::ptr::null::<u8>(); let _x = &*std::ptr::null::<u8>();
- Por padrão, a verificação de lint "missing_abi" está ativada, o que gera um aviso se um ABI não for especificado após a palavra-chave extern. Anteriormente, se um ABI não fosse especificado após extern, implicava-se que o ABI "C" estava sendo usado. Agora, é recomendado especificar explicitamente o ABI "C", por exemplo, 'extern "C" {}' e 'extern "C" fn'
- Uma nova leva de APIs foi traduzida para a categoria estável, incluindo estabilizações de métodos e implementações de traits:
- {float}::next_down
- {float}::next_up
- <[_]>::get_disjoint_mut
- <[_]>::get_disjoint_unchecked_mut
- slice::GetDisjointMutError
- HashMap::get_disjoint_mut
- HashMap::get_disjoint_unchecked_mut
- NonZero::count_ones
- Vec::pop_if
- sync::Once::wait
- sync::Once::wait_force
- sync::OnceLock::wait
- O modificador «const» é aplicado em funções:
- hint::black_box
- io::Cursor::get_mut
- io::Cursor::set_position
- str::is_char_boundary
- str::split_at
- str::split_at_checked
- str::split_at_mut
- str::split_at_mut_checked
- Foi implementado o terceiro nível de suporte para as plataformas {aarch64-unknown,x86_64-pc}-nto-qnx710_iosock, {aarch64-unknown,x86_64-pc}-nto-qnx800, {x86_64,i686}-win7-windows-gnu, amdgcn-amd-amdhsa, x86_64-pc-cygwin, {mips,mipsel}-mti-none-elf, m68k-unknown-none-elf, armv7a-nuttx-{eabi,eabihf}, aarch64-unknown-nuttx e thumbv7a-nuttx-{eabi,eabihf}. O terceiro nível implica suporte básico, mas sem teste automatizado, publicação de builds oficiais e verificação da capacidade de construção do código.
- Foi adicionado um aviso sobre a descontinuação do segundo nível de suporte para a plataforma de destino i586-pc-windows-msvc na próxima versão (1.87). Recomenda-se o uso da plataforma i686-pc-windows-msvc, que oferece suporte a instruções SSE2. A plataforma i586-pc-windows-msvc tornou-se obsoleta, pois o suporte a SSE2 é necessário para o Windows 10, e versões anteriores do Windows não são mais suportadas pelo Rust.
Adicionalmente, é importante notar que a empresa Ferrocene transmitiu à comunidade a especificação da linguagem Rust (FLS — Ferrocene Language Specification), criada durante o desenvolvimento de seu compilador Rust para sistemas críticos e sincronizada periodicamente com o estado atual do compilador Rust. A especificação FLS inclui um guia estruturado e detalhado sobre a sintaxe, semântica e comportamento de Rust, útil para verificação, avaliação de compatibilidade e padronização.
Os materiais fornecidos serão usados para criar uma especificação de referência para a linguagem Rust, que poderá ser utilizada no desenvolvimento de compiladores alternativos e para verificar o compilador em áreas críticas do ponto de vista da segurança.
Fonte: opennet.ru
