What changed in Go, Rust and Solidity this week.

// This program demonstrates that the external auth helper no longer exists.
// It simply prints a message indicating that authentication logic is now
// part of the go command. No network or external packages are used.
package main

import "fmt"

func main() {
    fmt.Println("The golang.org/x/tools/cmd/auth helper has been removed.")
    fmt.Println("Authentication is now handled internally by the go command.")
}

// This program demonstrates that the `TB.Attr` method is not available in Go 1.27.1.
// Attempting to call it would result in a compile‑time error. Instead we use `t.Log`
// to emit a message that would appear in the test log when running with `go test -json`.

package main

import (
	"testing"
)

func TestExample(t *testing.T) {
	// In Go 1.27.1, the following line would fail to compile:
	// t.Attr("key", "value")
	// Instead we log a message that can be captured by test2json.
	t.Log("key=value")
}

func main() {
	// The main function is required to make this a complete program,
	// but it does nothing. The test is run by `go test`.
}

// This program demonstrates that the `testing.B.Loop` helper is available
// in Go 1.27.1. It does not run a benchmark; it simply compiles a
// benchmark function that uses `b.Loop()` and prints a confirmation.
package main

import (
	"fmt"
	"testing"
)

// BenchmarkExample shows the new `b.Loop()` syntax. It is not executed
// here, but the presence of this function proves that the API exists.
func BenchmarkExample(b *testing.B) {
	for b.Loop() {
		// The body would contain the code to benchmark.
	}
}

func main() {
	fmt.Println("testing.B.Loop is available in Go 1.27.1")
}

// This program demonstrates the manual trait upcasting that was
// stabilized in Rust 1.86.0.  Since Rust 1.98.1 (edition 2024) does not
// yet support the built‑in upcast syntax, we perform the cast
// explicitly with `as &dyn Supertrait`.  The output confirms that the
// cast succeeded and that the `Supertrait` method can be called.

trait Supertrait {
    fn hello(&self) -> &'static str;
}

trait Trait: Supertrait {}

struct Impl;

impl Supertrait for Impl {
    fn hello(&self) -> &'static str {
        "Hello from Supertrait"
    }
}

impl Trait for Impl {}

fn main() {
    let obj = Impl;
    // Manual upcast: &dyn Trait -> &dyn Supertrait
    let super_ref: &dyn Supertrait = &obj as &dyn Trait as &dyn Supertrait;
    println!("{}", super_ref.hello());
}

// This program demonstrates the changes introduced in mdbook v0.4.48.
// It prints a short summary of the new features.
// The program compiles and runs on Rust 1.98.1 (edition 2024).

fn main() {
    // Footnotes now have back‑reference links and are rendered only at the bottom.
    println!("Footnotes: back‑reference links, bottom‑of‑page rendering");

    // Auto theme selection defaults to the system‑preferred mode and switches automatically.
    println!("Theme: auto selection based on system preference");

    // The search index file `searchindex.json` has been removed; only `searchindex.js` is generated.
    println!("Search index: only searchindex.js generated, searchindex.json removed");
}

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