Merge pull request #4263 from apple/se-0136

Implementation of SE-0136 => Swift-3.0 branch

Author: tkremenek

lib/Sema/MiscDiagnostics.cpp

@@ -2145,9 +2145,6 @@ bool AvailabilityWalker::diagnoseMemoryLayoutMigration(const ValueDecl *D,
       .Case("sizeof", {"size", false})
       .Case("alignof", {"alignment", false})
       .Case("strideof", {"stride", false})
-      .Case("sizeofValue", {"size", true})
-      .Case("alignofValue", {"alignment", true})
-      .Case("strideofValue", {"stride", true})
       .Default({});
 
   if (KindValue.first.empty())
@@ -2162,7 +2159,7 @@ bool AvailabilityWalker::diagnoseMemoryLayoutMigration(const ValueDecl *D,
 
   auto subject = args->getSubExpr();
   if (!isValue) {
-    // sizeof(x.dynamicType) is equivalent to sizeofValue(x)
+    // sizeof(type(of: x)) is equivalent to sizeofValue(x)
     if (auto DTE = dyn_cast<DynamicTypeExpr>(subject)) {
       subject = DTE->getBase();
       isValue = true;
@@ -2179,14 +2176,14 @@ bool AvailabilityWalker::diagnoseMemoryLayoutMigration(const ValueDecl *D,
   if (isValue) {
     auto valueType = subject->getType()->getRValueType();
     if (!valueType || valueType->is<ErrorType>()) {
-        // If we dont have good argument, We cannot emit fix-it.
-        return true;
+      // If we don't have a suitable argument, we cannot emit a fix-it.
+      return true;
     }
 
     // NOTE: We are destructively replacing the source text here.
-    // For instance, `sizeof(x.doSomethig())` => `MemoryLayout<T>.size` where
-    // T is return type of `doSomething()`. If that function have any
-    // side effects, it will break the source.
+    // `sizeof(type(of: doSomething()))` => `MemoryLayout<T>.size`, where T is
+    // the return type of `doSomething()`. If that function has any side
+    // effects, this replacement will break the source.
     diag.fixItReplace(call->getSourceRange(),
       (Prefix + valueType->getString() + Suffix + Kind).str());
   } else {

stdlib/private/SwiftPrivateLibcExtras/Subprocess.swift

@@ -116,7 +116,7 @@ public func spawnChild(_ args: [String])
 
     // If execve() encountered an error, we write the errno encountered to the
     // parent write pipe.
-    let errnoSize = MemoryLayout._ofInstance(errno).size
+    let errnoSize = MemoryLayout.size(ofValue: errno)
     var execveErrno = errno
     let writtenBytes = withUnsafePointer(to: &execveErrno) {
       write(childToParentPipe.writeFD, UnsafePointer($0), errnoSize)

stdlib/public/SDK/Foundation/Data.swift

@@ -669,7 +669,7 @@ public struct Data : ReferenceConvertible, Equatable, Hashable, RandomAccessColl
         public mutating func next() -> UInt8? {
             guard _idx < _endIdx else { return nil }
             defer { _idx += 1 }
-            let bufferSize = MemoryLayout._ofInstance(_buffer).size
+            let bufferSize = MemoryLayout.size(ofValue: _buffer)
             return withUnsafeMutablePointer(to: &_buffer) { ptr_ in
                 let ptr = UnsafeMutableRawPointer(ptr_).assumingMemoryBound(to: UInt8.self)
                 let bufferIdx = _idx % bufferSize

stdlib/public/core/BridgeObjectiveC.swift

@@ -546,7 +546,7 @@ internal struct _CocoaFastEnumerationStackBuf {
     _item14 = _item0
     _item15 = _item0
 
-    _sanityCheck(MemoryLayout._ofInstance(self).size >=
+    _sanityCheck(MemoryLayout.size(ofValue: self) >=
                    MemoryLayout<Optional<UnsafeRawPointer>>.size * count)
   }
 }

stdlib/public/core/Builtin.swift

@@ -20,7 +20,7 @@ public func sizeof<T>(_:T.Type) -> Int {
   Builtin.unreachable()
 }
 
-@available(*, unavailable, message: "use MemoryLayout<T>.size instead.")
+@available(*, unavailable, renamed: "MemoryLayout.size(ofValue:)")
 public func sizeofValue<T>(_:T) -> Int {
   Builtin.unreachable()
 }
@@ -30,7 +30,7 @@ public func alignof<T>(_:T.Type) -> Int {
   Builtin.unreachable()
 }
 
-@available(*, unavailable, message: "use MemoryLayout<T>.alignment instead.")
+@available(*, unavailable, renamed: "MemoryLayout.alignment(ofValue:)")
 public func alignofValue<T>(_:T) -> Int {
   Builtin.unreachable()
 }
@@ -40,7 +40,7 @@ public func strideof<T>(_:T.Type) -> Int {
   Builtin.unreachable()
 }
 
-@available(*, unavailable, message: "use MemoryLayout<T>.stride instead.")
+@available(*, unavailable, renamed: "MemoryLayout.stride(ofValue:)")
 public func strideofValue<T>(_:T) -> Int {
   Builtin.unreachable()
 }

stdlib/public/core/Character.swift

@@ -176,7 +176,7 @@ public struct Character :
     let (count, initialUTF8) = s._core._encodeSomeUTF8(from: 0)
     // Notice that the result of sizeof() is a small non-zero number and can't
     // overflow when multiplied by 8.
-    let bits = MemoryLayout._ofInstance(initialUTF8).size &* 8 &- 1
+    let bits = MemoryLayout.size(ofValue: initialUTF8) &* 8 &- 1
     if _fastPath(
       count == s._core.count && (initialUTF8 & (1 << numericCast(bits))) != 0) {
       _representation = .small(Builtin.trunc_Int64_Int63(initialUTF8._value))

stdlib/public/core/MemoryLayout.swift

@@ -12,40 +12,59 @@
 
 /// The memory layout of a type, describing its size, stride, and alignment.
 public enum MemoryLayout<T> {
-
-  /// The contiguous memory footprint of the type.
+  /// The contiguous memory footprint of `T`.
   ///
-  /// The `size` property for a type `T` does not include any
-  /// dynamically-allocated or "remote" storage. In particular,
-  /// `MemoryLayout<T>.size`, when `T` is a class type, is the same regardless
-  /// of how many stored properties `T` has.
+  /// Does not include any dynamically-allocated or "remote" storage. In
+  /// particular, `MemoryLayout<T>.size`, when `T` is a class type, is the same
+  /// regardless of how many stored properties `T` has.
   @_transparent
   public static var size: Int {
     return Int(Builtin.sizeof(T.self))
   }
 
-  /// The number of bytes from the start of one instance to the start of the
-  /// next, when stored in a contiguous array.
+  /// The number of bytes from the start of one instance of `T` to the start of
+  /// the next in an `Array<T>`.
   ///
   /// This is the same as the number of bytes moved when an `UnsafePointer<T>`
-  /// is incremented. The type may have a lower minimal alignment that trades
-  /// runtime performance for space efficiency. The result is always positive.
+  /// is incremented. `T` may have a lower minimal alignment that trades runtime
+  /// performance for space efficiency. The result is always positive.
   @_transparent
   public static var stride: Int {
     return Int(Builtin.strideof_nonzero(T.self))
   }
 
-  /// The default memory alignment of the type.
+  /// The default memory alignment of `T`.
   @_transparent
   public static var alignment: Int {
     return Int(Builtin.alignof(T.self))
   }
 }
 
 extension MemoryLayout {
+  /// Returns the contiguous memory footprint of `T`.
+  ///
+  /// Does not include any dynamically-allocated or "remote" storage. In
+  /// particular, `MemoryLayout.size(ofValue: x)`, when `x` is a class instance,
+  /// is the same regardless of how many stored properties `T` has.
+  @_transparent
+  public static func size(ofValue _: T) -> Int {
+    return MemoryLayout.size
+  }
+
+  /// Returns the number of bytes from the start of one instance of `T` to the
+  /// start of the next in an `Array<T>`.
+  ///
+  /// This is the same as the number of bytes moved when an `UnsafePointer<T>`
+  /// is incremented. `T` may have a lower minimal alignment that trades runtime
+  /// performance for space efficiency. The result is always positive.
+  @_transparent
+  public static func stride(ofValue _: T) -> Int {
+    return MemoryLayout.stride
+  }
+
+  /// Returns the default memory alignment of `T`.
   @_transparent
-  public // @testable
-  static func _ofInstance(_: @autoclosure () -> T) -> MemoryLayout<T>.Type {
-    return MemoryLayout<T>.self
+  public static func alignment(ofValue _: T) -> Int {
+    return MemoryLayout.alignment
   }
 }

stdlib/public/core/Unicode.swift

@@ -838,7 +838,7 @@ internal func _transcodeSomeUTF16AsUTF8<Input>(
     nextIndex = input.index(nextIndex, offsetBy: utf16Length)
   }
   // FIXME: Annoying check, courtesy of <rdar://problem/16740169>
-  if utf8Count < MemoryLayout._ofInstance(result).size {
+  if utf8Count < MemoryLayout.size(ofValue: result) {
     result |= ~0 << numericCast(utf8Count * 8)
   }
   return (nextIndex, result)

stdlib/public/core/VarArgs.swift

@@ -144,7 +144,7 @@ extension Int64 : CVarArg, _CVarArgAligned {
   /// the value returned by `_cVarArgEncoding`.
   public var _cVarArgAlignment: Int {
     // FIXME: alignof differs from the ABI alignment on some architectures
-    return MemoryLayout._ofInstance(self).alignment
+    return MemoryLayout.alignment(ofValue: self)
   }
 }
 
@@ -192,7 +192,7 @@ extension UInt64 : CVarArg, _CVarArgAligned {
   /// the value returned by `_cVarArgEncoding`.
   public var _cVarArgAlignment: Int {
     // FIXME: alignof differs from the ABI alignment on some architectures
-    return MemoryLayout._ofInstance(self).alignment
+    return MemoryLayout.alignment(ofValue: self)
   }
 }
 
@@ -265,7 +265,7 @@ extension Float : _CVarArgPassedAsDouble, _CVarArgAligned {
   /// the value returned by `_cVarArgEncoding`.
   public var _cVarArgAlignment: Int {
     // FIXME: alignof differs from the ABI alignment on some architectures
-    return MemoryLayout._ofInstance(Double(self)).alignment
+    return MemoryLayout.alignment(ofValue: Double(self))
   }
 }
 
@@ -280,7 +280,7 @@ extension Double : _CVarArgPassedAsDouble, _CVarArgAligned {
   /// the value returned by `_cVarArgEncoding`.
   public var _cVarArgAlignment: Int {
     // FIXME: alignof differs from the ABI alignment on some architectures
-    return MemoryLayout._ofInstance(self).alignment
+    return MemoryLayout.alignment(ofValue: self)
   }
 }
 

test/1_stdlib/Character.swift

@@ -142,7 +142,7 @@ CharacterTests.test("sizeof") {
   expectTrue(size1 == 8 || size1 == 9)
 
   var a: Character = "a"
-  let size2 = MemoryLayout._ofInstance(a).size
+  let size2 = MemoryLayout.size(ofValue: a)
   expectTrue(size2 == 8 || size2 == 9)
 
   expectEqual(size1, size2)