[stdlib/private][OSLog] Add basic support for interpolating floating-point

types without formatting options, add an auto-inferred privacy mode and
make it the default privacy mode, add support for aligning string
arguments.

Author: ravikandhadai

stdlib/private/OSLog/CMakeLists.txt

@@ -9,6 +9,7 @@ add_swift_target_library(swiftOSLogPrototype
   OSLogIntegerTypes.swift
   OSLogStringTypes.swift
   OSLogNSObjectType.swift
+  OSLogFloatingPointTypes.swift
 
   SWIFT_MODULE_DEPENDS_IOS Darwin os ObjectiveC
   SWIFT_MODULE_DEPENDS_OSX Darwin os ObjectiveC

stdlib/private/OSLog/OSLog.swift

@@ -2,13 +2,13 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2020 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
 //
-//===-----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 
 // This file contains the new swift APIs for OS log that accept string
 // interpolations. This is a prototype meant for experimentation and testing.

stdlib/private/OSLog/OSLogFloatingPointTypes.swift

@@ -0,0 +1,145 @@
+//===----------------- OSLogFloatingPointTypes.swift ----------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 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
+//
+//===----------------------------------------------------------------------===//
+
+// This file defines extensions for interpolating floating-point expressions
+// into an OSLogMesage. It defines `appendInterpolation` functions for standard
+// floating-point types. It also defines extensions for serializing floating-
+// point types into the argument buffer passed to os_log ABIs.
+//
+// The `appendInterpolation` functions defined in this file accept privacy
+// options along with the interpolated expression as shown below:
+// TODO: support floating-point formatting options.
+//
+//    "\(x, privacy: .private\)"
+
+extension OSLogInterpolation {
+
+  /// Define interpolation for expressions of type Float.
+  /// - Parameters:
+  ///  - number: the interpolated expression of type Float, which is autoclosured.
+  ///  - privacy: a privacy qualifier which is either private or public.
+  ///    It is auto-inferred by default.
+  @_semantics("constant_evaluable")
+  @inlinable
+  @_optimize(none)
+  public mutating func appendInterpolation(
+    _ number: @autoclosure @escaping () -> Float,
+    privacy: OSLogPrivacy = .auto
+  ) {
+    appendInterpolation(Double(number()), privacy: privacy)
+  }
+
+  /// Define interpolation for expressions of type Double.
+  /// - Parameters:
+  ///  - number: the interpolated expression of type Double, which is autoclosured.
+  ///  - privacy: a privacy qualifier which is either private or public.
+  ///    It is auto-inferred by default.
+  @_semantics("constant_evaluable")
+  @inlinable
+  @_optimize(none)
+  public mutating func appendInterpolation(
+    _ number: @autoclosure @escaping () -> Double,
+    privacy: OSLogPrivacy = .auto
+  ) {
+    guard argumentCount < maxOSLogArgumentCount else { return }
+
+    formatString += getDoubleFormatSpecifier(privacy: privacy)
+    addDoubleHeaders(privacy)
+
+    arguments.append(number)
+    argumentCount += 1
+  }
+
+  /// Update preamble and append argument headers based on the parameters of
+  /// the interpolation.
+  @_semantics("constant_evaluable")
+  @inlinable
+  @_optimize(none)
+  internal mutating func addDoubleHeaders(_ privacy: OSLogPrivacy) {
+    // Append argument header.
+    let argumentHeader = getArgumentHeader(privacy: privacy, type: .scalar)
+    arguments.append(argumentHeader)
+
+    // Append number of bytes needed to serialize the argument.
+    let byteCount = doubleSizeInBytes()
+    arguments.append(UInt8(byteCount))
+
+    // Increment total byte size by the number of bytes needed for this
+    // argument, which is the sum of the byte size of the argument and
+    // two bytes needed for the headers.
+    totalBytesForSerializingArguments += byteCount + 2
+
+    preamble = getUpdatedPreamble(privacy: privacy, isScalar: true)
+  }
+
+  /// Construct an os_log format specifier from the given parameters.
+  /// This function must be constant evaluable and all its arguments
+  /// must be known at compile time.
+  @inlinable
+  @_semantics("constant_evaluable")
+  @_effects(readonly)
+  @_optimize(none)
+  internal func getDoubleFormatSpecifier(privacy: OSLogPrivacy) -> String {
+    // TODO: this will become more sophisticated when floating-point formatting
+    // options are supported.
+    var specifier = "%"
+    switch privacy {
+    case .private:
+      specifier += "{private}"
+    case .public:
+      specifier += "{public}"
+    default:
+      break
+    }
+    specifier += "f"
+    return specifier
+  }
+}
+
+extension OSLogArguments {
+  /// Append an (autoclosured) interpolated expression of Double type, passed to
+  /// `OSLogMessage.appendInterpolation`, to the array of closures tracked
+  /// by this instance.
+  @_semantics("constant_evaluable")
+  @inlinable
+  @_optimize(none)
+  internal mutating func append(_ value: @escaping () -> Double) {
+    argumentClosures.append({ (position, _) in
+      serialize(value(), at: &position)
+    })
+  }
+}
+
+/// Return the number of bytes needed for serializing a double argument as
+/// specified by os_log. Note that this is marked transparent instead of
+/// @inline(__always) as it is used in optimize(none) functions.
+@_transparent
+@usableFromInline
+internal func doubleSizeInBytes() -> Int {
+  return 8
+}
+
+/// Serialize a double at the buffer location that `position` points to and
+/// increment `position` by the byte size of the double.
+@inlinable
+@_alwaysEmitIntoClient
+@inline(__always)
+internal func serialize(
+  _ value: Double,
+  at bufferPosition: inout ByteBufferPointer
+) {
+  let byteCount = doubleSizeInBytes()
+  let dest =
+    UnsafeMutableRawBufferPointer(start: bufferPosition, count: byteCount)
+  withUnsafeBytes(of: value) { dest.copyMemory(from: $0) }
+  bufferPosition += byteCount
+}

stdlib/private/OSLog/OSLogIntegerFormatting.swift

@@ -1,3 +1,18 @@
+//===----------------- OSLogIntegerFormatting.swift -----------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 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
+//
+//===----------------------------------------------------------------------===//
+
+// This file defines types and functions for specifying formatting of
+// integer-valued interpolations passed to the os log APIs.
+
 @frozen
 public struct OSLogIntegerFormatting: Equatable {
   /// The base to use for the string representation. `radix` must be at least 2
@@ -261,11 +276,8 @@ extension OSLogIntegerFormatting {
     // IEEE: `-` The result of the conversion shall be left-justified within
     // the field. The conversion is right-justified if this flag is not
     // specified.
-    switch align.anchor {
-    case OSLogCollectionBound.start:
-        specification += "-"
-    default:
-        break
+    if case .start = align.anchor {
+      specification += "-"
     }
 
     // 2. Minimumn field width

stdlib/private/OSLog/OSLogIntegerTypes.swift

@@ -2,41 +2,45 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2020 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
 //
 //===----------------------------------------------------------------------===//
 
-// This file defines extensions for interpolating integer expressions into a
+// This file defines extensions for interpolating integer expressions into an
 // OSLogMesage. It defines `appendInterpolation` functions for standard integer
 // types. It also defines extensions for serializing integer types into the
 // argument buffer passed to os_log ABIs.
 //
-// The `appendInterpolation` functions defined in this file accept formatting
-// and privacy options along with the interpolated expression as shown below:
+// The `appendInterpolation` functions defined in this file accept formatting,
+// privacy and alignment options along with the interpolated expression as
+// shown below:
 //
-//         "\(x, format: .hex, privacy: .private\)"
+//  1.  "\(x, format: .hex, privacy: .private, align: .right\)"
+//  2.  "\(x, format: .hex(minDigits: 10), align: .right(columns: 10)\)"
 
 extension OSLogInterpolation {
 
   /// Define interpolation for expressions of type Int.
   /// - Parameters:
   ///  - number: the interpolated expression of type Int, which is autoclosured.
   ///  - format: a formatting option available for integer types, defined by the
-  ///    enum `OSLogIntegerFormatting`.
+  ///    type`OSLogIntegerFormatting`. The default is .decimal.
+  ///  - align: left or right alignment with the minimum number of columns as
+  ///    defined by the type `OSLogStringAlignment`.
   ///  - privacy: a privacy qualifier which is either private or public.
-  ///    The default is public.
+  ///    It is auto-inferred by default.
   @_semantics("constant_evaluable")
   @inlinable
   @_optimize(none)
   public mutating func appendInterpolation(
     _ number: @autoclosure @escaping () -> Int,
     format: OSLogIntegerFormatting = .decimal,
     align: OSLogStringAlignment = .none,
-    privacy: OSLogPrivacy = .public
+    privacy: OSLogPrivacy = .auto
   ) {
     appendInteger(number, format: format, align: align, privacy: privacy)
   }
@@ -45,17 +49,19 @@ extension OSLogInterpolation {
   /// - Parameters:
   ///  - number: the interpolated expression of type Int32, which is autoclosured.
   ///  - format: a formatting option available for integer types, defined by the
-  ///    enum `OSLogIntegerFormatting`.
+  ///    type `OSLogIntegerFormatting`.
+  ///  - align: left or right alignment with the minimum number of columns as
+  ///    defined by the type `OSLogStringAlignment`.
   ///  - privacy: a privacy qualifier which is either private or public.
-  ///    The default is public.
+  ///    It is auto-inferred by default.
   @_semantics("constant_evaluable")
   @inlinable
   @_optimize(none)
   public mutating func appendInterpolation(
     _ number: @autoclosure @escaping () -> Int32,
     format: OSLogIntegerFormatting = .decimal,
     align: OSLogStringAlignment = .none,
-    privacy: OSLogPrivacy = .public
+    privacy: OSLogPrivacy = .auto
   ) {
     appendInteger(number, format: format, align: align, privacy: privacy)
   }
@@ -64,17 +70,19 @@ extension OSLogInterpolation {
   /// - Parameters:
   ///  - number: the interpolated expression of type UInt, which is autoclosured.
   ///  - format: a formatting option available for integer types, defined by the
-  ///    enum `OSLogIntegerFormatting`.
+  ///    type `OSLogIntegerFormatting`.
+  ///  - align: left or right alignment with the minimum number of columns as
+  ///    defined by the type `OSLogStringAlignment`.
   ///  - privacy: a privacy qualifier which is either private or public.
-  ///    The default is public.
+  ///    It is auto-inferred by default.
   @_semantics("constant_evaluable")
   @inlinable
   @_optimize(none)
   public mutating func appendInterpolation(
     _ number: @autoclosure @escaping () -> UInt,
     format: OSLogIntegerFormatting = .decimal,
     align: OSLogStringAlignment = .none,
-    privacy: OSLogPrivacy = .public
+    privacy: OSLogPrivacy = .auto
   ) {
     appendInteger(number, format: format, align: align, privacy: privacy)
   }
@@ -94,9 +102,7 @@ extension OSLogInterpolation {
     guard argumentCount < maxOSLogArgumentCount else { return }
     formatString +=
       format.formatSpecifier(for: T.self, align: align, privacy: privacy)
-
-    let isPrivateArgument = isPrivate(privacy)
-    addIntHeaders(isPrivateArgument, sizeForEncoding(T.self))
+    addIntHeaders(privacy, sizeForEncoding(T.self))
 
     arguments.append(number)
     argumentCount += 1
@@ -107,9 +113,12 @@ extension OSLogInterpolation {
   @_semantics("constant_evaluable")
   @inlinable
   @_optimize(none)
-  internal mutating func addIntHeaders(_ isPrivate: Bool, _ byteCount: Int) {
+  internal mutating func addIntHeaders(
+    _ privacy: OSLogPrivacy,
+    _ byteCount: Int
+  ) {
     // Append argument header.
-    let argumentHeader = getArgumentHeader(isPrivate: isPrivate, type: .scalar)
+    let argumentHeader = getArgumentHeader(privacy: privacy, type: .scalar)
     arguments.append(argumentHeader)
 
     // Append number of bytes needed to serialize the argument.
@@ -120,7 +129,7 @@ extension OSLogInterpolation {
     // two bytes needed for the headers.
     totalBytesForSerializingArguments += byteCount + 2
 
-    preamble = getUpdatedPreamble(isPrivate: isPrivate, isScalar: true)
+    preamble = getUpdatedPreamble(privacy: privacy, isScalar: true)
   }
 }