Merge pull request #69918 from tshortli/refactor-pattern-binding-checked-init

AST: Refactor pattern binding initializer expression state representation

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