Turn build-swift-stdlib-static-print on for freestanding preset (#41260)

Author: kubamracek

stdlib/private/StdlibUnittest/CMakeLists.txt

@@ -14,6 +14,10 @@ if(SWIFT_ENABLE_REFLECTION)
   list(APPEND swift_stdlib_unittest_compile_flags "-DSWIFT_ENABLE_REFLECTION")
 endif()
 
+if(SWIFT_STDLIB_STATIC_PRINT)
+  list(APPEND swift_stdlib_unittest_compile_flags "-D" "SWIFT_STDLIB_STATIC_PRINT")
+endif()
+
 set(swift_stdlib_unittest_link_libraries "")
 set(swift_stdlib_unittest_modules "")
 if (SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY)

stdlib/private/StdlibUnittest/StdlibCoreExtras.swift

@@ -304,3 +304,16 @@ public func dump<T, TargetStream: TextOutputStream>(_ value: T, to target: inout
 }
 
 #endif
+
+#if SWIFT_STDLIB_STATIC_PRINT
+
+public func print(_ s: Any, terminator: String = "\n") {
+  let data = Array("\(s)\(terminator)".utf8)
+  write(STDOUT_FILENO, data, data.count)
+}
+
+public func print<Target>(_ s: Any, terminator: String = "\n", to output: inout Target) where Target : TextOutputStream {
+  output.write("\(s)\(terminator)")
+}
+
+#endif

stdlib/private/SwiftPrivateLibcExtras/CMakeLists.txt

@@ -3,6 +3,10 @@ if(SWIFT_STDLIB_HAS_ENVIRON)
   set(swift_private_libc_extras_flags "-D" "SWIFT_STDLIB_HAS_ENVIRON")
 endif()
 
+if(SWIFT_STDLIB_STATIC_PRINT)
+  list(APPEND swift_private_libc_extras_flags "-D" "SWIFT_STDLIB_STATIC_PRINT")
+endif()
+
 set(swift_private_libc_extras_incorporate_object_libraries)
 if(SWIFT_STDLIB_HAS_COMMANDLINE)
   list(APPEND swift_private_libc_extras_flags "-D" "SWIFT_STDLIB_HAS_COMMANDLINE")

stdlib/private/SwiftPrivateLibcExtras/Subprocess.swift

@@ -244,6 +244,13 @@ var environ: UnsafeMutablePointer<UnsafeMutablePointer<CChar>?> {
 }
 #endif
 
+#if SWIFT_STDLIB_STATIC_PRINT
+func print(_ s: String) {
+  let data = Array("\(s)\n".utf8)
+  write(STDOUT_FILENO, data, data.count)
+}
+#endif
+
 /// Start the same executable as a child process, redirecting its stdout and
 /// stderr.
 public func spawnChild(_ args: [String])

stdlib/public/core/ArrayShared.swift

@@ -98,6 +98,7 @@ extension Collection {
   internal func _makeCollectionDescription(
     withTypeName type: String? = nil
   ) -> String {
+#if !SWIFT_STDLIB_STATIC_PRINT
     var result = ""
     if let type = type {
       result += "\(type)(["
@@ -116,6 +117,9 @@ extension Collection {
     }
     result += type != nil ? "])" : "]"
     return result
+#else
+    return "(collection printing not available)"
+#endif
   }
 }
 

stdlib/public/core/Dictionary.swift

@@ -1677,6 +1677,7 @@ extension Collection {
   internal func _makeKeyValuePairDescription<K, V>(
     withTypeName type: String? = nil
   ) -> String where Element == (key: K, value: V) {
+#if !SWIFT_STDLIB_STATIC_PRINT
     if self.isEmpty {
       return "[:]"
     }
@@ -1695,6 +1696,9 @@ extension Collection {
     }
     result += "]"
     return result
+#else
+    return "(collection printing not available)"
+#endif
   }
 }
 

stdlib/public/core/Optional.swift

@@ -295,10 +295,14 @@ extension Optional: CustomDebugStringConvertible {
   public var debugDescription: String {
     switch self {
     case .some(let value):
+#if !SWIFT_STDLIB_STATIC_PRINT
       var result = "Optional("
       debugPrint(value, terminator: "", to: &result)
       result += ")"
       return result
+#else
+    return "(optional printing not available)"
+#endif
     case .none:
       return "nil"
     }

stdlib/public/core/Print.swift

@@ -10,6 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if !SWIFT_STDLIB_STATIC_PRINT
+
 /// Writes the textual representations of the given items into the standard
 /// output.
 ///
@@ -247,3 +249,5 @@ internal func _debugPrint<Target: TextOutputStream>(
   }
   output.write(terminator)
 }
+
+#endif

stdlib/public/core/REPL.swift

@@ -10,6 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if !SWIFT_STDLIB_STATIC_PRINT
+
 /// Print a string as is to stdout.
 public // COMPILER_INTRINSIC
 func _replPrintLiteralString(_ text: String) {
@@ -22,3 +24,5 @@ public // COMPILER_INTRINSIC
 func _replDebugPrintln<T>(_ value: T) {
   debugPrint(value)
 }
+
+#endif

stdlib/public/core/StaticPrint.swift

@@ -789,7 +789,9 @@ public struct ConstantVPrintFMessage :
   @_semantics("oslog.message.init_interpolation")
   @_semantics("constant_evaluable")
   public init(stringInterpolation: ConstantVPrintFInterpolation) {
-    self.interpolation = stringInterpolation
+    var s = stringInterpolation
+    s.appendLiteral("\n")
+    self.interpolation = s
   }
 
   @inlinable
@@ -802,6 +804,7 @@ public struct ConstantVPrintFMessage :
       interpolationCount: 0
     )
     s.appendLiteral(value)
+    s.appendLiteral("\n")
     self.interpolation = s
   }
 }
@@ -836,13 +839,18 @@ internal func constant_vprintf_backend(
   if let closure = argumentClosures.first {
     closure { newArg in
       args.append(contentsOf: newArg)
-      print(argumentClosures.count)
       constant_vprintf_backend_recurse(
         fmt: fmt,
         argumentClosures: argumentClosures.dropFirst(),
         args: &args
       )
     }
+  } else {
+    constant_vprintf_backend_recurse(
+      fmt: fmt,
+      argumentClosures: ArraySlice(argumentClosures),
+      args: &args
+    )
   }
 }
 
@@ -851,10 +859,10 @@ internal func constant_vprintf_backend(
 @_transparent
 @_alwaysEmitIntoClient
 @_optimize(none)
-public func constant_vprintf(_ message: ConstantVPrintFMessage) {
+public func print(_ message: ConstantVPrintFMessage) {
   let formatString = message.interpolation.formatString
   let argumentClosures = message.interpolation.arguments.argumentClosures
-  if Bool(_builtinBooleanLiteral: Builtin.ifdef_PRINT_DISABLED()) { return }
+  if Bool(_builtinBooleanLiteral: Builtin.ifdef_SWIFT_STDLIB_PRINT_DISABLED()) { return }
   let formatStringPointer = _getGlobalStringTablePointer(formatString)
   constant_vprintf_backend(
     fmt: formatStringPointer,

test/SILOptimizer/StaticVPrintFMandatoryOptTest.swift

@@ -14,7 +14,7 @@ import Foundation
 // CHECK-LABEL: @${{.*}}testSimpleInterpolationyy
 func testSimpleInterpolation() {
   let x = "World"
-  constant_vprintf("Hello \(5) \(x)")
+  print("Hello \(5) \(x)")
   // Match the format string. For now we don't expect all allocations to be avoided
   // CHECK: string_literal utf8 "Hello %ld %s"
 }

test/stdlib/KeyPath.swift

@@ -3,6 +3,7 @@
 // RUN: %target-codesign %t/a.out
 // RUN: %target-run %t/a.out
 // REQUIRES: executable_test
+// UNSUPPORTED: freestanding
 
 import StdlibUnittest
 

test/stdlib/Map.swift

@@ -39,18 +39,29 @@ print("testing...")
 // Test mapping a collection
 // CHECK-NEXT: [6, 9, 12, 15, 18, 21]
 let a = Array((2..<8).lazy.map { $0 * 3 })
-print(a)
+do {
+  var output = ""
+  var prefix = ""
+  for x in a {
+    output += "\(prefix)\(x)"
+    prefix = ", "
+  }
+  print("[\(output)]")
+}
+
 
 // Test mapping a sequence
 let s = a.makeIterator().lazy.map { $0 / 3 }
 // CHECK-NEXT: <2, 3, 4, 5, 6, 7>
-print("<", terminator: "")
-var prefix = ""
-for x in s {
-  print("\(prefix)\(x)", terminator: "")
-  prefix = ", "
+do {
+  var output = ""
+  var prefix = ""
+  for x in s {
+    output += "\(prefix)\(x)"
+    prefix = ", "
+  }
+  print("<\(output)>")
 }
-print(">")
 
 //===--- Avoid creating gratuitously self-destructive sequences -----------===//
 
@@ -94,11 +105,27 @@ struct IntRange : Sequence {
 // consuming it.
 let m1 = IntRange(start: 1, end: 5).lazy.map { $0 * 2 }
 // CHECK-NEXT: [2, 4, 6, 8]
-print(Array(m1))
+do {
+  var output = ""
+  var prefix = ""
+  for x in m1 {
+    output += "\(prefix)\(x)"
+    prefix = ", "
+  }
+  print("[\(output)]")
+}
 
 // A second iteration produces the same result.
 // CHECK-NEXT: [2, 4, 6, 8]
-print(Array(m1))
+do {
+  var output = ""
+  var prefix = ""
+  for x in m1 {
+    output += "\(prefix)\(x)"
+    prefix = ", "
+  }
+  print("[\(output)]")
+}
 
 // CHECK-NEXT: all done.
 print("all done.")

test/stdlib/Reduce.swift

@@ -22,19 +22,27 @@ let numberSum = numbers.reduce(0, { x, y in
   x + y
 })
 // CHECK-NEXT: 10
-print(numberSum)
+print("\(numberSum)")
 
 let letters = "abracadabra"
 let letterCount = letters.reduce(into: [:]) { counts, letter in
   counts[letter, default: 0] += 1
 }
 // CHECK-NEXT: ["a", "b", "c", "d", "r"]
-print(letterCount.keys.sorted())
-print(letterCount["a"]!) // CHECK: 5
-print(letterCount["b"]!) // CHECK: 2
-print(letterCount["c"]!) // CHECK: 1
-print(letterCount["d"]!) // CHECK: 1
-print(letterCount["r"]!) // CHECK: 2
+do {
+  var output = ""
+  var prefix = ""
+  for x in letterCount.keys.sorted() {
+    output += "\(prefix)\"\(x)\""
+    prefix = ", "
+  }
+  print("[\(output)]")
+}
+print("\(letterCount["a"]!)") // CHECK: 5
+print("\(letterCount["b"]!)") // CHECK: 2
+print("\(letterCount["c"]!)") // CHECK: 1
+print("\(letterCount["d"]!)") // CHECK: 1
+print("\(letterCount["r"]!)") // CHECK: 2
 
 
 // Test the two reduce methods with different levels of inference
@@ -43,36 +51,36 @@ let numbers2 = Array(2..<7)
 // Test reduce(_:_:)
 // CHECK-NEXT: 20
 let sum1 = numbers2.reduce(0) { (x: Int, y: Int) -> Int in x + y }
-print(sum1)
+print("\(sum1)")
 
 // CHECK-NEXT: 20
 let sum2 = numbers2.reduce(0) { (x, y) in x + y }
-print(sum2)
+print("\(sum2)")
 
 // CHECK-NEXT: 20
 let sum3 = numbers2.reduce(0) { $0 + $1 }
-print(sum3)
+print("\(sum3)")
 
 // CHECK-NEXT: 20
 let sum4 = numbers2.reduce(0, +)
-print(sum4)
+print("\(sum4)")
 
 // Test reduce(into:_:)
 // CHECK-NEXT: 20
 let sum5 = numbers2.reduce(into: 0) { (x: inout Int, y: Int) in x += y }
-print(sum5)
+print("\(sum5)")
 
 // CHECK-NEXT: 20
 let sum6 = numbers2.reduce(into: 0) { x, y in x += y }
-print(sum6)
+print("\(sum6)")
 
 // CHECK-NEXT: 20
 let sum7 = numbers2.reduce(into: 0) { $0 += $1 }
-print(sum7)
+print("\(sum7)")
 
 // CHECK-NEXT: 20
 let sum8 = numbers2.reduce(into: 0, +=)
-print(sum8)
+print("\(sum8)")
 
 
 // Test that the initial value remains unmodified
@@ -81,9 +89,25 @@ let result = numbers2.reduce(into: original) { acc, x in
   acc.append(x)
 }
 // CHECK-NEXT: [0, 1]
-print(original)
+do {
+  var output = ""
+  var prefix = ""
+  for x in original {
+    output += "\(prefix)\(x)"
+    prefix = ", "
+  }
+  print("[\(output)]")
+}
 // CHECK-NEXT: [0, 1, 2, 3, 4, 5, 6]
-print(result)
+do {
+  var output = ""
+  var prefix = ""
+  for x in result {
+    output += "\(prefix)\(x)"
+    prefix = ", "
+  }
+  print("[\(output)]")
+}
 
 
 // CHECK: all done.

test/stdlib/StaticPrint.swift

@@ -18,14 +18,14 @@ let PrintTests = TestSuite("StaticPrint")
 // CHECK: string_literal utf8 ", world"
 // CHECK: string_literal utf8 "hello, world 5"
 PrintTests.test("StringInterpolation") {
-  constant_vprintf("")
-  constant_vprintf("hello")
-  constant_vprintf("\(5)")
+  print("")
+  print("hello")
+  print("\(5)")
   let x = 5
-  constant_vprintf("\(x)")
+  print("\(x)")
   let y = ", world"
-  constant_vprintf("\(y)")
-  constant_vprintf("hello \(y)\(x)")
+  print("\(y)")
+  print("hello \(y)\(x)")
 }
 
 runAllTests()