Rust 1.91.1: Patch Release Critica - Release Novembre 2025

Rust 1.91.1 è stato rilasciato il 10 novembre 2025. Questa patch release corregge due regressioni critiche introdotte nella 1.91.0: il fix WebAssembly cross-crate symbols e il ripristino del file locking su illumos. Update consigliato per tutti!

🎯 Fix Principali

WebAssembly Cross-Crate Symbols Fix

Risolto bug critico wasm_import_module attribute!

Il Problema (1.91.0)

// ❌ Rust 1.91.0 - BROKEN!

// crate A
#[link(wasm_import_module = "custom_env")]
extern "C" {
    fn external_function(x: i32) -> i32;
}

// crate B (depends on A)
pub fn use_external() {
    // ❌ Linker error o runtime crash!
    let result = external_function(42);
}

Cosa causava:

• 🔴 Linker errors durante compilazione cross-crate
• 🔴 Runtime crashes se linking riusciva
• 🔴 Data corruption da symbol mismatch

La Soluzione (1.91.1)

// ✅ Rust 1.91.1 - FIXED!

// crate A
#[link(wasm_import_module = "custom_env")]
extern "C" {
    fn external_function(x: i32) -> i32;
}

// crate B (depends on A)
pub fn use_external() {
    // ✅ Funziona correttamente!
    let result = external_function(42);
}

Background tecnico:

WebAssembly identifica symbols con doppia identificazione:

;; Symbol identification in Wasm
(import "module_name" "symbol_name" ...)
         ^^^^^^^^^^^   ^^^^^^^^^^^
         Wasm module   Symbol name

Differenza con altri targets:

Target	Symbol ID	Example
Linux/Mac/Windows	Nome solo	external_function
WebAssembly	Modulo + Nome	("env", "external_function")

Il bug 1.91.0:

L'attributo #[link(wasm_import_module)] non propagava correttamente attraverso crate boundaries:

// Crate A definisce
#[link(wasm_import_module = "custom")]  // Module = "custom"

// Crate B riceveva
// Module = "env" (default errato!)  ❌

// Risultato: symbol mismatch → linker error

illumos File Locking Fix

Ripristinato file locking per Cargo su illumos!

Il Problema (1.91.0)

# ❌ Cargo 1.91.0 su illumos
cargo build

# Internamente:
# File::lock() → sempre Unsupported ❌
# Cargo → nessun lock su target/ ❌
# Risultato: possibili race conditions! 🔴

Conseguenze:

• 🔴 Concurrent builds potevano corrompere artifacts
• 🔴 Build instabili su illumos
• 🔴 Race conditions su shared filesystems

La Soluzione (1.91.1)

// ✅ Rust 1.91.1 - File::lock restored

use std::fs::File;

let file = File::create("lockfile")?;

// ✅ Su illumos ora funziona correttamente!
file.lock_exclusive()?;
// Fa il build
file.unlock()?;

Background tecnico:

Cargo 1.91.0 migration:

// Prima (custom code)
#[cfg(target_os = "illumos")]
fn lock_directory(path: &Path) -> Result<Lock> {
    // Custom OS API calls ✅
}

// Dopo 1.91.0 (standard library)
fn lock_directory(path: &Path) -> Result<Lock> {
    let file = File::open(path)?;
    file.lock_exclusive()?;  // ❌ Sempre Unsupported su illumos!
    Ok(Lock { file })
}

Il bug: File::lock_exclusive() non era implementato correttamente per illumos!

// std/src/sys/unix/fs.rs (simplified)

#[cfg(target_os = "illumos")]
impl File {
    fn lock_exclusive(&self) -> io::Result<()> {
        // ❌ Rust 1.91.0
        Err(io::Error::new(io::ErrorKind::Unsupported, "not supported"))

        // ✅ Rust 1.91.1
        // Implementazione corretta con fcntl/flock
    }
}

Fix 1.91.1:

