How to use the struct inside a struct? invalid memory address or nil pointer dereference

I am getting an panic when I want to use Queue. This is my struct:

type RabbitMQ struct {
Connection    *amqp.Connection
Channel       *amqp.Channel
Queue         amqp.Queue // for consumer
done          chan os.Signal
notifyClose   chan *amqp.Error
notifyConfirm chan *amqp.Confirmation
IsConnected   bool
alive         bool
Done          chan os.Signal
Err           chan error
Wg            *sync.WaitGroup
}

This is the original Queue struct inside original library.

type Queue struct {
Name      string // server confirmed or generated name
Messages  int    // count of messages not awaiting acknowledgment
Consumers int    // number of consumers receiving deliveries
}

Here in this function I am trying to use r.Queue by:

func (r *RabbitMQ) InitQueueForConsumer() {
log.Println("inside initqueue")
var err error
r.Queue, err = r.Channel.QueueDeclare(
"",    // name
false, // durable
false, // delete when unused
true,  // exclusive
false, // no-wait
nil,   // arguments
)
if err != nil {
log.Printf("failed to declare a queue")
}
log.Println("inside initqueue")
err = r.Channel.QueueBind(
r.Queue.Name,
"",
"logs",
false,
nil,
)
if err != nil {
log.Printf("failed to bind a queue")
}
log.Println("inside initqueue")
}
func (r *RabbitMQ) Consume() {
msgs, err := r.Channel.Consume(
r.Queue.Name,
"",
true,
false,
false,
false,
nil,
)
if err != nil {
log.Printf("failed to register a consumer")
}
forever := make(chan bool)
go func() {
for {
select {
case msg, ok := <-msgs:
if !ok {
log.Printf("something wrong")
return
}
log.Printf("Received message: [%v]\n", msg)
}
}
}()
log.Printf("Waiting for logs")
<-forever
}

I am calling this function like:

rmq := shared.RabbitMQ{}
go rmq.New()
for {
go rmq.InitQueueForConsumer()
}

When I run I am getting the panic as follows:

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x54 pc=0x11c27c6]
goroutine 22 [running]:
github.com/streadway/amqp.(*Channel).send(0x0, 0x1283c78, 0xc0000b0000, 0xc000071e28, 0x100e86a)
/Users/barisertas/go/pkg/mod/github.com/streadway/amqp@v1.0.0/channel.go:157 +0x26
github.com/streadway/amqp.(*Channel).call(0x0, 0x1283c78, 0xc0000b0000, 0xc000071f40, 0x1, 0x1, 0xc000100050, 0x2)
/Users/barisertas/go/pkg/mod/github.com/streadway/amqp@v1.0.0/channel.go:171 +0x5d
github.com/streadway/amqp.(*Channel).QueueDeclare(0x0, 0x0, 0x0, 0x10000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, ...)
/Users/barisertas/go/pkg/mod/github.com/streadway/amqp@v1.0.0/channel.go:767 +0x150
github.com/bariis/rd/shared.(*RabbitMQ).InitQueueForConsumer(0xc000152000)
/Users/barisertas/workspace/golang-exercises/rd/shared/rabbitmq.go:151 +0x90
created by main.main
/Users/barisertas/workspace/golang-exercises/rd/receiver1/main.go:67 +0x76
exit status 2

And this what queueDeclare function returns from the original library:

func (ch *Channel) QueueDeclare(name string, durable, autoDelete, exclusive, noWait bool, args Table) (Queue, error) {
if err := args.Validate(); err != nil {
return Queue{}, err
}
req := &queueDeclare{
Queue:      name,
Passive:    false,
Durable:    durable,
AutoDelete: autoDelete,
Exclusive:  exclusive,
NoWait:     noWait,
Arguments:  args,
}
res := &queueDeclareOk{}
if err := ch.call(req, res); err != nil {
return Queue{}, err
}
if req.wait() {
return Queue{
Name:      res.Queue,
Messages:  int(res.MessageCount),
Consumers: int(res.ConsumerCount),
}, nil
}
return Queue{Name: name}, nil
}

I have tried every combination did with pointer, address etc. I tried to initialize it New function since it's called before QueueDeclare function I though It won't give panic but no solution. How can I do this properly?

rmq := shared.RabbitMQ{} not initialising any fields in RabbitMQ{}. It assigns zero (default) values for all fields.

Zero (default) value of a pointer is nil. tour here

So all pointers are nil inside RabbitMQ{}. So, when you going to access them in InitQueueForConsumer(), sure it will panic with runtime error: invalid memory address or nil pointer dereference.

First Initialise atleast pointer fields before using them.

Zero (default) value of a channel is also nil. refer -why-are-there-nil-channels-in-go.

But send to/receive from a nil channel not panics, but blocks forever. Closing a nil channel will panic with runtime error: close of nil channel