xds/resolver: drop field references on Close to prevent retention across ClientConn recycle (#9301)

Retention is via multiple field references off `*xdsResolver` that
survive `Close`:

- `r.cc` → the `ClientConn`, whose `ServiceConfig` still transitively
references the resolver
- `r.curConfigSelector` → captured by the `ClientConn`'s `ServiceConfig`
via `UpdateState`
- `r.dm` / `r.xdsClient` → watcher metadata held by the shared
`xdsclient.DefaultPool` singleton, which survives every ClientConn
lifetime

Individually each field is a benign back-reference; together they form
multiple independent retention chains through externally-anchored state.
Go's tracing GC handles cycles fine, but these aren't cycles — they're
chains rooted at package-global state (the shared xdsClient pool) and
other ClientConns that stay alive.

Explicitly dropping the field references at the end of `Close` leaves
the resolver struct with no outbound edges. The entire per-channel
resolver + CDS balancer subtree (roughly 40 `CallbackSerializer`s,
JSON-parsed service configs, `attributes.Attributes` chains, cloned
`[]resolver.Address` slices per channel) becomes GC-collectible.



RELEASE NOTES: None

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: sushanb

clientconn.go

@@ -1212,6 +1212,12 @@ func (cc *ClientConn) Close() error {
 	cc.mu.Unlock()
 
 	cc.resolverWrapper.close()
+	// Swap in a default ConfigSelector so the resolver-provided one (which may
+	// transitively retain resolver-owned state such as parsed service configs
+	// and cluster maps) is released once in-flight RPCs finish selecting on
+	// it. Done after the resolver has closed so no further UpdateState calls
+	// race with this swap.
+	cc.safeConfigSelector.UpdateConfigSelector(&defaultConfigSelector{nil})
 	// The order of closing matters here since the balancer wrapper assumes the
 	// picker is closed before it is closed.
 	cc.pickerWrapper.close()

internal/xds/resolver/xds_resolver.go

@@ -302,6 +302,21 @@ func (r *xdsResolver) Close() {
 	if r.xdsClientClose != nil {
 		r.xdsClientClose()
 	}
+	// Drop field references so the resolver isn't retained across ClientConn
+	// close via any cross-object retention chain (e.g. ClientConn holding the
+	// ServiceConfig that captures the configSelector, shared xDS-client
+	// watcher metadata, channelz trace entries). Each nil individually looks
+	// harmless; the combination breaks the multi-path retention observed when
+	// callers repeatedly Close and redial DirectPath channels.
+	r.cc = nil
+	r.curConfigSelector = nil
+	r.dm = nil
+	r.xdsClient = nil
+	r.xdsClientClose = nil
+	r.httpFilters = nil
+	r.activeClusters = nil
+	r.activePlugins = nil
+	r.xdsConfig = nil
 	r.logger.Infof("Shutdown")
 }
 

internal/xds/xdsdepmgr/xds_dependency_manager.go

@@ -203,6 +203,12 @@ func (m *DependencyManager) Close() {
 		dnsResolver.stop()
 		delete(m.dnsResolvers, name)
 	}
+
+	// Drop references to externally-owned collaborators so the dependency
+	// manager itself doesn't retain them once Close returns. All in-flight
+	// callbacks re-check m.stopped under m.mu before touching these fields.
+	m.watcher = nil
+	m.xdsClient = nil
 }
 
 // annotateErrorWithNodeID annotates the given error with the provided xDS node
@@ -999,6 +1005,13 @@ func (m *DependencyManager) SubscribeToCluster(name string) func() {
 func (m *DependencyManager) unsubscribeFromCluster(name string) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
+	// Balancers can invoke the unsubscribe closure returned by
+	// SubscribeToCluster after Close has already torn down all watchers and
+	// dropped m.watcher / m.xdsClient. Match the m.stopped guard used by
+	// every other post-Close callback in this file.
+	if m.stopped {
+		return
+	}
 	c := m.clusterSubscriptions[name]
 	c.dynamicRefCount--
 	// This should not happen as unsubscribe returned from the