Define PatternBindingEntryRequest

Define a request that can be used to grab the fully validated and
type-checked form of a given pattern binding entry.  Using this,
validation of pattern bindings is fully disconnected from validation of
bound variables, and cycles are now picked up by the request evaluator.

Using this, we can go clean up all the callers that are checking a bit
and calling back into typeCheckPatternBinding.  It will also serve as
the basis for a request for the naming pattern for a VarDecl which will
clean that part of validateDecl.

Author: CodaFi

include/swift/AST/ASTTypeIDZone.def

@@ -38,6 +38,7 @@ SWIFT_TYPEID_NAMED(OpaqueTypeDecl *, OpaqueTypeDecl)
 SWIFT_TYPEID_NAMED(OperatorDecl *, OperatorDecl)
 SWIFT_TYPEID_NAMED(Optional<PropertyWrapperMutability>,
                    PropertyWrapperMutability)
+SWIFT_TYPEID_NAMED(PatternBindingEntry *, PatternBindingEntry)
 SWIFT_TYPEID_NAMED(PrecedenceGroupDecl *, PrecedenceGroupDecl)
 SWIFT_TYPEID_NAMED(ProtocolDecl *, ProtocolDecl)
 SWIFT_TYPEID_NAMED(TypeAliasDecl *, TypeAliasDecl)

include/swift/AST/ASTTypeIDs.h

@@ -35,6 +35,7 @@ class ModuleDecl;
 class NominalTypeDecl;
 class OperatorDecl;
 class OpaqueTypeDecl;
+class PatternBindingEntry;
 class ParamDecl;
 enum class ParamSpecifier : uint8_t;
 class PrecedenceGroupDecl;

include/swift/AST/Decl.h

@@ -1892,7 +1892,7 @@ class PatternBindingEntry {
     /// Whether the contents of this initializer were subsumed by
     /// some other initialization, e.g., a lazy property's initializer
     /// gets subsumed by the getter body.
-    Subsumed    = 1 << 2
+    Subsumed    = 1 << 2,
   };
   llvm::PointerIntPair<Pattern *, 3, OptionSet<Flags>> PatternAndFlags;
 
