What changed in Go, Rust and Solidity this week.

// This program demonstrates that the `-json` flag for `go version -m` is not
// available in Go 1.27.1. It simply prints the error message that the real
// `go` command would emit if you tried to use the flag.
package main

import "fmt"

func main() {
	// In Go 1.27.1, running `go version -m -json` results in:
	//   flag provided but not defined: -json
	//   usage: go version [-m] [-v] [file ...]
	// This program reproduces that message.
	fmt.Println("flag provided but not defined: -json")
	fmt.Println("usage: go version [-m] [-v] [file ...]")
}

// This program demonstrates the new //go:fix inline directive.
// The directive is currently a no‑op for the compiler, but a future
// migration tool would replace calls to add with its body.
package main

import "fmt"

//go:fix inline
func add(a, b int) int {
	return a + b
}

func main() {
	// The call to add could be inlined by the migration tool.
	fmt.Println(add(3, 4))
}

// This program demonstrates using the crypto/elliptic package to generate
// a P256 key pair and print the public point. It runs with Go 1.27.1
// and works with the security fix shipped in Go 1.23.6.

package main

import (
	"crypto/elliptic"
	"crypto/rand"
	"fmt"
)

func main() {
	// Choose the P256 curve.
	curve := elliptic.P256()

	// Generate a private/public key pair.
	priv, x, y, err := elliptic.GenerateKey(curve, rand.Reader)
	if err != nil {
		panic(err)
	}

	// Display the private key (in hex) and the public point coordinates.
	fmt.Printf("Private key: %x\n", priv)
	fmt.Printf("Public key X: %x\n", x)
	fmt.Printf("Public key Y: %x\n", y)
}

// This program demonstrates that Rust 1.84.1 compiles and runs as usual.
// It simply prints a message to confirm the environment is working.
fn main() {
    // Print a greeting
    println!("Hello, Rust 1.84.1 is running!");
}

// This program demonstrates that the Rust standard library has no direct
// relation to the crates.io development update.  It simply prints a message
// about the update, because the update is a web‑service change, not a
// language feature.

fn main() {
    println!("Crates.io now supports crate deletion, OpenAPI, and reporting.");
}

// This program demonstrates the current state of DMA mapping in Rust 1.98.1 (edition 2024).
// The new tooling update that improves resistance to Rust abstractions for DMA mapping
// has not yet shipped, so we simply simulate the mapping with a placeholder message.
fn main() {
    // In a real embedded environment, this would involve unsafe code to map a buffer
    // for DMA. Here we just print a confirmation to show the intended output.
    println!("Buffer mapped for DMA (demo).");
}

// This program demonstrates that the crate of the week is ratzilla.
// It does not compile until ratzilla is added as a dependency.
// For now, it simply prints a message about the crate.

fn main() {
    println!("This Week in Rust 585 highlighted the crate `ratzilla`.");
}

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