Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package go1.21 for openSUSE:Factory checked in at 2023-08-09 17:25:46 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/go1.21 (Old) and /work/SRC/openSUSE:Factory/.go1.21.new.11712 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "go1.21" Wed Aug 9 17:25:46 2023 rev:4 rq:1103036 version:1.21.0 Changes: -------- --- /work/SRC/openSUSE:Factory/go1.21/go1.21.changes 2023-08-03 17:28:27.807284188 +0200 +++ /work/SRC/openSUSE:Factory/.go1.21.new.11712/go1.21.changes 2023-08-09 17:25:56.301636187 +0200 @@ -1,0 +2,567 @@ +Tue Aug 8 15:52:08 UTC 2023 - Jeff Kowalczyk <jkowalc...@suse.com> + +- go1.21 (released 2023-08-08) is a major release of Go. + go1.21.x minor releases will be provided through August 2024. + https://github.com/golang/go/wiki/Go-Release-Cycle + go1.21 arrives six months after go1.20. Most of its changes are + in the implementation of the toolchain, runtime, and libraries. + As always, the release maintains the Go 1 promise of + compatibility. We expect almost all Go programs to continue to + compile and run as before. + Refs boo#1212475 go1.21 release tracking + * Go 1.21 introduces a small change to the numbering of + releases. In the past, we used Go 1.N to refer to both the + overall Go language version and release family as well as the + first release in that family. Starting in Go 1.21, the first + release is now Go 1.N.0. Today we are releasing both the Go + 1.21 language and its initial implementation, the Go 1.21.0 + release. These notes refer to "Go 1.21"; tools like go version + will report "go1.21.0" (until you upgrade to Go 1.21.1). See + "Go versions" in the "Go Toolchains" documentation for details + about the new version numbering. + * Language change: Go 1.21 adds three new built-ins to the + language. + * Language change: The new functions min and max compute the + smallest (or largest, for max) value of a fixed number of given + arguments. See the language spec for details. + * Language change: The new function clear deletes all elements + from a map or zeroes all elements of a slice. See the language + spec for details. + * Package initialization order is now specified more + precisely. This may change the behavior of some programs that + rely on a specific initialization ordering that was not + expressed by explicit imports. The behavior of such programs + was not well defined by the spec in past releases. The new rule + provides an unambiguous definition. + * Multiple improvements that increase the power and precision of + type inference have been made. + * A (possibly partially instantiated generic) function may now be + called with arguments that are themselves (possibly partially + instantiated) generic functions. + * Type inference now also considers methods when a value is + assigned to an interface: type arguments for type parameters + used in method signatures may be inferred from the + corresponding parameter types of matching methods. + * Similarly, since a type argument must implement all the methods + of its corresponding constraint, the methods of the type + argument and constraint are matched which may lead to the + inference of additional type arguments. + * If multiple untyped constant arguments of different kinds (such + as an untyped int and an untyped floating-point constant) are + passed to parameters with the same (not otherwise specified) + type parameter type, instead of an error, now type inference + determines the type using the same approach as an operator with + untyped constant operands. This change brings the types + inferred from untyped constant arguments in line with the types + of constant expressions. + * Type inference is now precise when matching corresponding types + in assignments + * The description of type inference in the language spec has been + clarified. + * Go 1.21 includes a preview of a language change we are + considering for a future version of Go: making for loop + variables per-iteration instead of per-loop, to avoid + accidental sharing bugs. For details about how to try that + language change, see the LoopvarExperiment wiki page. + * Go 1.21 now defines that if a goroutine is panicking and + recover was called directly by a deferred function, the return + value of recover is guaranteed not to be nil. To ensure this, + calling panic with a nil interface value (or an untyped nil) + causes a run-time panic of type *runtime.PanicNilError. + To support programs written for older versions of Go, nil + panics can be re-enabled by setting GODEBUG=panicnil=1. This + setting is enabled automatically when compiling a program whose + main package is in a module with that declares go 1.20 or + earlier. + * Go 1.21 adds improved support for backwards compatibility and + forwards compatibility in the Go toolchain. + * To improve backwards compatibility, Go 1.21 formalizes Go's use + of the GODEBUG environment variable to control the default + behavior for changes that are non-breaking according to the + compatibility policy but nonetheless may cause existing + programs to break. (For example, programs that depend on buggy + behavior may break when a bug is fixed, but bug fixes are not + considered breaking changes.) When Go must make this kind of + behavior change, it now chooses between the old and new + behavior based on the go line in the workspace's go.work file + or else the main module's go.mod file. Upgrading to a new Go + toolchain but leaving the go line set to its original (older) + Go version preserves the behavior of the older toolchain. With + this compatibility support, the latest Go toolchain should + always be the best, most secure, implementation of an older + version of Go. See "Go, Backwards Compatibility, and GODEBUG" + for details. + * To improve forwards compatibility, Go 1.21 now reads the go + line in a go.work or go.mod file as a strict minimum + requirement: go 1.21.0 means that the workspace or module + cannot be used with Go 1.20 or with Go 1.21rc1. This allows + projects that depend on fixes made in later versions of Go to + ensure that they are not used with earlier versions. It also + gives better error reporting for projects that make use of new + Go features: when the problem is that a newer Go version is + needed, that problem is reported clearly, instead of attempting + to build the code and instead printing errors about unresolved + imports or syntax errors. + * To make these new stricter version requirements easier to + manage, the go command can now invoke not just the toolchain + bundled in its own release but also other Go toolchain versions + found in the PATH or downloaded on demand. If a go.mod or + go.work go line declares a minimum requirement on a newer + version of Go, the go command will find and run that version + automatically. The new toolchain directive sets a suggested + minimum toolchain to use, which may be newer than the strict go + minimum. See "Go Toolchains" for details. + * go command: The -pgo build flag now defaults to -pgo=auto, and + the restriction of specifying a single main package on the + command line is now removed. If a file named default.pgo is + present in the main package's directory, the go command will + use it to enable profile-guided optimization for building the + corresponding program. + * go command: The -C dir flag must now be the first flag on the + command-line when used. + * go command: The new go test option -fullpath prints full path + names in test log messages, rather than just base names. + * go command: The go test -c flag now supports writing test + binaries for multiple packages, each to pkg.test where pkg is + the package name. It is an error if more than one test package + being compiled has a given package name.] + * go command: The go test -o flag now accepts a directory + argument, in which case test binaries are written to that + directory instead of the current directory. + * cgo: In files that import "C", the Go toolchain now correctly + reports errors for attempts to declare Go methods on C types. + * runtime: When printing very deep stacks, the runtime now prints + the first 50 (innermost) frames followed by the bottom 50 + (outermost) frames, rather than just printing the first 100 + frames. This makes it easier to see how deeply recursive stacks + started, and is especially valuable for debugging stack + overflows. + * runtime: On Linux platforms that support transparent huge + pages, the Go runtime now manages which parts of the heap may + be backed by huge pages more explicitly. This leads to better + utilization of memory: small heaps should see less memory used + (up to 50% in pathological cases) while large heaps should see + fewer broken huge pages for dense parts of the heap, improving + CPU usage and latency by up to 1%. + * runtime: As a result of runtime-internal garbage collection + tuning, applications may see up to a 40% reduction in + application tail latency and a small decrease in memory + use. Some applications may also observe a small loss in + throughput. The memory use decrease should be proportional to + the loss in throughput, such that the previous release's + throughput/memory tradeoff may be recovered (with little change + to latency) by increasing GOGC and/or GOMEMLIMIT slightly. + * runtime: Calls from C to Go on threads created in C require + some setup to prepare for Go execution. On Unix platforms, this + setup is now preserved across multiple calls from the same + thread. This significantly reduces the overhead of subsequent C + to Go calls from ~1-3 microseconds per call to ~100-200 + nanoseconds per call. + * compiler: Profile-guide optimization (PGO), added as a preview + in Go 1.20, is now ready for general use. PGO enables + additional optimizations on code identified as hot by profiles + of production workloads. As mentioned in the Go command + section, PGO is enabled by default for binaries that contain a + default.pgo profile in the main package directory. Performance + improvements vary depending on application behavior, with most + programs from a representative set of Go programs seeing + between 2 and 7% improvement from enabling PGO. See the PGO + user guide for detailed documentation. + * compiler: PGO builds can now devirtualize some interface method + calls, adding a concrete call to the most common callee. This + enables further optimization, such as inlining the callee. + * compiler: Go 1.21 improves build speed by up to 6%, largely + thanks to building the compiler itself with PGO. + * assembler: On amd64, frameless nosplit assembly functions are + no longer automatically marked as NOFRAME. Instead, the NOFRAME + attribute must be explicitly specified if desired, which is + already the behavior on other architectures supporting frame + pointers. With this, the runtime now maintains the frame + pointers for stack transitions. + * assembler: The verifier that checks for incorrect uses of R15 + when dynamic linking on amd64 has been improved. + * linker: On windows/amd64, the linker (with help from the + compiler) now emits SEH unwinding data by default, which + improves the integration of Go applications with Windows + debuggers and other tools. + * linker: In Go 1.21 the linker (with help from the compiler) is + now capable of deleting dead (unreferenced) global map + variables, if the number of entries in the variable initializer + is sufficiently large, and if the initializer expressions are + side-effect free. + * core library: The new log/slog package provides structured + logging with levels. Structured logging emits key-value pairs + to enable fast, accurate processing of large amounts of log + data. The package supports integration with popular log + analysis tools and services. + * core library: The new testing/slogtest package can help to ++++ 370 more lines (skipped) ++++ between /work/SRC/openSUSE:Factory/go1.21/go1.21.changes ++++ and /work/SRC/openSUSE:Factory/.go1.21.new.11712/go1.21.changes Old: ---- go1.21rc4.src.tar.gz New: ---- go1.21.0.src.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ go1.21.spec ++++++ --- /var/tmp/diff_new_pack.hn0Kph/_old 2023-08-09 17:25:57.005640571 +0200 +++ /var/tmp/diff_new_pack.hn0Kph/_new 2023-08-09 17:25:57.013640621 +0200 @@ -126,7 +126,7 @@ %endif Name: go1.21 -Version: 1.21rc4 +Version: 1.21.0 Release: 0 Summary: A compiled, garbage-collected, concurrent programming language License: BSD-3-Clause ++++++ go1.21rc4.src.tar.gz -> go1.21.0.src.tar.gz ++++++ /work/SRC/openSUSE:Factory/go1.21/go1.21rc4.src.tar.gz /work/SRC/openSUSE:Factory/.go1.21.new.11712/go1.21.0.src.tar.gz differ: char 13, line 1
