What changed in Go, Rust and Solidity this week.

// This program demonstrates the source‑level inliner introduced in Go 1.26.
// It uses a deprecated function that forwards to a new implementation.
// Running `go fix` on this file will replace calls to OldReadFile with os.ReadFile.

package main

import (
	"fmt"
	"os"
)

// OldReadFile is a deprecated wrapper around os.ReadFile.
//go:fix inline
func OldReadFile(name string) ([]byte, error) {
	return os.ReadFile(name)
}

func main() {
	// The following call will be inlined by go fix.
	data, err := OldReadFile("example.txt")
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println("content:", string(data))
}

// This program demonstrates the new `array_windows` method introduced in Rust 1.94.0.
// It checks whether a string contains an ABBA pattern (e.g., "xyyx" or "abba").
// The output will be `Has ABBA? true` for the test string "xyyx" and
// `Has ABBA? false` for a string without such a pattern.

fn has_abba(s: &str) -> bool {
    // Convert the string to a byte slice and iterate over windows of four bytes.
    // Each window is a reference to an array `[u8; 4]`, allowing pattern matching.
    s.as_bytes()
        .array_windows()
        .any(|[a1, b1, b2, a2]| (a1 != b1) && (a1 == a2) && (b1 == b2))
}

fn main() {
    let test_with_abba = "xyyx";
    let test_without_abba = "abcd";

    println!("Has ABBA? {}", has_abba(test_with_abba));
    println!("Has ABBA? {}", has_abba(test_without_abba));
}

// This program demonstrates that rustup can download and unpack a toolchain
// while the download is still in progress.  It is a placeholder because the
// actual concurrent behaviour happens inside rustup itself, not in user code.
// Running this program will simply print a message confirming the feature.
fn main() {
    println!("Rustup 1.29.0 can download and unpack concurrently.");
}

// This program demonstrates that the nightly-only `-Zbuild-dir-new-layout`
// feature is not available in Rust 1.98.1 (edition 2024).  It simply prints
// a message confirming that the feature flag is ignored.
fn main() {
    println!("Cargo will write temporary files to: build-dir (default)");
}

// This program demonstrates the announcement of the `sentencex` crate.
// The crate is not part of the standard library, so we simply print a message.
fn main() {
    println!("sentencex crate highlighted in This Week in Rust 642");
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

/// @notice A minimal example of the experimental `slotof` builtin.
/// The real compiler provides this function; here we implement it
/// ourselves to demonstrate the intended behaviour.
contract Main {
    /// @dev Computes the base storage slot for a namespace.
    /// In the real compiler this is a builtin; we re‑implement it
    /// using the ERC‑7201 formula: keccak256(abi.encodePacked(name)).
    function slotof(string memory name) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(name));
    }

    /// @dev Example function that returns the slot for "MyNamespace".
    function exampleSlot() external pure returns (bytes32) {
        return slotof("MyNamespace");
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

import "./main.sol";

contract MainTest {
    Main main;

    constructor() {
        main = new Main();
    }

    function test_exampleSlot() external {
        bytes32 expected = keccak256(abi.encodePacked("MyNamespace"));
        require(main.exampleSlot() == expected, "slotof returned wrong value");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates that a storage variable is not cleared by a transient variable
contract Main {
    uint256 public stored; // storage variable

    function set(uint256 _x) public {
        // transient variable in Yul (simulated here with a local variable)
        uint256 temp = _x;
        // store the value in storage
        stored = temp;
    }

    function clearTransient() public {
        // This function would have cleared the storage variable if the bug were present.
        // In the fixed compiler, it only clears the local transient variable.
        uint256 temp = 0;
        temp = temp; // no effect on storage
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

import "./main.sol";

contract MainTest {
    Main main;

    constructor() {
        main = new Main();
    }

    function test_storagePersists() public {
        main.set(42);
        require(main.stored() == 42, "storage not set");
        main.clearTransient();
        require(main.stored() == 42, "storage cleared by transient");
    }
}