--- /dev/null
+// keyify transforms unkeyed struct literals into a keyed ones.
+package main
+
+import (
+ "bytes"
+ "encoding/json"
+ "flag"
+ "fmt"
+ "go/ast"
+ "go/build"
+ "go/constant"
+ "go/printer"
+ "go/token"
+ "go/types"
+ "log"
+ "os"
+ "path/filepath"
+
+ "honnef.co/go/tools/version"
+
+ "golang.org/x/tools/go/ast/astutil"
+ "golang.org/x/tools/go/buildutil"
+ "golang.org/x/tools/go/loader"
+)
+
+var (
+ fRecursive bool
+ fOneLine bool
+ fJSON bool
+ fMinify bool
+ fModified bool
+ fVersion bool
+)
+
+func init() {
+ flag.BoolVar(&fRecursive, "r", false, "keyify struct initializers recursively")
+ flag.BoolVar(&fOneLine, "o", false, "print new struct initializer on a single line")
+ flag.BoolVar(&fJSON, "json", false, "print new struct initializer as JSON")
+ flag.BoolVar(&fMinify, "m", false, "omit fields that are set to their zero value")
+ flag.BoolVar(&fModified, "modified", false, "read an archive of modified files from standard input")
+ flag.BoolVar(&fVersion, "version", false, "Print version and exit")
+}
+
+func usage() {
+ fmt.Printf("Usage: %s [flags] <position>\n\n", os.Args[0])
+ flag.PrintDefaults()
+}
+
+func main() {
+ log.SetFlags(0)
+ flag.Usage = usage
+ flag.Parse()
+
+ if fVersion {
+ version.Print()
+ os.Exit(0)
+ }
+
+ if flag.NArg() != 1 {
+ flag.Usage()
+ os.Exit(2)
+ }
+ pos := flag.Args()[0]
+ name, start, _, err := parsePos(pos)
+ if err != nil {
+ log.Fatal(err)
+ }
+ eval, err := filepath.EvalSymlinks(name)
+ if err != nil {
+ log.Fatal(err)
+ }
+ name, err = filepath.Abs(eval)
+ if err != nil {
+ log.Fatal(err)
+ }
+ cwd, err := os.Getwd()
+ if err != nil {
+ log.Fatal(err)
+ }
+ ctx := &build.Default
+ if fModified {
+ overlay, err := buildutil.ParseOverlayArchive(os.Stdin)
+ if err != nil {
+ log.Fatal(err)
+ }
+ ctx = buildutil.OverlayContext(ctx, overlay)
+ }
+ bpkg, err := buildutil.ContainingPackage(ctx, cwd, name)
+ if err != nil {
+ log.Fatal(err)
+ }
+ conf := &loader.Config{
+ Build: ctx,
+ }
+ conf.TypeCheckFuncBodies = func(s string) bool {
+ return s == bpkg.ImportPath || s == bpkg.ImportPath+"_test"
+ }
+ conf.ImportWithTests(bpkg.ImportPath)
+ lprog, err := conf.Load()
+ if err != nil {
+ log.Fatal(err)
+ }
+ var tf *token.File
+ var af *ast.File
+ var pkg *loader.PackageInfo
+outer:
+ for _, pkg = range lprog.InitialPackages() {
+ for _, ff := range pkg.Files {
+ file := lprog.Fset.File(ff.Pos())
+ if file.Name() == name {
+ af = ff
+ tf = file
+ break outer
+ }
+ }
+ }
+ if tf == nil {
+ log.Fatalf("couldn't find file %s", name)
+ }
+ tstart, tend, err := fileOffsetToPos(tf, start, start)
+ if err != nil {
+ log.Fatal(err)
+ }
+ path, _ := astutil.PathEnclosingInterval(af, tstart, tend)
+ var complit *ast.CompositeLit
+ for _, p := range path {
+ if p, ok := p.(*ast.CompositeLit); ok {
+ complit = p
+ break
+ }
+ }
+ if complit == nil {
+ log.Fatal("no composite literal found near point")
+ }
+ if len(complit.Elts) == 0 {
+ printComplit(complit, complit, lprog.Fset, lprog.Fset)
+ return
+ }
+ if _, ok := complit.Elts[0].(*ast.KeyValueExpr); ok {
+ lit := complit
+ if fOneLine {
+ lit = copyExpr(complit, 1).(*ast.CompositeLit)
+ }
+ printComplit(complit, lit, lprog.Fset, lprog.Fset)
+ return
+ }
+ _, ok := pkg.TypeOf(complit).Underlying().(*types.Struct)
+ if !ok {
+ log.Fatal("not a struct initialiser")
+ return
+ }
+
+ newComplit, lines := keyify(pkg, complit)
+ newFset := token.NewFileSet()
+ newFile := newFset.AddFile("", -1, lines)
+ for i := 1; i <= lines; i++ {
+ newFile.AddLine(i)
+ }
+ printComplit(complit, newComplit, lprog.Fset, newFset)
+}
+
+func keyify(
+ pkg *loader.PackageInfo,
+ complit *ast.CompositeLit,
+) (*ast.CompositeLit, int) {
+ var calcPos func(int) token.Pos
+ if fOneLine {
+ calcPos = func(int) token.Pos { return token.Pos(1) }
+ } else {
+ calcPos = func(i int) token.Pos { return token.Pos(2 + i) }
+ }
+
+ st, _ := pkg.TypeOf(complit).Underlying().(*types.Struct)
+ newComplit := &ast.CompositeLit{
+ Type: complit.Type,
+ Lbrace: 1,
+ Rbrace: token.Pos(st.NumFields() + 2),
+ }
+ if fOneLine {
+ newComplit.Rbrace = 1
+ }
+ numLines := 2 + st.NumFields()
+ n := 0
+ for i := 0; i < st.NumFields(); i++ {
+ field := st.Field(i)
+ val := complit.Elts[i]
+ if fRecursive {
+ if val2, ok := val.(*ast.CompositeLit); ok {
+ if _, ok := pkg.TypeOf(val2.Type).Underlying().(*types.Struct); ok {
+ // FIXME(dh): this code is obviously wrong. But
+ // what were we intending to do here?
+ var lines int
+ numLines += lines
+ //lint:ignore SA4006 See FIXME above.
+ val, lines = keyify(pkg, val2)
+ }
+ }
+ }
+ _, isIface := st.Field(i).Type().Underlying().(*types.Interface)
+ if fMinify && (isNil(val, pkg) || (!isIface && isZero(val, pkg))) {
+ continue
+ }
+ elt := &ast.KeyValueExpr{
+ Key: &ast.Ident{NamePos: calcPos(n), Name: field.Name()},
+ Value: copyExpr(val, calcPos(n)),
+ }
+ newComplit.Elts = append(newComplit.Elts, elt)
+ n++
+ }
+ return newComplit, numLines
+}
+
+func isNil(val ast.Expr, pkg *loader.PackageInfo) bool {
+ ident, ok := val.(*ast.Ident)
+ if !ok {
+ return false
+ }
+ if _, ok := pkg.ObjectOf(ident).(*types.Nil); ok {
+ return true
+ }
+ if c, ok := pkg.ObjectOf(ident).(*types.Const); ok {
+ if c.Val().Kind() != constant.Bool {
+ return false
+ }
+ return !constant.BoolVal(c.Val())
+ }
+ return false
+}
+
+func isZero(val ast.Expr, pkg *loader.PackageInfo) bool {
+ switch val := val.(type) {
+ case *ast.BasicLit:
+ switch val.Value {
+ case `""`, "``", "0", "0.0", "0i", "0.":
+ return true
+ default:
+ return false
+ }
+ case *ast.Ident:
+ return isNil(val, pkg)
+ case *ast.CompositeLit:
+ typ := pkg.TypeOf(val.Type)
+ if typ == nil {
+ return false
+ }
+ isIface := false
+ switch typ := typ.Underlying().(type) {
+ case *types.Struct:
+ case *types.Array:
+ _, isIface = typ.Elem().Underlying().(*types.Interface)
+ default:
+ return false
+ }
+ for _, elt := range val.Elts {
+ if isNil(elt, pkg) || (!isIface && !isZero(elt, pkg)) {
+ return false
+ }
+ }
+ return true
+ }
+ return false
+}
+
+func printComplit(oldlit, newlit *ast.CompositeLit, oldfset, newfset *token.FileSet) {
+ buf := &bytes.Buffer{}
+ cfg := printer.Config{Mode: printer.UseSpaces | printer.TabIndent, Tabwidth: 8}
+ _ = cfg.Fprint(buf, newfset, newlit)
+ if fJSON {
+ output := struct {
+ Start int `json:"start"`
+ End int `json:"end"`
+ Replacement string `json:"replacement"`
+ }{
+ oldfset.Position(oldlit.Pos()).Offset,
+ oldfset.Position(oldlit.End()).Offset,
+ buf.String(),
+ }
+ _ = json.NewEncoder(os.Stdout).Encode(output)
+ } else {
+ fmt.Println(buf.String())
+ }
+}
+
+func copyExpr(expr ast.Expr, line token.Pos) ast.Expr {
+ switch expr := expr.(type) {
+ case *ast.BasicLit:
+ cp := *expr
+ cp.ValuePos = 0
+ return &cp
+ case *ast.BinaryExpr:
+ cp := *expr
+ cp.X = copyExpr(cp.X, line)
+ cp.OpPos = 0
+ cp.Y = copyExpr(cp.Y, line)
+ return &cp
+ case *ast.CallExpr:
+ cp := *expr
+ cp.Fun = copyExpr(cp.Fun, line)
+ cp.Lparen = 0
+ for i, v := range cp.Args {
+ cp.Args[i] = copyExpr(v, line)
+ }
+ if cp.Ellipsis != 0 {
+ cp.Ellipsis = line
+ }
+ cp.Rparen = 0
+ return &cp
+ case *ast.CompositeLit:
+ cp := *expr
+ cp.Type = copyExpr(cp.Type, line)
+ cp.Lbrace = 0
+ for i, v := range cp.Elts {
+ cp.Elts[i] = copyExpr(v, line)
+ }
+ cp.Rbrace = 0
+ return &cp
+ case *ast.Ident:
+ cp := *expr
+ cp.NamePos = 0
+ return &cp
+ case *ast.IndexExpr:
+ cp := *expr
+ cp.X = copyExpr(cp.X, line)
+ cp.Lbrack = 0
+ cp.Index = copyExpr(cp.Index, line)
+ cp.Rbrack = 0
+ return &cp
+ case *ast.KeyValueExpr:
+ cp := *expr
+ cp.Key = copyExpr(cp.Key, line)
+ cp.Colon = 0
+ cp.Value = copyExpr(cp.Value, line)
+ return &cp
+ case *ast.ParenExpr:
+ cp := *expr
+ cp.Lparen = 0
+ cp.X = copyExpr(cp.X, line)
+ cp.Rparen = 0
+ return &cp
+ case *ast.SelectorExpr:
+ cp := *expr
+ cp.X = copyExpr(cp.X, line)
+ cp.Sel = copyExpr(cp.Sel, line).(*ast.Ident)
+ return &cp
+ case *ast.SliceExpr:
+ cp := *expr
+ cp.X = copyExpr(cp.X, line)
+ cp.Lbrack = 0
+ cp.Low = copyExpr(cp.Low, line)
+ cp.High = copyExpr(cp.High, line)
+ cp.Max = copyExpr(cp.Max, line)
+ cp.Rbrack = 0
+ return &cp
+ case *ast.StarExpr:
+ cp := *expr
+ cp.Star = 0
+ cp.X = copyExpr(cp.X, line)
+ return &cp
+ case *ast.TypeAssertExpr:
+ cp := *expr
+ cp.X = copyExpr(cp.X, line)
+ cp.Lparen = 0
+ cp.Type = copyExpr(cp.Type, line)
+ cp.Rparen = 0
+ return &cp
+ case *ast.UnaryExpr:
+ cp := *expr
+ cp.OpPos = 0
+ cp.X = copyExpr(cp.X, line)
+ return &cp
+ case *ast.MapType:
+ cp := *expr
+ cp.Map = 0
+ cp.Key = copyExpr(cp.Key, line)
+ cp.Value = copyExpr(cp.Value, line)
+ return &cp
+ case *ast.ArrayType:
+ cp := *expr
+ cp.Lbrack = 0
+ cp.Len = copyExpr(cp.Len, line)
+ cp.Elt = copyExpr(cp.Elt, line)
+ return &cp
+ case *ast.Ellipsis:
+ cp := *expr
+ cp.Elt = copyExpr(cp.Elt, line)
+ cp.Ellipsis = line
+ return &cp
+ case *ast.InterfaceType:
+ cp := *expr
+ cp.Interface = 0
+ return &cp
+ case *ast.StructType:
+ cp := *expr
+ cp.Struct = 0
+ return &cp
+ case *ast.FuncLit:
+ return expr
+ case *ast.ChanType:
+ cp := *expr
+ cp.Arrow = 0
+ cp.Begin = 0
+ cp.Value = copyExpr(cp.Value, line)
+ return &cp
+ case nil:
+ return nil
+ default:
+ panic(fmt.Sprintf("shouldn't happen: unknown ast.Expr of type %T", expr))
+ }
+}
projects / dotfiles / .git / blobdiff