[Diagnostics] Cleanup use of constraint system by ConstraintFix/FailureDiagnostic

Author: xedin

lib/Sema/CSApply.cpp

@@ -165,6 +165,13 @@ ConstraintLocator *Solution::getCalleeLocator(ConstraintLocator *locator,
       });
 }
 
+ConstraintLocator *
+Solution::getConstraintLocator(Expr *anchor,
+                               ArrayRef<LocatorPathElt> path) const {
+  auto &cs = getConstraintSystem();
+  return cs.getConstraintLocator(anchor, path);
+}
+
 /// Return the implicit access kind for a MemberRefExpr with the
 /// specified base and member in the specified DeclContext.
 static AccessSemantics
@@ -7702,6 +7709,15 @@ ProtocolConformanceRef Solution::resolveConformance(
   return ProtocolConformanceRef::forInvalid();
 }
 
+Type Solution::getType(TypedNode node) const {
+  auto result = nodeTypes.find(node);
+  if (result != nodeTypes.end())
+    return result->second;
+
+  auto &cs = getConstraintSystem();
+  return cs.getType(node);
+}
+
 void Solution::setExprTypes(Expr *expr) const {
   if (!expr)
     return;

lib/Sema/CSDiagnostics.cpp

@@ -80,7 +80,7 @@ Type FailureDiagnostic::getType(Expr *expr, bool wantRValue) const {
 }
 
 Type FailureDiagnostic::getType(const TypeLoc &loc, bool wantRValue) const {
-  return resolveType(S.getType(loc), /*reconstituteSugar=*/false, wantRValue);
+  return resolveType(S.getType(&loc), /*reconstituteSugar=*/false, wantRValue);
 }
 
 template <typename... ArgTypes>
@@ -132,8 +132,7 @@ Expr *FailureDiagnostic::getBaseExprFor(Expr *anchor) const {
 
 Optional<SelectedOverload>
 FailureDiagnostic::getChoiceFor(ConstraintLocator *locator) const {
-  auto &cs = getConstraintSystem();
-  return getOverloadChoiceIfAvailable(cs.getCalleeLocator(locator));
+  return getOverloadChoiceIfAvailable(S.getCalleeLocator(locator));
 }
 
 Type FailureDiagnostic::restoreGenericParameters(
@@ -1421,8 +1420,8 @@ bool TrailingClosureAmbiguityFailure::diagnoseAsNote() {
 
 AssignmentFailure::AssignmentFailure(Expr *destExpr, const Solution &solution,
                                      SourceLoc diagnosticLoc)
-    : FailureDiagnostic(solution, cs.getConstraintLocator(destExpr)),
-      DestExpr(destExpr), Loc(diagnosticLoc),
+    : FailureDiagnostic(solution, destExpr), DestExpr(destExpr),
+      Loc(diagnosticLoc),
       DeclDiagnostic(findDeclDiagonstic(getASTContext(), destExpr)),
       TypeDiagnostic(diag::assignment_lhs_not_lvalue) {}
 
@@ -3782,7 +3781,6 @@ bool ImplicitInitOnNonConstMetatypeFailure::diagnoseAsError() {
 }
 
 bool MissingArgumentsFailure::diagnoseAsError() {
-  auto &cs = getConstraintSystem();
   auto *locator = getLocator();
 
   if (!(locator->isLastElement<LocatorPathElt::ApplyArgToParam>() ||
@@ -6021,8 +6019,6 @@ bool AssignmentTypeMismatchFailure::diagnoseAsNote() {
 
 bool MissingContextualBaseInMemberRefFailure::diagnoseAsError() {
   auto *anchor = getAnchor();
-  auto &cs = getConstraintSystem();
-
   // Member reference could be wrapped into a number of parens
   // e.g. `((.foo))`.
   auto *parentExpr = findParentExpr(anchor);

lib/Sema/CSDiagnostics.h

@@ -55,6 +55,9 @@ class FailureDiagnostic {
     std::tie(Anchor, HasComplexLocator) = computeAnchor();
   }
 
+  FailureDiagnostic(const Solution &solution, Expr *anchor)
+      : FailureDiagnostic(solution, solution.getConstraintLocator(anchor)) {}
+
   virtual ~FailureDiagnostic();
 
   /// Try to diagnose a problem given affected expression,
@@ -155,8 +158,7 @@ class FailureDiagnostic {
   }
 
   ValueDecl *getResolvedMemberRef(UnresolvedDotExpr *member) const {
-    auto &cs = getConstraintSystem();
-    auto locator = cs.getConstraintLocator(member, ConstraintLocator::Member);
+    auto *locator = getConstraintLocator(member, ConstraintLocator::Member);
     if (auto overload = getOverloadChoiceIfAvailable(locator))
       return overload->choice.getDeclOrNull();
     return nullptr;
@@ -169,13 +171,17 @@ class FailureDiagnostic {
     return S.getOverloadChoiceIfAvailable(locator);
   }
 
-  /// Retrive the constraint locator for the given anchor and
-  /// path, uniqued and automatically calculate the summary flags
   ConstraintLocator *
   getConstraintLocator(Expr *anchor,
-                       ArrayRef<ConstraintLocator::PathElement> path) {
-    auto &cs = getConstraintSystem();
-    return cs.getConstraintLocator(anchor, path);
+                       ConstraintLocator::PathElement element) const {
+    return S.getConstraintLocator(anchor, {element});
+  }
+
+  /// Retrive the constraint locator for the given anchor and
+  /// path, uniqued and automatically calculate the summary flags
+  ConstraintLocator *getConstraintLocator(
+      Expr *anchor, ArrayRef<ConstraintLocator::PathElement> path = {}) const {
+    return S.getConstraintLocator(anchor, path);
   }
 
   Optional<FunctionArgApplyInfo>
@@ -503,10 +509,9 @@ class TrailingClosureAmbiguityFailure final : public FailureDiagnostic {
   ArrayRef<OverloadChoice> Choices;
 
 public:
-  TrailingClosureAmbiguityFailure(const Solution &solution, Expr *anchor,
+  TrailingClosureAmbiguityFailure(ArrayRef<Solution> solutions, Expr *anchor,
                                   ArrayRef<OverloadChoice> choices)
-      : FailureDiagnostic(solution, cs.getConstraintLocator(anchor)),
-        Choices(choices) {}
+      : FailureDiagnostic(solutions.front(), anchor), Choices(choices) {}
 
   bool diagnoseAsError() override { return false; }
 
@@ -529,9 +534,9 @@ class AssignmentFailure final : public FailureDiagnostic {
   AssignmentFailure(Expr *destExpr, const Solution &solution,
                     SourceLoc diagnosticLoc, Diag<StringRef> declDiag,
                     Diag<Type> typeDiag)
-      : FailureDiagnostic(solution, cs.getConstraintLocator(destExpr)),
-        DestExpr(destExpr), Loc(diagnosticLoc), DeclDiagnostic(declDiag),
-        TypeDiagnostic(typeDiag) {}
+      : FailureDiagnostic(solution, destExpr), DestExpr(destExpr),
+        Loc(diagnosticLoc), DeclDiagnostic(declDiag), TypeDiagnostic(typeDiag) {
+  }
 
   bool diagnoseAsError() override;
 

lib/Sema/CSFix.cpp

@@ -188,6 +188,7 @@ bool MissingConformance::diagnose(const Solution &solution, bool asNote) const {
   auto *locator = getLocator();
 
   if (IsContextual) {
+    auto &cs = solution.getConstraintSystem();
     auto context = cs.getContextualTypePurpose(locator->getAnchor());
     MissingContextualConformanceFailure failure(
         solution, context, NonConformingType, ProtocolType, locator);

lib/Sema/ConstraintSystem.cpp

@@ -2982,8 +2982,6 @@ bool ConstraintSystem::diagnoseAmbiguityWithFixes(
   // If we didn't find an ambiguous overload, diagnose the common fixes.
   if (ambiguousOverload == solutionDiff.overloads.end()) {
     bool diagnosed = false;
-    ConstraintSystem::SolverScope scope(*this);
-    applySolution(solutions.front());
     for (auto fixes: aggregatedFixes) {
       // A common fix must appear in all solutions
       if (fixes.second.size() < solutions.size()) continue;
@@ -3042,11 +3040,8 @@ bool ConstraintSystem::diagnoseAmbiguityWithFixes(
         continue;
 
       if (solution.Fixes.size() == 1) {
-        // Create scope so each applied solution is rolled back.
-        ConstraintSystem::SolverScope scope(*this);
-        applySolution(solution);
-        // All of the solutions supposed to produce a "candidate" note.
-        diagnosed &= solution.Fixes.front()->diagnose(/*asNote*/ true);
+        diagnosed &=
+            solution.Fixes.front()->diagnose(solution, /*asNote*/ true);
       } else if (llvm::all_of(solution.Fixes,
                               [&](ConstraintFix *fix) {
                                 return fix->getLocator()
@@ -3217,7 +3212,7 @@ bool ConstraintSystem::diagnoseAmbiguity(ArrayRef<Solution> solutions) {
                                   : diag::ambiguous_decl_ref,
                 name);
 
-    TrailingClosureAmbiguityFailure failure(*this, anchor,
+    TrailingClosureAmbiguityFailure failure(solutions, anchor,
                                             overload.choices);
     if (failure.diagnoseAsNote())
       return true;

lib/Sema/ConstraintSystem.h

@@ -975,14 +975,13 @@ class Solution {
   ConstraintLocator *getCalleeLocator(ConstraintLocator *locator,
                                       bool lookThroughApply = true) const;
 
+  ConstraintLocator *
+  getConstraintLocator(Expr *anchor, ArrayRef<LocatorPathElt> path = {}) const;
+
   void setExprTypes(Expr *expr) const;
 
   /// Retrieve the type of the given node, as recorded in this solution.
-  Type getType(TypedNode node) const {
-    auto known = nodeTypes.find(node);
-    assert(known != nodeTypes.end());
-    return known->second;
-  }
+  Type getType(TypedNode node) const;
 
   /// Resolve type variables present in the raw type, using generic parameter
   /// types where possible.