ssa: program.Closure, removeCtx for MakeClosure

ssa/di.go

@@ -179,7 +179,7 @@ func (b diBuilder) createType(name string, ty Type, pos token.Position) DIType {
 	case *types.Struct:
 		return b.createStructType(name, ty, pos)
 	case *types.Signature:
-		tyFn := b.prog.Closure(ty)
+		tyFn := b.prog.Closure(t)
 		return b.createFuncPtrType(name, tyFn, pos)
 	case *types.Array:
 		return b.createArrayType(ty, t.Len())
@@ -600,7 +600,7 @@ func (b Builder) doConstructDebugAddr(v Expr, t types.Type) (dbgPtr Expr, dbgVal
 	case *types.Slice:
 		ty = b.Prog.Type(b.Prog.rtType("Slice").RawType().Underlying(), InGo)
 	case *types.Signature:
-		ty = b.Prog.Closure(b.Prog.rawType(t))
+		ty = b.Prog.Closure(t)
 	case *types.Named:
 		ty = b.Prog.Type(t.Underlying(), InGo)
 	case *types.Map:

ssa/expr.go

@@ -924,19 +924,17 @@ func (b Builder) MakeClosure(fn Expr, bindings []Expr) Expr {
 	tctx := sig.Params().At(0).Type().Underlying().(*types.Pointer).Elem().(*types.Struct)
 	flds := llvmFields(bindings, tctx, b)
 	data := b.aggregateAllocU(prog.rawType(tctx), flds...)
-	return b.aggregateValue(closureType(prog, sig), fn.impl, data)
+	return b.aggregateValue(prog.Closure(removeCtx(sig)), fn.impl, data)
 }
 
-func closureType(p Program, sig *types.Signature) Type {
+func removeCtx(sig *types.Signature) *types.Signature {
 	params := sig.Params()
 	n := params.Len()
 	args := make([]*types.Var, n-1)
 	for i := 0; i < n-1; i++ {
 		args[i] = params.At(i + 1)
 	}
-	sig = types.NewSignature(sig.Recv(), types.NewTuple(args...), sig.Results(), sig.Variadic())
-	closure := p.gocvt.cvtClosure(sig)
-	return p.rawType(closure)
+	return types.NewSignature(sig.Recv(), types.NewTuple(args...), sig.Results(), sig.Variadic())
 }
 
 // -----------------------------------------------------------------------------

ssa/type_cvt.go

@@ -67,8 +67,7 @@ func (p Program) FuncDecl(sig *types.Signature, bg Background) Type {
 }
 
 // Closure creates a closture type for a function.
-func (p Program) Closure(fn Type) Type {
-	sig := fn.raw.Type.(*types.Signature)
+func (p Program) Closure(sig *types.Signature) Type {
 	closure := p.gocvt.cvtClosure(sig)
 	return p.rawType(closure)
 }