gopls: semantic tokens should report modifiers for the top-level type constructor of each symbol

These new semantic type modifiers will report in type definition, type
embedding, type alias, variable definition like `var foo Bar`'s `Bar',
parameter type and return type

Author: xzbdmw

gopls/doc/semantictokens.md

@@ -72,9 +72,14 @@ The references to *object* refer to the
 1. __`keyword`__ All Go [keywords](https://golang.org/ref/spec#Keywords) are marked `keyword`.
 1. __`namespace`__ All package names are marked `namespace`. In an import, if there is an
 alias, it would be marked. Otherwise the last component of the import path is marked.
-1. __`type`__ Objects of type ```types.TypeName``` are marked `type`.
-If they are also ```types.Basic```
+1. __`type`__ Objects of type ```types.TypeName``` are marked `type`, it also reports
+various top-level type constructor modifiers.
+If they are ```types.Basic```
 the modifier is `defaultLibrary`. (And in ```type B struct{C}```, ```B``` has modifier `definition`.)
+If they are ```types.Interface```
+the modifier is `interface`,
+same as `struct`, `signature`, `pointer`, `array`, `map`, `slice`, `chan`,
+together with `interface`, they are the 8 additional modifiers gopls supports.
 1. __`parameter`__ The formal arguments in ```ast.FuncDecl``` and ```ast.FuncType``` nodes are marked `parameter`.
 1. __`variable`__  Identifiers in the
 scope of ```const``` are modified with `readonly`. ```nil``` is usually a `variable` modified with both
@@ -121,4 +126,4 @@ While a file is being edited it may temporarily contain either
 parsing errors or type errors. In this case gopls cannot determine some (or maybe any)
 of the semantic tokens. To avoid weird flickering it is the responsibility
 of clients to maintain the semantic token information
-in the unedited part of the file, and they do.
+in the unedited part of the file, and they do.

gopls/internal/golang/semtok.go

@@ -210,18 +210,18 @@ func (tv *tokenVisitor) comment(c *ast.Comment, importByName map[string]*types.P
 		}
 	}
 
-	tokenTypeByObject := func(obj types.Object) semtok.TokenType {
+	tokenTypeByObject := func(obj types.Object) (semtok.TokenType, []string) {
 		switch obj.(type) {
 		case *types.PkgName:
-			return semtok.TokNamespace
+			return semtok.TokNamespace, nil
 		case *types.Func:
-			return semtok.TokFunction
+			return semtok.TokFunction, nil
 		case *types.TypeName:
-			return semtok.TokType
+			return underlineType(obj)
 		case *types.Const, *types.Var:
-			return semtok.TokVariable
+			return semtok.TokVariable, nil
 		default:
-			return semtok.TokComment
+			return semtok.TokComment, nil
 		}
 	}
 
@@ -244,7 +244,8 @@ func (tv *tokenVisitor) comment(c *ast.Comment, importByName map[string]*types.P
 					}
 					id, rest, _ := strings.Cut(name, ".")
 					name = rest
-					tv.token(offset, len(id), tokenTypeByObject(obj), nil)
+					tok, mods := tokenTypeByObject(obj)
+					tv.token(offset, len(id), tok, mods)
 					offset += token.Pos(len(id))
 				}
 				last = idx[3]
@@ -483,6 +484,31 @@ func (tv *tokenVisitor) inspect(n ast.Node) (descend bool) {
 	return true
 }
 
+func underlineType(obj types.Object) (semtok.TokenType, []string) {
+	switch obj.Type().Underlying().(type) {
+	case *types.Interface:
+		return semtok.TokType, []string{"interface"}
+	case *types.Struct:
+		return semtok.TokType, []string{"struct"}
+	case *types.Signature:
+		return semtok.TokType, []string{"signature"}
+	case *types.Pointer:
+		return semtok.TokType, []string{"pointer"}
+	case *types.Array:
+		return semtok.TokType, []string{"array"}
+	case *types.Map:
+		return semtok.TokType, []string{"map"}
+	case *types.Slice:
+		return semtok.TokType, []string{"slice"}
+	case *types.Chan:
+		return semtok.TokType, []string{"chan"}
+	case *types.Basic:
+		return semtok.TokType, []string{"defaultLibrary"}
+	default:
+		return semtok.TokType, nil
+	}
+}
+
 func (tv *tokenVisitor) ident(id *ast.Ident) {
 	var obj types.Object
 
@@ -535,10 +561,9 @@ func (tv *tokenVisitor) ident(id *ast.Ident) {
 	case *types.TypeName: // could be a TypeParam
 		if is[*types.TypeParam](aliases.Unalias(obj.Type())) {
 			emit(semtok.TokTypeParam)
-		} else if is[*types.Basic](obj.Type()) {
-			emit(semtok.TokType, "defaultLibrary")
 		} else {
-			emit(semtok.TokType)
+			tok, mods := underlineType(obj)
+			emit(tok, mods...)
 		}
 	case *types.Var:
 		if is[*types.Signature](aliases.Unalias(obj.Type())) {
@@ -795,11 +820,15 @@ func (tv *tokenVisitor) definitionFor(id *ast.Ident, obj types.Object) (semtok.T
 			if fld, ok := fldm.(*ast.Field); ok {
 				// if len(fld.names) == 0 this is a semtok.TokType, being used
 				if len(fld.Names) == 0 {
-					return semtok.TokType, nil
+					tok, mods := underlineType(obj)
+					modifiers = append(modifiers, mods...)
+					return tok, modifiers
 				}
 				return semtok.TokVariable, modifiers
 			}
-			return semtok.TokType, modifiers
+			tok, mods := underlineType(obj)
+			modifiers = append(modifiers, mods...)
+			return tok, modifiers
 		}
 	}
 	// can't happen

gopls/internal/protocol/semantic.go

@@ -52,5 +52,6 @@ var (
 	semanticModifiers = [...]string{
 		"declaration", "definition", "readonly", "static",
 		"deprecated", "abstract", "async", "modification", "documentation", "defaultLibrary",
+		"interface", "struct", "signature", "pointer", "array", "map", "slice", "chan",
 	}
 )

gopls/internal/test/integration/fake/editor.go

@@ -353,6 +353,8 @@ func clientCapabilities(cfg EditorConfig) (protocol.ClientCapabilities, error) {
 	capabilities.TextDocument.SemanticTokens.TokenModifiers = []string{
 		"declaration", "definition", "readonly", "static",
 		"deprecated", "abstract", "async", "modification", "documentation", "defaultLibrary",
+		// Additional modifiers supported by this client:
+		"interface", "struct", "signature", "pointer", "array", "map", "slice", "chan",
 	}
 	// The LSP tests have historically enabled this flag,
 	// but really we should test both ways for older editors.