Reimplement /go/ links without the Go langserver (#1197)

Author: chrismwendt

cmd/frontend/internal/app/go_symbol_url.go

@@ -1,15 +1,27 @@
 package app
 
 import (
+	"context"
 	"errors"
 	"fmt"
+	"go/ast"
+	"go/build"
+	"go/doc"
+	"go/token"
 	"net/http"
 	"net/url"
 	"path"
 	"strings"
 
-	"github.com/sourcegraph/go-lsp/lspext"
+	"github.com/sourcegraph/ctxvfs"
+	"github.com/sourcegraph/sourcegraph/pkg/vfsutil"
+	"golang.org/x/tools/go/buildutil"
+
+	"github.com/sourcegraph/go-lsp"
+
+	"github.com/hashicorp/go-multierror"
 	"github.com/sourcegraph/sourcegraph/cmd/frontend/backend"
+	"github.com/sourcegraph/sourcegraph/cmd/frontend/internal/app/pkg/golangserverutil"
 	"github.com/sourcegraph/sourcegraph/pkg/api"
 	"github.com/sourcegraph/sourcegraph/pkg/errcode"
 	"github.com/sourcegraph/sourcegraph/pkg/gituri"
@@ -37,7 +49,27 @@ func serveGoSymbolURL(w http.ResponseWriter, r *http.Request) error {
 		}
 	}
 
+	//                                                        def
+	//                                                    vvvvvvvvvvvv
+	// http://sourcegraph.com/go/github.com/gorilla/mux/-/Router/Match
+	//                           ^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^ ^^^^^
+	//                                 importPath      receiver? symbolname
 	importPath := strings.Split(symbolID, "/-/")[0]
+	def := strings.Split(symbolID, "/-/")[1]
+	var symbolName string
+	var receiver *string
+	symbolComponents := strings.Split(def, "/")
+	switch len(symbolComponents) {
+	case 1:
+		symbolName = symbolComponents[0]
+	case 2:
+		// This is a method call.
+		receiver = &symbolComponents[0]
+		symbolName = symbolComponents[1]
+	default:
+		return fmt.Errorf("invalid def %s (must have 1 or 2 path components)", def)
+	}
+
 	dir, err := gosrc.ResolveImportPath(httputil.CachingClient, importPath)
 	if err != nil {
 		return err
@@ -62,30 +94,150 @@ func serveGoSymbolURL(w http.ResponseWriter, r *http.Request) error {
 		return err
 	}
 
-	symbols, err := backend.Symbols.List(r.Context(), repo.Name, commitID, mode, lspext.WorkspaceSymbolParams{
-		Symbol: lspext.SymbolDescriptor{"id": symbolID},
-	})
+	vfs, err := repoVFS(r.Context(), repoName, commitID)
 	if err != nil {
 		return err
 	}
 
-	if len(symbols) > 0 {
-		symbol := symbols[0]
-		uri, err := gituri.Parse(string(symbol.Location.URI))
-		if err != nil {
-			return err
+	location, err := symbolLocation(r.Context(), vfs, commitID, importPath, path.Join("/", dir.RepoPrefix, strings.TrimPrefix(dir.ImportPath, string(dir.ProjectRoot))), receiver, symbolName)
+	if err != nil {
+		return err
+	}
+	if location == nil {
+		return &errcode.HTTPErr{
+			Status: http.StatusNotFound,
+			Err:    errors.New("symbol not found"),
 		}
-		filePath := uri.Fragment
-		dest := &url.URL{
-			Path:     "/" + path.Join(string(repo.Name), "-/blob", filePath),
-			Fragment: fmt.Sprintf("L%d:%d$references", symbol.Location.Range.Start.Line+1, symbol.Location.Range.Start.Character+1),
+	}
+
+	uri, err := gituri.Parse(string(location.URI))
+	if err != nil {
+		return err
+	}
+	filePath := uri.Fragment
+	dest := &url.URL{
+		Path:     "/" + path.Join(string(repo.Name), "-/blob", filePath),
+		Fragment: fmt.Sprintf("L%d:%d$references", location.Range.Start.Line+1, location.Range.Start.Character+1),
+	}
+	http.Redirect(w, r, dest.String(), http.StatusFound)
+	return nil
+}
+
+func symbolLocation(ctx context.Context, vfs ctxvfs.FileSystem, commitID api.CommitID, importPath string, path string, receiver *string, symbol string) (*lsp.Location, error) {
+	bctx := buildContextFromVFS(ctx, vfs)
+
+	fileSet := token.NewFileSet()
+	pkg, err := parseFiles(fileSet, &bctx, importPath, path)
+	if err != nil {
+		return nil, err
+	}
+
+	pos := (func() *token.Pos {
+		docPackage := doc.New(pkg, importPath, doc.AllDecls)
+		for _, docConst := range docPackage.Consts {
+			for _, spec := range docConst.Decl.Specs {
+				if valueSpec, ok := spec.(*ast.ValueSpec); ok {
+					for _, ident := range valueSpec.Names {
+						if ident.Name == symbol {
+							return &ident.NamePos
+						}
+					}
+				}
+			}
+		}
+		for _, docType := range docPackage.Types {
+			if receiver != nil && docType.Name == *receiver {
+				for _, method := range docType.Methods {
+					if method.Name == symbol {
+						return &method.Decl.Name.NamePos
+					}
+				}
+			}
+			for _, fun := range docType.Funcs {
+				if fun.Name == symbol {
+					return &fun.Decl.Name.NamePos
+				}
+			}
+			for _, spec := range docType.Decl.Specs {
+				if typeSpec, ok := spec.(*ast.TypeSpec); ok && typeSpec.Name.Name == symbol {
+					return &typeSpec.Name.NamePos
+				}
+			}
+		}
+		for _, docVar := range docPackage.Vars {
+			for _, spec := range docVar.Decl.Specs {
+				if valueSpec, ok := spec.(*ast.ValueSpec); ok {
+					for _, ident := range valueSpec.Names {
+						if ident.Name == symbol {
+							return &ident.NamePos
+						}
+					}
+				}
+			}
+		}
+		for _, docFunc := range docPackage.Funcs {
+			if docFunc.Name == symbol {
+				return &docFunc.Decl.Name.NamePos
+			}
 		}
-		http.Redirect(w, r, dest.String(), http.StatusFound)
 		return nil
+	})()
+
+	if pos == nil {
+		return nil, nil
+	}
+
+	position := fileSet.Position(*pos)
+	location := lsp.Location{
+		URI: lsp.DocumentURI("https://" + string(importPath) + "?" + string(commitID) + "#" + position.Filename),
+		Range: lsp.Range{
+			Start: lsp.Position{
+				Line:      position.Line - 1,
+				Character: position.Column - 1,
+			},
+			End: lsp.Position{
+				Line:      position.Line - 1,
+				Character: position.Column - 1,
+			},
+		},
+	}
+
+	return &location, nil
+}
+
+func buildContextFromVFS(ctx context.Context, vfs ctxvfs.FileSystem) build.Context {
+	bctx := build.Default
+	golangserverutil.PrepareContext(&bctx, ctx, vfs)
+	return bctx
+}
+
+func repoVFS(ctx context.Context, name api.RepoName, rev api.CommitID) (ctxvfs.FileSystem, error) {
+	if strings.HasPrefix(string(name), "github.com/") {
+		return vfsutil.NewGitHubRepoVFS(string(name), string(rev))
+	}
+
+	// Fall back to a full git clone for non-github.com repos.
+	return nil, fmt.Errorf("unable to fetch repo %s (only github.com repos are supported)", name)
+}
+
+func parseFiles(fset *token.FileSet, bctx *build.Context, importPath, srcDir string) (*ast.Package, error) {
+	bpkg, err := bctx.ImportDir(srcDir, 0)
+	if err != nil {
+		return nil, err
 	}
 
-	return &errcode.HTTPErr{
-		Status: http.StatusNotFound,
-		Err:    errors.New("symbol not found"),
+	pkg := &ast.Package{
+		Files: map[string]*ast.File{},
 	}
+	var errs error
+	for _, file := range append(bpkg.GoFiles, bpkg.TestGoFiles...) {
+		if src, err := buildutil.ParseFile(fset, bctx, nil, buildutil.JoinPath(bctx, srcDir), file, 0); err == nil {
+			pkg.Name = src.Name.Name
+			pkg.Files[file] = src
+		} else {
+			errs = multierror.Append(errs, err)
+		}
+	}
+
+	return pkg, errs
 }

cmd/frontend/internal/app/go_symbol_url_test.go

@@ -0,0 +1,138 @@
+package app
+
+import (
+	"context"
+	"testing"
+
+	"github.com/sourcegraph/ctxvfs"
+	"github.com/sourcegraph/go-langserver/pkg/lsp"
+	"github.com/sourcegraph/sourcegraph/pkg/api"
+)
+
+type symbolLocationArgs struct {
+	vfs        map[string]string
+	commitID   api.CommitID
+	importPath string
+	path       string
+	receiver   *string
+	symbol     string
+}
+
+type test struct {
+	args symbolLocationArgs
+	want *lsp.Location
+}
+
+func mkLocation(uri string, line int, character int) *lsp.Location {
+	return &lsp.Location{
+		URI: "https://github.com/gorilla/mux?deadbeefdeadbeefdeadbeefdeadbeefdeadbeef#/mux.go",
+		Range: lsp.Range{
+			Start: lsp.Position{
+				Line:      line,
+				Character: character,
+			},
+			End: lsp.Position{
+				Line:      line,
+				Character: character,
+			},
+		},
+	}
+}
+
+func strptr(s string) *string {
+	return &s
+}
+
+func TestSymbolLocation(t *testing.T) {
+	vfs := map[string]string{
+		"mux.go": "package mux\nconst Foo = 5\ntype Bar int\nfunc (b Bar) Quux() {}\nvar Floop = 6",
+	}
+
+	tests := []test{
+		test{
+			args: symbolLocationArgs{
+				vfs:        vfs,
+				commitID:   "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+				importPath: "github.com/gorilla/mux",
+				path:       "/",
+				receiver:   nil,
+				symbol:     "NonexistentSymbol",
+			},
+			want: nil,
+		},
+		test{
+			args: symbolLocationArgs{
+				vfs:        vfs,
+				commitID:   "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+				importPath: "github.com/gorilla/mux",
+				path:       "/",
+				receiver:   nil,
+				symbol:     "Foo",
+			},
+			want: mkLocation("https://github.com/gorilla/mux?deadbeefdeadbeefdeadbeefdeadbeefdeadbeef#mux.go", 1, 6),
+		},
+		test{
+			args: symbolLocationArgs{
+				vfs:        vfs,
+				commitID:   "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+				importPath: "github.com/gorilla/mux",
+				path:       "/",
+				receiver:   nil,
+				symbol:     "Bar",
+			},
+			want: mkLocation("https://github.com/gorilla/mux?deadbeefdeadbeefdeadbeefdeadbeefdeadbeef#mux.go", 2, 5),
+		},
+		test{
+			args: symbolLocationArgs{
+				vfs:        vfs,
+				commitID:   "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+				importPath: "github.com/gorilla/mux",
+				path:       "/",
+				receiver:   strptr("Bar"),
+				symbol:     "Quux",
+			},
+			want: mkLocation("https://github.com/gorilla/mux?deadbeefdeadbeefdeadbeefdeadbeefdeadbeef#mux.go", 3, 13),
+		},
+		test{
+			args: symbolLocationArgs{
+				vfs:        vfs,
+				commitID:   "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+				importPath: "github.com/gorilla/mux",
+				path:       "/",
+				receiver:   nil,
+				symbol:     "Floop",
+			},
+			want: mkLocation("https://github.com/gorilla/mux?deadbeefdeadbeefdeadbeefdeadbeefdeadbeef#mux.go", 4, 4),
+		},
+	}
+	for i, test := range tests {
+		got, _ := symbolLocation(context.Background(), mapFS(test.args.vfs), test.args.commitID, test.args.importPath, test.args.path, test.args.receiver, test.args.symbol)
+		if got != test.want && (got == nil || test.want == nil || *got != *test.want) {
+			t.Errorf("Test #%d:\ngot  %#v\nwant %#v", i, got, test.want)
+		}
+	}
+}
+
+// mapFS lets us easily instantiate a VFS with a map[string]string
+// (which is less noisy than map[string][]byte in test fixtures).
+func mapFS(m map[string]string) *stringMapFS {
+	m2 := make(map[string][]byte, len(m))
+	filenames := make([]string, 0, len(m))
+	for k, v := range m {
+		m2[k] = []byte(v)
+		filenames = append(filenames, k)
+	}
+	return &stringMapFS{
+		FileSystem: ctxvfs.Map(m2),
+		filenames:  filenames,
+	}
+}
+
+type stringMapFS struct {
+	ctxvfs.FileSystem
+	filenames []string
+}
+
+func (fs *stringMapFS) ListAllFiles(ctx context.Context) ([]string, error) {
+	return fs.filenames, nil
+}