func (p *exporter) signature(sig *types.Signature) { // We need the receiver information (T vs *T) // for methods associated with named types. // We do not record interface receiver types in the // export data because 1) the importer can derive them // from the interface type and 2) they create cycles // in the type graph. if recv := sig.Recv(); recv != nil { if _, ok := recv.Type().Underlying().(*types.Interface); !ok { // 1-element tuple p.int(1) p.param(recv) } else { // 0-element tuple p.int(0) } } else { // 0-element tuple p.int(0) } p.tuple(sig.Params()) p.tuple(sig.Results()) if sig.Variadic() { p.int(1) } else { p.int(0) } }
func (tm *llvmTypeMap) funcLLVMType(f *types.Signature, name string) llvm.Type { // If there's a receiver change the receiver to an // additional (first) parameter, and take the value of // the resulting signature instead. if recv := f.Recv(); recv != nil { params := f.Params() paramvars := make([]*types.Var, int(params.Len()+1)) paramvars[0] = recv for i := 0; i < int(params.Len()); i++ { paramvars[i+1] = params.At(i) } params = types.NewTuple(paramvars...) f := types.NewSignature(nil, nil, params, f.Results(), f.Variadic()) return tm.toLLVM(f, name) } if typ, ok := tm.types.At(f).(llvm.Type); ok { return typ } typ := llvm.GlobalContext().StructCreateNamed(name) tm.types.Set(f, typ) params := f.Params() param_types := make([]llvm.Type, params.Len()) for i := range param_types { llvmtyp := tm.ToLLVM(params.At(i).Type()) param_types[i] = llvmtyp } var return_type llvm.Type results := f.Results() switch nresults := int(results.Len()); nresults { case 0: return_type = llvm.VoidType() case 1: return_type = tm.ToLLVM(results.At(0).Type()) default: elements := make([]llvm.Type, nresults) for i := range elements { result := results.At(i) elements[i] = tm.ToLLVM(result.Type()) } return_type = llvm.StructType(elements, false) } fntyp := llvm.FunctionType(return_type, param_types, false) fnptrtyp := llvm.PointerType(fntyp, 0) i8ptr := llvm.PointerType(llvm.Int8Type(), 0) elements := []llvm.Type{fnptrtyp, i8ptr} // func, closure typ.StructSetBody(elements, false) return typ }
func (f *Finder) call(sig *types.Signature, args []ast.Expr) { if len(args) == 0 { return } // Ellipsis call? e.g. f(x, y, z...) if _, ok := args[len(args)-1].(*ast.Ellipsis); ok { for i, arg := range args { // The final arg is a slice, and so is the final param. f.assign(sig.Params().At(i).Type(), f.expr(arg)) } return } var argtypes []types.Type // Gather the effective actual parameter types. if tuple, ok := f.info.Types[args[0]].Type.(*types.Tuple); ok { // f(g()) call where g has multiple results? f.expr(args[0]) // unpack the tuple for i := 0; i < tuple.Len(); i++ { argtypes = append(argtypes, tuple.At(i).Type()) } } else { for _, arg := range args { argtypes = append(argtypes, f.expr(arg)) } } // Assign the actuals to the formals. if !sig.Variadic() { for i, argtype := range argtypes { f.assign(sig.Params().At(i).Type(), argtype) } } else { // The first n-1 parameters are assigned normally. nnormals := sig.Params().Len() - 1 for i, argtype := range argtypes[:nnormals] { f.assign(sig.Params().At(i).Type(), argtype) } // Remaining args are assigned to elements of varargs slice. tElem := sig.Params().At(nnormals).Type().(*types.Slice).Elem() for i := nnormals; i < len(argtypes); i++ { f.assign(tElem, argtypes[i]) } } }
func (c *funcContext) translateArgs(sig *types.Signature, args []ast.Expr, ellipsis bool) []string { params := make([]string, sig.Params().Len()) for i := range params { if sig.Variadic() && i == len(params)-1 && !ellipsis { varargType := sig.Params().At(i).Type().(*types.Slice) varargs := make([]string, len(args)-i) for j, arg := range args[i:] { varargs[j] = c.translateImplicitConversionWithCloning(arg, varargType.Elem()).String() } params[i] = fmt.Sprintf("new %s([%s])", c.typeName(varargType), strings.Join(varargs, ", ")) break } argType := sig.Params().At(i).Type() params[i] = c.translateImplicitConversionWithCloning(args[i], argType).String() } return params }
func (m *TypeMap) descriptorSignature(t *types.Signature, name string) TypeDebugDescriptor { // If there's a receiver change the receiver to an // additional (first) parameter, and take the value of // the resulting signature instead. if recv := t.Recv(); recv != nil { params := t.Params() paramvars := make([]*types.Var, int(params.Len()+1)) paramvars[0] = recv for i := 0; i < int(params.Len()); i++ { paramvars[i+1] = params.At(i) } params = types.NewTuple(paramvars...) t := types.NewSignature(nil, nil, params, t.Results(), t.Variadic()) return m.typeDebugDescriptor(t, name) } if dt, ok := m.m.At(t).(TypeDebugDescriptor); ok { return dt } var returnType DebugDescriptor var paramTypes []DebugDescriptor if results := t.Results(); results.Len() == 1 { returnType = m.TypeDebugDescriptor(results.At(0).Type()) } else if results != nil { fields := make([]DebugDescriptor, results.Len()) for i := range fields { fields[i] = m.TypeDebugDescriptor(results.At(i).Type()) } returnType = NewStructCompositeType(fields) } if params := t.Params(); params != nil && params.Len() > 0 { paramTypes = make([]DebugDescriptor, params.Len()) for i := range paramTypes { paramTypes[i] = m.TypeDebugDescriptor(params.At(i).Type()) } } ct := NewStructCompositeType([]DebugDescriptor{ NewSubroutineCompositeType(returnType, paramTypes), m.TypeDebugDescriptor(types.NewPointer(types.Typ[types.Uint8])), }) ct.Name = name m.m.Set(t, ct) return ct }
func (p *printer) writeSignatureInternal(this *types.Package, sig *types.Signature, visited []types.Type) { p.writeTuple(this, sig.Params(), sig.Variadic(), visited) res := sig.Results() n := res.Len() if n == 0 { // no result return } p.print(" ") if n == 1 && res.At(0).Name() == "" { // single unnamed result p.writeTypeInternal(this, res.At(0).Type(), visited) return } // multiple or named result(s) p.writeTuple(this, res, false, visited) }
func (tm *TypeMap) funcRuntimeType(f *types.Signature) (global, ptr llvm.Value) { rtype := tm.makeRtype(f, reflect.Func) funcType := llvm.ConstNull(tm.runtime.funcType.llvm) global, ptr = tm.makeRuntimeTypeGlobal(funcType, typeString(f)) tm.types.Set(f, runtimeTypeInfo{global, ptr}) funcType = llvm.ConstInsertValue(funcType, rtype, []uint32{0}) // dotdotdot if f.Variadic() { variadic := llvm.ConstInt(llvm.Int1Type(), 1, false) funcType = llvm.ConstInsertValue(funcType, variadic, []uint32{1}) } // in intypes := tm.rtypeSlice(f.Params()) funcType = llvm.ConstInsertValue(funcType, intypes, []uint32{2}) // out outtypes := tm.rtypeSlice(f.Results()) funcType = llvm.ConstInsertValue(funcType, outtypes, []uint32{3}) global.SetInitializer(funcType) return global, ptr }
func (p *exporter) signature(sig *types.Signature) { // TODO(gri) We only need to record the receiver type // for interface methods if we flatten them // out. If we track embedded types instead, // the information is already present. // We do need the receiver information (T vs *T) // for methods associated with named types. if recv := sig.Recv(); recv != nil { // 1-element tuple p.int(1) p.param(recv) } else { // 0-element tuple p.int(0) } p.tuple(sig.Params()) p.tuple(sig.Results()) if sig.Variadic() { p.int(1) } else { p.int(0) } }
func changeRecv(s *types.Signature, recv *types.Var) *types.Signature { return types.NewSignature(nil, recv, s.Params(), s.Results(), s.Variadic()) }