| // Copyright 2013 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 ssa | |
| // This file defines synthesis of Functions that delegate to declared | |
| // methods; they come in three kinds: | |
| // | |
| // (1) wrappers: methods that wrap declared methods, performing | |
| // implicit pointer indirections and embedded field selections. | |
| // | |
| // (2) thunks: funcs that wrap declared methods. Like wrappers, | |
| // thunks perform indirections and field selections. The thunk's | |
| // first parameter is used as the receiver for the method call. | |
| // | |
| // (3) bounds: funcs that wrap declared methods. The bound's sole | |
| // free variable, supplied by a closure, is used as the receiver | |
| // for the method call. No indirections or field selections are | |
| // performed since they can be done before the call. | |
| import ( | |
| "fmt" | |
| "go/token" | |
| "go/types" | |
| "golang.org/x/tools/internal/typeparams" | |
| ) | |
| // -- wrappers ----------------------------------------------------------- | |
| // createWrapper returns a synthetic method that delegates to the | |
| // declared method denoted by meth.Obj(), first performing any | |
| // necessary pointer indirections or field selections implied by meth. | |
| // | |
| // The resulting method's receiver type is meth.Recv(). | |
| // | |
| // This function is versatile but quite subtle! Consider the | |
| // following axes of variation when making changes: | |
| // - optional receiver indirection | |
| // - optional implicit field selections | |
| // - meth.Obj() may denote a concrete or an interface method | |
| // - the result may be a thunk or a wrapper. | |
| func createWrapper(prog *Program, sel *selection) *Function { | |
| obj := sel.obj.(*types.Func) // the declared function | |
| sig := sel.typ.(*types.Signature) // type of this wrapper | |
| var recv *types.Var // wrapper's receiver or thunk's params[0] | |
| name := obj.Name() | |
| var description string | |
| if sel.kind == types.MethodExpr { | |
| name += "$thunk" | |
| description = "thunk" | |
| recv = sig.Params().At(0) | |
| } else { | |
| description = "wrapper" | |
| recv = sig.Recv() | |
| } | |
| description = fmt.Sprintf("%s for %s", description, sel.obj) | |
| if prog.mode&LogSource != 0 { | |
| defer logStack("create %s to (%s)", description, recv.Type())() | |
| } | |
| /* method wrapper */ | |
| return &Function{ | |
| name: name, | |
| method: sel, | |
| object: obj, | |
| Signature: sig, | |
| Synthetic: description, | |
| Prog: prog, | |
| pos: obj.Pos(), | |
| // wrappers have no syntax | |
| build: (*builder).buildWrapper, | |
| syntax: nil, | |
| info: nil, | |
| goversion: "", | |
| } | |
| } | |
| // buildWrapper builds fn.Body for a method wrapper. | |
| func (b *builder) buildWrapper(fn *Function) { | |
| var recv *types.Var // wrapper's receiver or thunk's params[0] | |
| var start int // first regular param | |
| if fn.method.kind == types.MethodExpr { | |
| recv = fn.Signature.Params().At(0) | |
| start = 1 | |
| } else { | |
| recv = fn.Signature.Recv() | |
| } | |
| fn.startBody() | |
| fn.addSpilledParam(recv) | |
| createParams(fn, start) | |
| indices := fn.method.index | |
| var v Value = fn.Locals[0] // spilled receiver | |
| if isPointer(fn.method.recv) { | |
| v = emitLoad(fn, v) | |
| // For simple indirection wrappers, perform an informative nil-check: | |
| // "value method (T).f called using nil *T pointer" | |
| if len(indices) == 1 && !isPointer(recvType(fn.object)) { | |
| var c Call | |
| c.Call.Value = &Builtin{ | |
| name: "ssa:wrapnilchk", | |
| sig: types.NewSignature(nil, | |
| types.NewTuple(anonVar(fn.method.recv), anonVar(tString), anonVar(tString)), | |
| types.NewTuple(anonVar(fn.method.recv)), false), | |
| } | |
| c.Call.Args = []Value{ | |
| v, | |
| stringConst(typeparams.MustDeref(fn.method.recv).String()), | |
| stringConst(fn.method.obj.Name()), | |
| } | |
| c.setType(v.Type()) | |
| v = fn.emit(&c) | |
| } | |
| } | |
| // Invariant: v is a pointer, either | |
| // value of *A receiver param, or | |
| // address of A spilled receiver. | |
| // We use pointer arithmetic (FieldAddr possibly followed by | |
| // Load) in preference to value extraction (Field possibly | |
| // preceded by Load). | |
| v = emitImplicitSelections(fn, v, indices[:len(indices)-1], token.NoPos) | |
| // Invariant: v is a pointer, either | |
| // value of implicit *C field, or | |
| // address of implicit C field. | |
| var c Call | |
| if r := recvType(fn.object); !types.IsInterface(r) { // concrete method | |
| if !isPointer(r) { | |
| v = emitLoad(fn, v) | |
| } | |
| c.Call.Value = fn.Prog.objectMethod(fn.object, b) | |
| c.Call.Args = append(c.Call.Args, v) | |
| } else { | |
| c.Call.Method = fn.object | |
| c.Call.Value = emitLoad(fn, v) // interface (possibly a typeparam) | |
| } | |
| for _, arg := range fn.Params[1:] { | |
| c.Call.Args = append(c.Call.Args, arg) | |
| } | |
| emitTailCall(fn, &c) | |
| fn.finishBody() | |
| } | |
| // createParams creates parameters for wrapper method fn based on its | |
| // Signature.Params, which do not include the receiver. | |
| // start is the index of the first regular parameter to use. | |
| func createParams(fn *Function, start int) { | |
| tparams := fn.Signature.Params() | |
| for i, n := start, tparams.Len(); i < n; i++ { | |
| fn.addParamVar(tparams.At(i)) | |
| } | |
| } | |
| // -- bounds ----------------------------------------------------------- | |
| // createBound returns a bound method wrapper (or "bound"), a synthetic | |
| // function that delegates to a concrete or interface method denoted | |
| // by obj. The resulting function has no receiver, but has one free | |
| // variable which will be used as the method's receiver in the | |
| // tail-call. | |
| // | |
| // Use MakeClosure with such a wrapper to construct a bound method | |
| // closure. e.g.: | |
| // | |
| // type T int or: type T interface { meth() } | |
| // func (t T) meth() | |
| // var t T | |
| // f := t.meth | |
| // f() // calls t.meth() | |
| // | |
| // f is a closure of a synthetic wrapper defined as if by: | |
| // | |
| // f := func() { return t.meth() } | |
| // | |
| // Unlike createWrapper, createBound need perform no indirection or field | |
| // selections because that can be done before the closure is | |
| // constructed. | |
| func createBound(prog *Program, obj *types.Func) *Function { | |
| description := fmt.Sprintf("bound method wrapper for %s", obj) | |
| if prog.mode&LogSource != 0 { | |
| defer logStack("%s", description)() | |
| } | |
| /* bound method wrapper */ | |
| fn := &Function{ | |
| name: obj.Name() + "$bound", | |
| object: obj, | |
| Signature: changeRecv(obj.Type().(*types.Signature), nil), // drop receiver | |
| Synthetic: description, | |
| Prog: prog, | |
| pos: obj.Pos(), | |
| // wrappers have no syntax | |
| build: (*builder).buildBound, | |
| syntax: nil, | |
| info: nil, | |
| goversion: "", | |
| } | |
| fn.FreeVars = []*FreeVar{{name: "recv", typ: recvType(obj), parent: fn}} // (cyclic) | |
| return fn | |
| } | |
| // buildBound builds fn.Body for a bound method closure. | |
| func (b *builder) buildBound(fn *Function) { | |
| fn.startBody() | |
| createParams(fn, 0) | |
| var c Call | |
| recv := fn.FreeVars[0] | |
| if !types.IsInterface(recvType(fn.object)) { // concrete | |
| c.Call.Value = fn.Prog.objectMethod(fn.object, b) | |
| c.Call.Args = []Value{recv} | |
| } else { | |
| c.Call.Method = fn.object | |
| c.Call.Value = recv // interface (possibly a typeparam) | |
| } | |
| for _, arg := range fn.Params { | |
| c.Call.Args = append(c.Call.Args, arg) | |
| } | |
| emitTailCall(fn, &c) | |
| fn.finishBody() | |
| } | |
| // -- thunks ----------------------------------------------------------- | |
| // createThunk returns a thunk, a synthetic function that delegates to a | |
| // concrete or interface method denoted by sel.obj. The resulting | |
| // function has no receiver, but has an additional (first) regular | |
| // parameter. | |
| // | |
| // Precondition: sel.kind == types.MethodExpr. | |
| // | |
| // type T int or: type T interface { meth() } | |
| // func (t T) meth() | |
| // f := T.meth | |
| // var t T | |
| // f(t) // calls t.meth() | |
| // | |
| // f is a synthetic wrapper defined as if by: | |
| // | |
| // f := func(t T) { return t.meth() } | |
| func createThunk(prog *Program, sel *selection) *Function { | |
| if sel.kind != types.MethodExpr { | |
| panic(sel) | |
| } | |
| fn := createWrapper(prog, sel) | |
| if fn.Signature.Recv() != nil { | |
| panic(fn) // unexpected receiver | |
| } | |
| return fn | |
| } | |
| func changeRecv(s *types.Signature, recv *types.Var) *types.Signature { | |
| return types.NewSignature(recv, s.Params(), s.Results(), s.Variadic()) | |
| } | |
| // A local version of *types.Selection. | |
| // Needed for some additional control, such as creating a MethodExpr for an instantiation. | |
| type selection struct { | |
| kind types.SelectionKind | |
| recv types.Type | |
| typ types.Type | |
| obj types.Object | |
| index []int | |
| indirect bool | |
| } | |
| func toSelection(sel *types.Selection) *selection { | |
| return &selection{ | |
| kind: sel.Kind(), | |
| recv: sel.Recv(), | |
| typ: sel.Type(), | |
| obj: sel.Obj(), | |
| index: sel.Index(), | |
| indirect: sel.Indirect(), | |
| } | |
| } | |
| // -- instantiations -------------------------------------------------- | |
| // buildInstantiationWrapper builds the body of an instantiation | |
| // wrapper fn. The body calls the original generic function, | |
| // bracketed by ChangeType conversions on its arguments and results. | |
| func (b *builder) buildInstantiationWrapper(fn *Function) { | |
| orig := fn.topLevelOrigin | |
| sig := fn.Signature | |
| fn.startBody() | |
| if sig.Recv() != nil { | |
| fn.addParamVar(sig.Recv()) | |
| } | |
| createParams(fn, 0) | |
| // Create body. Add a call to origin generic function | |
| // and make type changes between argument and parameters, | |
| // as well as return values. | |
| var c Call | |
| c.Call.Value = orig | |
| if res := orig.Signature.Results(); res.Len() == 1 { | |
| c.typ = res.At(0).Type() | |
| } else { | |
| c.typ = res | |
| } | |
| // parameter of instance becomes an argument to the call | |
| // to the original generic function. | |
| argOffset := 0 | |
| for i, arg := range fn.Params { | |
| var typ types.Type | |
| if i == 0 && sig.Recv() != nil { | |
| typ = orig.Signature.Recv().Type() | |
| argOffset = 1 | |
| } else { | |
| typ = orig.Signature.Params().At(i - argOffset).Type() | |
| } | |
| c.Call.Args = append(c.Call.Args, emitTypeCoercion(fn, arg, typ)) | |
| } | |
| results := fn.emit(&c) | |
| var ret Return | |
| switch res := sig.Results(); res.Len() { | |
| case 0: | |
| // no results, do nothing. | |
| case 1: | |
| ret.Results = []Value{emitTypeCoercion(fn, results, res.At(0).Type())} | |
| default: | |
| for i := 0; i < sig.Results().Len(); i++ { | |
| v := emitExtract(fn, results, i) | |
| ret.Results = append(ret.Results, emitTypeCoercion(fn, v, res.At(i).Type())) | |
| } | |
| } | |
| fn.emit(&ret) | |
| fn.currentBlock = nil | |
| fn.finishBody() | |
| } |