.config/coc/extensions/coc-go-data/tools/pkg/mod/honnef.co/go/tools@v0.0.1-2020.1.5/ir/wrappers.go

   1 // Copyright 2013 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package ir
   6
   7 // This file defines synthesis of Functions that delegate to declared
   8 // methods; they come in three kinds:
   9 //
  10 // (1) wrappers: methods that wrap declared methods, performing
  11 //     implicit pointer indirections and embedded field selections.
  12 //
  13 // (2) thunks: funcs that wrap declared methods.  Like wrappers,
  14 //     thunks perform indirections and field selections. The thunk's
  15 //     first parameter is used as the receiver for the method call.
  16 //
  17 // (3) bounds: funcs that wrap declared methods.  The bound's sole
  18 //     free variable, supplied by a closure, is used as the receiver
  19 //     for the method call.  No indirections or field selections are
  20 //     performed since they can be done before the call.
  21
  22 import (
  23         "fmt"
  24
  25         "go/types"
  26 )
  27
  28 // -- wrappers -----------------------------------------------------------
  29
  30 // makeWrapper returns a synthetic method that delegates to the
  31 // declared method denoted by meth.Obj(), first performing any
  32 // necessary pointer indirections or field selections implied by meth.
  33 //
  34 // The resulting method's receiver type is meth.Recv().
  35 //
  36 // This function is versatile but quite subtle!  Consider the
  37 // following axes of variation when making changes:
  38 //   - optional receiver indirection
  39 //   - optional implicit field selections
  40 //   - meth.Obj() may denote a concrete or an interface method
  41 //   - the result may be a thunk or a wrapper.
  42 //
  43 // EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
  44 //
  45 func makeWrapper(prog *Program, sel *types.Selection) *Function {
  46         obj := sel.Obj().(*types.Func)       // the declared function
  47         sig := sel.Type().(*types.Signature) // type of this wrapper
  48
  49         var recv *types.Var // wrapper's receiver or thunk's params[0]
  50         name := obj.Name()
  51         var description string
  52         var start int // first regular param
  53         if sel.Kind() == types.MethodExpr {
  54                 name += "$thunk"
  55                 description = "thunk"
  56                 recv = sig.Params().At(0)
  57                 start = 1
  58         } else {
  59                 description = "wrapper"
  60                 recv = sig.Recv()
  61         }
  62
  63         description = fmt.Sprintf("%s for %s", description, sel.Obj())
  64         if prog.mode&LogSource != 0 {
  65                 defer logStack("make %s to (%s)", description, recv.Type())()
  66         }
  67         fn := &Function{
  68                 name:         name,
  69                 method:       sel,
  70                 object:       obj,
  71                 Signature:    sig,
  72                 Synthetic:    description,
  73                 Prog:         prog,
  74                 functionBody: new(functionBody),
  75         }
  76         fn.initHTML(prog.PrintFunc)
  77         fn.startBody()
  78         fn.addSpilledParam(recv, nil)
  79         createParams(fn, start)
  80
  81         indices := sel.Index()
  82
  83         var v Value = fn.Locals[0] // spilled receiver
  84         if isPointer(sel.Recv()) {
  85                 v = emitLoad(fn, v, nil)
  86
  87                 // For simple indirection wrappers, perform an informative nil-check:
  88                 // "value method (T).f called using nil *T pointer"
  89                 if len(indices) == 1 && !isPointer(recvType(obj)) {
  90                         var c Call
  91                         c.Call.Value = &Builtin{
  92                                 name: "ir:wrapnilchk",
  93                                 sig: types.NewSignature(nil,
  94                                         types.NewTuple(anonVar(sel.Recv()), anonVar(tString), anonVar(tString)),
  95                                         types.NewTuple(anonVar(sel.Recv())), false),
  96                         }
  97                         c.Call.Args = []Value{
  98                                 v,
  99                                 emitConst(fn, stringConst(deref(sel.Recv()).String())),
 100                                 emitConst(fn, stringConst(sel.Obj().Name())),
 101                         }
 102                         c.setType(v.Type())
 103                         v = fn.emit(&c, nil)
 104                 }
 105         }
 106
 107         // Invariant: v is a pointer, either
 108         //   value of *A receiver param, or
 109         // address of  A spilled receiver.
 110
 111         // We use pointer arithmetic (FieldAddr possibly followed by
 112         // Load) in preference to value extraction (Field possibly
 113         // preceded by Load).
 114
 115         v = emitImplicitSelections(fn, v, indices[:len(indices)-1], nil)
 116
 117         // Invariant: v is a pointer, either
 118         //   value of implicit *C field, or
 119         // address of implicit  C field.
 120
 121         var c Call
 122         if r := recvType(obj); !isInterface(r) { // concrete method
 123                 if !isPointer(r) {
 124                         v = emitLoad(fn, v, nil)
 125                 }
 126                 c.Call.Value = prog.declaredFunc(obj)
 127                 c.Call.Args = append(c.Call.Args, v)
 128         } else {
 129                 c.Call.Method = obj
 130                 c.Call.Value = emitLoad(fn, v, nil)
 131         }
 132         for _, arg := range fn.Params[1:] {
 133                 c.Call.Args = append(c.Call.Args, arg)
 134         }
 135         emitTailCall(fn, &c, nil)
 136         fn.finishBody()
 137         return fn
 138 }
 139
 140 // createParams creates parameters for wrapper method fn based on its
 141 // Signature.Params, which do not include the receiver.
 142 // start is the index of the first regular parameter to use.
 143 //
 144 func createParams(fn *Function, start int) {
 145         tparams := fn.Signature.Params()
 146         for i, n := start, tparams.Len(); i < n; i++ {
 147                 fn.addParamObj(tparams.At(i), nil)
 148         }
 149 }
 150
 151 // -- bounds -----------------------------------------------------------
 152
 153 // makeBound returns a bound method wrapper (or "bound"), a synthetic
 154 // function that delegates to a concrete or interface method denoted
 155 // by obj.  The resulting function has no receiver, but has one free
 156 // variable which will be used as the method's receiver in the
 157 // tail-call.
 158 //
 159 // Use MakeClosure with such a wrapper to construct a bound method
 160 // closure.  e.g.:
 161 //
 162 //   type T int          or:  type T interface { meth() }
 163 //   func (t T) meth()
 164 //   var t T
 165 //   f := t.meth
 166 //   f() // calls t.meth()
 167 //
 168 // f is a closure of a synthetic wrapper defined as if by:
 169 //
 170 //   f := func() { return t.meth() }
 171 //
 172 // Unlike makeWrapper, makeBound need perform no indirection or field
 173 // selections because that can be done before the closure is
 174 // constructed.
 175 //
 176 // EXCLUSIVE_LOCKS_ACQUIRED(meth.Prog.methodsMu)
 177 //
 178 func makeBound(prog *Program, obj *types.Func) *Function {
 179         prog.methodsMu.Lock()
 180         defer prog.methodsMu.Unlock()
 181         fn, ok := prog.bounds[obj]
 182         if !ok {
 183                 description := fmt.Sprintf("bound method wrapper for %s", obj)
 184                 if prog.mode&LogSource != 0 {
 185                         defer logStack("%s", description)()
 186                 }
 187                 fn = &Function{
 188                         name:         obj.Name() + "$bound",
 189                         object:       obj,
 190                         Signature:    changeRecv(obj.Type().(*types.Signature), nil), // drop receiver
 191                         Synthetic:    description,
 192                         Prog:         prog,
 193                         functionBody: new(functionBody),
 194                 }
 195                 fn.initHTML(prog.PrintFunc)
 196
 197                 fv := &FreeVar{name: "recv", typ: recvType(obj), parent: fn}
 198                 fn.FreeVars = []*FreeVar{fv}
 199                 fn.startBody()
 200                 createParams(fn, 0)
 201                 var c Call
 202
 203                 if !isInterface(recvType(obj)) { // concrete
 204                         c.Call.Value = prog.declaredFunc(obj)
 205                         c.Call.Args = []Value{fv}
 206                 } else {
 207                         c.Call.Value = fv
 208                         c.Call.Method = obj
 209                 }
 210                 for _, arg := range fn.Params {
 211                         c.Call.Args = append(c.Call.Args, arg)
 212                 }
 213                 emitTailCall(fn, &c, nil)
 214                 fn.finishBody()
 215
 216                 prog.bounds[obj] = fn
 217         }
 218         return fn
 219 }
 220
 221 // -- thunks -----------------------------------------------------------
 222
 223 // makeThunk returns a thunk, a synthetic function that delegates to a
 224 // concrete or interface method denoted by sel.Obj().  The resulting
 225 // function has no receiver, but has an additional (first) regular
 226 // parameter.
 227 //
 228 // Precondition: sel.Kind() == types.MethodExpr.
 229 //
 230 //   type T int          or:  type T interface { meth() }
 231 //   func (t T) meth()
 232 //   f := T.meth
 233 //   var t T
 234 //   f(t) // calls t.meth()
 235 //
 236 // f is a synthetic wrapper defined as if by:
 237 //
 238 //   f := func(t T) { return t.meth() }
 239 //
 240 // TODO(adonovan): opt: currently the stub is created even when used
 241 // directly in a function call: C.f(i, 0).  This is less efficient
 242 // than inlining the stub.
 243 //
 244 // EXCLUSIVE_LOCKS_ACQUIRED(meth.Prog.methodsMu)
 245 //
 246 func makeThunk(prog *Program, sel *types.Selection) *Function {
 247         if sel.Kind() != types.MethodExpr {
 248                 panic(sel)
 249         }
 250
 251         key := selectionKey{
 252                 kind:     sel.Kind(),
 253                 recv:     sel.Recv(),
 254                 obj:      sel.Obj(),
 255                 index:    fmt.Sprint(sel.Index()),
 256                 indirect: sel.Indirect(),
 257         }
 258
 259         prog.methodsMu.Lock()
 260         defer prog.methodsMu.Unlock()
 261
 262         // Canonicalize key.recv to avoid constructing duplicate thunks.
 263         canonRecv, ok := prog.canon.At(key.recv).(types.Type)
 264         if !ok {
 265                 canonRecv = key.recv
 266                 prog.canon.Set(key.recv, canonRecv)
 267         }
 268         key.recv = canonRecv
 269
 270         fn, ok := prog.thunks[key]
 271         if !ok {
 272                 fn = makeWrapper(prog, sel)
 273                 if fn.Signature.Recv() != nil {
 274                         panic(fn) // unexpected receiver
 275                 }
 276                 prog.thunks[key] = fn
 277         }
 278         return fn
 279 }
 280
 281 func changeRecv(s *types.Signature, recv *types.Var) *types.Signature {
 282         return types.NewSignature(recv, s.Params(), s.Results(), s.Variadic())
 283 }
 284
 285 // selectionKey is like types.Selection but a usable map key.
 286 type selectionKey struct {
 287         kind     types.SelectionKind
 288         recv     types.Type // canonicalized via Program.canon
 289         obj      types.Object
 290         index    string
 291         indirect bool
 292 }