---

yaml
---
r: 261887
b: refs/heads/tensorflow
c: 8664da6
h: refs/heads/master
i:
  261885: a5ff983
  261883: 2eea84c
  261879: dfa42f4
  261871: d36e890
  261855: d7f4460
  261823: 9ce570d
  261759: 3c26bf4
  261631: 64688f3

Author: atrick

[refs]

@@ -818,7 +818,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: dd08f6aa775b5069c155db0905d0f4d6a8fb95aa
+refs/heads/tensorflow: 8664da6d9d50e66820013b96bc6e2582935bc3fe
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/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)

branches/tensorflow/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;

branches/tensorflow/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++) {

branches/tensorflow/docs/ABI/Mangling.rst

@@ -183,7 +183,7 @@ types where the metadata itself has unknown layout.)
   global ::= type label-list? 'D'        // type mangling for the debugger with label list for function types.
   global ::= type 'TC'                   // continuation prototype (not actually used for real symbols)
   global ::= protocol-conformance entity 'TW' // protocol witness thunk
-  global ::= protocol-conformance entity 'TS' // protocol self-conformance witness thunk
+  global ::= entity 'TS'                 // protocol self-conformance witness thunk
   global ::= context identifier identifier 'TB' // property behavior initializer thunk (not used currently)
   global ::= context identifier identifier 'Tb' // property behavior setter thunk (not used currently)
   global ::= global specialization       // function specialization

branches/tensorflow/include/swift/ABI/Metadata.h

