Regular expression to capture a group that is optionally present in Go

I'm trying to write a regular expression that in a string representing Go code will replace the name of a type, say Bar, with an updated name, say FooBar, but only where it appears as the type of a field in another struct or as an array of that type. So I'd like to convert for example

type Foo struct {
    Bar  Bar
    Baz  []Bar
    Bars []Bar
}

into

type Foo struct {
    Bar  FooBar
    Baz  []FooBar
    Bars []FooBar
}

So far, I've managed to convert the array field types using this ReplaceAllString:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile(`(\w+)(\s+)\[\]Bar`)

    s := `type Foo struct {
    Bar  Bar
    Baz  []Bar
    Bars []Bar
}`

    fmt.Println(re.ReplaceAllString(s, `$1$2[]FooBar`))
}

which produces

type Foo struct {
    Bar  Bar
    Baz  []FooBar
    Bars []FooBar
}

The replacement of Bar is missing as the type of the first field, also named Bar. I've tried making the [] optional like so,

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile(`(\w+)(\s+)(\[\])?Bar`)

    s := `type Foo struct {
    Bar  Bar
    Baz  []Bar
    Bars []Bar
}`

    fmt.Println(re.ReplaceAllString(s, `$1$2$3FooBar`))
}

But this produces an output where all of the field types are missing:

type Foo struct {
    Bar
    Baz
    Bars
}

What is wrong here? (I could use a two-pass approach with two different regular expressions, but I would prefer to achieve this in one go).

Depending on your situation, gofmt might be a better option:

gofmt -r 'Bar -> FooBar' hello.go

File hello.go

package hello

type Foo struct {
        FooBar FooBar
        Baz    []FooBar
        Bars   []FooBar
}

https://godocs.io/cmd/gofmt

It turns out the third reference needs to be ${3}, not $3:

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`(\w+)(\s+)(\[\])?Bar`)

	s := `type Foo struct {
	Bar  Bar
	Baz  []Bar
	Bars []Bar
}`

	fmt.Println(re.ReplaceAllString(s, `$1$2FooBar`))
}

which produces the desired result

type Foo struct {
	Bar  FooBar
	Baz  []FooBar
	Bars []FooBar
}