hint composite literal

a.go

package main

import (
  "fmt"
  "go/ast"
  "go/types"

  "golang.org/x/tools/go/ast/astutil"
  "golang.org/x/tools/go/packages"
)

var pt = fmt.Printf

func main() {
  pkgs, err := packages.Load(&packages.Config{
    Mode: packages.NeedSyntax |
      packages.NeedTypesInfo |
      packages.NeedTypes,
  }, ".")
  if err != nil {
    panic(err)
  }
  if packages.PrintErrors(pkgs) > 0 {
    return
  }
  pkg := pkgs[0]

  typ := pkg.Types.Scope().Lookup("Foo")
  fieldNames := make(map[string]bool)
  structType := typ.Type().(*types.Named).Underlying().(*types.Struct)
  for i := 0; i < structType.NumFields(); i++ {
    fieldNames[structType.Field(i).Name()] = true
  }

  for ident, obj := range pkg.TypesInfo.Uses {
    if obj != typ {
      continue
    }

    for _, file := range pkg.Syntax {
      path, _ := astutil.PathEnclosingInterval(file, ident.Pos(), ident.End())
      if len(path) < 2 {
        continue
      }

      cl, ok := path[1].(*ast.CompositeLit)
      if !ok {
        continue
      }

      names := make(map[string]bool)
      for _, expr := range cl.Elts {
        kv := expr.(*ast.KeyValueExpr)
        name := kv.Key.(*ast.Ident).Name
        names[name] = true
      }
      for name := range fieldNames {
        if !names[name] {
          pt("no %s at %s\n", name, pkg.Fset.Position(ident.Pos()))
        }
      }
    }
  }
}

type Foo struct {
  Bar string
}

var f1 = Foo{}

var f2 = Foo{
  Bar: "bar",
}