[Type checker SR-899] Warning on missing ".self" for single-parameter functions.

Due to a modeling error in the type checker's folding of type
references into type expressions, code such as "strideof(Int)" would
be accepted without the required ".self". Commit
4a60b6c fixes the modeling issue but
left the historical accepts-invalid; now, diagnose these cases with a
warning + Fix-It to ease the transition.

Fixes SR-899.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -2168,6 +2168,8 @@ ERROR(value_of_module_type,none,
 
 ERROR(value_of_metatype_type,none,
       "expected member name or constructor call after type name", ())
+WARNING(warn_value_of_metatype_missing_self,none,
+      "missing '.self' for reference to metatype of type %0", (Type))
 
 NOTE(add_parens_to_type,none,
      "add arguments after the type to construct a value of the type", ())

lib/Sema/MiscDiagnostics.cpp

@@ -494,13 +494,15 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
           return;
         }
 
-        // FIXME: As a specific hack, we white-list parenthesized
-        // expressions that are call arguments.  This allows some
-        // ill-formed code to omit ".self" due to a historical bug. We
-        // keep that code working until we have a decision on SE-0090,
-        // rather than potentially breaking code twice.
-        if (isa<ParenExpr>(ParentExpr) && CallArgs.count(ParentExpr) > 0)
+        // Note: as a specific hack, produce a warning + Fix-It for
+        // the missing ".self" as the subexpression of a parenthesized
+        // expression, which is a historical bug.
+        if (isa<ParenExpr>(ParentExpr) && CallArgs.count(ParentExpr) > 0) {
+          TC.diagnose(E->getEndLoc(), diag::warn_value_of_metatype_missing_self,
+                      E->getType()->getRValueInstanceType())
+            .fixItInsertAfter(E->getEndLoc(), ".self");
           return;
+        }
       }
 
       // Is this a protocol metatype?

stdlib/private/SwiftPrivateLibcExtras/SwiftPrivateLibcExtras.swift

@@ -40,7 +40,7 @@ public var _stdlib_FD_SETSIZE: CInt {
 public struct _stdlib_fd_set {
   var _data: [UInt]
   static var _wordBits: Int {
-    return sizeof(UInt) * 8
+    return sizeof(UInt.self) * 8
   }
 
   public init() {

stdlib/public/SDK/CoreAudio/CoreAudio.swift

@@ -17,7 +17,7 @@ extension UnsafeBufferPointer {
   public init(_ audioBuffer: AudioBuffer) {
     self.init(
       start: UnsafePointer<Element>(audioBuffer.mData),
-      count: Int(audioBuffer.mDataByteSize) / strideof(Element))
+      count: Int(audioBuffer.mDataByteSize) / strideof(Element.self))
   }
 }
 
@@ -27,7 +27,7 @@ extension UnsafeMutableBufferPointer {
   public init(_ audioBuffer: AudioBuffer) {
     self.init(
       start: UnsafeMutablePointer<Element>(audioBuffer.mData),
-      count: Int(audioBuffer.mDataByteSize) / strideof(Element))
+      count: Int(audioBuffer.mDataByteSize) / strideof(Element.self))
   }
 }
 
@@ -40,7 +40,7 @@ extension AudioBuffer {
   ) {
     self.mNumberChannels = UInt32(numberOfChannels)
     self.mData = UnsafeMutablePointer<Void>(typedBuffer.baseAddress)
-    self.mDataByteSize = UInt32(typedBuffer.count * strideof(Element))
+    self.mDataByteSize = UInt32(typedBuffer.count * strideof(Element.self))
   }
 }
 
@@ -50,8 +50,8 @@ extension AudioBufferList {
   public static func sizeInBytes(maximumBuffers: Int) -> Int {
     _precondition(maximumBuffers >= 1,
       "AudioBufferList should contain at least one AudioBuffer")
-    return sizeof(AudioBufferList) +
-      (maximumBuffers - 1) * strideof(AudioBuffer)
+    return sizeof(AudioBufferList.self) +
+      (maximumBuffers - 1) * strideof(AudioBuffer.self)
   }
 
   /// Allocate an `AudioBufferList` with a capacity for the specified number of

stdlib/public/SDK/SceneKit/SceneKit.swift

@@ -162,10 +162,10 @@ extension SCNGeometryElement {
       primitiveCount = indexCount
     }
     self.init(
-      data: NSData(bytes: indices, length: indexCount * sizeof(IndexType)),
+      data: NSData(bytes: indices, length: indexCount * sizeof(IndexType.self)),
       primitiveType: primitiveType,
       primitiveCount: primitiveCount,
-      bytesPerIndex: sizeof(IndexType))
+      bytesPerIndex: sizeof(IndexType.self))
   }
 }
 

