gopls/internal/hover: show alias rhs type declaration on hover

This CL support to find the direct Rhs declaration for an alias type in hover.

Fixes golang/go#71286

Change-Id: Ie43a70ec52fe41510e303bb538cc170ff59020c0
Reviewed-on: https://go-review.googlesource.com/c/tools/+/644495
Auto-Submit: Robert Findley <[email protected]>
Reviewed-by: Robert Findley <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>

Author: xieyuschen

gopls/internal/golang/hover.go

@@ -138,6 +138,28 @@ func Hover(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, positi
 	}, nil
 }
 
+// findRhsTypeDecl finds an alias's rhs type and returns its declaration.
+// The rhs of an alias might be an alias as well, but we feel this is a rare case.
+// It returns an empty string if the given obj is not an alias.
+func findRhsTypeDecl(ctx context.Context, snapshot *cache.Snapshot, pkg *cache.Package, obj types.Object) (string, error) {
+	if alias, ok := obj.Type().(*types.Alias); ok {
+		// we choose Rhs instead of types.Unalias to make the connection between original alias
+		// and the corresponding aliased type clearer.
+		// types.Unalias brings confusion because it breaks the connection from A to C given
+		// the alias chain like 'type ( A = B; B =C ; )' except we show all transitive alias
+		// from start to the end. As it's rare, we don't do so.
+		t := alias.Rhs()
+		switch o := t.(type) {
+		case *types.Named:
+			obj = o.Obj()
+			declPGF1, declPos1, _ := parseFull(ctx, snapshot, pkg.FileSet(), obj.Pos())
+			realTypeDecl, _, err := typeDeclContent(declPGF1, declPos1, obj)
+			return realTypeDecl, err
+		}
+	}
+	return "", nil
+}
+
 // hover computes hover information at the given position. If we do not support
 // hovering at the position, it returns _, nil, nil: an error is only returned
 // if the position is valid but we fail to compute hover information.
