@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/testing/testing.go

@@ -562,11 +562,16 @@ func (f *chattyFlag) Get() any {
 	return f.on
 }
 
-const marker = byte(0x16) // ^V for framing
+const (
+	markFraming  byte = 'V' &^ '@' // ^V: framing
+	markErrBegin byte = 'O' &^ '@' // ^O: start of error
+	markErrEnd   byte = 'N' &^ '@' // ^N: end of error
+	markEscape   byte = '[' &^ '@' // ^[: escape
+)
 
 func (f *chattyFlag) prefix() string {
 	if f.json {
-		return string(marker)
+		return string(markFraming)
 	}
 	return ""
 }
@@ -588,7 +593,7 @@ func newChattyPrinter(w io.Writer) *chattyPrinter {
 // that as not in json mode (because it's not chatty at all).
 func (p *chattyPrinter) prefix() string {
 	if p != nil && p.json {
-		return string(marker)
+		return string(markFraming)
 	}
 	return ""
 }
@@ -624,6 +629,60 @@ func (p *chattyPrinter) Printf(testName, format string, args ...any) {
 	fmt.Fprintf(p.w, format, args...)
 }
 
+type stringWriter interface {
+	io.Writer
+	io.StringWriter
+}
+
+// escapeWriter is a [io.Writer] that escapes test framing markers.
+type escapeWriter struct {
+	w stringWriter
+}
+
+func (w escapeWriter) WriteString(s string) (int, error) {
+	return w.Write([]byte(s))
+}
+
+func (w escapeWriter) Write(p []byte) (int, error) {
+	var n, m int
+	var err error
+	for len(p) > 0 {
+		i := w.nextMark(p)
+		if i < 0 {
+			break
+		}
+
+		m, err = w.w.Write(p[:i])
+		n += m
+		if err != nil {
+			break
+		}
+
+		m, err = w.w.Write([]byte{markEscape, p[i]})
+		if err != nil {
+			break
+		}
+		if m != 2 {
+			return n, fmt.Errorf("short write")
+		}
+		n++
+		p = p[i+1:]
+	}
+	m, err = w.w.Write(p)
+	n += m
+	return n, err
+}
+
+func (escapeWriter) nextMark(p []byte) int {
+	for i, b := range p {
+		switch b {
+		case markFraming, markErrBegin, markErrEnd, markEscape:
+			return i
+		}
+	}
+	return -1
+}
+
 // The maximum number of stack frames to go through when skipping helper functions for
 // the purpose of decorating log messages.
 const maxStackLen = 50
@@ -757,8 +816,15 @@ func (c *common) frameSkip(skip int) runtime.Frame {
 	}
 	frames := runtime.CallersFrames(pc[:n])
 	var firstFrame, prevFrame, frame runtime.Frame
+	skipRange := false
 	for more := true; more; prevFrame = frame {
 		frame, more = frames.Next()
+		if skipRange {
+			// Skip the iterator function when a helper
+			// functions does a range over function.
+			skipRange = false
+			continue
+		}
 		if frame.Function == "runtime.gopanic" {
 			continue
 		}
@@ -802,7 +868,25 @@ func (c *common) frameSkip(skip int) runtime.Frame {
 				c.helperNames[pcToName(pc)] = struct{}{}
 			}
 		}
-		if _, ok := c.helperNames[frame.Function]; !ok {
+
+		fnName := frame.Function
+		// Ignore trailing -rangeN used for iterator functions.
+		const rangeSuffix = "-range"
+		if suffixIdx := strings.LastIndex(fnName, rangeSuffix); suffixIdx > 0 {
+			ok := true
+			for i := suffixIdx + len(rangeSuffix); i < len(fnName); i++ {
+				if fnName[i] < '0' || fnName[i] > '9' {
+					ok = false
+					break
+				}
+			}
+			if ok {
+				fnName = fnName[:suffixIdx]
+				skipRange = true
+			}
+		}
+
+		if _, ok := c.helperNames[fnName]; !ok {
 			// Found a frame that wasn't inside a helper function.
 			return frame
 		}
@@ -869,8 +953,8 @@ func (w indenter) Write(b []byte) (n int, err error) {
 		// An indent of 4 spaces will neatly align the dashes with the status
 		// indicator of the parent.
 		line := b[:end]
-		if line[0] == marker {
-			w.c.output = append(w.c.output, marker)
+		if line[0] == markFraming {
+			w.c.output = append(w.c.output, markFraming)
 			line = line[1:]
 		}
 		w.c.output = append(w.c.output, indent...)
@@ -1025,7 +1109,7 @@ func (c *common) FailNow() {
 // log generates the output. It is always at the same stack depth. log inserts
 // indentation and the final newline if necessary. It prefixes the string
 // with the file and line of the call site.
-func (c *common) log(s string) {
+func (c *common) log(s string, isErr bool) {
 	s = strings.TrimSuffix(s, "\n")
 
 	// Second and subsequent lines are indented 4 spaces. This is in addition to
@@ -1046,7 +1130,7 @@ func (c *common) log(s string) {
 	// Output buffered logs.
 	n.flushPartial()
 
-	n.o.Write([]byte(s))
+	n.o.write([]byte(s), isErr)
 }
 
 // destination selects the test to which output should be appended. It returns the
@@ -1134,6 +1218,10 @@ type outputWriter struct {
 // Write writes a log message to the test's output stream, properly formatted and
 // indented. It may not be called after a test function and all its parents return.
 func (o *outputWriter) Write(p []byte) (int, error) {
+	return o.write(p, false)
+}
+
+func (o *outputWriter) write(p []byte, isErr bool) (int, error) {
 	// o can be nil if this is called from a top-level *TB that is no longer active.
 	// Just ignore the message in that case.
 	if o == nil || o.c == nil {
@@ -1155,7 +1243,7 @@ func (o *outputWriter) Write(p []byte) (int, error) {
 			line = slices.Concat(o.partial, line)
 			o.partial = o.partial[:0]
 		}
-		o.writeLine(line)
+		o.writeLine(line, isErr && i == 0, isErr && i == last-1)
 	}
 	// Save partial line for next call.
 	o.partial = append(o.partial, lines[last]...)
@@ -1164,19 +1252,76 @@ func (o *outputWriter) Write(p []byte) (int, error) {
 }
 
 // writeLine generates the output for a given line.
-func (o *outputWriter) writeLine(b []byte) {
-	if !o.c.done && (o.c.chatty != nil) {
-		if o.c.bench {
-			// Benchmarks don't print === CONT, so we should skip the test
-			// printer and just print straight to stdout.
-			fmt.Printf("%s%s", indent, b)
-		} else {
-			o.c.chatty.Printf(o.c.name, "%s%s", indent, b)
-		}
+func (o *outputWriter) writeLine(b []byte, errBegin, errEnd bool) {
+	if o.c.done || (o.c.chatty == nil) {
+		o.c.output = append(o.c.output, indent...)
+		o.c.output = append(o.c.output, b...)
 		return
 	}
-	o.c.output = append(o.c.output, indent...)
-	o.c.output = append(o.c.output, b...)
+
+	// Escape the framing marker.
+	if o.c.chatty.json {
+		b = escapeMarkers(b)
+	}
+
+	// If this is the start of an error, add ^O to the start of the output.
+	var strErrBegin, strErrEnd string
+	if errBegin && o.c.chatty.json {
+		strErrBegin = string(markErrBegin)
+	}
+
+	// If this is the end of an error, add ^N to the end of the output. If the
+	// last character of the output is \n, add ^N before the \n, otherwise
+	// test2json will not handle it correctly.
+	var c []byte
+	if errEnd && o.c.chatty.json {
+		i := len(b)
+		if len(b) > 0 && b[i-1] == '\n' {
+			b, c = b[:i-1], b[i-1:]
+		}
+		strErrEnd = string(markErrEnd)
+	}
+
+	if o.c.bench {
+		// Benchmarks don't print === CONT, so we should skip the test
+		// printer and just print straight to stdout.
+		fmt.Printf("%s%s%s%s%s", strErrBegin, indent, b, strErrEnd, c)
+	} else {
+		o.c.chatty.Printf(o.c.name, "%s%s%s%s%s", strErrBegin, indent, b, strErrEnd, c)
+	}
+}
+
+func escapeMarkers(b []byte) []byte {
+	j := nextMark(b)
+	if j < 0 {
+		// Allocation-free fast path.
+		return b
+	}
+
+	c := make([]byte, 0, len(b)+10)
+	i := 0
+	for i < len(b) && j >= i {
+		if j > i {
+			c = append(c, b[i:j]...)
+		}
+		c = append(c, markEscape, b[j])
+		i = j + 1
+		j = i + nextMark(b[i:])
+	}
+	if i < len(b) {
+		c = append(c, b[i:]...)
+	}
+	return c
+}
+
+func nextMark(b []byte) int {
+	for i, b := range b {
+		switch b {
+		case markFraming, markEscape, markErrBegin, markErrEnd:
+			return i
+		}
+	}
+	return -1
 }
 
 // Log formats its arguments using default formatting, analogous to [fmt.Println],
@@ -1186,7 +1331,7 @@ func (o *outputWriter) writeLine(b []byte) {
 // It is an error to call Log after a test or benchmark returns.
 func (c *common) Log(args ...any) {
 	c.checkFuzzFn("Log")
-	c.log(fmt.Sprintln(args...))
+	c.log(fmt.Sprintln(args...), false)
 }
 
 // Logf formats its arguments according to the format, analogous to [fmt.Printf], and
@@ -1197,48 +1342,48 @@ func (c *common) Log(args ...any) {
 // It is an error to call Logf after a test or benchmark returns.
 func (c *common) Logf(format string, args ...any) {
 	c.checkFuzzFn("Logf")
-	c.log(fmt.Sprintf(format, args...))
+	c.log(fmt.Sprintf(format, args...), false)
 }
 
 // Error is equivalent to Log followed by Fail.
 func (c *common) Error(args ...any) {
 	c.checkFuzzFn("Error")
-	c.log(fmt.Sprintln(args...))
+	c.log(fmt.Sprintln(args...), true)
 	c.Fail()
 }
 
 // Errorf is equivalent to Logf followed by Fail.
 func (c *common) Errorf(format string, args ...any) {
 	c.checkFuzzFn("Errorf")
-	c.log(fmt.Sprintf(format, args...))
+	c.log(fmt.Sprintf(format, args...), true)
 	c.Fail()
 }
 
 // Fatal is equivalent to Log followed by FailNow.
 func (c *common) Fatal(args ...any) {
 	c.checkFuzzFn("Fatal")
-	c.log(fmt.Sprintln(args...))
+	c.log(fmt.Sprintln(args...), true)
 	c.FailNow()
 }
 
 // Fatalf is equivalent to Logf followed by FailNow.
 func (c *common) Fatalf(format string, args ...any) {
 	c.checkFuzzFn("Fatalf")
-	c.log(fmt.Sprintf(format, args...))
+	c.log(fmt.Sprintf(format, args...), true)
 	c.FailNow()
 }
 
 // Skip is equivalent to Log followed by SkipNow.
 func (c *common) Skip(args ...any) {
 	c.checkFuzzFn("Skip")
-	c.log(fmt.Sprintln(args...))
+	c.log(fmt.Sprintln(args...), false)
 	c.SkipNow()
 }
 
 // Skipf is equivalent to Logf followed by SkipNow.
 func (c *common) Skipf(format string, args ...any) {
 	c.checkFuzzFn("Skipf")
-	c.log(fmt.Sprintf(format, args...))
+	c.log(fmt.Sprintf(format, args...), false)
 	c.SkipNow()
 }
 
@@ -1363,6 +1508,21 @@ func (c *common) makeArtifactDir() (string, error) {
 		return c.makeTempDir()
 	}
 
+	artifactBase := filepath.Join(artifactDir, c.relativeArtifactBase())
+	if err := os.MkdirAll(artifactBase, 0o777); err != nil {
+		return "", err
+	}
+	dir, err := os.MkdirTemp(artifactBase, "")
+	if err != nil {
+		return "", err
+	}
+	if c.chatty != nil {
+		c.chatty.Updatef(c.name, "=== ARTIFACTS %s %v\n", c.name, dir)
+	}
+	return dir, nil
+}
+
+func (c *common) relativeArtifactBase() string {
 	// If the test name is longer than maxNameSize, truncate it and replace the last
 	// hashSize bytes with a hash of the full name.
 	const maxNameSize = 64
@@ -1373,11 +1533,17 @@ func (c *common) makeArtifactDir() (string, error) {
 	}
 
 	// Remove the module path prefix from the import path.
-	pkg := strings.TrimPrefix(c.importPath, c.modulePath+"/")
+	// If this is the root package, pkg will be empty.
+	pkg := strings.TrimPrefix(c.importPath, c.modulePath)
+	// Remove the leading slash.
+	pkg = strings.TrimPrefix(pkg, "/")
 
-	// Join with /, not filepath.Join: the import path is /-separated,
-	// and we don't want removeSymbolsExcept to strip \ separators on Windows.
-	base := "/" + pkg + "/" + name
+	base := name
+	if pkg != "" {
+		// Join with /, not filepath.Join: the import path is /-separated,
+		// and we don't want removeSymbolsExcept to strip \ separators on Windows.
+		base = pkg + "/" + name
+	}
 	base = removeSymbolsExcept(base, "!#$%&()+,-.=@^_{}~ /")
 	base, err := filepath.Localize(base)
 	if err != nil {
@@ -1386,18 +1552,7 @@ func (c *common) makeArtifactDir() (string, error) {
 		base = ""
 	}
 
-	artifactBase := filepath.Join(artifactDir, base)
-	if err := os.MkdirAll(artifactBase, 0o777); err != nil {
-		return "", err
-	}
-	dir, err := os.MkdirTemp(artifactBase, "")
-	if err != nil {
-		return "", err
-	}
-	if c.chatty != nil {
-		c.chatty.Updatef(c.name, "=== ARTIFACTS %s %v\n", c.name, dir)
-	}
-	return dir, nil
+	return base
 }
 
 func removeSymbolsExcept(s, allowed string) string {
@@ -1752,9 +1907,10 @@ func pcToName(pc uintptr) string {
 const parallelConflict = `testing: test using t.Setenv, t.Chdir, or cryptotest.SetGlobalRandom can not use t.Parallel`
 
 // Parallel signals that this test is to be run in parallel with (and only with)
-// other parallel tests. When a test is run multiple times due to use of
-// -test.count or -test.cpu, multiple instances of a single test never run in
-// parallel with each other.
+// other parallel tests, and pauses until all non-parallel tests have finished.
+//
+// When a test is run multiple times due to use of -test.count or -test.cpu,
+// multiple instances of a single test never run in parallel with each other.
 func (t *T) Parallel() {
 	if t.isParallel {
 		panic("testing: t.Parallel called multiple times")
@@ -1883,11 +2039,6 @@ func tRunner(t *T, fn func(t *T)) {
 	defer func() {
 		t.checkRaces()
 
-		// TODO(#61034): This is the wrong place for this check.
-		if t.Failed() {
-			numFailed.Add(1)
-		}
-
 		// Check if the test panicked or Goexited inappropriately.
 		//
 		// If this happens in a normal test, print output but continue panicking.
@@ -2016,6 +2167,14 @@ func tRunner(t *T, fn func(t *T)) {
 		for root := &t.common; root.parent != nil; root = root.parent {
 			root.flushPartial()
 		}
+
+		// Record this test's failure for -failfast. This must happen after the
+		// test's cleanup functions have run, since a cleanup may call t.Fail.
+		// See go.dev/issue/61034.
+		if t.Failed() {
+			numFailed.Add(1)
+		}
+
 		t.report() // Report after all subtests have finished.
 
 		// Do not lock t.done to allow race detector to detect race in case

package/bin/go/src/text/template/parse/lex.go

@@ -240,10 +240,10 @@ func (l *lexer) nextItem() item {
 // lex creates a new scanner for the input string.
 func lex(name, input, left, right string) *lexer {
 	if left == "" {
-		left = leftDelim
+		left = defaultLeftDelim
 	}
 	if right == "" {
-		right = rightDelim
+		right = defaultRightDelim
 	}
 	l := &lexer{
 		name:         name,
@@ -260,10 +260,10 @@ func lex(name, input, left, right string) *lexer {
 // state functions
 
 const (
-	leftDelim    = "{{"
-	rightDelim   = "}}"
-	leftComment  = "/*"
-	rightComment = "*/"
+	defaultLeftDelim  = "{{"
+	defaultRightDelim = "}}"
+	leftComment       = "/*"
+	rightComment      = "*/"
 )
 
 // lexText scans until an opening action delimiter, "{{".

package/bin/go/src/text/template/parse/node.go

@@ -171,9 +171,9 @@ func (c *CommentNode) String() string {
 }
 
 func (c *CommentNode) writeTo(sb *strings.Builder) {
-	sb.WriteString("{{")
+	sb.WriteString(c.tr.leftDelim)
 	sb.WriteString(c.Text)
-	sb.WriteString("}}")
+	sb.WriteString(c.tr.rightDelim)
 }
 
 func (c *CommentNode) tree() *Tree {
@@ -277,9 +277,9 @@ func (a *ActionNode) String() string {
 }
 
 func (a *ActionNode) writeTo(sb *strings.Builder) {
-	sb.WriteString("{{")
+	sb.WriteString(a.tr.leftDelim)
 	a.Pipe.writeTo(sb)
-	sb.WriteString("}}")
+	sb.WriteString(a.tr.rightDelim)
 }
 
 func (a *ActionNode) tree() *Tree {
@@ -793,7 +793,7 @@ func (t *Tree) newEnd(pos Pos) *endNode {
 }
 
 func (e *endNode) String() string {
-	return "{{end}}"
+	return e.tr.leftDelim + "end" + e.tr.rightDelim
 }
 
 func (e *endNode) writeTo(sb *strings.Builder) {
@@ -825,7 +825,7 @@ func (e *elseNode) Type() NodeType {
 }
 
 func (e *elseNode) String() string {
-	return "{{else}}"
+	return e.tr.leftDelim + "else" + e.tr.rightDelim
 }
 
 func (e *elseNode) writeTo(sb *strings.Builder) {
@@ -869,17 +869,21 @@ func (b *BranchNode) writeTo(sb *strings.Builder) {
 	default:
 		panic("unknown branch type")
 	}
-	sb.WriteString("{{")
+	sb.WriteString(b.tr.leftDelim)
 	sb.WriteString(name)
 	sb.WriteByte(' ')
 	b.Pipe.writeTo(sb)
-	sb.WriteString("}}")
+	sb.WriteString(b.tr.rightDelim)
 	b.List.writeTo(sb)
 	if b.ElseList != nil {
-		sb.WriteString("{{else}}")
+		sb.WriteString(b.tr.leftDelim)
+		sb.WriteString("else")
+		sb.WriteString(b.tr.rightDelim)
 		b.ElseList.writeTo(sb)
 	}
-	sb.WriteString("{{end}}")
+	sb.WriteString(b.tr.leftDelim)
+	sb.WriteString("end")
+	sb.WriteString(b.tr.rightDelim)
 }
 
 func (b *BranchNode) tree() *Tree {
@@ -925,9 +929,9 @@ func (t *Tree) newBreak(pos Pos, line int) *BreakNode {
 }
 
 func (b *BreakNode) Copy() Node                  { return b.tr.newBreak(b.Pos, b.Line) }
-func (b *BreakNode) String() string              { return "{{break}}" }
+func (b *BreakNode) String() string              { return b.tr.leftDelim + "break" + b.tr.rightDelim }
 func (b *BreakNode) tree() *Tree                 { return b.tr }
-func (b *BreakNode) writeTo(sb *strings.Builder) { sb.WriteString("{{break}}") }
+func (b *BreakNode) writeTo(sb *strings.Builder) { sb.WriteString(b.String()) }
 
 // ContinueNode represents a {{continue}} action.
 type ContinueNode struct {
@@ -942,9 +946,9 @@ func (t *Tree) newContinue(pos Pos, line int) *ContinueNode {
 }
 
 func (c *ContinueNode) Copy() Node                  { return c.tr.newContinue(c.Pos, c.Line) }
-func (c *ContinueNode) String() string              { return "{{continue}}" }
+func (c *ContinueNode) String() string              { return c.tr.leftDelim + "continue" + c.tr.rightDelim }
 func (c *ContinueNode) tree() *Tree                 { return c.tr }
-func (c *ContinueNode) writeTo(sb *strings.Builder) { sb.WriteString("{{continue}}") }
+func (c *ContinueNode) writeTo(sb *strings.Builder) { sb.WriteString(c.String()) }
 
 // RangeNode represents a {{range}} action and its commands.
 type RangeNode struct {
@@ -993,13 +997,14 @@ func (t *TemplateNode) String() string {
 }
 
 func (t *TemplateNode) writeTo(sb *strings.Builder) {
-	sb.WriteString("{{template ")
+	sb.WriteString(t.tr.leftDelim)
+	sb.WriteString("template ")
 	sb.WriteString(strconv.Quote(t.Name))
 	if t.Pipe != nil {
 		sb.WriteByte(' ')
 		t.Pipe.writeTo(sb)
 	}
-	sb.WriteString("}}")
+	sb.WriteString(t.tr.rightDelim)
 }
 
 func (t *TemplateNode) tree() *Tree {

package/bin/go/src/text/template/parse/parse.go

@@ -33,6 +33,9 @@ type Tree struct {
 	actionLine int // line of left delim starting action
 	rangeDepth int
 	stackDepth int // depth of nested parenthesized expressions
+
+	leftDelim  string
+	rightDelim string
 }
 
 // A Mode value is a set of flags (or 0). Modes control parser behavior.
@@ -60,10 +63,12 @@ func (t *Tree) Copy() *Tree {
 		return nil
 	}
 	return &Tree{
-		Name:      t.Name,
-		ParseName: t.ParseName,
-		Root:      t.Root.CopyList(),
-		text:      t.text,
+		Name:       t.Name,
+		ParseName:  t.ParseName,
+		Root:       t.Root.CopyList(),
+		text:       t.text,
+		leftDelim:  t.leftDelim,
+		rightDelim: t.rightDelim,
 	}
 }
 
@@ -258,7 +263,15 @@ func (t *Tree) stopParse() {
 func (t *Tree) Parse(text, leftDelim, rightDelim string, treeSet map[string]*Tree, funcs ...map[string]any) (tree *Tree, err error) {
 	defer t.recover(&err)
 	t.ParseName = t.Name
-	lexer := lex(t.Name, text, leftDelim, rightDelim)
+	t.leftDelim = leftDelim
+	if t.leftDelim == "" {
+		t.leftDelim = defaultLeftDelim
+	}
+	t.rightDelim = rightDelim
+	if t.rightDelim == "" {
+		t.rightDelim = defaultRightDelim
+	}
+	lexer := lex(t.Name, text, t.leftDelim, t.rightDelim)
 	t.startParse(funcs, lexer, treeSet)
 	t.text = text
 	t.parse()
@@ -318,6 +331,8 @@ func (t *Tree) parse() {
 				newT := New("definition") // name will be updated once we know it.
 				newT.text = t.text
 				newT.Mode = t.Mode
+				newT.leftDelim = t.leftDelim
+				newT.rightDelim = t.rightDelim
 				newT.ParseName = t.ParseName
 				newT.startParse(t.funcs, t.lex, t.treeSet)
 				newT.parseDefinition()
@@ -546,7 +561,7 @@ func (t *Tree) parseControl(context string) (pos Pos, line int, pipe *PipeNode,
 		t.rangeDepth--
 	}
 	switch next.Type() {
-	case nodeEnd: //done
+	case nodeEnd: // done
 	case nodeElse:
 		// Special case for "else if" and "else with".
 		// If the "else" is followed immediately by an "if" or "with",
@@ -650,6 +665,8 @@ func (t *Tree) blockControl() Node {
 	block := New(name) // name will be updated once we know it.
 	block.text = t.text
 	block.Mode = t.Mode
+	block.leftDelim = t.leftDelim
+	block.rightDelim = t.rightDelim
 	block.ParseName = t.ParseName
 	block.startParse(t.funcs, t.lex, t.treeSet)
 	var end Node

package/bin/go/src/text/template/template.go

@@ -167,11 +167,13 @@ func (t *Template) Delims(left, right string) *Template {
 }
 
 // Funcs adds the elements of the argument map to the template's function map.
-// It must be called before the template is parsed.
+// Any function used in the template must be added before the template is
+// parsed. Funcs may be called more than once, including after parsing (for
+// example, after [Template.Clone]), to replace a function of the same name;
+// the replacement is used when the template is executed.
 // It panics if a value in the map is not a function with appropriate return
 // type or if the name cannot be used syntactically as a function in a template.
-// It is legal to overwrite elements of the map. The return value is the template,
-// so calls can be chained.
+// The return value is the template, so calls can be chained.
 func (t *Template) Funcs(funcMap FuncMap) *Template {
 	t.init()
 	t.muFuncs.Lock()

package/bin/go/src/time/format.go

@@ -1002,6 +1002,9 @@ func skip(value, prefix string) (string, error) {
 // For layouts specifying the two-digit year 06, a value NN >= 69 will be treated
 // as 19NN and a value NN < 69 will be treated as 20NN.
 //
+// Timestamps representing leap seconds (second 60) cannot be parsed.
+// These are not representable by [Time].
+//
 // The remainder of this comment describes the handling of time zones.
 //
 // In the absence of a time zone indicator, Parse returns a time in UTC.