delegates: keep a goroutine alive during the lifecycle of delegates

There's an error in the Go runtime that causes a deadlock error whenever
we are waiting for a delegate callback to happen. This is because Go is
not able to detect that we are going to receive a syscall in the future.
See this for more information: golang/go#55015

internal/codegen/templates/delegate.tmpl

@@ -23,6 +23,11 @@ var callbacks{{.Name}} = &{{.Name | toLower}}CallbacksMap {
 	callbacks: make(map[unsafe.Pointer]{{.Name}}Callback),
 }
 
+var releaseChans{{.Name}} = &{{.Name | toLower}}ReleaseChannelsMap {
+	mu:        &sync.Mutex{},
+	chans: make(map[unsafe.Pointer]chan struct{}),
+}
+
 func New{{.Name}}(iid *ole.GUID, callback {{.Name}}Callback) *{{.Name}} {
 	size := unsafe.Sizeof(*(*{{.Name}})(nil))
 	instPtr := kernel32.Malloc(size)
@@ -42,6 +47,9 @@ func New{{.Name}}(iid *ole.GUID, callback {{.Name}}Callback) *{{.Name}} {
 
 	callbacks{{.Name}}.add(unsafe.Pointer(inst), callback)
 
+	// See the docs in the releaseChans{{.Name}} struct
+	releaseChans{{.Name}}.create(unsafe.Pointer(inst))
+
 	inst.addRef()
 	return inst
 }
@@ -127,6 +135,11 @@ func (instance *{{.Name}}) Release() uint64 {
 		// We're done.
 		instancePtr := unsafe.Pointer(instance)
 		callbacks{{.Name}}.delete(instancePtr)
+
+		// stop release channels used to avoid
+		// https://github.com/golang/go/issues/55015
+		releaseChans{{.Name}}.release(instancePtr)
+
 		kernel32.Free(instancePtr)
 	}
 	return rem
@@ -158,3 +171,48 @@ func (m *{{.Name | toLower}}CallbacksMap) delete(p unsafe.Pointer) {
 
 	delete(m.callbacks, p)
 }
+
+// typedEventHandlerReleaseChannelsMap keeps a map with channels
+// used to keep a goroutine alive during the lifecycle of this object.
+// This is required to avoid causing a deadlock error.
+// See this: https://github.com/golang/go/issues/55015
+type {{.Name | toLower}}ReleaseChannelsMap struct {
+	mu        *sync.Mutex
+	chans map[unsafe.Pointer]chan struct{}
+}
+
+func (m *{{.Name | toLower}}ReleaseChannelsMap) create(p unsafe.Pointer) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	c := make(chan struct{})
+	m.chans[p] = c
+
+	go func() {
+		// we need a timer to trick the go runtime into
+		// thinking there's still something going on here
+		// but we are only really interested in <-c
+		t := time.NewTimer(time.Minute)
+		for {
+			select {
+			case <-t.C:
+				t.Reset(time.Minute)
+			case <-c:
+				if !t.Stop(){
+					<-t.C
+				}
+				return
+			}
+		}
+	}()
+}
+
+func (m *{{.Name | toLower}}ReleaseChannelsMap) release(p unsafe.Pointer) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if c, ok := m.chans[p]; ok {
+		close(c)
+		delete(m.chans, p)
+	}
+}