Benchmark run swe-smoke-luna6-medium-20261011T105900Z

{
  "auto_organize_imports": false,
  "edits": [
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "language": "go",
        "symbol": "factor",
        "to": "multiplier"
      },
      "tool": "semantic_rename"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "group": "append",
        "kind": "const",
        "source": "const maxDelay = 120 * time.Second"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "kind": "type",
        "source": "type Exponential struct {\n\t// baseDelay is the amount of time to backoff after the first connection\n\t// failure.\n\tbaseDelay time.Duration\n\t// multiplier is the factor with which to multiply backoffs after a failed\n\t// retry.\n\tmultiplier float64\n\t// jitter is the factor with which backoffs are randomized.\n\tjitter float64\n\t// maxDelay is the upper bound of backoff delay.\n\tmaxDelay time.Duration\n}",
        "symbol": "Exponential"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "access_modifier": "public",
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "kind": "type",
        "source": "// StrategyBuilder helps build an implementation of the Strategy interface,\n// with setters provided to set individual parameters of the backoff strategy.\ntype StrategyBuilder interface {\n\t// BaseDelay sets the amount of time to backoff after the first connection\n\t// failure.\n\tBaseDelay(time.Duration) StrategyBuilder\n\t// Multiplier sets the the factor with which to multiply backoffs after a\n\t// failed retry.\n\tMultiplier(float64) StrategyBuilder\n\t// Jitter sets the factor with which backoffs are randomized.\n\tJitter(float64) StrategyBuilder\n\t// MaxDelay sets the upper bound of backoff delay.\n\tMaxDelay(time.Duration) StrategyBuilder\n\t// Build builds an implementation of the Strategy interface configured using\n\t// the above setter methods.\n\tBuild() Strategy\n}"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "kind": "type",
        "source": "// exponentialBuilder implements the StrategyBuilder interface for an\n// exponential backoff strategy.\ntype exponentialBuilder struct {\n\tbd     time.Duration\n\tmltpr  float64\n\tjitter float64\n\tmd     time.Duration\n}"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "access_modifier": "public",
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "kind": "function",
        "source": "// NewExponentialBuilder returns an implementation of the StrategyBuilder\n// interface used to build an exponential backoff strategy implementation, as\n// defined in\n// https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md.\nfunc NewExponentialBuilder() StrategyBuilder {\n\treturn \u0026exponentialBuilder{\n\t\tbd:     baseDelay,\n\t\tmltpr:  multiplier,\n\t\tjitter: jitter,\n\t\tmd:     maxDelay,\n\t}\n}"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "kind": "method",
        "source": "// BaseDelay helps implement StrategyBuilder.\nfunc (eb *exponentialBuilder) BaseDelay(bd time.Duration) StrategyBuilder {\n\teb.bd = bd\n\treturn eb\n}"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "kind": "method",
        "source": "// BaseDelay helps implement StrategyBuilder.\nfunc (eb *exponentialBuilder) Multiplier(m float64) StrategyBuilder {\n\teb.mltpr = m\n\treturn eb\n}"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "kind": "method",
        "source": "// BaseDelay helps implement StrategyBuilder.\nfunc (eb *exponentialBuilder) Jitter(j float64) StrategyBuilder {\n\teb.jitter = j\n\treturn eb\n}"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "kind": "method",
        "source": "// BaseDelay helps implement StrategyBuilder.\nfunc (eb *exponentialBuilder) MaxDelay(md time.Duration) StrategyBuilder {\n\teb.md = md\n\treturn eb\n}"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "kind": "method",
        "source": "// BaseDelay helps implement StrategyBuilder.\nfunc (eb *exponentialBuilder) Build() Strategy {\n\treturn Exponential{\n\t\tbaseDelay:  eb.bd,\n\t\tmultiplier: eb.mltpr,\n\t\tjitter:     eb.jitter,\n\t\tmaxDelay:   eb.md,\n\t}\n}"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/backoff/backoff.go",
        "kind": "method",
        "source": "// Backoff returns the amount of time to wait before the next retry given the\n// number of retries.\n// Helps implement Strategy.\nfunc (bc Exponential) Backoff(retries int) time.Duration {\n\tif retries == 0 {\n\t\treturn bc.baseDelay\n\t}\n\tbackoff, max := float64(bc.baseDelay), float64(bc.maxDelay)\n\tfor backoff \u003c max \u0026\u0026 retries \u003e 0 {\n\t\tbackoff *= bc.multiplier\n\t\tretries--\n\t}\n\tif backoff \u003e max {\n\t\tbackoff = max\n\t}\n\t// Randomize backoff delays so that if a cluster of requests start at\n\t// the same time, they won't operate in lockstep.\n\tbackoff *= 1 + bc.jitter*(grpcrand.Float64()*2-1)\n\tif backoff \u003c 0 {\n\t\treturn 0\n\t}\n\treturn time.Duration(backoff)\n}",
        "symbol": "Exponential.Backoff"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "backoff.go",
        "kind": "type",
        "source": "// BackoffConfig defines the parameters for the default gRPC backoff strategy.\n// Deprecated: use ConnectParams instead.\ntype BackoffConfig struct {\n\t// MaxDelay is the upper bound of backoff delay.\n\tMaxDelay time.Duration\n}",
        "symbol": "BackoffConfig"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "access_modifier": "public",
        "auto_organize_imports": false,
        "file": "backoff.go",
        "kind": "type",
        "source": "// ConnectParams defines the parameters for connecting and retrying. Users\n// are encouraged to use this instead of BackoffConfig.\n// https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md.\n//\n// This API is EXPERIMENTAL.\ntype ConnectParams struct {\n\t// BackoffBaseDelay is the amount of time to backoff after the first\n\t// connection failure.\n\tBackoffBaseDelay time.Duration\n\t// BackoffMultiplier is the factor with which to multiply backoffs after a\n\t// failed retry. Should ideally be greater than 1.\n\tBackoffMultiplier float64\n\t// BackoffJitter is the factor with which backoffs are randomized.\n\tBackoffJitter float64\n\t// BackoffMaxDelay is the upper bound of backoff delay.\n\tBackoffMaxDelay time.Duration\n\t// MinConnectTimeout is the minimum amount of time we are willing to give a\n\t// connection to complete.\n\tMinConnectTimeout time.Duration\n}"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "backoff.go",
        "kind": "var",
        "source": "// DefaultBackoffConfig uses values specified for backoff in\n// https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md.\n// Deprecated: use ConnectParams instead.\nvar DefaultBackoffConfig = BackoffConfig{\n\tMaxDelay: 120 * time.Second,\n}",
        "symbol": "DefaultBackoffConfig"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "dialoptions.go",
        "in_type": "dialOptions",
        "kind": "field",
        "placement": "type_end",
        "source": "mct time.Duration"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "clientconn.go",
        "kind": "const",
        "symbol": "minConnectTimeout"
      },
      "tool": "semantic_remove_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "dialoptions.go",
        "group": "append",
        "kind": "const",
        "source": "const (\n\t// Minimum time to give a connection to complete.\n\tminConnectTimeout = 20 * time.Second\n)"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "dialoptions.go",
        "source": "// WithConnectParams configures the dialer to use the provided backoff\n// parameters for the algorithm defined in\n// https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md.\n// This will override all the default values with the ones provided here. So,\n// use with caution.\n//\n// This API is EXPERIMENTAL.\nfunc WithConnectParams(p ConnectParams) DialOption {\n\tb := backoff.NewExponentialBuilder()\n\tb.BaseDelay(p.BackoffBaseDelay).Multiplier(p.BackoffMultiplier).Jitter(p.BackoffJitter).MaxDelay(p.BackoffMaxDelay)\n\treturn newFuncDialOption(func(o *dialOptions) {\n\t\to.bs = b.Build()\n\t\to.mct = p.MinConnectTimeout\n\t})\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "dialoptions.go",
        "kind": "function",
        "source": "// WithBackoffMaxDelay configures the dialer to use the provided maximum delay\n// when backing off after failed connection attempts.\n//\n// Deprecated: use WithConnectParams instead.\nfunc WithBackoffMaxDelay(md time.Duration) DialOption {\n\treturn WithBackoffConfig(BackoffConfig{MaxDelay: md})\n}",
        "symbol": "WithBackoffMaxDelay"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "dialoptions.go",
        "kind": "function",
        "source": "// WithBackoffConfig configures the dialer to use the provided backoff\n// parameters after connection failures.\n//\n// Deprecated: use WithConnectParams instead.\nfunc WithBackoffConfig(b BackoffConfig) DialOption {\n\treturn withBackoff(backoff.NewExponentialBuilder().MaxDelay(b.MaxDelay).Build())\n}",
        "symbol": "WithBackoffConfig"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "return dialOptions{\n\tdisableRetry:    !envconfig.Retry,\n\treqHandshake:    envconfig.RequireHandshake,\n\thealthCheckFunc: internal.HealthCheckFunc,\n\tcopts: transport.ConnectOptions{\n\t\tWriteBufferSize: defaultWriteBufSize,\n\t\tReadBufferSize:  defaultReadBufSize,\n\t},\n\tmct: minConnectTimeout,\n}",
        "file": "dialoptions.go",
        "symbol": "defaultDialOptions"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "discriminator": "cc.dopts.bs == nil",
        "file": "clientconn.go",
        "in_function": "DialContext",
        "kind": "if",
        "source": "if cc.dopts.bs == nil {\n\tcc.dopts.bs = backoff.NewExponentialBuilder().Build()\n}"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "discriminator": "dialDuration := minConnectTimeout",
        "file": "clientconn.go",
        "in_function": "addrConn.resetTransport",
        "kind": "statement/expression",
        "source": "dialDuration := ac.dopts.mct"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/grpclb/grpclb.go",
        "language": "go",
        "symbol": "defaultBackoffConfig",
        "to": "defaultBackoffStrategy"
      },
      "tool": "semantic_rename"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/grpclb/grpclb.go",
        "source": "// defaultBackoffStrategy configures the backoff strategy that's used when the\n// init handshake in the RPC is unsuccessful. It's not for the clientconn\n// reconnect backoff.\n//\n// It has the same value as the default grpc.DefaultBackoffConfig.\n//\n// TODO: make backoff configurable.\nvar defaultBackoffStrategy = backoff.NewExponentialBuilder().Build()",
        "symbol": "defaultBackoffStrategy"
      },
      "tool": "semantic_replace_decl"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/xds/xds_client.go",
        "language": "go",
        "symbol": "defaultBackoffConfig",
        "to": "defaultBackoffStrategy"
      },
      "tool": "semantic_rename"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/xds/xds_client.go",
        "kind": "var",
        "source": "var defaultBackoffStrategy = backoff.NewExponentialBuilder().Build()",
        "symbol": "defaultBackoffStrategy"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "health/client.go",
        "kind": "var",
        "source": "var backoffStrategy = backoff.NewExponentialBuilder().Build()",
        "symbol": "backoffStrategy"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "health/client.go",
        "kind": "const",
        "safe_delete": false,
        "symbol": "maxDelay"
      },
      "tool": "semantic_remove_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver/dns/dns_resolver.go",
        "kind": "type",
        "source": "// dnsResolver watches for the name resolution update for a non-IP target.\ntype dnsResolver struct {\n\tfreq       time.Duration\n\tbackoff    backoff.Strategy\n\tretryCount int\n\thost       string\n\tport       string\n\tresolver   netResolver\n\tctx        context.Context\n\tcancel     context.CancelFunc\n\tcc         resolver.ClientConn\n\t// rn channel is used by ResolveNow() to force an immediate resolution of the target.\n\trn chan struct{}\n\tt  *time.Timer\n\t// wg is used to enforce Close() to return after the watcher() goroutine has finished.\n\t// Otherwise, data race will be possible. [Race Example] in dns_resolver_test we\n\t// replace the real lookup functions with mocked ones to facilitate testing.\n\t// If Close() doesn't wait for watcher() goroutine finishes, race detector sometimes\n\t// will warns lookup (READ the lookup function pointers) inside watcher() goroutine\n\t// has data race with replaceNetFunc (WRITE the lookup function pointers).\n\twg                   sync.WaitGroup\n\tdisableServiceConfig bool\n}",
        "symbol": "dnsResolver"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\thost, port, err := parseTarget(target.Endpoint, defaultPort)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\t// IP address.\n\tif net.ParseIP(host) != nil {\n\t\thost, _ = formatIP(host)\n\t\taddr := []resolver.Address{{Addr: host + \":\" + port}}\n\t\ti := \u0026ipResolver{\n\t\t\tcc: cc,\n\t\t\tip: addr,\n\t\t\trn: make(chan struct{}, 1),\n\t\t\tq:  make(chan struct{}),\n\t\t}\n\t\tcc.NewAddress(addr)\n\t\tgo i.watcher()\n\t\treturn i, nil\n\t}\n\n\t// DNS address (non-IP).\n\tctx, cancel := context.WithCancel(context.Background())\n\td := \u0026dnsResolver{\n\t\tfreq:                 b.minFreq,\n\t\tbackoff:              backoff.NewExponentialBuilder().MaxDelay(b.minFreq).Build(),\n\t\t host:                 host,\n\t\tport:                 port,\n\t\tctx:                  ctx,\n\t\tcancel:               cancel,\n\t\tcc:                   cc,\n\t\tt:                    time.NewTimer(0),\n\t\trn:                   make(chan struct{}, 1),\n\t\tdisableServiceConfig: opts.DisableServiceConfig,\n\t}\n\n\tif target.Authority == \"\" {\n\t\td.resolver = defaultResolver\n\t} else {\n\t\td.resolver, err = customAuthorityResolver(target.Authority)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\td.wg.Add(1)\n\tgo d.watcher()\n\treturn d, nil",
        "file": "resolver/dns/dns_resolver.go",
        "symbol": "(*dnsBuilder).Build"
      },
      "tool": "semantic_replace_body"
    }
  ],
  "trust_workspace": true
}

