1 files changed, 19 insertions, 199 deletions

diff --git a/src/path/filepath/path.go b/src/path/filepath/path.go
index 6c8a0aa8b3..b0f3cbbfe9 100644
--- a/src/path/filepath/path.go
+++ b/src/path/filepath/path.go
@@ -13,58 +13,13 @@ package filepath
 
 import (
 	"errors"
-	"internal/safefilepath"
+	"internal/bytealg"
+	"internal/filepathlite"
 	"io/fs"
 	"os"
-	"slices"
 	"sort"
-	"strings"
 )
 
-// A lazybuf is a lazily constructed path buffer.
-// It supports append, reading previously appended bytes,
-// and retrieving the final string. It does not allocate a buffer
-// to hold the output until that output diverges from s.
-type lazybuf struct {
-	path       string
-	buf        []byte
-	w          int
-	volAndPath string
-	volLen     int
-}
-
-func (b *lazybuf) index(i int) byte {
-	if b.buf != nil {
-		return b.buf[i]
-	}
-	return b.path[i]
-}
-
-func (b *lazybuf) append(c byte) {
-	if b.buf == nil {
-		if b.w < len(b.path) && b.path[b.w] == c {
-			b.w++
-			return
-		}
-		b.buf = make([]byte, len(b.path))
-		copy(b.buf, b.path[:b.w])
-	}
-	b.buf[b.w] = c
-	b.w++
-}
-
-func (b *lazybuf) prepend(prefix ...byte) {
-	b.buf = slices.Insert(b.buf, 0, prefix...)
-	b.w += len(prefix)
-}
-
-func (b *lazybuf) string() string {
-	if b.buf == nil {
-		return b.volAndPath[:b.volLen+b.w]
-	}
-	return b.volAndPath[:b.volLen] + string(b.buf[:b.w])
-}
-
 const (
 	Separator     = os.PathSeparator
 	ListSeparator = os.PathListSeparator
@@ -98,78 +53,7 @@ const (
 // Getting Dot-Dot Right,”
 // https://9p.io/sys/doc/lexnames.html
 func Clean(path string) string {
-	originalPath := path
-	volLen := volumeNameLen(path)
-	path = path[volLen:]
-	if path == "" {
-		if volLen > 1 && os.IsPathSeparator(originalPath[0]) && os.IsPathSeparator(originalPath[1]) {
-			// should be UNC
-			return FromSlash(originalPath)
-		}
-		return originalPath + "."
-	}
-	rooted := os.IsPathSeparator(path[0])
-
-	// Invariants:
-	//	reading from path; r is index of next byte to process.
-	//	writing to buf; w is index of next byte to write.
-	//	dotdot is index in buf where .. must stop, either because
-	//		it is the leading slash or it is a leading ../../.. prefix.
-	n := len(path)
-	out := lazybuf{path: path, volAndPath: originalPath, volLen: volLen}
-	r, dotdot := 0, 0
-	if rooted {
-		out.append(Separator)
-		r, dotdot = 1, 1
-	}
-
-	for r < n {
-		switch {
-		case os.IsPathSeparator(path[r]):
-			// empty path element
-			r++
-		case path[r] == '.' && (r+1 == n || os.IsPathSeparator(path[r+1])):
-			// . element
-			r++
-		case path[r] == '.' && path[r+1] == '.' && (r+2 == n || os.IsPathSeparator(path[r+2])):
-			// .. element: remove to last separator
-			r += 2
-			switch {
-			case out.w > dotdot:
-				// can backtrack
-				out.w--
-				for out.w > dotdot && !os.IsPathSeparator(out.index(out.w)) {
-					out.w--
-				}
-			case !rooted:
-				// cannot backtrack, but not rooted, so append .. element.
-				if out.w > 0 {
-					out.append(Separator)
-				}
-				out.append('.')
-				out.append('.')
-				dotdot = out.w
-			}
-		default:
-			// real path element.
-			// add slash if needed
-			if rooted && out.w != 1 || !rooted && out.w != 0 {
-				out.append(Separator)
-			}
-			// copy element
-			for ; r < n && !os.IsPathSeparator(path[r]); r++ {
-				out.append(path[r])
-			}
-		}
-	}
-
-	// Turn empty string into "."
-	if out.w == 0 {
-		out.append('.')
-	}
-
-	postClean(&out) // avoid creating absolute paths on Windows
-	return FromSlash(out.string())
+	return filepathlite.Clean(path)
 }
 
 // IsLocal reports whether path, using lexical analysis only, has all of these properties:
@@ -187,29 +71,7 @@ func Clean(path string) string {
 // In particular, it does not account for the effect of any symbolic links
 // that may exist in the filesystem.
 func IsLocal(path string) bool {
-	return isLocal(path)
-}
-
-func unixIsLocal(path string) bool {
-	if IsAbs(path) || path == "" {
-		return false
-	}
-	hasDots := false
-	for p := path; p != ""; {
-		var part string
-		part, p, _ = strings.Cut(p, "/")
-		if part == "." || part == ".." {
-			hasDots = true
-			break
-		}
-	}
-	if hasDots {
-		path = Clean(path)
-	}
-	if path == ".." || strings.HasPrefix(path, "../") {
-		return false
-	}
-	return true
+	return filepathlite.IsLocal(path)
 }
 
 // Localize converts a slash-separated path into an operating system path.
@@ -221,17 +83,14 @@ func unixIsLocal(path string) bool {
 //
 // The path returned by Localize will always be local, as reported by IsLocal.
 func Localize(path string) (string, error) {
-	return safefilepath.Localize(path)
+	return filepathlite.Localize(path)
 }
 
 // ToSlash returns the result of replacing each separator character
 // in path with a slash ('/') character. Multiple separators are
 // replaced by multiple slashes.
 func ToSlash(path string) string {
-	if Separator == '/' {
-		return path
-	}
-	return strings.ReplaceAll(path, string(Separator), "/")
+	return filepathlite.ToSlash(path)
 }
 
 // FromSlash returns the result of replacing each slash ('/') character
@@ -241,10 +100,7 @@ func ToSlash(path string) string {
 // See also the Localize function, which converts a slash-separated path
 // as used by the io/fs package to an operating system path.
 func FromSlash(path string) string {
-	if Separator == '/' {
-		return path
-	}
-	return strings.ReplaceAll(path, "/", string(Separator))
+	return filepathlite.FromSlash(path)
 }
 
 // SplitList splits a list of paths joined by the OS-specific [ListSeparator],
@@ -261,12 +117,7 @@ func SplitList(path string) []string {
 // and file set to path.
 // The returned values have the property that path = dir+file.
 func Split(path string) (dir, file string) {
-	vol := VolumeName(path)
-	i := len(path) - 1
-	for i >= len(vol) && !os.IsPathSeparator(path[i]) {
-		i--
-	}
-	return path[:i+1], path[i+1:]
+	return filepathlite.Split(path)
 }
 
 // Join joins any number of path elements into a single path,
@@ -285,12 +136,7 @@ func Join(elem ...string) string {
 // in the final element of path; it is empty if there is
 // no dot.
 func Ext(path string) string {
-	for i := len(path) - 1; i >= 0 && !os.IsPathSeparator(path[i]); i-- {
-		if path[i] == '.' {
-			return path[i:]
-		}
-	}
-	return ""
+	return filepathlite.Ext(path)
 }
 
 // EvalSymlinks returns the path name after the evaluation of any symbolic
@@ -302,6 +148,11 @@ func EvalSymlinks(path string) (string, error) {
 	return evalSymlinks(path)
 }
 
+// IsAbs reports whether the path is absolute.
+func IsAbs(path string) bool {
+	return filepathlite.IsAbs(path)
+}
+
 // Abs returns an absolute representation of path.
 // If the path is not absolute it will be joined with the current
 // working directory to turn it into an absolute path. The absolute
@@ -342,7 +193,7 @@ func Rel(basepath, targpath string) (string, error) {
 	targ = targ[len(targVol):]
 	if base == "." {
 		base = ""
-	} else if base == "" && volumeNameLen(baseVol) > 2 /* isUNC */ {
+	} else if base == "" && filepathlite.VolumeNameLen(baseVol) > 2 /* isUNC */ {
 		// Treat any targetpath matching `\\host\share` basepath as absolute path.
 		base = string(Separator)
 	}
@@ -381,7 +232,7 @@ func Rel(basepath, targpath string) (string, error) {
 	}
 	if b0 != bl {
 		// Base elements left. Must go up before going down.
-		seps := strings.Count(base[b0:bl], string(Separator))
+		seps := bytealg.CountString(base[b0:bl], Separator)
 		size := 2 + seps*3
 		if tl != t0 {
 			size += 1 + tl - t0
@@ -602,28 +453,7 @@ func readDirNames(dirname string) ([]string, error) {
 // If the path is empty, Base returns ".".
 // If the path consists entirely of separators, Base returns a single separator.
 func Base(path string) string {
-	if path == "" {
-		return "."
-	}
-	// Strip trailing slashes.
-	for len(path) > 0 && os.IsPathSeparator(path[len(path)-1]) {
-		path = path[0 : len(path)-1]
-	}
-	// Throw away volume name
-	path = path[len(VolumeName(path)):]
-	// Find the last element
-	i := len(path) - 1
-	for i >= 0 && !os.IsPathSeparator(path[i]) {
-		i--
-	}
-	if i >= 0 {
-		path = path[i+1:]
-	}
-	// If empty now, it had only slashes.
-	if path == "" {
-		return string(Separator)
-	}
-	return path
+	return filepathlite.Base(path)
 }
 
 // Dir returns all but the last element of path, typically the path's directory.
@@ -633,17 +463,7 @@ func Base(path string) string {
 // If the path consists entirely of separators, Dir returns a single separator.
 // The returned path does not end in a separator unless it is the root directory.
 func Dir(path string) string {
-	vol := VolumeName(path)
-	i := len(path) - 1
-	for i >= len(vol) && !os.IsPathSeparator(path[i]) {
-		i--
-	}
-	dir := Clean(path[len(vol) : i+1])
-	if dir == "." && len(vol) > 2 {
-		// must be UNC
-		return vol
-	}
-	return vol + dir
+	return filepathlite.Dir(path)
 }
 
 // VolumeName returns leading volume name.
@@ -651,5 +471,5 @@ func Dir(path string) string {
 // Given "\\host\share\foo" it returns "\\host\share".
 // On other platforms it returns "".
 func VolumeName(path string) string {
-	return FromSlash(path[:volumeNameLen(path)])
+	return filepathlite.VolumeName(path)
 }