[CSStep] Conjunction: Give each conjunction step a fresh timer

Original timer cannot be used each expression in the multi-statement
closure is type-checked independently.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -167,8 +167,10 @@ struct RestrictionOrFix {
 
 
 class ExpressionTimer {
+public:
   using AnchorType = llvm::PointerUnion<Expr *, ConstraintLocator *>;
 
+private:
   AnchorType Anchor;
   ASTContext &Context;
   llvm::TimeRecord StartTime;
@@ -188,6 +190,8 @@ class ExpressionTimer {
 
   ~ExpressionTimer();
 
+  AnchorType getAnchor() const { return Anchor; }
+
   unsigned getWarnLimit() const {
     return Context.TypeCheckerOpts.WarnLongExpressionTypeChecking;
   }
@@ -5681,6 +5685,8 @@ class ConjunctionElement {
 
   bool attempt(ConstraintSystem &cs) const;
 
+  ConstraintLocator *getLocator() const { return Element->getLocator(); }
+
   void print(llvm::raw_ostream &Out, SourceManager *SM) const {
     Out << "conjunction element ";
     Element->print(Out, SM);

lib/Sema/CSStep.cpp

@@ -820,6 +820,14 @@ bool ConjunctionStep::attempt(const ConjunctionElement &element) {
   // when closure has a lot of elements in the body.
   CS.CountScopes = 0;
 
+  // If timer is enabled, let's reset it so that each element
+  // (expression) gets a fresh time slice to get solved. This
+  // is important for closures with large number of statements
+  // in them.
+  if (CS.Timer) {
+    CS.Timer.emplace(element.getLocator(), CS);
+  }
+
   auto success = element.attempt(CS);
 
   // If element attempt has failed, mark whole conjunction

lib/Sema/CSStep.h

@@ -861,6 +861,11 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
   /// before accepting this conjunction.
   llvm::SaveAndRestore<unsigned> OuterScopeCount;
 
+  /// The number of milliseconds until outer constraint system
+  /// is considered "too complex" if timer is enabled.
+  Optional<std::pair<ExpressionTimer::AnchorType, unsigned>>
+      OuterTimeRemaining = None;
+
   /// Conjunction constraint associated with this step.
   Constraint *Conjunction;
   /// Position of the conjunction in the inactive constraints
@@ -900,6 +905,11 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
     // Make a snapshot of the constraint system state before conjunction.
     if (conjunction->isIsolated())
       Snapshot.emplace(cs, conjunction);
+
+    if (cs.Timer) {
+      auto remainingTime = cs.Timer->getRemainingProcessTimeInMillis();
+      OuterTimeRemaining.emplace(cs.Timer->getAnchor(), remainingTime);
+    }
   }
 
   ~ConjunctionStep() override {
@@ -915,6 +925,12 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
     // successful outcome should keep a score set by `restoreOuterState`.
     if (HadFailure)
       restoreOriginalScores();
+
+    if (OuterTimeRemaining) {
+      auto anchor = OuterTimeRemaining->first;
+      auto remainingTime = OuterTimeRemaining->second;
+      CS.Timer.emplace(anchor, CS, remainingTime);
+    }
   }
 
   StepResult resume(bool prevFailed) override;