Only use FoundationEssentials if available

Sources/ArgumentParser/Completions/CompletionsGenerator.swift

@@ -203,14 +203,29 @@ extension Sequence where Element == ParsableCommand.Type {
 }
 
 extension String {
+  #if canImport(FoundationEssentials)
+  func shellEscapeForSingleQuotedString(iterationCount: UInt64 = 1) -> Self {
+    iterationCount == 0
+      ? self
+      : replacing("'", with: "'\\''")
+        .shellEscapeForSingleQuotedString(iterationCount: iterationCount - 1)
+  }
+  #else
   func shellEscapeForSingleQuotedString(iterationCount: UInt64 = 1) -> Self {
     iterationCount == 0
       ? self
       : replacingOccurrences(of: "'", with: "'\\''")
         .shellEscapeForSingleQuotedString(iterationCount: iterationCount - 1)
   }
-
+  #endif
+
+  #if canImport(FoundationEssentials)
+  func shellEscapeForVariableName() -> Self {
+    replacing("-", with: "_")
+  }
+  #else
   func shellEscapeForVariableName() -> Self {
     replacingOccurrences(of: "-", with: "_")
   }
+  #endif
 }

Sources/ArgumentParser/Completions/FishCompletionsGenerator.swift

@@ -132,9 +132,15 @@ extension Name {
 }
 
 extension String {
+  #if canImport(FoundationEssentials)
+  fileprivate func fishEscape() -> String {
+    replacing("'", with: #"\'"#)
+  }
+  #else
   fileprivate func fishEscape() -> String {
     replacingOccurrences(of: "'", with: #"\'"#)
   }
+  #endif
 }
 
 extension FishCompletionsGenerator {

Sources/ArgumentParser/Completions/ZshCompletionsGenerator.swift

@@ -221,14 +221,20 @@ extension [ParsableCommand.Type] {
 }
 
 extension String {
+  #if canImport(FoundationEssentials)
+  fileprivate func zshEscapeForSingleQuotedExplanation() -> String {
+    replacing(#/[\\\[\]]/#, with: { "\\\($0.output)" })
+    .shellEscapeForSingleQuotedString()
+  }
+  #else
   fileprivate func zshEscapeForSingleQuotedExplanation() -> String {
     replacingOccurrences(
       of: #"[\\\[\]]"#,
       with: #"\\$0"#,
-      options: .regularExpression
-    )
+      options: .regularExpression)
     .shellEscapeForSingleQuotedString()
   }
+  #endif
 }
 
 extension ArgumentDefinition {

Sources/ArgumentParser/Parsable Types/ParsableArguments.swift

@@ -35,7 +35,7 @@ struct _WrappedParsableCommand<P: ParsableArguments>: ParsableCommand {
 
     // If the type is named something like "TransformOptions", we only want
     // to use "transform" as the command name.
-    if let optionsRange = name.range(of: "_options"),
+    if let optionsRange = name._range(of: "_options"),
       optionsRange.upperBound == name.endIndex
     {
       return String(name[..<optionsRange.lowerBound])

Sources/ArgumentParser/Parsing/CommandParser.swift

@@ -10,10 +10,19 @@
 //===----------------------------------------------------------------------===//
 
 #if swift(>=6.0)
+#if canImport(FoundationEssentials)
+internal import class FoundationEssentials.ProcessInfo
+#else
 internal import class Foundation.ProcessInfo
+#endif
+#else
+#if canImport(FoundationEssentials)
+import class FoundationEssentials.ProcessInfo
 #else
 import class Foundation.ProcessInfo
 #endif
+#endif
+
 
 struct CommandError: Error {
   var commandStack: [ParsableCommand.Type]

Sources/ArgumentParser/Usage/DumpHelpGenerator.swift

@@ -11,11 +11,19 @@
 
 #if swift(>=6.0)
 internal import ArgumentParserToolInfo
+#if canImport(FoundationEssentials)
+internal import class FoundationEssentials.JSONEncoder
+#else
 internal import class Foundation.JSONEncoder
+#endif
 #else
 import ArgumentParserToolInfo
+#if canImport(FoundationEssentials)
+import class FoundationEssentials.JSONEncoder
+#else
 import class Foundation.JSONEncoder
 #endif
+#endif
 
 internal struct DumpHelpGenerator {
   private var toolInfo: ToolInfoV0

Sources/ArgumentParser/Usage/MessageInfo.swift

@@ -10,12 +10,20 @@
 //===----------------------------------------------------------------------===//
 
 #if swift(>=6.0)
+#if canImport(FoundationEssentials)
+internal import protocol FoundationEssentials.LocalizedError
+#else
 internal import protocol Foundation.LocalizedError
 internal import class Foundation.NSError
+#endif
+#else
+#if canImport(FoundationEssentials)
+import protocol FoundationEssentials.LocalizedError
 #else
 import protocol Foundation.LocalizedError
 import class Foundation.NSError
 #endif
+#endif
 
 enum MessageInfo {
   case help(text: String)
@@ -135,11 +143,15 @@ enum MessageInfo {
         // No way to unwrap bind description in pattern
         self = .other(message: error.errorDescription!, exitCode: .failure)
       default:
+        #if canImport(FoundationEssentials)
+        self = .other(message: String(describing: error), exitCode: .failure)
+        #else
         if Swift.type(of: error) is NSError.Type {
           self = .other(message: error.localizedDescription, exitCode: .failure)
         } else {
           self = .other(message: String(describing: error), exitCode: .failure)
         }
+        #endif
       }
     } else if let parserError = parserError {
       let usage: String = {

Sources/ArgumentParser/Usage/UsageGenerator.swift

@@ -10,10 +10,18 @@
 //===----------------------------------------------------------------------===//
 
 #if swift(>=6.0)
+#if canImport(FoundationEssentials)
+internal import protocol FoundationEssentials.LocalizedError
+#else
 internal import protocol Foundation.LocalizedError
+#endif
+#else
+#if canImport(FoundationEssentials)
+import protocol FoundationEssentials.LocalizedError
 #else
 import protocol Foundation.LocalizedError
 #endif
+#endif
 
 struct UsageGenerator {
   var toolName: String

Sources/ArgumentParser/Utilities/BidirectionalCollection.swift

@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+
+extension BidirectionalCollection {
+    // Equal to calling `index(&idx, offsetBy: -other.count)` with just one loop
+    func _index<S: BidirectionalCollection>(_ index: Index, backwardsOffsetByCountOf other: S) -> Index? {
+        var idx = index
+        var otherIdx = other.endIndex
+        while otherIdx > other.startIndex {
+            guard idx > startIndex else {
+                // other.count > self.count: bail
+                return nil
+            }
+            other.formIndex(before: &otherIdx)
+            formIndex(before: &idx)
+        }
+        return idx
+    }
+
+    func _range<S: BidirectionalCollection>(of other: S, anchored: Bool = false, backwards: Bool = false) -> Range<Index>? where S.Element == Element, Element : Equatable {
+        var result: Range<Index>? = nil
+        var fromLoc: Index
+        var toLoc: Index
+        if backwards {
+            guard let idx = _index(endIndex, backwardsOffsetByCountOf: other) else {
+                // other.count > string.count: bail
+                return nil
+            }
+            fromLoc = idx
+
+            toLoc = anchored ? fromLoc : startIndex
+        } else {
+            fromLoc = startIndex
+            if anchored {
+                toLoc = fromLoc
+            } else {
+                guard let idx = _index(endIndex, backwardsOffsetByCountOf: other) else {
+                    return nil
+                }
+                toLoc = idx
+            }
+        }
+
+        let delta = fromLoc <= toLoc ? 1 : -1
+
+        while true {
+            var str1Index = fromLoc
+            var str2Index = other.startIndex
+
+            while str2Index < other.endIndex && str1Index < endIndex {
+                if self[str1Index] != other[str2Index] {
+                    break
+                }
+                formIndex(after: &str1Index)
+                other.formIndex(after: &str2Index)
+            }
+
+            if str2Index == other.endIndex {
+                result = fromLoc..<str1Index
+                break
+            }
+
+            if fromLoc == toLoc {
+                break
+            }
+
+            formIndex(&fromLoc, offsetBy: delta)
+        }
+
+        return result
+    }
+}