---

yaml
---
r: 343791
b: refs/heads/master-rebranch
c: 1f0e2da
h: refs/heads/master
i:
  343789: 19242d5
  343787: 77a0366
  343783: 1dfc424
  343775: cea0c1f

Author: DougGregor

[refs]

@@ -1455,7 +1455,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-02-a: ddd2b2976aa9bfde5f20fe37f6bd2
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-03-a: 171cc166f2abeb5ca2a4003700a8a78a108bd300
 refs/heads/benlangmuir-patch-1: baaebaf39d52f3bf36710d4fe40cf212e996b212
 refs/heads/i-do-redeclare: 8c4e6d5de5c1e3f0a2cedccf319df713ea22c48e
-refs/heads/master-rebranch: 6329fc0a92aa0881e578f1f85dd9952a4b7d84dc
+refs/heads/master-rebranch: 1f0e2da9a09648b6065e099a75ae4b7d6a010707
 refs/heads/rdar-53901732: 9bd06af3284e18a109cdbf9aa59d833b24eeca7b
 refs/heads/revert-26776-subst-always-returns-a-type: 1b8e18fdd391903a348970a4c848995d4cdd789c
 refs/heads/tensorflow-merge: 8b854f62f80d4476cb383d43c4aac2001dde3cec

branches/master-rebranch/docs/CToSwiftNameTranslation.md

@@ -2,6 +2,19 @@
 
 This document gives a high-level description of how C and Objective-C declarations are translated to Swift, with particular focus on how names are adjusted. It is not attempting to be a *complete* description of everything the compiler does except with regards to how *names* are transformed; even there, some special cases that only apply to Apple's SDKs have been omitted.
 
+## Word boundaries
+
+Several forms of name translation are defined in terms of word boundaries. The word-splitting algorithm used by the Swift compiler is as follows: there is a boundary after
+
+1. An underscore ("\_").
+2. A series of two or more uppercase ASCII characters and the suffix "s", "es", or "ies" (e.g. "URLs", "VAXes")...unless the last uppercase letter is "I" and the suffix is "s", in which case it's just as likely to be an acronym followed by "Is" (i.e. "URLIs" is treated as "URL Is").
+2. A series of two or more uppercase ASCII characters followed by an uppercase ASCII character and then a lowercase ASCII character ("XMLReader" becomes "XML Reader").
+3. A series of two or more uppercase ASCII characters followed by a non-ASCII-alphabetic character. ("UTF8" becomes "UTF 8")
+4. A series of two or more uppercase ASCII characters at the end of the string.
+5. An uppercase ASCII character and any number of non-ASCII-uppercase, non-underscore characters ("ContrivedExample" becomes "Contrived Example").
+6. Any number of non-ASCII-uppercase, non-underscore characters ("lowercase\_example" becomes "lowercase \_ example").
+
+
 ## Enums
 
 1. Anonymous? Import elements as constants of the underlying type, *except* that Int is used for an inferred underlying type if all the cases fit in an Int32, since integer conversions are explicit in Swift.
@@ -114,15 +127,7 @@ In C, enumerators (enum cases) aren't namespaced under their enum type, so their
 
 1. Collect all *available, non-deprecated* enum cases *without custom names.* If there are no such cases, collect all cases without custom names, whether available or not.
 
-2. Find the common word-boundary prefix __CP__ of these cases. There is a word boundary after
-
-    1. An underscore ("\_").
-    2. A series of two or more uppercase ASCII characters and the suffix "s", "es", or "ies" (e.g. "URLs", "VAXes")...unless the last uppercase letter is "I" and the suffix is "s", in which case it's just as likely to be an acronym followed by "Is" (i.e. "URLIs" is treated as "URL Is").
-    2. A series of two or more uppercase ASCII characters followed by an uppercase ASCII character and then a lowercase ASCII character ("XMLReader" becomes "XML Reader").
-    3. A series of two or more uppercase ASCII characters followed by a non-ASCII-alphabetic character. ("UTF8" becomes "UTF 8")
-    4. A series of two or more uppercase ASCII characters at the end of the string.
-    5. An uppercase ASCII character and any number of non-ASCII-uppercase, non-underscore characters ("ContrivedExample" becomes "Contrived Example").
-    6. Any number of non-ASCII-uppercase, non-underscore characters ("lowercase\_example" becomes "lowercase \_ example").
+2. Find the common word-boundary prefix __CP__ of these cases.
 
 3. If __CP__ starts with "k" followed by an uppercase letter, or if it's *just* "k" and none of the cases have a non-identifier-start character immediately after the 'k', treat that as meaning "constant" and ignore it for the next step.
 
