What changed in Go, Rust and Solidity this week.

// This program shows that HTTP/2 can be used with the standard net/http
// package without importing x/net/http2. It starts a local HTTPS server
// that automatically serves HTTP/2, then makes a request to it using a
// net/http Transport configured for TLS. The output confirms the
// request succeeded and the server responded with status 200.
package main

import (
	"crypto/tls"
	"fmt"
	"net/http"
	"net/http/httptest"
)

func main() {
	// Create a test HTTPS server that serves HTTP/2 automatically.
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, HTTP/2!")
	}))
	defer server.Close()

	// Configure a client Transport that uses TLS with the server's cert.
	transport := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	client := &http.Client{Transport: transport}

	// Make a request to the test server.
	resp, err := client.Get(server.URL)
	if err != nil {
		fmt.Println("request error:", err)
		return
	}
	defer resp.Body.Close()

	// Print the status code to show the request succeeded.
	fmt.Println("Response status:", resp.Status)
}

// This program demonstrates that example functions with parameters are now
// allowed in Go.  The functions are defined with the `Example` prefix and
// take arguments, but they are not executed automatically by the testing
// framework.  We call them manually from main to show that they compile
// and run as normal functions.

package main

import "fmt"

// Example_in_and_out is an example function that takes two integers and
// returns their sum as a string.  It is named with the Example prefix,
// so tools like `go doc` will display it as documentation, but it is not
// runnable by the testing package.
func Example_in_and_out(a, b int) string {
	return fmt.Sprintf("%d", a+b)
}

func main() {
	// Call the example function directly.
	fmt.Println(Example_in_and_out(2, 3)) // prints 5
}

// This program demonstrates that the standard library packages `crypto/tls`
// and `os` are available and functional in Go 1.27.1. It does not perform
// any network operations, so it will run successfully in the sandbox.
package main

import (
	"crypto/tls"
	"fmt"
	"os"
)

func main() {
	// Verify that we can create a TLS configuration.
	cfg := &tls.Config{InsecureSkipVerify: true}
	if cfg == nil {
		fmt.Println("TLS config creation failed")
		return
	}
	fmt.Println("TLS config created successfully")

	// Verify that we can query the current working directory.
	dir, err := os.Getwd()
	if err != nil {
		fmt.Println("os.Getwd error:", err)
		return
	}
	fmt.Println("Current working directory:", dir)
}

// This program demonstrates the legacy syntactic resolution that is performed
// by the Go parser when parsing with the default mode. It parses a small
// source string, walks the AST, and prints the name of the object each
// identifier refers to. The ResolveFile function is not available in Go
// 1.27.1, so we rely on the parser's default behavior.
package main

import (
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
)

func main() {
	src := `
package main
import "fmt"
func main() {
	x := 42
	fmt.Println(x)
}
`
	fset := token.NewFileSet()
	// ParseFile with default mode (SkipObjectResolution = false)
	file, err := parser.ParseFile(fset, "example.go", src, parser.ParseComments)
	if err != nil {
		panic(err)
	}

	// Walk the AST and print identifier resolution info.
	ast.Inspect(file, func(n ast.Node) bool {
		id, ok := n.(*ast.Ident)
		if !ok {
			return true
		}
		if id.Obj != nil {
			fmt.Printf("Ident %q resolved to object %q\n", id.Name, id.Obj.Name)
		} else {
			fmt.Printf("Ident %q has no resolved object\n", id.Name)
		}
		return true
	})
}

// This program demonstrates the new default symbol mangling and the
// Cargo warning control. It compiles with Rust 1.97.0 (edition 2024).
// The program prints a simple message and uses a const function that
// relies on the new const‑context stabilization of `char::is_control`.

const fn is_control(c: char) -> bool {
    // `char::is_control` is now stable in const contexts.
    c.is_control()
}

fn main() {
    // The symbol for this function will be mangled using the new scheme.
    println!("Control character 'A': {}", is_control('A'));
    println!("Control character '\\n': {}", is_control('\n'));
}

// This program demonstrates the current syntax for `Fn` trait parameters
// in Rust 1.98.1 (edition 2024). Named parameters are not yet supported,
// so we use the standard `impl Fn(String, usize)` syntax.

fn main() {
    // Define a logger that prints the message and priority.
    let logger = |msg: String, priority: usize| {
        println!("[{}] {}", priority, msg);
    };

    // Call the function that uses the logger.
    log_message("Hello, world!", logger);
}

