[Constraint solver] Remove ExprTypeCheckListener.

The last client of this listener-based interface has been refactored,
so remove it.

Author: DougGregor

lib/Sema/CSSolver.cpp

@@ -1141,7 +1141,6 @@ static bool debugConstraintSolverForTarget(
 
 Optional<std::vector<Solution>> ConstraintSystem::solve(
     SolutionApplicationTarget &target,
-    ExprTypeCheckListener *listener,
     FreeTypeVariableBinding allowFreeTypeVariables
 ) {
   llvm::SaveAndRestore<bool> debugForExpr(
@@ -1171,7 +1170,7 @@ Optional<std::vector<Solution>> ConstraintSystem::solve(
   // when there is an error and attempts to salvage an ill-formed program.
   for (unsigned stage = 0; stage != 2; ++stage) {
     auto solution = (stage == 0)
-        ? solveImpl(target, listener, allowFreeTypeVariables)
+        ? solveImpl(target, allowFreeTypeVariables)
         : salvage();
 
     switch (solution.getKind()) {
@@ -1237,7 +1236,6 @@ Optional<std::vector<Solution>> ConstraintSystem::solve(
 
 SolutionResult
 ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
-                            ExprTypeCheckListener *listener,
                             FreeTypeVariableBinding allowFreeTypeVariables) {
   if (getASTContext().TypeCheckerOpts.DebugConstraintSolver) {
     auto &log = getASTContext().TypeCheckerDebug->getStream();
@@ -1260,13 +1258,6 @@ ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
   if (generateConstraints(target, allowFreeTypeVariables))
     return SolutionResult::forError();;
 
-  // Notify the listener that we've built the constraint system.
-  if (Expr *expr = target.getAsExpr()) {
-    if (listener && listener->builtConstraints(*this, expr)) {
-      return SolutionResult::forError();
-    }
-  }
-
   // Try to solve the constraint system using computed suggestions.
   SmallVector<Solution, 4> solutions;
   solve(solutions, allowFreeTypeVariables);

lib/Sema/ConstraintSystem.h

@@ -2309,8 +2309,7 @@ class ConstraintSystem {
   friend Optional<SolutionApplicationTarget>
   swift::TypeChecker::typeCheckExpression(SolutionApplicationTarget &target,
                                           bool &unresolvedTypeExprs,
-                                          TypeCheckExprOptions options,
-                                          ExprTypeCheckListener *listener);
+                                          TypeCheckExprOptions options);
 
   /// Emit the fixes computed as part of the solution, returning true if we were
   /// able to emit an error message, or false if none of the fixits worked out.
@@ -4453,11 +4452,9 @@ class ConstraintSystem {
   /// Solve the system of constraints generated from provided expression.
   ///
   /// \param target The target to generate constraints from.
-  /// \param listener The callback to check solving progress.
   /// \param allowFreeTypeVariables How to bind free type variables in
   /// the solution.
   SolutionResult solveImpl(SolutionApplicationTarget &target,
-                           ExprTypeCheckListener *listener,
                            FreeTypeVariableBinding allowFreeTypeVariables
                              = FreeTypeVariableBinding::Disallow);
 
@@ -4470,15 +4467,13 @@ class ConstraintSystem {
   ///
   /// \param target The target that we'll generate constraints from, which
   /// may be updated by the solving process.
-  /// \param listener The callback to check solving progress.
   /// \param allowFreeTypeVariables How to bind free type variables in
   /// the solution.
   ///
   /// \returns the set of solutions, if any were found, or \c None if an
   /// error occurred. When \c None, an error has been emitted.
   Optional<std::vector<Solution>> solve(
       SolutionApplicationTarget &target,
-      ExprTypeCheckListener *listener,
       FreeTypeVariableBinding allowFreeTypeVariables
         = FreeTypeVariableBinding::Disallow);
 

lib/Sema/TypeCheckConstraints.cpp

@@ -1958,16 +1958,6 @@ bool ConstraintSystem::preCheckExpression(Expr *&expr, DeclContext *dc) {
   return true;
 }
 
-ExprTypeCheckListener::~ExprTypeCheckListener() { }
-
-bool ExprTypeCheckListener::builtConstraints(ConstraintSystem &cs, Expr *expr) {
-  return false;
-}
-
-Expr *ExprTypeCheckListener::appliedSolution(Solution &solution, Expr *expr) {
-  return expr;
-}
-
 void ParentConditionalConformance::diagnoseConformanceStack(
     DiagnosticEngine &diags, SourceLoc loc,
     ArrayRef<ParentConditionalConformance> conformances) {
@@ -1999,14 +1989,13 @@ bool GenericRequirementsCheckListener::diagnoseUnsatisfiedRequirement(
 Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
                                       TypeLoc convertType,
                                       ContextualTypePurpose convertTypePurpose,
-                                      TypeCheckExprOptions options,
-                                      ExprTypeCheckListener *listener) {
+                                      TypeCheckExprOptions options) {
   SolutionApplicationTarget target(
       expr, dc, convertTypePurpose, convertType,
       options.contains(TypeCheckExprFlags::IsDiscarded));
   bool unresolvedTypeExprs = false;
   auto resultTarget = typeCheckExpression(
-      target, unresolvedTypeExprs, options, listener);
+      target, unresolvedTypeExprs, options);
   if (!resultTarget) {
     expr = target.getAsExpr();
     return Type();
@@ -2027,8 +2016,7 @@ Optional<SolutionApplicationTarget>
 TypeChecker::typeCheckExpression(
     SolutionApplicationTarget &target,
     bool &unresolvedTypeExprs,
-    TypeCheckExprOptions options,
-    ExprTypeCheckListener *listener) {
+    TypeCheckExprOptions options) {
   unresolvedTypeExprs = false;
   Expr *expr = target.getAsExpr();
   DeclContext *dc = target.getDeclContext();
@@ -2076,7 +2064,7 @@ TypeChecker::typeCheckExpression(
     allowFreeTypeVariables = FreeTypeVariableBinding::UnresolvedType;
 
   // Attempt to solve the constraint system.
-  auto viable = cs.solve(target, listener, allowFreeTypeVariables);
+  auto viable = cs.solve(target, allowFreeTypeVariables);
   if (!viable) {
     target.setExpr(expr);
     return None;
@@ -2107,13 +2095,6 @@ TypeChecker::typeCheckExpression(
   }
   Expr *result = resultTarget->getAsExpr();
 
-  // Notify listener that we've applied the solution.
-  if (listener) {
-    result = listener->appliedSolution(solution, result);
-    if (!result)
-      return None;
-  }
-
   // Unless the client has disabled them, perform syntactic checks on the
   // expression now.
   if (!cs.shouldSuppressDiagnostics()) {
@@ -2137,8 +2118,7 @@ Type TypeChecker::typeCheckParameterDefault(Expr *&defaultValue,
 Type TypeChecker::
 getTypeOfExpressionWithoutApplying(Expr *&expr, DeclContext *dc,
                                    ConcreteDeclRef &referencedDecl,
-                                 FreeTypeVariableBinding allowFreeTypeVariables,
-                                   ExprTypeCheckListener *listener) {
+                                 FreeTypeVariableBinding allowFreeTypeVariables) {
   auto &Context = dc->getASTContext();
   FrontendStatsTracer StatsTracer(Context.Stats,
                                   "typecheck-expr-no-apply", expr);
@@ -2162,7 +2142,7 @@ getTypeOfExpressionWithoutApplying(Expr *&expr, DeclContext *dc,
     expr->setType(Type());
   SolutionApplicationTarget target(
       expr, dc, CTP_Unused, Type(), /*isDiscarded=*/false);
-  auto viable = cs.solve(target, listener, allowFreeTypeVariables);
+  auto viable = cs.solve(target, allowFreeTypeVariables);
   if (!viable) {
     recoverOriginalType();
     return Type();

lib/Sema/TypeChecker.h

@@ -258,33 +258,6 @@ enum class FreeTypeVariableBinding {
   UnresolvedType
 };
 
-/// An abstract interface that can interact with the type checker during
-/// the type checking of a particular expression.
-class ExprTypeCheckListener {
-public:
-  virtual ~ExprTypeCheckListener();
-
-  /// Callback invoked once the constraint system has been constructed.
-  ///
-  /// \param cs The constraint system that has been constructed.
-  ///
-  /// \param expr The pre-checked expression from which the constraint system
-  /// was generated.
-  ///
-  /// \returns true if an error occurred that is not itself part of the
-  /// constraint system, or false otherwise.
-  virtual bool builtConstraints(constraints::ConstraintSystem &cs, Expr *expr);
-
-  /// Callback invokes once the chosen solution has been applied to the
-  /// expression.
-  ///
-  /// The callback may further alter the expression, returning either a
-  /// new expression (to replace the result) or a null pointer to indicate
-  /// failure.
-  virtual Expr *appliedSolution(constraints::Solution &solution,
-                                Expr *expr);
-};
-
 /// A conditional conformance that implied some other requirements. That is, \c
 /// ConformingType conforming to \c Protocol may have required additional
 /// requirements to be satisfied.
@@ -757,23 +730,17 @@ Expr *findLHS(DeclContext *DC, Expr *E, Identifier name);
 ///
 /// \param options Options that control how type checking is performed.
 ///
-/// \param listener If non-null, a listener that will be notified of important
-/// events in the type checking of this expression, and which can introduce
-/// additional constraints.
-///
 /// \returns The type of the top-level expression, or Type() if an
 ///          error occurred.
 Type typeCheckExpression(Expr *&expr, DeclContext *dc,
                          TypeLoc convertType = TypeLoc(),
                          ContextualTypePurpose convertTypePurpose = CTP_Unused,
-                         TypeCheckExprOptions options = TypeCheckExprOptions(),
-                         ExprTypeCheckListener *listener = nullptr);
+                         TypeCheckExprOptions options = TypeCheckExprOptions());
 
 Optional<constraints::SolutionApplicationTarget>
 typeCheckExpression(constraints::SolutionApplicationTarget &target,
                     bool &unresolvedTypeExprs,
-                    TypeCheckExprOptions options = TypeCheckExprOptions(),
-                    ExprTypeCheckListener *listener = nullptr);
+                    TypeCheckExprOptions options = TypeCheckExprOptions());
 
 /// Type check the given expression and return its type without
 /// applying the solution.
@@ -786,17 +753,12 @@ typeCheckExpression(constraints::SolutionApplicationTarget &target,
 /// \param allowFreeTypeVariables Whether free type variables are allowed in
 /// the solution, and what to do with them.
 ///
-/// \param listener If non-null, a listener that will be notified of important
-/// events in the type checking of this expression, and which can introduce
-/// additional constraints.
-///
 /// \returns the type of \p expr on success, Type() otherwise.
 /// FIXME: expr may still be modified...
 Type getTypeOfExpressionWithoutApplying(
     Expr *&expr, DeclContext *dc, ConcreteDeclRef &referencedDecl,
     FreeTypeVariableBinding allowFreeTypeVariables =
-        FreeTypeVariableBinding::Disallow,
-    ExprTypeCheckListener *listener = nullptr);
+        FreeTypeVariableBinding::Disallow);
 
 /// Return the type of operator function for specified LHS, or a null
 /// \c Type on error.