internal/lsp/source: add a new symbolStyle configuration option

Add a symbolStyle configuration option, and use it to parameterize the
following behavior when computing workspace symbols:

 + package (default): include package name in the workspace symbol.
 + full: fully qualify the symbol by import path
 + dynamic: use as the symbol the shortest suffix of the full path that
   contains the match.

To implement this, expose package name in the source.Package interface.
To be consistent with other handling in the cache package, define a new
cache.packageName named string type, to avoid confusion with packageID
or packagePath (if confusing those two identifiers was a problem, surely
it is a potential problem for package name as well).

Change-Id: Ic8ed6ba5473b0523b97e677878e5e6bddfff10a7
Reviewed-on: https://go-review.googlesource.com/c/tools/+/236842
Run-TryBot: Robert Findley <[email protected]>
TryBot-Result: Gobot Gobot <[email protected]>
Reviewed-by: Paul Jolly <[email protected]>

Author: findleyr

internal/lsp/cache/check.go

@@ -276,6 +276,7 @@ func typeCheck(ctx context.Context, fset *token.FileSet, m *metadata, mode sourc
 
 	pkg := &pkg{
 		id:              m.id,
+		name:            m.name,
 		pkgPath:         m.pkgPath,
 		mode:            mode,
 		goFiles:         goFiles,
@@ -352,7 +353,7 @@ func typeCheck(ctx context.Context, fset *token.FileSet, m *metadata, mode sourc
 	} else if len(files) == 0 { // not the unsafe package, no parsed files
 		return nil, errors.Errorf("no parsed files for package %s, expected: %s, errors: %v, list errors: %v", pkg.pkgPath, pkg.compiledGoFiles, actualErrors, rawErrors)
 	} else {
-		pkg.types = types.NewPackage(string(m.pkgPath), m.name)
+		pkg.types = types.NewPackage(string(m.pkgPath), string(m.name))
 	}
 
 	cfg := &types.Config{

internal/lsp/cache/load.go

@@ -23,7 +23,7 @@ import (
 type metadata struct {
 	id              packageID
 	pkgPath         packagePath
-	name            string
+	name            packageName
 	goFiles         []span.URI
 	compiledGoFiles []span.URI
 	forTest         packagePath
@@ -171,7 +171,7 @@ func (s *snapshot) setMetadata(ctx context.Context, pkgPath packagePath, pkg *pa
 	m := &metadata{
 		id:         id,
 		pkgPath:    pkgPath,
-		name:       pkg.Name,
+		name:       packageName(pkg.Name),
 		forTest:    packagePath(packagesinternal.GetForTest(pkg)),
 		typesSizes: pkg.TypesSizes,
 		errors:     pkg.Errors,

internal/lsp/cache/pkg.go

@@ -18,6 +18,7 @@ import (
 type pkg struct {
 	// ID and package path have their own types to avoid being used interchangeably.
 	id              packageID
+	name            packageName
 	pkgPath         packagePath
 	mode            source.ParseMode
 	forTest         packagePath
@@ -32,11 +33,15 @@ type pkg struct {
 	typesSizes      types.Sizes
 }
 
-// Declare explicit types for package paths and IDs to ensure that we never use
-// an ID where a path belongs, and vice versa. If we confused the two, it would
-// result in confusing errors because package IDs often look like package paths.
-type packageID string
-type packagePath string
+// Declare explicit types for package paths, names, and IDs to ensure that we
+// never use an ID where a path belongs, and vice versa. If we confused these,
+// it would result in confusing errors because package IDs often look like
+// package paths.
+type (
+	packageID   string
+	packagePath string
+	packageName string
+)
 
 // Declare explicit types for files and directories to distinguish between the two.
 type fileURI span.URI
@@ -47,6 +52,10 @@ func (p *pkg) ID() string {
 	return string(p.id)
 }
 
+func (p *pkg) Name() string {
+	return string(p.name)
+}
+
 func (p *pkg) PkgPath() string {
 	return string(p.pkgPath)
 }

internal/lsp/regtest/symbol_test.go

@@ -44,14 +44,14 @@ type myInterface interface { // interface
 	DoSomeCoolStuff() string // interface method
 }
 -- p/p.go --
-package main
+package p
 
 const Message = "Hello World." // constant
 `
 
 var caseSensitiveSymbolChecks = map[string]*expSymbolInformation{
 	"main": {
-		Name: pString("mod.com.main"),
+		Name: pString("main.main"),
 		Kind: pKind(protocol.Function),
 		Location: &expLocation{
 			Path: pString("main.go"),
@@ -64,7 +64,7 @@ var caseSensitiveSymbolChecks = map[string]*expSymbolInformation{
 		},
 	},
 	"Message": {
-		Name: pString("mod.com/p.Message"),
+		Name: pString("p.Message"),
 		Kind: pKind(protocol.Constant),
 		Location: &expLocation{
 			Path: pString("p/p.go"),
@@ -77,7 +77,7 @@ var caseSensitiveSymbolChecks = map[string]*expSymbolInformation{
 		},
 	},
 	"myvar": {
-		Name: pString("mod.com.myvar"),
+		Name: pString("main.myvar"),
 		Kind: pKind(protocol.Variable),
 		Location: &expLocation{
 			Path: pString("main.go"),
@@ -90,7 +90,7 @@ var caseSensitiveSymbolChecks = map[string]*expSymbolInformation{
 		},
 	},
 	"myType": {
-		Name: pString("mod.com.myType"),
+		Name: pString("main.myType"),
 		Kind: pKind(protocol.String),
 		Location: &expLocation{
 			Path: pString("main.go"),
@@ -103,7 +103,7 @@ var caseSensitiveSymbolChecks = map[string]*expSymbolInformation{
 		},
 	},
 	"Blahblah": {
-		Name: pString("mod.com.myType.Blahblah"),
+		Name: pString("main.myType.Blahblah"),
 		Kind: pKind(protocol.Method),
 		Location: &expLocation{
 			Path: pString("main.go"),
@@ -116,11 +116,11 @@ var caseSensitiveSymbolChecks = map[string]*expSymbolInformation{
 		},
 	},
 	"NewEncoder": {
-		Name: pString("encoding/json.NewEncoder"),
+		Name: pString("json.NewEncoder"),
 		Kind: pKind(protocol.Function),
 	},
 	"myStruct": {
-		Name: pString("mod.com.myStruct"),
+		Name: pString("main.myStruct"),
 		Kind: pKind(protocol.Struct),
 		Location: &expLocation{
 			Path: pString("main.go"),
@@ -134,7 +134,7 @@ var caseSensitiveSymbolChecks = map[string]*expSymbolInformation{
 	},
 	// TODO: not sure we should be returning struct fields
 	"myStructField": {
-		Name: pString("mod.com.myStruct.myStructField"),
+		Name: pString("main.myStruct.myStructField"),
 		Kind: pKind(protocol.Field),
 		Location: &expLocation{
 			Path: pString("main.go"),
@@ -147,7 +147,7 @@ var caseSensitiveSymbolChecks = map[string]*expSymbolInformation{
 		},
 	},
 	"myInterface": {
-		Name: pString("mod.com.myInterface"),
+		Name: pString("main.myInterface"),
 		Kind: pKind(protocol.Interface),
 		Location: &expLocation{
 			Path: pString("main.go"),
@@ -161,7 +161,7 @@ var caseSensitiveSymbolChecks = map[string]*expSymbolInformation{
 	},
 	// TODO: not sure we should be returning interface methods
 	"DoSomeCoolStuff": {
-		Name: pString("mod.com.myInterface.DoSomeCoolStuff"),
+		Name: pString("main.myInterface.DoSomeCoolStuff"),
 		Kind: pKind(protocol.Method),
 		Location: &expLocation{
 			Path: pString("main.go"),
@@ -180,7 +180,7 @@ var caseInsensitiveSymbolChecks = map[string]*expSymbolInformation{
 }
 
 var fuzzySymbolChecks = map[string]*expSymbolInformation{
-	"mod.Mn": caseSensitiveSymbolChecks["main"],
+	"Mn": caseSensitiveSymbolChecks["main"],
 }
 
 // TestSymbolPos tests that, at a basic level, we get the correct position
@@ -202,7 +202,7 @@ func checkChecks(t *testing.T, matcher string, checks map[string]*expSymbolInfor
 				t.Run(query, func(t *testing.T) {
 					res := env.Symbol(query)
 					if !exp.matchAgainst(res) {
-						t.Fatalf("failed to find a match against query %q for %v", query, exp)
+						t.Fatalf("failed to find a match against query %q for %v,\ngot: %v", query, exp, res)
 					}
 				})
 			}

internal/lsp/source/options.go

@@ -215,6 +215,10 @@ type UserOptions struct {
 	// SymbolMatcher specifies the type of matcher to use for symbol requests.
 	SymbolMatcher SymbolMatcher
 
+	// SymbolStyle specifies what style of symbols to return in symbol requests
+	// (package qualified, fully qualified, etc).
+	SymbolStyle SymbolStyle
+
 	// DeepCompletion allows completion to perform nested searches through
 	// possible candidates.
 	DeepCompletion bool
@@ -303,6 +307,14 @@ const (
 	SymbolCaseSensitive
 )
 
+type SymbolStyle int
+
+const (
+	PackageQualifiedSymbols = SymbolStyle(iota)
+	FullyQualifiedSymbols
+	DynamicSymbols
+)
+
 type HoverKind int
 
 const (
@@ -449,6 +461,20 @@ func (o *Options) set(name string, value interface{}) OptionResult {
 			o.SymbolMatcher = SymbolCaseInsensitive
 		}
 
+	case "symbolStyle":
+		style, ok := result.asString()
+		if !ok {
+			break
+		}
+		switch style {
+		case "full":
+			o.SymbolStyle = FullyQualifiedSymbols
+		case "dynamic":
+			o.SymbolStyle = DynamicSymbols
+		default:
+			o.SymbolStyle = PackageQualifiedSymbols
+		}
+
 	case "hoverKind":
 		hoverKind, ok := result.asString()
 		if !ok {

internal/lsp/source/source_test.go

@@ -817,7 +817,7 @@ func (r *runner) CaseSensitiveWorkspaceSymbols(t *testing.T, query string, expec
 
 func (r *runner) callWorkspaceSymbols(t *testing.T, query string, matcher source.SymbolMatcher, dirs map[string]struct{}, expectedSymbols []protocol.SymbolInformation) {
 	t.Helper()
-	got, err := source.WorkspaceSymbols(r.ctx, matcher, []source.View{r.view}, query)
+	got, err := source.WorkspaceSymbols(r.ctx, matcher, source.PackageQualifiedSymbols, []source.View{r.view}, query)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/lsp/source/view.go

@@ -440,6 +440,7 @@ func (a Analyzer) Enabled(snapshot Snapshot) bool {
 // only the relevant fields of a *go/packages.Package.
 type Package interface {
 	ID() string
+	Name() string
 	PkgPath() string
 	CompiledGoFiles() []ParseGoHandle
 	File(uri span.URI) (ParseGoHandle, error)