{
  "auto_organize_imports": false,
  "edits": [
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/balancer.go",
        "source": "// ErrBadResolverState may be returned by UpdateClientConnState to indicate a\n// problem with the provided name resolver data.\nvar ErrBadResolverState = errors.New(\"bad resolver state\")"
      },
      "tool": "semantic_insert_decl"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/balancer.go",
        "kind": "type",
        "source": "// V2Balancer is defined for documentation purposes.  If a Balancer also\n// implements V2Balancer, its UpdateClientConnState method will be called\n// instead of HandleResolvedAddrs and its UpdateSubConnState will be called\n// instead of HandleSubConnStateChange.\ntype V2Balancer interface {\n\t// UpdateClientConnState is called by gRPC when the state of the ClientConn\n\t// changes.  If the error returned is ErrBadResolverState, the ClientConn\n\t// will begin calling ResolveNow on the active name resolver with\n\t// exponential backoff until a subsequent call to UpdateClientConnState\n\t// returns a nil error.  Any other errors are currently ignored.\n\tUpdateClientConnState(ClientConnState) error\n\t// ResolverError is called by gRPC when the name resolver reports an error.\n\tResolverError(error)\n\t// UpdateSubConnState is called by gRPC when the state of a SubConn\n\t// changes.\n\tUpdateSubConnState(SubConn, SubConnState)\n\t// Close closes the balancer. The balancer is not required to call\n\t// ClientConn.RemoveSubConn for its existing SubConns.\n\tClose()\n}",
        "symbol": "V2Balancer"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/base/balancer.go",
        "source": "var _ balancer.V2Balancer = (*baseBalancer)(nil) // Assert that we implement V2Balancer\n"
      },
      "tool": "semantic_insert_decl"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/base/balancer.go",
        "source": "func (b *baseBalancer) ResolverError(error) {\n\t// Ignore\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/base/balancer.go",
        "kind": "method",
        "source": "func (b *baseBalancer) UpdateClientConnState(s balancer.ClientConnState) error {\n\t// TODO: handle s.ResolverState.Err (log if not nil) once implemented.\n\t// TODO: handle s.ResolverState.ServiceConfig?\n\tif grpclog.V(2) {\n\t\tgrpclog.Infoln(\"base.baseBalancer: got new ClientConn state: \", s)\n\t}\n\t// addrsSet is the set converted from addrs, it's used for quick lookup of an address.\n\taddrsSet := make(map[resolver.Address]struct{})\n\tfor _, a := range s.ResolverState.Addresses {\n\t\taddrsSet[a] = struct{}{}\n\t\tif _, ok := b.subConns[a]; !ok {\n\t\t\t// a is a new address (not existing in b.subConns).\n\t\t\tsc, err := b.cc.NewSubConn([]resolver.Address{a}, balancer.NewSubConnOptions{HealthCheckEnabled: b.config.HealthCheck})\n\t\t\tif err != nil {\n\t\t\t\tgrpclog.Warningf(\"base.baseBalancer: failed to create new SubConn: %v\", err)\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tb.subConns[a] = sc\n\t\t\tb.scStates[sc] = connectivity.Idle\n\t\t\tsc.Connect()\n\t\t}\n\t}\n\tfor a, sc := range b.subConns {\n\t\t// a was removed by resolver.\n\t\tif _, ok := addrsSet[a]; !ok {\n\t\t\tb.cc.RemoveSubConn(sc)\n\t\t\tdelete(b.subConns, a)\n\t\t\t// Keep the state of this sc in b.scStates until sc's state becomes Shutdown.\n\t\t\t// The entry will be deleted in HandleSubConnStateChange.\n\t\t}\n\t}\n\treturn nil\n}",
        "symbol": "baseBalancer.UpdateClientConnState"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/grpclb/grpclb.go",
        "source": "var _ balancer.V2Balancer = (*lbBalancer)(nil) // Assert that we implement V2Balancer\n"
      },
      "tool": "semantic_insert_decl"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/grpclb/grpclb.go",
        "source": "func (lb *lbBalancer) ResolverError(error) {\n\t// Ignore resolver errors.  GRPCLB is not selected unless the resolver\n\t// works at least once.\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer/grpclb/grpclb.go",
        "kind": "method",
        "source": "func (lb *lbBalancer) UpdateClientConnState(ccs balancer.ClientConnState) error {\n\tif grpclog.V(2) {\n\t\tgrpclog.Infof(\"lbBalancer: UpdateClientConnState: %+v\", ccs)\n\t}\n\tgc, _ := ccs.BalancerConfig.(*grpclbServiceConfig)\n\tlb.handleServiceConfig(gc)\n\n\taddrs := ccs.ResolverState.Addresses\n\tif len(addrs) == 0 {\n\t\treturn balancer.ErrBadResolverState\n\t}\n\n\tvar remoteBalancerAddrs, backendAddrs []resolver.Address\n\tfor _, a := range addrs {\n\t\tif a.Type == resolver.GRPCLB {\n\t\t\ta.Type = resolver.Backend\n\t\t\tremoteBalancerAddrs = append(remoteBalancerAddrs, a)\n\t\t} else {\n\t\t\tbackendAddrs = append(backendAddrs, a)\n\t\t}\n\t}\n\n\tif lb.ccRemoteLB == nil {\n\t\tif len(remoteBalancerAddrs) == 0 {\n\t\t\tgrpclog.Errorf(\"grpclb: no remote balancer address is available, should never happen\")\n\t\t\treturn balancer.ErrBadResolverState\n\t\t}\n\t\t// First time receiving resolved addresses, create a cc to remote\n\t\t// balancers.\n\t\tlb.dialRemoteLB(remoteBalancerAddrs[0].ServerName)\n\t\t// Start the fallback goroutine.\n\t\tgo lb.fallbackToBackendsAfter(lb.fallbackTimeout)\n\t}\n\n\t// cc to remote balancers uses lb.manualResolver. Send the updated remote\n\t// balancer addresses to it through manualResolver.\n\tlb.manualResolver.UpdateState(resolver.State{Addresses: remoteBalancerAddrs})\n\n\tlb.mu.Lock()\n\tlb.resolvedBackendAddrs = backendAddrs\n\tif lb.inFallback {\n\t\t// This means we received a new list of resolved backends, and we are\n\t\t// still in fallback mode. Need to update the list of backends we are\n\t\t// using to the new list of backends.\n\t\tlb.refreshSubConns(lb.resolvedBackendAddrs, true, lb.usePickFirst)\n\t}\n\tlb.mu.Unlock()\n\treturn nil\n}",
        "symbol": "lbBalancer.UpdateClientConnState"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer_conn_wrappers.go",
        "kind": "type",
        "source": "// ccBalancerWrapper is a wrapper on top of cc for balancers.\n// It implements balancer.ClientConn interface.\ntype ccBalancerWrapper struct {\n\tcc               *ClientConn\n\tbalancerMu       sync.Mutex // synchronizes calls to the balancer\n\tbalancer         balancer.Balancer\n\tstateChangeQueue *scStateUpdateBuffer\n\tdone             *grpcsync.Event\n\n\tmu       sync.Mutex\n\tsubConns map[*acBalancerWrapper]struct{}\n}",
        "symbol": "ccBalancerWrapper"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tccb := \u0026ccBalancerWrapper{\n\t\tcc:               cc,\n\t\tstateChangeQueue: newSCStateUpdateBuffer(),\n\t\tdone:             grpcsync.NewEvent(),\n\t\tsubConns:         make(map[*acBalancerWrapper]struct{}),\n\t}\n\tgo ccb.watcher()\n\tccb.balancer = b.Build(ccb, bopts)\n\treturn ccb\n",
        "file": "balancer_conn_wrappers.go",
        "symbol": "newCCBalancerWrapper"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tfor {\n\t\tselect {\n\t\tcase t := \u003c-ccb.stateChangeQueue.get():\n\t\t\tccb.stateChangeQueue.load()\n\t\t\tif ccb.done.HasFired() {\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tccb.balancerMu.Lock()\n\t\t\tif ub, ok := ccb.balancer.(balancer.V2Balancer); ok {\n\t\t\t\tub.UpdateSubConnState(t.sc, balancer.SubConnState{ConnectivityState: t.state})\n\t\t\t} else {\n\t\t\t\tccb.balancer.HandleSubConnStateChange(t.sc, t.state)\n\t\t\t}\n\t\t\tccb.balancerMu.Unlock()\n\t\tcase \u003c-ccb.done.Done():\n\t\t}\n\n\t\tif ccb.done.HasFired() {\n\t\t\tccb.balancer.Close()\n\t\t\tccb.mu.Lock()\n\t\t\tscs := ccb.subConns\n\t\t\tccb.subConns = nil\n\t\t\tccb.mu.Unlock()\n\t\t\tfor acbw := range scs {\n\t\t\t\tccb.cc.removeAddrConn(acbw.getAddrConn(), errConnDrain)\n\t\t\t}\n\t\t\tccb.UpdateBalancerState(connectivity.Connecting, nil)\n\t\t\treturn\n\t\t}\n\t}\n",
        "file": "balancer_conn_wrappers.go",
        "symbol": "ccBalancerWrapper.watcher"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tccb.done.Fire()\n",
        "file": "balancer_conn_wrappers.go",
        "symbol": "ccBalancerWrapper.close"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer_conn_wrappers.go",
        "kind": "method",
        "source": "func (ccb *ccBalancerWrapper) updateClientConnState(ccs *balancer.ClientConnState) error {\n\tccb.balancerMu.Lock()\n\tdefer ccb.balancerMu.Unlock()\n\tif ub, ok := ccb.balancer.(balancer.V2Balancer); ok {\n\t\treturn ub.UpdateClientConnState(*ccs)\n\t}\n\tccb.balancer.HandleResolvedAddrs(ccs.ResolverState.Addresses, nil)\n\treturn nil\n}",
        "symbol": "ccBalancerWrapper.updateClientConnState"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "balancer_conn_wrappers.go",
        "source": "func (ccb *ccBalancerWrapper) resolverError(err error) {\n\tif ub, ok := ccb.balancer.(balancer.V2Balancer); ok {\n\t\tccb.balancerMu.Lock()\n\t\tub.ResolverError(err)\n\t\tccb.balancerMu.Unlock()\n\t}\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "add": [
          "google.golang.org/grpc/internal/grpcsync"
        ],
        "file": "balancer_conn_wrappers.go",
        "remove": []
      },
      "tool": "semantic_organize_imports"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tcc := \u0026ClientConn{\n\t\ttarget:            target,\n\t\tcsMgr:             \u0026connectivityStateManager{},\n\t\tconns:             make(map[*addrConn]struct{}),\n\t\tdopts:             defaultDialOptions(),\n\t\tblockingpicker:    newPickerWrapper(),\n\t\tczData:            new(channelzData),\n\t\tfirstResolveEvent: grpcsync.NewEvent(),\n\t}\n\tcc.retryThrottler.Store((*retryThrottler)(nil))\n\tcc.ctx, cc.cancel = context.WithCancel(context.Background())\n\n\tfor _, opt := range opts {\n\t\topt.apply(\u0026cc.dopts)\n\t}\n\n\tchainUnaryClientInterceptors(cc)\n\tchainStreamClientInterceptors(cc)\n\n\tdefer func() {\n\t\tif err != nil {\n\t\t\tcc.Close()\n\t\t}\n\t}()\n\n\tif channelz.IsOn() {\n\t\tif cc.dopts.channelzParentID != 0 {\n\t\t\tcc.channelzID = channelz.RegisterChannel(\u0026channelzChannel{cc}, cc.dopts.channelzParentID, target)\n\t\t\tchannelz.AddTraceEvent(cc.channelzID, \u0026channelz.TraceEventDesc{\n\t\t\t\tDesc:     \"Channel Created\",\n\t\t\t\tSeverity: channelz.CtINFO,\n\t\t\t\tParent: \u0026channelz.TraceEventDesc{\n\t\t\t\t\tDesc:     fmt.Sprintf(\"Nested Channel(id:%d) created\", cc.channelzID),\n\t\t\t\t\tSeverity: channelz.CtINFO,\n\t\t\t\t},\n\t\t\t})\n\t\t} else {\n\t\t\tcc.channelzID = channelz.RegisterChannel(\u0026channelzChannel{cc}, 0, target)\n\t\t\tchannelz.AddTraceEvent(cc.channelzID, \u0026channelz.TraceEventDesc{\n\t\t\t\tDesc:     \"Channel Created\",\n\t\t\t\tSeverity: channelz.CtINFO,\n\t\t\t})\n\t\t}\n\t\tcc.csMgr.channelzID = cc.channelzID\n\t}\n\n\tif !cc.dopts.insecure {\n\t\tif cc.dopts.copts.TransportCredentials == nil \u0026\u0026 cc.dopts.copts.CredsBundle == nil {\n\t\t\treturn nil, errNoTransportSecurity\n\t\t}\n\t\tif cc.dopts.copts.TransportCredentials != nil \u0026\u0026 cc.dopts.copts.CredsBundle != nil {\n\t\t\treturn nil, errTransportCredsAndBundle\n\t\t}\n\t} else {\n\t\tif cc.dopts.copts.TransportCredentials != nil || cc.dopts.copts.CredsBundle != nil {\n\t\t\treturn nil, errCredentialsConflict\n\t\t}\n\t\tfor _, cd := range cc.dopts.copts.PerRPCCredentials {\n\t\t\tif cd.RequireTransportSecurity() {\n\t\t\t\treturn nil, errTransportCredentialsMissing\n\t\t\t}\n\t\t}\n\t}\n\n\tif cc.dopts.defaultServiceConfigRawJSON != nil {\n\t\tscpr := parseServiceConfig(*cc.dopts.defaultServiceConfigRawJSON)\n\t\tif scpr.Err != nil {\n\t\t\treturn nil, fmt.Errorf(\"%s: %v\", invalidDefaultServiceConfigErrPrefix, scpr.Err)\n\t\t}\n\t\tcc.dopts.defaultServiceConfig, _ = scpr.Config.(*ServiceConfig)\n\t}\n\tcc.mkp = cc.dopts.copts.KeepaliveParams\n\n\tif cc.dopts.copts.Dialer == nil {\n\t\tcc.dopts.copts.Dialer = newProxyDialer(\n\t\t\tfunc(ctx context.Context, addr string) (net.Conn, error) {\n\t\t\t\tnetwork, addr := parseDialTarget(addr)\n\t\t\t\treturn (\u0026net.Dialer{}).DialContext(ctx, network, addr)\n\t\t\t},\n\t\t)\n\t}\n\n\tif cc.dopts.copts.UserAgent != \"\" {\n\t\tcc.dopts.copts.UserAgent += \" \" + grpcUA\n\t} else {\n\t\tcc.dopts.copts.UserAgent = grpcUA\n\t}\n\n\tif cc.dopts.timeout \u003e 0 {\n\t\tvar cancel context.CancelFunc\n\t\tctx, cancel = context.WithTimeout(ctx, cc.dopts.timeout)\n\t\tdefer cancel()\n\t}\n\tdefer func() {\n\t\tselect {\n\t\tcase \u003c-ctx.Done():\n\t\t\tconn, err = nil, ctx.Err()\n\t\tdefault:\n\t\t}\n\t}()\n\n\tscSet := false\n\tif cc.dopts.scChan != nil {\n\t\t// Try to get an initial service config.\n\t\tselect {\n\t\tcase sc, ok := \u003c-cc.dopts.scChan:\n\t\t\tif ok {\n\t\t\t\tcc.sc = \u0026sc\n\t\t\t\tscSet = true\n\t\t\t}\n\t\tdefault:\n\t\t}\n\t}\n\tif cc.dopts.bs == nil {\n\t\tcc.dopts.bs = backoff.DefaultExponential\n\t}\n\tif cc.dopts.resolverBuilder == nil {\n\t\t// Only try to parse target when resolver builder is not already set.\n\t\tcc.parsedTarget = parseTarget(cc.target)\n\t\tgrpclog.Infof(\"parsed scheme: %q\", cc.parsedTarget.Scheme)\n\t\tcc.dopts.resolverBuilder = resolver.Get(cc.parsedTarget.Scheme)\n\t\tif cc.dopts.resolverBuilder == nil {\n\t\t\t// If resolver builder is still nil, the parsed target's scheme is\n\t\t\t// not registered. Fallback to default resolver and set Endpoint to\n\t\t\t// the original target.\n\t\t\tgrpclog.Infof(\"scheme %q not registered, fallback to default scheme\", cc.parsedTarget.Scheme)\n\t\t\tcc.parsedTarget = resolver.Target{\n\t\t\t\tScheme:   resolver.GetDefaultScheme(),\n\t\t\t\tEndpoint: target,\n\t\t\t}\n\t\t\tcc.dopts.resolverBuilder = resolver.Get(cc.parsedTarget.Scheme)\n\t\t}\n\t} else {\n\t\tcc.parsedTarget = resolver.Target{Endpoint: target}\n\t}\n\tcreds := cc.dopts.copts.TransportCredentials\n\tif creds != nil \u0026\u0026 creds.Info().ServerName != \"\" {\n\t\tcc.authority = creds.Info().ServerName\n\t} else if cc.dopts.insecure \u0026\u0026 cc.dopts.authority != \"\" {\n\t\tcc.authority = cc.dopts.authority\n\t} else {\n\t\t// Use endpoint from \"scheme://authority/endpoint\" as the default\n\t\t// authority for ClientConn.\n\t\tcc.authority = cc.parsedTarget.Endpoint\n\t}\n\n\tif cc.dopts.scChan != nil \u0026\u0026 !scSet {\n\t\t// Blocking wait for the initial service config.\n\t\tselect {\n\t\tcase sc, ok := \u003c-cc.dopts.scChan:\n\t\t\tif ok {\n\t\t\t\tcc.sc = \u0026sc\n\t\t\t}\n\t\tcase \u003c-ctx.Done():\n\t\t\treturn nil, ctx.Err()\n\t\t}\n\t}\n\tif cc.dopts.scChan != nil {\n\t\tgo cc.scWatcher()\n\t}\n\n\tvar credsClone credentials.TransportCredentials\n\tif creds := cc.dopts.copts.TransportCredentials; creds != nil {\n\t\tcredsClone = creds.Clone()\n\t}\n\tcc.balancerBuildOpts = balancer.BuildOptions{\n\t\tDialCreds:        credsClone,\n\t\tCredsBundle:      cc.dopts.copts.CredsBundle,\n\t\tDialer:           cc.dopts.copts.Dialer,\n\t\tChannelzParentID: cc.channelzID,\n\t\tTarget:           cc.parsedTarget,\n\t}\n\n\t// Build the resolver.\n\trWrapper, err := newCCResolverWrapper(cc)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"failed to build resolver: %v\", err)\n\t}\n\n\tcc.mu.Lock()\n\tcc.resolverWrapper = rWrapper\n\tcc.mu.Unlock()\n\t// A blocking dial blocks until the clientConn is ready.\n\tif cc.dopts.block {\n\t\tfor {\n\t\t\ts := cc.GetState()\n\t\t\tif s == connectivity.Ready {\n\t\t\t\tbreak\n\t\t\t} else if cc.dopts.copts.FailOnNonTempDialError \u0026\u0026 s == connectivity.TransientFailure {\n\t\t\t\tif err = cc.blockingpicker.connectionError(); err != nil {\n\t\t\t\t\tterr, ok := err.(interface {\n\t\t\t\t\t\tTemporary() bool\n\t\t\t\t\t})\n\t\t\t\t\tif ok \u0026\u0026 !terr.Temporary() {\n\t\t\t\t\t\treturn nil, err\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif !cc.WaitForStateChange(ctx, s) {\n\t\t\t\t// ctx got timeout or canceled.\n\t\t\t\treturn nil, ctx.Err()\n\t\t\t}\n\t\t}\n\t}\n\n\treturn cc, nil\n",
        "file": "clientconn.go",
        "symbol": "DialContext"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "clientconn.go",
        "source": "var emptyServiceConfig *ServiceConfig"
      },
      "tool": "semantic_insert_decl"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "clientconn.go",
        "source": "func (cc *ClientConn) maybeApplyDefaultServiceConfig(addrs []resolver.Address) {\n\tif cc.sc != nil {\n\t\tcc.applyServiceConfigAndBalancer(cc.sc, addrs)\n\t\treturn\n\t}\n\tif cc.dopts.defaultServiceConfig != nil {\n\t\tcc.applyServiceConfigAndBalancer(cc.dopts.defaultServiceConfig, addrs)\n\t} else {\n\t\tcc.applyServiceConfigAndBalancer(emptyServiceConfig, addrs)\n\t}\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "clientconn.go",
        "kind": "method",
        "source": "func (cc *ClientConn) updateResolverState(s resolver.State, err error) error {\n\tdefer cc.firstResolveEvent.Fire()\n\tcc.mu.Lock()\n\t// Check if the ClientConn is already closed. Some fields (e.g.\n\t// balancerWrapper) are set to nil when closing the ClientConn, and could\n\t// cause nil pointer panic if we don't have this check.\n\tif cc.conns == nil {\n\t\tcc.mu.Unlock()\n\t\treturn nil\n\t}\n\n\tif err != nil {\n\t\t// May need to apply the initial service config in case the resolver\n\t\t// doesn't support service configs, or doesn't provide a service config\n\t\t// with the new addresses.\n\t\tcc.maybeApplyDefaultServiceConfig(nil)\n\n\t\tif cc.balancerWrapper != nil {\n\t\t\tcc.balancerWrapper.resolverError(err)\n\t\t}\n\n\t\t// No addresses are valid with err set; return early.\n\t\tcc.mu.Unlock()\n\t\treturn balancer.ErrBadResolverState\n\t}\n\n\tvar ret error\n\tif cc.dopts.disableServiceConfig || s.ServiceConfig == nil {\n\t\tcc.maybeApplyDefaultServiceConfig(s.Addresses)\n\t\t// TODO: do we need to apply a failing LB policy if there is no\n\t\t// default, per the error handling design?\n\t} else {\n\t\tif sc, ok := s.ServiceConfig.Config.(*ServiceConfig); s.ServiceConfig.Err == nil \u0026\u0026 ok {\n\t\t\tcc.applyServiceConfigAndBalancer(sc, s.Addresses)\n\t\t} else {\n\t\t\tret = balancer.ErrBadResolverState\n\t\t\tif cc.balancerWrapper == nil {\n\t\t\t\tvar err error\n\t\t\t\tif s.ServiceConfig.Err != nil {\n\t\t\t\t\terr = status.Errorf(codes.Unavailable, \"error parsing service config: %v\", s.ServiceConfig.Err)\n\t\t\t\t} else {\n\t\t\t\t\terr = status.Errorf(codes.Unavailable, \"illegal service config type: %T\", s.ServiceConfig.Config)\n\t\t\t\t}\n\t\t\t\tcc.blockingpicker.updatePicker(base.NewErrPicker(err))\n\t\t\t\tcc.csMgr.updateState(connectivity.TransientFailure)\n\t\t\t\tcc.mu.Unlock()\n\t\t\t\treturn ret\n\t\t\t}\n\t\t}\n\t}\n\n\tvar balCfg serviceconfig.LoadBalancingConfig\n\tif cc.dopts.balancerBuilder == nil \u0026\u0026 cc.sc != nil \u0026\u0026 cc.sc.lbConfig != nil {\n\t\tbalCfg = cc.sc.lbConfig.cfg\n\t}\n\n\tcbn := cc.curBalancerName\n\tbw := cc.balancerWrapper\n\tcc.mu.Unlock()\n\tif cbn != grpclbName {\n\t\t// Filter any grpclb addresses since we don't have the grpclb balancer.\n\t\tfor i := 0; i \u003c len(s.Addresses); {\n\t\t\tif s.Addresses[i].Type == resolver.GRPCLB {\n\t\t\t\tcopy(s.Addresses[i:], s.Addresses[i+1:])\n\t\t\t\ts.Addresses = s.Addresses[:len(s.Addresses)-1]\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\ti++\n\t\t}\n\t}\n\tuccsErr := bw.updateClientConnState(\u0026balancer.ClientConnState{ResolverState: s, BalancerConfig: balCfg})\n\tif ret == nil {\n\t\tret = uccsErr // prefer ErrBadResolver state since any other error is\n\t\t// currently meaningless to the caller.\n\t}\n\treturn ret\n}",
        "symbol": "ClientConn.updateResolverState"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "clientconn.go",
        "source": "func (cc *ClientConn) applyServiceConfigAndBalancer(sc *ServiceConfig, addrs []resolver.Address) {\n\tif sc == nil {\n\t\t// should never reach here.\n\t\treturn\n\t}\n\tcc.sc = sc\n\n\tif cc.sc.retryThrottling != nil {\n\t\tnewThrottler := \u0026retryThrottler{\n\t\t\ttokens: cc.sc.retryThrottling.MaxTokens,\n\t\t\tmax:    cc.sc.retryThrottling.MaxTokens,\n\t\t\tthresh: cc.sc.retryThrottling.MaxTokens / 2,\n\t\t\tratio:  cc.sc.retryThrottling.TokenRatio,\n\t\t}\n\t\tcc.retryThrottler.Store(newThrottler)\n\t} else {\n\t\tcc.retryThrottler.Store((*retryThrottler)(nil))\n\t}\n\n\tif cc.dopts.balancerBuilder == nil {\n\t\t// Only look at balancer types and switch balancer if balancer dial\n\t\t// option is not set.\n\t\tvar newBalancerName string\n\t\tif cc.sc != nil \u0026\u0026 cc.sc.lbConfig != nil {\n\t\t\tnewBalancerName = cc.sc.lbConfig.name\n\t\t} else {\n\t\t\tvar isGRPCLB bool\n\t\t\tfor _, a := range addrs {\n\t\t\t\tif a.Type == resolver.GRPCLB {\n\t\t\t\t\tisGRPCLB = true\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\t\t\tif isGRPCLB {\n\t\t\t\tnewBalancerName = grpclbName\n\t\t\t} else if cc.sc != nil \u0026\u0026 cc.sc.LB != nil {\n\t\t\t\tnewBalancerName = *cc.sc.LB\n\t\t\t} else {\n\t\t\t\tnewBalancerName = PickFirstBalancerName\n\t\t\t}\n\t\t}\n\t\tcc.switchBalancer(newBalancerName)\n\t} else if cc.balancerWrapper == nil {\n\t\t// Balancer dial option was set, and this is the first time handling\n\t\t// resolved addresses. Build a balancer with dopts.balancerBuilder.\n\t\tcc.curBalancerName = cc.dopts.balancerBuilder.Name()\n\t\tcc.balancerWrapper = newCCBalancerWrapper(cc, cc.dopts.balancerBuilder, cc.balancerBuildOpts)\n\t}\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "clientconn.go",
        "kind": "method",
        "symbol": "ClientConn.applyServiceConfig"
      },
      "tool": "semantic_remove_construct"
    },
    {
      "params": {
        "add": [
          "google.golang.org/grpc/balancer/base"
        ],
        "file": "clientconn.go",
        "remove": []
      },
      "tool": "semantic_organize_imports"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/internal.go",
        "source": "// ParseServiceConfigForTesting is for creating a fake\n\t// ClientConn for resolver testing only\n\tvar // ParseServiceConfigForTesting is for creating a fake\n// ClientConn for resolver testing only\nParseServiceConfigForTesting interface{} // func(string) *serviceconfig.ParseResult\n"
      },
      "tool": "semantic_insert_decl"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "internal/internal.go",
        "kind": "var",
        "symbol": "ParseServiceConfig"
      },
      "tool": "semantic_remove_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\treturn \u0026Resolver{\n\t\tResolveNowCallback: func(resolver.ResolveNowOption) {},\n\t\tscheme:             scheme,\n\t}\n",
        "file": "resolver/manual/manual.go",
        "symbol": "NewBuilderWithScheme"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver/manual/manual.go",
        "kind": "type",
        "source": "// Resolver is also a resolver builder.\n// It's build() function always returns itself.\ntype Resolver struct {\n\t// ResolveNowCallback is called when the ResolveNow method is called on the\n\t// resolver.  Must not be nil.  Must not be changed after the resolver may\n\t// be built.\n\tResolveNowCallback func(resolver.ResolveNowOption)\n\tscheme             string\n\n\t// Fields actually belong to the resolver.\n\tCC             resolver.ClientConn\n\tbootstrapState *resolver.State\n}",
        "symbol": "Resolver"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tr.CC = cc\n\tif r.bootstrapState != nil {\n\t\tr.UpdateState(*r.bootstrapState)\n\t}\n\treturn r, nil\n",
        "file": "resolver/manual/manual.go",
        "symbol": "Resolver.Build"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver/manual/manual.go",
        "kind": "method",
        "source": "// ResolveNow is a noop for Resolver.\nfunc (r *Resolver) ResolveNow(o resolver.ResolveNowOption) {\n\tr.ResolveNowCallback(o)\n}",
        "symbol": "Resolver.ResolveNow"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver/manual/manual.go",
        "kind": "method",
        "source": "// UpdateState calls CC.UpdateState.\nfunc (r *Resolver) UpdateState(s resolver.State) {\n\tr.CC.UpdateState(s)\n}",
        "symbol": "Resolver.UpdateState"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver/resolver.go",
        "kind": "type",
        "source": "// State contains the current Resolver state relevant to the ClientConn.\ntype State struct {\n\t// Addresses is the latest set of resolved addresses for the target.\n\tAddresses []Address\n\n\t// ServiceConfig contains the result from parsing the latest service\n\t// config.  If it is nil, it indicates no service config is present or the\n\t// resolver does not provide service configs.\n\tServiceConfig *serviceconfig.ParseResult\n}",
        "symbol": "State"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver/resolver.go",
        "kind": "type",
        "source": "// ClientConn contains the callbacks for resolver to notify any updates\n// to the gRPC ClientConn.\n//\n// This interface is to be implemented by gRPC. Users should not need a\n// brand new implementation of this interface. For the situations like\n// testing, the new implementation should embed this interface. This allows\n// gRPC to add new methods to this interface.\ntype ClientConn interface {\n\t// UpdateState updates the state of the ClientConn appropriately.\n\tUpdateState(State)\n\t// ReportError notifies the ClientConn that the Resolver encountered an\n\t// error.  The ClientConn will notify the load balancer and begin calling\n\t// ResolveNow on the Resolver with exponential backoff.\n\tReportError(error)\n\t// NewAddress is called by resolver to notify ClientConn a new list\n\t// of resolved addresses.\n\t// The address list should be the complete list of resolved addresses.\n\t//\n\t// Deprecated: Use UpdateState instead.\n\tNewAddress(addresses []Address)\n\t// NewServiceConfig is called by resolver to notify ClientConn a new\n\t// service config. The service config should be provided as a json string.\n\t//\n\t// Deprecated: Use UpdateState instead.\n\tNewServiceConfig(serviceConfig string)\n\t// ParseServiceConfig parses the provided service config and returns an\n\t// object that provides the parsed config.\n\tParseServiceConfig(serviceConfigJSON string) *serviceconfig.ParseResult\n}",
        "symbol": "ClientConn"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver_conn_wrapper.go",
        "kind": "type",
        "source": "// ccResolverWrapper is a wrapper on top of cc for resolvers.\n// It implements resolver.ClientConnection interface.\ntype ccResolverWrapper struct {\n\tcc       *ClientConn\n\tresolver resolver.Resolver\n\tdone     *grpcsync.Event\n\tcurState resolver.State\n\n\tmu      sync.Mutex // protects polling\n\tpolling chan struct{}\n}",
        "symbol": "ccResolverWrapper"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\trb := cc.dopts.resolverBuilder\n\tif rb == nil {\n\t\treturn nil, fmt.Errorf(\"could not get resolver for scheme: %q\", cc.parsedTarget.Scheme)\n\t}\n\n\tccr := \u0026ccResolverWrapper{\n\t\tcc:   cc,\n\t\tdone: grpcsync.NewEvent(),\n\t}\n\n\tvar err error\n\tccr.resolver, err = rb.Build(cc.parsedTarget, ccr, resolver.BuildOption{DisableServiceConfig: cc.dopts.disableServiceConfig})\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn ccr, nil\n",
        "file": "resolver_conn_wrapper.go",
        "symbol": "newCCResolverWrapper"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tccr.mu.Lock()\n\tif !ccr.done.HasFired() {\n\t\tccr.resolver.ResolveNow(o)\n\t}\n\tccr.mu.Unlock()\n",
        "file": "resolver_conn_wrapper.go",
        "symbol": "ccResolverWrapper.resolveNow"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tccr.mu.Lock()\n\tccr.resolver.Close()\n\tccr.done.Fire()\n\tccr.mu.Unlock()\n",
        "file": "resolver_conn_wrapper.go",
        "symbol": "ccResolverWrapper.close"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver_conn_wrapper.go",
        "source": "var resolverBackoff = internalbackoff.Exponential{Config: backoff.Config{MaxDelay: 2 * time.Minute}}.Backoff"
      },
      "tool": "semantic_insert_decl"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver_conn_wrapper.go",
        "source": "// poll begins or ends asynchronous polling of the resolver based on whether\n// err is ErrBadResolverState.\nfunc (ccr *ccResolverWrapper) poll(err error) {\n\tccr.mu.Lock()\n\tdefer ccr.mu.Unlock()\n\tif err != balancer.ErrBadResolverState {\n\t\t// stop polling\n\t\tif ccr.polling != nil {\n\t\t\tclose(ccr.polling)\n\t\t\tccr.polling = nil\n\t\t}\n\t\treturn\n\t}\n\tif ccr.polling != nil {\n\t\t// already polling\n\t\treturn\n\t}\n\tp := make(chan struct{})\n\tccr.polling = p\n\tgo func() {\n\t\tfor i := 0; ; i++ {\n\t\t\tccr.resolveNow(resolver.ResolveNowOption{})\n\t\t\tt := time.NewTimer(resolverBackoff(i))\n\t\t\tselect {\n\t\t\tcase \u003c-p:\n\t\t\t\tt.Stop()\n\t\t\t\treturn\n\t\t\tcase \u003c-ccr.done.Done():\n\t\t\t\t// Resolver has been closed.\n\t\t\t\tt.Stop()\n\t\t\t\treturn\n\t\t\tcase \u003c-t.C:\n\t\t\t\tselect {\n\t\t\t\tcase \u003c-p:\n\t\t\t\t\treturn\n\t\t\t\tdefault:\n\t\t\t\t}\n\t\t\t\t// Timer expired; re-resolve.\n\t\t\t}\n\t\t}\n\t}()\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tif ccr.done.HasFired() {\n\t\treturn\n\t}\n\tgrpclog.Infof(\"ccResolverWrapper: sending update to cc: %v\", s)\n\tif channelz.IsOn() {\n\t\tccr.addChannelzTraceEvent(s)\n\t}\n\tccr.curState = s\n\tccr.poll(ccr.cc.updateResolverState(ccr.curState, nil))\n",
        "file": "resolver_conn_wrapper.go",
        "symbol": "ccResolverWrapper.UpdateState"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver_conn_wrapper.go",
        "source": "func (ccr *ccResolverWrapper) ReportError(err error) {\n\tif ccr.done.HasFired() {\n\t\treturn\n\t}\n\tgrpclog.Warningf(\"ccResolverWrapper: reporting error to cc: %v\", err)\n\tif channelz.IsOn() {\n\t\tchannelz.AddTraceEvent(ccr.cc.channelzID, \u0026channelz.TraceEventDesc{\n\t\t\tDesc:     fmt.Sprintf(\"Resolver reported error: %v\", err),\n\t\t\tSeverity: channelz.CtWarning,\n\t\t})\n\t}\n\tccr.poll(ccr.cc.updateResolverState(resolver.State{}, err))\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tif ccr.done.HasFired() {\n\t\treturn\n\t}\n\tgrpclog.Infof(\"ccResolverWrapper: sending new addresses to cc: %v\", addrs)\n\tif channelz.IsOn() {\n\t\tccr.addChannelzTraceEvent(resolver.State{Addresses: addrs, ServiceConfig: ccr.curState.ServiceConfig})\n\t}\n\tccr.curState.Addresses = addrs\n\tccr.poll(ccr.cc.updateResolverState(ccr.curState, nil))\n",
        "file": "resolver_conn_wrapper.go",
        "symbol": "ccResolverWrapper.NewAddress"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tif ccr.done.HasFired() {\n\t\treturn\n\t}\n\tgrpclog.Infof(\"ccResolverWrapper: got new service config: %v\", sc)\n\tscpr := parseServiceConfig(sc)\n\tif scpr.Err != nil {\n\t\tgrpclog.Warningf(\"ccResolverWrapper: error parsing service config: %v\", scpr.Err)\n\t\tif channelz.IsOn() {\n\t\t\tchannelz.AddTraceEvent(ccr.cc.channelzID, \u0026channelz.TraceEventDesc{\n\t\t\t\tDesc:     fmt.Sprintf(\"Error parsing service config: %v\", scpr.Err),\n\t\t\t\tSeverity: channelz.CtWarning,\n\t\t\t})\n\t\t}\n\t\tccr.poll(balancer.ErrBadResolverState)\n\t\treturn\n\t}\n\tif channelz.IsOn() {\n\t\tccr.addChannelzTraceEvent(resolver.State{Addresses: ccr.curState.Addresses, ServiceConfig: scpr})\n\t}\n\tccr.curState.ServiceConfig = scpr\n\tccr.poll(ccr.cc.updateResolverState(ccr.curState, nil))\n",
        "file": "resolver_conn_wrapper.go",
        "symbol": "ccResolverWrapper.NewServiceConfig"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver_conn_wrapper.go",
        "source": "func (ccr *ccResolverWrapper) ParseServiceConfig(scJSON string) *serviceconfig.ParseResult {\n\treturn parseServiceConfig(scJSON)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tvar updates []string\n\tvar oldSC, newSC *ServiceConfig\n\tvar oldOK, newOK bool\n\tif ccr.curState.ServiceConfig != nil {\n\t\toldSC, oldOK = ccr.curState.ServiceConfig.Config.(*ServiceConfig)\n\t}\n\tif s.ServiceConfig != nil {\n\t\tnewSC, newOK = s.ServiceConfig.Config.(*ServiceConfig)\n\t}\n\tif oldOK != newOK || (oldOK \u0026\u0026 newOK \u0026\u0026 oldSC.rawJSONString != newSC.rawJSONString) {\n\t\tupdates = append(updates, \"service config updated\")\n\t}\n\tif len(ccr.curState.Addresses) \u003e 0 \u0026\u0026 len(s.Addresses) == 0 {\n\t\tupdates = append(updates, \"resolver returned an empty address list\")\n\t} else if len(ccr.curState.Addresses) == 0 \u0026\u0026 len(s.Addresses) \u003e 0 {\n\t\tupdates = append(updates, \"resolver returned new addresses\")\n\t}\n\tchannelz.AddTraceEvent(ccr.cc.channelzID, \u0026channelz.TraceEventDesc{\n\t\tDesc:     fmt.Sprintf(\"Resolver state updated: %+v (%v)\", s, strings.Join(updates, \"; \")),\n\t\tSeverity: channelz.CtINFO,\n\t})\n",
        "file": "resolver_conn_wrapper.go",
        "symbol": "ccResolverWrapper.addChannelzTraceEvent"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "resolver_conn_wrapper.go",
        "kind": "method",
        "symbol": "ccResolverWrapper.isDone"
      },
      "tool": "semantic_remove_construct"
    },
    {
      "params": {
        "add": [
          "sync",
          "time",
          "google.golang.org/grpc/backoff",
          "google.golang.org/grpc/balancer",
          "google.golang.org/grpc/internal/grpcsync",
          "google.golang.org/grpc/serviceconfig",
          "internalbackoff google.golang.org/grpc/internal/backoff"
        ],
        "file": "resolver_conn_wrapper.go",
        "remove": [
          "sync/atomic"
        ]
      },
      "tool": "semantic_organize_imports"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\tinternal.ParseServiceConfigForTesting = parseServiceConfig\n\n\n\tcfg := parseServiceConfig(\"{}\")\n\tif cfg.Err != nil {\n\t\tpanic(fmt.Sprintf(\"impossible error parsing empty service config: %v\", cfg.Err))\n\t}\n\temptyServiceConfig = cfg.Config.(*ServiceConfig)\n",
        "file": "service_config.go",
        "symbol": "init"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "service_config.go",
        "kind": "function",
        "source": "func parseServiceConfig(js string) *serviceconfig.ParseResult {\n\tif len(js) == 0 {\n\t\treturn \u0026serviceconfig.ParseResult{Err: fmt.Errorf(\"no JSON service config provided\")}\n\t}\n\tvar rsc jsonSC\n\terr := json.Unmarshal([]byte(js), \u0026rsc)\n\tif err != nil {\n\t\tgrpclog.Warningf(\"grpc: parseServiceConfig error unmarshaling %s due to %v\", js, err)\n\t\treturn \u0026serviceconfig.ParseResult{Err: err}\n\t}\n\tsc := ServiceConfig{\n\t\tLB:                rsc.LoadBalancingPolicy,\n\t\tMethods:           make(map[string]MethodConfig),\n\t\tretryThrottling:   rsc.RetryThrottling,\n\t\thealthCheckConfig: rsc.HealthCheckConfig,\n\t\trawJSONString:     js,\n\t}\n\tif rsc.LoadBalancingConfig != nil {\n\t\tfor i, lbcfg := range *rsc.LoadBalancingConfig {\n\t\t\tif len(lbcfg) != 1 {\n\t\t\t\terr := fmt.Errorf(\"invalid loadBalancingConfig: entry %v does not contain exactly 1 policy/config pair: %q\", i, lbcfg)\n\t\t\t\tgrpclog.Warningf(err.Error())\n\t\t\t\treturn \u0026serviceconfig.ParseResult{Err: err}\n\t\t\t}\n\t\t\tvar name string\n\t\t\tvar jsonCfg json.RawMessage\n\t\t\tfor name, jsonCfg = range lbcfg {\n\t\t\t}\n\t\t\tbuilder := balancer.Get(name)\n\t\t\tif builder == nil {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tsc.lbConfig = \u0026lbConfig{name: name}\n\t\t\tif parser, ok := builder.(balancer.ConfigParser); ok {\n\t\t\t\tvar err error\n\t\t\t\tsc.lbConfig.cfg, err = parser.ParseConfig(jsonCfg)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn \u0026serviceconfig.ParseResult{Err: fmt.Errorf(\"error parsing loadBalancingConfig for policy %q: %v\", name, err)}\n\t\t\t\t}\n\t\t\t} else if string(jsonCfg) != \"{}\" {\n\t\t\t\tgrpclog.Warningf(\"non-empty balancer configuration %q, but balancer does not implement ParseConfig\", string(jsonCfg))\n\t\t\t}\n\t\t\tbreak\n\t\t}\n\t\tif sc.lbConfig == nil {\n\t\t\t// We had a loadBalancingConfig field but did not encounter a\n\t\t\t// supported policy.  The config is considered invalid in this\n\t\t\t// case.\n\t\t\terr := fmt.Errorf(\"invalid loadBalancingConfig: no supported policies found\")\n\t\t\tgrpclog.Warningf(err.Error())\n\t\t\treturn \u0026serviceconfig.ParseResult{Err: err}\n\t\t}\n\t}\n\n\tif rsc.MethodConfig == nil {\n\t\treturn \u0026serviceconfig.ParseResult{Config: \u0026sc}\n\t}\n\tfor _, m := range *rsc.MethodConfig {\n\t\tif m.Name == nil {\n\t\t\tcontinue\n\t\t}\n\t\td, err := parseDuration(m.Timeout)\n\t\tif err != nil {\n\t\t\tgrpclog.Warningf(\"grpc: parseServiceConfig error unmarshaling %s due to %v\", js, err)\n\t\t\treturn \u0026serviceconfig.ParseResult{Err: err}\n\t\t}\n\n\t\tmc := MethodConfig{\n\t\t\tWaitForReady: m.WaitForReady,\n\t\t\tTimeout:      d,\n\t\t}\n\t\tif mc.retryPolicy, err = convertRetryPolicy(m.RetryPolicy); err != nil {\n\t\t\tgrpclog.Warningf(\"grpc: parseServiceConfig error unmarshaling %s due to %v\", js, err)\n\t\t\treturn \u0026serviceconfig.ParseResult{Err: err}\n\t\t}\n\t\tif m.MaxRequestMessageBytes != nil {\n\t\t\tif *m.MaxRequestMessageBytes \u003e int64(maxInt) {\n\t\t\t\tmc.MaxReqSize = newInt(maxInt)\n\t\t\t} else {\n\t\t\t\tmc.MaxReqSize = newInt(int(*m.MaxRequestMessageBytes))\n\t\t\t}\n\t\t}\n\t\tif m.MaxResponseMessageBytes != nil {\n\t\t\tif *m.MaxResponseMessageBytes \u003e int64(maxInt) {\n\t\t\t\tmc.MaxRespSize = newInt(maxInt)\n\t\t\t} else {\n\t\t\t\tmc.MaxRespSize = newInt(int(*m.MaxResponseMessageBytes))\n\t\t\t}\n\t\t}\n\t\tfor _, n := range *m.Name {\n\t\t\tif path, valid := n.generatePath(); valid {\n\t\t\t\tsc.Methods[path] = mc\n\t\t\t}\n\t\t}\n\t}\n\n\tif sc.retryThrottling != nil {\n\t\tif mt := sc.retryThrottling.MaxTokens; mt \u003c= 0 || mt \u003e 1000 {\n\t\t\treturn \u0026serviceconfig.ParseResult{Err: fmt.Errorf(\"invalid retry throttling config: maxTokens (%v) out of range (0, 1000]\", mt)}\n\t\t}\n\t\tif tr := sc.retryThrottling.TokenRatio; tr \u003c= 0 {\n\t\t\treturn \u0026serviceconfig.ParseResult{Err: fmt.Errorf(\"invalid retry throttling config: tokenRatio (%v) may not be negative\", tr)}\n\t\t}\n\t}\n\treturn \u0026serviceconfig.ParseResult{Config: \u0026sc}\n}",
        "symbol": "parseServiceConfig"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "serviceconfig/serviceconfig.go",
        "kind": "type",
        "source": "// Config represents an opaque data structure holding a service config.\ntype Config interface {\n\tisServiceConfig()\n}",
        "symbol": "Config"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "serviceconfig/serviceconfig.go",
        "kind": "type",
        "source": "// LoadBalancingConfig represents an opaque data structure holding a load\n// balancing config.\ntype LoadBalancingConfig interface {\n\tisLoadBalancingConfig()\n}",
        "symbol": "LoadBalancingConfig"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "serviceconfig/serviceconfig.go",
        "source": "// ParseResult contains a service config or an error.  Exactly one must be\n// non-nil.\ntype ParseResult struct {\n\tConfig Config\n\tErr    error\n}"
      },
      "tool": "semantic_insert_type"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "serviceconfig/serviceconfig.go",
        "kind": "function",
        "symbol": "Parse"
      },
      "tool": "semantic_remove_construct"
    },
    {
      "params": {
        "add": [],
        "file": "serviceconfig/serviceconfig.go",
        "remove": [
          "google.golang.org/grpc/internal"
        ]
      },
      "tool": "semantic_organize_imports"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "xds/internal/balancer/xds.go",
        "source": "var _ balancer.V2Balancer = (*xdsBalancer)(nil) // Assert that we implement V2Balancer\n"
      },
      "tool": "semantic_insert_decl"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "xds/internal/balancer/xds.go",
        "source": "func (x *xdsBalancer) ResolverError(error) {\n\t// Ignore for now\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "xds/internal/balancer/xds.go",
        "kind": "method",
        "source": "func (x *xdsBalancer) UpdateClientConnState(s balancer.ClientConnState) error {\n\tselect {\n\tcase x.grpcUpdate \u003c- \u0026s:\n\tcase \u003c-x.ctx.Done():\n\t}\n\treturn nil\n}",
        "symbol": "xdsBalancer.UpdateClientConnState"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "body": "\n\t// The xds balancer must have been registered at this point for the service\n\t// config to be parsed properly.\n\tscpr := cc.ParseServiceConfig(jsonSC)\n\n\tif scpr.Err != nil {\n\t\tpanic(fmt.Sprintf(\"error parsing service config %q: %v\", jsonSC, scpr.Err))\n\t}\n\n\t// We return a resolver which bacically does nothing. The hard-coded service\n\t// config returned here picks the xds balancer.\n\tcc.UpdateState(resolver.State{ServiceConfig: scpr})\n\treturn \u0026xdsResolver{}, nil\n",
        "file": "xds/internal/resolver/xds_resolver.go",
        "symbol": "xdsBuilder.Build"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "xds/internal/resolver/xds_resolver.go",
        "kind": "var",
        "symbol": "parseOnce"
      },
      "tool": "semantic_remove_construct"
    },
    {
      "params": {
        "auto_organize_imports": false,
        "file": "xds/internal/resolver/xds_resolver.go",
        "kind": "var",
        "symbol": "parsedSC"
      },
      "tool": "semantic_remove_construct"
    },
    {
      "params": {
        "add": [],
        "file": "xds/internal/resolver/xds_resolver.go",
        "remove": [
          "sync",
          "google.golang.org/grpc",
          "google.golang.org/grpc/internal",
          "google.golang.org/grpc/serviceconfig"
        ]
      },
      "tool": "semantic_organize_imports"
    }
  ],
  "trust_workspace": true
}

