Improved comments

internal/grpcutil/target.go

@@ -37,15 +37,17 @@ func split2(s, sep string) (string, string, bool) {
 }
 
 // ParseTarget splits target into a resolver.Target struct containing scheme,
-// authority and endpoint.
+// authority and endpoint. skipUnixColonParsing indicates that the parse should
+// not parse "unix:[path]" cases. This should be true in cases where a custom
+// dialer is present, to prevent a behavior change.
 //
 // If target is not a valid scheme:https://authority/endpoint, it returns {Endpoint:
 // target}.
-func ParseTarget(target string, hasDialer bool) (ret resolver.Target) {
+func ParseTarget(target string, skipUnixColonParsing bool) (ret resolver.Target) {
  var ok bool
  ret.Scheme, ret.Endpoint, ok = split2(target, ":https://")
  if !ok {
- if strings.HasPrefix(target, "unix:") && !hasDialer {
+ if strings.HasPrefix(target, "unix:") && !skipUnixColonParsing {
  // Handle the "unix:[path]" case, because splitting on :https:// only
  // handles the "unix:https://[/absolute/path]" case. Only handle if the
  // dialer is nil, to avoid a behavior change with custom dialers.

internal/grpcutil/target_test.go

@@ -86,12 +86,13 @@ func TestParseTargetString(t *testing.T) {
  if got != test.want {
  t.Errorf("ParseTarget(%q, false) = %+v, want %+v", test.targetStr, got, test.want)
  }
- if test.wantWithDialer == (resolver.Target{}) {
- test.wantWithDialer = test.want
+ wantWithDialer := test.wantWithDialer
+ if wantWithDialer == (resolver.Target{}) {
+ wantWithDialer = test.want
  }
  got = ParseTarget(test.targetStr, true)
- if got != test.wantWithDialer {
- t.Errorf("ParseTarget(%q, true) = %+v, want %+v", test.targetStr, got, test.wantWithDialer)
+ if got != wantWithDialer {
+ t.Errorf("ParseTarget(%q, true) = %+v, want %+v", test.targetStr, got, wantWithDialer)
  }
  }
 }

internal/transport/proxy.go

@@ -110,8 +110,8 @@ func doHTTPConnectHandshake(ctx context.Context, conn net.Conn, backendAddr stri
 }
 
 // proxyDial dials, connecting to a proxy first if necessary. Checks if a proxy
-// is necessary, dial to the proxy with using proxyDialer, does HTTP CONNECT
-// handshake, and returns the connection.
+// is necessary, dials, does the HTTP CONNECT handshake, and returns the
+// connection.
 func proxyDial(ctx context.Context, addr string, grpcUA string) (conn net.Conn, err error) {
  newAddr := addr
  proxyURL, err := mapAddress(ctx, addr)