Implement split/group code action

Author: fatanugraha

gopls/internal/lsp/source/fix.go

@@ -51,6 +51,8 @@ var fixers = map[settings.Fix]Fixer{
 	settings.InvertIfCondition: singleFile(invertIfCondition),
 	settings.StubMethods:       stubMethodsFixer,
 	settings.UndeclaredName:    singleFile(undeclaredname.SuggestedFix),
+	settings.SplitLines:        singleFile(splitLines),
+	settings.GroupLines:        singleFile(groupLines),
 }
 
 // A singleFileFixer is a Fixer that inspects only a single file,

gopls/internal/lsp/source/lines.go

@@ -0,0 +1,210 @@
+package source
+
+import (
+	"bytes"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"strings"
+	"unicode"
+
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/gopls/internal/util/safetoken"
+)
+
+func CanSplitLines(
+	file *ast.File,
+	fset *token.FileSet,
+	start, end token.Pos,
+) (string, bool, error) {
+	msg, lines, numElts, target := findSplitGroupTarget(file, fset, start, end)
+	if target == nil {
+		return "", false, nil
+	}
+
+	// minus two to discount the parens/brackets.
+	if lines-2 == numElts {
+		return "", false, nil
+	}
+
+	return "Split " + msg + " into separate lines", true, nil
+}
+
+func CanGroupLines(file *ast.File, fset *token.FileSet, start, end token.Pos) (string, bool, error) {
+	msg, lines, _, target := findSplitGroupTarget(file, fset, start, end)
+	if target == nil {
+		return "", false, nil
+	}
+
+	if lines == 1 {
+		return "", false, nil
+	}
+
+	return "Group " + msg + " into one line", true, nil
+}
+
+func splitLines(
+	fset *token.FileSet,
+	start token.Pos,
+	end token.Pos,
+	src []byte,
+	file *ast.File,
+	_ *types.Package,
+	_ *types.Info,
+) (*token.FileSet, *analysis.SuggestedFix, error) {
+	_, _, _, target := findSplitGroupTarget(file, fset, start, end)
+
+	// get the original line indent of target.
+	split := bytes.Split(src, []byte("\n"))
+	targetLineNumber := safetoken.StartPosition(fset, target.Pos()).Line
+	firstLine := string(split[targetLineNumber-1])
+	trimmed := strings.TrimFunc(string(firstLine), unicode.IsSpace)
+
+	firstLineIndent := firstLine[:strings.Index(firstLine, trimmed)]
+	eltIndent := firstLineIndent + "\t"
+
+	return fset, processLines(fset, target, src, file, ",\n", "\n", ",\n"+firstLineIndent, eltIndent), nil
+}
+
+func groupLines(
+	fset *token.FileSet,
+	start, end token.Pos,
+	src []byte,
+	file *ast.File,
+	_ *types.Package,
+	_ *types.Info,
+) (*token.FileSet, *analysis.SuggestedFix, error) {
+	_, _, _, target := findSplitGroupTarget(file, fset, start, end)
+	return fset, processLines(fset, target, src, file, ", ", "", "", ""), nil
+}
+
+func processLines(fset *token.FileSet, target ast.Node, src []byte, file *ast.File, sep,
+	prefix,
+	suffix, indent string,
+) *analysis.SuggestedFix {
+	var replPos, replEnd token.Pos
+	var lines []string
+
+	switch node := target.(type) {
+	case *ast.FieldList:
+		replPos, replEnd = node.Opening+1, node.Closing
+
+		for _, field := range node.List {
+			pos := safetoken.StartPosition(fset, field.Pos())
+			end := safetoken.EndPosition(fset, field.End())
+			lines = append(lines, indent+string(src[pos.Offset:end.Offset]))
+		}
+	case *ast.CallExpr:
+		replPos, replEnd = node.Lparen+1, node.Rparen
+
+		for _, arg := range node.Args {
+			pos := safetoken.StartPosition(fset, arg.Pos())
+			end := safetoken.EndPosition(fset, arg.End())
+			lines = append(lines, indent+string(src[pos.Offset:end.Offset]))
+		}
+	case *ast.CompositeLit:
+		replPos, replEnd = node.Lbrace+1, node.Rbrace
+
+		for _, arg := range node.Elts {
+			pos := safetoken.StartPosition(fset, arg.Pos())
+			end := safetoken.EndPosition(fset, arg.End())
+			lines = append(lines, indent+string(src[pos.Offset:end.Offset]))
+		}
+	}
+
+	return &analysis.SuggestedFix{
+		TextEdits: []analysis.TextEdit{{
+			Pos:     replPos,
+			End:     replEnd,
+			NewText: []byte(prefix + strings.Join(lines, sep) + suffix),
+		}},
+	}
+}
+
+func findSplitGroupTarget(
+	file *ast.File,
+	fset *token.FileSet,
+	start, end token.Pos,
+) (targetName string, numLines int, targetElts int, target ast.Node) {
+	isValidTarget := func(opening token.Pos, closing token.Pos, numElts int) bool {
+		// current cursor is inside the parens/bracket
+		isInside := opening < start && end < closing
+
+		// todo: retain /*-style comments.
+		// it doesnt have //-style comment in between
+		// we prefer not to do anything here because it will break the code once it got grouped.
+		for _, comment := range file.Comments {
+			if comment.End() < start {
+				continue
+			}
+
+			if closing < comment.Pos() {
+				break
+			}
+
+			for _, c := range comment.List {
+				if strings.HasPrefix(c.Text, "//") {
+					return false
+				}
+			}
+		}
+
+		// and it has more than 1 element
+		return isInside && numElts > 1
+	}
+
+	// find the closest enclosing parens/bracket from the cursor.
+	path, _ := astutil.PathEnclosingInterval(file, start, end)
+	for _, p := range path {
+		switch node := p.(type) {
+		// Case 1: target struct method declarations.
+		//   function (...) someMethod(a int, b int, c int) (d int, e, int) {}
+		case *ast.FuncDecl:
+			fl := node.Type.Params
+			if isValidTarget(fl.Opening, fl.Closing, len(fl.List)) {
+				return "parameters", countLines(fset, fl.Opening, fl.Closing), len(fl.List), fl
+			}
+
+			fl = node.Type.Results
+			if fl != nil && isValidTarget(fl.Opening, fl.Closing, len(fl.List)) {
+				return "return values", countLines(fset, fl.Opening, fl.Closing), len(fl.List), fl
+			}
+
+		// Case 2: target function signature args and result.
+		//   type someFunc func (a int, b int, c int) (d int, e int)
+		case *ast.FuncType:
+			fl := node.Params
+			if isValidTarget(fl.Opening, fl.Closing, len(fl.List)) {
+				return "parameters", countLines(fset, fl.Opening, fl.Closing), len(fl.List), fl
+			}
+
+			fl = node.Results
+			if fl != nil && isValidTarget(fl.Opening, fl.Closing, len(fl.List)) {
+				return "return values", countLines(fset, fl.Opening, fl.Closing), len(fl.List), fl
+			}
+
+		// Case 3: target function calls.
+		//   someFunction(a, b, c)
+		case *ast.CallExpr:
+			if isValidTarget(node.Lparen, node.Rparen, len(node.Args)) {
+				return "parameters", countLines(fset, node.Lparen, node.Rparen), len(node.Args), node
+			}
+
+		// Case 4: target composite lit instantiation (structs, maps, arrays).
+		//   A{b: 1, c: 2, d: 3}
+		case *ast.CompositeLit:
+			if isValidTarget(node.Lbrace, node.Rbrace, len(node.Elts)) {
+				return "elements", countLines(fset, node.Lbrace, node.Rbrace), len(node.Elts), node
+			}
+		}
+	}
+
+	return "", 0, 0, nil
+}
+
+func countLines(fset *token.FileSet, start, end token.Pos) int {
+	startPos := safetoken.StartPosition(fset, start)
+	endPos := safetoken.EndPosition(fset, end)
+	return endPos.Line - startPos.Line + 1
+}

