all: use lazyregexp (#5911)

* Use lazyregexp

* all: fix imports and usages

2 files changed, 143 insertions, 0 deletions

diff --git a/internal/lazyregexp/NOTICE b/internal/lazyregexp/NOTICE
new file mode 100644
index 00000000..9955f078
--- /dev/null
+++ b/internal/lazyregexp/NOTICE
@@ -0,0 +1,29 @@
+Code extended from https://raw.githubusercontent.com/golang/go/go1.13.3/src/internal/lazyregexp/lazyre.go
+
+Copyright (c) 2019 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/internal/lazyregexp/lazyre.go b/internal/lazyregexp/lazyre.go
new file mode 100644
index 00000000..79ce5a18
--- /dev/null
+++ b/internal/lazyregexp/lazyre.go
@@ -0,0 +1,114 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package lazyregexp is a thin wrapper over regexp, allowing the use of global
+// regexp variables without forcing them to be compiled at init.
+package lazyregexp
+
+import (
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+)
+
+// Regexp is a wrapper around regexp.Regexp, where the underlying regexp will be
+// compiled the first time it is needed.
+type Regexp struct {
+	str  string
+	once sync.Once
+	rx   *regexp.Regexp
+}
+
+func (r *Regexp) Regexp() *regexp.Regexp {
+	r.once.Do(r.build)
+	return r.rx
+}
+
+func (r *Regexp) build() {
+	r.rx = regexp.MustCompile(r.str)
+	r.str = ""
+}
+
+func (r *Regexp) Find(b []byte) []byte {
+	return r.Regexp().Find(b)
+}
+
+func (r *Regexp) FindSubmatch(s []byte) [][]byte {
+	return r.Regexp().FindSubmatch(s)
+}
+
+func (r *Regexp) FindStringSubmatch(s string) []string {
+	return r.Regexp().FindStringSubmatch(s)
+}
+
+func (r *Regexp) FindStringSubmatchIndex(s string) []int {
+	return r.Regexp().FindStringSubmatchIndex(s)
+}
+
+func (r *Regexp) ReplaceAllString(src, repl string) string {
+	return r.Regexp().ReplaceAllString(src, repl)
+}
+
+func (r *Regexp) FindString(s string) string {
+	return r.Regexp().FindString(s)
+}
+
+func (r *Regexp) FindAll(b []byte, n int) [][]byte {
+	return r.Regexp().FindAll(b, n)
+}
+
+func (r *Regexp) FindAllString(s string, n int) []string {
+	return r.Regexp().FindAllString(s, n)
+}
+
+func (r *Regexp) MatchString(s string) bool {
+	return r.Regexp().MatchString(s)
+}
+
+func (r *Regexp) SubexpNames() []string {
+	return r.Regexp().SubexpNames()
+}
+
+func (r *Regexp) FindAllStringSubmatch(s string, n int) [][]string {
+	return r.Regexp().FindAllStringSubmatch(s, n)
+}
+
+func (r *Regexp) Split(s string, n int) []string {
+	return r.Regexp().Split(s, n)
+}
+
+func (r *Regexp) ReplaceAllLiteralString(src, repl string) string {
+	return r.Regexp().ReplaceAllLiteralString(src, repl)
+}
+
+func (r *Regexp) FindAllIndex(b []byte, n int) [][]int {
+	return r.Regexp().FindAllIndex(b, n)
+}
+
+func (r *Regexp) Match(b []byte) bool {
+	return r.Regexp().Match(b)
+}
+
+func (r *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string {
+	return r.Regexp().ReplaceAllStringFunc(src, repl)
+}
+
+func (r *Regexp) ReplaceAll(src, repl []byte) []byte {
+	return r.Regexp().ReplaceAll(src, repl)
+}
+
+var inTest = len(os.Args) > 0 && strings.HasSuffix(strings.TrimSuffix(os.Args[0], ".exe"), ".test")
+
+// New creates a new lazy regexp, delaying the compiling work until it is first
+// needed. If the code is being run as part of tests, the regexp compiling will
+// happen immediately.
+func New(str string) *Regexp {
+	lr := &Regexp{str: str}
+	if inTest {
+		// In tests, always compile the regexps early.
+		lr.Regexp()
+	}
+	return lr
+}