What changed in Go, Rust and Solidity this week.

// This program demonstrates that the `x/net/http2.WriteScheduler` interface
// is still part of the external `golang.org/x/net/http2` package and is
// marked deprecated. Since the sandbox has no network access, we cannot
// import that package, so we simply print a message explaining the
// situation.

package main

import "fmt"

func main() {
	fmt.Println("The WriteScheduler interface in golang.org/x/net/http2 is deprecated.")
}

// This program demonstrates the new Clone methods for net/url.URL and url.Values.
// It runs in Go 1.27.1 and shows how to copy a URL and its query parameters safely.
package main

import (
	"fmt"
	"net/url"
)

func main() {
	// Original URL with user info and query parameters.
	orig, _ := url.Parse("https://user:[email protected]/path?foo=bar&baz=qux")

	// Clone the URL. The returned value is a deep copy, including the User field.
	cloned := orig.Clone()

	// Modify the clone: change the path and add a query value.
	cloned.Path = "/newpath"
	cloned.Query().Set("new", "value")

	// Show that the original URL is unchanged.
	fmt.Println("Original:", orig.String())
	fmt.Println("Cloned :", cloned.String())

	// Clone the query values separately.
	origVals := orig.Query()
	clonedVals := origVals.Clone()

	// Modify the cloned values.
	clonedVals.Set("foo", "changed")

	// The original values remain untouched.
	fmt.Println("Original query:", origVals.Encode())
	fmt.Println("Cloned query  :", clonedVals.Encode())
}

// This program demonstrates the new go vet check for missing Err calls
// on bufio.Scanner. It compiles and runs on Go 1.27.1. The program
// reads a string with a scanner, prints each token, and then checks
// scanner.Err() to ensure no scanning error occurred.
package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	// Create a scanner over a simple string.
	s := bufio.NewScanner(strings.NewReader("one two three"))
	for s.Scan() { // use the scanner
		fmt.Println(s.Text())
	}
	// Check the error after the loop.
	if err := s.Err(); err != nil {
		fmt.Println("scan error:", err)
	}
}

// This program demonstrates the newexpr modernizer feature introduced in Go 1.26.
// It uses the new function with an expression argument and prints the result.
package main

import (
	"fmt"
)

func main() {
	// new(10) creates an int variable initialized to 10 and returns its address.
	ptr := new(10)
	fmt.Println(*ptr) // prints 10
}

// This program demonstrates that the compiler is stable after the 1.93.1 update.
// It simply prints a message; no new features are used.
fn main() {
    println!("Rust 1.93.1 is installed and working.");
}

// This program demonstrates the current notification policy for malicious crates.
// It prints the recommended way to stay informed: subscribing to the RustSec RSS feed.
// No network access is performed; the program simply outputs guidance.

fn main() {
    println!("Crates.io no longer posts a blog entry for every malicious crate.");
    println!("Instead, subscribe to the RustSec advisory RSS feed for updates.");
}

// This program demonstrates that Cargo 1.94 has no new public API changes.
// It simply prints a message confirming that the current Cargo behavior
// remains the same as before the announcement.

fn main() {
    println!("Cargo 1.94 development cycle announced – no new API changes yet.");
}

// This program simply prints a message. The Rust language itself has not changed
// as a result of the announcement, so the code runs unchanged on Rust 1.98.1.
fn main() {
    println!("Rust participates in GSoC 2026");
}

// This example shows how you would normally implement a simple state machine
// without the banish crate. The banish macro would generate the same code
// automatically, but it is not available in Rust 1.98.1 (edition 2024).

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum State {
    Idle,
    Running,
    Stopped,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Event {
    Start,
    Stop,
}

struct Machine {
    state: State,
}

impl Machine {
    fn new() -> Self {
        Self { state: State::Idle }
    }

    fn step(&mut self, event: Event) {
        self.state = match (self.state, event) {
            (State::Idle, Event::Start) => State::Running,
            (State::Running, Event::Stop) => State::Stopped,
            // All other combinations leave the state unchanged
            (s, _) => s,
        };
    }
}

fn main() {
    let mut m = Machine::new();
    println!("Initial state: {:?}", m.state);
    m.step(Event::Start);
    println!("After Start: {:?}", m.state);
    m.step(Event::Stop);
    println!("After Stop: {:?}", m.state);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// Demonstrates that the compiler now emits distinct helpers for
// persistent and transient storage clearing.  A delete on a
// persistent mapping value clears the slot with sstore, while a
// delete on a transient variable clears the slot with tstore.
// The test contract verifies that each operation affects only its
// intended storage location.

contract StorageClearDemo {
    // persistent storage
    mapping(uint256 => address) public approvals;

    // transient storage
    address transient _caller;

    // set a persistent approval
    function setApproval(uint256 id, address spender) external {
        approvals[id] = spender;
    }

    // delete the persistent approval
    function revokeApproval(uint256 id) external {
        delete approvals[id];
    }

    // set a transient caller
    function setCaller() external {
        _caller = msg.sender;
    }

    // delete the transient caller
    function clearCaller() external {
        delete _caller;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

import "./main.sol";

contract StorageClearDemoTest {
    StorageClearDemo demo;

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

    // Test that persistent approval is cleared correctly
    function test_persistentClearing() external {
        demo.setApproval(1, address(0x123));
        require(demo.approvals(1) == address(0x123), "approval not set");

        demo.revokeApproval(1);
        require(demo.approvals(1) == address(0), "approval not cleared");
    }

    // Test that transient caller is cleared correctly
    function test_transientClearing() external {
        demo.setCaller();
        // _caller is transient; we cannot read it directly, but we can
        // infer it is set by calling a function that requires it.
        // Here we simply call clearCaller and ensure no revert occurs.
        demo.clearCaller();
        // If clearCaller had used sstore instead of tstore, the
        // persistent slot 0 would be overwritten, potentially
        // breaking the contract.  The absence of a revert indicates
        // the correct opcode was used.
    }
}