What changed in Go, Rust and Solidity this week.

// This program demonstrates that the packages
// golang.org/x/tools/refactor/rename,
// golang.org/x/tools/refactor/importgraph,
// golang.org/x/tools/go/buildutil,
// and golang.org/x/tools/cmd/gomvpkg
// are still importable but will no longer receive updates.
// In this sandbox we cannot fetch external modules, so the imports would fail.
// In a real environment, the following imports would compile and the program would run.
package main

import (
	"fmt"
	// _ "golang.org/x/tools/refactor/rename"
	// _ "golang.org/x/tools/refactor/importgraph"
	// _ "golang.org/x/tools/go/buildutil"
	// _ "golang.org/x/tools/cmd/gomvpkg"
)

func main() {
	fmt.Println("The x/tools refactor and build utilities are still available but are now frozen.")
}

// This program demonstrates the current behavior of xml.Decoder in Go 1.27.1.
// The Decoder has a Strict field but no Check field. Setting Strict to false
// allows the parser to invent missing end tags and ignore malformed entities.
package main

import (
	"encoding/xml"
	"fmt"
	"strings"
)

func main() {
	// XML with a missing end tag and an unknown entity.
	data := `<root><child>Some &unknown; text</child><empty></root>`

	// Create a decoder that does not enforce strict validation.
	dec := xml.NewDecoder(strings.NewReader(data))
	dec.Strict = false

	for {
		tok, err := dec.Token()
		if err != nil {
			break
		}
		switch v := tok.(type) {
		case xml.StartElement:
			fmt.Printf("Start: %s\n", v.Name.Local)
		case xml.EndElement:
			fmt.Printf("End: %s\n", v.Name.Local)
		case xml.CharData:
			fmt.Printf("Char: %s\n", strings.TrimSpace(string(v)))
		}
	}
}

// This program demonstrates that the net/http package is usable in Go 1.27.1.
// It performs a simple GET request and prints the result. The request
// will fail in the sandbox because network access is disabled, but the
// code compiles and runs without panicking, showing that the security
// fixes in go1.23.7 do not alter the public API or basic behaviour.
package main

import (
	"fmt"
	"net/http"
)

func main() {
	resp, err := http.Get("http://example.com")
	if err != nil {
		fmt.Println("request error:", err)
		return
	}
	defer resp.Body.Close()
	fmt.Println("status code:", resp.StatusCode)
}

// This program demonstrates that rustup 1.28.0 has been released.
// It simply prints a message; there is no code change to illustrate.
fn main() {
    println!("rustup 1.28.0 is now available");
}

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