---

yaml
---
r: 344159
b: refs/heads/master-rebranch
c: b11e8ac
h: refs/heads/master
i:
  344157: c517728
  344155: 631ce30
  344151: 838adbe
  344143: 048b73f
  344127: cc97011

Author: slavapestov

[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: 8f346a0ca8b714de8103b9b05d6020e4645cc0bf
+refs/heads/master-rebranch: b11e8ac95eb50831aafbf3ce4f1ada8370dc1c26
 refs/heads/rdar-53901732: 9bd06af3284e18a109cdbf9aa59d833b24eeca7b
 refs/heads/revert-26776-subst-always-returns-a-type: 1b8e18fdd391903a348970a4c848995d4cdd789c
 refs/heads/tensorflow-merge: 8b854f62f80d4476cb383d43c4aac2001dde3cec

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

@@ -460,6 +460,8 @@ class ASTContext final {
   /// Retrieve the declaration of ObjectiveC.ObjCBool.
   StructDecl *getObjCBoolDecl() const;
 
+  /// Retrieve the declaration of Foundation.NSCopying.
+  ProtocolDecl *getNSCopyingDecl() const;
   /// Retrieve the declaration of Foundation.NSError.
   ClassDecl *getNSErrorDecl() const;
   /// Retrieve the declaration of Foundation.NSNumber.

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

@@ -14,11 +14,13 @@
 #define SWIFT_AST_CAPTURE_INFO_H
 
 #include "swift/Basic/LLVM.h"
+#include "swift/Basic/OptionSet.h"
 #include "swift/Basic/SourceLoc.h"
 #include "swift/AST/TypeAlignments.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/Support/TrailingObjects.h"
 #include <vector>
 
 namespace swift {
@@ -114,31 +116,63 @@ class DynamicSelfType;
 
 /// Stores information about captured variables.
 class CaptureInfo {
-  const CapturedValue *Captures;
-  DynamicSelfType *DynamicSelf;
-  OpaqueValueExpr *OpaqueValue;
-  unsigned Count = 0;
-  bool GenericParamCaptures : 1;
-  bool Computed : 1;
+  class CaptureInfoStorage final
+      : public llvm::TrailingObjects<CaptureInfoStorage, CapturedValue> {
+
+    DynamicSelfType *DynamicSelf;
+    OpaqueValueExpr *OpaqueValue;
+    unsigned Count;
+  public:
+    explicit CaptureInfoStorage(unsigned count, DynamicSelfType *dynamicSelf,
+                                OpaqueValueExpr *opaqueValue)
+      : DynamicSelf(dynamicSelf), OpaqueValue(opaqueValue), Count(count) { }
+
+    ArrayRef<CapturedValue> getCaptures() const {
+      return llvm::makeArrayRef(this->getTrailingObjects<CapturedValue>(),
+                                Count);
+    }
+
+    DynamicSelfType *getDynamicSelfType() const {
+      return DynamicSelf;
+    }
+
+    OpaqueValueExpr *getOpaqueValue() const {
+      return OpaqueValue;
+    }
+  };
+
+  enum class Flags : unsigned {
+    HasGenericParamCaptures = 1 << 0
+  };
+
+  llvm::PointerIntPair<const CaptureInfoStorage *, 2, OptionSet<Flags>>
+      StorageAndFlags;
 
 public:
-  CaptureInfo()
-    : Captures(nullptr), DynamicSelf(nullptr), OpaqueValue(nullptr), Count(0),
-      GenericParamCaptures(0), Computed(0) { }
+  /// The default-constructed CaptureInfo is "not yet computed".
+  CaptureInfo() = default;
+  CaptureInfo(ASTContext &ctx, ArrayRef<CapturedValue> captures,
+              DynamicSelfType *dynamicSelf, OpaqueValueExpr *opaqueValue,
+              bool genericParamCaptures);
 
-  bool hasBeenComputed() const { return Computed; }
+  /// A CaptureInfo representing no captures at all.
+  static CaptureInfo empty();
+
+  bool hasBeenComputed() const {
+    return StorageAndFlags.getPointer();
+  }
 
   bool isTrivial() const {
-    return Count == 0 && !GenericParamCaptures && !DynamicSelf && !OpaqueValue;
+    return getCaptures().empty() && !hasGenericParamCaptures() &&
+           !hasDynamicSelfCapture() && !hasOpaqueValueCapture();
   }
 
   ArrayRef<CapturedValue> getCaptures() const {
-    return llvm::makeArrayRef(Captures, Count);
-  }
-  void setCaptures(ArrayRef<CapturedValue> C) {
-    Captures = C.data();
-    Computed = true;
-    Count = C.size();
+    // FIXME: Ideally, everywhere that synthesizes a function should include
+    // its capture info.
+    if (!hasBeenComputed())
+      return None;
+    return StorageAndFlags.getPointer()->getCaptures();
   }
 
   /// Return a filtered list of the captures for this function,
@@ -152,37 +186,37 @@ class CaptureInfo {
 
   /// \returns true if the function captures any generic type parameters.
   bool hasGenericParamCaptures() const {
-    return GenericParamCaptures;
-  }
-
-  void setGenericParamCaptures(bool genericParamCaptures) {
-    GenericParamCaptures = genericParamCaptures;
+    // FIXME: Ideally, everywhere that synthesizes a function should include
+    // its capture info.
+    if (!hasBeenComputed())
+      return false;
+    return StorageAndFlags.getInt().contains(Flags::HasGenericParamCaptures);
   }
 
   /// \returns true if the function captures the dynamic Self type.
   bool hasDynamicSelfCapture() const {
-    return DynamicSelf != nullptr;
+    return getDynamicSelfType() != nullptr;
   }
 
   /// \returns the captured dynamic Self type, if any.
   DynamicSelfType *getDynamicSelfType() const {
-    return DynamicSelf;
-  }
-
-  void setDynamicSelfType(DynamicSelfType *dynamicSelf) {
-    DynamicSelf = dynamicSelf;
+    // FIXME: Ideally, everywhere that synthesizes a function should include
+    // its capture info.
+    if (!hasBeenComputed())
+      return nullptr;
+    return StorageAndFlags.getPointer()->getDynamicSelfType();
   }
 
   bool hasOpaqueValueCapture() const {
-    return OpaqueValue != nullptr;
+    return getOpaqueValue() != nullptr;
   }
 
   OpaqueValueExpr *getOpaqueValue() const {
-    return OpaqueValue;
-  }
-
-  void setOpaqueValue(OpaqueValueExpr *OVE) {
-    OpaqueValue = OVE;
+    // FIXME: Ideally, everywhere that synthesizes a function should include
+    // its capture info.
+    if (!hasBeenComputed())
+      return nullptr;
+    return StorageAndFlags.getPointer()->getOpaqueValue();
   }
 
   void dump() const;

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

@@ -396,6 +396,12 @@ ERROR(cannot_convert_partial_argument_value_protocol,none,
 ERROR(cannot_convert_argument_value_nil,none,
       "'nil' is not compatible with expected argument type %0", (Type))
 
+ERROR(cannot_convert_condition_value,none,
+      "cannot convert value of type %0 to expected condition type %1",
+      (Type, Type))
+ERROR(cannot_convert_condition_value_nil,none,
+      "'nil' is not compatible with expected condition type %0", (Type))
+
 ERROR(cannot_yield_rvalue_by_reference_same_type,none,
       "cannot yield immutable value of type %0 as an inout yield", (Type))
 ERROR(cannot_yield_rvalue_by_reference,none,

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

@@ -20,7 +20,6 @@
 #endif
 
 FOUNDATION_ENTITY(NSArray)
-FOUNDATION_ENTITY(NSCopying)
 FOUNDATION_ENTITY(NSDictionary)
 FOUNDATION_ENTITY(NSError)
 FOUNDATION_ENTITY(NSErrorPointer)

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

@@ -11,7 +11,8 @@
 //===----------------------------------------------------------------------===//
 //
 // This file defines macros used for macro-metaprogramming with compiler-known
-// protocols.
+// protocols. Note that this mechanism does not look through an overlay into its
+// underlying module, so it typically cannot find Objective-C protocols.
 //
 //===----------------------------------------------------------------------===//
 

branches/master-rebranch/lib/AST/ASTContext.cpp

@@ -100,9 +100,10 @@ using AssociativityCacheType =
                  Associativity>;
 
 #define FOR_KNOWN_FOUNDATION_TYPES(MACRO) \
-  MACRO(NSError) \
-  MACRO(NSNumber) \
-  MACRO(NSValue)
+  MACRO(NSCopying, ProtocolDecl) \
+  MACRO(NSError, ClassDecl) \
+  MACRO(NSNumber, ClassDecl) \
+  MACRO(NSValue, ClassDecl)
 
 struct OverrideSignatureKey {
   GenericSignature *baseMethodSig;
@@ -219,9 +220,9 @@ struct ASTContext::Implementation {
   /// The declaration of ObjectiveC.ObjCBool.
   StructDecl *ObjCBoolDecl = nullptr;
 
-#define CACHE_FOUNDATION_DECL(NAME) \
+#define CACHE_FOUNDATION_DECL(NAME, DECLTYPE) \
   /** The declaration of Foundation.NAME. */ \
-  ClassDecl *NAME##Decl = nullptr;
+  DECLTYPE *NAME##Decl = nullptr;
 FOR_KNOWN_FOUNDATION_TYPES(CACHE_FOUNDATION_DECL)
 #undef CACHE_FOUNDATION_DECL
 
@@ -850,18 +851,18 @@ StructDecl *ASTContext::getObjCBoolDecl() const {
   return getImpl().ObjCBoolDecl;
 }
 
-#define GET_FOUNDATION_DECL(NAME) \
-ClassDecl *ASTContext::get##NAME##Decl() const { \
+#define GET_FOUNDATION_DECL(NAME, DECLTYPE) \
+DECLTYPE *ASTContext::get##NAME##Decl() const { \
   if (!getImpl().NAME##Decl) { \
     if (ModuleDecl *M = getLoadedModule(Id_Foundation)) { \
       /* Note: lookupQualified() will search both the Foundation module \
        * and the Clang Foundation module it imports. */ \
       SmallVector<ValueDecl *, 1> decls; \
       M->lookupQualified(M, getIdentifier(#NAME), NL_OnlyTypes, decls); \
-      if (decls.size() == 1 && isa<ClassDecl>(decls[0])) { \
-        auto classDecl = cast<ClassDecl>(decls[0]); \
-        if (classDecl->getGenericParams() == nullptr) { \
-          getImpl().NAME##Decl = classDecl; \
+      if (decls.size() == 1 && isa<DECLTYPE>(decls[0])) { \
+        auto decl = cast<DECLTYPE>(decls[0]); \
+        if (isa<ProtocolDecl>(decl) || decl->getGenericParams() == nullptr) { \
+          getImpl().NAME##Decl = decl; \
         } \
       } \
     } \

branches/master-rebranch/lib/AST/CaptureInfo.cpp

@@ -11,11 +11,50 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/CaptureInfo.h"
+#include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
 
+CaptureInfo::CaptureInfo(ASTContext &ctx, ArrayRef<CapturedValue> captures,
+                         DynamicSelfType *dynamicSelf,
+                         OpaqueValueExpr *opaqueValue,
+                         bool genericParamCaptures) {
+  static_assert(IsTriviallyDestructible<CapturedValue>::value,
+                "Capture info is alloc'd on the ASTContext and not destroyed");
+  static_assert(IsTriviallyDestructible<CaptureInfo::CaptureInfoStorage>::value,
+                "Capture info is alloc'd on the ASTContext and not destroyed");
+
+  OptionSet<Flags> flags;
+  if (genericParamCaptures)
+    flags |= Flags::HasGenericParamCaptures;
+
+  if (captures.empty() && !dynamicSelf && !opaqueValue) {
+    *this = CaptureInfo::empty();
+    StorageAndFlags.setInt(flags);
+    return;
+  }
+
+  size_t storageToAlloc =
+      CaptureInfoStorage::totalSizeToAlloc<CapturedValue>(captures.size());
+  void *storageBuf = ctx.Allocate(storageToAlloc, alignof(CaptureInfoStorage));
+  auto *storage = new (storageBuf) CaptureInfoStorage(captures.size(),
+                                                      dynamicSelf,
+                                                      opaqueValue);
+  StorageAndFlags.setPointerAndInt(storage, flags);
+  std::uninitialized_copy(captures.begin(), captures.end(),
+                          storage->getTrailingObjects<CapturedValue>());
+}
+
+CaptureInfo CaptureInfo::empty() {
+  static const CaptureInfoStorage empty{0, /*dynamicSelf*/nullptr,
+                                        /*opaqueValue*/nullptr};
+  CaptureInfo result;
+  result.StorageAndFlags.setPointer(&empty);
+  return result;
+}
+
 bool CaptureInfo::hasLocalCaptures() const {
   for (auto capture : getCaptures())
     if (capture.getDecl()->getDeclContext()->isLocalContext())
@@ -28,7 +67,7 @@ void CaptureInfo::
 getLocalCaptures(SmallVectorImpl<CapturedValue> &Result) const {
   if (!hasLocalCaptures()) return;
 
-  Result.reserve(Count);
+  Result.reserve(getCaptures().size());
 
   // Filter out global variables.
   for (auto capture : getCaptures()) {

branches/master-rebranch/lib/ClangImporter/ImportDecl.cpp

@@ -2634,13 +2634,13 @@ namespace {
             return newtype;
 
       if (!SwiftType) {
-        // Import typedefs of blocks as their fully-bridged equivalent Swift
-        // type. That matches how we want to use them in most cases. All other
-        // types should be imported in a non-bridged way.
+        // Note that the code below checks to see if the typedef allows
+        // bridging, i.e. if the imported typealias should name a bridged type
+        // or the original C type.
         clang::QualType ClangType = Decl->getUnderlyingType();
         SwiftType = Impl.importTypeIgnoreIUO(
             ClangType, ImportTypeKind::Typedef, isInSystemModule(DC),
-            getTypedefBridgeability(Decl, ClangType), OTK_Optional);
+            getTypedefBridgeability(Decl), OTK_Optional);
       }
 
       if (!SwiftType)