The latest Go release, version 1.8, arrives six months after Go 1.7. Most of its changes are in the implementation of the toolchain, runtime, and libraries. There are two minor changes to the language specification. 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.
The release adds support for 32-bit MIPS, updates the compiler back end to generate more efficient code, reduces GC pauses by eliminating stop-the-world stack rescanning, adds HTTP/2 Push support, adds HTTP graceful shutdown, adds more context support, enables profiling mutexes, and simplifies sorting slices.
When explicitly converting a value from one struct type to another, as of Go 1.8 the tags are ignored. Thus two structs that differ only in their tags may be converted from one to the other:
func example() {
type T1 struct {
X int `json:"foo"`
}
type T2 struct {
X int `json:"bar"`
}
var v1 T1
var v2 T2
v1 = T1(v2) // now legal
}
The language specification now only requires that implementations
support up to 16-bit exponents in floating-point constants. This does not affect
either the “gc” or
gccgo compilers, both of
which still support 32-bit exponents.
Go now supports 32-bit MIPS on Linux for both big-endian
(linux/mips) and little-endian machines
(linux/mipsle) that implement the MIPS32r1 instruction set with FPU
or kernel FPU emulation. Note that many common MIPS-based routers lack an FPU and
have firmware that doesn't enable kernel FPU emulation; Go won't run on such machines.
On DragonFly BSD, Go now requires DragonFly 4.4.4 or later.
On OpenBSD, Go now requires OpenBSD 5.9 or later.
The Plan 9 port's networking support is now much more complete and matches the behavior of Unix and Windows with respect to deadlines and cancelation. For Plan 9 kernel requirements, see the Plan 9 wiki page.
Go 1.8 now only supports OS X 10.8 or later. This is likely the last Go release to support 10.8. Compiling Go or running binaries on older OS X versions is untested.
Go 1.8 will be the last release to support Linux on ARMv5E and ARMv6 processors:
Go 1.9 will likely require the ARMv6K (as found in the Raspberry Pi 1) or later.
To identify whether a Linux system is ARMv6K or later, run
“go tool dist -check-armv6k”
(to facilitate testing, it is also possible to just copy the dist command to the
system without installing a full copy of Go 1.8)
and if the program terminates with output "ARMv6K supported." then the system
implements ARMv6K or later.
Go on non-Linux ARM systems already requires ARMv6K or later.
There are some instabilities on FreeBSD and NetBSD that are known but not understood. These can lead to program crashes in rare cases. See issue 15658 and issue 16511. Any help in solving these issues would be appreciated.
For 64-bit x86 systems, the following instructions have been added:
VBROADCASTSD,
BROADCASTSS,
MOVDDUP,
MOVSHDUP,
MOVSLDUP,
VMOVDDUP,
VMOVSHDUP, and
VMOVSLDUP.
For 64-bit PPC systems, the common vector scalar instructions have been
added:
LXS,
LXSDX,
LXSI,
LXSIWAX,
LXSIWZX,
LXV,
LXVD2X,
LXVDSX,
LXVW4X,
MFVSR,
MFVSRD,
MFVSRWZ,
MTVSR,
MTVSRD,
MTVSRWA,
MTVSRWZ,
STXS,
STXSDX,
STXSI,
STXSIWX,
STXV,
STXVD2X,
STXVW4X,
XSCV,
XSCVDPSP,
XSCVDPSPN,
XSCVDPSXDS,
XSCVDPSXWS,
XSCVDPUXDS,
XSCVDPUXWS,
XSCVSPDP,
XSCVSPDPN,
XSCVSXDDP,
XSCVSXDSP,
XSCVUXDDP,
XSCVUXDSP,
XSCVX,
XSCVXP,
XVCV,
XVCVDPSP,
XVCVDPSXDS,
XVCVDPSXWS,
XVCVDPUXDS,
XVCVDPUXWS,
XVCVSPDP,
XVCVSPSXDS,
XVCVSPSXWS,
XVCVSPUXDS,
XVCVSPUXWS,
XVCVSXDDP,
XVCVSXDSP,
XVCVSXWDP,
XVCVSXWSP,
XVCVUXDDP,
XVCVUXDSP,
XVCVUXWDP,
XVCVUXWSP,
XVCVX,
XVCVXP,
XXLAND,
XXLANDC,
XXLANDQ,
XXLEQV,
XXLNAND,
XXLNOR,
XXLOR,
XXLORC,
XXLORQ,
XXLXOR,
XXMRG,
XXMRGHW,
XXMRGLW,
XXPERM,
XXPERMDI,
XXSEL,
XXSI,
XXSLDWI,
XXSPLT, and
XXSPLTW.
The yacc tool (previously available by running
“go tool yacc”) has been removed.
As of Go 1.7 it was no longer used by the Go compiler.
It has moved to the “tools” repository and is now available at
golang.org/x/tools/cmd/goyacc.
The fix tool has a new “context”
fix to change imports from “golang.org/x/net/context”
to “context”.
The pprof tool can now profile TLS servers
and skip certificate validation by using the “https+insecure”
URL scheme.
The callgrind output now has instruction-level granularity.
The trace tool has a new -pprof flag for
producing pprof-compatible blocking and latency profiles from an
execution trace.
Garbage collection events are now shown more clearly in the execution trace viewer. Garbage collection activity is shown on its own row and GC helper goroutines are annotated with their roles.
Vet is stricter in some ways and looser where it previously caused false positives.
Vet now checks for copying an array of locks,
duplicate JSON and XML struct field tags,
non-space-separated struct tags,
deferred calls to HTTP Response.Body.Close
before checking errors, and
indexed arguments in Printf.
It also improves existing checks.
Go 1.7 introduced a new compiler back end for 64-bit x86 systems. In Go 1.8, that back end has been developed further and is now used for all architectures.
The new back end, based on static single assignment form (SSA), generates more compact, more efficient code and provides a better platform for optimizations such as bounds check elimination. The new back end reduces the CPU time required by our benchmark programs by 20-30% on 32-bit ARM systems. For 64-bit x86 systems, which already used the SSA back end in Go 1.7, the gains are a more modest 0-10%. Other architectures will likely see improvements closer to the 32-bit ARM numbers.
The temporary -ssa=0 compiler flag introduced in Go 1.7
to disable the new back end has been removed in Go 1.8.
In addition to enabling the new compiler back end for all systems, Go 1.8 also introduces a new compiler front end. The new compiler front end should not be noticeable to users but is the foundation for future performance work.
The compiler and linker have been optimized and run faster in this release than in Go 1.7, although they are still slower than we would like and will continue to be optimized in future releases. Compared to the previous release, Go 1.8 is about 15% faster.
The Go tool now remembers the value of the CGO_ENABLED environment
variable set during make.bash and applies it to all future compilations
by default to fix issue #12808.
When doing native compilation, it is rarely necessary to explicitly set
the CGO_ENABLED environment variable as make.bash
will detect the correct setting automatically. The main reason to explicitly
set the CGO_ENABLED environment variable is when your environment
supports cgo, but you explicitly do not want cgo support, in which case, set
CGO_ENABLED=0 during make.bash or all.bash.
The environment variable PKG_CONFIG may now be used to
set the program to run to handle #cgo pkg-config
directives. The default is pkg-config, the program
always used by earlier releases. This is intended to make it easier
to cross-compile
cgo code.
The cgo tool now supports a -srcdir
option, which is used by the go command.
If cgo code calls C.malloc, and
malloc returns NULL, the program will now
crash with an out of memory error.
C.malloc will never return nil.
Unlike most C functions, C.malloc may not be used in a
two-result form returning an errno value.
If cgo is used to call a C function passing a pointer to a C union, and if the C union can contain any pointer values, and if cgo pointer checking is enabled (as it is by default), the union value is now checked for Go pointers.
Due to the alignment of Go's semiannual release schedule with GCC's annual release schedule, GCC release 6 contains the Go 1.6.1 version of gccgo. We expect that the next release, GCC 7, will contain the Go 1.8 version of gccgo.
The
GOPATH
environment variable now has a default value if it
is unset. It defaults to
$HOME/go on Unix and
%USERPROFILE%/go on Windows.
The “go get” command now always respects
HTTP proxy environment variables, regardless of whether
the -insecure flag is used. In previous releases, the
-insecure flag had the side effect of not using proxies.
The new
“go bug”
command starts a bug report on GitHub, prefilled
with information about the current system.
The
“go doc”
command now groups constants and variables with their type,
following the behavior of
godoc.
In order to improve the readability of doc's
output, each summary of the first-level items is guaranteed to
occupy a single line.
Documentation for a specific method in an interface definition can
now be requested, as in
“go doc net.Conn.SetDeadline”.
Go now provides early support for plugins with a “plugin”
build mode for generating plugins written in Go, and a
new plugin package for
loading such plugins at run time. Plugin support is currently only
available on Linux. Please report any issues.
The garbage collector no longer considers
arguments live throughout the entirety of a function. For more
information, and for how to force a variable to remain live, see
the runtime.KeepAlive
function added in Go 1.7.
Updating:
Code that sets a finalizer on an allocated object may need to add
calls to runtime.KeepAlive in functions or methods
using that object.
Read the
KeepAlive
documentation and its example for more details.
In Go 1.6, the runtime added lightweight, best-effort detection of concurrent misuse of maps. This release improves that detector with support for detecting programs that concurrently write to and iterate over a map.
As always, if one goroutine is writing to a map, no other goroutine should be reading (which includes iterating) or writing the map concurrently. If the runtime detects this condition, it prints a diagnosis and crashes the program. The best way to find out more about the problem is to run the program under the race detector, which will more reliably identify the race and give more detail.
The runtime.MemStats
type has been more thoroughly documented.
As always, the changes are so general and varied that precise statements about performance are difficult to make. Most programs should run a bit faster, due to speedups in the garbage collector and optimizations in the standard library.
There have been optimizations to implementations in the
bytes,
crypto/aes,
crypto/cipher,
crypto/elliptic,
crypto/sha256,
crypto/sha512,
encoding/asn1,
encoding/csv,
encoding/hex,
encoding/json,
hash/crc32,
image/color,
image/draw,
math,
math/big,
reflect,
regexp,
runtime,
strconv,
strings,
syscall,
text/template, and
unicode/utf8
packages.
Garbage collection pauses should be significantly shorter than they were in Go 1.7, usually under 100 microseconds and often as low as 10 microseconds. See the document on eliminating stop-the-world stack re-scanning for details. More work remains for Go 1.9.
The overhead of deferred function calls has been reduced by about half.
The overhead of calls from Go into C has been reduced by about half.
Examples have been added to the documentation across many packages.
The sort package
now includes a convenience function
Slice to sort a
slice given a less function.
In many cases this means that writing a new sorter type is not
necessary.
Also new are
SliceStable and
SliceIsSorted.
The net/http package now includes a
mechanism to
send HTTP/2 server pushes from a
Handler.
Similar to the existing Flusher and Hijacker
interfaces, an HTTP/2
ResponseWriter
now implements the new
Pusher interface.
The HTTP Server now has support for graceful shutdown using the new
Server.Shutdown
method and abrupt shutdown using the new
Server.Close
method.
Continuing Go 1.7's adoption
of context.Context
into the standard library, Go 1.8 adds more context support
to existing packages:
Server.Shutdown
takes a context argument.Lookup methods on the new
net.Resolver now
take a context.The runtime and tools now support profiling contended mutexes.
Most users will want to use the new -mutexprofile
flag with “go test”,
and then use pprof on the resultant file.
Lower-level support is also available via the new
MutexProfile
and
SetMutexProfileFraction.
A known limitation for Go 1.8 is that the profile only reports contention for
sync.Mutex,
not
sync.RWMutex.
As always, there are various minor changes and updates to the library, made with the Go 1 promise of compatibility in mind. The following sections list the user visible changes and additions. Optimizations and minor bug fixes are not listed.
The tar implementation corrects many bugs in corner cases of the file format.
The Reader
is now able to process tar files in the PAX format with entries larger than 8GB.
The Writer
no longer produces invalid tar files in some situations involving long pathnames.
There have been some minor fixes to the encoder to improve the
compression ratio in certain situations. As a result, the exact
encoded output of DEFLATE may be different from Go 1.7. Since
DEFLATE is the underlying compression of gzip, png, zlib, and zip,
those formats may have changed outputs.
The encoder, when operating in
NoCompression
mode, now produces a consistent output that is not dependent on
the size of the slices passed to the
Write
method.
The decoder, upon encountering an error, now returns any buffered data it had uncompressed along with the error.
The Writer
now encodes a zero MTIME field when
the Header.ModTime
field is the zero value.
In previous releases of Go, the Writer would encode
a nonsensical value.
Similarly,
the Reader
now reports a zero encoded MTIME field as a zero
Header.ModTime.
The DeadlineExceeded
error now implements
net.Error
and reports true for both the Timeout and
Temporary methods.
The new method
Conn.CloseWrite
allows TLS connections to be half closed.
The new method
Config.Clone
clones a TLS configuration.
The new Config.GetConfigForClient
callback allows selecting a configuration for a client dynamically, based
on the client's
ClientHelloInfo.
The ClientHelloInfo
struct now has new
fields Conn, SignatureSchemes (using
the new
type SignatureScheme),
SupportedProtos, and SupportedVersions.
The new Config.GetClientCertificate
callback allows selecting a client certificate based on the server's
TLS CertificateRequest message, represented by the new
CertificateRequestInfo.
The new
Config.KeyLogWriter
allows debugging TLS connections
in WireShark and
similar tools.
The new
Config.VerifyPeerCertificate
callback allows additional validation of a peer's presented certificate.
The crypto/tls package now implements basic
countermeasures against CBC padding oracles. There should be
no explicit secret-dependent timings, but it does not attempt to
normalize memory accesses to prevent cache timing leaks.
The crypto/tls package now supports
X25519 and
ChaCha20-Poly1305.
ChaCha20-Poly1305 is now prioritized unless
hardware support for AES-GCM is present.
AES-128-CBC cipher suites with SHA-256 are also now supported, but disabled by default.
PSS signatures are now supported.
UnknownAuthorityError
now has a Cert field, reporting the untrusted
certificate.
Certificate validation is more permissive in a few cases and stricter in a few other cases.
Root certificates will now also be looked for
at /etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem
on Linux, to support RHEL and CentOS.
The package now supports context.Context. There are new methods
ending in Context such as
DB.QueryContext and
DB.PrepareContext
that take context arguments. Using the new Context methods ensures that
connections are closed and returned to the connection pool when the
request is done; enables canceling in-progress queries
should the driver support that; and allows the database
pool to cancel waiting for the next available connection.
The IsolationLevel
can now be set when starting a transaction by setting the isolation level
on TxOptions.Isolation and passing
it to DB.BeginTx.
An error will be returned if an isolation level is selected that the driver
does not support. A read-only attribute may also be set on the transaction
by setting TxOptions.ReadOnly
to true.
Queries now expose the SQL column type information for drivers that support it.
Rows can return ColumnTypes
which can include SQL type information, column type lengths, and the Go type.
A Rows
can now represent multiple result sets. After
Rows.Next returns false,
Rows.NextResultSet
may be called to advance to the next result set. The existing Rows
should continue to be used after it advances to the next result set.
NamedArg may be used
as query arguments. The new function Named
helps create a NamedArg
more succinctly.
If a driver supports the new
Pinger
interface, the
DB.Ping
and
DB.PingContext
methods will use that interface to check whether a
database connection is still valid.
The new Context query methods work for all drivers, but
Context cancelation is not responsive unless the driver has been
updated to use them. The other features require driver support in
database/sql/driver.
Driver authors should review the new interfaces. Users of existing
driver should review the driver documentation to see what
it supports and any system specific documentation on each feature.
The package has been extended and is now used by
the Go linker to read gcc-generated object files.
The new
File.StringTable
and
Section.Relocs
fields provide access to the COFF string table and COFF relocations.
The new
File.COFFSymbols
allows low-level access to the COFF symbol table.
The new
Encoding.Strict
method returns an Encoding that causes the decoder
to return an error when the trailing padding bits are not zero.
UnmarshalTypeError
now includes the struct and field name.
A nil Marshaler
now marshals as a JSON null value.
A RawMessage value now
marshals the same as its pointer type.
Marshal
encodes floating-point numbers using the same format as in ES6,
preferring decimal (not exponential) notation for a wider range of values.
In particular, all floating-point integers up to 264 format the
same as the equivalent int64 representation.
In previous versions of Go, unmarshaling a JSON null into an
Unmarshaler
was considered a no-op; now the Unmarshaler's
UnmarshalJSON method is called with the JSON literal
null and can define the semantics of that case.
Decode
is now strict about the format of the ending line.
Unmarshal
now has wildcard support for collecting all attributes using
the new ",any,attr" struct tag.
The new methods
Int.Value,
String.Value,
Float.Value, and
Func.Value
report the current value of an exported variable.
The new
function Handler
returns the package's HTTP handler, to enable installing it in
non-standard locations.
Scanf,
Fscanf, and
Sscanf now
handle spaces differently and more consistently than
previous releases. See the
scanning documentation
for details.
The new IsPredeclared
function reports whether a string is a predeclared identifier.
The new function
Default
returns the default "typed" type for an "untyped" type.
The alignment of complex64 now matches
the Go compiler.
The package now validates
the "type" attribute on
a <script> tag.
Decode
(and DecodeConfig)
now supports True Color and grayscale transparency.
Encoder
is now faster and creates smaller output
when encoding paletted images.
The new method
Int.Sqrt
calculates ⌊√x⌋.
The new method
Float.Scan
is a support routine for
fmt.Scanner.
Int.ModInverse
now supports negative numbers.
The new Rand.Uint64
method returns uint64 values. The
new Source64
interface describes sources capable of generating such values
directly; otherwise the Rand.Uint64 method
constructs a uint64 from two calls
to Source's
Int63 method.
ParseMediaType
now preserves unnecessary backslash escapes as literals,
in order to support MSIE.
When MSIE sends a full file path (in “intranet mode”), it does not
escape backslashes: “C:\dev\go\foo.txt”, not
“C:\\dev\\go\\foo.txt”.
If we see an unnecessary backslash escape, we now assume it is from MSIE
and intended as a literal backslash.
No known MIME generators emit unnecessary backslash escapes
for simple token characters like numbers and letters.
The
Reader's
parsing has been relaxed in two ways to accept
more input seen in the wild.
First, it accepts an equals sign (=) not followed
by two hex digits as a literal equal sign.
Second, it silently ignores a trailing equals sign at the end of
an encoded input.
The Conn documentation
has been updated to clarify expectations of an interface
implementation. Updates in the net/http packages
depend on implementations obeying the documentation.
Updating: implementations of the Conn interface should verify
they implement the documented semantics. The
golang.org/x/net/nettest
package will exercise a Conn and validate it behaves properly.
The new method
UnixListener.SetUnlinkOnClose
sets whether the underlying socket file should be removed from the file system when
the listener is closed.
The new Buffers type permits
writing to the network more efficiently from multiple discontiguous buffers
in memory. On certain machines, for certain types of connections,
this is optimized into an OS-specific batch write operation (such as writev).
The new Resolver looks up names and numbers
and supports context.Context.
The Dialer now has an optional
Resolver field.
Interfaces is now supported on Solaris.
The Go DNS resolver now supports resolv.conf's “rotate”
and “option ndots:0” options. The “ndots” option is
now respected in the same way as libresolve.
Server changes:
Server
adds configuration options
ReadHeaderTimeout and IdleTimeout
and documents WriteTimeout.
FileServer
and
ServeContent
now support HTTP If-Match conditional requests,
in addition to the previous If-None-Match
support for ETags properly formatted according to RFC 7232, section 2.3.
There are several additions to what a server's Handler can do:
Context
returned
by Request.Context
is canceled if the underlying net.Conn
closes. For instance, if the user closes their browser in the
middle of a slow request, the Handler can now
detect that the user is gone. This complements the
existing CloseNotifier
support. This functionality requires that the underlying
net.Conn implements
recently clarified interface documentation.
TrailerPrefix
mechanism.
Handler can now abort a response by panicking
with the error
ErrAbortHandler.
Write of zero bytes to a
ResponseWriter
is now defined as a
way to test whether a ResponseWriter has been hijacked:
if so, the Write returns
ErrHijacked
without printing an error
to the server's error log.
Client & Transport changes:
Client
now copies most request headers on redirect. See
the documentation
on the Client type for details.
Transport
now supports international domain names. Consequently, so do
Get and other helpers.
Client now supports 301, 307, and 308 redirects.
For example, Client.Post now follows 301
redirects, converting them to GET requests
without bodies, like it did for 302 and 303 redirect responses
previously.
The Client now also follows 307 and 308
redirects, preserving the original request method and body, if
any. If the redirect requires resending the request body, the
request must have the new
Request.GetBody
field defined.
NewRequest
sets Request.GetBody automatically for common
body types.
Transport now rejects requests for URLs with
ports containing non-digit characters.
Transport will now retry non-idempotent
requests if no bytes were written before a network failure
and the request has no body.
Transport.ProxyConnectHeader
allows configuration of header values to send to a proxy
during a CONNECT request.
DefaultTransport.Dialer
now enables DualStack ("Happy Eyeballs") support,
allowing the use of IPv4 as a backup if it looks like IPv6 might be
failing.
Transport
no longer reads a byte of a non-nil
Request.Body
when the
Request.ContentLength
is zero to determine whether the ContentLength
is actually zero or just undefined.
To explicitly signal that a body has zero length,
either set it to nil, or set it to the new value
NoBody.
The new NoBody value is intended for use by Request
constructor functions; it is used by
NewRequest.
There is now support for tracing a client request's TLS handshakes with
the new
ClientTrace.TLSHandshakeStart
and
ClientTrace.TLSHandshakeDone.
The ReverseProxy
has a new optional hook,
ModifyResponse,
for modifying the response from the back end before proxying it to the client.
Empty quoted strings are once again allowed in the name part of
an address. That is, Go 1.4 and earlier accepted
"" <[email protected]>,
but Go 1.5 introduced a bug that rejected this address.
The address is recognized again.
The
Header.Date
method has always provided a way to parse
the Date: header.
A new function
ParseDate
allows parsing dates found in other
header lines, such as the Resent-Date: header.
If an implementation of the
Auth.Start
method returns an empty toServer value,
the package no longer sends
trailing whitespace in the SMTP AUTH command,
which some servers rejected.
The new functions
PathEscape
and
PathUnescape
are similar to the query escaping and unescaping functions but
for path elements.
The new methods
URL.Hostname
and
URL.Port
return the hostname and port fields of a URL,
correctly handling the case where the port may not be present.
The existing method
URL.ResolveReference
now properly handles paths with escaped bytes without losing
the escaping.
The URL type now implements
encoding.BinaryMarshaler and
encoding.BinaryUnmarshaler,
making it possible to process URLs in gob data.
Following RFC 3986,
Parse
now rejects URLs like this_that:other/thing instead of
interpreting them as relative paths (this_that is not a valid scheme).
To force interpretation as a relative path,
such URLs should be prefixed with “./”.
The URL.String method now inserts this prefix as needed.
The new function
Executable returns
the path name of the running executable.
An attempt to call a method on
an os.File that has
already been closed will now return the new error
value os.ErrClosed.
Previously it returned a system-specific error such
as syscall.EBADF.
On Unix systems, os.Rename
will now return an error when used to rename a directory to an
existing empty directory.
Previously it would fail when renaming to a non-empty directory
but succeed when renaming to an empty directory.
This makes the behavior on Unix correspond to that of other systems.
On Windows, long absolute paths are now transparently converted to
extended-length paths (paths that start with “\\?\”).
This permits the package to work with files whose path names are
longer than 260 characters.
On Windows, os.IsExist
will now return true for the system
error ERROR_DIR_NOT_EMPTY.
This roughly corresponds to the existing handling of the Unix
error ENOTEMPTY.
On Plan 9, files that are not served by #M will now
have ModeDevice set in
the value returned
by FileInfo.Mode.
A number of bugs and corner cases on Windows were fixed:
Abs now calls Clean as documented,
Glob now matches
“\\?\c:\*”,
EvalSymlinks now
correctly handles “C:.”, and
Clean now properly
handles a leading “..” in the path.
The new function
Swapper was
added to support sort.Slice.
The Unquote
function now strips carriage returns (\r) in
backquoted raw strings, following the
Go language semantics.
The Getpagesize
now returns the system's size, rather than a constant value.
Previously it always returned 4KB.
The signature
of Utimes has
changed on Solaris to match all the other Unix systems'
signature. Portable code should continue to use
os.Chtimes instead.
The X__cmsg_data field has been removed from
Cmsghdr.
Template.Execute
can now take a
reflect.Value as its data
argument, and
FuncMap
functions can also accept and return reflect.Value.
The new function
Until complements
the analogous Since function.
ParseDuration
now accepts long fractional parts.
Parse
now rejects dates before the start of a month, such as June 0;
it already rejected dates beyond the end of the month, such as
June 31 and July 32.
The tzdata database has been updated to version
2016j for systems that don't already have a local time zone
database.
The new method
T.Name
(and B.Name) returns the name of the current
test or benchmark.
The new function
CoverMode
reports the test coverage mode.
Tests and benchmarks are now marked as failed if the race detector is enabled and a data race occurs during execution. Previously, individual test cases would appear to pass, and only the overall execution of the test binary would fail.
The signature of the
MainStart
function has changed, as allowed by the documentation. It is an
internal detail and not part of the Go 1 compatibility promise.
If you're not calling MainStart directly but see
errors, that likely means you set the
normally-empty GOROOT environment variable and it
doesn't match the version of your go command's binary.
SimpleFold
now returns its argument unchanged if the provided input was an invalid rune.
Previously, the implementation failed with an index bounds check panic.