Merge branch 'master' into 12ya-patch

Author: 12ya

go/analysis/passes/printf/printf.go

@@ -758,7 +758,9 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firs
 		pass.ReportRangef(call, "%s format %s has arg %s of wrong type %s%s", name, operation.Text, analysisinternal.Format(pass.Fset, arg), typeString, details)
 		return false
 	}
-	if v.typ&argString != 0 && v.verb != 'T' && !strings.Contains(operation.Flags, "#") {
+	// Detect recursive formatting via value's String/Error methods.
+	// The '#' flag suppresses the methods, except with %x, %X, and %q.
+	if v.typ&argString != 0 && v.verb != 'T' && (!strings.Contains(operation.Flags, "#") || strings.ContainsRune("qxX", v.verb)) {
 		if methodName, ok := recursiveStringer(pass, arg); ok {
 			pass.ReportRangef(call, "%s format %s with arg %s causes recursive %s method call", name, operation.Text, analysisinternal.Format(pass.Fset, arg), methodName)
 			return false

go/analysis/passes/printf/testdata/src/a/a.go

@@ -567,10 +567,16 @@ type recursiveStringer int
 func (s recursiveStringer) String() string {
 	_ = fmt.Sprintf("%d", s)
 	_ = fmt.Sprintf("%#v", s)
-	_ = fmt.Sprintf("%v", s)  // want `fmt.Sprintf format %v with arg s causes recursive \(a.recursiveStringer\).String method call`
-	_ = fmt.Sprintf("%v", &s) // want `fmt.Sprintf format %v with arg &s causes recursive \(a.recursiveStringer\).String method call`
-	_ = fmt.Sprintf("%T", s)  // ok; does not recursively call String
-	return fmt.Sprintln(s)    // want `fmt.Sprintln arg s causes recursive call to \(a.recursiveStringer\).String method`
+	_ = fmt.Sprintf("%v", s)   // want `fmt.Sprintf format %v with arg s causes recursive \(a.recursiveStringer\).String method call`
+	_ = fmt.Sprintf("%v", &s)  // want `fmt.Sprintf format %v with arg &s causes recursive \(a.recursiveStringer\).String method call`
+	_ = fmt.Sprintf("%#x", s)  // want `fmt.Sprintf format %#x with arg s causes recursive \(a.recursiveStringer\).String method call`
+	_ = fmt.Sprintf("%#x", &s) // want `fmt.Sprintf format %#x with arg &s causes recursive \(a.recursiveStringer\).String method call`
+	_ = fmt.Sprintf("%#X", s)  // want `fmt.Sprintf format %#X with arg s causes recursive \(a.recursiveStringer\).String method call`
+	_ = fmt.Sprintf("%#X", &s) // want `fmt.Sprintf format %#X with arg &s causes recursive \(a.recursiveStringer\).String method call`
+	_ = fmt.Sprintf("%#q", s)  // want `fmt.Sprintf format %#q with arg s causes recursive \(a.recursiveStringer\).String method call`
+	_ = fmt.Sprintf("%#q", &s) // want `fmt.Sprintf format %#q with arg &s causes recursive \(a.recursiveStringer\).String method call`
+	_ = fmt.Sprintf("%T", s)   // ok; does not recursively call String
+	return fmt.Sprintln(s)     // want `fmt.Sprintln arg s causes recursive call to \(a.recursiveStringer\).String method`
 }
 
 type recursivePtrStringer int
@@ -586,10 +592,16 @@ type recursiveError int
 func (s recursiveError) Error() string {
 	_ = fmt.Sprintf("%d", s)
 	_ = fmt.Sprintf("%#v", s)
-	_ = fmt.Sprintf("%v", s)  // want `fmt.Sprintf format %v with arg s causes recursive \(a.recursiveError\).Error method call`
-	_ = fmt.Sprintf("%v", &s) // want `fmt.Sprintf format %v with arg &s causes recursive \(a.recursiveError\).Error method call`
-	_ = fmt.Sprintf("%T", s)  // ok; does not recursively call Error
-	return fmt.Sprintln(s)    // want `fmt.Sprintln arg s causes recursive call to \(a.recursiveError\).Error method`
+	_ = fmt.Sprintf("%v", s)   // want `fmt.Sprintf format %v with arg s causes recursive \(a.recursiveError\).Error method call`
+	_ = fmt.Sprintf("%v", &s)  // want `fmt.Sprintf format %v with arg &s causes recursive \(a.recursiveError\).Error method call`
+	_ = fmt.Sprintf("%#x", s)  // want `fmt.Sprintf format %#x with arg s causes recursive \(a.recursiveError\).Error method call`
+	_ = fmt.Sprintf("%#x", &s) // want `fmt.Sprintf format %#x with arg &s causes recursive \(a.recursiveError\).Error method call`
+	_ = fmt.Sprintf("%#X", s)  // want `fmt.Sprintf format %#X with arg s causes recursive \(a.recursiveError\).Error method call`
+	_ = fmt.Sprintf("%#X", &s) // want `fmt.Sprintf format %#X with arg &s causes recursive \(a.recursiveError\).Error method call`
+	_ = fmt.Sprintf("%#q", s)  // want `fmt.Sprintf format %#q with arg s causes recursive \(a.recursiveError\).Error method call`
+	_ = fmt.Sprintf("%#q", &s) // want `fmt.Sprintf format %#q with arg &s causes recursive \(a.recursiveError\).Error method call`
+	_ = fmt.Sprintf("%T", s)   // ok; does not recursively call Error
+	return fmt.Sprintln(s)     // want `fmt.Sprintln arg s causes recursive call to \(a.recursiveError\).Error method`
 }
 
 type recursivePtrError int
@@ -605,19 +617,31 @@ type recursiveStringerAndError int
 func (s recursiveStringerAndError) String() string {
 	_ = fmt.Sprintf("%d", s)
 	_ = fmt.Sprintf("%#v", s)
-	_ = fmt.Sprintf("%v", s)  // want `fmt.Sprintf format %v with arg s causes recursive \(a.recursiveStringerAndError\).String method call`
-	_ = fmt.Sprintf("%v", &s) // want `fmt.Sprintf format %v with arg &s causes recursive \(a.recursiveStringerAndError\).String method call`
-	_ = fmt.Sprintf("%T", s)  // ok; does not recursively call String
-	return fmt.Sprintln(s)    // want `fmt.Sprintln arg s causes recursive call to \(a.recursiveStringerAndError\).String method`
+	_ = fmt.Sprintf("%v", s)   // want `fmt.Sprintf format %v with arg s causes recursive \(a.recursiveStringerAndError\).String method call`
+	_ = fmt.Sprintf("%v", &s)  // want `fmt.Sprintf format %v with arg &s causes recursive \(a.recursiveStringerAndError\).String method call`
+	_ = fmt.Sprintf("%#x", s)  // want `fmt.Sprintf format %#x with arg s causes recursive \(a.recursiveStringerAndError\).String method call`
+	_ = fmt.Sprintf("%#x", &s) // want `fmt.Sprintf format %#x with arg &s causes recursive \(a.recursiveStringerAndError\).String method call`
+	_ = fmt.Sprintf("%#X", s)  // want `fmt.Sprintf format %#X with arg s causes recursive \(a.recursiveStringerAndError\).String method call`
+	_ = fmt.Sprintf("%#X", &s) // want `fmt.Sprintf format %#X with arg &s causes recursive \(a.recursiveStringerAndError\).String method call`
+	_ = fmt.Sprintf("%#q", s)  // want `fmt.Sprintf format %#q with arg s causes recursive \(a.recursiveStringerAndError\).String method call`
+	_ = fmt.Sprintf("%#q", &s) // want `fmt.Sprintf format %#q with arg &s causes recursive \(a.recursiveStringerAndError\).String method call`
+	_ = fmt.Sprintf("%T", s)   // ok; does not recursively call String
+	return fmt.Sprintln(s)     // want `fmt.Sprintln arg s causes recursive call to \(a.recursiveStringerAndError\).String method`
 }
 
 func (s recursiveStringerAndError) Error() string {
 	_ = fmt.Sprintf("%d", s)
 	_ = fmt.Sprintf("%#v", s)
-	_ = fmt.Sprintf("%v", s)  // want `fmt.Sprintf format %v with arg s causes recursive \(a.recursiveStringerAndError\).Error method call`
-	_ = fmt.Sprintf("%v", &s) // want `fmt.Sprintf format %v with arg &s causes recursive \(a.recursiveStringerAndError\).Error method call`
-	_ = fmt.Sprintf("%T", s)  // ok; does not recursively call Error
-	return fmt.Sprintln(s)    // want `fmt.Sprintln arg s causes recursive call to \(a.recursiveStringerAndError\).Error method`
+	_ = fmt.Sprintf("%v", s)   // want `fmt.Sprintf format %v with arg s causes recursive \(a.recursiveStringerAndError\).Error method call`
+	_ = fmt.Sprintf("%v", &s)  // want `fmt.Sprintf format %v with arg &s causes recursive \(a.recursiveStringerAndError\).Error method call`
+	_ = fmt.Sprintf("%#x", s)  // want `fmt.Sprintf format %#x with arg s causes recursive \(a.recursiveStringerAndError\).Error method call`
+	_ = fmt.Sprintf("%#x", &s) // want `fmt.Sprintf format %#x with arg &s causes recursive \(a.recursiveStringerAndError\).Error method call`
+	_ = fmt.Sprintf("%#X", s)  // want `fmt.Sprintf format %#X with arg s causes recursive \(a.recursiveStringerAndError\).Error method call`
+	_ = fmt.Sprintf("%#X", &s) // want `fmt.Sprintf format %#X with arg &s causes recursive \(a.recursiveStringerAndError\).Error method call`
+	_ = fmt.Sprintf("%#q", s)  // want `fmt.Sprintf format %#q with arg s causes recursive \(a.recursiveStringerAndError\).Error method call`
+	_ = fmt.Sprintf("%#q", &s) // want `fmt.Sprintf format %#q with arg &s causes recursive \(a.recursiveStringerAndError\).Error method call`
+	_ = fmt.Sprintf("%T", s)   // ok; does not recursively call Error
+	return fmt.Sprintln(s)     // want `fmt.Sprintln arg s causes recursive call to \(a.recursiveStringerAndError\).Error method`
 }
 
 type recursivePtrStringerAndError int

gopls/internal/test/integration/bench/didchange_test.go

@@ -21,7 +21,7 @@ import (
 var editID int64 = time.Now().UnixNano()
 
 type changeTest struct {
-	repo    string
+	repo    string // repo identifier + optional disambiguating ".foo" suffix
 	file    string
 	canSave bool
 }
@@ -30,6 +30,7 @@ var didChangeTests = []changeTest{
 	{"google-cloud-go", "internal/annotate.go", true},
 	{"istio", "pkg/fuzz/util.go", true},
 	{"kubernetes", "pkg/controller/lookup_cache.go", true},
+	{"kubernetes.types", "staging/src/k8s.io/api/core/v1/types.go", true}, // results in 25K file batch!
 	{"kuma", "api/generic/insights.go", true},
 	{"oracle", "dataintegration/data_type.go", false}, // diagnoseSave fails because this package is generated
 	{"pkgsite", "internal/frontend/server.go", true},

gopls/internal/test/integration/bench/repo_test.go

@@ -13,6 +13,7 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -109,8 +110,13 @@ var repos = map[string]*repo{
 
 // getRepo gets the requested repo, and skips the test if -short is set and
 // repo is not configured as a short repo.
+//
+// The name may include an optional ".foo" suffix after the repo
+// identifier. This allows several tests to use the same repo but have
+// distinct test names and associated file names.
 func getRepo(tb testing.TB, name string) *repo {
 	tb.Helper()
+	name, _, _ = strings.Cut(name, ".") // remove ".foo" suffix
 	repo := repos[name]
 	if repo == nil {
 		tb.Fatalf("repo %s does not exist", name)

internal/jsonrpc2_v2/net.go

@@ -100,14 +100,14 @@ func (l *netPiper) Accept(context.Context) (io.ReadWriteCloser, error) {
 	// preferring the latter if already closed at the start of Accept.
 	select {
 	case <-l.done:
-		return nil, errClosed
+		return nil, net.ErrClosed
 	default:
 	}
 	select {
 	case rwc := <-l.dialed:
 		return rwc, nil
 	case <-l.done:
-		return nil, errClosed
+		return nil, net.ErrClosed
 	}
 }
 
@@ -133,6 +133,6 @@ func (l *netPiper) Dial(ctx context.Context) (io.ReadWriteCloser, error) {
 	case <-l.done:
 		client.Close()
 		server.Close()
-		return nil, errClosed
+		return nil, net.ErrClosed
 	}
 }

internal/jsonrpc2_v2/serve_go116.go

@@ -162,7 +162,7 @@ func (c *Client) RemoveRoots(uris ...string) {
 // changeAndNotify is called when a feature is added or removed.
 // It calls change, which should do the work and report whether a change actually occurred.
 // If there was a change, it notifies a snapshot of the sessions.
-func (c *Client) changeAndNotify(notification string, params any, change func() bool) {
+func (c *Client) changeAndNotify(notification string, params Params, change func() bool) {
 	var sessions []*ClientSession
 	// Lock for the change, but not for the notification.
 	c.mu.Lock()
@@ -231,8 +231,8 @@ func (cs *ClientSession) methodHandler() MethodHandler[ClientSession] {
 // getConn implements [session.getConn].
 func (cs *ClientSession) getConn() *jsonrpc2.Connection { return cs.conn }
 
-func (c *ClientSession) ping(ct context.Context, params *PingParams) (struct{}, error) {
-	return struct{}{}, nil
+func (c *ClientSession) ping(ct context.Context, params *PingParams) (Result, error) {
+	return emptyResult{}, nil
 }
 
 // Ping makes an MCP "ping" request to the server.
@@ -296,29 +296,21 @@ func (c *ClientSession) ReadResource(ctx context.Context, params *ReadResourcePa
 	return standardCall[ReadResourceResult](ctx, c.conn, methodReadResource, params)
 }
 
-func (c *Client) callToolChangedHandler(ctx context.Context, s *ClientSession, params *ToolListChangedParams) (any, error) {
+func (c *Client) callToolChangedHandler(ctx context.Context, s *ClientSession, params *ToolListChangedParams) (Result, error) {
 	return callNotificationHandler(ctx, c.opts.ToolListChangedHandler, s, params)
 }
 
-func (c *Client) callPromptChangedHandler(ctx context.Context, s *ClientSession, params *PromptListChangedParams) (any, error) {
+func (c *Client) callPromptChangedHandler(ctx context.Context, s *ClientSession, params *PromptListChangedParams) (Result, error) {
 	return callNotificationHandler(ctx, c.opts.PromptListChangedHandler, s, params)
 }
 
-func (c *Client) callResourceChangedHandler(ctx context.Context, s *ClientSession, params *ResourceListChangedParams) (any, error) {
+func (c *Client) callResourceChangedHandler(ctx context.Context, s *ClientSession, params *ResourceListChangedParams) (Result, error) {
 	return callNotificationHandler(ctx, c.opts.ResourceListChangedHandler, s, params)
 }
 
-func (c *Client) callLoggingHandler(ctx context.Context, cs *ClientSession, params *LoggingMessageParams) (any, error) {
+func (c *Client) callLoggingHandler(ctx context.Context, cs *ClientSession, params *LoggingMessageParams) (Result, error) {
 	if h := c.opts.LoggingMessageHandler; h != nil {
 		h(ctx, cs, params)
 	}
 	return nil, nil
 }
-
-func standardCall[TRes, TParams any](ctx context.Context, conn *jsonrpc2.Connection, method string, params TParams) (*TRes, error) {
-	var result TRes
-	if err := call(ctx, conn, method, params, &result); err != nil {
-		return nil, err
-	}
-	return &result, nil
-}

internal/jsonrpc2_v2/serve_pre116.go

@@ -243,7 +243,7 @@ Types needed for the protocol are generated from the [JSON schema of the MCP spe
 
 These types will be included in the `mcp` package, but will be unexported unless they are needed for the user-facing API. Notably, JSON-RPC request types are elided, since they are handled by the `jsonrpc2` package and should not be observed by the user.
 
-For user-provided data, we use `json.RawMessage`, so that marshalling/unmarshalling can be delegated to the business logic of the client or server.
+For user-provided data, we use `json.RawMessage` or `map[string]any`, depending on the use case.
 
 For union types, which can't be represented in Go (specifically `Content` and `ResourceContents`), we prefer distinguished unions: struct types with fields corresponding to the union of all properties for union elements.
 
@@ -255,9 +255,9 @@ type ReadResourceParams struct {
 }
 
 type CallToolResult struct {
-	Meta    map[string]json.RawMessage `json:"_meta,omitempty"`
-	Content []Content                  `json:"content"`
-	IsError bool                       `json:"isError,omitempty"`
+	Meta    Meta      `json:"_meta,omitempty"`
+	Content []Content `json:"content"`
+	IsError bool      `json:"isError,omitempty"`
 }
 
 // Content is the wire format for content.
@@ -276,6 +276,7 @@ type Content struct {
 func NewTextContent(text string) *Content
 // etc.
 ```
+The `Meta` type includes a `map[string]any` for arbitrary data, and a `ProgressToken` field.
 
 **Differences from mcp-go**: these types are largely similar, but our type generator flattens types rather than using struct embedding.
 
@@ -480,15 +481,21 @@ The server observes a client cancellation as a cancelled context.
 
 ### Progress handling
 
-A caller can request progress notifications by setting the `ProgressToken` field on any request.
+A caller can request progress notifications by setting the `Meta.ProgressToken` field on any request.
 
 ```go
 type XXXParams struct { // where XXX is each type of call
+  Meta Meta
   ...
+}
+
+type Meta struct {
+  Data          map[string]any
   ProgressToken any // string or int
 }
 ```
 
+
 Handlers can notify their peer about progress by calling the `NotifyProgress` method. The notification is only sent if the peer requested it by providing a progress token.
 
 ```go

internal/mcp/client.go

@@ -299,13 +299,21 @@ func loadSchema(schemaFile string) (data []byte, err error) {
 
 func writeDecl(configName string, config typeConfig, def *jsonschema.Schema, named map[string]*bytes.Buffer) error {
 	var w io.Writer = io.Discard
-	if typeName := config.Name; typeName != "-" {
+	var typeName string
+	if typeName = config.Name; typeName != "-" {
 		if typeName == "" {
 			typeName = configName
 		}
 		if _, ok := named[typeName]; ok {
 			return nil
 		}
+		// The JSON schema does not accurately represent the source of truth, which is typescript.
+		// Every Params and Result type should have a _meta property.
+		// Also, those with a progress token will turn into a struct; we want the progress token to
+		// be a map item. So replace all metas.
+		if strings.HasSuffix(typeName, "Params") || strings.HasSuffix(typeName, "Result") {
+			def.Properties["_meta"] = metaSchema
+		}
 		buf := new(bytes.Buffer)
 		w = buf
 		named[typeName] = buf
@@ -318,6 +326,12 @@ func writeDecl(configName string, config typeConfig, def *jsonschema.Schema, nam
 		return err // Better error here?
 	}
 	fmt.Fprintf(w, "\n")
+
+	// Any decl with a _meta field gets a GetMeta method.
+	if _, ok := def.Properties["_meta"]; ok {
+		fmt.Fprintf(w, "\nfunc (x *%s) GetMeta() *Meta { return &x.Meta }", typeName)
+	}
+
 	return nil
 }
 
@@ -354,11 +368,7 @@ func writeType(w io.Writer, config *typeConfig, def *jsonschema.Schema, named ma
 
 	// For types that explicitly allow additional properties, we can either
 	// unmarshal them into a map[string]any, or delay unmarshalling with
-	// json.RawMessage. For now, use json.RawMessage as it defers the choice.
-	//
-	// TODO(jba): further refine this classification of object schemas.
-	// For example, the typescript "object" type, which should map to a Go "any",
-	// is represented in schema.json by `{type: object, properties: {}, additionalProperties: true}`.
+	// json.RawMessage. We use any.
 	if def.Type == "object" && canHaveAdditionalProperties(def) && def.Properties == nil {
 		w.Write([]byte("map[string]"))
 		return writeType(w, nil, def.AdditionalProperties, named)
@@ -372,7 +382,7 @@ func writeType(w io.Writer, config *typeConfig, def *jsonschema.Schema, named ma
 			fmt.Fprintf(w, "*Content")
 		} else {
 			// E.g. union types.
-			fmt.Fprintf(w, "json.RawMessage")
+			fmt.Fprintf(w, "any")
 		}
 	} else {
 		switch def.Type {
@@ -398,6 +408,11 @@ func writeType(w io.Writer, config *typeConfig, def *jsonschema.Schema, named ma
 				if fieldDef.Description != "" {
 					fmt.Fprintf(w, "%s\n", toComment(fieldDef.Description))
 				}
+				if name == "_meta" {
+					fmt.Fprintln(w, "\tMeta Meta `json:\"_meta,omitempty\"`")
+					continue
+				}
+
 				export := exportName(name)
 				fmt.Fprintf(w, "\t%s ", export)
 
@@ -551,6 +566,12 @@ func isStruct(s *jsonschema.Schema) bool {
 	return s.Type == "object" && s.Properties != nil && !canHaveAdditionalProperties(s)
 }
 
+// The schema for "_meta".
+// We only need the description: the rest is a special case.
+var metaSchema = &jsonschema.Schema{
+	Description: "This property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses.",
+}
+
 // schemaJSON returns the JSON for s.
 // For debugging.
 func schemaJSON(s *jsonschema.Schema) string {