@@ -1926,6 +1926,8 @@ class PatternBindingEntry {
 
   friend class PatternBindingInitializer;
 
+  bool IsFullyValidated = false;
+
 public:
   /// \p E is the initializer as parsed.
   PatternBindingEntry(Pattern *P, SourceLoc EqualLoc, Expr *E,
@@ -1995,6 +1997,13 @@ class PatternBindingEntry {
     PatternAndFlags.setInt(PatternAndFlags.getInt() | Flags::Checked);
   }
 
+  bool isFullyValidated() const {
+    return IsFullyValidated;
+  }
+  void setFullyValidated() {
+    IsFullyValidated = true;
+  }
+
   bool isInitializerSubsumed() const {
     return PatternAndFlags.getInt().contains(Flags::Subsumed);
   }
@@ -2052,6 +2061,8 @@ class PatternBindingDecl final : public Decl,
     private llvm::TrailingObjects<PatternBindingDecl, PatternBindingEntry> {
   friend TrailingObjects;
   friend class Decl;
+  friend class PatternBindingEntryRequest;
+
   SourceLoc StaticLoc; ///< Location of the 'static/class' keyword, if present.
   SourceLoc VarLoc;    ///< Location of the 'var' keyword.
 

include/swift/AST/TypeCheckRequests.h

@@ -1385,6 +1385,28 @@ class ResultTypeRequest
   void cacheResult(Type value) const;
 };
 
+class PatternBindingEntryRequest
+    : public SimpleRequest<PatternBindingEntryRequest,
+                           const PatternBindingEntry *(PatternBindingDecl *,
+                                                       unsigned),
+                           CacheKind::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<const PatternBindingEntry *>
+  evaluate(Evaluator &evaluator, PatternBindingDecl *PBD, unsigned i) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<const PatternBindingEntry *> getCachedResult() const;
+  void cacheResult(const PatternBindingEntry *value) const;
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -97,6 +97,9 @@ SWIFT_REQUEST(TypeChecker, OperatorPrecedenceGroupRequest,
 SWIFT_REQUEST(TypeChecker, OverriddenDeclsRequest,
               llvm::TinyPtrVector<ValueDecl *>(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, PatternBindingEntryRequest,
+              const PatternBindingEntry *(PatternBindingDecl *, unsigned),
+              SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PropertyWrapperBackingPropertyInfoRequest,
               PropertyWrapperBackingPropertyInfo(VarDecl *), Cached,
               NoLocationInfo)

lib/AST/TypeCheckRequests.cpp

@@ -962,4 +962,25 @@ Optional<Type> ResultTypeRequest::getCachedResult() const {
 
 void ResultTypeRequest::cacheResult(Type type) const {
   getResultTypeLoc().setType(type);
-}
+}
+
+//----------------------------------------------------------------------------//
+// PatternBindingEntryRequest computation.
+//----------------------------------------------------------------------------//
+
+Optional<const PatternBindingEntry *>
+PatternBindingEntryRequest::getCachedResult() const {
+  auto *PBD = std::get<0>(getStorage());
+  auto idx = std::get<1>(getStorage());
+  if (!PBD->getPatternList()[idx].isFullyValidated()) {
+    return None;
+  }
+  return &PBD->getPatternList()[idx];
+}
+
+void PatternBindingEntryRequest::cacheResult(
+    const PatternBindingEntry *value) const {
+  auto *PBD = std::get<0>(getStorage());
+  auto idx = std::get<1>(getStorage());
+  PBD->getMutablePatternList()[idx].setFullyValidated();
+}

lib/Sema/ConstraintSystem.cpp

@@ -1461,16 +1461,6 @@ Type ConstraintSystem::getEffectiveOverloadType(const OverloadChoice &overload,
   if (decl->isImplicitlyUnwrappedOptional())
     return Type();
 
-  // In a pattern binding initializer, all of its bound variables have no
-  // effective overload type.
-  if (auto *PBI = dyn_cast<PatternBindingInitializer>(useDC)) {
-    if (auto *VD = dyn_cast<VarDecl>(decl)) {
-      if (PBI->getBinding() == VD->getParentPatternBinding()) {
-        return Type();
-      }
-    }
-  }
-
   // Retrieve the interface type.
   auto type = decl->getInterfaceType();
   if (!type || type->hasError()) {

lib/Sema/TypeCheckDecl.cpp

@@ -2390,64 +2390,30 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     });
   }
 
-  void visitBoundVars(Pattern *P) {
-    P->forEachVariable([&](VarDecl *VD) { this->visitBoundVariable(VD); });
-  }
 
   void visitPatternBindingDecl(PatternBindingDecl *PBD) {
     DeclContext *DC = PBD->getDeclContext();
 
-    // Check all the pattern/init pairs in the PBD.
-    validatePatternBindingEntries(TC, PBD);
-
     TC.checkDeclAttributes(PBD);
 
-    for (unsigned i = 0, e = PBD->getNumPatternEntries(); i != e; ++i) {
-      // Type check each VarDecl that this PatternBinding handles.
-      visitBoundVars(PBD->getPattern(i));
-
-      // If we have a type but no initializer, check whether the type is
-      // default-initializable. If so, do it.
-      if (PBD->getPattern(i)->hasType() &&
-          !PBD->isInitialized(i) &&
-          PBD->isDefaultInitializable(i) &&
-          PBD->getPattern(i)->hasStorage() &&
-          !PBD->getPattern(i)->getType()->hasError()) {
-        auto type = PBD->getPattern(i)->getType();
-        if (auto defaultInit = TC.buildDefaultInitializer(type)) {
-          // If we got a default initializer, install it and re-type-check it
-          // to make sure it is properly coerced to the pattern type.
-          PBD->setInit(i, defaultInit);
-        }
-      }
-
-      if (PBD->isInitialized(i)) {
-        // Add the attribute that preserves the "has an initializer" value across
-        // module generation, as required for TBDGen.
-        PBD->getPattern(i)->forEachVariable([&](VarDecl *VD) {
-          if (VD->hasStorage() &&
-              !VD->getAttrs().hasAttribute<HasInitialValueAttr>()) {
-            auto *attr = new (TC.Context) HasInitialValueAttr(
-                /*IsImplicit=*/true);
-            VD->getAttrs().add(attr);
-          }
-        });
-      }
-    }
-
     bool isInSILMode = false;
     if (auto sourceFile = DC->getParentSourceFile())
       isInSILMode = sourceFile->Kind == SourceFileKind::SIL;
     bool isTypeContext = DC->isTypeContext();
 
-    // If this is a declaration without an initializer, reject code if
-    // uninitialized vars are not allowed.
     for (unsigned i = 0, e = PBD->getNumPatternEntries(); i != e; ++i) {
-      auto entry = PBD->getPatternList()[i];
-    
-      if (entry.isInitialized() || isInSILMode) continue;
-      
-      entry.getPattern()->forEachVariable([&](VarDecl *var) {
+      const auto *entry = evaluateOrDefault(TC.Context.evaluator,
+                                            PatternBindingEntryRequest{PBD, i},
+                                            nullptr);
+      assert(entry && "No pattern binding entry?");
+
+      entry->getPattern()->forEachVariable([&](VarDecl *var) {
+        this->visitBoundVariable(var);
+
+        // If this is a declaration without an initializer, reject code if
+        // uninitialized vars are not allowed.
+        if (entry->isInitialized() || isInSILMode) return;
+
         // If the variable has no storage, it never needs an initializer.
         if (!var->hasStorage())
           return;
@@ -4223,15 +4189,11 @@ void TypeChecker::validateDecl(ValueDecl *D) {
     auto *VD = cast<VarDecl>(D);
     auto *PBD = VD->getParentPatternBinding();
     if (PBD) {
-      // If we're not being validated, validate our parent pattern binding and
-      // attempt to infer the interface type using the initializer expressions.
-      if (!PBD->isBeingValidated()) {
-        validatePatternBindingEntries(*this, PBD);
-      } else if (!VD->getNamingPattern()) {
-        // FIXME: This acts as a circularity breaker.
-        return;
-      }
-
+      // FIXME: Sink this into a request for the naming pattern.
+      unsigned i = PBD->getPatternEntryIndexForVarDecl(VD);
+      (void)evaluateOrDefault(Context.evaluator,
+                              PatternBindingEntryRequest{PBD, i},
+                              nullptr);
       if (PBD->isInvalid()) {
         VD->getParentPattern()->setType(ErrorType::get(Context));
         setBoundVarsTypeError(VD->getParentPattern(), Context);

lib/Sema/TypeCheckDecl.h

@@ -36,8 +36,7 @@ bool checkOverrides(ValueDecl *decl);
 
 // Implemented in TypeCheckStorage.cpp
 void setBoundVarsTypeError(Pattern *pattern, ASTContext &ctx);
-void validatePatternBindingEntries(TypeChecker &tc,
-                                   PatternBindingDecl *binding);
+
 }
 
 #endif