internal/lsp: generate boilerplate stubs for type Server

go generate server.go generates server_gen.go which contains 44 boilerplate
stubs implementing the LSP protocol. The Server methods are defined
in protocol/tsserver.go and implemented in the lsp package. server_gen.go
ties the two together.

The generator is in helper/helper.go, and described in helper/README.md.

Change-Id: I120bc658e55a91ec5b07c0c0cf8c188882f0be66
Reviewed-on: https://go-review.googlesource.com/c/tools/+/215979
Run-TryBot: Peter Weinberger <[email protected]>
TryBot-Result: Gobot Gobot <[email protected]>
Reviewed-by: Rebecca Stambler <[email protected]>

Author: pjweinbgo

internal/lsp/helper/README.md

@@ -0,0 +1,33 @@
+# Generate server_gen.go
+
+`helper` generates boilerplate code for server.go by processing the
+generated code in `protocol/tsserver.go`.
+
+First, build `helper` in this directore (`go build .`).
+
+In directory `lsp`, executing `go generate server.go` generates the stylized file
+`server_gen.go` that contains stubs for type `Server`.
+
+It decides what stubs are needed and their signatures
+by looking at the `Server` interface (`-t` flag). These all look somewhat like
+`Resolve(context.Context, *CompletionItem) (*CompletionItem, error)`.
+
+It then parses the `lsp` directory (`-u` flag) to see if there is a corresponding
+implementation function (which in this case would be named `resolve`). If so
+it discovers the parameter names needed, and generates (in `server_gen.go`) code
+like
+
+``` go
+func (s *Server) resolve(ctx context.Context, params *protocol.CompletionItem) (*protocol.CompletionItem, error) {
+    return s.resolve(ctx, params)
+}
+```
+
+If `resolve` is not defined (and it is not), then the body of the generated function is
+
+```go
+    return nil, notImplemented("resolve")
+```
+
+So to add a capability currently not implemented, just define it somewhere in `lsp`.
+In this case, just define `func (s *Server) resolve(...)` and re-generate `server_gen.go`.

internal/lsp/helper/helper.go