{
  "auto_organize_imports": true,
  "edits": [
    {
      "params": {
        "file": "balancer.go",
        "in_type": "baseBalancer",
        "kind": "field",
        "placement": "type_end",
        "source": "resolverErr error // the last error reported by the resolver; cleared on successful resolution"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "file": "balancer.go",
        "in_type": "baseBalancer",
        "kind": "field",
        "placement": "type_end",
        "source": "connErr error // the last connection error; cleared upon leaving TransientFailure"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "file": "balancer.go",
        "kind": "method",
        "source": "// mergeErrors builds an error from the last connection error and the last\n// resolver error.  Must only be called if b.state is TransientFailure.\nfunc (b *baseBalancer) mergeErrors() error {\n\t// connErr must always be non-nil unless there are no SubConns, in which\n\t// case resolverErr must be non-nil.\n\tif b.connErr == nil {\n\t\treturn fmt.Errorf(\"last resolver error: %v\", b.resolverErr)\n\t}\n\tif b.resolverErr == nil {\n\t\treturn fmt.Errorf(\"last connection error: %v\", b.connErr)\n\t}\n\treturn fmt.Errorf(\"last connection error: %v; last resolver error: %v\", b.connErr, b.resolverErr)\n}"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "body": "b.resolverErr = err\nif len(b.subConns) == 0 {\n\tb.state = connectivity.TransientFailure\n}\nif b.state != connectivity.TransientFailure {\n\t// The picker will not change since the balancer does not currently\n\t// report an error.\n\treturn\n}\nb.regeneratePicker()\nif b.picker != nil {\n\tb.cc.UpdateBalancerState(b.state, b.picker)\n} else {\n\tb.cc.UpdateState(balancer.State{\n\t\tConnectivityState: b.state,\n\t\tPicker:            b.v2Picker,\n\t})\n}",
        "file": "balancer.go",
        "symbol": "baseBalancer.ResolverError"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "body": "// TODO: handle s.ResolverState.Err (log if not nil) once implemented.\n// TODO: handle s.ResolverState.ServiceConfig?\nif grpclog.V(2) {\n\tgrpclog.Infoln(\"base.baseBalancer: got new ClientConn state: \", s)\n}\nif len(s.ResolverState.Addresses) == 0 {\n\tb.ResolverError(errors.New(\"produced zero addresses\"))\n\treturn balancer.ErrBadResolverState\n}\n// Successful resolution; clear resolver error and ensure we return nil.\nb.resolverErr = nil\n// addrsSet is the set converted from addrs, it's used for quick lookup of an address.\naddrsSet := make(map[resolver.Address]struct{})\nfor _, a := range s.ResolverState.Addresses {\n\taddrsSet[a] = struct{}{}\n\tif _, ok := b.subConns[a]; !ok {\n\t\t// a is a new address (not existing in b.subConns).\n\t\tsc, err := b.cc.NewSubConn([]resolver.Address{a}, balancer.NewSubConnOptions{HealthCheckEnabled: b.config.HealthCheck})\n\t\tif err != nil {\n\t\t\tgrpclog.Warningf(\"base.baseBalancer: failed to create new SubConn: %v\", err)\n\t\t\tcontinue\n\t\t}\n\t\tb.subConns[a] = sc\n\t\tb.scStates[sc] = connectivity.Idle\n\t\tsc.Connect()\n\t}\n}\nfor a, sc := range b.subConns {\n\t// a was removed by resolver.\n\tif _, ok := addrsSet[a]; !ok {\n\t\tb.cc.RemoveSubConn(sc)\n\t\tdelete(b.subConns, a)\n\t\t// Keep the state of this sc in b.scStates until sc's state becomes Shutdown.\n\t\t// The entry will be deleted in HandleSubConnStateChange.\n\t}\n}\nreturn nil",
        "file": "balancer.go",
        "symbol": "baseBalancer.UpdateClientConnState"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "file": "balancer.go",
        "kind": "method",
        "source": "// regeneratePicker takes a snapshot of the balancer, and generates a picker\n// from it. The picker is\n//  - errPicker if the balancer is in TransientFailure,\n//  - built by the pickerBuilder with all READY SubConns otherwise.\nfunc (b *baseBalancer) regeneratePicker() {\n\tif b.state == connectivity.TransientFailure {\n\t\tif b.pickerBuilder != nil {\n\t\t\tb.picker = NewErrPicker(balancer.ErrTransientFailure)\n\t\t} else {\n\t\t\tb.v2Picker = NewErrPickerV2(balancer.TransientFailureError(b.mergeErrors()))\n\t\t}\n\t\treturn\n\t}\n\tif b.pickerBuilder != nil {\n\t\treadySCs := make(map[resolver.Address]balancer.SubConn)\n\n\t\t// Filter out all ready SCs from full subConn map.\n\t\tfor addr, sc := range b.subConns {\n\t\t\tif st, ok := b.scStates[sc]; ok \u0026\u0026 st == connectivity.Ready {\n\t\t\t\treadySCs[addr] = sc\n\t\t\t}\n\t\t}\n\t\tb.picker = b.pickerBuilder.Build(readySCs)\n\t} else {\n\t\treadySCs := make(map[balancer.SubConn]SubConnInfo)\n\n\t\t// Filter out all ready SCs from full subConn map.\n\t\tfor addr, sc := range b.subConns {\n\t\t\tif st, ok := b.scStates[sc]; ok \u0026\u0026 st == connectivity.Ready {\n\t\t\t\treadySCs[sc] = SubConnInfo{Address: addr}\n\t\t\t}\n\t\t}\n\t\tb.v2Picker = b.v2PickerBuilder.Build(PickerBuildInfo{ReadySCs: readySCs})\n\t}\n}",
        "symbol": "baseBalancer.regeneratePicker"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "body": "s := state.ConnectivityState\nif grpclog.V(2) {\n\tgrpclog.Infof(\"base.baseBalancer: handle SubConn state change: %p, %v\", sc, s)\n}\noldS, ok := b.scStates[sc]\nif !ok {\n\tif grpclog.V(2) {\n\t\tgrpclog.Infof(\"base.baseBalancer: got state changes for an unknown SubConn: %p, %v\", sc, s)\n\t}\n\treturn\n}\nb.scStates[sc] = s\nswitch s {\ncase connectivity.Idle:\n\tsc.Connect()\ncase connectivity.Shutdown:\n\t// When an address was removed by resolver, b called RemoveSubConn but\n\t// kept the sc's state in scStates. Remove state for this sc here.\n\tdelete(b.scStates, sc)\n}\n\noldAggrState := b.state\nb.state = b.csEvltr.RecordTransition(oldS, s)\n\n// Set or clear the last connection error accordingly.\nb.connErr = state.ConnectionError\n\n// Regenerate picker when one of the following happens:\n//  - this sc became ready from not-ready\n//  - this sc became not-ready from ready\n//  - the aggregated state of balancer became TransientFailure from non-TransientFailure\n//  - the aggregated state of balancer became non-TransientFailure from TransientFailure\nif (s == connectivity.Ready) != (oldS == connectivity.Ready) ||\n\t(b.state == connectivity.TransientFailure) != (oldAggrState == connectivity.TransientFailure) {\n\tb.regeneratePicker()\n}\n\nif b.picker != nil {\n\tb.cc.UpdateBalancerState(b.state, b.picker)\n} else {\n\tb.cc.UpdateState(balancer.State{ConnectivityState: b.state, Picker: b.v2Picker})\n}",
        "file": "balancer.go",
        "symbol": "baseBalancer.UpdateSubConnState"
      },
      "tool": "semantic_replace_body"
    }
  ],
  "workspace_root": "balancer/base"
}

