What changed in Go, Rust and Solidity this week.

// This program demonstrates the current state of the go/token File type in Go 1.27.1.
// The proposed End() method is not yet available, so we compute the end position
// manually using Base() and Size() and print the result.
package main

import (
	"fmt"
	"go/token"
)

func main() {
	// Create a new FileSet and add a file named "example.go" with 20 bytes of content.
	fset := token.NewFileSet()
	f := fset.AddFile("example.go", -1, 20)

	// Base() returns the starting position of the file (usually 1).
	base := f.Base()
	// Size() returns the number of bytes in the file.
	size := f.Size()

	// Compute the end position as Base() + Size().
	end := token.Pos(base + size)

	fmt.Printf("Base: %d\n", base)
	fmt.Printf("Size: %d\n", size)
	fmt.Printf("End: %d\n", end)
}

// This program demonstrates the incorrect End position for a multiline raw
// string literal in Go 1.27.1. The change that adds BasicLit.ValueEnd is not
// yet available, so we show the problem that the proposal fixes.
package main

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

func main() {
	src := `package main
func main() {
	s := ` + "`Hello\nWorld`" + `
}`
	fset := token.NewFileSet()
	// Parse the source code.
	f, err := parser.ParseFile(fset, "example.go", src, 0)
	if err != nil {
		panic(err)
	}

	// Find the first BasicLit node (the raw string literal).
	var lit *ast.BasicLit
	ast.Inspect(f, func(n ast.Node) bool {
		if bl, ok := n.(*ast.BasicLit); ok && bl.Kind == token.STRING {
			lit = bl
			return false
		}
		return true
	})
	if lit == nil {
		panic("no string literal found")
	}

	// Print the literal value and its start position.
	fmt.Printf("Literal value: %q\n", lit.Value)
	fmt.Printf("Start position: %s\n", fset.Position(lit.Pos()))

	// End() uses ValuePos + len(Value), which is incorrect for multiline raw strings.
	fmt.Printf("End() position: %s\n", fset.Position(lit.End()))

	// Compute the correct end position by looking at the file content.
	// The file's content ends at the position of the closing backtick.
	// We find the index of the closing backtick in the source string.
	endIdx := len(src) - 1 // last character is the closing backtick
	endPos := fset.File(lit.Pos()).Pos(endIdx)
	fmt.Printf("Manual end position: %s\n", fset.Position(endPos))
}

// This program demonstrates the new fips140.Version function.
// Since Go 1.27.1 does not yet include the change, the call will compile
// but return "latest" unless the build is done with GOFIPS140 set.
package main

import (
	"fmt"
	"crypto/fips140"
)

func main() {
	// Retrieve the FIPS 140-3 module version.
	ver := fips140.Version()
	// Print the result; it will be "latest" in this environment.
	fmt.Println("FIPS 140-3 module version:", ver)
}

// This program demonstrates the behavior that go vet now warns about: using
// the %q verb with an integer that is not a rune or byte.  The output shows
// that fmt.Printf("%q", 123) prints the character with code 123, which is
// '{'.
package main

import "fmt"

func main() {
	// Print the result of formatting an integer with %q.
	fmt.Printf("%q\n", 123)
}

// This program demonstrates the new Zulip channel for infrastructure announcements.
// The change is not part of the Rust language itself, so we just print a message.
fn main() {
    println!("Zulip channel #infra/announcements is now available for infrastructure updates.");
}