gopls/internal/server/code_action.go

@@ -475,6 +475,30 @@ func refactorRewrite(snapshot *cache.Snapshot, pkg *cache.Package, pgf *source.P
 		commands = append(commands, cmd)
 	}
 
+	if msg, ok, _ := source.CanSplitLines(pgf.File, pkg.FileSet(), start, end); ok {
+		cmd, err := command.NewApplyFixCommand(msg, command.ApplyFixArgs{
+			URI:   pgf.URI,
+			Fix:   string(settings.SplitLines),
+			Range: rng,
+		})
+		if err != nil {
+			return nil, err
+		}
+		commands = append(commands, cmd)
+	}
+
+	if msg, ok, _ := source.CanGroupLines(pgf.File, pkg.FileSet(), start, end); ok {
+		cmd, err := command.NewApplyFixCommand(msg, command.ApplyFixArgs{
+			URI:   pgf.URI,
+			Fix:   string(settings.GroupLines),
+			Range: rng,
+		})
+		if err != nil {
+			return nil, err
+		}
+		commands = append(commands, cmd)
+	}
+
 	// N.B.: an inspector only pays for itself after ~5 passes, which means we're
 	// currently not getting a good deal on this inspection.
 	//

gopls/internal/settings/analyzer.go

@@ -23,6 +23,8 @@ const (
 	InlineCall        Fix = "inline_call"
 	InvertIfCondition Fix = "invert_if_condition"
 	AddEmbedImport    Fix = "add_embed_import"
+	SplitLines        Fix = "split_lines"
+	GroupLines        Fix = "group_lines"
 )
 
 // Analyzer augments a go/analysis analyzer with additional LSP configuration.