Update module github.com/containers/storage to v1.47.0

Signed-off-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

vendor/github.com/containers/storage/pkg/regexp/regexp.go

@@ -10,14 +10,17 @@ import (
 // used as global variables. Using this structure helps speed the startup time
 // of apps that want to use global regex variables. This library initializes them on
 // first use as opposed to the start of the executable.
-type Regexp struct {
+type Regexp = *regexpStruct
+
+type regexpStruct struct {
+	_      noCopy
 	once   sync.Once
 	regexp *regexp.Regexp
 	val    string
 }
 
 func Delayed(val string) Regexp {
-	re := Regexp{
+	re := &regexpStruct{
 		val: val,
 	}
 	if precompile {
@@ -26,7 +29,7 @@ func Delayed(val string) Regexp {
 	return re
 }
 
-func (re *Regexp) compile() {
+func (re *regexpStruct) compile() {
 	if precompile {
 		return
 	}
@@ -35,180 +38,195 @@ func (re *Regexp) compile() {
 	})
 }
 
-func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte {
+func (re *regexpStruct) Expand(dst []byte, template []byte, src []byte, match []int) []byte {
 	re.compile()
 	return re.regexp.Expand(dst, template, src, match)
 }
 
-func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte {
+func (re *regexpStruct) ExpandString(dst []byte, template string, src string, match []int) []byte {
 	re.compile()
 	return re.regexp.ExpandString(dst, template, src, match)
 }
-func (re *Regexp) Find(b []byte) []byte {
+
+func (re *regexpStruct) Find(b []byte) []byte {
 	re.compile()
 	return re.regexp.Find(b)
 }
 
-func (re *Regexp) FindAll(b []byte, n int) [][]byte {
+func (re *regexpStruct) FindAll(b []byte, n int) [][]byte {
 	re.compile()
 	return re.regexp.FindAll(b, n)
 }
 
-func (re *Regexp) FindAllIndex(b []byte, n int) [][]int {
+func (re *regexpStruct) FindAllIndex(b []byte, n int) [][]int {
 	re.compile()
 	return re.regexp.FindAllIndex(b, n)
 }
 
-func (re *Regexp) FindAllString(s string, n int) []string {
+func (re *regexpStruct) FindAllString(s string, n int) []string {
 	re.compile()
 	return re.regexp.FindAllString(s, n)
 }
 
-func (re *Regexp) FindAllStringIndex(s string, n int) [][]int {
+func (re *regexpStruct) FindAllStringIndex(s string, n int) [][]int {
 	re.compile()
 	return re.regexp.FindAllStringIndex(s, n)
 }
 
-func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string {
+func (re *regexpStruct) FindAllStringSubmatch(s string, n int) [][]string {
 	re.compile()
 	return re.regexp.FindAllStringSubmatch(s, n)
 }
 
-func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int {
+func (re *regexpStruct) FindAllStringSubmatchIndex(s string, n int) [][]int {
 	re.compile()
 	return re.regexp.FindAllStringSubmatchIndex(s, n)
 }
 
-func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte {
+func (re *regexpStruct) FindAllSubmatch(b []byte, n int) [][][]byte {
 	re.compile()
 	return re.regexp.FindAllSubmatch(b, n)
 }
 
-func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int {
+func (re *regexpStruct) FindAllSubmatchIndex(b []byte, n int) [][]int {
 	re.compile()
 	return re.regexp.FindAllSubmatchIndex(b, n)
 }
 
-func (re *Regexp) FindIndex(b []byte) (loc []int) {
+func (re *regexpStruct) FindIndex(b []byte) (loc []int) {
 	re.compile()
 	return re.regexp.FindIndex(b)
 }
 
-func (re *Regexp) FindReaderIndex(r io.RuneReader) (loc []int) {
+func (re *regexpStruct) FindReaderIndex(r io.RuneReader) (loc []int) {
 	re.compile()
 	return re.regexp.FindReaderIndex(r)
 }
 
-func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int {
+func (re *regexpStruct) FindReaderSubmatchIndex(r io.RuneReader) []int {
 	re.compile()
 	return re.regexp.FindReaderSubmatchIndex(r)
 }
 
-func (re *Regexp) FindString(s string) string {
+func (re *regexpStruct) FindString(s string) string {
 	re.compile()
 	return re.regexp.FindString(s)
 }
 
-func (re *Regexp) FindStringIndex(s string) (loc []int) {
+func (re *regexpStruct) FindStringIndex(s string) (loc []int) {
 	re.compile()
 	return re.regexp.FindStringIndex(s)
 }
 
-func (re *Regexp) FindStringSubmatch(s string) []string {
+func (re *regexpStruct) FindStringSubmatch(s string) []string {
 	re.compile()
 	return re.regexp.FindStringSubmatch(s)
 }
 
-func (re *Regexp) FindStringSubmatchIndex(s string) []int {
+func (re *regexpStruct) FindStringSubmatchIndex(s string) []int {
 	re.compile()
 	return re.regexp.FindStringSubmatchIndex(s)
 }
 
-func (re *Regexp) FindSubmatch(b []byte) [][]byte {
+func (re *regexpStruct) FindSubmatch(b []byte) [][]byte {
 	re.compile()
 	return re.regexp.FindSubmatch(b)
 }
 
-func (re *Regexp) FindSubmatchIndex(b []byte) []int {
+func (re *regexpStruct) FindSubmatchIndex(b []byte) []int {
 	re.compile()
 	return re.regexp.FindSubmatchIndex(b)
 }
 
-func (re *Regexp) LiteralPrefix() (prefix string, complete bool) {
+func (re *regexpStruct) LiteralPrefix() (prefix string, complete bool) {
 	re.compile()
 	return re.regexp.LiteralPrefix()
 }
 
-func (re *Regexp) Longest() {
+func (re *regexpStruct) Longest() {
 	re.compile()
 	re.regexp.Longest()
 }
 
-func (re *Regexp) Match(b []byte) bool {
+func (re *regexpStruct) Match(b []byte) bool {
 	re.compile()
 	return re.regexp.Match(b)
 }
 
-func (re *Regexp) MatchReader(r io.RuneReader) bool {
+func (re *regexpStruct) MatchReader(r io.RuneReader) bool {
 	re.compile()
 	return re.regexp.MatchReader(r)
 }
-func (re *Regexp) MatchString(s string) bool {
+
+func (re *regexpStruct) MatchString(s string) bool {
 	re.compile()
 	return re.regexp.MatchString(s)
 }
 
-func (re *Regexp) NumSubexp() int {
+func (re *regexpStruct) NumSubexp() int {
 	re.compile()
 	return re.regexp.NumSubexp()
 }
 
-func (re *Regexp) ReplaceAll(src, repl []byte) []byte {
+func (re *regexpStruct) ReplaceAll(src, repl []byte) []byte {
 	re.compile()
 	return re.regexp.ReplaceAll(src, repl)
 }
 
-func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte {
+func (re *regexpStruct) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte {
 	re.compile()
 	return re.regexp.ReplaceAllFunc(src, repl)
 }
 
-func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte {
+func (re *regexpStruct) ReplaceAllLiteral(src, repl []byte) []byte {
 	re.compile()
 	return re.regexp.ReplaceAllLiteral(src, repl)
 }
 
-func (re *Regexp) ReplaceAllLiteralString(src, repl string) string {
+func (re *regexpStruct) ReplaceAllLiteralString(src, repl string) string {
 	re.compile()
 	return re.regexp.ReplaceAllLiteralString(src, repl)
 }
 
-func (re *Regexp) ReplaceAllString(src, repl string) string {
+func (re *regexpStruct) ReplaceAllString(src, repl string) string {
 	re.compile()
 	return re.regexp.ReplaceAllString(src, repl)
 }
 
-func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string {
+func (re *regexpStruct) ReplaceAllStringFunc(src string, repl func(string) string) string {
 	re.compile()
 	return re.regexp.ReplaceAllStringFunc(src, repl)
 }
 
-func (re *Regexp) Split(s string, n int) []string {
+func (re *regexpStruct) Split(s string, n int) []string {
 	re.compile()
 	return re.regexp.Split(s, n)
 }
 
-func (re *Regexp) String() string {
+func (re *regexpStruct) String() string {
 	re.compile()
 	return re.regexp.String()
 }
 
-func (re *Regexp) SubexpIndex(name string) int {
+func (re *regexpStruct) SubexpIndex(name string) int {
 	re.compile()
 	return re.regexp.SubexpIndex(name)
 }
 
-func (re *Regexp) SubexpNames() []string {
+func (re *regexpStruct) SubexpNames() []string {
 	re.compile()
 	return re.regexp.SubexpNames()
 }
+
+// noCopy may be added to structs which must not be copied
+// after the first use.
+//
+// See https://golang.org/issues/8005#issuecomment-190753527
+// for details.
+//
+// Note that it must not be embedded, due to the Lock and Unlock methods.
+type noCopy struct{}
+
+// Lock is a no-op used by -copylocks checker from `go vet`.
+func (*noCopy) Lock()   {}
+func (*noCopy) Unlock() {}