---

yaml
---
r: 345948
b: refs/heads/master
c: 635eef2
h: refs/heads/master

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a86313f1291d0c1ef78ad5ce749dd24a3e898e19
+refs/heads/master: 635eef202f6ca5ea62f0360767ad0cf2aaaef06b
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/benchmark/single-source/ObjectiveCBridgingStubs.swift

@@ -37,6 +37,7 @@ public let ObjectiveCBridgingStubs = [
   BenchmarkInfo(name: "ObjectiveCBridgeStringRangeOfString", runFunction: run_ObjectiveCBridgeStringRangeOfString, tags: [.validation, .String, .bridging], setUpFunction: setup_StringBridgeBenchmark),
   BenchmarkInfo(name: "ObjectiveCBridgeStringHash", runFunction: run_ObjectiveCBridgeStringHash, tags: [.validation, .String, .bridging], setUpFunction: setup_StringBridgeBenchmark),
   BenchmarkInfo(name: "ObjectiveCBridgeStringUTF8String", runFunction: run_ObjectiveCBridgeStringUTF8String, tags: [.validation, .String, .bridging], setUpFunction: setup_StringBridgeBenchmark),
+  BenchmarkInfo(name: "ObjectiveCBridgeStringCStringUsingEncoding", runFunction: run_ObjectiveCBridgeStringCStringUsingEncoding, tags: [.validation, .String, .bridging], setUpFunction: setup_StringBridgeBenchmark),
 ]
 
 var b:BridgeTester! = nil
@@ -387,6 +388,17 @@ public func run_ObjectiveCBridgeStringUTF8String(N: Int) {
   #endif
 }
 
+@inline(never)
+public func run_ObjectiveCBridgeStringCStringUsingEncoding(N: Int) {
+  #if _runtime(_ObjC)
+  for _ in 0 ..< N {
+    autoreleasepool {
+      b.testCStringUsingEncoding()
+    }
+  }
+  #endif
+}
+
 @inline(never)
 public func setup_StringBridgeBenchmark() {
 #if _runtime(_ObjC)

trunk/benchmark/utils/ObjectiveCTests/ObjectiveCTests.h

@@ -38,6 +38,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)testIsEqualToString2;
 - (void)testIsEqualToStringAllSwift;
 - (void)testUTF8String;
+- (void)testCStringUsingEncoding;
 - (void)testGetUTF8Contents;
 - (void)testGetASCIIContents;
 - (void)testRangeOfString;

trunk/benchmark/utils/ObjectiveCTests/ObjectiveCTests.m

@@ -249,6 +249,30 @@ - (void)testUTF8String {
   }
 }
 