@@ -144,7 +149,7 @@ In C, enumerators (enum cases) aren't namespaced under their enum type, so their
 
 9. ASCII-lowercase the first word of the remaining name if it starts with an uppercase ASCII character.
 
-    _There's a bug here where the special case for "Is" is missing, so "URLIs" will be lowercased to "urlis"._
+    _There's a bug in this step where the special case for "Is" is missing, so "URLIs" will be lowercased to "urlis"._
 
 ## `swift_wrapper` typedefs
 
@@ -190,4 +195,48 @@ extension SecretResourceID {
 
 On Apple platforms, whenever Foundation is imported, constants with the type "NSNotificationName" additionally have the suffix "Notification" stripped before performing the above rules unless they have a custom name. Global NSString constants whose name ends in "Notification" will also automatically be treated as if they were declared with the type NSNotificationName unless they have a custom name.
 
+
+## Objective-C Protocols
+
+Protocols in Objective-C are normally in a separate namespace from the "ordinary" identifier namespace used by typedefs and classes. Swift does not have separate namespaces, so if the protocol has the same name as another declaration in the same module, the suffix "Protocol" is appended. (Example: NSObjectProtocol in the ObjectiveC module.)
+
+
+## CF Types
+
+"Core Foundation" is a C-based object-oriented system with strong conventions built around pointers to opaque structs. Creating new Core Foundation types is not generally supported, but Swift will recognize those in Apple's SDKs. If a struct has the `objc_bridge`, `objc_mutable_bridge`, or `objc_bridge_related` Clang attributes, it will be treated as a CF type and a typedef of a pointer to that struct will be imported as a class in Swift. The suffix "Ref" will be dropped from the class's name if present unless doing so would conflict with another declaration in the same module as the typedef.
+
+If the class name contains the word "Mutable" exactly once per the usual word-boundary rules, a corresponding class name without the word "Mutable" will be used as the superclass if present. Otherwise, the CF type is taken to be a root object.
+
+Additionally, typedefs for `void *` or `const void *` that are themselves annotated with `objc_bridge` will be treated as CFTypeRef-like and imported as `Any` rather than `Unsafe[Mutable]RawPointer`.
+
+If a typedef's underlying type is itself a "CF pointer" typedef, the "alias" typedef will be imported as a regular typealias, with the suffix "Ref" still dropped from its name (if present) unless doing so would conflict with another declaration in the same module as the typedef.
+
+
+## `swift_private`
+
+The `swift_private` Clang attribute prepends `__` onto the base name of any declaration being imported except initializers. For initializers with no arguments, a dummy `Void` argument with the name `__` is inserted; otherwise, the label for the first argument has `__` prepended. This transformation takes place after any other name manipulation, unless the declaration has a custom name. It will not occur if the declaration is an override; in that case the name needs to match the overridden declaration.
+
+```objc
+@interface Example : NSObject
+- (instancetype)initWithValue:(int)value __attribute__((swift_private));
+@property(readonly) int value __attribute__((swift_private));
+@end
+
+// Usually seen as NS_REFINED_FOR_SWIFT
+```
+
+```swift
+class Example: NSObject {
+  init(__value: Int32)
+  var __value: Int32 { get }
+}
+```
+
+The purpose of this annotation is to allow a more idiomatic implementation to be provided in Swift. The effect of `swift_private` is inherited from an enum onto its elements if the enum is not imported as an error code enum, an `@objc` enum, or an option set.
+
+_The original intent of the `swift_private` attribute was additionally to limit access to a Swift module with the same name as the owning Clang module, e.g. the Swift half of a mixed-source framework. However, this restriction has not been implemented as of Swift 5.1._
+
+_For "historical reasons", the `swift_private` attribute is ignored on factory methods with no arguments imported as initializers. This is essentially matching the behavior of older Swift compilers for source compatibility in case someone has marked such a factory method as `swift_private`._
+
+
 ## More to come...

branches/master-rebranch/include/swift/AST/Attr.def

@@ -121,11 +121,12 @@ DECL_ATTR(available, Available,
   1)
 CONTEXTUAL_SIMPLE_DECL_ATTR(final, Final,
   OnClass | OnFunc | OnAccessor | OnVar | OnSubscript |
-  DeclModifier,
+  DeclModifier | ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd,
   2)
 DECL_ATTR(objc, ObjC,
   OnAbstractFunction | OnClass | OnProtocol | OnExtension | OnVar |
-  OnSubscript | OnEnum | OnEnumElement,
+  OnSubscript | OnEnum | OnEnumElement | ABIBreakingToAdd | ABIBreakingToRemove,
   3)
 CONTEXTUAL_SIMPLE_DECL_ATTR(required, Required,
   OnConstructor |
@@ -187,7 +188,7 @@ DECL_ATTR(_semantics, Semantics,
   21)
 CONTEXTUAL_SIMPLE_DECL_ATTR(dynamic, Dynamic,
   OnFunc | OnAccessor | OnVar | OnSubscript | OnConstructor |
-  DeclModifier,
+  DeclModifier | ABIBreakingToAdd | ABIBreakingToRemove,
   22)
 CONTEXTUAL_SIMPLE_DECL_ATTR(infix, Infix,
   OnFunc | OnOperator |
@@ -212,7 +213,7 @@ SIMPLE_DECL_ATTR(nonobjc, NonObjC,
   30)
 SIMPLE_DECL_ATTR(_fixed_layout, FixedLayout,
   OnVar | OnClass | OnStruct |
-  UserInaccessible,
+  UserInaccessible | ABIBreakingToAdd | ABIBreakingToRemove,
   31)
 SIMPLE_DECL_ATTR(inlinable, Inlinable,
   OnVar | OnSubscript | OnAbstractFunction,
@@ -362,7 +363,7 @@ SIMPLE_DECL_ATTR(_weakLinked, WeakLinked,
   OnSubscript | OnConstructor | OnEnumElement | OnExtension | UserInaccessible,
   75)
 SIMPLE_DECL_ATTR(frozen, Frozen,
-  OnEnum | OnStruct,
+  OnEnum | OnStruct | ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToRemove,
   76)
 DECL_ATTR_ALIAS(_frozen, Frozen)
 SIMPLE_DECL_ATTR(_forbidSerializingReference, ForbidSerializingReference,

branches/master-rebranch/include/swift/AST/Attr.h

@@ -353,6 +353,18 @@ class DeclAttribute : public AttributeBase {
 
     /// Whether client code cannot use the attribute.
     UserInaccessible = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 7),
+
+    /// Whether adding this attribute can break API
+    APIBreakingToAdd = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 8),
+
+    /// Whether removing this attribute can break API
+    APIBreakingToRemove = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 9),
+
+    /// Whether adding this attribute can break ABI
+    ABIBreakingToAdd = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 10),
+
+    /// Whether removing this attribute can break ABI
+    ABIBreakingToRemove = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 11),
   };
 
   LLVM_READNONE
