AST: Refactor pattern binding initializer expression state representation.

As a follow up to #69841, clarify the
possible states that initializer expression of a pattern can be in. The
possible states are not checked, checked, and "checked and contextualized"
(which is the new state that was introduced and requestified in the previous
PR). This refactoring encodes the states more explicitly and renames a few
compiler APIs to better align with the new naming. NFC.

Author: tshortli

include/swift/AST/Decl.h

@@ -1918,7 +1918,7 @@ class ExtensionRange {
 /// the initializer can be null if there is none.
 class PatternBindingEntry {
   enum class Flags {
-    Checked = 1 << 0,
+    // 1 << 0 is available
     Removed = 1 << 1,
     /// Whether the contents of this initializer were subsumed by
     /// some other initialization, e.g., a lazy property's initializer
@@ -1927,6 +1927,15 @@ class PatternBindingEntry {
   };
   llvm::PointerIntPair<Pattern *, 3, OptionSet<Flags>> PatternAndFlags;
 
+  enum class InitializerStatus {
+    /// The init expression has not been typechecked.
+    NotChecked = 0,
+    /// The init expression has been typechecked but not contextualized.
+    Checked,
+    /// The init expression has been typechecked and contextualized.
+    CheckedAndContextualized,
+  };
+
   struct InitializerAndEqualLoc {
     // When the initializer is removed we don't actually clear the pointers
     // because we might need to get initializer's source range. Since the
@@ -1936,7 +1945,7 @@ class PatternBindingEntry {
     Expr *originalInit;
     /// Might be transformed, e.g. for a property wrapper. In the absence of
     /// transformation or synthesis, holds the expr as parsed.
-    Expr *initAfterSynthesis;
+    llvm::PointerIntPair<Expr *, 2, InitializerStatus> initAfterSynthesis;
     /// The location of the equal '=' token.
     SourceLoc EqualLoc;
   };
@@ -1974,6 +1983,7 @@ class PatternBindingEntry {
   // typeCheckPatternBinding are requestified, merge this bit with
   // Flags::Checked.
   friend class PatternBindingEntryRequest;
+  friend class PatternBindingCheckedAndContextualizedInitRequest;
 
   bool isFullyValidated() const {
     return InitContextAndFlags.getInt().contains(
@@ -1996,7 +2006,8 @@ class PatternBindingEntry {
   /// \p E is the initializer as parsed.
   PatternBindingEntry(Pattern *P, SourceLoc EqualLoc, Expr *E,
                       DeclContext *InitContext)
-      : PatternAndFlags(P, {}), InitExpr({E, E, EqualLoc}),
+      : PatternAndFlags(P, {}),
+        InitExpr({E, {E, InitializerStatus::NotChecked}, EqualLoc}),
         InitContextAndFlags({InitContext, llvm::None}) {}
 
 private:
@@ -2013,7 +2024,7 @@ class PatternBindingEntry {
     if (PatternAndFlags.getInt().contains(Flags::Removed) ||
         InitContextAndFlags.getInt().contains(PatternFlags::IsText))
       return nullptr;
-    return InitExpr.initAfterSynthesis;
+    return InitExpr.initAfterSynthesis.getPointer();
   }
   /// Retrieve the initializer if it should be executed to initialize this
   /// particular pattern binding.
@@ -2060,11 +2071,26 @@ class PatternBindingEntry {
   /// Set the initializer after the = as it was written in the source.
   void setOriginalInit(Expr *);
 
+  InitializerStatus initializerStatus() const {
+    if (InitContextAndFlags.getInt().contains(PatternFlags::IsText))
+      return InitializerStatus::NotChecked;
+    return InitExpr.initAfterSynthesis.getInt();
+  }
   bool isInitializerChecked() const {
-    return PatternAndFlags.getInt().contains(Flags::Checked);
+    return initializerStatus() != InitializerStatus::NotChecked;
   }
   void setInitializerChecked() {
-    PatternAndFlags.setInt(PatternAndFlags.getInt() | Flags::Checked);
+    assert(!InitContextAndFlags.getInt().contains(PatternFlags::IsText));
+    InitExpr.initAfterSynthesis.setInt(InitializerStatus::Checked);
+  }
+
+  bool isInitializerCheckedAndContextualized() const {
+    return initializerStatus() == InitializerStatus::CheckedAndContextualized;
+  }
+  void setInitializerCheckedAndContextualized() {
+    assert(!InitContextAndFlags.getInt().contains(PatternFlags::IsText));
+    InitExpr.initAfterSynthesis.setInt(
+        InitializerStatus::CheckedAndContextualized);
   }
 
   bool isInitializerSubsumed() const {
@@ -2128,6 +2154,7 @@ class PatternBindingDecl final : public Decl,
   friend TrailingObjects;
   friend class Decl;
   friend class PatternBindingEntryRequest;
+  friend class PatternBindingCheckedAndContextualizedInitRequest;
 
   SourceLoc StaticLoc; ///< Location of the 'static/class' keyword, if present.
   SourceLoc VarLoc;    ///< Location of the 'var' keyword.
@@ -2276,9 +2303,13 @@ class PatternBindingDecl final : public Decl,
     getMutablePatternList()[i].setOriginalInit(E);
   }
 
-  /// Returns a fully typechecked executable init expression for the pattern at
-  /// the given index.
-  Expr *getCheckedExecutableInit(unsigned i) const;
+  /// Returns a fully typechecked init expression for the pattern at the given
+  /// index.
+  Expr *getCheckedAndContextualizedInit(unsigned i) const;
+
+  /// Returns the result of `getCheckedAndContextualizedInit()` if the init is
+  /// not subsumed. Otherwise, returns `nullptr`.
+  Expr *getCheckedAndContextualizedExecutableInit(unsigned i) const;
 
   Pattern *getPattern(unsigned i) const {
     return getPatternList()[i].getPattern();

include/swift/AST/Pattern.h

@@ -68,11 +68,10 @@ class alignas(8) Pattern : public ASTAllocated<Pattern> {
   // clang-format off
   union { uint64_t OpaqueBits;
 
-  SWIFT_INLINE_BITFIELD_BASE(Pattern, bitmax(NumPatternKindBits,8)+1+1+1,
+  SWIFT_INLINE_BITFIELD_BASE(Pattern, bitmax(NumPatternKindBits,8)+1+1,
     Kind : bitmax(NumPatternKindBits,8),
     isImplicit : 1,
-    hasInterfaceType : 1,
-    executableInitChecked : 1
+    hasInterfaceType : 1
   );
 
   SWIFT_INLINE_BITFIELD_FULL(TuplePattern, Pattern, 32,
@@ -105,7 +104,6 @@ class alignas(8) Pattern : public ASTAllocated<Pattern> {
     Bits.Pattern.Kind = unsigned(kind);
     Bits.Pattern.isImplicit = false;
     Bits.Pattern.hasInterfaceType = false;
-    Bits.Pattern.executableInitChecked = false;
   }
 
 private:
@@ -138,11 +136,6 @@ class alignas(8) Pattern : public ASTAllocated<Pattern> {
   bool isImplicit() const { return Bits.Pattern.isImplicit; }
   void setImplicit() { Bits.Pattern.isImplicit = true; }
 
-  bool executableInitChecked() const {
-    return Bits.Pattern.executableInitChecked;
-  }
-  void setExecutableInitChecked() { Bits.Pattern.executableInitChecked = true; }
-
   /// Find the smallest subpattern which obeys the property that matching it is
   /// equivalent to matching this pattern.
   ///

include/swift/AST/TypeCheckRequests.h

@@ -2347,8 +2347,8 @@ class PatternBindingEntryRequest
   void cacheResult(const PatternBindingEntry *value) const;
 };
 
-class PatternBindingCheckedExecutableInitRequest
-    : public SimpleRequest<PatternBindingCheckedExecutableInitRequest,
+class PatternBindingCheckedAndContextualizedInitRequest
+    : public SimpleRequest<PatternBindingCheckedAndContextualizedInitRequest,
                            Expr *(PatternBindingDecl *, unsigned),
                            RequestFlags::SeparatelyCached> {
 public:

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -258,7 +258,7 @@ SWIFT_REQUEST(TypeChecker, OverriddenDeclsRequest,
 SWIFT_REQUEST(TypeChecker, PatternBindingEntryRequest,
               const PatternBindingEntry *(PatternBindingDecl *, unsigned, bool),
               SeparatelyCached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, PatternBindingCheckedExecutableInitRequest,
+SWIFT_REQUEST(TypeChecker, PatternBindingCheckedAndContextualizedInitRequest,
               Expr *(PatternBindingDecl *, unsigned),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PrimarySourceFilesRequest,

lib/AST/Decl.cpp

@@ -2072,7 +2072,7 @@ void PatternBindingEntry::setInit(Expr *E) {
   } else {
     PatternAndFlags.setInt(F | Flags::Removed);
   }
-  InitExpr.initAfterSynthesis = E;
+  InitExpr.initAfterSynthesis.setPointer(E);
   InitContextAndFlags.setInt(InitContextAndFlags.getInt() -
                              PatternFlags::IsText);
 }
@@ -2198,13 +2198,19 @@ PatternBindingDecl::getInitializerIsolation(unsigned i) const {
   return var->getInitializerIsolation();
 }
 
-Expr *PatternBindingDecl::getCheckedExecutableInit(unsigned i) const {
+Expr *PatternBindingDecl::getCheckedAndContextualizedInit(unsigned i) const {
   return evaluateOrDefault(getASTContext().evaluator,
-                           PatternBindingCheckedExecutableInitRequest{
+                           PatternBindingCheckedAndContextualizedInitRequest{
                                const_cast<PatternBindingDecl *>(this), i},
                            nullptr);
 }
 
+Expr *PatternBindingDecl::getCheckedAndContextualizedExecutableInit(
+    unsigned i) const {
+  (void)getCheckedAndContextualizedInit(i);
+  return getExecutableInit(i);
+}
+
 bool PatternBindingDecl::hasStorage() const {
   // Walk the pattern, to check to see if any of the VarDecls included in it
   // have storage.

lib/AST/TypeCheckRequests.cpp

@@ -1023,23 +1023,24 @@ void PatternBindingEntryRequest::cacheResult(
 }
 
 //----------------------------------------------------------------------------//
-// PatternCheckedExecutableInitRequest computation.
+// PatternBindingCheckedAndContextualizedInitRequest computation.
 //----------------------------------------------------------------------------//
 
 llvm::Optional<Expr *>
-PatternBindingCheckedExecutableInitRequest::getCachedResult() const {
+PatternBindingCheckedAndContextualizedInitRequest::getCachedResult() const {
   auto *PBD = std::get<0>(getStorage());
   auto idx = std::get<1>(getStorage());
-  if (!PBD->getPattern(idx)->executableInitChecked())
+  if (!PBD->getPatternList()[idx].isInitializerCheckedAndContextualized())
     return llvm::None;
-  return PBD->getExecutableInit(idx);
+  return PBD->getInit(idx);
 }
 
-void PatternBindingCheckedExecutableInitRequest::cacheResult(Expr *expr) const {
+void PatternBindingCheckedAndContextualizedInitRequest::cacheResult(
+    Expr *expr) const {
   auto *PBD = std::get<0>(getStorage());
   auto idx = std::get<1>(getStorage());
-  assert(expr == PBD->getExecutableInit(idx));
-  PBD->getPattern(idx)->setExecutableInitChecked();
+  assert(expr == PBD->getInit(idx));
+  PBD->getMutablePatternList()[idx].setInitializerCheckedAndContextualized();
 }
 
 //----------------------------------------------------------------------------//

lib/SILGen/SILGen.cpp

@@ -1657,7 +1657,7 @@ emitStoredPropertyInitialization(PatternBindingDecl *pbd, unsigned i) {
     return;
 
   // Force the executable init to be type checked before emission.
-  if (!pbd->getCheckedExecutableInit(i))
+  if (!pbd->getCheckedAndContextualizedExecutableInit(i))
     return;
 
   auto *var = pbd->getAnchoringVarDecl(i);

lib/SILGen/SILGenGlobalVariable.cpp

@@ -220,7 +220,7 @@ void SILGenModule::emitGlobalInitialization(PatternBindingDecl *pd,
   }
 
   // Force the executable init to be type checked before emission.
-  if (!pd->getCheckedExecutableInit(pbdEntry))
+  if (!pd->getCheckedAndContextualizedExecutableInit(pbdEntry))
     return;
 
   Mangle::ASTMangler TokenMangler;

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2664,7 +2664,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
         // Trigger a request that will complete typechecking for the
         // initializer.
-        (void)PBD->getCheckedExecutableInit(i);
+        (void)PBD->getCheckedAndContextualizedInit(i);
       }
     }
 

lib/Sema/TypeCheckStorage.cpp

@@ -585,41 +585,48 @@ const PatternBindingEntry *PatternBindingEntryRequest::evaluate(
   return &pbe;
 }
 
-Expr *PatternBindingCheckedExecutableInitRequest::evaluate(
-    Evaluator &eval, PatternBindingDecl *binding, unsigned i) const {
+static void checkAndContextualizePatternBindingInit(PatternBindingDecl *binding,
+                                                    unsigned i) {
   // Force the entry to be checked.
   (void)binding->getCheckedPatternBindingEntry(i);
   if (binding->isInvalid())
-    return nullptr;
+    return;
 
   if (!binding->isInitialized(i))
-    return nullptr;
+    return;
 
   if (!binding->isInitializerChecked(i))
     TypeChecker::typeCheckPatternBinding(binding, i);
 
   if (binding->isInvalid())
-    return nullptr;
+    return;
 
   // If we entered an initializer context, contextualize any auto-closures we
   // might have created. Note that we don't contextualize the initializer for a
   // property with a wrapper, because the initializer will have been subsumed by
   // the backing storage property.
-  auto *init = binding->getInit(i);
+  if (binding->getDeclContext()->isLocalContext())
+    return;
 
-  if (!binding->getDeclContext()->isLocalContext() &&
-      !(binding->getSingleVar() &&
-        binding->getSingleVar()->hasAttachedPropertyWrapper())) {
-    auto *initContext =
-        cast_or_null<PatternBindingInitializer>(binding->getInitContext(i));
-    if (initContext) {
-      TypeChecker::contextualizeInitializer(initContext, init);
-      (void)binding->getInitializerIsolation(i);
-      TypeChecker::checkInitializerEffects(initContext, init);
-    }
+  if (auto *var = binding->getSingleVar()) {
+    if (var->hasAttachedPropertyWrapper())
+      return;
   }
 
-  return binding->getExecutableInit(i);
+  auto *initContext =
+      cast_or_null<PatternBindingInitializer>(binding->getInitContext(i));
+  if (initContext) {
+    auto *init = binding->getInit(i);
+    TypeChecker::contextualizeInitializer(initContext, init);
+    (void)binding->getInitializerIsolation(i);
+    TypeChecker::checkInitializerEffects(initContext, init);
+  }
+}
+
+Expr *PatternBindingCheckedAndContextualizedInitRequest::evaluate(
+    Evaluator &eval, PatternBindingDecl *binding, unsigned i) const {
+  checkAndContextualizePatternBindingInit(binding, i);
+  return binding->getInit(i);
 }
 
 bool