+- (void)testCStringUsingEncoding {
+  for (NSString *str1 in bridgedStrings) {
+    @autoreleasepool {
+      for (int i = 0; i < 100; i++) {
+        (void)[str1 cStringUsingEncoding: NSASCIIStringEncoding];
+      }
+    }
+  }
+  for (NSString *str1 in bridgedStrings) {
+    @autoreleasepool {
+      for (int i = 0; i < 100; i++) {
+        (void)[str1 cStringUsingEncoding: NSUTF8StringEncoding];
+      }
+    }
+  }
+  for (NSString *str1 in bridgedStrings) {
+    @autoreleasepool {
+      for (int i = 0; i < 100; i++) {
+        (void)[str1 cStringUsingEncoding: NSUnicodeStringEncoding];
+      }
+    }
+  }
+}
+
 - (void)testGetUTF8Contents {
   for (NSString *str1 in bridgedStrings) {
     for (int i = 0; i < 200; i++) {

trunk/include/swift/IRGen/Linking.h

@@ -676,6 +676,7 @@ class LinkEntity {
   }
 
   static LinkEntity forPropertyDescriptor(AbstractStorageDecl *decl) {
+    assert(decl->exportsPropertyDescriptor());
     LinkEntity entity;
     entity.setForDecl(Kind::PropertyDescriptor, decl);
     return entity;

trunk/include/swift/SIL/SILLinkage.h

@@ -118,6 +118,10 @@ enum class SubclassScope : uint8_t {
   /// This class can only be subclassed in this module.
   Internal,
 
+  /// This class is resilient so even public methods cannot be directly
+  /// referenced from outside the module.
+  Resilient,
+
   /// There is no class to subclass, or it is final.
   NotApplicable,
 };
@@ -250,6 +254,11 @@ inline SILLinkage effectiveLinkageForClassMember(SILLinkage linkage,
       return SILLinkage::Hidden;
     break;
 
+  case SubclassScope::Resilient:
+    if (isAvailableExternally(linkage))
+      return SILLinkage::HiddenExternal;
+    return SILLinkage::Hidden;
+
   case SubclassScope::NotApplicable:
     break;
   }

trunk/lib/AST/Decl.cpp

@@ -5335,6 +5335,9 @@ bool AbstractFunctionDecl::isObjCInstanceMethod() const {
 }
 
 static bool requiresNewVTableEntry(const AbstractFunctionDecl *decl) {
+  if (!isa<ClassDecl>(decl->getDeclContext()))
+    return true;
+
   assert(isa<FuncDecl>(decl) || isa<ConstructorDecl>(decl));
 
   // Final members are always be called directly.

trunk/lib/IRGen/GenInit.cpp

@@ -37,10 +37,11 @@ using namespace irgen;
 /// Emit a global variable.
 void IRGenModule::emitSILGlobalVariable(SILGlobalVariable *var) {
   auto &ti = getTypeInfo(var->getLoweredType());
-  
-  // If the variable is empty in all resilience domains, don't actually emit it;
-  // just return undef.
-  if (ti.isKnownEmpty(ResilienceExpansion::Minimal)) {
+  auto expansion = getResilienceExpansionForLayout(var);
+
+  // If the variable is empty in all resilience domains that can access this
+  // variable directly, don't actually emit it; just return undef.
+  if (ti.isKnownEmpty(expansion)) {
     if (DebugInfo && var->getDecl()) {
       auto DbgTy = DebugTypeInfo::getGlobal(var, Int8Ty, Size(0), Alignment(1));
       DebugInfo->emitGlobalVariableDeclaration(

trunk/lib/SIL/SILDeclRef.cpp

@@ -893,10 +893,14 @@ SubclassScope SILDeclRef::getSubclassScope() const {
     return SubclassScope::NotApplicable;
 
   // If this declaration is a function which goes into a vtable, then it's
-  // symbol must be as visible as its class. Derived classes even have to put
+  // symbol must be as visible as its class, because derived classes have to put
   // all less visible methods of the base class into their vtables.
 
-  auto *FD = dyn_cast<AbstractFunctionDecl>(getDecl());
+  if (auto *CD = dyn_cast<ConstructorDecl>(getDecl()))
+    if (!CD->isRequired())
+      return SubclassScope::NotApplicable;
+
+  auto *FD = dyn_cast<FuncDecl>(getDecl());
   if (!FD)
     return SubclassScope::NotApplicable;
 
@@ -924,6 +928,9 @@ SubclassScope SILDeclRef::getSubclassScope() const {
   assert(FD->getEffectiveAccess() <= classType->getEffectiveAccess() &&
          "class must be as visible as its members");
 
+  if (classType->isResilient())
+    return SubclassScope::Resilient;
+
   switch (classType->getEffectiveAccess()) {
   case AccessLevel::Private:
   case AccessLevel::FilePrivate:
@@ -932,8 +939,6 @@ SubclassScope SILDeclRef::getSubclassScope() const {
   case AccessLevel::Public:
     return SubclassScope::Internal;
   case AccessLevel::Open:
-    if (classType->isResilient())
-      return SubclassScope::Internal;
     return SubclassScope::External;
   }
 

trunk/lib/SILGen/SILGenGlobalVariable.cpp

@@ -36,21 +36,27 @@ SILGlobalVariable *SILGenModule::getSILGlobalVariable(VarDecl *gDecl,
     }
   }
 
+  // Get the linkage for SILGlobalVariable.
+  FormalLinkage formalLinkage;
+  if (gDecl->isResilient())
+    formalLinkage = FormalLinkage::Private;
+  else
+    formalLinkage = getDeclLinkage(gDecl);
+  auto silLinkage = getSILLinkage(formalLinkage, forDef);
+
   // Check if it is already created, and update linkage if necessary.
   if (auto gv = M.lookUpGlobalVariable(mangledName)) {
     // Update the SILLinkage here if this is a definition.
     if (forDef == ForDefinition) {
-      gv->setLinkage(getSILLinkage(getDeclLinkage(gDecl), ForDefinition));
+      gv->setLinkage(silLinkage);
       gv->setDeclaration(false);
     }
     return gv;
   }
 
-  // Get the linkage for SILGlobalVariable.
-  SILLinkage link = getSILLinkage(getDeclLinkage(gDecl), forDef);
   SILType silTy = M.Types.getLoweredTypeOfGlobal(gDecl);
 
-  auto *silGlobal = SILGlobalVariable::create(M, link, IsNotSerialized,
+  auto *silGlobal = SILGlobalVariable::create(M, silLinkage, IsNotSerialized,
                                               mangledName, silTy,
                                               None, gDecl);
   silGlobal->setDeclaration(!forDef);

trunk/lib/TBDGen/TBDGen.cpp

@@ -224,27 +224,30 @@ void TBDGenVisitor::visitAbstractStorageDecl(AbstractStorageDecl *ASD) {
 }
 
 void TBDGenVisitor::visitVarDecl(VarDecl *VD) {
-  // Non-global variables might have an explicit initializer symbol, in
-  // non-resilient modules.
-  if (VD->getAttrs().hasAttribute<HasInitialValueAttr>() &&
-      SwiftModule->getResilienceStrategy() == ResilienceStrategy::Default &&
-      !isGlobalOrStaticVar(VD)) {
-    auto declRef = SILDeclRef(VD, SILDeclRef::Kind::StoredPropertyInitializer);
-    // Stored property initializers for public properties are currently
-    // public.
-    addSymbol(declRef);
-  }
-
-  // statically/globally stored variables have some special handling.
-  if (VD->hasStorage() && isGlobalOrStaticVar(VD)) {
-    if (getDeclLinkage(VD) == FormalLinkage::PublicUnique) {
-      // The actual variable has a symbol.
-      Mangle::ASTMangler mangler;
-      addSymbol(mangler.mangleEntity(VD, false));
+  // Variables inside non-resilient modules have some additional symbols.
+  if (!VD->isResilient()) {
+    // Non-global variables might have an explicit initializer symbol, in
+    // non-resilient modules.
+    if (VD->getAttrs().hasAttribute<HasInitialValueAttr>() &&
+        !isGlobalOrStaticVar(VD)) {
+      auto declRef = SILDeclRef(VD, SILDeclRef::Kind::StoredPropertyInitializer);
+      // Stored property initializers for public properties are currently
+      // public.
+      addSymbol(declRef);
     }
 
-    if (VD->isLazilyInitializedGlobal())
-      addSymbol(SILDeclRef(VD, SILDeclRef::Kind::GlobalAccessor));
+    // statically/globally stored variables have some special handling.
+    if (VD->hasStorage() &&
+        isGlobalOrStaticVar(VD)) {
+      if (getDeclLinkage(VD) == FormalLinkage::PublicUnique) {
+        // The actual variable has a symbol.
+        Mangle::ASTMangler mangler;
+        addSymbol(mangler.mangleEntity(VD, false));
+      }
+
+      if (VD->isLazilyInitializedGlobal())
+        addSymbol(SILDeclRef(VD, SILDeclRef::Kind::GlobalAccessor));
+    }
   }
 
   visitAbstractStorageDecl(VD);

trunk/stdlib/public/SwiftShims/CoreFoundationShims.h

@@ -125,6 +125,18 @@ SWIFT_RUNTIME_STDLIB_API
 _swift_shims_CFHashCode
 _swift_stdlib_CFStringHashCString(const _swift_shims_UInt8 * _Nonnull bytes,
                                   _swift_shims_CFIndex length);
+
+SWIFT_RUNTIME_STDLIB_API
+const __swift_uint8_t * _Nullable
+_swift_stdlib_NSStringCStringUsingEncodingTrampoline(id _Nonnull obj,
+                                                     unsigned long encoding);
+
+SWIFT_RUNTIME_STDLIB_API
+__swift_uint8_t
+_swift_stdlib_NSStringGetCStringTrampoline(id _Nonnull obj,
+                                         _swift_shims_UInt8 *buffer,
+                                         _swift_shims_CFIndex maxLength,
+                                         unsigned long encoding);
 
 #endif // __OBJC2__
 

trunk/stdlib/public/core/StringBridge.swift

@@ -93,6 +93,33 @@ internal func _cocoaHashASCIIBytes(
   return _swift_stdlib_CFStringHashCString(bytes, length)
 }
 
+// These "trampolines" are effectively objc_msgSend_super.
+// They bypass our implementations to use NSString's
+
+@_effects(readonly)
+internal func _cocoaCStringUsingEncodingTrampoline(
+  _ string: _CocoaString,
+  _ encoding: UInt)
+  -> UnsafePointer<UInt8>? {
+    return _swift_stdlib_NSStringCStringUsingEncodingTrampoline(
+      string,
+      encoding)
+}
+
+
+@_effects(releasenone)
+internal func _cocoaGetCStringTrampoline(
+                             _ string: _CocoaString,
+                             _ buffer: UnsafeMutablePointer<UInt8>,
+                             _ maxLength: Int,
+                             _ encoding: UInt)
+  -> Int8 {
+    return Int8(_swift_stdlib_NSStringGetCStringTrampoline(string,
+                                                    buffer,
+                                                    maxLength,
+                                                    encoding))
+}
+
 //
 // Conversion from NSString to Swift's native representation
 //