---

yaml
---
r: 343995
b: refs/heads/master-rebranch
c: 5c01a11
h: refs/heads/master
i:
  343993: a4b4177
  343991: e45ea99

Author: xedin

[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: 0aeaf7f15e7b18c346d026fa7535c5134b768d4c
+refs/heads/master-rebranch: 5c01a1185d5c700347f0185ead5f24112bbb8139
 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/Decl.h

@@ -1505,12 +1505,13 @@ class alignas(8) _GenericContext {
   TrailingWhereClause *TrailingWhere = nullptr;
 
   /// The generic signature of this declaration.
-  GenericSignature *GenericSig = nullptr;
+  llvm::PointerIntPair<GenericSignature *, 1, bool> GenericSigAndBit;
 };
 
 class GenericContext : private _GenericContext, public DeclContext {
   friend class GenericParamListRequest;
-
+  friend class GenericSignatureRequest;
+  
 protected:
   GenericContext(DeclContextKind Kind, DeclContext *Parent,
                  GenericParamList *Params);
@@ -1534,7 +1535,8 @@ class GenericContext : private _GenericContext, public DeclContext {
   /// }
   /// \endcode
   bool isGeneric() const { return getGenericParams() != nullptr; }
-
+  bool hasComputedGenericSignature() const;
+  
   /// Retrieve the trailing where clause for this extension, if any.
   TrailingWhereClause *getTrailingWhereClause() const {
     return TrailingWhere;

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

@@ -1160,6 +1160,27 @@ class FunctionOperatorRequest :
   bool isCached() const { return true; }
 };
 
+class GenericSignatureRequest :
+    public SimpleRequest<GenericSignatureRequest,
+                         GenericSignature *(GenericContext *),
+                         CacheKind::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+  
+private:
+  friend SimpleRequest;
+  
+  // Evaluation.
+  llvm::Expected<GenericSignature *>
+  evaluate(Evaluator &evaluator, GenericContext *value) const;
+  
+public:              
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<GenericSignature *> getCachedResult() const;
+  void cacheResult(GenericSignature *value) const;
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

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

@@ -49,6 +49,9 @@ SWIFT_REQUEST(TypeChecker, FunctionBuilderTypeRequest, Type(ValueDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, FunctionOperatorRequest, OperatorDecl *(FuncDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(NameLookup, GenericSignatureRequest,
+              GenericSignature *(GenericContext *),
+              SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
               GenericSignature *(ModuleDecl *, GenericSignature *,
                                  SmallVector<GenericParamList *, 2>,

branches/master-rebranch/include/swift/SIL/BranchPropagatedUser.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_SIL_BRANCHPROPAGATEDUSER_H
 #define SWIFT_SIL_BRANCHPROPAGATEDUSER_H
 
+#include "swift/Basic/LLVM.h"
 #include "swift/SIL/SILBasicBlock.h"
 #include "swift/SIL/SILInstruction.h"
 #include "llvm/ADT/DenseMap.h"
@@ -27,68 +28,68 @@ namespace swift {
 /// BranchPropagatedUser and friends break all such critical edges.
 class BranchPropagatedUser {
   using InnerTy = llvm::PointerIntPair<SILInstruction *, 1>;
-  InnerTy User;
+  InnerTy user;
 
 public:
-  BranchPropagatedUser(SILInstruction *I) : User(I) {
-    assert(!isa<CondBranchInst>(I));
+  BranchPropagatedUser(SILInstruction *inst) : user(inst) {
+    assert(!isa<CondBranchInst>(inst));
   }
 
-  BranchPropagatedUser(CondBranchInst *I) : User(I) {}
+  BranchPropagatedUser(CondBranchInst *cbi) : user(cbi) {}
 
-  BranchPropagatedUser(CondBranchInst *I, unsigned SuccessorIndex)
-      : User(I, SuccessorIndex) {
-    assert(SuccessorIndex == CondBranchInst::TrueIdx ||
-           SuccessorIndex == CondBranchInst::FalseIdx);
+  BranchPropagatedUser(CondBranchInst *cbi, unsigned successorIndex)
+      : user(cbi, successorIndex) {
+    assert(successorIndex == CondBranchInst::TrueIdx ||
+           successorIndex == CondBranchInst::FalseIdx);
   }
 
-  BranchPropagatedUser(const BranchPropagatedUser &Other) : User(Other.User) {}
-  BranchPropagatedUser &operator=(const BranchPropagatedUser &Other) {
-    User = Other.User;
+  BranchPropagatedUser(const BranchPropagatedUser &other) : user(other.user) {}
+  BranchPropagatedUser &operator=(const BranchPropagatedUser &other) {
+    user = other.user;
     return *this;
   }
 
-  operator SILInstruction *() { return User.getPointer(); }
-  operator const SILInstruction *() const { return User.getPointer(); }
+  operator SILInstruction *() { return user.getPointer(); }
+  operator const SILInstruction *() const { return user.getPointer(); }
 
-  SILInstruction *getInst() const { return User.getPointer(); }
+  SILInstruction *getInst() const { return user.getPointer(); }
 
   SILBasicBlock *getParent() const {
     if (!isCondBranchUser()) {
       return getInst()->getParent();
     }
 
-    auto *CBI = cast<CondBranchInst>(getInst());
-    unsigned Number = getCondBranchSuccessorID();
-    if (Number == CondBranchInst::TrueIdx)
-      return CBI->getTrueBB();
-    return CBI->getFalseBB();
+    auto *cbi = cast<CondBranchInst>(getInst());
+    unsigned number = getCondBranchSuccessorID();
+    if (number == CondBranchInst::TrueIdx)
+      return cbi->getTrueBB();
+    return cbi->getFalseBB();
   }
 
   bool isCondBranchUser() const {
-    return isa<CondBranchInst>(User.getPointer());
+    return isa<CondBranchInst>(user.getPointer());
   }
 
   unsigned getCondBranchSuccessorID() const {
     assert(isCondBranchUser());
-    return User.getInt();
+    return user.getInt();
   }
 
   SILBasicBlock::iterator getIterator() const {
-    return User.getPointer()->getIterator();
+    return user.getPointer()->getIterator();
   }
 
   void *getAsOpaqueValue() const {
-    return llvm::PointerLikeTypeTraits<InnerTy>::getAsVoidPointer(User);
+    return llvm::PointerLikeTypeTraits<InnerTy>::getAsVoidPointer(user);
   }
 
   static BranchPropagatedUser getFromOpaqueValue(void *p) {
-    InnerTy TmpUser =
+    InnerTy tmpUser =
         llvm::PointerLikeTypeTraits<InnerTy>::getFromVoidPointer(p);
-    if (auto *CBI = dyn_cast<CondBranchInst>(TmpUser.getPointer())) {
-      return BranchPropagatedUser(CBI, TmpUser.getInt());
+    if (auto *cbi = dyn_cast<CondBranchInst>(tmpUser.getPointer())) {
+      return BranchPropagatedUser(cbi, tmpUser.getInt());
     }
-    return BranchPropagatedUser(TmpUser.getPointer());
+    return BranchPropagatedUser(tmpUser.getPointer());
   }
 
   enum {

branches/master-rebranch/include/swift/SIL/OwnershipUtils.h

@@ -127,27 +127,50 @@ class LinearLifetimeError {
   }
 };
 
-/// Returns true if:
+/// A class used to validate linear lifetime with respect to an SSA-like
+/// definition.
 ///
-/// 1. No consuming uses are reachable from any other consuming use, from any
-/// non-consuming uses, or from the producer instruction.
-/// 2. The consuming use set jointly post dominates producers and all non
-/// consuming uses.
+/// This class is able to both validate that a linear lifetime has been properly
+/// constructed (for verification and safety purposes) as well as return to the
+/// caller upon failure, what the failure was. In certain cases (for instance if
+/// there exists a path without a non-consuming use), the class will report back
+/// the specific insertion points needed to insert these compensating releases.
 ///
-/// \p value The value whose lifetime we are checking.
-/// \p consumingUses the array of users that destroy or consume a value.
-/// \p nonConsumingUses regular uses
-/// \p deadEndBlocks a cache for the dead end block computation
-/// \p errorBehavior If we detect an error, should we return false or hard
-/// error.
-/// \p leakingBlocks If non-null a list of blocks where the value was detected
-/// to leak. Can be used to insert missing destroys.
-LinearLifetimeError valueHasLinearLifetime(
-    SILValue value, ArrayRef<BranchPropagatedUser> consumingUses,
-    ArrayRef<BranchPropagatedUser> nonConsumingUses,
-    SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
-    DeadEndBlocks &deadEndBlocks, ownership::ErrorBehaviorKind errorBehavior,
-    SmallVectorImpl<SILBasicBlock *> *leakingBlocks = nullptr);
+/// DISCUSSION: A linear lifetime consists of a starting block or instruction
+/// and a list of non-consuming uses and a set of consuming uses. The consuming
+/// uses must not be reachable from each other and jointly post-dominate all
+/// consuming uses as well as the defining block/instruction.
+class LinearLifetimeChecker {
+  SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks;
+  DeadEndBlocks &deadEndBlocks;
+
+public:
+  LinearLifetimeChecker(SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
+                        DeadEndBlocks &deadEndBlocks)
+      : visitedBlocks(visitedBlocks), deadEndBlocks(deadEndBlocks) {}
+
+  /// Returns true if:
+  ///
+  /// 1. No consuming uses are reachable from any other consuming use, from any
+  /// non-consuming uses, or from the producer instruction.
+  /// 2. The consuming use set jointly post dominates producers and all non
+  /// consuming uses.
+  ///
+  /// Returns false otherwise.
+  ///
+  /// \p value The value whose lifetime we are checking.
+  /// \p consumingUses the array of users that destroy or consume a value.
+  /// \p nonConsumingUses regular uses
+  /// \p errorBehavior If we detect an error, should we return false or hard
+  /// error.
+  /// \p leakingBlocks If non-null a list of blocks where the value was detected
+  /// to leak. Can be used to insert missing destroys.
+  LinearLifetimeError
+  checkValue(SILValue value, ArrayRef<BranchPropagatedUser> consumingUses,
+             ArrayRef<BranchPropagatedUser> nonConsumingUses,
+             ownership::ErrorBehaviorKind errorBehavior,
+             SmallVectorImpl<SILBasicBlock *> *leakingBlocks = nullptr);
+};
 
 /// Returns true if v is an address or trivial.
 bool isValueAddressOrTrivial(SILValue v);

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

@@ -167,15 +167,32 @@ std::pair<bool, Expr *> dispatchVisitPreExprHelper(
 }
 
 namespace {
-  /// Retrieve the "overridden" declaration of this declaration, but only if
-  // it's already been computed.
-  template<typename T>
-  T *getOverriddenDeclIfAvailable(T *decl) {
-    if (!decl->overriddenDeclsComputed()) return nullptr;
+// Retrieve the "overridden" declaration of this declaration, but only if
+// it's already been computed.
+template <typename T> T *getOverriddenDeclIfAvailable(T *decl) {
+  if (!decl->overriddenDeclsComputed())
+    return nullptr;
 
-    return cast_or_null<T>(decl->getOverriddenDecl());
-  }
+  return cast_or_null<T>(decl->getOverriddenDecl());
 }
+
+// Retrieve the generic signature of the innermost context that has been forced
+// so far.
+//
+// This avoids kicking off the request for a generic signature in the verifier.
+static GenericSignature *
+getNearestForcedGenericSignatureOfContext(DeclContext *dc) {
+  do {
+    if (auto decl = dc->getAsDecl())
+      if (auto GC = decl->getAsGenericContext())
+        if (GC->hasComputedGenericSignature())
+          return GC->getGenericSignature();
+  } while ((dc = dc->getParent()));
+
+  return nullptr;
+}
+} // namespace
+
 class Verifier : public ASTWalker {
   PointerUnion<ModuleDecl *, SourceFile *> M;
   ASTContext &Ctx;
@@ -686,14 +703,14 @@ class Verifier : public ASTWalker {
 
     void pushScope(DeclContext *scope) {
       Scopes.push_back(scope);
-      GenericSig.push_back(scope->getGenericSignatureOfContext());
+      GenericSig.push_back(::getNearestForcedGenericSignatureOfContext(scope));
     }
     void pushScope(BraceStmt *scope) {
       Scopes.push_back(scope);
     }
     void popScope(DeclContext *scope) {
       assert(Scopes.back().get<DeclContext*>() == scope);
-      assert(GenericSig.back() == scope->getGenericSignatureOfContext());
+      assert(GenericSig.back() == ::getNearestForcedGenericSignatureOfContext(scope));
       Scopes.pop_back();
       GenericSig.pop_back();
     }

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

@@ -855,22 +855,14 @@ GenericParamList *GenericContext::getGenericParams() const {
                                const_cast<GenericContext *>(this)}, nullptr);
 }
 
-GenericSignature *GenericContext::getGenericSignature() const {
-  if (GenericSig)
-    return GenericSig;
-
-  // The signature of a Protocol is trivial (Self: TheProtocol) so let's compute
-  // it.
-  if (auto PD = dyn_cast<ProtocolDecl>(this)) {
-    auto self = PD->getSelfInterfaceType()->castTo<GenericTypeParamType>();
-    auto req =
-        Requirement(RequirementKind::Conformance, self, PD->getDeclaredType());
-    const_cast<GenericContext *>(this)->GenericSig
-      = GenericSignature::get({self}, {req});
-    return GenericSig;
-  }
+bool GenericContext::hasComputedGenericSignature() const {
+  return GenericSigAndBit.getInt();
+}
 
-  return nullptr;
+GenericSignature *GenericContext::getGenericSignature() const {
+  return evaluateOrDefault(
+      getASTContext().evaluator,
+      GenericSignatureRequest{const_cast<GenericContext *>(this)}, nullptr);
 }
 
 GenericEnvironment *GenericContext::getGenericEnvironment() const {
@@ -881,8 +873,9 @@ GenericEnvironment *GenericContext::getGenericEnvironment() const {
 }
 
 void GenericContext::setGenericSignature(GenericSignature *genericSig) {
-  assert(GenericSig == nullptr && "Generic signature cannot be changed");
-  this->GenericSig = genericSig;
+  assert(!GenericSigAndBit.getPointer() && "Generic signature cannot be changed");
+  getASTContext().evaluator.cacheOutput(GenericSignatureRequest{this},
+                                        std::move(genericSig));
 }
 
 SourceRange GenericContext::getGenericTrailingWhereClauseSourceRange() const {
@@ -6159,6 +6152,10 @@ void SubscriptDecl::computeType() {
 
   // Record the interface type.
   setInterfaceType(funcTy);
+      
+  // Make sure that there are no unresolved dependent types in the
+  // generic signature.
+  assert(!funcTy->findUnresolvedDependentMemberType());
 }
 
 ObjCSubscriptKind SubscriptDecl::getObjCSubscriptKind() const {
@@ -6753,6 +6750,10 @@ void AbstractFunctionDecl::computeType(AnyFunctionType::ExtInfo info) {
   // Compute the type of the 'self' parameter if we're created one already.
   if (hasSelf)
     computeSelfDeclType();
+      
+  // Make sure that there are no unresolved dependent types in the
+  // generic signature.
+  assert(!funcTy->findUnresolvedDependentMemberType());
 }
 
 bool AbstractFunctionDecl::hasInlinableBodyText() const {

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

@@ -5296,6 +5296,12 @@ class GenericSignatureBuilder::InferRequirementsWalker : public TypeWalker {
     auto decl = ty->getAnyNominal();
     if (!decl) return Action::Continue;
 
+    // FIXME: The GSB and the request evaluator both detect a cycle here if we
+    // force a recursive generic signature.  We should look into moving cycle
+    // detection into the generic signature request(s) - see rdar://55263708
+    if (!decl->hasComputedGenericSignature())
+      return Action::Continue;
+    
     auto genericSig = decl->getGenericSignature();
     if (!genericSig)
       return Action::Continue;