Read function body from a function passed as argument at runtime

I have some dynamic code generated and compiled - then I need to read function body at runtime, is that possible?

package example

import (
	"fmt"
	"testing"
)

type TestStruct struct {}

func (TestStruct) New() *TestStruct {
	return &TestStruct{}
}

// CreateFunction func
func (t *TestStruct) CreateFunction(runFunc func(args []string)) {
	// Read code block, switch values from function pointer
	//val := reflect.ValueOf(t)....?
	fmt.Println(val[0]) // << read switch string option "one"
	fmt.Println(val[1]) // << read switch string option "two"
}

// Testing
func TestReflection(t *testing.T) {
	TestStruct{}.New().CreateFunction(func(args []string) {
		sw := "one"
		switch sw {
		case "one":
			fmt.Println("some text")
		case "two":
			fmt.Println("some text")
		}
	})
}

If it is for testing purposes, the following code is feasible. I just printed out the body of function, you could try to parse the SwitchStmt in function body and get what you need.

package main

import (
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
	"io"
	"log"
	"os"
	"reflect"
	"runtime"
	"testing"
)

type TestStruct struct{}

func (TestStruct) New() *TestStruct {
	return &TestStruct{}
}

type FindBlockByLine struct {
	Fset  *token.FileSet
	Line  int
	Block *ast.BlockStmt
}

func (f *FindBlockByLine) Visit(node ast.Node) ast.Visitor {
	if node == nil {
		return nil
	}

	if blockStmt, ok := node.(*ast.BlockStmt); ok {
		stmtStartingPosition := blockStmt.Pos()
		stmtLine := f.Fset.Position(stmtStartingPosition).Line
		if stmtLine == f.Line {
			f.Block = blockStmt
			return nil
		}
	}
	return f
}

// CreateFunction func
func (t *TestStruct) CreateFunction(runFunc func(args []string)) {
	p := reflect.ValueOf(runFunc).Pointer()
	fc := runtime.FuncForPC(p)
    // get filename and line number of runFunc
	filename, line := fc.FileLine(p)
	fset := token.NewFileSet()
    // parse file to AST tree
	node, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
	if err != nil {
		log.Fatal(err)
	}
    // walk and find the function block
	find := &FindBlockByLine{Fset: fset, Line: line}
	ast.Walk(find, node)

	if find.Block != nil {
		fp, err := os.Open(filename)
		if err != nil {
			log.Fatal(err)
		}
        defer fp.Close()
		fp.Seek(int64(find.Block.Lbrace-1), 0)
		buf := make([]byte, int64(find.Block.Rbrace-find.Block.Lbrace))
		_, err = io.ReadFull(fp, buf)
		if err != nil {
			log.Fatal(err)
		}

		fmt.Println("code of runFunc:", string(buf))
	}
	// Read code block, switch values from function pointer
	// val := reflect.ValueOf(t)....?
	// fmt.Println(val[0]) // << read switch string option "one"
	// fmt.Println(val[1]) // << read switch string option "two"
}

// Testing
func TestReflection(t *testing.T) {
	TestStruct{}.New().CreateFunction(func(args []string) {
		sw := "one"
		switch sw {
		case "one":
			fmt.Println("some text")
		case "two":
			fmt.Println("some text")
		}
	})
}

output:

$ go test -v -run TestReflection
=== RUN   TestReflection
/xxxxxxxxxx.go 82
code of runFunc: {
sw := "one"
switch sw {
case "one":
fmt.Println("some text")
case "two":
fmt.Println("some text")
}
--- PASS: TestReflection (0.00s)
PASS
ok  	maint	0.501s