/bin/zsh -lc "pwd && \
rg --files -g 'PROJECT_BRIEF.md' -g 'AGENTS.md' -g '*logx*' -g 'go.mod' | head -80 && \
git status --short"

/bin/zsh -lc "git status --short && \
git rev-parse HEAD && \
rg --files -g 'PROJECT_BRIEF.md' -g 'AGENTS.md' -g 'go.mod' -g 'core/logx/fields.go' -g 'core/logx/writer.go' -g 'core/logc/*.go'"

/bin/zsh -lc "rg --files | rg '("'^|/)logx|PROJECT_BRIEF|AGENTS'"\\.md' | head -120 && \
rg -n 'serviceName|WithFields|AddField|Fields\\(|logx' core logx 2>/dev/null | head -100"

{}

/bin/zsh -lc "sed -n '1,240p' core/logx/config.go && \
sed -n '1,300p' core/logx/logs.go && \
sed -n '1,220p' core/logx/fields.go && \
sed -n '1,150p' core/logx/readme-cn.md && \
rg -n 'LogConf|Mode:|ServiceName' core | head -120"

{
  "language": "go",
  "path": ".",
  "trust_workspace": true
}

/bin/zsh -lc "sed -n '300,460p' core/logx/logs.go && \
sed -n '1,240p' core/logx/richlogger.go && \
sed -n '1,180p' core/logx/lesslogger.go && \
sed -n '1,130p' core/logx/logger.go"

