[stdlib] Remove dead code

stdlib/public/core/Unicode.swift

@@ -477,13 +477,6 @@ extension Unicode.UTF32 : UnicodeCodec {
   @inlinable // FIXME(sil-serialize-all)
   public mutating func decode<I : IteratorProtocol>(
     _ input: inout I
-  ) -> UnicodeDecodingResult where I.Element == CodeUnit {
-    return UTF32._decode(&input)
-  }
-
-  @inlinable // FIXME(sil-serialize-all)
-  internal static func _decode<I : IteratorProtocol>(
-    _ input: inout I
   ) -> UnicodeDecodingResult where I.Element == CodeUnit {
     var parser = ForwardParser()
 

stdlib/public/core/UnicodeParser.swift

@@ -57,79 +57,6 @@ public protocol _UnicodeParser {
   where I.Element == Encoding.CodeUnit
 }
 
-extension _UnicodeParser {
-  @inlinable // FIXME(sil-serialize-all)
-  @inline(__always)
-  @discardableResult
-  internal static func _parse<I: IteratorProtocol>(
-    _ input: inout I,
-    repairingIllFormedSequences makeRepairs: Bool = true,
-    into output: (Encoding.EncodedScalar)->Void
-  ) -> Int
-  where I.Element == Encoding.CodeUnit
-  {
-    var errorCount = 0
-    var d = Self()
-    while true {
-      switch d.parseScalar(from: &input) {
-      case let .valid(scalarContent):
-        output(scalarContent)
-      case .error:
-        if _slowPath(!makeRepairs) { return 1 }
-        errorCount += 1
-        output(Encoding.encodedReplacementCharacter)
-      case .emptyInput:
-        return errorCount
-      }
-    }
-  }
-
-  @inlinable // FIXME(sil-serialize-all)
-  @inline(__always)
-  @discardableResult
-  public static func _decode<I: IteratorProtocol>(
-    _ input: inout I,
-    repairingIllFormedSequences makeRepairs: Bool,
-    into output: (Unicode.Scalar)->Void
-  ) -> Int
-  where I.Element == Encoding.CodeUnit
-  {
-    return _parse(&input, repairingIllFormedSequences: makeRepairs) {
-      output(Encoding.decode($0))
-    }
-  }
-}
-
 extension Unicode {
   public typealias Parser = _UnicodeParser
 }
-
-extension Unicode {
-  @_fixed_layout
-  public // @testable
-  struct _ParsingIterator<
-    CodeUnitIterator : IteratorProtocol, 
-    Parser: Unicode.Parser
-  > where Parser.Encoding.CodeUnit == CodeUnitIterator.Element {
-    @inline(__always)
-    @inlinable
-    public init(codeUnits: CodeUnitIterator, parser: Parser) {
-      self.codeUnits = codeUnits
-      self.parser = parser
-    }
-    public var codeUnits: CodeUnitIterator
-    public var parser: Parser
-  }
-}
-
-extension Unicode._ParsingIterator : IteratorProtocol, Sequence {
-  @inline(__always)
-  @inlinable
-  public mutating func next() -> Parser.Encoding.EncodedScalar? {
-    switch parser.parseScalar(from: &codeUnits) {
-    case let .valid(scalarContent): return scalarContent
-    case .error: return Parser.Encoding.encodedReplacementCharacter
-    case .emptyInput: return nil
-    }
-  }
-}

test/Prototypes/UnicodeDecoders.swift

@@ -36,6 +36,79 @@ extension Unicode.Scalar {
 }
 //===----------------------------------------------------------------------===//
 
+extension Unicode {
+  @_fixed_layout
+  public // @testable
+  struct _ParsingIterator<
+    CodeUnitIterator : IteratorProtocol, 
+    Parser: Unicode.Parser
+  > where Parser.Encoding.CodeUnit == CodeUnitIterator.Element {
+    @inline(__always)
+    @inlinable
+    public init(codeUnits: CodeUnitIterator, parser: Parser) {
+      self.codeUnits = codeUnits
+      self.parser = parser
+    }
+    public var codeUnits: CodeUnitIterator
+    public var parser: Parser
+  }
+}
+
+extension Unicode._ParsingIterator : IteratorProtocol, Sequence {
+  @inline(__always)
+  @inlinable
+  public mutating func next() -> Parser.Encoding.EncodedScalar? {
+    switch parser.parseScalar(from: &codeUnits) {
+    case let .valid(scalarContent): return scalarContent
+    case .error: return Parser.Encoding.encodedReplacementCharacter
+    case .emptyInput: return nil
+    }
+  }
+}
+
+extension _UnicodeParser {
+  @inlinable // FIXME(sil-serialize-all)
+  @inline(__always)
+  @discardableResult
+  internal static func _parse<I: IteratorProtocol>(
+    _ input: inout I,
+    repairingIllFormedSequences makeRepairs: Bool = true,
+    into output: (Encoding.EncodedScalar)->Void
+  ) -> Int
+  where I.Element == Encoding.CodeUnit
+  {
+    var errorCount = 0
+    var d = Self()
+    while true {
+      switch d.parseScalar(from: &input) {
+      case let .valid(scalarContent):
+        output(scalarContent)
+      case .error:
+        if _slowPath(!makeRepairs) { return 1 }
+        errorCount += 1
+        output(Encoding.encodedReplacementCharacter)
+      case .emptyInput:
+        return errorCount
+      }
+    }
+  }
+
+  @inlinable // FIXME(sil-serialize-all)
+  @inline(__always)
+  @discardableResult
+  public static func _decode<I: IteratorProtocol>(
+    _ input: inout I,
+    repairingIllFormedSequences makeRepairs: Bool,
+    into output: (Unicode.Scalar)->Void
+  ) -> Int
+  where I.Element == Encoding.CodeUnit
+  {
+    return _parse(&input, repairingIllFormedSequences: makeRepairs) {
+      output(Encoding.decode($0))
+    }
+  }
+}
+
 extension Unicode {
   struct DefaultScalarView<
     CodeUnits: BidirectionalCollection,

test/api-digester/Outputs/stability-stdlib-abi.swift.expected

@@ -76,5 +76,10 @@ Class _SharedStringStorage has removed conformance to _NSStringCore
 Class _StringStorage has removed conformance to _NSStringCore
 Protocol _NSStringCore has been removed
 
+Func Unicode.UTF32._decode(_:) has been removed
+Func _UnicodeParser._decode(_:repairingIllFormedSequences:into:) has been removed
+Func _UnicodeParser._parse(_:repairingIllFormedSequences:into:) has been removed
+Struct Unicode._ParsingIterator has been removed
+
 Constructor ManagedBuffer.init(_doNotCallMe:) has been removed
 Func _makeAnyHashableUpcastingToHashableBaseType(_:storingResultInto:) has been removed