What changed in Go, Rust and Solidity this week.

// This program demonstrates the new modernize analyzers.
// It intentionally uses patterns that the analyzers will flag.
// Running `go vet -vettool=$(go env GOROOT)/pkg/tool/linux_amd64/vet`
// will show suggestions for atomic, embedlit, errorsastype,
// plusbuild, stringscut, and stditerators.

package main

import (
	"errors"
	"fmt"
	"sync/atomic"
)

// atomic example: old sync/atomic usage
var counter int32

func inc() {
	atomic.AddInt32(&counter, 1) // modernize will suggest atomic.Int32
}

// embedlit example: embedding a string literal
type Config struct {
	Data string // modernize will suggest go:embed
}

// errorsastype example: converting error to any
func errToAny(err error) any {
	return err // modernize will suggest errors.As
}

// plusbuild example: old build tag syntax
// +build ignore

// stringscut example: trimming a string
func trim(s string) string {
	return s[:len(s)-1] // modernize will suggest strings.TrimSpace
}

// stditerators example: inefficient range loop
func sum(nums []int) int {
	total := 0
	for i := 0; i < len(nums); i++ { // modernize will suggest range
		total += nums[i]
	}
	return total
}

func main() {
	inc()
	fmt.Println("counter:", counter)
	c := Config{Data: "example"}
	fmt.Println(c.Data)
	err := errors.New("oops")
	fmt.Println(errToAny(err))
	fmt.Println(trim("hello "))
	fmt.Println(sum([]int{1, 2, 3}))
}

// This program simply prints a message that the 2026 Project Goals draft
// is a planning document and does not involve any code changes.
fn main() {
    println!("The 2026 Project Goals draft is a planning document; no code changes are required.");
}

// This program demonstrates that the change is purely editorial and has no effect on Rust code.
// It simply prints a message confirming that the RFC link and headers are now correct.
fn main() {
    println!("RFC 3935 link and headers have been fixed.");
}

// This program demonstrates that the change is about a GitHub action,
// not Rust itself. It simply prints a message explaining the update.
fn main() {
    println!("The actions/upload-pages-artifact action was updated to v5, adding an include-hidden-files input.");
}

// This program demonstrates that the crate `dithr` is available on crates.io
// and can be used to dither a simple 2x2 image buffer.
// It does not compile until the crate is added to Cargo.toml, which is
// not possible in this sandbox, so we just print a placeholder message.

fn main() {
    println!("dithr crate is highlighted this week, but cannot be used here.");
}

// main.sol
pragma solidity ^0.8.37;

// This contract demonstrates the new keyword‑promotion warnings.
// The compiler will warn about the identifiers `error`, `layout`, and `super`.
// The warnings do not affect compilation or execution.
contract KeywordPromotionDemo {
    // Warning: identifier 'error' may be promoted to a keyword
    uint256 public error;

    // Warning: identifier 'layout' may be promoted to a keyword
    string public layout;

    // Warning: identifier 'super' may be promoted to a keyword
    function super() public pure returns (string memory) {
        return "super function";
    }
}

Tests

// test.sol
pragma solidity ^0.8.37;
import "./main.sol";

contract KeywordPromotionDemoTest {
    KeywordPromotionDemo demo;

    constructor() {
        demo = new KeywordPromotionDemo();
    }

    function test_errorVariable() public view {
        require(demo.error() == 0, "error variable not zero");
    }

    function test_layoutVariable() public view {
        require(bytes(demo.layout()).length == 0, "layout variable not empty");
    }

    function test_superFunction() public view {
        require(
            keccak256(bytes(demo.super())) == keccak256(bytes("super function")),
            "super function returned wrong string"
        );
    }
}