@@ -435,6 +447,21 @@ class DeclAttribute : public AttributeBase {
     return getOptions(DK) & UserInaccessible;
   }
 
+  static bool isAddingBreakingABI(DeclAttrKind DK) {
+    return getOptions(DK) & ABIBreakingToAdd;
+  }
+
+  static bool isAddingBreakingAPI(DeclAttrKind DK) {
+    return getOptions(DK) & APIBreakingToAdd;
+  }
+
+  static bool isRemovingBreakingABI(DeclAttrKind DK) {
+    return getOptions(DK) & ABIBreakingToRemove;
+  }
+  static bool isRemovingBreakingAPI(DeclAttrKind DK) {
+    return getOptions(DK) & APIBreakingToRemove;
+  }
+
   bool isDeclModifier() const {
     return isDeclModifier(getKind());
   }

branches/master-rebranch/include/swift/SILOptimizer/Utils/StackNesting.h

@@ -155,10 +155,13 @@ class StackNesting {
     return bitNumberForAlloc(AllocInst);
   }
 
+  /// Insert deallocations at block boundaries.
+  Changes insertDeallocsAtBlockBoundaries();
+
   /// Modifies the SIL to end up with a correct stack nesting.
   ///
   /// Returns the status of what changes were made.
-  Changes adaptDeallocs();
+  bool adaptDeallocs();
 };
 
 } // end namespace swift