@@ -2083,10 +2083,10 @@ struct TargetTypeMetadataRecord {
   const TargetTypeContextDescriptor<Runtime> *
   getTypeContextDescriptor() const {
     switch (getTypeKind()) {
-    case TypeReferenceKind::DirectNominalTypeDescriptor:
+    case TypeReferenceKind::DirectTypeDescriptor:
       return DirectNominalTypeDescriptor.getPointer();
 
-    case TypeReferenceKind::IndirectNominalTypeDescriptor:
+    case TypeReferenceKind::IndirectTypeDescriptor:
       return *IndirectNominalTypeDescriptor.getPointer();
 
     // These types (and any others we might add to TypeReferenceKind
@@ -2172,14 +2172,14 @@ class RelativeTargetProtocolDescriptorPointer {
 template <typename Runtime>
 struct TargetTypeReference {
   union {
-    /// A direct reference to a nominal type descriptor.
-    RelativeDirectPointer<TargetTypeContextDescriptor<Runtime>>
-      DirectNominalTypeDescriptor;
+    /// A direct reference to a TypeContextDescriptor or ProtocolDescriptor.
+    RelativeDirectPointer<TargetContextDescriptor<Runtime>>
+      DirectTypeDescriptor;
 
-    /// An indirect reference to a nominal type descriptor.
+    /// An indirect reference to a TypeContextDescriptor or ProtocolDescriptor.
     RelativeDirectPointer<
-        ConstTargetMetadataPointer<Runtime, TargetTypeContextDescriptor>>
-      IndirectNominalTypeDescriptor;
+        ConstTargetMetadataPointer<Runtime, TargetContextDescriptor>>
+      IndirectTypeDescriptor;
 
     /// An indirect reference to an Objective-C class.
     RelativeDirectPointer<
@@ -2191,14 +2191,14 @@ struct TargetTypeReference {
       DirectObjCClassName;
   };
 
-  const TargetTypeContextDescriptor<Runtime> *
-  getTypeContextDescriptor(TypeReferenceKind kind) const {
+  const TargetContextDescriptor<Runtime> *
+  getTypeDescriptor(TypeReferenceKind kind) const {
     switch (kind) {
-    case TypeReferenceKind::DirectNominalTypeDescriptor:
-      return DirectNominalTypeDescriptor;
+    case TypeReferenceKind::DirectTypeDescriptor:
+      return DirectTypeDescriptor;
 
-    case TypeReferenceKind::IndirectNominalTypeDescriptor:
-      return *IndirectNominalTypeDescriptor;
+    case TypeReferenceKind::IndirectTypeDescriptor:
+      return *IndirectTypeDescriptor;
 
     case TypeReferenceKind::DirectObjCClassName:
     case TypeReferenceKind::IndirectObjCClass:
@@ -2305,8 +2305,8 @@ struct TargetProtocolConformanceDescriptor final
     return TypeRef.getIndirectObjCClass(getTypeKind());
   }
 
-  const TargetTypeContextDescriptor<Runtime> *getTypeContextDescriptor() const {
-    return TypeRef.getTypeContextDescriptor(getTypeKind());
+  const TargetContextDescriptor<Runtime> *getTypeDescriptor() const {
+    return TypeRef.getTypeDescriptor(getTypeKind());
   }
 
   /// Retrieve the context of a retroactive conformance.

branches/tensorflow/include/swift/ABI/MetadataValues.h

@@ -380,12 +380,12 @@ enum : unsigned {
 /// Kinds of type metadata/protocol conformance records.
 enum class TypeReferenceKind : unsigned {
   /// The conformance is for a nominal type referenced directly;
-  /// getNominalTypeDescriptor() points to the nominal type descriptor.
-  DirectNominalTypeDescriptor = 0x00,
+  /// getTypeDescriptor() points to the type context descriptor.
+  DirectTypeDescriptor = 0x00,
 
   /// The conformance is for a nominal type referenced indirectly;
-  /// getNominalTypeDescriptor() points to the nominal type descriptor.
-  IndirectNominalTypeDescriptor = 0x01,
+  /// getTypeDescriptor() points to the type context descriptor.
+  IndirectTypeDescriptor = 0x01,
 
   /// The conformance is for an Objective-C class that should be looked up
   /// by class name.
@@ -402,7 +402,7 @@ enum class TypeReferenceKind : unsigned {
 
   // We only reserve three bits for this in the various places we store it.
 
-  First_Kind = DirectNominalTypeDescriptor,
+  First_Kind = DirectTypeDescriptor,
   Last_Kind = IndirectObjCClass,
 };
 

branches/tensorflow/include/swift/AST/DiagnosticsCommon.def

@@ -95,6 +95,10 @@ NOTE(profile_read_error,none,
 ERROR(generic_signature_not_minimal,none,
       "generic requirement '%0' is redundant in %1", (StringRef, StringRef))
 
+WARNING(protocol_extension_redundant_requirement,none,
+      "requirement of '%1' to '%2' is redundant in an extension of '%0'",
+      (StringRef, StringRef, StringRef))
+
 ERROR(attr_only_on_parameters, none,
       "'%0' may only be used on parameters", (StringRef))
 

branches/tensorflow/include/swift/AST/ProtocolConformance.h

@@ -364,6 +364,33 @@ class RootProtocolConformance : public ProtocolConformance {
   ConcreteDeclRef getWitnessDeclRef(ValueDecl *requirement,
                                     LazyResolver *resolver) const;
 
+  /// Apply the given function object to each value witness within this
+  /// protocol conformance.
+  ///
+  /// The function object should accept a \c ValueDecl* for the requirement
+  /// followed by the \c Witness for the witness. Note that a generic
+  /// witness will only be specialized if the conformance came from the current
+  /// file.
+  template<typename F>
+  void forEachValueWitness(LazyResolver *resolver, F f) const {
+    const ProtocolDecl *protocol = getProtocol();
+    for (auto req : protocol->getMembers()) {
+      auto valueReq = dyn_cast<ValueDecl>(req);
+      if (!valueReq || isa<AssociatedTypeDecl>(valueReq) ||
+          valueReq->isInvalid())
+        continue;
+
+      if (!valueReq->isProtocolRequirement())
+        continue;
+
+      // If we don't have and cannot resolve witnesses, skip it.
+      if (!resolver && !hasWitness(valueReq))
+        continue;
+
+      f(valueReq, getWitness(valueReq, resolver));
+    }
+  }
+
   static bool classof(const ProtocolConformance *conformance) {
     return conformance->getKind() == ProtocolConformanceKind::Normal ||
            conformance->getKind() == ProtocolConformanceKind::Self;
@@ -639,33 +666,6 @@ class NormalProtocolConformance : public RootProtocolConformance,
   /// Set the witness for the given requirement.
   void setWitness(ValueDecl *requirement, Witness witness) const;
 
-  /// Apply the given function object to each value witness within this
-  /// protocol conformance.
-  ///
-  /// The function object should accept a \c ValueDecl* for the requirement
-  /// followed by the \c Witness for the witness. Note that a generic
-  /// witness will only be specialized if the conformance came from the current
-  /// file.
-  template<typename F>
-  void forEachValueWitness(LazyResolver *resolver, F f) const {
-    const ProtocolDecl *protocol = getProtocol();
-    for (auto req : protocol->getMembers()) {
-      auto valueReq = dyn_cast<ValueDecl>(req);
-      if (!valueReq || isa<AssociatedTypeDecl>(valueReq) ||
-          valueReq->isInvalid())
-        continue;
-
-      if (!valueReq->isProtocolRequirement())
-        continue;
-
-      // If we don't have and cannot resolve witnesses, skip it.
-      if (!resolver && !hasWitness(valueReq))
-        continue;
-
-      f(valueReq, getWitness(valueReq, resolver));
-    }
-  }
-
   /// Retrieve the protocol conformances that satisfy the requirements of the
   /// protocol, which line up with the conformance constraints in the
   /// protocol's requirement signature.

branches/tensorflow/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;

branches/tensorflow/include/swift/Remote/MetadataReader.h

@@ -790,7 +790,7 @@ class MetadataReader {
                    const MetadataFn &metadataFn,
                    const ClassNameFn &classNameFn) {
     switch (refKind) {
-    case TypeReferenceKind::IndirectNominalTypeDescriptor: {
+    case TypeReferenceKind::IndirectTypeDescriptor: {
       StoredPointer descriptorAddress = 0;
       if (!Reader->readInteger(RemoteAddress(ref), &descriptorAddress))
         return None;
@@ -799,7 +799,7 @@ class MetadataReader {
       LLVM_FALLTHROUGH;
     }
 
-    case TypeReferenceKind::DirectNominalTypeDescriptor: {
+    case TypeReferenceKind::DirectTypeDescriptor: {
       auto descriptor = readContextDescriptor(ref);
       if (!descriptor)
         return None;

branches/tensorflow/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;
   }

branches/tensorflow/lib/AST/ASTMangler.cpp

@@ -201,10 +201,7 @@ std::string ASTMangler::mangleWitnessThunk(
   beginMangling();
   // Concrete witness thunks get a special mangling.
   if (Conformance) {
-    if (auto selfConformance = dyn_cast<SelfProtocolConformance>(Conformance)) {
-      auto protocol = cast<SelfProtocolConformance>(Conformance)->getProtocol();
-      appendProtocolName(protocol);
-    } else {
+    if (!isa<SelfProtocolConformance>(Conformance)) {
       appendProtocolConformance(Conformance);
     }
   }

branches/tensorflow/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.

branches/tensorflow/lib/Demangling/Remangler.cpp

@@ -1720,7 +1720,7 @@ void Remangler::mangleProtocolRequirementsBaseDescriptor(Node *node) {
 }
 
 void Remangler::mangleProtocolSelfConformanceDescriptor(Node *node) {
-  mangleProtocol(node->getChild(0));
+  manglePureProtocol(node->getChild(0));
   Buffer << "MS";
 }
 

branches/tensorflow/lib/IRGen/GenDecl.cpp

@@ -2530,22 +2530,30 @@ IRGenModule::getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity,
 }
 
 static TypeEntityReference
-getTypeContextDescriptorEntityReference(IRGenModule &IGM,
-                                        NominalTypeDecl *decl) {
-  // A reference to a concrete type.
+getContextDescriptorEntityReference(IRGenModule &IGM, const LinkEntity &entity){
   // TODO: consider using a symbolic reference (i.e. a symbol string
   // to be looked up dynamically) for types defined outside the module.
-  auto kind = TypeReferenceKind::DirectNominalTypeDescriptor;
-  auto entity = LinkEntity::forNominalTypeDescriptor(decl);
-
-  IGM.IRGen.noteUseOfTypeContextDescriptor(decl, DontRequireMetadata);
   auto ref = IGM.getAddrOfLLVMVariableOrGOTEquivalent(entity);
+  auto kind = ref.isIndirect()
+                ? TypeReferenceKind::IndirectTypeDescriptor
+                : TypeReferenceKind::DirectTypeDescriptor;
+  return TypeEntityReference(kind, ref.getValue());
+}
 
-  if (ref.isIndirect()) {
-    kind = TypeReferenceKind::IndirectNominalTypeDescriptor;
-  }
+static TypeEntityReference
+getTypeContextDescriptorEntityReference(IRGenModule &IGM,
+                                        NominalTypeDecl *decl) {
+  auto entity = LinkEntity::forNominalTypeDescriptor(decl);
+  IGM.IRGen.noteUseOfTypeContextDescriptor(decl, DontRequireMetadata);
+  return getContextDescriptorEntityReference(IGM, entity);
+}
 
-  return TypeEntityReference(kind, ref.getValue());
+static TypeEntityReference
+getProtocolDescriptorEntityReference(IRGenModule &IGM, ProtocolDecl *protocol) {
+  assert(!protocol->isObjC() &&
+         "objc protocols don't have swift protocol descriptors");
+  auto entity = LinkEntity::forProtocolDescriptor(protocol);
+  return getContextDescriptorEntityReference(IGM, entity);
 }
 
 static TypeEntityReference
@@ -2577,6 +2585,11 @@ getRuntimeOnlyClassEntityReference(IRGenModule &IGM, ClassDecl *cls) {
 
 TypeEntityReference
 IRGenModule::getTypeEntityReference(NominalTypeDecl *decl) {
+  if (auto protocol = dyn_cast<ProtocolDecl>(decl)) {
+    assert(!protocol->isObjC() && "imported protocols not handled here");
+    return getProtocolDescriptorEntityReference(*this, protocol);
+  }
+
   auto clas = dyn_cast<ClassDecl>(decl);
   if (!clas) {
     return getTypeContextDescriptorEntityReference(*this, decl);