Adding upstream version 1.20.14.upstream/1.20.14upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 299 insertions, 0 deletions

diff --git a/src/cmd/go/internal/str/path.go b/src/cmd/go/internal/str/path.go
new file mode 100644
index 0000000..c165b91
--- /dev/null
+++ b/src/cmd/go/internal/str/path.go
@@ -0,0 +1,86 @@
+// 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 str
+
+import (
+	"path/filepath"
+	"strings"
+)
+
+// HasPathPrefix reports whether the slash-separated path s
+// begins with the elements in prefix.
+func HasPathPrefix(s, prefix string) bool {
+	if len(s) == len(prefix) {
+		return s == prefix
+	}
+	if prefix == "" {
+		return true
+	}
+	if len(s) > len(prefix) {
+		if prefix[len(prefix)-1] == '/' || s[len(prefix)] == '/' {
+			return s[:len(prefix)] == prefix
+		}
+	}
+	return false
+}
+
+// HasFilePathPrefix reports whether the filesystem path s
+// begins with the elements in prefix.
+func HasFilePathPrefix(s, prefix string) bool {
+	sv := strings.ToUpper(filepath.VolumeName(s))
+	pv := strings.ToUpper(filepath.VolumeName(prefix))
+	s = s[len(sv):]
+	prefix = prefix[len(pv):]
+	switch {
+	default:
+		return false
+	case sv != pv:
+		return false
+	case len(s) == len(prefix):
+		return s == prefix
+	case prefix == "":
+		return true
+	case len(s) > len(prefix):
+		if prefix[len(prefix)-1] == filepath.Separator {
+			return strings.HasPrefix(s, prefix)
+		}
+		return s[len(prefix)] == filepath.Separator && s[:len(prefix)] == prefix
+	}
+}
+
+// TrimFilePathPrefix returns s without the leading path elements in prefix.
+// If s does not start with prefix (HasFilePathPrefix with the same arguments
+// returns false), TrimFilePathPrefix returns s. If s equals prefix,
+// TrimFilePathPrefix returns "".
+func TrimFilePathPrefix(s, prefix string) string {
+	if !HasFilePathPrefix(s, prefix) {
+		return s
+	}
+	trimmed := s[len(prefix):]
+	if len(trimmed) == 0 || trimmed[0] != filepath.Separator {
+		// Prefix either is equal to s, or ends with a separator
+		// (for example, if it is exactly "/").
+		return trimmed
+	}
+	return trimmed[1:]
+}
+
+// QuoteGlob returns s with all Glob metacharacters quoted.
+// We don't try to handle backslash here, as that can appear in a
+// file path on Windows.
+func QuoteGlob(s string) string {
+	if !strings.ContainsAny(s, `*?[]`) {
+		return s
+	}
+	var sb strings.Builder
+	for _, c := range s {
+		switch c {
+		case '*', '?', '[', ']':
+			sb.WriteByte('\\')
+		}
+		sb.WriteRune(c)
+	}
+	return sb.String()
+}
diff --git a/src/cmd/go/internal/str/str.go b/src/cmd/go/internal/str/str.go
new file mode 100644
index 0000000..af7c699
--- /dev/null
+++ b/src/cmd/go/internal/str/str.go
@@ -0,0 +1,113 @@
+// Copyright 2017 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 str provides string manipulation utilities.
+package str
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// StringList flattens its arguments into a single []string.
+// Each argument in args must have type string or []string.
+func StringList(args ...any) []string {
+	var x []string
+	for _, arg := range args {
+		switch arg := arg.(type) {
+		case []string:
+			x = append(x, arg...)
+		case string:
+			x = append(x, arg)
+		default:
+			panic("stringList: invalid argument of type " + fmt.Sprintf("%T", arg))
+		}
+	}
+	return x
+}
+
+// ToFold returns a string with the property that
+//
+//	strings.EqualFold(s, t) iff ToFold(s) == ToFold(t)
+//
+// This lets us test a large set of strings for fold-equivalent
+// duplicates without making a quadratic number of calls
+// to EqualFold. Note that strings.ToUpper and strings.ToLower
+// do not have the desired property in some corner cases.
+func ToFold(s string) string {
+	// Fast path: all ASCII, no upper case.
+	// Most paths look like this already.
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c >= utf8.RuneSelf || 'A' <= c && c <= 'Z' {
+			goto Slow
+		}
+	}
+	return s
+
+Slow:
+	var b strings.Builder
+	for _, r := range s {
+		// SimpleFold(x) cycles to the next equivalent rune > x
+		// or wraps around to smaller values. Iterate until it wraps,
+		// and we've found the minimum value.
+		for {
+			r0 := r
+			r = unicode.SimpleFold(r0)
+			if r <= r0 {
+				break
+			}
+		}
+		// Exception to allow fast path above: A-Z => a-z
+		if 'A' <= r && r <= 'Z' {
+			r += 'a' - 'A'
+		}
+		b.WriteRune(r)
+	}
+	return b.String()
+}
+
+// FoldDup reports a pair of strings from the list that are
+// equal according to strings.EqualFold.
+// It returns "", "" if there are no such strings.
+func FoldDup(list []string) (string, string) {
+	clash := map[string]string{}
+	for _, s := range list {
+		fold := ToFold(s)
+		if t := clash[fold]; t != "" {
+			if s > t {
+				s, t = t, s
+			}
+			return s, t
+		}
+		clash[fold] = s
+	}
+	return "", ""
+}
+
+// Contains reports whether x contains s.
+func Contains(x []string, s string) bool {
+	for _, t := range x {
+		if t == s {
+			return true
+		}
+	}
+	return false
+}
+
+// Uniq removes consecutive duplicate strings from ss.
+func Uniq(ss *[]string) {
+	if len(*ss) <= 1 {
+		return
+	}
+	uniq := (*ss)[:1]
+	for _, s := range *ss {
+		if s != uniq[len(uniq)-1] {
+			uniq = append(uniq, s)
+		}
+	}
+	*ss = uniq
+}
diff --git a/src/cmd/go/internal/str/str_test.go b/src/cmd/go/internal/str/str_test.go
new file mode 100644
index 0000000..158fe65
--- /dev/null
+++ b/src/cmd/go/internal/str/str_test.go
@@ -0,0 +1,100 @@
+// Copyright 2020 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 str
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+var foldDupTests = []struct {
+	list   []string
+	f1, f2 string
+}{
+	{StringList("math/rand", "math/big"), "", ""},
+	{StringList("math", "strings"), "", ""},
+	{StringList("strings"), "", ""},
+	{StringList("strings", "strings"), "strings", "strings"},
+	{StringList("Rand", "rand", "math", "math/rand", "math/Rand"), "Rand", "rand"},
+}
+
+func TestFoldDup(t *testing.T) {
+	for _, tt := range foldDupTests {
+		f1, f2 := FoldDup(tt.list)
+		if f1 != tt.f1 || f2 != tt.f2 {
+			t.Errorf("foldDup(%q) = %q, %q, want %q, %q", tt.list, f1, f2, tt.f1, tt.f2)
+		}
+	}
+}
+
+type trimFilePathPrefixTest struct {
+	s, prefix, want string
+}
+
+func TestTrimFilePathPrefixSlash(t *testing.T) {
+	if os.PathSeparator != '/' {
+		t.Skipf("test requires slash-separated file paths")
+	}
+	tests := []trimFilePathPrefixTest{
+		{"/foo", "", "foo"},
+		{"/foo", "/", "foo"},
+		{"/foo", "/foo", ""},
+		{"/foo/bar", "/foo", "bar"},
+		{"/foo/bar", "/foo/", "bar"},
+		// if prefix is not s's prefix, return s
+		{"/foo", "/bar", "/foo"},
+		{"/foo", "/foo/bar", "/foo"},
+	}
+
+	for _, tt := range tests {
+		if got := TrimFilePathPrefix(tt.s, tt.prefix); got != tt.want {
+			t.Errorf("TrimFilePathPrefix(%q, %q) = %q, want %q", tt.s, tt.prefix, got, tt.want)
+		}
+	}
+}
+
+func TestTrimFilePathPrefixWindows(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skipf("test requires Windows file paths")
+	}
+	tests := []trimFilePathPrefixTest{
+		{`C:\foo`, `C:`, `foo`},
+		{`C:\foo`, `C:\`, `foo`},
+		{`C:\foo`, `C:\foo`, ``},
+		{`C:\foo\bar`, `C:\foo`, `bar`},
+		{`C:\foo\bar`, `C:\foo\`, `bar`},
+		// if prefix is not s's prefix, return s
+		{`C:\foo`, `C:\bar`, `C:\foo`},
+		{`C:\foo`, `C:\foo\bar`, `C:\foo`},
+		// if volumes are different, return s
+		{`C:\foo`, ``, `C:\foo`},
+		{`C:\foo`, `\foo`, `C:\foo`},
+		{`C:\foo`, `D:\foo`, `C:\foo`},
+
+		//UNC path
+		{`\\host\share\foo`, `\\host\share`, `foo`},
+		{`\\host\share\foo`, `\\host\share\`, `foo`},
+		{`\\host\share\foo`, `\\host\share\foo`, ``},
+		{`\\host\share\foo\bar`, `\\host\share\foo`, `bar`},
+		{`\\host\share\foo\bar`, `\\host\share\foo\`, `bar`},
+		// if prefix is not s's prefix, return s
+		{`\\host\share\foo`, `\\host\share\bar`, `\\host\share\foo`},
+		{`\\host\share\foo`, `\\host\share\foo\bar`, `\\host\share\foo`},
+		// if either host or share name is different, return s
+		{`\\host\share\foo`, ``, `\\host\share\foo`},
+		{`\\host\share\foo`, `\foo`, `\\host\share\foo`},
+		{`\\host\share\foo`, `\\host\other\`, `\\host\share\foo`},
+		{`\\host\share\foo`, `\\other\share\`, `\\host\share\foo`},
+		{`\\host\share\foo`, `\\host\`, `\\host\share\foo`},
+		{`\\host\share\foo`, `\share\`, `\\host\share\foo`},
+	}
+
+	for _, tt := range tests {
+		if got := TrimFilePathPrefix(tt.s, tt.prefix); got != tt.want {
+			t.Errorf("TrimFilePathPrefix(%q, %q) = %q, want %q", tt.s, tt.prefix, got, tt.want)
+		}
+	}
+}