branches/master-rebranch/lib/SILOptimizer/Utils/StackNesting.cpp

@@ -24,6 +24,7 @@ void StackNesting::setup(SILFunction *F) {
 
   // We use pointers to BlockInfo structs. Therefore it's important that the
   // BlockInfos vector is never re-allocated.
+  BlockInfos.clear();
   BlockInfos.reserve(F->size());
 
   // Start with the function entry block and add blocks while walking down along
@@ -231,36 +232,26 @@ bool StackNesting::insertDeallocs(const BitVector &AliveBefore,
   return changesMade;
 }
 
-StackNesting::Changes StackNesting::adaptDeallocs() {
-
-  bool InstChanged = false;
-  bool CFGChanged = false;
-  BitVector Bits(StackLocs.size());
-
-  // Visit all blocks. Actually the order doesn't matter, but let's to it in
-  // the same order as in solve().
+// Insert deallocations at block boundaries.
+// This can be necessary for unreachable blocks. Example:
+//
+//   %1 = alloc_stack
+//   %2 = alloc_stack
+//   cond_br %c, bb2, bb3
+// bb2: <--- need to insert a dealloc_stack %2 at the begin of bb2
+//   dealloc_stack %1
+//   unreachable
+// bb3:
+//   dealloc_stack %2
+//   dealloc_stack %1
+StackNesting::Changes StackNesting::insertDeallocsAtBlockBoundaries() {
+  Changes changes = Changes::None;
   for (const BlockInfo &BI : reversed(BlockInfos)) {
-    // Collect the alive-bits (at the block exit) from the successor blocks.
-    Bits = BI.AliveStackLocsAtExit;
-
-    // Insert deallocations at block boundaries.
-    // This can be necessary for unreachable blocks. Example:
-    //
-    //   %1 = alloc_stack
-    //   %2 = alloc_stack
-    //   cond_br %c, bb2, bb3
-    // bb2:   <--- need to insert a dealloc_stack %2 at the begin of bb2
-    //   dealloc_stack %1
-    //   unreachable
-    // bb3:
-    //   dealloc_stack %2
-    //   dealloc_stack %1
-    //
     for (unsigned SuccIdx = 0, NumSuccs = BI.Successors.size();
-         SuccIdx < NumSuccs; ++ SuccIdx) {
-      BlockInfo *SuccBI = BI.Successors[SuccIdx];
+         SuccIdx < NumSuccs; ++SuccIdx) {
 
-      if (SuccBI->AliveStackLocsAtEntry == Bits)
+      BlockInfo *SuccBI = BI.Successors[SuccIdx];
+      if (SuccBI->AliveStackLocsAtEntry == BI.AliveStackLocsAtExit)
         continue;
 
       // Insert deallocations for all locations which are alive at the end of
@@ -271,11 +262,26 @@ StackNesting::Changes StackNesting::adaptDeallocs() {
         // block, we have to insert a new block where we can add the
         // deallocations.
         InsertionBlock = splitEdge(BI.Block->getTerminator(), SuccIdx);
-        CFGChanged = true;
+        changes = Changes::CFG;
+      }
+      if (insertDeallocs(BI.AliveStackLocsAtExit, SuccBI->AliveStackLocsAtEntry,
+                         &InsertionBlock->front(), None)) {
+        if (changes == Changes::None)
+          changes = Changes::Instructions;
       }
-      InstChanged |= insertDeallocs(Bits, SuccBI->AliveStackLocsAtEntry,
-                                    &InsertionBlock->front(), None);
     }
+  }
+  return changes;
+}
+
+bool StackNesting::adaptDeallocs() {
+  bool InstChanged = false;
+  BitVector Bits(StackLocs.size());
+
+  // Visit all blocks. Actually the order doesn't matter, but let's to it in
+  // the same order as in solve().
+  for (const BlockInfo &BI : reversed(BlockInfos)) {
+    Bits = BI.AliveStackLocsAtExit;
 
     // Insert/remove deallocations inside blocks.
     for (SILInstruction *StackInst : reversed(BI.StackInsts)) {
@@ -310,19 +316,29 @@ StackNesting::Changes StackNesting::adaptDeallocs() {
     }
     assert(Bits == BI.AliveStackLocsAtEntry && "dataflow didn't converge");
   }
-  if (CFGChanged)
-    return Changes::CFG;
-  if (InstChanged)
-    return Changes::Instructions;
-  return Changes::None;
+  return InstChanged;
 }
 
 StackNesting::Changes StackNesting::correctStackNesting(SILFunction *F) {
   setup(F);
-  if (solve()) {
-    return adaptDeallocs();
+  if (!solve())
+    return Changes::None;
+
+  // Insert deallocs at block boundaries. This might be necessary in CFG sub
+  // graphs which don't  reach a function exit, but only an unreachable.
+  Changes changes = insertDeallocsAtBlockBoundaries();
+  if (changes != Changes::None) {
+    // Those inserted deallocs make it necessary to re-compute the analysis.
+    setup(F);
+    solve();
+  }
+  // Do the real work: extend lifetimes by moving deallocs.
+  if (adaptDeallocs()) {
+    if (changes == Changes::None)
+      changes = Changes::Instructions;
   }
-  return Changes::None;
+
+  return changes;
 }
 
 void StackNesting::dump() const {

branches/master-rebranch/lib/Sema/CSGen.cpp

@@ -2478,11 +2478,11 @@ namespace {
     }
 
     Type visitDefaultArgumentExpr(DefaultArgumentExpr *expr) {
-      llvm_unreachable("Already type checked");
+      return expr->getType();
     }
 
     Type visitCallerDefaultArgumentExpr(CallerDefaultArgumentExpr *expr) {
-      llvm_unreachable("Already type checked");
+      return expr->getType();
     }
 
     Type visitApplyExpr(ApplyExpr *expr) {

branches/master-rebranch/lib/Sema/CSSimplify.cpp

@@ -4713,7 +4713,8 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
     // as representing "dynamic lookup" unless it's a direct call
     // to such subscript (in that case label is expected to match).
     if (auto *subscript = dyn_cast<SubscriptDecl>(cand)) {
-      if (::hasDynamicMemberLookupAttribute(instanceTy,
+      if (memberLocator &&
+          ::hasDynamicMemberLookupAttribute(instanceTy,
                                             DynamicMemberLookupCache) &&
           isValidKeyPathDynamicMemberLookup(subscript, TC)) {
         auto info = getArgumentInfo(memberLocator);

branches/master-rebranch/lib/Sema/ConstraintSystem.cpp

@@ -2880,6 +2880,9 @@ ConstraintSystem::getArgumentInfoLocator(ConstraintLocator *locator) {
 
 Optional<ConstraintSystem::ArgumentInfo>
 ConstraintSystem::getArgumentInfo(ConstraintLocator *locator) {
+  if (!locator)
+    return None;
+
   if (auto *infoLocator = getArgumentInfoLocator(locator)) {
     auto known = ArgumentInfos.find(infoLocator);
     if (known != ArgumentInfos.end())

branches/master-rebranch/lib/Sema/TypeCheckCaptures.cpp

@@ -645,6 +645,12 @@ void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
   }
 }
 
+static bool isLazy(PatternBindingDecl *PBD) {
+  if (auto var = PBD->getSingleVar())
+    return var->getAttrs().hasAttribute<LazyAttr>();
+  return false;
+}
+
 void TypeChecker::checkPatternBindingCaptures(NominalTypeDecl *typeDecl) {
   auto &ctx = typeDecl->getASTContext();
 
@@ -669,7 +675,7 @@ void TypeChecker::checkPatternBindingCaptures(NominalTypeDecl *typeDecl) {
                               /*ObjC=*/false);
       init->walk(finder);
 
-      if (finder.getDynamicSelfCaptureLoc().isValid()) {
+      if (finder.getDynamicSelfCaptureLoc().isValid() && !isLazy(PBD)) {
         ctx.Diags.diagnose(finder.getDynamicSelfCaptureLoc(),
                            diag::dynamic_self_stored_property_init);
       }