internal/lsp: added a code action which generates key-value pairs of individual

fields and default values between a struct's enclosing braces

Fixes #37576

Author: luciolas

internal/lsp/code_action.go

@@ -134,6 +134,7 @@ func (s *Server) codeAction(ctx context.Context, params *protocol.CodeActionPara
 				})
 			}
 		}
+		codeActions, err = source.StructFill(ctx, params, snapshot, fh, codeActions)
 	default:
 		// Unsupported file kind for a code action.
 		return nil, nil

internal/lsp/source/completion.go

@@ -295,7 +295,7 @@ func (c *completer) getSurrounding() *Selection {
 func (c *completer) found(cand candidate) {
 	obj := cand.obj
 
-	if obj.Pkg() != nil && obj.Pkg() != c.pkg.GetTypes() && !obj.Exported() {
+	if !IsObjectExported(obj, c.pkg) {
 		// obj is not accessible because it lives in another package and is not
 		// exported. Don't treat it as a completion candidate.
 		return
@@ -728,6 +728,15 @@ func (c *completer) populateCommentCompletions(comment *ast.CommentGroup) {
 	}
 }
 
+func (c *completer) wantFillStructCompletions() bool {
+	clInfo := c.enclosingCompositeLiteral
+	if clInfo == nil {
+		return false
+	}
+
+	return clInfo.isStruct() && !(clInfo.inKey || clInfo.maybeInFieldName)
+}
+
 func (c *completer) wantStructFieldCompletions() bool {
 	clInfo := c.enclosingCompositeLiteral
 	if clInfo == nil {
@@ -1162,6 +1171,30 @@ func (c *completer) inConstDecl() bool {
 	return false
 }
 
+func generateCompletionForStructFields(snip *snippet.Builder, field *types.Var, qualifer types.Qualifier, placeholder bool) (*snippet.Builder, string) {
+	var (
+		label  = field.Name()
+		detail = typeDefaultValues(field, field.Type(), qualifer)
+		text   = "\n" + label + " : " + detail + ","
+	)
+
+	// A plain snippet turns "Foo{Ba<>" into "Foo{Bar: <>".
+	snip.WriteText("\n" + label + ": ")
+
+	// Don't write placeholders if it is not offered.
+	if placeholder {
+		snip.WritePlaceholder(func(b *snippet.Builder) {
+			// A placeholder snippet turns "Foo{Ba<>" into "Foo{Bar: <*int*>".
+			b.WriteText(detail)
+		})
+	} else {
+		snip.WriteText(detail)
+	}
+
+	snip.WriteText(",")
+	return snip, text
+}
+
 // structLiteralFieldName finds completions for struct field names inside a struct literal.
 func (c *completer) structLiteralFieldName() error {
 	clInfo := c.enclosingCompositeLiteral

internal/lsp/source/fill_struct.go

@@ -0,0 +1,137 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package source
+
+import (
+	"context"
+	"fmt"
+	"go/types"
+
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/internal/lsp/protocol"
+	"golang.org/x/tools/internal/lsp/snippet"
+)
+
+func typeDefaultValues(field *types.Var, fieldType types.Type, qff types.Qualifier) string {
+	var edit string
+	switch typ := fieldType.(type) {
+	case *types.Basic:
+		switch typ.Info() {
+		case types.IsInteger, types.IsUnsigned:
+			edit = "0"
+		case types.IsBoolean:
+			edit = "false"
+		case types.IsFloat:
+			edit = "0.0"
+		case types.IsString:
+			edit = `""`
+		}
+	case *types.Named:
+		switch underlying := typ.Underlying().(type) {
+
+		// To prevent such cases where
+		// type NameA struct{}
+		// type NameB NameA
+		// type NameC NameB
+		// we just return the field's typename.
+		case *types.Struct:
+			edit = types.TypeString(field.Type(), qff) + "{}"
+		default:
+			// get the base type of a named type recursively.
+			edit = typeDefaultValues(field, underlying, qff)
+		}
+	default:
+		edit = "nil"
+	}
+	return edit
+}
+
+func StructFill(ctx context.Context, params *protocol.CodeActionParams, snapshot Snapshot, fh FileHandle, codeActions []protocol.CodeAction) ([]protocol.CodeAction, error) {
+	rangeOfTarget := params.Range
+
+	pkg, pgh, err := getParsedFile(ctx, snapshot, fh, NarrowestPackageHandle)
+	if err != nil {
+		return codeActions, fmt.Errorf("getting file for Completion: %v", err)
+	}
+	file, _, m, _, err := pgh.Cached()
+	if err != nil {
+		return codeActions, err
+	}
+	spn, err := m.PointSpan(rangeOfTarget.Start)
+	if err != nil {
+		return codeActions, err
+	}
+	rng, err := spn.Range(m.Converter)
+	if err != nil {
+		return codeActions, err
+	}
+	path, _ := astutil.PathEnclosingInterval(file, rng.Start, rng.End)
+	if path == nil {
+		return codeActions, nil
+	}
+
+	ecl := enclosingCompositeLiteral(path, rng.Start, pkg.GetTypesInfo())
+	if ecl == nil || !ecl.isStruct() {
+		return codeActions, nil
+	}
+
+	// If in F{ Bar<> : V} or anywhere in F{Bar : V, ...}
+	// we should not fill the struct.
+	if ecl.inKey || len(ecl.cl.Elts) != 0 {
+		return codeActions, nil
+	}
+
+	// the range to replace all text  between enclosing braces {<> ... <>}
+	newMappedRange := newMappedRange(snapshot.View().Session().Cache().FileSet(), m, ecl.cl.Lbrace+1, ecl.cl.Rbrace)
+	newProtoRange, err := newMappedRange.Range()
+	if err != nil {
+		return codeActions, err
+	}
+	qfFunc := qualifier(file, pkg.GetTypes(), pkg.GetTypesInfo())
+	switch obj := ecl.clType.(type) {
+	case *types.Struct:
+
+		fieldCount := obj.NumFields()
+		if fieldCount == 0 {
+			return codeActions, nil
+		}
+		var edit, insert string
+		for i := 0; i < fieldCount; i++ {
+			field := obj.Field(i)
+			if !IsObjectExported(field, pkg) {
+				continue
+			}
+
+			// Code action does not support placeholders (?) yet
+			_, insert = generateCompletionForStructFields(&snippet.Builder{}, field, qfFunc, false)
+			edit += insert
+		}
+		edit += "\n"
+		codeActions = append(codeActions, protocol.CodeAction{
+			Title: "Fill struct",
+			Kind:  protocol.RefactorRewrite,
+			Edit: protocol.WorkspaceEdit{
+				DocumentChanges: []protocol.TextDocumentEdit{
+					{
+						TextDocument: protocol.VersionedTextDocumentIdentifier{
+							Version: fh.Identity().Version,
+							TextDocumentIdentifier: protocol.TextDocumentIdentifier{
+								URI: protocol.URIFromSpanURI(fh.Identity().URI),
+							},
+						},
+						Edits: []protocol.TextEdit{
+							{
+								Range:   newProtoRange,
+								NewText: edit,
+							},
+						},
+					},
+				},
+			},
+		})
+	}
+
+	return codeActions, nil
+}

internal/lsp/source/options.go

@@ -69,6 +69,7 @@ func DefaultOptions() Options {
 					protocol.SourceFixAll:          true,
 					protocol.SourceOrganizeImports: true,
 					protocol.QuickFix:              true,
+					protocol.RefactorRewrite:       true,
 				},
 				Mod: {
 					protocol.SourceOrganizeImports: true,

internal/lsp/source/util.go

@@ -774,3 +774,9 @@ func formatZeroValue(T types.Type, qf types.Qualifier) string {
 		return types.TypeString(T, qf) + "{}"
 	}
 }
+
+// IsObjectExported checks if an obj is accessible, or not because it lives in another package and is not
+// exported.
+func IsObjectExported(obj types.Object, targetPkg Package) bool {
+	return obj.Pkg() == nil || obj.Pkg() == targetPkg.GetTypes() || obj.Exported()
+}