• ✅ Implementata corretta chiamata fcntl() per illumos
• ✅ File locking ora funzionale su filesystem supportati
• ✅ Cargo può lockare target/ correttamente

📊 Context: Rust 1.91.0 Features

Per riferimento, le feature principali di 1.91.0 (30 Ottobre 2025):

aarch64-pc-windows-msvc → Tier 1

# ✅ Pieno supporto Windows ARM64
rustup target add aarch64-pc-windows-msvc

# Garantiti:
# - Full test suite su ogni commit
# - Prebuilt binaries disponibili
# - Supporto production-ready

Dangling Raw Pointer Lint

// ⚠️ Warn by default
fn get_pointer() -> *const i32 {
    let x = 42;
    &x as *const i32  // ⚠️ Warning: returning pointer to local!
}

// ✅ Correct patterns
fn get_pointer_safe() -> *const i32 {
    Box::leak(Box::new(42)) as *const i32
}

static VALUE: i32 = 42;
fn get_static_pointer() -> *const i32 {
    &VALUE as *const i32
}

Stabilized APIs (1.91.0)

use std::path::Path;
use std::sync::atomic::{AtomicPtr, Ordering};

// Path absolute/normalize
let path = Path::new("./src/../main.rs");
let absolute = path.canonicalize()?;  // ✅ Stabilized

// Atomic pointer methods
let ptr = AtomicPtr::new(Box::leak(Box::new(42)));
let old = ptr.swap(std::ptr::null_mut(), Ordering::SeqCst);

// Integer methods
let n: i32 = -42;
let abs = n.unsigned_abs();  // ✅ Returns u32

🔄 Upgrade

Installazione/Update

# Update esistente
rustup update stable

# Da zero
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Verifica versione
rustc --version
# rustc 1.91.1 (stable)

Migrazione da 1.91.0

# 1. Update Rust
rustup update stable

# 2. Clean e rebuild (risolve Wasm/illumos issues)
cargo clean
cargo build

# 3. Verifica fix Wasm (se usi Wasm target)
cargo build --target wasm32-unknown-unknown

# 4. Test completo
cargo test

Chi Deve Upgradare SUBITO

🔴 CRITICO - Upgrade immediato:

• ✅ WebAssembly projects con cross-crate symbols
• ✅ illumos users (Cargo builds instabili)
• ✅ Progetti usando #[link(wasm_import_module)]

🟡 CONSIGLIATO:

• ✅ Tutti i progetti Rust in production
• ✅ CI/CD pipelines
• ✅ Shared development environments

Testing Post-Upgrade

# Test Wasm fix
cargo build --target wasm32-unknown-unknown --release
wasm-bindgen target/wasm32-unknown-unknown/release/my_crate.wasm

# Test illumos fix (su illumos)
cargo build -j 4  # Concurrent builds dovrebbero funzionare

# Integration tests
cargo test --workspace

💡 Conclusioni

Rust 1.91.1 è una patch release critica:

✅ WebAssembly fix - Cross-crate symbols funzionanti ✅ illumos fix - File locking ripristinato ✅ Stability - Regressioni 1.91.0 risolte ✅ Production ready - Safe per deploy immediato ✅ Backward compatible - Drop-in replacement

Impatto:

Issue	Severità	Impatto	Fix
Wasm symbols	🔴 CRITICO	Linker errors, crashes	✅ Risolto
illumos locking	🔴 CRITICO	Build corruption	✅ Risolto

Timeline:

• 30 Ottobre 2025: Rust 1.91.0 released (con bugs)
• 10 Novembre 2025: Rust 1.91.1 released (fix critici)

Prossimi rilasci:

• 11 Dicembre 2025: Rust 1.92.0 (scheduled)
• 22 Gennaio 2026: Rust 1.93.0 (scheduled)

Action items:

# 1. Update NOW
rustup update stable

# 2. Rebuild projects
cargo clean && cargo build

# 3. Run tests
cargo test

# 4. Deploy with confidence! 🚀