package bar
    import "fmt"

    type T string

    func (t T) String() string {
            return "earlier compile (" + string(t) + ")"
    }

    func Bar() interface{} {
            // Call Println to prevent inlining.
            fmt.Println("earlier called")
            return T("earlier")
    }

package main
import "local/bar"

var X interface{} = bar.Bar()

package main
import (
    "fmt"
    "log"
    "local/bar"
    "plugin"
)

func main() {
    x0 := bar.Bar()
    x1 := get("/home/rog/src/go/src/local/foo/foo.so")
    fmt.Printf("x0 %q %T\n", x0, x0)
    fmt.Printf("x1 %q %T\n", x1, x1)
}

func get(path string) interface{} {
    p, err := plugin.Open(path)
    if err != nil {
        log.Fatal(err)
    }
    sym, err := p.Lookup("X")
    if err != nil {
        log.Fatal(err)
    }
    switch sym := sym.(type) {
    case *interface{}:
        return *sym
    default:
        log.Fatalf("unexpected type %T", sym)
        panic("not reached")
    }
}

later called
earlier called
x0 "later compile (later)" bar.T
x1 "later compile (earlier)" bar.T