Skip to content

Commit b437eff

Browse files
jbajba
committed
go/types/typeutil: implement Callee and StaticCallee with Used
Also, add a test for typesinternal.Used. It is employed by Callee and StaticCallee, and behaves differently from ClassifyCall in some cases. Change-Id: I21178a2cc8acdc20ebf669bb4741df03851be0b3 Reviewed-on: https://go-review.googlesource.com/c/tools/+/658235 LUCI-TryBot-Result: Go LUCI <[email protected]> Reviewed-by: Alan Donovan <[email protected]>
1 parent e29f9ae commit b437eff

File tree

4 files changed

+100
-103
lines changed

4 files changed

+100
-103
lines changed

‎go/types/typeutil/callee.go

Lines changed: 53 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -7,45 +7,23 @@ package typeutil
77
import (
88
"go/ast"
99
"go/types"
10-
11-
"golang.org/x/tools/internal/typeparams"
10+
_ "unsafe" // for linkname
1211
)
1312

1413
// Callee returns the named target of a function call, if any:
1514
// a function, method, builtin, or variable.
1615
//
1716
// Functions and methods may potentially have type parameters.
17+
//
18+
// Note: for calls of instantiated functions and methods, Callee returns
19+
// the corresponding generic function or method on the generic type.
1820
func Callee(info *types.Info, call *ast.CallExpr) types.Object {
19-
fun := ast.Unparen(call.Fun)
20-
21-
// Look through type instantiation if necessary.
22-
isInstance := false
23-
switch fun.(type) {
24-
case *ast.IndexExpr, *ast.IndexListExpr:
25-
// When extracting the callee from an *IndexExpr, we need to check that
26-
// it is a *types.Func and not a *types.Var.
27-
// Example: Don't match a slice m within the expression `m[0]()`.
28-
isInstance = true
29-
fun, _, _, _ = typeparams.UnpackIndexExpr(fun)
30-
}
31-
32-
var obj types.Object
33-
switch fun := fun.(type) {
34-
case *ast.Ident:
35-
obj = info.Uses[fun] // type, var, builtin, or declared func
36-
case *ast.SelectorExpr:
37-
if sel, ok := info.Selections[fun]; ok {
38-
obj = sel.Obj() // method or field
39-
} else {
40-
obj = info.Uses[fun.Sel] // qualified identifier?
41-
}
21+
obj := used(info, call.Fun)
22+
if obj == nil {
23+
return nil
4224
}
4325
if _, ok := obj.(*types.TypeName); ok {
44-
return nil // T(x) is a conversion, not a call
45-
}
46-
// A Func is required to match instantiations.
47-
if _, ok := obj.(*types.Func); isInstance && !ok {
48-
return nil // Was not a Func.
26+
return nil
4927
}
5028
return obj
5129
}
@@ -56,13 +34,54 @@ func Callee(info *types.Info, call *ast.CallExpr) types.Object {
5634
// Note: for calls of instantiated functions and methods, StaticCallee returns
5735
// the corresponding generic function or method on the generic type.
5836
func StaticCallee(info *types.Info, call *ast.CallExpr) *types.Func {
59-
if f, ok := Callee(info, call).(*types.Func); ok && !interfaceMethod(f) {
60-
return f
37+
obj := used(info, call.Fun)
38+
fn, _ := obj.(*types.Func)
39+
if fn == nil || interfaceMethod(fn) {
40+
return nil
6141
}
62-
return nil
42+
return fn
6343
}
6444

45+
// used is the implementation of [internal/typesinternal.Used].
46+
// It returns the object associated with e.
47+
// See typesinternal.Used for a fuller description.
48+
// This function should live in typesinternal, but cannot because it would
49+
// create an import cycle.
50+
//
51+
//go:linkname used
52+
func used(info *types.Info, e ast.Expr) types.Object {
53+
if info.Types == nil || info.Uses == nil || info.Selections == nil {
54+
panic("one of info.Types, info.Uses or info.Selections is nil; all must be populated")
55+
}
56+
// Look through type instantiation if necessary.
57+
switch d := ast.Unparen(e).(type) {
58+
case *ast.IndexExpr:
59+
if info.Types[d.Index].IsType() {
60+
e = d.X
61+
}
62+
case *ast.IndexListExpr:
63+
e = d.X
64+
}
65+
66+
var obj types.Object
67+
switch e := ast.Unparen(e).(type) {
68+
case *ast.Ident:
69+
obj = info.Uses[e] // type, var, builtin, or declared func
70+
case *ast.SelectorExpr:
71+
if sel, ok := info.Selections[e]; ok {
72+
obj = sel.Obj() // method or field
73+
} else {
74+
obj = info.Uses[e.Sel] // qualified identifier?
75+
}
76+
}
77+
return obj
78+
}
79+
80+
// interfaceMethod reports whether its argument is a method of an interface.
81+
// This function should live in typesinternal, but cannot because it would create an import cycle.
82+
//
83+
//go:linkname interfaceMethod
6584
func interfaceMethod(f *types.Func) bool {
66-
recv := f.Type().(*types.Signature).Recv()
85+
recv := f.Signature().Recv()
6786
return recv != nil && types.IsInterface(recv.Type())
6887
}

‎go/types/typeutil/callee_test.go

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -122,6 +122,7 @@ func testStaticCallee(t *testing.T, contents []string) {
122122
cfg := &types.Config{Importer: closure(packages)}
123123
info := &types.Info{
124124
Instances: make(map[*ast.Ident]types.Instance),
125+
Types: make(map[ast.Expr]types.TypeAndValue),
125126
Uses: make(map[*ast.Ident]types.Object),
126127
Selections: make(map[*ast.SelectorExpr]*types.Selection),
127128
FileVersions: make(map[*ast.File]string),

‎internal/typesinternal/classify_call.go

Lines changed: 8 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@ import (
88
"fmt"
99
"go/ast"
1010
"go/types"
11+
_ "unsafe"
1112
)
1213

1314
// CallKind describes the function position of an [*ast.CallExpr].
@@ -74,6 +75,9 @@ func (k CallKind) String() string {
7475
// int(x) CallConversion nil
7576
// []byte("") CallConversion nil
7677
func ClassifyCall(info *types.Info, call *ast.CallExpr) (CallKind, types.Object) {
78+
if info.Types == nil {
79+
panic("ClassifyCall: info.Types is nil")
80+
}
7781
if info.Types[call.Fun].IsType() {
7882
return CallConversion, nil
7983
}
@@ -134,40 +138,8 @@ func Used(info *types.Info, e ast.Expr) types.Object {
134138
return used(info, e)
135139
}
136140

137-
// placeholder: will be moved and documented in the next CL.
138-
func used(info *types.Info, e ast.Expr) types.Object {
139-
e = ast.Unparen(e)
140-
// Look through type instantiation if necessary.
141-
isIndexed := false
142-
switch d := e.(type) {
143-
case *ast.IndexExpr:
144-
if info.Types[d.Index].IsType() {
145-
e = d.X
146-
}
147-
case *ast.IndexListExpr:
148-
e = d.X
149-
}
150-
var obj types.Object
151-
switch e := e.(type) {
152-
case *ast.Ident:
153-
obj = info.Uses[e] // type, var, builtin, or declared func
154-
case *ast.SelectorExpr:
155-
if sel, ok := info.Selections[e]; ok {
156-
obj = sel.Obj() // method or field
157-
} else {
158-
obj = info.Uses[e.Sel] // qualified identifier?
159-
}
160-
}
161-
// If a variable like a slice or map is being indexed, do not
162-
// return an object.
163-
if _, ok := obj.(*types.Var); ok && isIndexed {
164-
return nil
165-
}
166-
return obj
167-
}
141+
//go:linkname used golang.org/x/tools/go/types/typeutil.used
142+
func used(info *types.Info, e ast.Expr) types.Object
168143

169-
// placeholder: will be moved and documented in the next CL.
170-
func interfaceMethod(f *types.Func) bool {
171-
recv := f.Signature().Recv()
172-
return recv != nil && types.IsInterface(recv.Type())
173-
}
144+
//go:linkname interfaceMethod golang.org/x/tools/go/types/typeutil.interfaceMethod
145+
func interfaceMethod(f *types.Func) bool

‎internal/typesinternal/classify_call_test.go

Lines changed: 38 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -19,9 +19,6 @@ import (
1919
)
2020

2121
func TestClassifyCallAndUsed(t *testing.T) {
22-
// This function directly tests ClassifyCall, but since that
23-
// function's second return value is always the result of Used,
24-
// it effectively tests Used as well.
2522
const src = `
2623
package p
2724
@@ -78,13 +75,7 @@ func TestClassifyCallAndUsed(t *testing.T) {
7875
Error: func(err error) { t.Fatal(err) },
7976
Importer: importer.Default(),
8077
}
81-
info := &types.Info{
82-
Instances: make(map[*ast.Ident]types.Instance),
83-
Uses: make(map[*ast.Ident]types.Object),
84-
Defs: make(map[*ast.Ident]types.Object),
85-
Types: make(map[ast.Expr]types.TypeAndValue),
86-
Selections: make(map[*ast.SelectorExpr]*types.Selection),
87-
}
78+
info := ti.NewTypesInfo()
8879
// parse
8980
f, err := parser.ParseFile(fset, "classify.go", src, 0)
9081
if err != nil {
@@ -108,30 +99,36 @@ func TestClassifyCallAndUsed(t *testing.T) {
10899

109100
printlnObj := types.Universe.Lookup("println")
110101

102+
typeParam := lookup("tests").Type().(*types.Signature).TypeParams().At(0).Obj()
103+
104+
// A unique value for marking that Used returns the same object as ClassifyCall.
105+
same := &types.Label{}
106+
111107
// Expected Calls are in the order of CallExprs at the end of src, above.
112108
wants := []struct {
113-
kind ti.CallKind
114-
obj types.Object
109+
kind ti.CallKind
110+
classifyObj types.Object // the object returned from ClassifyCall
111+
usedObj types.Object // the object returned from Used, sometimes different
115112
}{
116-
{ti.CallStatic, lookup("g")}, // g
117-
{ti.CallDynamic, nil}, // f
118-
{ti.CallBuiltin, printlnObj}, // println
119-
{ti.CallStatic, member("S", "g")}, // z.g
120-
{ti.CallStatic, member("S", "g")}, // a.b.c.g
121-
{ti.CallStatic, member("S", "g")}, // S.g(z, 1)
122-
{ti.CallDynamic, nil}, // z.f
123-
{ti.CallInterface, member("I", "m")}, // I(nil).m
124-
{ti.CallConversion, nil}, // I(nil)
125-
{ti.CallDynamic, nil}, // m[0]
126-
{ti.CallDynamic, nil}, // n[0]
127-
{ti.CallStatic, lookup("F")}, // F[int]
128-
{ti.CallStatic, lookup("F")}, // F[T]
129-
{ti.CallDynamic, nil}, // f(){}
130-
{ti.CallConversion, nil}, // []byte
131-
{ti.CallConversion, nil}, // A[int]
132-
{ti.CallConversion, nil}, // T
133-
{ti.CallStatic, member("S", "g")}, // (z.g)
134-
{ti.CallStatic, member("S", "g")}, // (z).g
113+
{ti.CallStatic, lookup("g"), same}, // g
114+
{ti.CallDynamic, nil, lookup("f")}, // f
115+
{ti.CallBuiltin, printlnObj, same}, // println
116+
{ti.CallStatic, member("S", "g"), same}, // z.g
117+
{ti.CallStatic, member("S", "g"), same}, // a.b.c.g
118+
{ti.CallStatic, member("S", "g"), same}, // S.g(z, 1)
119+
{ti.CallDynamic, nil, member("z", "f")}, // z.f
120+
{ti.CallInterface, member("I", "m"), same}, // I(nil).m
121+
{ti.CallConversion, nil, lookup("I")}, // I(nil)
122+
{ti.CallDynamic, nil, same}, // m[0]
123+
{ti.CallDynamic, nil, same}, // n[0]
124+
{ti.CallStatic, lookup("F"), same}, // F[int]
125+
{ti.CallStatic, lookup("F"), same}, // F[T]
126+
{ti.CallDynamic, nil, same}, // f(){}
127+
{ti.CallConversion, nil, same}, // []byte
128+
{ti.CallConversion, nil, lookup("A")}, // A[int]
129+
{ti.CallConversion, nil, typeParam}, // T
130+
{ti.CallStatic, member("S", "g"), same}, // (z.g)
131+
{ti.CallStatic, member("S", "g"), same}, // (z).g
135132
}
136133

137134
i := 0
@@ -152,8 +149,16 @@ func TestClassifyCallAndUsed(t *testing.T) {
152149
if gotKind != want.kind {
153150
t.Errorf("%s kind: got %s, want %s", prefix, gotKind, want.kind)
154151
}
155-
if gotObj != want.obj {
156-
t.Errorf("%s obj: got %v (%[2]T), want %v", prefix, gotObj, want.obj)
152+
if gotObj != want.classifyObj {
153+
t.Errorf("%s obj: got %v (%[2]T), want %v", prefix, gotObj, want.classifyObj)
154+
}
155+
156+
w := want.usedObj
157+
if w == same {
158+
w = want.classifyObj
159+
}
160+
if g := ti.Used(info, call.Fun); g != w {
161+
t.Errorf("%s used obj: got %v (%[2]T), want %v", prefix, g, w)
157162
}
158163
i++
159164
}

0 commit comments

Comments
 (0)