AST/SILGen: Requestify var initializer expression typechecking.

Allow initializer expressions to be emitted during SILGen when
`-experimental-lazy-typecheck` is specified by introducing a new request that
fully typechecks the init expressions of pattern binding declarations
on-demand.

There are still a few rough edges, like missing support for wrapped properties
and incomplete handling of subsumed initializers. Fixing these issues is not an
immediate priority because in the short term `-experimental-lazy-typecheck`
will always be accompanied by `-enable-library-evolution` and
`-experimental-skip-non-exportable-decls`. This means that only the
initializers of properties on `@frozen` types will need to be emitted and
property wrappers are not yet fully supported on properties belonging to
`@frozen` types.

Resolves rdar://117448868

Author: tshortli

include/swift/AST/Decl.h

@@ -2276,6 +2276,10 @@ 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;
+
   Pattern *getPattern(unsigned i) const {
     return getPatternList()[i].getPattern();
   }

include/swift/AST/Pattern.h

@@ -68,10 +68,11 @@ class alignas(8) Pattern : public ASTAllocated<Pattern> {
   // clang-format off
   union { uint64_t OpaqueBits;
 
-  SWIFT_INLINE_BITFIELD_BASE(Pattern, bitmax(NumPatternKindBits,8)+1+1,
+  SWIFT_INLINE_BITFIELD_BASE(Pattern, bitmax(NumPatternKindBits,8)+1+1+1,
     Kind : bitmax(NumPatternKindBits,8),
     isImplicit : 1,
-    hasInterfaceType : 1
+    hasInterfaceType : 1,
+    executableInitChecked : 1
   );
 
   SWIFT_INLINE_BITFIELD_FULL(TuplePattern, Pattern, 32,
@@ -104,6 +105,7 @@ 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:
@@ -136,6 +138,11 @@ 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,6 +2347,27 @@ class PatternBindingEntryRequest
   void cacheResult(const PatternBindingEntry *value) const;
 };
 
+class PatternBindingCheckedExecutableInitRequest
+    : public SimpleRequest<PatternBindingCheckedExecutableInitRequest,
+                           Expr *(PatternBindingDecl *, unsigned),
+                           RequestFlags::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  Expr *evaluate(Evaluator &evaluator, PatternBindingDecl *PBD,
+                 unsigned i) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  llvm::Optional<Expr *> getCachedResult() const;
+  void cacheResult(Expr *expr) const;
+};
+
 class NamingPatternRequest
     : public SimpleRequest<NamingPatternRequest, NamedPattern *(VarDecl *),
                            RequestFlags::SeparatelyCached> {

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -258,6 +258,9 @@ SWIFT_REQUEST(TypeChecker, OverriddenDeclsRequest,
 SWIFT_REQUEST(TypeChecker, PatternBindingEntryRequest,
               const PatternBindingEntry *(PatternBindingDecl *, unsigned, bool),
               SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, PatternBindingCheckedExecutableInitRequest,
+              Expr *(PatternBindingDecl *, unsigned),
+              SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PrimarySourceFilesRequest,
               ArrayRef<SourceFile *>(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PropertyWrapperAuxiliaryVariablesRequest,

lib/AST/Decl.cpp

@@ -2198,6 +2198,13 @@ PatternBindingDecl::getInitializerIsolation(unsigned i) const {
   return var->getInitializerIsolation();
 }
 
+Expr *PatternBindingDecl::getCheckedExecutableInit(unsigned i) const {
+  return evaluateOrDefault(getASTContext().evaluator,
+                           PatternBindingCheckedExecutableInitRequest{
+                               const_cast<PatternBindingDecl *>(this), i},
+                           nullptr);
+}
+
 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

@@ -1022,6 +1022,26 @@ void PatternBindingEntryRequest::cacheResult(
   PBD->getMutablePatternList()[idx].setFullyValidated();
 }
 
+//----------------------------------------------------------------------------//
+// PatternCheckedExecutableInitRequest computation.
+//----------------------------------------------------------------------------//
+
+llvm::Optional<Expr *>
+PatternBindingCheckedExecutableInitRequest::getCachedResult() const {
+  auto *PBD = std::get<0>(getStorage());
+  auto idx = std::get<1>(getStorage());
+  if (!PBD->getPattern(idx)->executableInitChecked())
+    return llvm::None;
+  return PBD->getExecutableInit(idx);
+}
+
+void PatternBindingCheckedExecutableInitRequest::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();
+}
+
 //----------------------------------------------------------------------------//
 // NamingPatternRequest computation.
 //----------------------------------------------------------------------------//

lib/SILGen/SILGen.cpp

@@ -1656,6 +1656,10 @@ emitStoredPropertyInitialization(PatternBindingDecl *pbd, unsigned i) {
       !pbd->getAnchoringVarDecl(i)->isInitExposedToClients())
     return;
 
+  // Force the executable init to be type checked before emission.
+  if (!pbd->getCheckedExecutableInit(i))
+    return;
+
   auto *var = pbd->getAnchoringVarDecl(i);
   SILDeclRef constant(var, SILDeclRef::Kind::StoredPropertyInitializer);
   emitOrDelayFunction(constant);
@@ -1666,6 +1670,9 @@ emitPropertyWrapperBackingInitializer(VarDecl *var) {
   auto initInfo = var->getPropertyWrapperInitializerInfo();
 
   if (initInfo.hasInitFromWrappedValue()) {
+    // FIXME: Fully typecheck the original property's init expression on-demand
+    // for lazy typechecking mode.
+
     SILDeclRef constant(var, SILDeclRef::Kind::PropertyWrapperBackingInitializer);
     emitOrDelayFunction(constant);
   }

lib/SILGen/SILGenGlobalVariable.cpp

@@ -219,6 +219,10 @@ void SILGenModule::emitGlobalInitialization(PatternBindingDecl *pd,
                 ->areAllParamsConcrete());
   }
 
+  // Force the executable init to be type checked before emission.
+  if (!pd->getCheckedExecutableInit(pbdEntry))
+    return;
+
   Mangle::ASTMangler TokenMangler;
   std::string onceTokenBuffer = TokenMangler.mangleGlobalInit(pd, pbdEntry,
                                                               false);

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2662,22 +2662,9 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         // as a replacement.
         diagnoseWrittenPlaceholderTypes(Ctx, PBD->getPattern(i), init);
 
-        // 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.
-        if (!DC->isLocalContext() &&
-            !(PBD->getSingleVar() &&
-              PBD->getSingleVar()->hasAttachedPropertyWrapper())) {
-          auto *initContext = cast_or_null<PatternBindingInitializer>(
-              PBD->getInitContext(i));
-          if (initContext) {
-            TypeChecker::contextualizeInitializer(initContext, init);
-            (void)PBD->getInitializerIsolation(i);
-            TypeChecker::checkInitializerEffects(initContext, init);
-          }
-        }
+        // Trigger a request that will complete typechecking for the
+        // initializer.
+        (void)PBD->getCheckedExecutableInit(i);
       }
     }
 
@@ -2686,6 +2673,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       // If this is an init accessor property with a default initializer,
       // make sure that it subsumes initializers of all of its "initializes"
       // stored properties.
+      // FIXME: This should be requestified.
       auto *initAccessor = var->getAccessor(AccessorKind::Init);
       if (initAccessor && PBD->isInitialized(0)) {
         for (auto *property : initAccessor->getInitializedProperties()) {

lib/Sema/TypeCheckStorage.cpp

@@ -585,6 +585,43 @@ const PatternBindingEntry *PatternBindingEntryRequest::evaluate(
   return &pbe;
 }
 
+Expr *PatternBindingCheckedExecutableInitRequest::evaluate(
+    Evaluator &eval, PatternBindingDecl *binding, unsigned i) const {
+  // Force the entry to be checked.
+  (void)binding->getCheckedPatternBindingEntry(i);
+  if (binding->isInvalid())
+    return nullptr;
+
+  if (!binding->isInitialized(i))
+    return nullptr;
+
+  if (!binding->isInitializerChecked(i))
+    TypeChecker::typeCheckPatternBinding(binding, i);
+
+  if (binding->isInvalid())
+    return nullptr;
+
+  // 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() &&
+      !(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);
+    }
+  }
+
+  return binding->getExecutableInit(i);
+}
+
 bool
 IsGetterMutatingRequest::evaluate(Evaluator &evaluator,
                                   AbstractStorageDecl *storage) const {