What changed in Go, Rust and Solidity this week.

// This program demonstrates the new go:fix directives.
// It will not compile until the change ships in a future Go release.
// The comments below describe how go:fix would rewrite the code.

package main

import "fmt"

// Deprecated: Use io.SeekStart instead.
//go:fix-to io.SeekStart
const SEEK_SET int = 0

func main() {
	// Before go:fix, this would use the old constant name.
	// After go:fix, the line below would be rewritten to use io.SeekStart.
	fmt.Println(SEEK_SET)
}

// This program demonstrates how Go handles nil slices with built‑in
// operations. It does not use the experimental slices package because
// that package is not part of the standard library and cannot be imported
// in a sandboxed Go 1.27.1 environment.
package main

import "fmt"

func main() {
	// A nil slice has no underlying array and its value is nil.
	var nilSlice []int
	fmt.Printf("nilSlice is nil: %v\n", nilSlice == nil)

	// Converting an empty composite literal to a slice yields a non‑nil slice.
	emptyLiteral := []int{}
	fmt.Printf("emptyLiteral is nil: %v\n", emptyLiteral == nil)

	// Slicing a nil slice preserves nilness.
	var x []int
	y := x[:0]
	fmt.Printf("x[:0] preserves nilness: %v\n", y == nil)

	// Append to a nil slice returns a non‑nil slice unless the result is empty.
	// Here we append nothing, so the result remains nil.
	z := append(x, []int{}...)
	fmt.Printf("append(nil, []int{}...) is nil: %v\n", z == nil)

	// Appending an element to a nil slice creates a non‑nil slice.
	w := append(x, 42)
	fmt.Printf("append(nil, 42) is nil: %v\n", w == nil)
}

// This program demonstrates the idea of triagebot shortcuts.
// The actual bot integration is not part of the Rust compiler,
// so we just print what a shortcut would do.

fn main() {
    // Simulate a comment containing a shortcut.
    let comment = "@rustbot author";

    // In the real bot, this string would be parsed and an action taken.
    // Here we just show the intended effect.
    if comment.contains("@rustbot author") {
        println!("Assigning PR to the author.");
    } else if comment.contains("@rustbot ready") {
        println!("Marking PR as ready for review.");
    } else {
        println!("No recognized shortcut.");
    }
}

// This program demonstrates that the change does not affect Rust code.
// The missing word was added to the RFC text, not to the language itself.
fn main() {
    println!("Rust code runs unchanged after the RFC update.");
}

// This program simply prints a message. The change in the RFC does not affect any code.
fn main() {
    println!("Rust 1.98.1 (edition 2024) runs this program unchanged.");
}

// 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");
    }
}