blob: 08e7654c7ed09c3e410f8e67f9de8b00cf8ba45a [file] [log] [blame]
// Copyright 2022 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 completion
import (
"fmt"
"go/ast"
"go/token"
"go/types"
"strings"
"golang.org/x/tools/gopls/internal/lsp/protocol"
)
// golang/go#51089
// *testing.F deserves special treatment as member use is constrained:
// The arguments to f.Fuzz are determined by the arguments to a previous f.Add
// Inside f.Fuzz only f.Failed and f.Name are allowed.
// PJW: are there other packages where we can deduce usage constraints?
// if we find fuzz completions, then return true, as those are the only completions to offer
func (c *completer) fuzz(typ types.Type, mset *types.MethodSet, imp *importInfo, cb func(candidate), fset *token.FileSet) bool {
// 1. inside f.Fuzz? (only f.Failed and f.Name)
// 2. possible completing f.Fuzz?
// [Ident,SelectorExpr,Callexpr,ExprStmt,BlockiStmt,FuncDecl(Fuzz...)]
// 3. before f.Fuzz, same (for 2., offer choice when looking at an F)
// does the path contain FuncLit as arg to f.Fuzz CallExpr?
inside := false
Loop:
for i, n := range c.path {
switch v := n.(type) {
case *ast.CallExpr:
if len(v.Args) != 1 {
continue Loop
}
if _, ok := v.Args[0].(*ast.FuncLit); !ok {
continue
}
if s, ok := v.Fun.(*ast.SelectorExpr); !ok || s.Sel.Name != "Fuzz" {
continue
}
if i > 2 { // avoid t.Fuzz itself in tests
inside = true
break Loop
}
}
}
if inside {
for i := 0; i < mset.Len(); i++ {
o := mset.At(i).Obj()
if o.Name() == "Failed" || o.Name() == "Name" {
cb(candidate{
obj: o,
score: stdScore,
imp: imp,
addressable: true,
})
}
}
return true
}
// if it could be t.Fuzz, look for the preceding t.Add
id, ok := c.path[0].(*ast.Ident)
if ok && strings.HasPrefix("Fuzz", id.Name) {
var add *ast.CallExpr
f := func(n ast.Node) bool {
if n == nil {
return true
}
call, ok := n.(*ast.CallExpr)
if !ok {
return true
}
s, ok := call.Fun.(*ast.SelectorExpr)
if !ok {
return true
}
if s.Sel.Name != "Add" {
return true
}
// Sel.X should be of type *testing.F
got := c.pkg.GetTypesInfo().Types[s.X]
if got.Type.String() == "*testing.F" {
add = call
}
return false // because we're done...
}
// look at the enclosing FuzzFoo functions
if len(c.path) < 2 {
return false
}
n := c.path[len(c.path)-2]
if _, ok := n.(*ast.FuncDecl); !ok {
// the path should start with ast.File, ast.FuncDecl, ...
// but it didn't, so give up
return false
}
ast.Inspect(n, f)
if add == nil {
// looks like f.Fuzz without a preceding f.Add.
// let the regular completion handle it.
return false
}
lbl := "Fuzz(func(t *testing.T"
for i, a := range add.Args {
info := c.pkg.GetTypesInfo().TypeOf(a)
if info == nil {
return false // How could this happen, but better safe than panic.
}
lbl += fmt.Sprintf(", %c %s", 'a'+i, info)
}
lbl += ")"
xx := CompletionItem{
Label: lbl,
InsertText: lbl,
Kind: protocol.FunctionCompletion,
Depth: 0,
Score: 10, // pretty confident the user should see this
Documentation: "argument types from f.Add",
isSlice: false,
}
c.items = append(c.items, xx)
for i := 0; i < mset.Len(); i++ {
o := mset.At(i).Obj()
if o.Name() != "Fuzz" {
cb(candidate{
obj: o,
score: stdScore,
imp: imp,
addressable: true,
})
}
}
return true // done
}
// let the standard processing take care of it instead
return false
}