@@ -404,46 +426,20 @@ func hover(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, pp pro
 	_, isTypeName := obj.(*types.TypeName)
 	_, isTypeParam := types.Unalias(obj.Type()).(*types.TypeParam)
 	if isTypeName && !isTypeParam {
-		spec, ok := spec.(*ast.TypeSpec)
-		if !ok {
-			// We cannot find a TypeSpec for this type or alias declaration
-			// (that is not a type parameter or a built-in).
-			// This should be impossible even for ill-formed trees;
-			// we suspect that AST repair may be creating inconsistent
-			// positions. Don't report a bug in that case. (#64241)
-			errorf := fmt.Errorf
-			if !declPGF.Fixed() {
-				errorf = bug.Errorf
-			}
-			return protocol.Range{}, nil, errorf("type name %q without type spec", obj.Name())
+		var spec1 *ast.TypeSpec
+		typeDecl, spec1, err = typeDeclContent(declPGF, declPos, obj)
+		if err != nil {
+			return protocol.Range{}, nil, err
 		}
 
-		// Format the type's declaration syntax.
-		{
-			// Don't duplicate comments.
-			spec2 := *spec
-			spec2.Doc = nil
-			spec2.Comment = nil
-
-			var b strings.Builder
-			b.WriteString("type ")
-			fset := tokeninternal.FileSetFor(declPGF.Tok)
-			// TODO(adonovan): use a smarter formatter that omits
-			// inaccessible fields (non-exported ones from other packages).
-			if err := format.Node(&b, fset, &spec2); err != nil {
-				return protocol.Range{}, nil, err
-			}
-			typeDecl = b.String()
-
-			// Splice in size/offset at end of first line.
-			//   "type T struct { // size=..."
-			if sizeOffset != "" {
-				nl := strings.IndexByte(typeDecl, '\n')
-				if nl < 0 {
-					nl = len(typeDecl)
-				}
-				typeDecl = typeDecl[:nl] + " // " + sizeOffset + typeDecl[nl:]
+		// Splice in size/offset at end of first line.
+		//   "type T struct { // size=..."
+		if sizeOffset != "" {
+			nl := strings.IndexByte(typeDecl, '\n')
+			if nl < 0 {
+				nl = len(typeDecl)
 			}
+			typeDecl = typeDecl[:nl] + " // " + sizeOffset + typeDecl[nl:]
 		}
 
 		// Promoted fields
@@ -478,7 +474,7 @@ func hover(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, pp pro
 		// already been displayed when the node was formatted
 		// above. Don't list these again.
 		var skip map[string]bool
-		if iface, ok := spec.Type.(*ast.InterfaceType); ok {
+		if iface, ok := spec1.Type.(*ast.InterfaceType); ok {
 			if iface.Methods.List != nil {
 				for _, m := range iface.Methods.List {
 					if len(m.Names) == 1 {
@@ -520,6 +516,12 @@ func hover(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, pp pro
 		}
 	}
 
+	// realTypeDecl is defined to store the underlying definition of an alias.
+	realTypeDecl, _ := findRhsTypeDecl(ctx, snapshot, pkg, obj) // tolerate the error
+	if realTypeDecl != "" {
+		typeDecl += fmt.Sprintf("\n\n%s", realTypeDecl)
+	}
+
 	// Compute link data (on pkg.go.dev or other documentation host).
 	//
 	// If linkPath is empty, the symbol is not linkable.
@@ -640,6 +642,39 @@ func hover(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, pp pro
 	}, nil
 }
 
+// typeDeclContent returns a well formatted type definition.
+func typeDeclContent(declPGF *parsego.File, declPos token.Pos, obj types.Object) (string, *ast.TypeSpec, error) {
+	_, spec, _ := findDeclInfo([]*ast.File{declPGF.File}, declPos) // may be nil^3
+	// Don't duplicate comments.
+	spec1, ok := spec.(*ast.TypeSpec)
+	if !ok {
+		// We cannot find a TypeSpec for this type or alias declaration
+		// (that is not a type parameter or a built-in).
+		// This should be impossible even for ill-formed trees;
+		// we suspect that AST repair may be creating inconsistent
+		// positions. Don't report a bug in that case. (#64241)
+		errorf := fmt.Errorf
+		if !declPGF.Fixed() {
+			errorf = bug.Errorf
+		}
+		return "", nil, errorf("type name %q without type spec", obj.Name())
+	}
+	spec2 := *spec1
+	spec2.Doc = nil
+	spec2.Comment = nil
+
+	var b strings.Builder
+	b.WriteString("type ")
+	fset := tokeninternal.FileSetFor(declPGF.Tok)
+	// TODO(adonovan): use a smarter formatter that omits
+	// inaccessible fields (non-exported ones from other packages).
+	if err := format.Node(&b, fset, &spec2); err != nil {
+		return "", nil, err
+	}
+	typeDecl := b.String()
+	return typeDecl, spec1, nil
+}
+
 // hoverBuiltin computes hover information when hovering over a builtin
 // identifier.
 func hoverBuiltin(ctx context.Context, snapshot *cache.Snapshot, obj types.Object) (*hoverResult, error) {

gopls/internal/test/marker/testdata/definition/embed.txt

@@ -322,6 +322,8 @@ func (a.A) Hi()
 -- @aAlias --
 ```go
 type aAlias = a.A // size=16 (0x10)
+
+type A string
 ```
 
 ---

gopls/internal/test/marker/testdata/hover/hover_alias.txt

@@ -0,0 +1,81 @@
+This test checks gopls behavior when hovering over alias type.
+
+-- flags --
+-skip_goarch=386,arm
+
+-- go.mod --
+module mod.com
+
+-- main.go --
+package main
+
+import "mod.com/a"
+import "mod.com/b"
+
+type ToTypeDecl = b.RealType //@hover("ToTypeDecl", "ToTypeDecl", ToTypeDecl)
+
+type ToAlias = a.Alias //@hover("ToAlias", "ToAlias", ToAlias)
+
+type ToAliasWithComment = a.AliasWithComment //@hover("ToAliasWithComment", "ToAliasWithComment", ToAliasWithComment)
+
+-- a/a.go --
+package a
+import "mod.com/b"
+
+type Alias = b.RealType
+
+// AliasWithComment is a type alias with comments.
+type AliasWithComment = b.RealType
+
+-- b/b.go --
+package b
+// RealType is a real type rather than an alias type.
+type RealType struct {
+	Name string
+	Age int
+}
+
+-- @ToTypeDecl --
+```go
+type ToTypeDecl = b.RealType // size=24 (0x18)
+
+type RealType struct {
+	Name string
+	Age  int
+}
+```
+
+---
+
+@hover("ToTypeDecl", "ToTypeDecl", ToTypeDecl)
+
+
+---
+
+[`main.ToTypeDecl` on pkg.go.dev](https://pkg.go.dev/mod.com#ToTypeDecl)
+-- @ToAlias --
+```go
+type ToAlias = a.Alias // size=24 (0x18)
+```
+
+---
+
+@hover("ToAlias", "ToAlias", ToAlias)
+
+
+---
+
+[`main.ToAlias` on pkg.go.dev](https://pkg.go.dev/mod.com#ToAlias)
+-- @ToAliasWithComment --
+```go
+type ToAliasWithComment = a.AliasWithComment // size=24 (0x18)
+```
+
+---
+
+@hover("ToAliasWithComment", "ToAliasWithComment", ToAliasWithComment)
+
+
+---
+
+[`main.ToAliasWithComment` on pkg.go.dev](https://pkg.go.dev/mod.com#ToAliasWithComment)