Sema: Record potential throw sites in the trail

Author: slavapestov

include/swift/Sema/CSTrail.def

@@ -64,8 +64,9 @@ CHANGE(RecordedClosureType)
 CHANGE(RecordedContextualInfo)
 CHANGE(RecordedTarget)
 CHANGE(RecordedCaseLabelItemInfo)
+CHANGE(RecordedPotentialThrowSite)
 
-LAST_CHANGE(RecordedCaseLabelItemInfo)
+LAST_CHANGE(RecordedPotentialThrowSite)
 
 #undef LOCATOR_CHANGE
 #undef EXPR_CHANGE

include/swift/Sema/CSTrail.h

@@ -133,6 +133,7 @@ class SolverTrail {
       ClosureExpr *TheClosure;
       DeclContext *TheDeclContext;
       CaseLabelItem *TheItem;
+      CatchNode TheCatchNode;
     };
 
     Change() : Kind(ChangeKind::AddedTypeVariable), TypeVar(nullptr) { }
@@ -224,6 +225,9 @@ class SolverTrail {
     /// Create a change that recorded a SyntacticElementTarget.
     static Change RecordedCaseLabelItemInfo(CaseLabelItem *item);
 
+    /// Create a change that recorded a potential throw site.
+    static Change RecordedPotentialThrowSite(CatchNode catchNode);
+
     /// Undo this change, reverting the constraint graph to the state it
     /// had prior to this change.
     ///

include/swift/Sema/ConstraintSystem.h

@@ -1585,7 +1585,7 @@ class Solution {
   /// Maps catch nodes to the set of potential throw sites that will be caught
   /// at that location.
 
-  /// The set of opened types for a given locator.
+  /// Keep track of all of the potential throw sites.
   std::vector<std::pair<CatchNode, PotentialThrowSite>>
       potentialThrowSites;
 
@@ -2855,9 +2855,6 @@ class ConstraintSystem {
     /// FIXME: Remove this.
     unsigned numFixes;
 
-    /// The length of \c potentialThrowSites.
-    unsigned numPotentialThrowSites;
-
     /// The length of \c exprPatterns.
     unsigned numExprPatterns;
 
@@ -3425,6 +3422,14 @@ class ConstraintSystem {
       PotentialThrowSite::Kind kind, Type type,
       ConstraintLocatorBuilder locator);
 
+  /// Used by the above to update potentialThrowSites and record a change
+  /// in the trail.
+  void recordPotentialThrowSite(CatchNode catchNode,
+                                PotentialThrowSite site);
+
+  /// Undo the above change.
+  void removePotentialThrowSite(CatchNode catchNode);
+
   /// Determine the caught error type for the given catch node.
   Type getCaughtErrorType(CatchNode node);
 

lib/Sema/CSSolver.cpp

@@ -399,9 +399,11 @@ void ConstraintSystem::applySolution(const Solution &solution) {
       setCaseLabelItemInfo(info.first, info.second);
   }
 
-  potentialThrowSites.insert(potentialThrowSites.end(),
-                             solution.potentialThrowSites.begin(),
-                             solution.potentialThrowSites.end());
+  auto sites = ArrayRef(solution.potentialThrowSites);
+  ASSERT(sites.size() >= potentialThrowSites.size());
+  for (const auto &site : sites.slice(potentialThrowSites.size())) {
+    potentialThrowSites.push_back(site);
+  }
 
   for (auto param : solution.isolatedParams) {
     isolatedParams.insert(param);
@@ -693,7 +695,6 @@ ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs)
   numTypeVariables = cs.TypeVariables.size();
   numFixes = cs.Fixes.size();
   numKeyPaths = cs.KeyPaths.size();
-  numPotentialThrowSites = cs.potentialThrowSites.size();
   numExprPatterns = cs.exprPatterns.size();
   numIsolatedParams = cs.isolatedParams.size();
   numPreconcurrencyClosures = cs.preconcurrencyClosures.size();
@@ -736,9 +737,6 @@ ConstraintSystem::SolverScope::~SolverScope() {
   /// Remove any key path expressions.
   truncate(cs.KeyPaths, numKeyPaths);
 
-  // Remove any potential throw sites.
-  truncate(cs.potentialThrowSites, numPotentialThrowSites);
-
   // Remove any ExprPattern mappings.
   truncate(cs.exprPatterns, numExprPatterns);
 

lib/Sema/CSTrail.cpp

@@ -311,6 +311,14 @@ SolverTrail::Change::RecordedCaseLabelItemInfo(CaseLabelItem *item) {
   return result;
 }
 
+SolverTrail::Change
+SolverTrail::Change::RecordedPotentialThrowSite(CatchNode catchNode) {
+  Change result;
+  result.Kind = ChangeKind::RecordedPotentialThrowSite;
+  result.TheCatchNode = catchNode;
+  return result;
+}
+
 SyntacticElementTargetKey
 SolverTrail::Change::getSyntacticElementTargetKey() const {
   ASSERT(Kind == ChangeKind::RecordedTarget);
@@ -477,6 +485,10 @@ void SolverTrail::Change::undo(ConstraintSystem &cs) const {
   case ChangeKind::RecordedCaseLabelItemInfo:
     cs.removeCaseLabelItemInfo(TheItem);
     break;
+
+  case ChangeKind::RecordedPotentialThrowSite:
+    cs.removePotentialThrowSite(TheCatchNode);
+    break;
   }
 }
 
@@ -686,6 +698,11 @@ void SolverTrail::Change::dump(llvm::raw_ostream &out,
     // FIXME: Print something here
     out << "(RecordedCaseLabelItemInfo)\n";
     break;
+
+  case ChangeKind::RecordedPotentialThrowSite:
+    // FIXME: Print something here
+    out << "(RecordedPotentialThrowSite)\n";
+    break;
   }
 }
 

lib/Sema/ConstraintSystem.cpp

@@ -435,6 +435,18 @@ bool ConstraintSystem::containsIDEInspectionTarget(
                                             Context.SourceMgr);
 }
 
+void ConstraintSystem::recordPotentialThrowSite(
+    CatchNode catchNode, PotentialThrowSite site) {
+  potentialThrowSites.push_back({catchNode, site});
+  if (solverState)
+    recordChange(SolverTrail::Change::RecordedPotentialThrowSite(catchNode));
+}
+
+void ConstraintSystem::removePotentialThrowSite(CatchNode catchNode) {
+  ASSERT(potentialThrowSites.back().first == catchNode);
+  potentialThrowSites.pop_back();
+}
+
 void ConstraintSystem::recordPotentialThrowSite(
     PotentialThrowSite::Kind kind, Type type,
     ConstraintLocatorBuilder locator) {
@@ -461,9 +473,8 @@ void ConstraintSystem::recordPotentialThrowSite(
   // do..catch statements without an explicit `throws` clause do infer
   // thrown types.
   if (auto doCatch = catchNode.dyn_cast<DoCatchStmt *>()) {
-    potentialThrowSites.push_back(
-        {catchNode,
-         PotentialThrowSite{kind, type, getConstraintLocator(locator)}});
+    PotentialThrowSite site{kind, type, getConstraintLocator(locator)};
+    recordPotentialThrowSite(catchNode, site);
     return;
   }
 
@@ -476,9 +487,8 @@ void ConstraintSystem::recordPotentialThrowSite(
   if (!closureEffects(closure).isThrowing())
     return;
 
-  potentialThrowSites.push_back(
-      {catchNode,
-       PotentialThrowSite{kind, type, getConstraintLocator(locator)}});
+  PotentialThrowSite site{kind, type, getConstraintLocator(locator)};
+  recordPotentialThrowSite(catchNode, site);
 }
 
 Type ConstraintSystem::getCaughtErrorType(CatchNode catchNode) {