Add further compatibility fixes for normalizeURI (#4346)

Suggested by @emcfarlane. Follow up to #4345.

Ref: https://github.com/microsoft/vscode-uri

Author: stefanvanburen

private/buf/buflsp/uri.go

@@ -15,35 +15,57 @@
 package buflsp
 
 import (
+	"net/url"
 	"strings"
 
 	"go.lsp.dev/protocol"
 	"go.lsp.dev/uri"
 )
 
-// normalizeURI ensures that URIs are properly percent-encoded for LSP compatibility.
-//
-// The go.lsp.dev/uri package (which uses Go's net/url) follows RFC 3986 strictly and
-// allows '@' unencoded in path components. However, VS Code's LSP client uses the
-// microsoft/vscode-uri package which encodes '@' as '%40' everywhere to avoid ambiguity
-// with the authority component separator (user@host).
-//
-// Additionally, on Windows, the package also encodes ':' as '%3A' in drive letter paths
-// (e.g., 'file:///d:/path' becomes 'file:///d%3A/path').
+// FilePathToURI converts a file path to a properly encoded URI.
+func FilePathToURI(path string) protocol.URI {
+	return normalizeURI(uri.File(path))
+}
+
+// normalizeURI encodes a URI to match VS Code's microsoft/vscode-uri behavior.
 //
-// When URIs don't match exactly, LSP operations like go-to-definition fail because
-// the client's URI (with %40) doesn't match the server's URI (with @).
+// Go's net/url follows RFC 3986 and permits '@' and ':' unencoded in path
+// components (valid pchar); vscode-uri always encodes them. vscode-uri also
+// lowercases Windows drive letters. When URIs differ, LSP operations like
+// go-to-definition silently fail because the client and server URIs don't match.
 func normalizeURI(u protocol.URI) protocol.URI {
-	normalized := strings.ReplaceAll(string(u), "@", "%40")
+	str := string(u)
 
-	if after, found := strings.CutPrefix(normalized, "file:///"); found {
-		normalized = "file:///" + strings.ReplaceAll(after, ":", "%3A")
+	after, found := strings.CutPrefix(str, "file:///")
+	if !found {
+		// Non-file URIs: only encode @.
+		return protocol.URI(strings.ReplaceAll(str, "@", "%40"))
 	}
 
-	return protocol.URI(normalized)
-}
+	segments := strings.Split(after, "/")
+	for i, segment := range segments {
+		// Decode first to avoid double-encoding already-normalized URIs.
+		// PathUnescape only fails on malformed sequences (e.g. %2G); falling
+		// back to the raw segment is the best we can do.
+		decoded, err := url.PathUnescape(segment)
+		if err != nil {
+			decoded = segment
+		}
+		// PathEscape encodes spaces as %20 (not +) and most special chars,
+		// but permits '@' and ':' as RFC 3986 pchar. Encode those manually.
+		encoded := url.PathEscape(decoded)
+		encoded = strings.ReplaceAll(encoded, "@", "%40")
+		encoded = strings.ReplaceAll(encoded, ":", "%3A")
+		segments[i] = encoded
+	}
 
-// FilePathToURI converts a file path to a properly encoded URI.
-func FilePathToURI(path string) protocol.URI {
-	return normalizeURI(uri.File(path))
+	// vscode-uri lowercases Windows drive letters: C%3A → c%3A.
+	// 'A'+32 == 'a' by ASCII identity; segments[0] is e.g. "C%3A" (4 bytes).
+	if len(segments[0]) == 4 &&
+		segments[0][0] >= 'A' && segments[0][0] <= 'Z' &&
+		segments[0][1:] == "%3A" {
+		segments[0] = string(segments[0][0]+32) + "%3A"
+	}
+
+	return protocol.URI("file:///" + strings.Join(segments, "/"))
 }

private/buf/buflsp/uri_test.go

@@ -40,9 +40,9 @@ func TestNormalizeURI(t *testing.T) {
 			expected: "file:///home/user%40host/project/foo.proto",
 		},
 		{
-			name:     "windows-drive-letter-colon-encoded",
+			name:     "windows-drive-letter-uppercased-and-colon-encoded",
 			input:    "file:///C:/Users/project/foo.proto",
-			expected: "file:///C%3A/Users/project/foo.proto",
+			expected: "file:///c%3A/Users/project/foo.proto",
 		},
 		{
 			name:     "windows-lowercase-drive-letter-colon-encoded",
@@ -54,10 +54,45 @@ func TestNormalizeURI(t *testing.T) {
 			input:    "untitled:Untitled-1",
 			expected: "untitled:Untitled-1",
 		},
+		{
+			name:     "non-file-uri-at-sign-encoded",
+			input:    "untitled:user@host",
+			expected: "untitled:user%40host",
+		},
 		{
 			name:     "at-sign-and-windows-drive-letter-both-encoded",
 			input:    "file:///C:/Users/user@host/foo.proto",
-			expected: "file:///C%3A/Users/user%40host/foo.proto",
+			expected: "file:///c%3A/Users/user%40host/foo.proto",
+		},
+		{
+			name:     "space-in-path-encoded-as-percent-20",
+			input:    "file:///Users/bufbot/My Documents/foo.proto",
+			expected: "file:///Users/bufbot/My%20Documents/foo.proto",
+		},
+		{
+			name:     "already-encoded-space-is-idempotent",
+			input:    "file:///Users/bufbot/My%20Documents/foo.proto",
+			expected: "file:///Users/bufbot/My%20Documents/foo.proto",
+		},
+		{
+			name:     "already-encoded-at-sign-is-idempotent",
+			input:    "file:///home/user%40host/project/foo.proto",
+			expected: "file:///home/user%40host/project/foo.proto",
+		},
+		{
+			name:     "already-encoded-windows-drive-letter-lowercased",
+			input:    "file:///C%3A/Users/project/foo.proto",
+			expected: "file:///c%3A/Users/project/foo.proto",
+		},
+		{
+			name:     "percent-literal-in-filename-not-double-encoded",
+			input:    "file:///path/100%25done/foo.proto",
+			expected: "file:///path/100%25done/foo.proto",
+		},
+		{
+			name:     "space-at-sign-and-windows-drive-letter",
+			input:    "file:///C:/Users/user@host/My Documents/foo.proto",
+			expected: "file:///c%3A/Users/user%40host/My%20Documents/foo.proto",
 		},
 	}
 	for _, test := range tests {