{
  "auto_organize_imports": true,
  "edits": [
    {
      "params": {
        "file": "core/logc/logs.go",
        "package": "logc",
        "purpose_header": "// Package logc provides context-aware logging wrappers."
      },
      "tool": "semantic_scaffold_file"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logx/fields.go",
        "source": "var globalFields atomic.Value"
      },
      "tool": "semantic_insert_decl"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logx/fields.go",
        "source": "var globalFieldsLock sync.Mutex"
      },
      "tool": "semantic_insert_decl"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logx/fields.go",
        "source": "func AddGlobalFields(fields ...LogField) {\n\tglobalFieldsLock.Lock()\n\tdefer globalFieldsLock.Unlock()\n\n\told := globalFields.Load()\n\tif old == nil {\n\t\tglobalFields.Store(append([]LogField(nil), fields...))\n\t} else {\n\t\tglobalFields.Store(append(old.([]LogField), fields...))\n\t}\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logx/writer.go",
        "source": "func combineGlobalFields(fields []LogField) []LogField {\n\tglobals := globalFields.Load()\n\tif globals == nil {\n\t\treturn fields\n\t}\n\n\treturn append(globals.([]LogField), fields...)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "body": "fields = combineGlobalFields(fields)\n\nswitch atomic.LoadUint32(\u0026encoding) {\ncase plainEncodingType:\n\twritePlainAny(writer, level, val, buildFields(fields...)...)\ndefault:\n\tentry := make(logEntry)\n\tfor _, field := range fields {\n\t\tentry[field.Key] = field.Value\n\t}\n\tentry[timestampKey] = getTimestamp()\n\tentry[levelKey] = level\n\tentry[contentKey] = val\n\twriteJson(writer, entry)\n}",
        "file": "core/logx/writer.go",
        "symbol": "output"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "access_modifier": "public",
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "kind": "type",
        "source": "type (\n\tLogConf = logx.LogConf\n\tLogField = logx.LogField\n)"
      },
      "tool": "semantic_insert_construct"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// AddGlobalFields adds global fields.\nfunc AddGlobalFields(fields ...LogField) {\n\tlogx.AddGlobalFields(fields...)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Alert alerts v in alert level, and the message is written to error log.\nfunc Alert(_ context.Context, v string) {\n\tlogx.Alert(v)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Close closes the logging.\nfunc Close() error {\n\treturn logx.Close()\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Error writes v into error log.\nfunc Error(ctx context.Context, v ...interface{}) {\n\tgetLogger(ctx).Error(v...)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Errorf writes v with format into error log.\nfunc Errorf(ctx context.Context, format string, v ...interface{}) {\n\tgetLogger(ctx).Errorf(fmt.Errorf(format, v...).Error())\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Errorv writes v into error log with json content.\n// No call stack attached, because not elegant to pack the messages.\nfunc Errorv(ctx context.Context, v interface{}) {\n\tgetLogger(ctx).Errorv(v)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Errorw writes msg along with fields into error log.\nfunc Errorw(ctx context.Context, msg string, fields ...LogField) {\n\tgetLogger(ctx).Errorw(msg, fields...)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Field returns a LogField for the given key and value.\nfunc Field(key string, value interface{}) LogField {\n\treturn logx.Field(key, value)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Info writes v into access log.\nfunc Info(ctx context.Context, v ...interface{}) {\n\tgetLogger(ctx).Info(v...)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Infof writes v with format into access log.\nfunc Infof(ctx context.Context, format string, v ...interface{}) {\n\tgetLogger(ctx).Infof(format, v...)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Infov writes v into access log with json content.\nfunc Infov(ctx context.Context, v interface{}) {\n\tgetLogger(ctx).Infov(v)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Infow writes msg along with fields into access log.\nfunc Infow(ctx context.Context, msg string, fields ...LogField) {\n\tgetLogger(ctx).Infow(msg, fields...)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Must checks if err is nil, otherwise logs the error and exits.\nfunc Must(err error) {\n\tlogx.Must(err)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// MustSetup sets up logging with given config c. It exits on error.\nfunc MustSetup(c logx.LogConf) {\n\tlogx.MustSetup(c)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// SetLevel sets the logging level. It can be used to suppress some logs.\nfunc SetLevel(level uint32) {\n\tlogx.SetLevel(level)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// SetUp sets up the logx. If already set up, just return nil.\n// we allow SetUp to be called multiple times, because for example\n// we need to allow different service frameworks to initialize logx respectively.\n// the same logic for SetUp\nfunc SetUp(c LogConf) error {\n\treturn logx.SetUp(c)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Slow writes v into slow log.\nfunc Slow(ctx context.Context, v ...interface{}) {\n\tgetLogger(ctx).Slow(v...)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Slowf writes v with format into slow log.\nfunc Slowf(ctx context.Context, format string, v ...interface{}) {\n\tgetLogger(ctx).Slowf(format, v...)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Slowv writes v into slow log with json content.\nfunc Slowv(ctx context.Context, v interface{}) {\n\tgetLogger(ctx).Slowv(v)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// Sloww writes msg along with fields into slow log.\nfunc Sloww(ctx context.Context, msg string, fields ...LogField) {\n\tgetLogger(ctx).Sloww(msg, fields...)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "auto_organize_imports": true,
        "file": "core/logc/logs.go",
        "source": "// getLogger returns the logx.Logger with the given ctx and correct caller.\nfunc getLogger(ctx context.Context) logx.Logger {\n\treturn logx.WithContext(ctx).WithCallerSkip(1)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "add": [
          "github.com/zeromicro/go-zero/core/logx"
        ],
        "file": "core/logc/logs.go"
      },
      "tool": "semantic_organize_imports"
    }
  ],
  "trust_workspace": true
}

