diagnoseUnownedImmediateDeallocation doesn't need a TypeChecker

Author: hamishknight

lib/Sema/CSApply.cpp

@@ -3722,7 +3722,7 @@ namespace {
         // If we're performing an assignment to a weak or unowned variable from
         // a constructor call, emit a warning that the instance will be
         // immediately deallocated.
-        diagnoseUnownedImmediateDeallocation(cs.getTypeChecker(), expr);
+        diagnoseUnownedImmediateDeallocation(cs.getASTContext(), expr);
       }
       return expr;
     }

lib/Sema/MiscDiagnostics.cpp

@@ -1690,7 +1690,7 @@ static const Expr *lookThroughExprsToImmediateDeallocation(const Expr *E) {
   }
 }
 
-static void diagnoseUnownedImmediateDeallocationImpl(TypeChecker &TC,
+static void diagnoseUnownedImmediateDeallocationImpl(ASTContext &ctx,
                                                      const VarDecl *varDecl,
                                                      const Expr *initExpr,
                                                      SourceLoc diagLoc,
@@ -1741,17 +1741,18 @@ static void diagnoseUnownedImmediateDeallocationImpl(TypeChecker &TC,
   if (varDecl->getDeclContext()->isTypeContext())
     storageKind = SK_Property;
 
-  TC.diagnose(diagLoc, diag::unowned_assignment_immediate_deallocation,
-              varDecl->getName(), ownershipAttr->get(), unsigned(storageKind))
+  ctx.Diags.diagnose(diagLoc, diag::unowned_assignment_immediate_deallocation,
+                     varDecl->getName(), ownershipAttr->get(),
+                     unsigned(storageKind))
     .highlight(diagRange);
 
-  TC.diagnose(diagLoc, diag::unowned_assignment_requires_strong)
+  ctx.Diags.diagnose(diagLoc, diag::unowned_assignment_requires_strong)
     .highlight(diagRange);
 
-  TC.diagnose(varDecl, diag::decl_declared_here, varDecl->getFullName());
+  ctx.Diags.diagnose(varDecl, diag::decl_declared_here, varDecl->getFullName());
 }
 
-void swift::diagnoseUnownedImmediateDeallocation(TypeChecker &TC,
+void swift::diagnoseUnownedImmediateDeallocation(ASTContext &ctx,
                                                  const AssignExpr *assignExpr) {
   auto *destExpr = assignExpr->getDest()->getValueProvidingExpr();
   auto *initExpr = assignExpr->getSrc();
@@ -1765,12 +1766,12 @@ void swift::diagnoseUnownedImmediateDeallocation(TypeChecker &TC,
   }
 
   if (VD)
-    diagnoseUnownedImmediateDeallocationImpl(TC, VD, initExpr,
+    diagnoseUnownedImmediateDeallocationImpl(ctx, VD, initExpr,
                                              assignExpr->getLoc(),
                                              initExpr->getSourceRange());
 }
 
-void swift::diagnoseUnownedImmediateDeallocation(TypeChecker &TC,
+void swift::diagnoseUnownedImmediateDeallocation(ASTContext &ctx,
                                                  const Pattern *pattern,
                                                  SourceLoc equalLoc,
                                                  const Expr *initExpr) {
@@ -1788,12 +1789,12 @@ void swift::diagnoseUnownedImmediateDeallocation(TypeChecker &TC,
         const Pattern *subPattern = elt.getPattern();
         Expr *subInitExpr = TE->getElement(i);
 
-        diagnoseUnownedImmediateDeallocation(TC, subPattern, equalLoc,
+        diagnoseUnownedImmediateDeallocation(ctx, subPattern, equalLoc,
                                              subInitExpr);
       }
     }
   } else if (auto *NP = dyn_cast<NamedPattern>(pattern)) {
-    diagnoseUnownedImmediateDeallocationImpl(TC, NP->getDecl(), initExpr,
+    diagnoseUnownedImmediateDeallocationImpl(ctx, NP->getDecl(), initExpr,
                                              equalLoc,
                                              initExpr->getSourceRange());
   }

lib/Sema/MiscDiagnostics.h

@@ -75,13 +75,13 @@ bool diagnoseArgumentLabelError(ASTContext &ctx,
 /// with a non-owning attribute, such as 'weak' or 'unowned' and the initializer
 /// expression refers to a class constructor, emit a warning that the assigned
 /// instance will be immediately deallocated.
-void diagnoseUnownedImmediateDeallocation(TypeChecker &TC,
+void diagnoseUnownedImmediateDeallocation(ASTContext &ctx,
                                           const AssignExpr *assignExpr);
 
 /// If \p pattern binds to a declaration with a non-owning attribute, such as
 /// 'weak' or 'unowned' and \p initializer refers to a class constructor,
 /// emit a warning that the bound instance will be immediately deallocated.
-void diagnoseUnownedImmediateDeallocation(TypeChecker &TC,
+void diagnoseUnownedImmediateDeallocation(ASTContext &ctx,
                                           const Pattern *pattern,
                                           SourceLoc equalLoc,
                                           const Expr *initializer);

lib/Sema/TypeCheckDecl.cpp

@@ -2600,9 +2600,9 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         // If we're performing an binding to a weak or unowned variable from a
         // constructor call, emit a warning that the instance will be immediately
         // deallocated.
-        diagnoseUnownedImmediateDeallocation(TC, PBD->getPattern(i),
-                                              PBD->getEqualLoc(i),
-                                              init);
+        diagnoseUnownedImmediateDeallocation(Ctx, PBD->getPattern(i),
+                                             PBD->getEqualLoc(i),
+                                             init);
 
         // If we entered an initializer context, contextualize any
         // auto-closures we might have created.