@@ -0,0 +1,244 @@
+// Invoke with //go:generate helper/helper -t Server -d protocol/tsserver.go -u lsp -o server_gen.go
+// invoke in internal/lsp
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"log"
+	"os"
+	"sort"
+	"strings"
+	"text/template"
+)
+
+var (
+	typ = flag.String("t", "Server", "generate code for this type")
+	def = flag.String("d", "", "the file the type is defined in") // this relies on punning
+	use = flag.String("u", "", "look for uses in this package")
+	out = flag.String("o", "", "where to write the generated file")
+)
+
+func main() {
+	log.SetFlags(log.Lshortfile)
+	flag.Parse()
+	if *typ == "" || *def == "" || *use == "" || *out == "" {
+		flag.PrintDefaults()
+		return
+	}
+	// read the type definition and see what methods we're looking for
+	doTypes()
+
+	// parse the package and see which methods are defined
+	doUses()
+
+	output()
+}
+
+// replace "\\\n" with nothing before using
+var tmpl = `
+package lsp
+
+// code generated by helper. DO NOT EDIT.
+
+import (
+	"context"
+
+	"golang.org/x/tools/internal/lsp/protocol"
+)
+
+{{range $key, $v := .Stuff}}
+func (s *{{$.Type}}) {{$v.Name}}({{.Param}}) {{.Result}} {
+	{{if ne .Found ""}} return s.{{.Internal}}({{.Invoke}})\
+	{{else}}return {{if lt 1 (len .Results)}}nil, {{end}}notImplemented("{{.Name}}"){{end}}
+}
+{{end}}
+`
+
+func output() {
+	// put in empty param names as needed
+	for _, t := range types {
+		if t.paramnames == nil {
+			t.paramnames = make([]string, len(t.paramtypes))
+		}
+		for i, p := range t.paramtypes {
+			cm := ""
+			if i > 0 {
+				cm = ", "
+			}
+			t.Param += fmt.Sprintf("%s%s %s", cm, t.paramnames[i], p)
+			t.Invoke += fmt.Sprintf("%s%s", cm, t.paramnames[i])
+		}
+		if len(t.Results) > 1 {
+			t.Result = "("
+		}
+		for i, r := range t.Results {
+			cm := ""
+			if i > 0 {
+				cm = ", "
+			}
+			t.Result += fmt.Sprintf("%s%s", cm, r)
+		}
+		if len(t.Results) > 1 {
+			t.Result += ")"
+		}
+	}
+
+	fd, err := os.Create(*out)
+	if err != nil {
+		log.Fatal(err)
+	}
+	t, err := template.New("foo").Parse(tmpl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	type par struct {
+		Type  string
+		Stuff []*Function
+	}
+	p := par{*typ, types}
+	if false { // debugging the template
+		t.Execute(os.Stderr, &p)
+	}
+	buf := bytes.NewBuffer(nil)
+	err = t.Execute(buf, &p)
+	if err != nil {
+		log.Fatal(err)
+	}
+	ans := bytes.Replace(buf.Bytes(), []byte("\\\n"), []byte{}, -1)
+	fd.Write(ans)
+}
+
+func doUses() {
+	fset := token.NewFileSet()
+	pkgs, err := parser.ParseDir(fset, *use, nil, 0)
+	if err != nil {
+		log.Fatalf("%q:%v", *use, err)
+	}
+	pkg := pkgs["lsp"] // CHECK
+	files := pkg.Files
+	for fname, f := range files {
+		for _, d := range f.Decls {
+			fd, ok := d.(*ast.FuncDecl)
+			if !ok {
+				continue
+			}
+			nm := fd.Name.String()
+			if isExported(nm) {
+				// we're looking for things like didChange
+				continue
+			}
+			if fx, ok := byname[nm]; ok {
+				if fx.Found != "" {
+					log.Fatalf("found %s in %s and %s", fx.Internal, fx.Found, fname)
+				}
+				fx.Found = fname
+				// and the Paramnames
+				ft := fd.Type
+				for _, f := range ft.Params.List {
+					nm := ""
+					if len(f.Names) > 0 {
+						nm = f.Names[0].String()
+					}
+					fx.paramnames = append(fx.paramnames, nm)
+				}
+			}
+		}
+	}
+	if false {
+		for i, f := range types {
+			log.Printf("%d %s %s", i, f.Internal, f.Found)
+		}
+	}
+}
+
+type Function struct {
+	Name       string
+	Internal   string // first letter lower case
+	paramtypes []string
+	paramnames []string
+	Results    []string
+	Param      string
+	Result     string // do it in code, easier than in a template
+	Invoke     string
+	Found      string // file it was found in
+}
+
+var types []*Function
+var byname = map[string]*Function{} // internal names
+
+func doTypes() {
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, *def, nil, 0)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fd, err := os.Create("/tmp/ast")
+	if err != nil {
+		log.Fatal(err)
+	}
+	ast.Fprint(fd, fset, f, ast.NotNilFilter)
+	ast.Inspect(f, inter)
+	sort.Slice(types, func(i, j int) bool { return types[i].Name < types[j].Name })
+	if false {
+		for i, f := range types {
+			log.Printf("%d %s(%v) %v", i, f.Name, f.paramtypes, f.Results)
+		}
+	}
+}
+
+func inter(n ast.Node) bool {
+	x, ok := n.(*ast.TypeSpec)
+	if !ok || x.Name.Name != *typ {
+		return true
+	}
+	m := x.Type.(*ast.InterfaceType).Methods.List
+	for _, fld := range m {
+		fn := fld.Type.(*ast.FuncType)
+		p := fn.Params.List
+		r := fn.Results.List
+		fx := &Function{
+			Name: fld.Names[0].String(),
+		}
+		fx.Internal = strings.ToLower(fx.Name[:1]) + fx.Name[1:]
+		for _, f := range p {
+			fx.paramtypes = append(fx.paramtypes, whatis(f.Type))
+		}
+		for _, f := range r {
+			fx.Results = append(fx.Results, whatis(f.Type))
+		}
+		types = append(types, fx)
+		byname[fx.Internal] = fx
+	}
+	return false
+}
+
+func whatis(x ast.Expr) string {
+	switch n := x.(type) {
+	case *ast.SelectorExpr:
+		return whatis(n.X) + "." + n.Sel.String()
+	case *ast.StarExpr:
+		return "*" + whatis(n.X)
+	case *ast.Ident:
+		if isExported(n.Name) {
+			// these are from package protocol
+			return "protocol." + n.Name
+		}
+		return n.Name
+	case *ast.ArrayType:
+		return "[]" + whatis(n.Elt)
+	case *ast.InterfaceType:
+		return "interface{}"
+	default:
+		log.Fatalf("Fatal %T", x)
+		return fmt.Sprintf("%T", x)
+	}
+}
+
+func isExported(n string) bool {
+	return n[0] >= 'A' && n[0] <= 'Z'
+}