@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/encoding/json/v2_stream.go

@@ -10,6 +10,7 @@ import (
 	"bytes"
 	"errors"
 	"io"
+	"reflect"
 
 	"encoding/json/jsontext"
 	jsonv2 "encoding/json/v2"
@@ -24,6 +25,10 @@ type Decoder struct {
 	// hadPeeked reports whether [Decoder.More] was called.
 	// It is reset by [Decoder.Decode] and [Decoder.Token].
 	hadPeeked bool
+
+	// hadEOF reports whether [Decoder.Token] had hit [io.EOF].
+	// It is reset by [Decoder.Decode] and [Decoder.Token].
+	hadEOF bool
 }
 
 // NewDecoder returns a new decoder that reads from r.
@@ -32,7 +37,7 @@ type Decoder struct {
 // read data from r beyond the JSON values requested.
 func NewDecoder(r io.Reader) *Decoder {
 	// Hide bytes.Buffer from jsontext since it implements optimizations that
-	// also limits certain ways it could be used. For example, one cannot write
+	// also limit certain ways it could be used. For example, one cannot write
 	// to the bytes.Buffer while it is in use by jsontext.Decoder.
 	if _, ok := r.(*bytes.Buffer); ok {
 		r = struct{ io.Reader }{r}
@@ -81,11 +86,24 @@ func (dec *Decoder) Decode(v any) error {
 		return dec.err
 	}
 	dec.hadPeeked = false
+	dec.hadEOF = false
 	return jsonv2.Unmarshal(b, v, dec.opts)
 }
 
-// Buffered returns a reader of the data remaining in the Decoder's
-// buffer. The reader is valid until the next call to [Decoder.Decode].
+// Buffered returns a reader of the data remaining in the unread buffer,
+// which may contain zero or more bytes.
+// This is the data already consumed from the input [io.Reader],
+// but not yet read by a [Decoder.Decode] or [Decoder.Token] call.
+// It may contain bytes that do not form valid JSON as it has not yet
+// been validated according to the JSON grammar.
+// The exact amount of buffered data is an implementation detail
+// of the Decoder and may change over time.
+//
+// It is the caller's responsibility to concatenate this buffer with
+// the remainder of the input Reader to obtain the full sequence
+// of bytes after the last decoded JSON value.
+//
+// The reader is valid until the next call to [Decoder.Decode] or [Decoder.Token].
 func (dec *Decoder) Buffered() io.Reader {
 	return bytes.NewReader(dec.dec.UnreadBuffer())
 }
@@ -96,7 +114,6 @@ type Encoder struct {
 	opts jsonv2.Options
 	err  error
 
-	buf       bytes.Buffer
 	indentBuf bytes.Buffer
 
 	indentPrefix string
@@ -121,21 +138,22 @@ func (enc *Encoder) Encode(v any) error {
 		return enc.err
 	}
 
-	buf := &enc.buf
-	buf.Reset()
-	if err := jsonv2.MarshalWrite(buf, v, enc.opts); err != nil {
+	e := export.GetBufferedEncoder(enc.opts)
+	defer export.PutBufferedEncoder(e)
+	if err := jsonv2.MarshalEncode(e, v); err != nil {
 		return err
 	}
+	b := export.Encoder(e).Buf // b must not leak current scope
 	if len(enc.indentPrefix)+len(enc.indentValue) > 0 {
 		enc.indentBuf.Reset()
-		if err := Indent(&enc.indentBuf, buf.Bytes(), enc.indentPrefix, enc.indentValue); err != nil {
+		if err := Indent(&enc.indentBuf, b, enc.indentPrefix, enc.indentValue); err != nil {
 			return err
 		}
-		buf = &enc.indentBuf
+		b = enc.indentBuf.Bytes()
 	}
-	buf.WriteByte('\n')
+	b = append(b, '\n')
 
-	if _, err := enc.w.Write(buf.Bytes()); err != nil {
+	if _, err := enc.w.Write(b); err != nil {
 		enc.err = err
 		return err
 	}
@@ -146,6 +164,9 @@ func (enc *Encoder) Encode(v any) error {
 // value as if indented by the package-level function Indent(dst, src, prefix, indent).
 // Calling SetIndent("", "") disables indentation.
 func (enc *Encoder) SetIndent(prefix, indent string) {
+	// NOTE: Do not rely on the newer [jsontext.WithIndent] option since
+	// the v1 [Indent] behavior has historical bugs that cannot be changed
+	// for backward compatibility reasons.
 	enc.indentPrefix = prefix
 	enc.indentValue = indent
 }
@@ -206,8 +227,11 @@ func (dec *Decoder) Token() (Token, error) {
 		// the stream is a prefix of a valid JSON value.
 		// It reports an unwrapped [io.ErrUnexpectedEOF] if
 		// truncated within a JSON token such as a literal, number, or string.
-		if errors.Is(err, io.ErrUnexpectedEOF) {
+		// If the underlying [io.Reader] produced the [io.ErrUnexpectedEOF],
+		// then return the error as-is (including any wrapping).
+		if errors.Is(err, io.ErrUnexpectedEOF) && !export.IsIOError(err) {
 			if len(bytes.Trim(dec.dec.UnreadBuffer(), " \r\n\t,:")) == 0 {
+				dec.hadEOF = true
 				return nil, io.EOF
 			}
 			return nil, io.ErrUnexpectedEOF
@@ -215,6 +239,7 @@ func (dec *Decoder) Token() (Token, error) {
 		return nil, transformSyntacticError(err)
 	}
 	dec.hadPeeked = false
+	dec.hadEOF = false
 	switch k := tok.Kind(); k {
 	case 'n':
 		return nil, nil
@@ -228,7 +253,11 @@ func (dec *Decoder) Token() (Token, error) {
 		if useNumber, _ := jsonv2.GetOption(dec.opts, unmarshalAnyWithRawNumber); useNumber {
 			return Number(tok.String()), nil
 		}
-		return tok.Float(), nil
+		v, err := tok.Float()
+		if err != nil {
+			return nil, &UnmarshalTypeError{Value: "number " + tok.String(), Type: reflect.TypeFor[float64](), Offset: dec.InputOffset()}
+		}
+		return v, nil
 	case '{', '}', '[', ']':
 		return Delim(k), nil
 	default:
@@ -262,7 +291,7 @@ func (dec *Decoder) More() bool {
 // and the beginning of the next token.
 func (dec *Decoder) InputOffset() int64 {
 	offset := dec.dec.InputOffset()
-	if dec.hadPeeked {
+	if dec.hadPeeked || dec.hadEOF {
 		// Historically, InputOffset reported the location of
 		// the end of the most recently returned token
 		// unless [Decoder.More] is called, in which case, it reported
@@ -272,6 +301,12 @@ func (dec *Decoder) InputOffset() int64 {
 		if len(trailingTokens) > 0 {
 			leadingWhitespace := len(unreadBuffer) - len(trailingTokens)
 			offset += int64(leadingWhitespace)
+
+			// If [Decoder.Token] had encountered [io.EOF],
+			// then it also includes the upcoming comma or colon.
+			if dec.hadEOF && (trailingTokens[0] == ',' || trailingTokens[0] == ':') {
+				offset++
+			}
 		}
 	}
 	return offset

package/bin/go/src/encoding/pem/pem.go

@@ -307,8 +307,12 @@ func Encode(out io.Writer, b *Block) error {
 	if _, err := b64.Write(b.Bytes); err != nil {
 		return err
 	}
-	b64.Close()
-	breaker.Close()
+	if err := b64.Close(); err != nil {
+		return err
+	}
+	if err := breaker.Close(); err != nil {
+		return err
+	}
 
 	if _, err := out.Write(pemEnd[1:]); err != nil {
 		return err

package/bin/go/src/fmt/doc.go

@@ -43,7 +43,7 @@ Integer:
 	%d	base 10
 	%o	base 8
 	%O	base 8 with 0o prefix
-	%q	a single-quoted character literal safely escaped with Go syntax.
+	%q	a single-quoted rune literal safely escaped with Go syntax.
 	%x	base 16, with lower-case letters for a-f
 	%X	base 16, with upper-case letters for A-F
 	%U	Unicode format: U+1234; same as "U+%04X"
@@ -299,6 +299,16 @@ occurred. If the panic is caused by a nil receiver to an Error,
 String, or GoString method, however, the output is the undecorated
 string, "<nil>".
 
+Many packages whose APIs involve string formatting expose a trio of
+functions similar to [Print], [Printf], and [Println].
+For example, the [log.Print], [log.Printf] and [log.Println] functions
+forward their arguments to the corresponding functions in this package.
+To avoid confusion, other wrapper functions should follow the naming
+and behavioral conventions established by this package.
+In particular, a single function should not choose between literal
+printing (like [Print]) and formatted printing (like [Printf])
+based on the number of arguments; instead, provide separate functions.
+
 # Scanning
 
 An analogous set of functions scans formatted text to yield

package/bin/go/src/fmt/print.go

@@ -120,12 +120,6 @@ func (b *buffer) writeRune(r rune) {
 type pp struct {
 	buf buffer
 
-	// arg holds the current item, as an interface{}.
-	arg any
-
-	// value is used instead of arg for reflect values.
-	value reflect.Value
-
 	// fmt is used to format basic items such as integers or strings.
 	fmt fmt
 
@@ -175,8 +169,6 @@ func (p *pp) free() {
 		p.wrappedErrs = nil
 	}
 
-	p.arg = nil
-	p.value = reflect.Value{}
 	p.wrappedErrs = p.wrappedErrs[:0]
 	ppFree.Put(p)
 }
@@ -379,20 +371,20 @@ func (p *pp) unknownType(v reflect.Value) {
 	p.buf.writeByte('?')
 }
 
-func (p *pp) badVerb(verb rune) {
+func (p *pp) badVerb(arg any, value reflect.Value, verb rune) {
 	p.erroring = true
 	p.buf.writeString(percentBangString)
 	p.buf.writeRune(verb)
 	p.buf.writeByte('(')
 	switch {
-	case p.arg != nil:
-		p.buf.writeString(reflect.TypeOf(p.arg).String())
+	case arg != nil:
+		p.buf.writeString(reflect.TypeOf(arg).String())
 		p.buf.writeByte('=')
-		p.printArg(p.arg, 'v')
-	case p.value.IsValid():
-		p.buf.writeString(p.value.Type().String())
+		p.printArg(arg, 'v')
+	case value.IsValid():
+		p.buf.writeString(value.Type().String())
 		p.buf.writeByte('=')
-		p.printValue(p.value, 'v', 0)
+		p.printValue(value, 'v', 0)
 	default:
 		p.buf.writeString(nilAngleString)
 	}
@@ -400,12 +392,12 @@ func (p *pp) badVerb(verb rune) {
 	p.erroring = false
 }
 
-func (p *pp) fmtBool(v bool, verb rune) {
+func (p *pp) fmtBool(arg any, value reflect.Value, v bool, verb rune) {
 	switch verb {
 	case 't', 'v':
 		p.fmt.fmtBoolean(v)
 	default:
-		p.badVerb(verb)
+		p.badVerb(arg, value, verb)
 	}
 }
 
@@ -419,7 +411,7 @@ func (p *pp) fmt0x64(v uint64, leading0x bool) {
 }
 
 // fmtInteger formats a signed or unsigned integer.
-func (p *pp) fmtInteger(v uint64, isSigned bool, verb rune) {
+func (p *pp) fmtInteger(arg any, value reflect.Value, v uint64, isSigned bool, verb rune) {
 	switch verb {
 	case 'v':
 		if p.fmt.sharpV && !isSigned {
@@ -444,13 +436,13 @@ func (p *pp) fmtInteger(v uint64, isSigned bool, verb rune) {
 	case 'U':
 		p.fmt.fmtUnicode(v)
 	default:
-		p.badVerb(verb)
+		p.badVerb(arg, value, verb)
 	}
 }
 
 // fmtFloat formats a float. The default precision for each verb
 // is specified as last argument in the call to fmt_float.
-func (p *pp) fmtFloat(v float64, size int, verb rune) {
+func (p *pp) fmtFloat(arg any, value reflect.Value, v float64, size int, verb rune) {
 	switch verb {
 	case 'v':
 		p.fmt.fmtFloat(v, size, 'g', -1)
@@ -461,32 +453,32 @@ func (p *pp) fmtFloat(v float64, size int, verb rune) {
 	case 'F':
 		p.fmt.fmtFloat(v, size, 'f', 6)
 	default:
-		p.badVerb(verb)
+		p.badVerb(arg, value, verb)
 	}
 }
 
 // fmtComplex formats a complex number v with
 // r = real(v) and j = imag(v) as (r+ji) using
 // fmtFloat for r and j formatting.
-func (p *pp) fmtComplex(v complex128, size int, verb rune) {
+func (p *pp) fmtComplex(arg any, value reflect.Value, v complex128, size int, verb rune) {
 	// Make sure any unsupported verbs are found before the
 	// calls to fmtFloat to not generate an incorrect error string.
 	switch verb {
 	case 'v', 'b', 'g', 'G', 'x', 'X', 'f', 'F', 'e', 'E':
 		oldPlus := p.fmt.plus
 		p.buf.writeByte('(')
-		p.fmtFloat(real(v), size/2, verb)
+		p.fmtFloat(arg, value, real(v), size/2, verb)
 		// Imaginary part always has a sign.
 		p.fmt.plus = true
-		p.fmtFloat(imag(v), size/2, verb)
+		p.fmtFloat(arg, value, imag(v), size/2, verb)
 		p.buf.writeString("i)")
 		p.fmt.plus = oldPlus
 	default:
-		p.badVerb(verb)
+		p.badVerb(arg, value, verb)
 	}
 }
 
-func (p *pp) fmtString(v string, verb rune) {
+func (p *pp) fmtString(arg any, value reflect.Value, v string, verb rune) {
 	switch verb {
 	case 'v':
 		if p.fmt.sharpV {
@@ -503,7 +495,7 @@ func (p *pp) fmtString(v string, verb rune) {
 	case 'q':
 		p.fmt.fmtQ(v)
 	default:
-		p.badVerb(verb)
+		p.badVerb(arg, value, verb)
 	}
 }
 
@@ -547,13 +539,13 @@ func (p *pp) fmtBytes(v []byte, verb rune, typeString string) {
 	}
 }
 
-func (p *pp) fmtPointer(value reflect.Value, verb rune) {
+func (p *pp) fmtPointer(arg any, value reflect.Value, verb rune) {
 	var u uintptr
 	switch value.Kind() {
 	case reflect.Chan, reflect.Func, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer:
 		u = uintptr(value.UnsafePointer())
 	default:
-		p.badVerb(verb)
+		p.badVerb(arg, value, verb)
 		return
 	}
 
@@ -579,9 +571,9 @@ func (p *pp) fmtPointer(value reflect.Value, verb rune) {
 	case 'p':
 		p.fmt0x64(uint64(u), !p.fmt.sharp)
 	case 'b', 'o', 'd', 'x', 'X':
-		p.fmtInteger(uint64(u), unsigned, verb)
+		p.fmtInteger(arg, value, uint64(u), unsigned, verb)
 	default:
-		p.badVerb(verb)
+		p.badVerb(arg, value, verb)
 	}
 }
 
@@ -619,15 +611,15 @@ func (p *pp) catchPanic(arg any, verb rune, method string) {
 	}
 }
 
-func (p *pp) handleMethods(verb rune) (handled bool) {
+func (p *pp) handleMethods(arg any, value reflect.Value, verb rune) (handled bool) {
 	if p.erroring {
 		return
 	}
 	if verb == 'w' {
 		// It is invalid to use %w other than with Errorf or with a non-error arg.
-		_, ok := p.arg.(error)
+		_, ok := arg.(error)
 		if !ok || !p.wrapErrs {
-			p.badVerb(verb)
+			p.badVerb(arg, value, verb)
 			return true
 		}
 		// If the arg is a Formatter, pass 'v' as the verb to it.
@@ -635,18 +627,18 @@ func (p *pp) handleMethods(verb rune) (handled bool) {
 	}
 
 	// Is it a Formatter?
-	if formatter, ok := p.arg.(Formatter); ok {
+	if formatter, ok := arg.(Formatter); ok {
 		handled = true
-		defer p.catchPanic(p.arg, verb, "Format")
+		defer p.catchPanic(arg, verb, "Format")
 		formatter.Format(p, verb)
 		return
 	}
 
 	// If we're doing Go syntax and the argument knows how to supply it, take care of it now.
 	if p.fmt.sharpV {
-		if stringer, ok := p.arg.(GoStringer); ok {
+		if stringer, ok := arg.(GoStringer); ok {
 			handled = true
-			defer p.catchPanic(p.arg, verb, "GoString")
+			defer p.catchPanic(arg, verb, "GoString")
 			// Print the result of GoString unadorned.
 			p.fmt.fmtS(stringer.GoString())
 			return
@@ -661,17 +653,17 @@ func (p *pp) handleMethods(verb rune) (handled bool) {
 			// The duplication in the bodies is necessary:
 			// setting handled and deferring catchPanic
 			// must happen before calling the method.
-			switch v := p.arg.(type) {
+			switch v := arg.(type) {
 			case error:
 				handled = true
-				defer p.catchPanic(p.arg, verb, "Error")
-				p.fmtString(v.Error(), verb)
+				defer p.catchPanic(arg, verb, "Error")
+				p.fmtString(arg, value, v.Error(), verb)
 				return
 
 			case Stringer:
 				handled = true
-				defer p.catchPanic(p.arg, verb, "String")
-				p.fmtString(v.String(), verb)
+				defer p.catchPanic(arg, verb, "String")
+				p.fmtString(arg, value, v.String(), verb)
 				return
 			}
 		}
@@ -680,15 +672,12 @@ func (p *pp) handleMethods(verb rune) (handled bool) {
 }
 
 func (p *pp) printArg(arg any, verb rune) {
-	p.arg = arg
-	p.value = reflect.Value{}
-
 	if arg == nil {
 		switch verb {
 		case 'T', 'v':
 			p.fmt.padString(nilAngleString)
 		default:
-			p.badVerb(verb)
+			p.badVerb(arg, reflect.Value{}, verb)
 		}
 		return
 	}
@@ -700,61 +689,61 @@ func (p *pp) printArg(arg any, verb rune) {
 		p.fmt.fmtS(reflect.TypeOf(arg).String())
 		return
 	case 'p':
-		p.fmtPointer(reflect.ValueOf(arg), 'p')
+		p.fmtPointer(arg, reflect.ValueOf(arg), 'p')
 		return
 	}
 
 	// Some types can be done without reflection.
 	switch f := arg.(type) {
 	case bool:
-		p.fmtBool(f, verb)
+		p.fmtBool(arg, reflect.Value{}, f, verb)
 	case float32:
-		p.fmtFloat(float64(f), 32, verb)
+		p.fmtFloat(arg, reflect.Value{}, float64(f), 32, verb)
 	case float64:
-		p.fmtFloat(f, 64, verb)
+		p.fmtFloat(arg, reflect.Value{}, f, 64, verb)
 	case complex64:
-		p.fmtComplex(complex128(f), 64, verb)
+		p.fmtComplex(arg, reflect.Value{}, complex128(f), 64, verb)
 	case complex128:
-		p.fmtComplex(f, 128, verb)
+		p.fmtComplex(arg, reflect.Value{}, f, 128, verb)
 	case int:
-		p.fmtInteger(uint64(f), signed, verb)
+		p.fmtInteger(arg, reflect.Value{}, uint64(f), signed, verb)
 	case int8:
-		p.fmtInteger(uint64(f), signed, verb)
+		p.fmtInteger(arg, reflect.Value{}, uint64(f), signed, verb)
 	case int16:
-		p.fmtInteger(uint64(f), signed, verb)
+		p.fmtInteger(arg, reflect.Value{}, uint64(f), signed, verb)
 	case int32:
-		p.fmtInteger(uint64(f), signed, verb)
+		p.fmtInteger(arg, reflect.Value{}, uint64(f), signed, verb)
 	case int64:
-		p.fmtInteger(uint64(f), signed, verb)
+		p.fmtInteger(arg, reflect.Value{}, uint64(f), signed, verb)
 	case uint:
-		p.fmtInteger(uint64(f), unsigned, verb)
+		p.fmtInteger(arg, reflect.Value{}, uint64(f), unsigned, verb)
 	case uint8:
-		p.fmtInteger(uint64(f), unsigned, verb)
+		p.fmtInteger(arg, reflect.Value{}, uint64(f), unsigned, verb)
 	case uint16:
-		p.fmtInteger(uint64(f), unsigned, verb)
+		p.fmtInteger(arg, reflect.Value{}, uint64(f), unsigned, verb)
 	case uint32:
-		p.fmtInteger(uint64(f), unsigned, verb)
+		p.fmtInteger(arg, reflect.Value{}, uint64(f), unsigned, verb)
 	case uint64:
-		p.fmtInteger(f, unsigned, verb)
+		p.fmtInteger(arg, reflect.Value{}, f, unsigned, verb)
 	case uintptr:
-		p.fmtInteger(uint64(f), unsigned, verb)
+		p.fmtInteger(arg, reflect.Value{}, uint64(f), unsigned, verb)
 	case string:
-		p.fmtString(f, verb)
+		p.fmtString(arg, reflect.Value{}, f, verb)
 	case []byte:
 		p.fmtBytes(f, verb, "[]byte")
 	case reflect.Value:
 		// Handle extractable values with special methods
 		// since printValue does not handle them at depth 0.
 		if f.IsValid() && f.CanInterface() {
-			p.arg = f.Interface()
-			if p.handleMethods(verb) {
+			arg = f.Interface() // TODO(thepudds): Currently causes f to escape.
+			if p.handleMethods(arg, reflect.Value{}, verb) {
 				return
 			}
 		}
 		p.printValue(f, verb, 0)
 	default:
 		// If the type is not simple, it might have methods.
-		if !p.handleMethods(verb) {
+		if !p.handleMethods(arg, reflect.Value{}, verb) {
 			// Need to use reflection, since the type had no
 			// interface methods that could be used for formatting.
 			p.printValue(reflect.ValueOf(f), verb, 0)
@@ -767,13 +756,11 @@ func (p *pp) printArg(arg any, verb rune) {
 func (p *pp) printValue(value reflect.Value, verb rune, depth int) {
 	// Handle values with special methods if not already handled by printArg (depth == 0).
 	if depth > 0 && value.IsValid() && value.CanInterface() {
-		p.arg = value.Interface()
-		if p.handleMethods(verb) {
+		arg := value.Interface() // TODO(thepudds): Currently causes value to escape.
+		if p.handleMethods(arg, value, verb) {
 			return
 		}
 	}
-	p.arg = nil
-	p.value = value
 
 	switch f := value; value.Kind() {
 	case reflect.Invalid:
@@ -784,25 +771,25 @@ func (p *pp) printValue(value reflect.Value, verb rune, depth int) {
 			case 'v':
 				p.buf.writeString(nilAngleString)
 			default:
-				p.badVerb(verb)
+				p.badVerb(nil, value, verb)
 			}
 		}
 	case reflect.Bool:
-		p.fmtBool(f.Bool(), verb)
+		p.fmtBool(nil, value, f.Bool(), verb)
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		p.fmtInteger(uint64(f.Int()), signed, verb)
+		p.fmtInteger(nil, value, uint64(f.Int()), signed, verb)
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		p.fmtInteger(f.Uint(), unsigned, verb)
+		p.fmtInteger(nil, value, f.Uint(), unsigned, verb)
 	case reflect.Float32:
-		p.fmtFloat(f.Float(), 32, verb)
+		p.fmtFloat(nil, value, f.Float(), 32, verb)
 	case reflect.Float64:
-		p.fmtFloat(f.Float(), 64, verb)
+		p.fmtFloat(nil, value, f.Float(), 64, verb)
 	case reflect.Complex64:
-		p.fmtComplex(f.Complex(), 64, verb)
+		p.fmtComplex(nil, value, f.Complex(), 64, verb)
 	case reflect.Complex128:
-		p.fmtComplex(f.Complex(), 128, verb)
+		p.fmtComplex(nil, value, f.Complex(), 128, verb)
 	case reflect.String:
-		p.fmtString(f.String(), verb)
+		p.fmtString(nil, value, f.String(), verb)
 	case reflect.Map:
 		if p.fmt.sharpV {
 			p.buf.writeString(f.Type().String())
@@ -925,7 +912,7 @@ func (p *pp) printValue(value reflect.Value, verb rune, depth int) {
 		}
 		fallthrough
 	case reflect.Chan, reflect.Func, reflect.UnsafePointer:
-		p.fmtPointer(f, verb)
+		p.fmtPointer(nil, f, verb)
 	default:
 		p.unknownType(f)
 	}

package/bin/go/src/go/ast/ast.go

@@ -6,8 +6,8 @@
 // packages.
 //
 // Syntax trees may be constructed directly, but they are typically
-// produced from Go source code by the parser; see the ParseFile
-// function in package [go/parser].
+// produced from Go source code by the parser; see the
+// [go/parser.ParseFile] function.
 package ast
 
 import (
@@ -1110,10 +1110,10 @@ func (p *Package) End() token.Pos { return token.NoPos }
 // not handwritten, by detecting the special comment described
 // at https://go.dev/s/generatedcode.
 //
-// The syntax tree must have been parsed with the [parser.ParseComments] flag.
+// The syntax tree must have been parsed with the [go/parser.ParseComments] flag.
 // Example:
 //
-//	f, err := parser.ParseFile(fset, filename, src, parser.ParseComments|parser.PackageClauseOnly)
+//	f, err := parser.ParseFile(fset, filename, src, parser.ParseComments|parser.PackageClauseOnly|parser.SkipObjectResolution)
 //	if err != nil { ... }
 //	gen := ast.IsGenerated(f)
 func IsGenerated(file *File) bool {

package/bin/go/src/go/ast/filter.go

@@ -358,7 +358,6 @@ func MergePackageFiles(pkg *Package, mode MergeMode) *File {
 	i := 0
 	for filename, f := range pkg.Files {
 		filenames[i] = filename
-		i++
 		if f.Doc != nil {
 			ndocs += len(f.Doc.List) + 1 // +1 for separator
 		}
@@ -370,6 +369,7 @@ func MergePackageFiles(pkg *Package, mode MergeMode) *File {
 		if i == 0 || f.FileEnd > maxPos {
 			maxPos = f.FileEnd
 		}
+		i++
 	}
 	slices.Sort(filenames)
 

package/bin/go/src/go/ast/scope.go

@@ -79,11 +79,11 @@ func (s *Scope) String() string {
 // refers to a field of T, whereas for the other types it refers to a
 // value in the environment.
 //
-// New programs should set the [parser.SkipObjectResolution] parser
+// New programs should set the [go/parser.SkipObjectResolution] parser
 // flag to disable syntactic object resolution (which also saves CPU
 // and memory), and instead use the type checker [go/types] if object
 // resolution is desired. See the Defs, Uses, and Implicits fields of
-// the [types.Info] struct for details.
+// the [go/types.Info] struct for details.
 type Object struct {
 	Kind ObjKind
 	Name string // declared name

package/bin/go/src/go/build/build.go

@@ -1139,7 +1139,7 @@ func (ctxt *Context) importGo(p *Package, path, srcDir string, mode ImportMode)
 	// we must not being doing special things like AllowBinary or IgnoreVendor,
 	// and all the file system callbacks must be nil (we're meant to use the local file system).
 	if mode&AllowBinary != 0 || mode&IgnoreVendor != 0 ||
-		ctxt.JoinPath != nil || ctxt.SplitPathList != nil || ctxt.IsAbsPath != nil || ctxt.IsDir != nil || ctxt.HasSubdir != nil || ctxt.ReadDir != nil || ctxt.OpenFile != nil || !slices.Equal(ctxt.ToolTags, defaultToolTags) || !slices.Equal(ctxt.ReleaseTags, defaultReleaseTags) {
+		ctxt.JoinPath != nil || ctxt.SplitPathList != nil || ctxt.IsAbsPath != nil || ctxt.IsDir != nil || ctxt.HasSubdir != nil || ctxt.ReadDir != nil || ctxt.OpenFile != nil || !slices.Equal(ctxt.ToolTags, defaultToolTags) || !slices.Equal(ctxt.ReleaseTags, defaultReleaseTags) || ctxt.UseAllFiles {
 		return errNoModules
 	}
 

package/bin/go/src/go/build/constraint/vers.go

@@ -66,7 +66,10 @@ func minVersion(z Expr, sign int) int {
 		if z.Tag == "go1" {
 			return 0
 		}
-		_, v, _ := strings.Cut(z.Tag, "go1.")
+		_, v, ok := strings.Cut(z.Tag, "go1.")
+		if !ok {
+			return -1
+		}
 		n, err := strconv.Atoi(v)
 		if err != nil {
 			// not a go1.N tag

package/bin/go/src/go/build/read.go

@@ -311,7 +311,7 @@ func readGoInfo(f io.Reader, info *fileInfo) error {
 	}
 
 	// Parse file header & record imports.
-	info.parsed, info.parseErr = parser.ParseFile(info.fset, info.name, info.header, parser.ImportsOnly|parser.ParseComments)
+	info.parsed, info.parseErr = parser.ParseFile(info.fset, info.name, info.header, parser.ImportsOnly|parser.ParseComments|parser.SkipObjectResolution)
 	if info.parseErr != nil {
 		return nil
 	}
@@ -335,7 +335,7 @@ func readGoInfo(f io.Reader, info *fileInfo) error {
 			if !isValidImport(path) {
 				// The parser used to return a parse error for invalid import paths, but
 				// no longer does, so check for and create the error here instead.
-				info.parseErr = scanner.Error{Pos: info.fset.Position(spec.Pos()), Msg: "invalid import path: " + path}
+				info.parseErr = &scanner.Error{Pos: info.fset.Position(spec.Pos()), Msg: "invalid import path: " + path}
 				info.imports = nil
 				return nil
 			}