/bin/zsh -lc "sed -n '1,160p' core/logx/writer.go && \
rg -n 'func \\(.*\\) (Info|Error|Severe|Stack|Stat)' core/logx"

/bin/zsh -lc 'git status --short && \
git diff --stat && \
git diff -- core/logx/fields.go core/logx/writer.go core/logc/logs.go'

/bin/zsh -lc "sed -n '185,235p' core/logx/writer.go && \
sed -n '1,140p' core/logx/logwriter.go"

/bin/zsh -lc "find .scratch -maxdepth 3 -type f -print; sed -n '1,240p' core/logc/logs.go"

/bin/zsh -lc "rg -n 'func output|range fields' core/logx"

/bin/zsh -lc "sed -n '259,290p' core/logx/writer.go && \
sed -n '330,380p' core/logx/writer.go"

/bin/zsh -lc 'gofmt -w core/logx/logs.go core/logx/richlogger.go && \
git diff --check && \
git diff -- core/logx/logs.go core/logx/richlogger.go core/logx/readme.md core/logx/readme-cn.md && \
git status --short'

/bin/zsh -lc "sed -n '45,120p' core/logx/logs.go && \
sed -n '130,310p' core/logx/logs.go && \
sed -n '345,450p' core/logx/logs.go && \
sed -n '115,175p' core/logx/richlogger.go && \
sed -n '200,275p' core/logx/writer.go && \
sed -n '1,110p' core/logx/logs_test.go"

