What changed in Go, Rust and Solidity this week.

// This program demonstrates that the new ExtKeyUsage.OID method is not
// available in Go 1.27.1. It simply prints a message explaining the
// current limitation.

package main

import "fmt"

func main() {
	// In Go 1.27.1 the crypto/x509 package does not expose an OID() method
	// on the ExtKeyUsage type, so we cannot retrieve the ASN.1 object
	// identifier of an extended key usage directly.
	fmt.Println("ExtKeyUsage.OID is not available in Go 1.27.1")
}

// This program demonstrates that the mlkemtest package is not available in Go 1.27.1.
// It simply prints a message indicating the absence of the new API.
package main

import "fmt"

func main() {
	fmt.Println("The crypto/mlkem/mlkemtest package is not part of Go 1.27.1.")
}

// This program demonstrates the fixed behaviour of url.Parse in Go 1.24.10.
// It parses a URL with an uncommon scheme and prints the components.
package main

import (
	"fmt"
	"net/url"
)

func main() {
	// URL with a non‑standard scheme that previously caused a panic.
	u, err := url.Parse("custom://example.com/path?query=1")
	if err != nil {
		fmt.Println("Parse error:", err)
		return
	}
	fmt.Println("Scheme:", u.Scheme)
	fmt.Println("Host:", u.Host)
	fmt.Println("Path:", u.Path)
	fmt.Println("RawQuery:", u.RawQuery)
}

// This program demonstrates that the standard library still works after the
// 1.25.4 fixes. It parses a URL and prints its components.
package main

import (
	"fmt"
	"net/url"
)

func main() {
	u, err := url.Parse("https://example.com/path?query=1")
	if err != nil {
		panic(err)
	}
	fmt.Printf("Scheme: %s\nHost: %s\nPath: %s\nQuery: %s\n",
		u.Scheme, u.Host, u.Path, u.RawQuery)
}

// This program demonstrates the newly stabilized `Path::file_prefix` API,
// which is available in Rust 1.91.0 and later. It prints the file prefix
// component of a path, if one exists.

use std::path::Path;

fn main() {
    // A path that has a file prefix (e.g., "foo/bar.txt" has "foo" as the prefix).
    let path = Path::new("foo/bar.txt");

    // `file_prefix` returns an `Option<&Path>` containing the prefix.
    match path.file_prefix() {
        Some(prefix) => println!("File prefix: {}", prefix.display()),
        None => println!("No file prefix found."),
    }
}

// This program demonstrates the current limitation: the `asm!` macro
// is unstable and not available on Rust 1.98.1 (edition 2024).  The
// proposed change would allow a const pointer to be passed to the
// `asm!` operand, expanding to the symbol name and an optional
// offset.  Since the feature is not yet stable, the code below
// intentionally fails to compile, illustrating the problem that
// the RFC aims to solve.

fn main() {
    const VALUE: *const i32 = &42;
    let mut out: i32 = 0;

    // The following line would compile once the change is stable:
    // asm!("mov {}, {}", in(reg) VALUE, out(reg) out, options(nostack));

    // On stable Rust 1.98.1 this macro is not available, so the
    // compiler emits an error.  The error message is shown in the
    // comment above.
}

// This program simply demonstrates that the Rust toolchain is available.
// The RFC markup changes are unrelated to Rust code, so we just print a message.
fn main() {
    println!("RFC markup fixes have been applied.");
}

// This program is unrelated to the mdbook change; it simply demonstrates
// that the Rust compiler can run a basic program. The mdbook feature is
// a tool‑chain improvement, not a Rust language feature.
fn main() {
    println!("mdbook serve now reloads on file changes (but not new files).");
}

// This program demonstrates the new PR template warning.
// It simply prints the warning text that appears in the RFC PR template.
fn main() {
    println!("When responding to RFCs, try to use inline review comments");
    println!("instead of direct comments for normal comments and keep");
    println!("normal comments for procedural matters.");
}

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

// This contract demonstrates that delete on a memory bytes array element
// clears only the targeted byte, not the whole 32‑byte word.
contract Main {
    function clearByte(uint index) external pure returns (bytes memory) {
        bytes memory data = new bytes(5);
        // set all bytes to 0xFF for visibility
        for (uint i = 0; i < data.length; i++) {
            data[i] = 0xFF;
        }
        // delete the element at `index`
        delete data[index];
        return data;
    }
}

Tests

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

import "./main.sol";

contract MainTest {
    Main main;

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

    function test_singleByteCleared() public {
        bytes memory result = main.clearByte(2);
        // bytes[2] should be 0x00, others remain 0xFF
        require(result[2] == 0x00, "byte not cleared");
        require(result[0] == 0xFF, "other byte altered");
        require(result[1] == 0xFF, "other byte altered");
        require(result[3] == 0xFF, "other byte altered");
        require(result[4] == 0xFF, "other byte altered");
    }
}

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

// This contract demonstrates the 0.8.37 delete‑byte‑array‑element fix.
// It creates a memory bytes array, sets each element to 0x01,
// deletes the middle element, and returns the array.
contract Demo {
    function deleteMiddle() external pure returns (bytes memory) {
        bytes memory b = new bytes(3);
        b[0] = 0x01;
        b[1] = 0x01;
        b[2] = 0x01;
        delete b[1]; // only b[1] should become 0x00
        return b;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;
import "./main.sol";

contract DemoTest {
    Demo demo;

    constructor() {
        demo = new Demo();
    }

    function test_deleteLeavesOtherBytes() external {
        bytes memory result = demo.deleteMiddle();
        require(result.length == 3, "wrong length");
        require(result[0] == 0x01, "b[0] altered");
        require(result[1] == 0x00, "b[1] not zeroed");
        require(result[2] == 0x01, "b[2] altered");
    }
}