What changed in Go, Rust and Solidity this week.

// This program demonstrates how a GODEBUG flag is handled when it is
// marked as deprecated and then removed.  The flag "panicnil" is a
// real flag that existed in Go 1.21.  In this sandbox we simulate the
// deprecation logic by checking the flag value and printing a warning
// if it is set to a non‑default value.  The program then proceeds
// normally, ignoring the flag value because the flag has been removed
// in the current release.
//
// Note: In Go 1.27.1 the flag is still present, but the policy would
// have removed it in a future release.  This example shows the
// deprecation warning that would be emitted by tools.

package main

import (
	"fmt"
	"os"
)

func main() {
	// Read the GODEBUG environment variable.
	godebug := os.Getenv("GODEBUG")
	// For simplicity we only look for the "panicnil" flag.
	// In a real tool this would parse all flags.
	if godebug != "" {
		// Simulate deprecation: warn if panicnil is set to 1.
		if godebug == "panicnil=1" {
			fmt.Println("WARNING: panicnil is deprecated; setting it to 1 will be ignored.")
		}
	}
	// The rest of the program runs normally.
	fmt.Println("Program running with panicnil default (0).")
}

package main

import (
	"crypto/x509"
	"encoding/pem"
	"fmt"
)

func main() {
	// A PEM block with a missing footer. The crypto/x509 package now
	// rejects such malformed input, which is part of the security fixes
	// in go1.25.11.
	pemData := []byte(`-----BEGIN CERTIFICATE-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz
`)

	// Decode the PEM block.
	block, rest := pem.Decode(pemData)
	if block == nil {
		fmt.Println("failed to decode PEM:", rest)
		return
	}

	// Attempt to parse the certificate. This will fail because the
	// PEM block is incomplete.
	_, err := x509.ParseCertificate(block.Bytes)
	if err != nil {
		fmt.Println("certificate parse error:", err)
		return
	}

	fmt.Println("certificate parsed successfully")
}

// This program demonstrates how to create a *types.TypeParamList in Go 1.27.1,
// where the NewTypeParamList constructor is not yet available. It uses an
// unsafe cast from a slice of *types.TypeParam to *types.TypeParamList,
// which is the workaround that existed before the proposed constructor
// shipped in Go 1.28.
//
// The program defines two dummy type parameters, builds a slice, casts it,
// and prints the number of parameters in the resulting list.
package main

import (
	"fmt"
	"go/types"
	"unsafe"
)

func main() {
	// Create two dummy type parameters. In practice these would come from
	// parsing or type-checking code, but here we fabricate them with
	// minimal information.
	tp1 := &types.TypeParam{
		// The fields of TypeParam are unexported, so we cannot set them
		// directly. We only need the pointer to satisfy the slice.
	}
	tp2 := &types.TypeParam{}

	// Build a slice of *types.TypeParam.
	tps := []*types.TypeParam{tp1, tp2}

	// Convert the slice to a *types.TypeParamList via an unsafe cast.
	// This relies on the internal layout of TypeParamList matching a
	// slice header, which is true in the current implementation.
	tpl := (*types.TypeParamList)(unsafe.Pointer(&tps))

	// Print the length of the constructed list.
	fmt.Printf("TypeParamList contains %d parameters\n", tpl.Len())
}

// This program demonstrates that the Rust compiler is unchanged by the mdBook update.
// It simply prints a message to confirm that the code compiles and runs.
fn main() {
    println!("mdBook 0.5.3 update has no effect on Rust code.");
}

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