stdlib/public/core/Builtin.swift

@@ -98,7 +98,7 @@ internal func _roundUp<T, DestinationType>(
   return UnsafeMutablePointer<DestinationType>(
     bitPattern: _roundUpImpl(
       UInt(bitPattern: pointer),
-      toAlignment: alignof(DestinationType))
+      toAlignment: alignof(DestinationType.self))
   ).unsafelyUnwrapped
 }
 

stdlib/public/core/HashedCollections.swift.gyb

@@ -2475,14 +2475,14 @@ final internal class _Native${Self}StorageImpl<${TypeParameters}> :
   /// padding to align the start to word alignment.
   internal static func bytesForBitMap(capacity: Int) -> Int {
     let numWords = _UnsafeBitMap.sizeInWords(forSizeInBits: capacity)
-    return numWords * strideof(UInt) + alignof(UInt)
+    return numWords * strideof(UInt.self) + alignof(UInt.self)
   }
 
   /// Returns the bytes necessary to store 'capacity' keys and padding to align
   /// the start to the alignment of the 'Key' type assuming a word aligned base
   /// address.
   internal static func bytesForKeys(capacity: Int) -> Int {
-    let padding = max(0, alignof(Key.self) - alignof(UInt))
+    let padding = max(0, alignof(Key.self) - alignof(UInt.self))
     return strideof(Key.self) * capacity + padding
   }
 
@@ -2492,7 +2492,7 @@ final internal class _Native${Self}StorageImpl<${TypeParameters}> :
   /// address aligned to the maximum of the alignment of the 'Key' type and the
   /// alignment of a word.
   internal static func bytesForValues(capacity: Int) -> Int {
-    let maxPrevAlignment = max(alignof(Key.self), alignof(UInt))
+    let maxPrevAlignment = max(alignof(Key.self), alignof(UInt.self))
     let padding = max(0, alignof(Value.self) - maxPrevAlignment)
     return strideof(Value.self) * capacity + padding
   }
@@ -2540,7 +2540,7 @@ final internal class _Native${Self}StorageImpl<${TypeParameters}> :
     let bitMapSizeInBytes =
       _unsafeMultiply(
         _UnsafeBitMap.sizeInWords(forSizeInBits: _capacity),
-        strideof(UInt))
+        strideof(UInt.self))
     let start =
       UnsafeMutablePointer<UInt8>(_initializedHashtableEntriesBitMapStorage)
       + bitMapSizeInBytes

stdlib/public/core/ManagedBuffer.swift

@@ -248,7 +248,7 @@ public struct ManagedBufferPointer<Value, Element> : Equatable {
   /// idea to store this information in the "value" area when
   /// an instance is created.
   public var capacity: Int {
-    return (_capacityInBytes &- _My._elementOffset) / strideof(Element)
+    return (_capacityInBytes &- _My._elementOffset) / strideof(Element.self)
   }
 
   /// Call `body` with an `UnsafeMutablePointer` to the stored

stdlib/public/core/Runtime.swift.gyb

@@ -474,7 +474,7 @@ func _rawPointerToString(_ value: Builtin.RawPointer) -> String {
       radix: 16,
       uppercase: false
     )
-  for _ in 0..<(2 * sizeof(UnsafePointer<Void>) - result.utf16.count) {
+  for _ in 0..<(2 * sizeof(UnsafePointer<Void>.self) - result.utf16.count) {
     result = "0" + result
   }
   return "0x" + result

test/Constraints/metatypes.swift

@@ -13,3 +13,6 @@ struct S {}
 
 let test5 : S.Type = S.self
 let test6 : AnyClass = S.self // expected-error {{cannot convert value of type 'S.Type' to specified type 'AnyClass' (aka 'AnyObject.Type')}}
+
+func acceptMeta<T>(_ meta: T.Type) { }
+acceptMeta(A) // expected-warning{{missing '.self' for reference to metatype of type 'A'}}{{13-13=.self}}