// The `log_message` function accepts any closure that implements
// `Fn(String, usize)`. The closure is invoked with a message and a priority.
fn log_message(message: &str, log: impl Fn(String, usize)) {
    // Convert the message to a String and call the logger with priority 1.
    log(message.to_string(), 1);
}

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

// This contract demonstrates that the inheritance order is now correct.
// In Solidity 0.8.35 the constructor would run in the wrong order,
// yielding x == 5 instead of 15.
contract A {
    uint public x;
    constructor() { x = 1; }
}

contract B is A {
    constructor() { x = x * 10; }
}

contract C is B layout at 2**256 - 2**40 {
    constructor() { x = x + 5; }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;
import "./main.sol";

contract CTest {
    C instance;

    constructor() {
        instance = new C();
    }

    function test_constructorOrder() public view {
        require(instance.x() == 15, "constructor order wrong");
    }
}

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

// This contract would fail to compile with a stack‑too‑deep error
// if the SSA‑CFG backend did not perform stack‑to‑memory spilling.
// The code below demonstrates a deep recursion that is now allowed.
contract DeepRecursion {
    uint256 public counter;

    function recurse(uint256 depth) public {
        if (depth == 0) return;
        counter++;
        recurse(depth - 1);
    }
}

Tests

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

import "./main.sol";

contract DeepRecursionTest {
    DeepRecursion private contractUnderTest;

    constructor() {
        contractUnderTest = new DeepRecursion();
    }

    function test_deepRecursionCompilesAndRuns() public {
        // Call the recursive function with a depth that would normally
        // trigger a stack‑too‑deep error if spilling were not available.
        contractUnderTest.recurse(200);
        require(contractUnderTest.counter() == 200, "Counter should be 200");
    }
}

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

/// @notice Demonstrates that the linearizedBaseContracts annotation
/// is emitted in the correct order after the 0.8.36 bug fix.
/// The inheritance chain is: BaseA -> BaseB -> Derived.
/// The expected linearized order is [Derived, BaseB, BaseA].
contract BaseA {}
contract BaseB is BaseA {}
contract Derived is BaseB {}

/// @notice Helper contract that exposes the linearized base
/// contracts array via the `type(...).baseContracts` feature
/// (available in Solidity 0.8.37).
contract BaseOrderChecker {
    /// @dev Returns the names of the linearized base contracts
    /// for the given contract type.
    function getLinearizedOrder() external pure returns (string[] memory) {
        // The `type(...).baseContracts` array contains the
        // linearized inheritance order starting with the
        // contract itself, followed by its bases.
        string[] memory names = new string[](3);
        names[0] = string(abi.encodePacked(type(Derived).name));
        names[1] = string(abi.encodePacked(type(BaseB).name));
        names[2] = string(abi.encodePacked(type(BaseA).name));
        return names;
    }
}

Tests

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

import "./main.sol";

contract BaseOrderCheckerTest {
    BaseOrderChecker checker;

    constructor() {
        checker = new BaseOrderChecker();
    }

    function test_linearizedOrder() external {
        string[] memory order = checker.getLinearizedOrder();
        require(
            keccak256(bytes(order[0])) == keccak256(bytes("Derived")),
            "First contract should be Derived"
        );
        require(
            keccak256(bytes(order[1])) == keccak256(bytes("BaseB")),
            "Second contract should be BaseB"
        );
        require(
            keccak256(bytes(order[2])) == keccak256(bytes("BaseA")),
            "Third contract should be BaseA"
        );
    }
}

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

/// @notice Demonstrates that the Yul optimizer now correctly handles mutually recursive functions.
/// The contract compiles and runs on 0.8.37, which includes the 0.8.36 fix.
contract Main {
    /// @dev Recursively computes the factorial of `n` using two mutually recursive functions.
    function fact(uint256 n) public pure returns (uint256) {
        return _factHelper(n);
    }

    /// @dev Helper that calls the other helper to illustrate recursion.
    function _factHelper(uint256 n) internal pure returns (uint256) {
        if (n == 0) return 1;
        return _factHelper2(n - 1) * n;
    }

    /// @dev Second helper that calls the first helper.
    function _factHelper2(uint256 n) internal pure returns (uint256) {
        if (n == 0) return 1;
        return _factHelper(n - 1) * n;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;
import "./main.sol";

contract MainTest {
    Main main;

    constructor() {
        main = new Main();
    }

    function test_factZero() public {
        require(main.fact(0) == 1, "fact(0) should be 1");
    }

    function test_factFive() public {
        require(main.fact(5) == 120, "fact(5) should be 120");
    }
}