---

yaml
---
r: 349365
b: refs/heads/master-next
c: 0d74b5c
h: refs/heads/master
i:
  349363: 1d90297

Author: swift-ci

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 4e4836d708dc55bc1b7926a5983977890d88af7a
+refs/heads/master-next: 0d74b5c71c410ac59b5a77c31620a5fe7e4ab628
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/include/swift/AST/DiagnosticsSema.def

@@ -81,6 +81,13 @@ ERROR(could_not_find_value_member,none,
 ERROR(could_not_find_value_member_corrected,none,
       "value of type %0 has no member %1; did you mean %2?",
       (Type, DeclName, DeclName))
+ERROR(could_not_find_value_dynamic_member_corrected,none,
+      "value of type %0 has no dynamic member %2 using key path from root type %1; did you mean %3?",
+      (Type, Type, DeclName, DeclName))
+ERROR(could_not_find_value_dynamic_member,none,
+      "value of type %0 has no dynamic member %2 using key path from root type %1",
+      (Type, Type, DeclName))
+
 ERROR(could_not_find_type_member,none,
       "type %0 has no member %1", (Type, DeclName))
 ERROR(could_not_find_type_member_corrected,none,

branches/master-next/lib/Sema/CSDiagnostics.cpp

@@ -2258,8 +2258,8 @@ bool MissingMemberFailure::diagnoseAsError() {
   };
 
   TypoCorrectionResults corrections(TC, getName(), nameLoc);
-  auto tryTypoCorrection = [&] {
-    TC.performTypoCorrection(getDC(), DeclRefKind::Ordinary, baseType,
+  auto tryTypoCorrection = [&] (Type type) {
+    TC.performTypoCorrection(getDC(), DeclRefKind::Ordinary, type,
                              defaultMemberLookupOptions, corrections);
   };
 
@@ -2279,7 +2279,7 @@ bool MissingMemberFailure::diagnoseAsError() {
         .highlight(baseExpr->getSourceRange());
   } else if (auto metatypeTy = baseType->getAs<MetatypeType>()) {
     auto instanceTy = metatypeTy->getInstanceType();
-    tryTypoCorrection();
+    tryTypoCorrection(baseType);
 
     if (DeclName rightName =
             findCorrectEnumCaseName(instanceTy, corrections, getName())) {
@@ -2323,18 +2323,46 @@ bool MissingMemberFailure::diagnoseAsError() {
           .fixItInsertAfter(baseExpr->getEndLoc(), " as AnyObject)");
       return true;
     }
-
-    tryTypoCorrection();
-
-    if (auto correction = corrections.claimUniqueCorrection()) {
-      auto diagnostic = emitDiagnostic(
-          anchor->getLoc(), diag::could_not_find_value_member_corrected,
-          baseType, getName(), correction->CorrectedName);
-      diagnostic.highlight(baseExpr->getSourceRange())
-          .highlight(nameLoc.getSourceRange());
-      correction->addFixits(diagnostic);
+    
+    tryTypoCorrection(baseType);
+    
+    // If locator points to the member found via key path dynamic member lookup,
+    // we provide a custom diagnostic and emit typo corrections for the wrapper type too.
+    if (getLocator()->isForKeyPathDynamicMemberLookup()) {
+      auto baseExprType = getType(baseExpr)->getWithoutSpecifierType();
+      
+      tryTypoCorrection(baseExprType);
+      
+      if (auto correction = corrections.claimUniqueCorrection()) {
+        auto diagnostic = emitDiagnostic(
+            anchor->getLoc(),
+            diag::could_not_find_value_dynamic_member_corrected,
+            baseExprType, baseType, getName(),
+            correction->CorrectedName);
+        diagnostic.highlight(baseExpr->getSourceRange())
+            .highlight(nameLoc.getSourceRange());
+        correction->addFixits(diagnostic);
+      } else {
+        auto diagnostic = emitDiagnostic(
+            anchor->getLoc(),
+            diag::could_not_find_value_dynamic_member,
+            baseExprType, baseType, getName());
+        diagnostic.highlight(baseExpr->getSourceRange())
+            .highlight(nameLoc.getSourceRange());
+      }
     } else {
-      emitBasicError(baseType);
+      if (auto correction = corrections.claimUniqueCorrection()) {
+        auto diagnostic = emitDiagnostic(
+            anchor->getLoc(),
+            diag::could_not_find_value_member_corrected,
+            baseType, getName(),
+            correction->CorrectedName);
+        diagnostic.highlight(baseExpr->getSourceRange())
+            .highlight(nameLoc.getSourceRange());
+        correction->addFixits(diagnostic);
+      } else {
+        emitBasicError(baseType);
+      }
     }
   }
 

branches/master-next/stdlib/public/Darwin/Foundation/String.swift

@@ -96,3 +96,28 @@ extension Substring : _ObjectiveCBridgeable {
 }
 
 extension String: CVarArg {}
+
+/*
+ This is on NSObject so that the stdlib can call it in StringBridge.swift
+ without having to synthesize a receiver (e.g. lookup a class or allocate)
+ 
+ In the future (once the Foundation overlay can know about SmallString), we
+ should move the caller of this method up into the overlay and avoid this
+ indirection.
+ */
+private extension NSObject {
+  // The ObjC selector has to start with "new" to get ARC to not autorelease
+  @_effects(releasenone)
+  @objc(newTaggedNSStringWithASCIIBytes_:length_:)
+  func createTaggedString(bytes: UnsafePointer<UInt8>,
+                          count: Int) -> AnyObject? {
+    //TODO: update this to use _CFStringCreateTaggedPointerString once we can
+    return CFStringCreateWithBytes(
+      kCFAllocatorSystemDefault,
+      bytes,
+      count,
+      CFStringBuiltInEncodings.UTF8.rawValue,
+      false
+    ) as NSString as NSString? //just "as AnyObject" inserts unwanted bridging
+  }
+}

branches/master-next/stdlib/public/SwiftShims/CoreFoundationShims.h

@@ -28,29 +28,17 @@ namespace swift { extern "C" {
 
 #ifdef __OBJC2__
 #if __LLP64__
-typedef unsigned long long _swift_shims_CFTypeID;
 typedef unsigned long long _swift_shims_CFHashCode;
 typedef signed long long _swift_shims_CFIndex;
 #else
-typedef unsigned long _swift_shims_CFTypeID;
 typedef unsigned long _swift_shims_CFHashCode;
 typedef signed long _swift_shims_CFIndex;
 #endif
 
-typedef id _swift_shims_CFStringRef;
-typedef __swift_uint32_t _swift_shims_CFStringEncoding;
-
 // Consider creating SwiftMacTypes.h for these
 typedef unsigned char _swift_shims_Boolean;
 typedef __swift_uint8_t _swift_shims_UInt8;
-
-SWIFT_RUNTIME_STDLIB_API
-__attribute__((ns_returns_retained))
-_swift_shims_CFStringRef _Nonnull _swift_stdlib_CFStringCreateWithBytes(
-    const void * _Nullable unused,
-    const __swift_uint8_t *_Nonnull bytes, _swift_shims_CFIndex numBytes,
-    _swift_shims_CFStringEncoding encoding,
-    _swift_shims_Boolean isExternalRepresentation);
+typedef __swift_uint32_t _swift_shims_CFStringEncoding;
 
 SWIFT_RUNTIME_STDLIB_API
 __swift_uint8_t _swift_stdlib_isNSString(id _Nonnull obj);

branches/master-next/stdlib/public/core/StringBridge.swift

@@ -58,6 +58,10 @@ internal typealias _CocoaString = AnyObject
                options: UInt,
                range: _SwiftNSRange,
                locale: AnyObject?) -> Int
+
+  @objc(newTaggedNSStringWithASCIIBytes_:length_:)
+  func createTaggedString(bytes: UnsafePointer<UInt8>, 
+                          count: Int) -> AnyObject?
 }
 
 /*
@@ -410,19 +414,28 @@ extension String {
   }
 }
 
+@_effects(releasenone)
+private func _createNSString(
+  _ receiver: _StringSelectorHolder,
+  _ ptr: UnsafePointer<UInt8>,
+  _ count: Int,
+  _ encoding: UInt32
+) -> AnyObject? {
+  return receiver.createTaggedString(bytes: ptr, count: count)
+}
+
 @_effects(releasenone)
 private func _createCFString(
   _ ptr: UnsafePointer<UInt8>,
   _ count: Int,
   _ encoding: UInt32
-) -> AnyObject {
-  return _swift_stdlib_CFStringCreateWithBytes(
-    nil, //ignored in the shim for perf reasons
+) -> AnyObject? {
+  return _createNSString(
+    unsafeBitCast(__StringStorage.self as AnyClass, to: _StringSelectorHolder.self),
     ptr,
     count,
-    kCFStringEncodingUTF8,
-    0
-  ) as AnyObject
+    encoding
+  )
 }
 
 extension String {
@@ -431,13 +444,14 @@ extension String {
   func _bridgeToObjectiveCImpl() -> AnyObject {
     // Smol ASCII a) may bridge to tagged pointers, b) can't contain a BOM
     if _guts.isSmallASCII {
-      return _guts.asSmall.withUTF8 { bufPtr in
+      let maybeTagged = _guts.asSmall.withUTF8 { bufPtr in
         return _createCFString(
           bufPtr.baseAddress._unsafelyUnwrappedUnchecked,
           bufPtr.count,
           kCFStringEncodingUTF8
         )
       }
+      if let tagged = maybeTagged { return tagged }
     }
     if _guts.isSmall {
         // We can't form a tagged pointer String, so grow to a non-small String,

branches/master-next/stdlib/public/stubs/FoundationHelpers.mm

@@ -25,38 +25,13 @@
 
 using namespace swift;
 
-template <class FromTy> struct DestType;
-
-#define BRIDGE_TYPE(FROM, TO) \
-template <> struct DestType<FROM> { using type = TO; }
-
-BRIDGE_TYPE(_swift_shims_CFStringRef, CFStringRef);
-BRIDGE_TYPE(_swift_shims_CFStringEncoding, CFStringEncoding);
-BRIDGE_TYPE(CFStringRef, _swift_shims_CFStringRef);
-
-template <class FromTy>
-static typename DestType<FromTy>::type cast(FromTy value) {
-  return (typename DestType<FromTy>::type) value;
-}
-
 __swift_uint8_t
 swift::_swift_stdlib_isNSString(id obj) {
   //TODO: we can likely get a small perf win by using _NSIsNSString on
   //sufficiently new OSs
   return CFGetTypeID((CFTypeRef)obj) == CFStringGetTypeID() ? 1 : 0;
 }
 
-_swift_shims_CFStringRef
-swift::_swift_stdlib_CFStringCreateWithBytes(
-    const void *unused, const uint8_t *bytes,
-    _swift_shims_CFIndex numBytes, _swift_shims_CFStringEncoding encoding,
-    _swift_shims_Boolean isExternalRepresentation) {
-  assert(unused == NULL);
-  return cast(CFStringCreateWithBytes(kCFAllocatorSystemDefault, bytes, numBytes,
-                                      cast(encoding),
-                                      isExternalRepresentation));
-}
-
 extern "C" CFHashCode CFStringHashCString(const uint8_t *bytes, CFIndex len);
 extern "C" CFHashCode CFStringHashNSString(id str);
 

branches/master-next/test/attr/attr_dynamic_member_lookup.swift

@@ -688,3 +688,37 @@ func invalid_refs_through_dynamic_lookup() {
     _ = lens.baz("hello")  // expected-error {{dynamic key path member lookup cannot refer to static method 'baz'}}
   }
 }
+
+// SR-10597
+
+final class SR10597 {
+}
+
+@dynamicMemberLookup
+struct SR10597_W<T> {
+  var obj: T
+  init(_ obj: T) { self.obj = obj }
+  subscript<U>(dynamicMember member: KeyPath<T, U>) -> U {
+    return obj[keyPath: member]
+  }
+  var wooo: SR10597 { SR10597() } // expected-note {{declared here}}
+}
+
+_ = SR10597_W<SR10597>(SR10597()).wooooo // expected-error {{value of type 'SR10597_W<SR10597>' has no dynamic member 'wooooo' using key path from root type 'SR10597'; did you mean 'wooo'?}}
+_ = SR10597_W<SR10597>(SR10597()).bla // expected-error {{value of type 'SR10597_W<SR10597>' has no dynamic member 'bla' using key path from root type 'SR10597'}}
+
+final class SR10597_1 {
+    var woo: Int? // expected-note 2 {{'woo' declared here}}
+}
+
+@dynamicMemberLookup
+struct SR10597_1_W<T> {
+  var obj: T
+  init(_ obj: T) { self.obj = obj }
+  subscript<U>(dynamicMember member: KeyPath<T, U>) -> U {
+    return obj[keyPath: member]
+  }
+}
+
+_ = SR10597_1_W<SR10597_1>(SR10597_1()).wooo // expected-error {{value of type 'SR10597_1_W<SR10597_1>' has no dynamic member 'wooo' using key path from root type 'SR10597_1'; did you mean 'woo'?}}
+_ = SR10597_1_W<SR10597_1>(SR10597_1()).bla // expected-error {{value of type 'SR10597_1_W<SR10597_1>' has no dynamic member 'bla' using key path from root type 'SR10597_1'}}