/bin/zsh -lc "sed -n '370,475p' core/logx/logs.go && \
rg -n 'func writePlainAny|func writePlain' core/logx/writer.go && \
rg -n 'func Test.*(Plain|Global|ErrorStack|Severe|Alert)|SetEncoding|encoding =' core/logx/*_test.go | head -80"

/bin/zsh -lc "rg -n 'TestAddGlobalFields|func TestField' core/logx/logs_test.go && \
sed -n '105,180p' core/logx/logs_test.go"

/bin/zsh -lc "sed -n '310,340p' core/logx/writer.go"

/bin/zsh -lc 'gofmt -w core/logx/logs_test.go && \
go test ./core/logx'

/bin/zsh -lc 'git diff --check && \
git status --short && \
git diff --stat && \
git diff -- core/logx/logs_test.go core/logx/logs.go core/logx/richlogger.go'

/bin/zsh -lc "sed -n '1,90p' core/logx/fields.go && \
sed -n '1,90p' core/logx/logs.go && \
sed -n '48,75p' core/logx/logs.go && \
sed -n '345,365p' core/logx/logs.go && \
sed -n '115,145p' core/logx/richlogger.go && \
sed -n '250,285p' core/logx/writer.go && \
rg -n 'func \\(w \\*concreteWriter\\) Alert|output\\(' core/logx/writer.go"

/bin/zsh -lc 'gofmt -w core/logx/fields.go core/logx/logs.go core/logx/richlogger.go core/logx/writer.go core/logx/logs_test.go && \
git diff --check && \
git diff --stat && \
git diff -- core/logx/fields.go core/logx/logs.go core/logx/richlogger.go core/logx/writer.go core/logx/logs_test.go'

/bin/zsh -lc "rg --files core | rg '/logc|logx' | head -100 && \
rg -n 'WithCallerSkip\\(1\\)|type LogConf =|AddGlobalFields|func Errorf\\(' core"

/bin/zsh -lc "rg -n '"'^func [A-Z]'"' core/logx/logs.go core/logx/fields.go && \
sed -n '1,100p' core/logx/logger.go && \
rg -n 'logc'"

/bin/zsh -lc "gofmt -w core/logc/logs.go && \
git diff --check && \
git status --short && \
sed -n '1,240p' core/logc/logs.go"

/bin/zsh -lc "git diff --check && \
git diff --stat -- core/logc/logs.go core/logx/fields.go core/logx/writer.go && \
rg -n '"'^func '"' core/logc/logs.go"

/bin/zsh -lc "pwd && \
rg --files -g 'AGENTS.md' -g 'PROJECT_BRIEF.md' -g 'go.mod' -g '*etcd*' -g '*discov*' | head -120"

