Merge pull request #28181 from CodaFi/exprt-systems

[NFC] Remove Diagnostic State From TypeChecker

Author: CodaFi

lib/Sema/CSDiag.cpp

@@ -1017,8 +1017,8 @@ Expr *FailureDiagnosis::typeCheckChildIndependently(
   // expression (which may lead to infinite recursion).  If the client is
   // telling us that it knows what it is doing, then believe it.
   if (!options.contains(TCC_ForceRecheck)) {
-    if (CS.getTypeChecker().isExprBeingDiagnosed(subExpr)) {
-      auto *savedExpr = CS.getTypeChecker().getExprBeingDiagnosed(subExpr);
+    if (CS.isExprBeingDiagnosed(subExpr)) {
+      auto *savedExpr = CS.getExprBeingDiagnosed(subExpr);
       if (subExpr == savedExpr)
         return subExpr;
 
@@ -1028,7 +1028,7 @@ Expr *FailureDiagnosis::typeCheckChildIndependently(
   }
 
   // Mark current expression as about to be diagnosed.
-  CS.getTypeChecker().addExprForDiagnosis(subExpr, subExpr);
+  CS.addExprForDiagnosis(subExpr, subExpr);
 
   // Validate contextual type before trying to use it.
   std::tie(convertType, convertTypePurpose) =
@@ -1118,7 +1118,7 @@ Expr *FailureDiagnosis::typeCheckChildIndependently(
   }
 
   if (preCheckedExpr != subExpr)
-    CS.getTypeChecker().addExprForDiagnosis(preCheckedExpr, subExpr);
+    CS.addExprForDiagnosis(preCheckedExpr, subExpr);
 
   return subExpr;
 }
@@ -4068,7 +4068,7 @@ diagnoseAmbiguousMultiStatementClosure(ClosureExpr *closure) {
       if (hasUnresolvedParams)
         continue;
 
-      ConstraintSystem::preCheckExpression(resultExpr, CS.DC);
+      ConstraintSystem::preCheckExpression(resultExpr, CS.DC, &CS);
 
       // Obtain type of the result expression without applying solutions,
       // because otherwise this might result in leaking of type variables,

lib/Sema/CSGen.cpp

@@ -1147,7 +1147,7 @@ namespace {
       // If this is a standalone `nil` literal expression e.g.
       // `_ = nil`, let's diagnose it here because solver can't
       // attempt any types for it.
-      if (!CS.getTypeChecker().isExprBeingDiagnosed(expr)) {
+      if (!CS.isExprBeingDiagnosed(expr)) {
         auto *parentExpr = CS.getParentExpr(expr);
 
         // `_ = nil`

lib/Sema/ConstraintSystem.cpp

@@ -1708,7 +1708,7 @@ static bool shouldCheckForPartialApplication(ConstraintSystem &cs,
 
   // FIXME(diagnostics): This check should be removed together with
   // expression based diagnostics.
-  if (cs.getTypeChecker().isExprBeingDiagnosed(anchor))
+  if (cs.isExprBeingDiagnosed(anchor))
     return false;
 
   // If this is a reference to instance method marked as 'mutating'

lib/Sema/ConstraintSystem.h

@@ -3590,7 +3590,8 @@ class ConstraintSystem {
 public:
   /// Pre-check the expression, validating any types that occur in the
   /// expression and folding sequence expressions.
-  static bool preCheckExpression(Expr *&expr, DeclContext *dc);
+  static bool preCheckExpression(Expr *&expr, DeclContext *dc,
+                                 ConstraintSystem *baseCS = nullptr);
 
   /// Solve the system of constraints generated from provided expression.
   ///
@@ -3822,6 +3823,36 @@ class ConstraintSystem {
                             SmallVectorImpl<unsigned> &Ordering,
                             SmallVectorImpl<unsigned> &PartitionBeginning);
 
+private:
+  /// The set of expressions currently being analyzed for failures.
+  llvm::DenseMap<Expr*, Expr*> DiagnosedExprs;
+
+public:
+  void addExprForDiagnosis(Expr *E1, Expr *Result) {
+    DiagnosedExprs[E1] = Result;
+  }
+  bool isExprBeingDiagnosed(Expr *E) {
+    if (DiagnosedExprs.count(E)) {
+      return true;
+    }
+    
+    if (baseCS && baseCS != this) {
+      return baseCS->isExprBeingDiagnosed(E);
+    }
+    return false;
+  }
+  Expr *getExprBeingDiagnosed(Expr *E) {
+    if (auto *expr = DiagnosedExprs[E]) {
+      return expr;
+    }
+    
+    if (baseCS && baseCS != this) {
+      return baseCS->getExprBeingDiagnosed(E);
+    }
+    return nullptr;
+  }
+        
+public:
   SWIFT_DEBUG_DUMP;
   SWIFT_DEBUG_DUMPER(dump(Expr *));
 

lib/Sema/TypeCheckConstraints.cpp

@@ -911,7 +911,8 @@ namespace {
   class PreCheckExpression : public ASTWalker {
     ASTContext &Ctx;
     DeclContext *DC;
-
+    ConstraintSystem *BaseCS;
+    
     Expr *ParentExpr;
 
     /// A stack of expressions being walked, used to determine where to
@@ -1053,17 +1054,14 @@ namespace {
     }
 
   public:
-    PreCheckExpression(DeclContext *dc, Expr *parent)
-        : Ctx(dc->getASTContext()), DC(dc), ParentExpr(parent) {}
+    PreCheckExpression(DeclContext *dc, Expr *parent, ConstraintSystem *base)
+        : Ctx(dc->getASTContext()), DC(dc), BaseCS(base), ParentExpr(parent) {}
 
     ASTContext &getASTContext() const { return Ctx; }
 
     bool walkToClosureExprPre(ClosureExpr *expr);
 
     std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
-      // FIXME: Remove TypeChecker dependencies below.
-      auto &TC = *Ctx.getLegacyGlobalTypeChecker();
-
       // If this is a call, record the argument expression.
       if (auto call = dyn_cast<ApplyExpr>(expr)) {
         if (!isa<SelfApplyExpr>(expr)) {
@@ -1160,8 +1158,8 @@ namespace {
         if (expr->isImplicit())
           return finish(true, expr);
 
-        if (TC.isExprBeingDiagnosed(ParentExpr) ||
-            TC.isExprBeingDiagnosed(expr))
+        if (BaseCS && (BaseCS->isExprBeingDiagnosed(ParentExpr) ||
+                       BaseCS->isExprBeingDiagnosed(expr)))
           return finish(true, expr);
 
         auto parents = ParentExpr->getParentMap();
@@ -2013,8 +2011,9 @@ Expr *PreCheckExpression::simplifyTypeConstructionWithLiteralArg(Expr *E) {
 
 /// Pre-check the expression, validating any types that occur in the
 /// expression and folding sequence expressions.
-bool ConstraintSystem::preCheckExpression(Expr *&expr, DeclContext *dc) {
-  PreCheckExpression preCheck(dc, expr);
+bool ConstraintSystem::preCheckExpression(Expr *&expr, DeclContext *dc,
+                                          ConstraintSystem *baseCS) {
+  PreCheckExpression preCheck(dc, expr, baseCS);
   // Perform the pre-check.
   if (auto result = expr->walk(preCheck)) {
     expr = result;
@@ -2177,7 +2176,7 @@ Type TypeChecker::typeCheckExpressionImpl(Expr *&expr, DeclContext *dc,
 
   // First, pre-check the expression, validating any types that occur in the
   // expression and folding sequence expressions.
-  if (ConstraintSystem::preCheckExpression(expr, dc)) {
+  if (ConstraintSystem::preCheckExpression(expr, dc, baseCS)) {
     listener.preCheckFailed(expr);
     return Type();
   }

lib/Sema/TypeChecker.h

@@ -544,9 +544,6 @@ class TypeChecker final {
 private:
   ASTContext &Context;
 
-  /// The set of expressions currently being analyzed for failures.
-  llvm::DenseMap<Expr*, Expr*> DiagnosedExprs;
-
   /// If non-zero, warn when a function body takes longer than this many
   /// milliseconds to type-check.
   ///
@@ -1778,16 +1775,6 @@ class TypeChecker final {
   static void checkPropertyWrapperErrorHandling(PatternBindingDecl *binding,
                                                 Expr *expr);
 
-  void addExprForDiagnosis(Expr *E1, Expr *Result) {
-    DiagnosedExprs[E1] = Result;
-  }
-  bool isExprBeingDiagnosed(Expr *E) {
-    return DiagnosedExprs.count(E);
-  }
-  Expr *getExprBeingDiagnosed(Expr *E) {
-    return DiagnosedExprs[E];
-  }
-
   /// If an expression references 'self.init' or 'super.init' in an
   /// initializer context, returns the implicit 'self' decl of the constructor.
   /// Otherwise, return nil.