Foi publicado o lançamento da linguagem de programação de uso geral Rust 1.64, fundada pelo projeto Mozilla, mas agora desenvolvida sob os auspícios da organização independente sem fins lucrativos Rust Foundation. A linguagem se concentra na segurança da memória e fornece os meios para obter alto paralelismo de trabalho, evitando o uso de um coletor de lixo e tempo de execução (o tempo de execução é reduzido à inicialização básica e manutenção da biblioteca padrão).
Os métodos de manipulação de memória do Rust salvam o desenvolvedor de erros ao manipular ponteiros e protegem contra problemas que surgem devido ao manuseio de memória de baixo nível, como acessar uma área de memória após ter sido liberada, desreferenciar ponteiros nulos, saturação de buffer, etc. Para distribuir bibliotecas, prover builds e gerenciar dependências, o projeto desenvolve o gerenciador de pacotes Cargo. O repositório crates.io é compatível com hospedagem de bibliotecas.
A segurança da memória é fornecida no Rust em tempo de compilação por meio de verificação de referência, acompanhando a propriedade do objeto, acompanhando o tempo de vida do objeto (escopos) e avaliando a exatidão do acesso à memória durante a execução do código. Rust também fornece proteção contra estouros de número inteiro, requer inicialização obrigatória de valores de variáveis antes do uso, lida melhor com erros na biblioteca padrão, aplica o conceito de referências e variáveis imutáveis por padrão, oferece tipagem estática forte para minimizar erros lógicos.
Principais inovações:
- Os requisitos para o ambiente Linux no compilador, o gerenciador de pacotes Cargo e a biblioteca padrão libstd foram aumentados - os requisitos mínimos para Glibc foram aumentados da versão 2.11 para 2.17, e o kernel Linux da versão 2.6.32 para 3.2. As restrições também se aplicam a executáveis de aplicativos Rust criados com libstd. Os kits de distribuição RHEL 7, SLES 12-SP5, Debian 8 e Ubuntu 14.04 atendem aos novos requisitos. O suporte para RHEL 6, SLES 11-SP4, Debian 7 e Ubuntu 12.04 será descontinuado. Os usuários que usam executáveis construídos em Rust em ambientes com um kernel Linux mais antigo são incentivados a atualizar seus sistemas, permanecer em versões mais antigas do compilador ou manter seu próprio fork libstd com camadas para manter a compatibilidade.
Entre os motivos para encerrar o suporte para sistemas Linux mais antigos estão os recursos limitados para continuar mantendo a compatibilidade com ambientes mais antigos. O suporte para Glibc legado requer o uso de ferramentas legadas ao fazer check-in em um sistema de integração contínua, diante dos crescentes requisitos de versão em LLVM e utilitários de compilação cruzada. O aumento nos requisitos de versão do kernel se deve à capacidade de usar novas chamadas de sistema no libstd sem a necessidade de manter camadas para garantir compatibilidade com kernels mais antigos.
- A característica IntoFuture foi estabilizada, que se assemelha ao IntoIterator, mas difere deste último por usar loops “.await” em vez de “for...in...”. Quando combinada com IntoFuture, a palavra-chave ".await" pode esperar não apenas uma característica Future, mas também quaisquer outros tipos que possam ser convertidos em Future.
- O utilitário analisador de ferrugem está incluído na coleção de utilitários fornecidos com as versões do Rust. O utilitário também está disponível para instalação usando o Rustup (componente Rustup e analisador de ferrugem).
- O gerenciador de pacotes Cargo inclui herança de espaço de trabalho para eliminar a duplicação de valores de campos comuns entre pacotes, como versões Rust e URLs de repositório. Também foi adicionado suporte para construção de várias plataformas de destino ao mesmo tempo (agora você pode especificar mais de um parâmetro na opção “--target”).
- Uma nova parte da API foi movida para a categoria de estável, incluindo os métodos e implementações de características que foram estabilizadas:
- futuro::IntoFuture
- num::NonZero*::checked_mul
- num::NonZero*::checked_pow
- num::NonZero*::saturating_mul
- num::NonZero*::saturating_pow
- num::NonZeroI*::abs
- num::NonZeroI*::checked_abs
- num::NonZeroI*::overflowing_abs
- num::NonZeroI*::saturating_abs
- num::NonZeroI*::unsigned_abs
- num::NonZeroI*::wrapping_abs
- num::NonZeroU*::checked_add
- num::NonZeroU*::checked_next_power_of_two
- num::NonZeroU*::saturating_add
- os::unix::process::CommandExt::process_group
- os::windows::fs::FileTypeExt::is_symlink_dir
- os::windows::fs::FileTypeExt::is_symlink_file
- Tipos compatíveis com C, previamente estabilizados no módulo std::ffi, foram adicionados ao núcleo e à biblioteca alloc:
- núcleo::ffi::CStr
- core::ffi::FromBytesWithNulError
- aloc::ffi::CString
- aloc::ffi::FromVecWithNulError
- alloc::ffi::IntoStringError
- aloc::ffi::NulError
- Os tipos C previamente estabilizados no módulo std::os::raw foram adicionados aos módulos core::ffi e std::ffi (por exemplo, os tipos c_uint e c_ulong foram propostos para os tipos C uint e ulong):
- ffi::c_char
- ffi::c_double
- ffi::c_float
- ffi::c_int
- ffi::c_long
- ffi::c_longlong
- ffi::c_schar
- ffi::c_short
- ffi::c_uchar
- ffi::c_uint
- ffi::c_ulong
- ffi::c_ulonglong
- ffi::c_ushort
- Os manipuladores de baixo nível foram estabilizados para uso com o mecanismo Poll (no futuro está planejado fornecer uma API simplificada que não exija o uso de estruturas de baixo nível, como Pull e Pin):
- futuro::poll_fn
- tarefa::pronto!
- O atributo “const”, que determina a possibilidade de utilizá-lo em qualquer contexto ao invés de constantes, é utilizado na função slice::from_raw_parts.
- Para armazenar dados de forma mais compacta, o layout de memória das estruturas Ipv4Addr, Ipv6Addr, SocketAddrV4 e SocketAddrV6 foi alterado. Pode haver um problema de compatibilidade com pacotes de caixa única que usam std::mem::transmute para manipulação de estruturas de baixo nível.
- A construção do compilador Rust para a plataforma Windows utiliza otimizações PGO (otimização guiada por perfil), que possibilitou aumentar o desempenho de compilação de código em 10-20%.
- O compilador implementou um novo aviso sobre campos não utilizados em determinadas estruturas.
Além disso, pode-se observar o relatório de status do desenvolvimento de uma implementação alternativa do compilador da linguagem Rust, elaborado pelo projeto gccrs (GCC Rust) e aprovado para inclusão no GCC. Após a integração do frontend, as ferramentas padrão do GCC podem ser utilizadas para compilar programas na linguagem Rust sem a necessidade de instalação do compilador Rustc, construído usando desenvolvimentos LLVM. Enquanto o desenvolvimento estiver no caminho certo, e salvo problemas imprevistos, o frontend Rust será integrado ao lançamento do GCC 13 agendado para maio do próximo ano. A implementação do Rust no GCC 13 estará em status beta, ainda não habilitada por padrão.
Fonte: opennet.ru