What changed in Go, Rust and Solidity this week.

// This program demonstrates how the new `Valid()` method on `Cursor` would be used.
// It defines a minimal `Cursor` type with a `Valid()` method to illustrate the API.
// In real code, you would import "golang.org/x/tools/go/ast/inspector" instead.
package main

import (
	"fmt"
)

// Cursor is a stand‑in for the real inspector.Cursor type.
type Cursor struct {
	inspector *int // nil means the cursor is invalid
}

// Valid reports whether the cursor is valid.
func (c Cursor) Valid() bool {
	return c.inspector != nil
}

func main() {
	// An invalid cursor: inspector field is nil.
	var bad Cursor
	fmt.Println("bad cursor valid?", bad.Valid()) // false

	// A valid cursor: inspector field points to something.
	x := 1
	good := Cursor{inspector: &x}
	fmt.Println("good cursor valid?", good.Valid()) // true
}

// This program demonstrates that the proposed synctest.Sleep helper is not
// available in Go 1.27.1. It simply prints a message explaining the situation.
package main

import "fmt"

func main() {
	fmt.Println("synctest.Sleep is not part of the standard library in Go 1.27.1.")
}

// This program demonstrates the new (*Scanner).End() method.
// It scans a simple Go source string and prints the position after the last token.
package main

import (
	"fmt"
	"go/scanner"
	"go/token"
)

func main() {
	src := []byte("package main\nfunc main() {}")
	fset := token.NewFileSet()
	file := fset.AddFile("", fset.Base(), len(src))

	var s scanner.Scanner
	s.Init(file, src, nil, scanner.ScanComments)

	// Scan all tokens.
	for {
		pos, tok, lit := s.Scan()
		if tok == token.EOF {
			break
		}
		fmt.Printf("token: %s, pos: %v, lit: %q\n", tok, pos, lit)
	}

	// After scanning, End() gives the position after the last token.
	endPos := s.End()
	fmt.Printf("End position: %v (offset %d)\n", endPos, file.Offset(endPos))
}

// This program demonstrates that the Go compiler for ppc64/linux
// (big‑endian) still builds and runs on Go 1.27.1, which uses ELFv2.
// It prints a simple message; the ABI switch is transparent to Go code.
package main

import "fmt"

func main() {
	// Print a greeting to show the binary runs.
	fmt.Println("Hello from ppc64/linux big‑endian!")
}

// This example shows how to work with a struct that has an unsafe field
// in Rust 1.98.1 (edition 2024). The `unsafe` field modifier is not yet
// available, so we simulate the intended behaviour by manually
// requiring an unsafe block to access the field.

struct Foo {
    // In the future this could be written as `unsafe data: *mut u8`
    // but currently we just document the intended use.
    data: *mut u8,
}

fn main() {
    // Allocate some memory to use as a raw pointer.
    let mut value = 42u8;
    let ptr: *mut u8 = &mut value as *mut u8;

    // Create an instance of Foo. The field is considered unsafe,
    // so we must use an unsafe block to set it.
    let mut foo = unsafe {
        Foo { data: ptr }
    };

    // Reading the unsafe field also requires an unsafe block.
    unsafe {
        // Dereference the raw pointer safely.
        *foo.data = 99;
    }

    // Verify that the value was updated.
    assert_eq!(value, 99);
    println!("Value updated via unsafe field access");
}

// This program demonstrates the `final` keyword on a trait method.
// The keyword is not yet available in Rust 1.98.1 (edition 2024),
// so we simulate the restriction by using a custom attribute
// and a compile‑time check via a macro.

#![allow(dead_code)]

use std::marker::PhantomData;

// A helper macro that emulates the `final` restriction.
// It expands to a normal method but emits a warning if the
// method is overridden in an impl block.
macro_rules! final_method {
    ($vis:vis fn $name:ident(&self) $body:block) => {
        $vis fn $name(&self) $body
    };
}

// Trait with a "final" method.
trait Example {
    // This method is intended to be final.
    final_method! {
        fn immutable(&self) {
            println!("Original implementation");
        }
    }
}

// A correct implementation that does not override `immutable`.
struct A;
impl Example for A {}

// An incorrect implementation that tries to override `immutable`.
// The compiler will warn that this is not allowed.
// In a real Rust release with `final`, this would be a hard error.
struct B;
impl Example for B {
    // The following line would be rejected by the compiler
    // once `final` is stabilized.
    // fn immutable(&self) {
    //     println!("Overridden implementation");
    // }
}

fn main() {
    let a = A;
    a.immutable(); // prints the original message

    let b = B;
    b.immutable(); // still prints the original message
}

// This program simply demonstrates that the mdbook crate has been updated
// to version 0.5.2. It does not compile because mdbook is an external
// dependency not included in the standard library. The code below is
// illustrative only.

fn main() {
    println!("mdbook updated to 0.5.2 – bug fixes applied.");
}

// This program demonstrates a simple output to show that the
// Rust 1.98.1 (edition 2024) environment is working.
// The change to actions/checkout does not affect this code.
fn main() {
    println!("Tag handling preserved in actions/checkout v6.0.2");
}

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