{
  "auto_organize_imports": true,
  "edits": [
    {
      "params": {
        "file": "core/discov/config.go",
        "kind": "type",
        "source": "type EtcdConf struct {\n\tHosts []string\n\tKey   string\n\tUser  string `json:\",optional\"`\n\tPass  string `json:\",optional=User\"`\n}",
        "symbol": "EtcdConf"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "body": "if len(c.Hosts) == 0 {\n\treturn errors.New(\"empty etcd hosts\")\n}\nif len(c.Key) == 0 {\n\treturn errors.New(\"empty etcd key\")\n}\nif (c.User == \"\") != (c.Pass == \"\") {\n\treturn errors.New(\"etcd user and pass must be paired\")\n}\nreturn nil",
        "file": "core/discov/config.go",
        "symbol": "EtcdConf.Validate"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "file": "core/discov/config.go",
        "source": "func (c EtcdConf) EnableAuth() bool {\n\treturn c.User != \"\" \u0026\u0026 c.Pass != \"\"\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "file": "core/discov/internal/registry.go",
        "kind": "type",
        "source": "type cluster struct {\n\tendpoints  []string\n\tuser       string\n\tpass       string\n\tkey        string\n\tvalues     map[string]map[string]string\n\tlisteners  map[string][]UpdateListener\n\twatchGroup *threading.RoutineGroup\n\tdone       chan lang.PlaceholderType\n\tlock       sync.Mutex\n}",
        "symbol": "cluster"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "file": "core/discov/internal/registry.go",
        "kind": "function",
        "source": "func DialClient(endpoints []string, user, pass string) (EtcdClient, error) {\n\treturn clientv3.New(clientv3.Config{\n\t\tEndpoints:            endpoints,\n\t\tAutoSyncInterval:     autoSyncInterval,\n\t\tDialTimeout:          DialTimeout,\n\t\tDialKeepAliveTime:    dialKeepAliveTime,\n\t\tDialKeepAliveTimeout: DialTimeout,\n\t\tRejectOldCluster:     true,\n\t\tUsername:             user,\n\t\tPassword:             pass,\n\t})\n}",
        "symbol": "DialClient"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "body": "cli, err := NewClient(c.endpoints, c.user, c.pass)\nif err != nil {\n\treturn nil, err\n}\n\ngo c.watchConnState(cli)\n\nreturn cli, nil",
        "file": "core/discov/internal/registry.go",
        "symbol": "cluster.newClient"
      },
      "tool": "semantic_replace_body"
    },
    {
      "params": {
        "file": "core/discov/internal/registry.go",
        "source": "func newClusterWithAuth(endpoints []string, user, pass string) *cluster {\n\tc := newCluster(endpoints)\n\tc.user = user\n\tc.pass = pass\n\treturn c\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "file": "core/discov/internal/registry.go",
        "source": "func (r *Registry) getClusterWithAuth(endpoints []string, user, pass string) *cluster {\n\tclusterKey := fmt.Sprintf(\"%s|%q|%q\", getClusterKey(endpoints), user, pass)\n\tr.lock.Lock()\n\tdefer r.lock.Unlock()\n\tc, ok := r.clusters[clusterKey]\n\tif !ok {\n\t\tc = newClusterWithAuth(endpoints, user, pass)\n\t\tr.clusters[clusterKey] = c\n\t}\n\treturn c\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "file": "core/discov/internal/registry.go",
        "source": "func (r *Registry) GetConnWithAuth(endpoints []string, user, pass string) (EtcdClient, error) {\n\treturn r.getClusterWithAuth(endpoints, user, pass).getClient()\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "file": "core/discov/internal/registry.go",
        "source": "func (r *Registry) MonitorWithAuth(endpoints []string, user, pass, key string, l UpdateListener) error {\n\treturn r.getClusterWithAuth(endpoints, user, pass).monitor(key, l)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "file": "core/discov/publisher.go",
        "kind": "type",
        "source": "// A Publisher can be used to publish the value to an etcd cluster on the given key.\ntype Publisher struct {\n\tendpoints  []string\n\tuser       string\n\tpass       string\n\tkey        string\n\tfullKey    string\n\tid         int64\n\tvalue      string\n\tlease      clientv3.LeaseID\n\tquit       *syncx.DoneChan\n\tpauseChan  chan lang.PlaceholderType\n\tresumeChan chan lang.PlaceholderType\n}",
        "symbol": "Publisher"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "file": "core/discov/publisher.go",
        "source": "func NewPublisherWithAuth(endpoints []string, user, pass, key, value string, opts ...PublisherOption) *Publisher {\n\tpublisher := \u0026Publisher{\n\t\tendpoints:  endpoints,\n\t\tuser:       user,\n\t\tpass:       pass,\n\t\tkey:        key,\n\t\tvalue:      value,\n\t\tquit:       syncx.NewDoneChan(),\n\t\tpauseChan:  make(chan lang.PlaceholderType),\n\t\tresumeChan: make(chan lang.PlaceholderType),\n\t}\n\tfor _, opt := range opts {\n\t\topt(publisher)\n\t}\n\treturn publisher\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "file": "core/discov/publisher.go",
        "source": "func (p *Publisher) KeepAliveWithAuth() error {\n\tcli, err := internal.GetRegistry().GetConnWithAuth(p.endpoints, p.user, p.pass)\n\tif err != nil {\n\t\treturn err\n\t}\n\tp.lease, err = p.register(cli)\n\tif err != nil {\n\t\treturn err\n\t}\n\tproc.AddWrapUpListener(func() {\n\t\tp.Stop()\n\t})\n\treturn p.keepAliveAsync(cli)\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "file": "zrpc/internal/rpcpubserver.go",
        "kind": "function",
        "source": "func NewRpcPubServer(etcdEndpoints []string, etcdKey, listenOn string, opts ...ServerOption) (Server, error) {\n\tregisterEtcd := func() error {\n\t\tpubListenOn := figureOutListenOn(listenOn)\n\t\tpubClient := discov.NewPublisher(etcdEndpoints, etcdKey, pubListenOn)\n\t\treturn pubClient.KeepAlive()\n\t}\n\treturn newKeepAliveServer(registerEtcd, listenOn, opts...), nil\n}",
        "symbol": "NewRpcPubServer"
      },
      "tool": "semantic_replace_construct"
    },
    {
      "params": {
        "file": "zrpc/internal/rpcpubserver.go",
        "source": "func NewRpcPubServerWithEtcdAuth(etcdEndpoints []string, user, pass, etcdKey, listenOn string, opts ...ServerOption) (Server, error) {\n\tregisterEtcd := func() error {\n\t\tpubListenOn := figureOutListenOn(listenOn)\n\t\tpubClient := discov.NewPublisherWithAuth(etcdEndpoints, user, pass, etcdKey, pubListenOn)\n\t\treturn pubClient.KeepAliveWithAuth()\n\t}\n\treturn newKeepAliveServer(registerEtcd, listenOn, opts...), nil\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "file": "zrpc/internal/rpcpubserver.go",
        "source": "func newKeepAliveServer(registerEtcd func() error, listenOn string, opts ...ServerOption) keepAliveServer {\n\treturn keepAliveServer{\n\t\tregisterEtcd: registerEtcd,\n\t\tServer:       NewRpcServer(listenOn, opts...),\n\t}\n}"
      },
      "tool": "semantic_insert_function"
    },
    {
      "params": {
        "file": "zrpc/server.go",
        "kind": "function",
        "source": "func NewServer(c RpcServerConf, register internal.RegisterFn) (*RpcServer, error) {\n\tvar err error\n\tif err = c.Validate(); err != nil {\n\t\treturn nil, err\n\t}\n\n\tvar server internal.Server\n\tmetrics := stat.NewMetrics(c.ListenOn)\n\tserverOptions := []internal.ServerOption{internal.WithMetrics(metrics), internal.WithMaxRetries(c.MaxRetries)}\n\n\tif c.HasEtcd() {\n\t\tif c.Etcd.EnableAuth() {\n\t\t\tserver, err = internal.NewRpcPubServerWithEtcdAuth(c.Etcd.Hosts, c.Etcd.User, c.Etcd.Pass, c.Etcd.Key, c.ListenOn, serverOptions...)\n\t\t} else {\n\t\t\tserver, err = internal.NewRpcPubServer(c.Etcd.Hosts, c.Etcd.Key, c.ListenOn, serverOptions...)\n\t\t}\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t} else {\n\t\tserver = internal.NewRpcServer(c.ListenOn, serverOptions...)\n\t}\n\n\tserver.SetName(c.Name)\n\tif err = setupInterceptors(server, c, metrics); err != nil {\n\t\treturn nil, err\n\t}\n\n\trpcServer := \u0026RpcServer{\n\t\tserver:   server,\n\t\tregister: register,\n\t}\n\tif err = c.SetUp(); err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn rpcServer, nil\n}",
        "symbol": "NewServer"
      },
      "tool": "semantic_replace_construct"
    }
  ],
  "trust_workspace": true
}

/bin/zsh -lc "rg -n \"EtcdConf|NewEtcd|etcd\\.New|Username|Password\" core zrpc | head -240 && \
git status --short"

/bin/zsh -lc "cat core/discov/config.go && \
cat core/discov/internal/etcdclient.go && \
rg -n \"Endpoints|DialTimeout|etcdclient|NewClient\" core/discov && \
sed -n '1,100p' go.mod && \
find .. -name AGENTS.md -o -name PROJECT_BRIEF.md"

/bin/zsh -lc "sed -n '200,340p' core/discov/internal/registry.go && \
rg -n \"NewRegistry|NewSubscriber|NewPublisher|NewEtcd\" core/discov | head -100 && \
rg -n \"type Config struct\" core/discov -g '*.go'"

/bin/zsh -lc "cat core/discov/clients.go; sed -n '1,130p' core/discov/publisher.go; sed -n '1,100p' core/discov/subscriber.go; rg -n \"NewPublisher|NewSubscriber\" --glob '*.go'"

/bin/zsh -lc "sed -n '1,130p' core/discov/internal/registry.go; rg -n \"EtcdConf|etcd\\.Hosts|\\.Etcd\" --glob '*.go' | head -150; cat core/discov/internal/vars.go"

/bin/zsh -lc "cat zrpc/internal/resolver/discovbuilder.go zrpc/internal/rpcpubserver.go; sed -n '1,100p' zrpc/server.go; sed -n '55,90p' zrpc/client.go"

/bin/zsh -lc "sed -n '1,110p' zrpc/config.go; sed -n '1,110p' zrpc/internal/resolver/discovbuilder_test.go; sed -n '1,100p' core/discov/internal/registry_test.go; rg -n 'func Test.*DialClient|DialClient' core/discov/internal"

/bin/zsh -lc "rg -n 'BuildDiscovTarget|DiscovScheme|EndpointSepChar' zrpc/internal"

/bin/zsh -lc "cat zrpc/internal/target.go; sed -n '1,45p' zrpc/internal/resolver/resolver.go;"

/bin/zsh -lc 'gofmt -w core/discov/config.go core/discov/internal/registry.go core/discov/internal/vars.go core/discov/publisher.go core/discov/subscriber.go zrpc/internal/target.go zrpc/internal/resolver/discovbuilder.go zrpc/internal/rpcpubserver.go zrpc/client.go zrpc/server.go && \
git diff --stat && \
git diff --check && \
go test ./core/discov/... ./zrpc/...'

/bin/zsh -lc 'gofmt -w core/discov/internal/registry.go && \
git diff --check && \
git status --short && \
git diff -- core/discov/config.go core/discov/internal/registry.go zrpc/internal/target.go'

/bin/zsh -lc 'gofmt -w core/discov/config.go core/discov/internal/registry.go core/discov/internal/vars.go zrpc/config.go && \
git diff --check && \
git diff --stat'

/bin/zsh -lc "sed -n '1,90p' core/discov/config.go; sed -n '1,100p' core/discov/internal/vars.go; sed -n '1,125p' core/discov/publisher.go; sed -n '25,110p' core/discov/internal/registry.go; sed -n '320,360p' core/discov/internal/registry.go; cat zrpc/internal/rpcpubserver.go; sed -n '35,60p' zrpc/server.go"

/bin/zsh -lc 'rg -n "NewRpcPubServerWithAuth|NewRpcPubServerWithEtcdAuth|EnableAuth|NewPublisherWithAuth|KeepAliveWithAuth"; gofmt -w core/discov/config.go core/discov/publisher.go zrpc/internal/rpcpubserver.go zrpc/server.go && \
git diff --check'

/bin/zsh -lc "sed -n '1,90p' core/discov/internal/vars.go; sed -n '45,95p' core/discov/publisher.go; sed -n '14,60p' zrpc/internal/rpcpubserver.go; sed -n '55,90p' zrpc/config.go; git diff --check; git status --short"