Lançamento do Rust 1.53. O Google financiará a adição de suporte ao Rust no kernel do Linux

Foi lançado o Rust 1.53, uma linguagem de programação de sistemas que começou como um projeto da Mozilla, mas agora é desenvolvida sob a supervisão da organização sem fins lucrativos Rust Foundation. A linguagem é focada na segurança da memória, oferece gerenciamento automático de memória e fornece recursos para atingir alta conciliação na execução de tarefas, sem precisar de um coletor de lixo ou runtime (o runtime é restrito à inicialização básica e ao suporte da biblioteca padrão).

O gerenciamento automático de memória em Rust livra os desenvolvedores de erros ao manipular ponteiros e os protege de problemas resultantes do trabalho de baixo nível com a memória, como acessar a memória após a liberação, desreferenciar ponteiros nulos, transbordamento de buffer, entre outros. Para distribuição de bibliotecas, construção e gerenciamento de dependências, o gerenciador de pacotes Cargo está em desenvolvimento. Um repositório, crates.io, é suportado para hospedar bibliotecas.

Principais novidades:

• O traço IntoIterator foi implementado para arrays, permitindo a iteração sobre os elementos do array por valores: for i in [1, 2, 3] { .. }

  Agora também é possível passar arrays em métodos que aceitam iteradores, por exemplo: let set = BTreeSet::from_iter([1, 2, 3]); for (a, b) in some_iterator.chain([1]).zip([1, 2, 3]) { .. }

  Anteriormente, o IntoIterator só estava implementado para referências a arrays, isto é, para iterar sobre os valores era necessário usar referências ('&[1, 2, 3]') ou '[1, 2, 3].iter()'. A implementação de IntoIterator para arrays foi complicada por problemas de compatibilidade causados pela conversão anteriormente adicionada no compilador de array.into_iter() em (&array).into_iter(). Esses problemas foram resolvidos da maneira mais simples — o compilador continuará a converter array.into_iter() em (&array).into_iter() como se a implementação do traço IntoIterator não existisse, mas apenas ao chamar o método usando a sintaxe '.into_iter()' e sem afetar chamadas na forma 'in [1, 2, 3]', 'iter.zip([1, 2, 3])', 'IntoIterator::into_iter([1, 2, 3])'.

• Agora é possível especificar expressões '| ' (operação lógica OR) em qualquer parte do padrão, por exemplo, em vez de 'Some(1) | Some(2)', agora pode-se escrever 'Some(1 | 2)': match result { Ok(Some(1 | 2)) => { .. } Err(MyError { kind: FileNotFound | PermissionDenied, .. }) => { .. } _ => { .. } }
• O uso de caracteres não ASCII é permitido em identificadores, incluindo quaisquer caracteres nacionais definidos na especificação Unicode UAX 31, exceto caracteres emoji. Ao usar caracteres diferentes, mas semelhantes em aparência, o compilador emitirá um aviso. const BLÅHAJ: &str = «🦈»; struct 人 { 名字: String, } let α = 1; let ｓos = 2; aviso: par de identificadores considerado confuso entre ‘ｓ’ e ‘s’
• Uma nova porção da API foi classificada como estável, incluindo as seguintes funcionalidades estabilizadas:
  • array::from_ref
  • array::from_mut
  • AtomicBool::fetch_update
  • AtomicPtr::fetch_update
  • BTreeSet::retain
  • BTreeMap::retain
  • BufReader::seek_relative
  • cmp::min_by
  • cmp::min_by_key
  • cmp::max_by
  • cmp::max_by_key
  • DebugStruct::finish_non_exhaustive
  • Duration::ZERO
  • Duration::MAX
  • Duration::is_zero
  • Duration::saturating_add
  • Duration::saturating_sub
  • Duration::saturating_mul
  • f32::is_subnormal
  • f64::is_subnormal
  • IntoIterator para arrays
  • {integer}::BITS
  • io::Error::Unsupported
  • NonZero*::leading_zeros
  • NonZero*::trailing_zeros
  • Option::insert
  • Ordering::is_eq
  • Ordering::is_ne
  • Ordering::is_lt
  • Ordering::is_gt
  • Ordering::is_le
  • Ordering::is_ge
  • OsStr::make_ascii_lowercase
  • OsStr::make_ascii_uppercase
  • OsStr::to_ascii_lowercase
  • OsStr::to_ascii_uppercase
  • OsStr::is_ascii
  • OsStr::eq_ignore_ascii_case
  • Peekable::peek_mut
  • Rc::increment_strong_count
  • Rc::decrement_strong_count
  • slice::IterMut::as_slice
  • AsRef<[T]> para slice::IterMut
  • impl SliceIndex para (Bound<usize>, Bound<usize>)
  • Vec::extend_from_within
• Foi implementado o terceiro nível de suporte para a plataforma wasm64-unknown-unknown. O terceiro nível implica suporte básico, mas sem testes automatizados, publicação de versões oficiais e verificação da possibilidade de compilar o código.
• O gerenciador de pacotes Cargo agora usa por padrão o nome "main" para o branch principal do repositório Git (HEAD). Para dependências hospedadas em repositórios que usam o nome main em vez de master, não é mais necessário especificar nas configurações branch = "main".
• Os requisitos para a versão mínima do LLVM foram aumentados para LLVM 10.

Além disso, pode-se notar que foi fornecido financiamento para o desenvolvimento da integração no núcleo Linux para ferramentas de desenvolvimento de componentes na linguagem Rust. O trabalho será realizado no projeto Prossimo sob a égide da organização ISRG (Internet Security Research Group), que é a fundadora do projeto Let’s Encrypt e contribui para a promoção do HTTPS e o desenvolvimento de tecnologias para aumentar a segurança da internet. Os fundos serão fornecidos pela Google, que custeará o trabalho de Miguel Ojeda, autor do projeto Rust-for-Linux. Anteriormente, a ISRG e a Google já financiaram a criação de um backend HTTP alternativo para a ferramenta curl e o desenvolvimento de um novo módulo TLS para o servidor http Apache.

De acordo com empresas como Microsoft e Google, cerca de 70% das vulnerabilidades são causadas por manipulação insegura da memória. Espera-se que o uso da linguagem Rust para o desenvolvimento de componentes do núcleo, como drivers de dispositivos, reduza o risco de vulnerabilidades causadas por manipulação insegura da memória e elimine erros como o acesso a áreas de memória após a liberação e estouro de buffer.

A segurança no manuseio da memória é garantida no Rust durante a compilação através da verificação de referências, rastreamento da propriedade dos objetos e consideração do tempo de vida dos objetos (escopo), bem como pela avaliação da correção do acesso à memória durante a execução do código. O Rust também oferece ferramentas para proteção contra estouros inteiros, exige a inicialização obrigatória dos valores das variáveis antes do uso, lida melhor com erros na biblioteca padrão, aplica o conceito de imutabilidade (immutable) para referências e variáveis por padrão e oferece forte tipagem estática para minimizar erros lógicos.

Fonte: opennet.ru