What changed in Go, Rust and Solidity this week.

// This program demonstrates that the new fields are not yet available in Go 1.27.1.
// It simply imports syscall, uses the existing SysProcAttr type, and prints its zero value.
// The output shows the struct with no custom fields, confirming the current API state.
package main

import (
	"fmt"
	"syscall"
)

func main() {
	// Create a zero-valued SysProcAttr and print it.
	// The struct contains only the fields that are currently defined in Go 1.27.1.
	var attr syscall.SysProcAttr
	fmt.Printf("Current SysProcAttr: %+v\n", attr)
}

// This program demonstrates how to iterate over the objects in a
// types.Scope in Go 1.27.1, where the proposed Objects() iterator
// is not yet available. It parses a small Go source file, builds
// its type information, and then walks the package scope printing
// each object's name and kind.
//
// In a future release that includes the change, the loop could be
// simplified to:
//   for obj := range pkg.Scope().Objects() { ... }
package main

import (
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
	"go/types"
)

func main() {
	// Create a file set and parse a tiny Go source snippet.
	fset := token.NewFileSet()
	src := `package main
func foo() {}
var x int`
	file, err := parser.ParseFile(fset, "example.go", src, 0)
	if err != nil {
		panic(err)
	}

	// Set up type checking for the file.
	conf := types.Config{Importer: nil}
	info := &types.Info{Defs: make(map[*ast.Ident]types.Object)}
	pkg, err := conf.Check("example", fset, []*ast.File{file}, info)
	if err != nil {
		panic(err)
	}

	// Iterate over the package scope using the existing API.
	s := pkg.Scope()
	for _, name := range s.Names() {
		obj := s.Lookup(name)
		fmt.Printf("%s: %s\n", name, obj.Type())
	}
}

// This program demonstrates that allocating many small structs is fast
// in Go 1.27.1 thanks to size‑specialized allocation. It measures the
// time to allocate 10 000 000 structs of 16 bytes each and prints the
// average time per allocation in nanoseconds.
package main

import (
	"fmt"
	"time"
)

type small struct {
	a, b uint64 // 16 bytes
}

func main() {
	const n = 10_000_000
	start := time.Now()
	// Allocate a slice of small structs. The runtime will use the
	// specialized allocator for 16‑byte objects.
	s := make([]small, n)
	// Touch the slice to keep the compiler from optimizing away the
	// allocation.
	for i := range s {
		s[i].a = uint64(i)
		s[i].b = uint64(i) * 2
	}
	elapsed := time.Since(start)
	avg := float64(elapsed.Nanoseconds()) / float64(n)
	fmt.Printf("Allocated %d small structs in %v (%.2f ns each)\n", n, elapsed, avg)
}

// This program simply prints the advisory message.
// It demonstrates how to display a warning in a Rust program.
fn main() {
    println!("⚠️  Security Advisory: Targeted attacks on prominent Rustaceans");
    println!("Please be cautious of unsolicited outreach and verify all contacts.");
}

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