contrib/llvm/tools/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp

   1 //== Nullabilityhecker.cpp - Nullability checker ----------------*- C++ -*--==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This checker tries to find nullability violations. There are several kinds of
  11 // possible violations:
  12 // * Null pointer is passed to a pointer which has a _Nonnull type.
  13 // * Null pointer is returned from a function which has a _Nonnull return type.
  14 // * Nullable pointer is passed to a pointer which has a _Nonnull type.
  15 // * Nullable pointer is returned from a function which has a _Nonnull return
  16 //   type.
  17 // * Nullable pointer is dereferenced.
  18 //
  19 // This checker propagates the nullability information of the pointers and looks
  20 // for the patterns that are described above. Explicit casts are trusted and are
  21 // considered a way to suppress false positives for this checker. The other way
  22 // to suppress warnings would be to add asserts or guarding if statements to the
  23 // code. In addition to the nullability propagation this checker also uses some
  24 // heuristics to suppress potential false positives.
  25 //
  26 //===----------------------------------------------------------------------===//
  27
  28 #include "ClangSACheckers.h"
  29
  30 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
  31 #include "clang/StaticAnalyzer/Core/Checker.h"
  32 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  33 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h"
  34 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
  35 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
  36
  37 #include "llvm/ADT/StringExtras.h"
  38 #include "llvm/Support/Path.h"
  39
  40 using namespace clang;
  41 using namespace ento;
  42
  43 namespace {
  44
  45 /// Returns the most nullable nullability. This is used for message expressions
  46 /// like [receiver method], where the nullability of this expression is either
  47 /// the nullability of the receiver or the nullability of the return type of the
  48 /// method, depending on which is more nullable. Contradicted is considered to
  49 /// be the most nullable, to avoid false positive results.
  50 Nullability getMostNullable(Nullability Lhs, Nullability Rhs) {
  51   return static_cast<Nullability>(
  52       std::min(static_cast<char>(Lhs), static_cast<char>(Rhs)));
  53 }
  54
  55 const char *getNullabilityString(Nullability Nullab) {
  56   switch (Nullab) {
  57   case Nullability::Contradicted:
  58     return "contradicted";
  59   case Nullability::Nullable:
  60     return "nullable";
  61   case Nullability::Unspecified:
  62     return "unspecified";
  63   case Nullability::Nonnull:
  64     return "nonnull";
  65   }
  66   llvm_unreachable("Unexpected enumeration.");
  67   return "";
  68 }
  69
  70 // These enums are used as an index to ErrorMessages array.
  71 enum class ErrorKind : int {
  72   NilAssignedToNonnull,
  73   NilPassedToNonnull,
  74   NilReturnedToNonnull,
  75   NullableAssignedToNonnull,
  76   NullableReturnedToNonnull,
  77   NullableDereferenced,
  78   NullablePassedToNonnull
  79 };
  80
  81 class NullabilityChecker
  82     : public Checker<check::Bind, check::PreCall, check::PreStmt<ReturnStmt>,
  83                      check::PostCall, check::PostStmt<ExplicitCastExpr>,
  84                      check::PostObjCMessage, check::DeadSymbols,
  85                      check::Event<ImplicitNullDerefEvent>> {
  86   mutable std::unique_ptr<BugType> BT;
  87
  88 public:
  89   // If true, the checker will not diagnose nullabilility issues for calls
  90   // to system headers. This option is motivated by the observation that large
  91   // projects may have many nullability warnings. These projects may
  92   // find warnings about nullability annotations that they have explicitly
  93   // added themselves higher priority to fix than warnings on calls to system
  94   // libraries.
  95   DefaultBool NoDiagnoseCallsToSystemHeaders;
  96
  97   void checkBind(SVal L, SVal V, const Stmt *S, CheckerContext &C) const;
  98   void checkPostStmt(const ExplicitCastExpr *CE, CheckerContext &C) const;
  99   void checkPreStmt(const ReturnStmt *S, CheckerContext &C) const;
 100   void checkPostObjCMessage(const ObjCMethodCall &M, CheckerContext &C) const;
 101   void checkPostCall(const CallEvent &Call, CheckerContext &C) const;
 102   void checkPreCall(const CallEvent &Call, CheckerContext &C) const;
 103   void checkDeadSymbols(SymbolReaper &SR, CheckerContext &C) const;
 104   void checkEvent(ImplicitNullDerefEvent Event) const;
 105
 106   void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
 107                   const char *Sep) const override;
 108
 109   struct NullabilityChecksFilter {
 110     DefaultBool CheckNullPassedToNonnull;
 111     DefaultBool CheckNullReturnedFromNonnull;
 112     DefaultBool CheckNullableDereferenced;
 113     DefaultBool CheckNullablePassedToNonnull;
 114     DefaultBool CheckNullableReturnedFromNonnull;
 115
 116     CheckName CheckNameNullPassedToNonnull;
 117     CheckName CheckNameNullReturnedFromNonnull;
 118     CheckName CheckNameNullableDereferenced;
 119     CheckName CheckNameNullablePassedToNonnull;
 120     CheckName CheckNameNullableReturnedFromNonnull;
 121   };
 122
 123   NullabilityChecksFilter Filter;
 124   // When set to false no nullability information will be tracked in
 125   // NullabilityMap. It is possible to catch errors like passing a null pointer
 126   // to a callee that expects nonnull argument without the information that is
 127   // stroed in the NullabilityMap. This is an optimization.
 128   DefaultBool NeedTracking;
 129
 130 private:
 131   class NullabilityBugVisitor : public BugReporterVisitor {
 132   public:
 133     NullabilityBugVisitor(const MemRegion *M) : Region(M) {}
 134
 135     void Profile(llvm::FoldingSetNodeID &ID) const override {
 136       static int X = 0;
 137       ID.AddPointer(&X);
 138       ID.AddPointer(Region);
 139     }
 140
 141     std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
 142                                                    const ExplodedNode *PrevN,
 143                                                    BugReporterContext &BRC,
 144                                                    BugReport &BR) override;
 145
 146   private:
 147     // The tracked region.
 148     const MemRegion *Region;
 149   };
 150
 151   /// When any of the nonnull arguments of the analyzed function is null, do not
 152   /// report anything and turn off the check.
 153   ///
 154   /// When \p SuppressPath is set to true, no more bugs will be reported on this
 155   /// path by this checker.
 156   void reportBugIfInvariantHolds(StringRef Msg, ErrorKind Error,
 157                                  ExplodedNode *N, const MemRegion *Region,
 158                                  CheckerContext &C,
 159                                  const Stmt *ValueExpr = nullptr,
 160                                   bool SuppressPath = false) const;
 161
 162   void reportBug(StringRef Msg, ErrorKind Error, ExplodedNode *N,
 163                  const MemRegion *Region, BugReporter &BR,
 164                  const Stmt *ValueExpr = nullptr) const {
 165     if (!BT)
 166       BT.reset(new BugType(this, "Nullability", categories::MemoryError));
 167
 168     auto R = llvm::make_unique<BugReport>(*BT, Msg, N);
 169     if (Region) {
 170       R->markInteresting(Region);
 171       R->addVisitor(llvm::make_unique<NullabilityBugVisitor>(Region));
 172     }
 173     if (ValueExpr) {
 174       R->addRange(ValueExpr->getSourceRange());
 175       if (Error == ErrorKind::NilAssignedToNonnull ||
 176           Error == ErrorKind::NilPassedToNonnull ||
 177           Error == ErrorKind::NilReturnedToNonnull)
 178         bugreporter::trackNullOrUndefValue(N, ValueExpr, *R);
 179     }
 180     BR.emitReport(std::move(R));
 181   }
 182
 183   /// If an SVal wraps a region that should be tracked, it will return a pointer
 184   /// to the wrapped region. Otherwise it will return a nullptr.
 185   const SymbolicRegion *getTrackRegion(SVal Val,
 186                                        bool CheckSuperRegion = false) const;
 187
 188   /// Returns true if the call is diagnosable in the currrent analyzer
 189   /// configuration.
 190   bool isDiagnosableCall(const CallEvent &Call) const {
 191     if (NoDiagnoseCallsToSystemHeaders && Call.isInSystemHeader())
 192       return false;
 193
 194     return true;
 195   }
 196 };
 197
 198 class NullabilityState {
 199 public:
 200   NullabilityState(Nullability Nullab, const Stmt *Source = nullptr)
 201       : Nullab(Nullab), Source(Source) {}
 202
 203   const Stmt *getNullabilitySource() const { return Source; }
 204
 205   Nullability getValue() const { return Nullab; }
 206
 207   void Profile(llvm::FoldingSetNodeID &ID) const {
 208     ID.AddInteger(static_cast<char>(Nullab));
 209     ID.AddPointer(Source);
 210   }
 211
 212   void print(raw_ostream &Out) const {
 213     Out << getNullabilityString(Nullab) << "\n";
 214   }
 215
 216 private:
 217   Nullability Nullab;
 218   // Source is the expression which determined the nullability. For example in a
 219   // message like [nullable nonnull_returning] has nullable nullability, because
 220   // the receiver is nullable. Here the receiver will be the source of the
 221   // nullability. This is useful information when the diagnostics are generated.
 222   const Stmt *Source;
 223 };
 224
 225 bool operator==(NullabilityState Lhs, NullabilityState Rhs) {
 226   return Lhs.getValue() == Rhs.getValue() &&
 227          Lhs.getNullabilitySource() == Rhs.getNullabilitySource();
 228 }
 229
 230 } // end anonymous namespace
 231
 232 REGISTER_MAP_WITH_PROGRAMSTATE(NullabilityMap, const MemRegion *,
 233                                NullabilityState)
 234
 235 // We say "the nullability type invariant is violated" when a location with a
 236 // non-null type contains NULL or a function with a non-null return type returns
 237 // NULL. Violations of the nullability type invariant can be detected either
 238 // directly (for example, when NULL is passed as an argument to a nonnull
 239 // parameter) or indirectly (for example, when, inside a function, the
 240 // programmer defensively checks whether a nonnull parameter contains NULL and
 241 // finds that it does).
 242 //
 243 // As a matter of policy, the nullability checker typically warns on direct
 244 // violations of the nullability invariant (although it uses various
 245 // heuristics to suppress warnings in some cases) but will not warn if the
 246 // invariant has already been violated along the path (either directly or
 247 // indirectly). As a practical matter, this prevents the analyzer from
 248 // (1) warning on defensive code paths where a nullability precondition is
 249 // determined to have been violated, (2) warning additional times after an
 250 // initial direct violation has been discovered, and (3) warning after a direct
 251 // violation that has been implicitly or explicitly suppressed (for
 252 // example, with a cast of NULL to _Nonnull). In essence, once an invariant
 253 // violation is detected on a path, this checker will be essentially turned off
 254 // for the rest of the analysis
 255 //
 256 // The analyzer takes this approach (rather than generating a sink node) to
 257 // ensure coverage of defensive paths, which may be important for backwards
 258 // compatibility in codebases that were developed without nullability in mind.
 259 REGISTER_TRAIT_WITH_PROGRAMSTATE(InvariantViolated, bool)
 260
 261 enum class NullConstraint { IsNull, IsNotNull, Unknown };
 262
 263 static NullConstraint getNullConstraint(DefinedOrUnknownSVal Val,
 264                                         ProgramStateRef State) {
 265   ConditionTruthVal Nullness = State->isNull(Val);
 266   if (Nullness.isConstrainedFalse())
 267     return NullConstraint::IsNotNull;
 268   if (Nullness.isConstrainedTrue())
 269     return NullConstraint::IsNull;
 270   return NullConstraint::Unknown;
 271 }
 272
 273 const SymbolicRegion *
 274 NullabilityChecker::getTrackRegion(SVal Val, bool CheckSuperRegion) const {
 275   if (!NeedTracking)
 276     return nullptr;
 277
 278   auto RegionSVal = Val.getAs<loc::MemRegionVal>();
 279   if (!RegionSVal)
 280     return nullptr;
 281
 282   const MemRegion *Region = RegionSVal->getRegion();
 283
 284   if (CheckSuperRegion) {
 285     if (auto FieldReg = Region->getAs<FieldRegion>())
 286       return dyn_cast<SymbolicRegion>(FieldReg->getSuperRegion());
 287     if (auto ElementReg = Region->getAs<ElementRegion>())
 288       return dyn_cast<SymbolicRegion>(ElementReg->getSuperRegion());
 289   }
 290
 291   return dyn_cast<SymbolicRegion>(Region);
 292 }
 293
 294 std::shared_ptr<PathDiagnosticPiece>
 295 NullabilityChecker::NullabilityBugVisitor::VisitNode(const ExplodedNode *N,
 296                                                      const ExplodedNode *PrevN,
 297                                                      BugReporterContext &BRC,
 298                                                      BugReport &BR) {
 299   ProgramStateRef State = N->getState();
 300   ProgramStateRef StatePrev = PrevN->getState();
 301
 302   const NullabilityState *TrackedNullab = State->get<NullabilityMap>(Region);
 303   const NullabilityState *TrackedNullabPrev =
 304       StatePrev->get<NullabilityMap>(Region);
 305   if (!TrackedNullab)
 306     return nullptr;
 307
 308   if (TrackedNullabPrev &&
 309       TrackedNullabPrev->getValue() == TrackedNullab->getValue())
 310     return nullptr;
 311
 312   // Retrieve the associated statement.
 313   const Stmt *S = TrackedNullab->getNullabilitySource();
 314   if (!S || S->getLocStart().isInvalid()) {
 315     S = PathDiagnosticLocation::getStmt(N);
 316   }
 317
 318   if (!S)
 319     return nullptr;
 320
 321   std::string InfoText =
 322       (llvm::Twine("Nullability '") +
 323        getNullabilityString(TrackedNullab->getValue()) + "' is inferred")
 324           .str();
 325
 326   // Generate the extra diagnostic.
 327   PathDiagnosticLocation Pos(S, BRC.getSourceManager(),
 328                              N->getLocationContext());
 329   return std::make_shared<PathDiagnosticEventPiece>(Pos, InfoText, true,
 330                                                     nullptr);
 331 }
 332
 333 /// Returns true when the value stored at the given location is null
 334 /// and the passed in type is nonnnull.
 335 static bool checkValueAtLValForInvariantViolation(ProgramStateRef State,
 336                                                   SVal LV, QualType T) {
 337   if (getNullabilityAnnotation(T) != Nullability::Nonnull)
 338     return false;
 339
 340   auto RegionVal = LV.getAs<loc::MemRegionVal>();
 341   if (!RegionVal)
 342     return false;
 343
 344   auto StoredVal =
 345   State->getSVal(RegionVal->getRegion()).getAs<DefinedOrUnknownSVal>();
 346   if (!StoredVal)
 347     return false;
 348
 349   if (getNullConstraint(*StoredVal, State) == NullConstraint::IsNull)
 350     return true;
 351
 352   return false;
 353 }
 354
 355 static bool
 356 checkParamsForPreconditionViolation(ArrayRef<ParmVarDecl *> Params,
 357                                     ProgramStateRef State,
 358                                     const LocationContext *LocCtxt) {
 359   for (const auto *ParamDecl : Params) {
 360     if (ParamDecl->isParameterPack())
 361       break;
 362
 363     SVal LV = State->getLValue(ParamDecl, LocCtxt);
 364     if (checkValueAtLValForInvariantViolation(State, LV,
 365                                               ParamDecl->getType())) {
 366       return true;
 367     }
 368   }
 369   return false;
 370 }
 371
 372 static bool
 373 checkSelfIvarsForInvariantViolation(ProgramStateRef State,
 374                                     const LocationContext *LocCtxt) {
 375   auto *MD = dyn_cast<ObjCMethodDecl>(LocCtxt->getDecl());
 376   if (!MD || !MD->isInstanceMethod())
 377     return false;
 378
 379   const ImplicitParamDecl *SelfDecl = LocCtxt->getSelfDecl();
 380   if (!SelfDecl)
 381     return false;
 382
 383   SVal SelfVal = State->getSVal(State->getRegion(SelfDecl, LocCtxt));
 384
 385   const ObjCObjectPointerType *SelfType =
 386       dyn_cast<ObjCObjectPointerType>(SelfDecl->getType());
 387   if (!SelfType)
 388     return false;
 389
 390   const ObjCInterfaceDecl *ID = SelfType->getInterfaceDecl();
 391   if (!ID)
 392     return false;
 393
 394   for (const auto *IvarDecl : ID->ivars()) {
 395     SVal LV = State->getLValue(IvarDecl, SelfVal);
 396     if (checkValueAtLValForInvariantViolation(State, LV, IvarDecl->getType())) {
 397       return true;
 398     }
 399   }
 400   return false;
 401 }
 402
 403 static bool checkInvariantViolation(ProgramStateRef State, ExplodedNode *N,
 404                                     CheckerContext &C) {
 405   if (State->get<InvariantViolated>())
 406     return true;
 407
 408   const LocationContext *LocCtxt = C.getLocationContext();
 409   const Decl *D = LocCtxt->getDecl();
 410   if (!D)
 411     return false;
 412
 413   ArrayRef<ParmVarDecl*> Params;
 414   if (const auto *BD = dyn_cast<BlockDecl>(D))
 415     Params = BD->parameters();
 416   else if (const auto *FD = dyn_cast<FunctionDecl>(D))
 417     Params = FD->parameters();
 418   else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
 419     Params = MD->parameters();
 420   else
 421     return false;
 422
 423   if (checkParamsForPreconditionViolation(Params, State, LocCtxt) ||
 424       checkSelfIvarsForInvariantViolation(State, LocCtxt)) {
 425     if (!N->isSink())
 426       C.addTransition(State->set<InvariantViolated>(true), N);
 427     return true;
 428   }
 429   return false;
 430 }
 431
 432 void NullabilityChecker::reportBugIfInvariantHolds(StringRef Msg,
 433     ErrorKind Error, ExplodedNode *N, const MemRegion *Region,
 434     CheckerContext &C, const Stmt *ValueExpr, bool SuppressPath) const {
 435   ProgramStateRef OriginalState = N->getState();
 436
 437   if (checkInvariantViolation(OriginalState, N, C))
 438     return;
 439   if (SuppressPath) {
 440     OriginalState = OriginalState->set<InvariantViolated>(true);
 441     N = C.addTransition(OriginalState, N);
 442   }
 443
 444   reportBug(Msg, Error, N, Region, C.getBugReporter(), ValueExpr);
 445 }
 446
 447 /// Cleaning up the program state.
 448 void NullabilityChecker::checkDeadSymbols(SymbolReaper &SR,
 449                                           CheckerContext &C) const {
 450   if (!SR.hasDeadSymbols())
 451     return;
 452
 453   ProgramStateRef State = C.getState();
 454   NullabilityMapTy Nullabilities = State->get<NullabilityMap>();
 455   for (NullabilityMapTy::iterator I = Nullabilities.begin(),
 456                                   E = Nullabilities.end();
 457        I != E; ++I) {
 458     const auto *Region = I->first->getAs<SymbolicRegion>();
 459     assert(Region && "Non-symbolic region is tracked.");
 460     if (SR.isDead(Region->getSymbol())) {
 461       State = State->remove<NullabilityMap>(I->first);
 462     }
 463   }
 464   // When one of the nonnull arguments are constrained to be null, nullability
 465   // preconditions are violated. It is not enough to check this only when we
 466   // actually report an error, because at that time interesting symbols might be
 467   // reaped.
 468   if (checkInvariantViolation(State, C.getPredecessor(), C))
 469     return;
 470   C.addTransition(State);
 471 }
 472
 473 /// This callback triggers when a pointer is dereferenced and the analyzer does
 474 /// not know anything about the value of that pointer. When that pointer is
 475 /// nullable, this code emits a warning.
 476 void NullabilityChecker::checkEvent(ImplicitNullDerefEvent Event) const {
 477   if (Event.SinkNode->getState()->get<InvariantViolated>())
 478     return;
 479
 480   const MemRegion *Region =
 481       getTrackRegion(Event.Location, /*CheckSuperregion=*/true);
 482   if (!Region)
 483     return;
 484
 485   ProgramStateRef State = Event.SinkNode->getState();
 486   const NullabilityState *TrackedNullability =
 487       State->get<NullabilityMap>(Region);
 488
 489   if (!TrackedNullability)
 490     return;
 491
 492   if (Filter.CheckNullableDereferenced &&
 493       TrackedNullability->getValue() == Nullability::Nullable) {
 494     BugReporter &BR = *Event.BR;
 495     // Do not suppress errors on defensive code paths, because dereferencing
 496     // a nullable pointer is always an error.
 497     if (Event.IsDirectDereference)
 498       reportBug("Nullable pointer is dereferenced",
 499                 ErrorKind::NullableDereferenced, Event.SinkNode, Region, BR);
 500     else {
 501       reportBug("Nullable pointer is passed to a callee that requires a "
 502                 "non-null", ErrorKind::NullablePassedToNonnull,
 503                 Event.SinkNode, Region, BR);
 504     }
 505   }
 506 }
 507
 508 /// Find the outermost subexpression of E that is not an implicit cast.
 509 /// This looks through the implicit casts to _Nonnull that ARC adds to
 510 /// return expressions of ObjC types when the return type of the function or
 511 /// method is non-null but the express is not.
 512 static const Expr *lookThroughImplicitCasts(const Expr *E) {
 513   assert(E);
 514
 515   while (auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
 516     E = ICE->getSubExpr();
 517   }
 518
 519   return E;
 520 }
 521
 522 /// This method check when nullable pointer or null value is returned from a
 523 /// function that has nonnull return type.
 524 void NullabilityChecker::checkPreStmt(const ReturnStmt *S,
 525                                       CheckerContext &C) const {
 526   auto RetExpr = S->getRetValue();
 527   if (!RetExpr)
 528     return;
 529
 530   if (!RetExpr->getType()->isAnyPointerType())
 531     return;
 532
 533   ProgramStateRef State = C.getState();
 534   if (State->get<InvariantViolated>())
 535     return;
 536
 537   auto RetSVal = C.getSVal(S).getAs<DefinedOrUnknownSVal>();
 538   if (!RetSVal)
 539     return;
 540
 541   bool InSuppressedMethodFamily = false;
 542
 543   QualType RequiredRetType;
 544   AnalysisDeclContext *DeclCtxt =
 545       C.getLocationContext()->getAnalysisDeclContext();
 546   const Decl *D = DeclCtxt->getDecl();
 547   if (auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
 548     // HACK: This is a big hammer to avoid warning when there are defensive
 549     // nil checks in -init and -copy methods. We should add more sophisticated
 550     // logic here to suppress on common defensive idioms but still
 551     // warn when there is a likely problem.
 552     ObjCMethodFamily Family = MD->getMethodFamily();
 553     if (OMF_init == Family || OMF_copy == Family || OMF_mutableCopy == Family)
 554       InSuppressedMethodFamily = true;
 555
 556     RequiredRetType = MD->getReturnType();
 557   } else if (auto *FD = dyn_cast<FunctionDecl>(D)) {
 558     RequiredRetType = FD->getReturnType();
 559   } else {
 560     return;
 561   }
 562
 563   NullConstraint Nullness = getNullConstraint(*RetSVal, State);
 564
 565   Nullability RequiredNullability = getNullabilityAnnotation(RequiredRetType);
 566
 567   // If the returned value is null but the type of the expression
 568   // generating it is nonnull then we will suppress the diagnostic.
 569   // This enables explicit suppression when returning a nil literal in a
 570   // function with a _Nonnull return type:
 571   //    return (NSString * _Nonnull)0;
 572   Nullability RetExprTypeLevelNullability =
 573         getNullabilityAnnotation(lookThroughImplicitCasts(RetExpr)->getType());
 574
 575   bool NullReturnedFromNonNull = (RequiredNullability == Nullability::Nonnull &&
 576                                   Nullness == NullConstraint::IsNull);
 577   if (Filter.CheckNullReturnedFromNonnull &&
 578       NullReturnedFromNonNull &&
 579       RetExprTypeLevelNullability != Nullability::Nonnull &&
 580       !InSuppressedMethodFamily &&
 581       C.getLocationContext()->inTopFrame()) {
 582     static CheckerProgramPointTag Tag(this, "NullReturnedFromNonnull");
 583     ExplodedNode *N = C.generateErrorNode(State, &Tag);
 584     if (!N)
 585       return;
 586
 587     SmallString<256> SBuf;
 588     llvm::raw_svector_ostream OS(SBuf);
 589     OS << (RetExpr->getType()->isObjCObjectPointerType() ? "nil" : "Null");
 590     OS << " returned from a " << C.getDeclDescription(D) <<
 591           " that is expected to return a non-null value";
 592     reportBugIfInvariantHolds(OS.str(),
 593                               ErrorKind::NilReturnedToNonnull, N, nullptr, C,
 594                               RetExpr);
 595     return;
 596   }
 597
 598   // If null was returned from a non-null function, mark the nullability
 599   // invariant as violated even if the diagnostic was suppressed.
 600   if (NullReturnedFromNonNull) {
 601     State = State->set<InvariantViolated>(true);
 602     C.addTransition(State);
 603     return;
 604   }
 605
 606   const MemRegion *Region = getTrackRegion(*RetSVal);
 607   if (!Region)
 608     return;
 609
 610   const NullabilityState *TrackedNullability =
 611       State->get<NullabilityMap>(Region);
 612   if (TrackedNullability) {
 613     Nullability TrackedNullabValue = TrackedNullability->getValue();
 614     if (Filter.CheckNullableReturnedFromNonnull &&
 615         Nullness != NullConstraint::IsNotNull &&
 616         TrackedNullabValue == Nullability::Nullable &&
 617         RequiredNullability == Nullability::Nonnull) {
 618       static CheckerProgramPointTag Tag(this, "NullableReturnedFromNonnull");
 619       ExplodedNode *N = C.addTransition(State, C.getPredecessor(), &Tag);
 620
 621       SmallString<256> SBuf;
 622       llvm::raw_svector_ostream OS(SBuf);
 623       OS << "Nullable pointer is returned from a " << C.getDeclDescription(D) <<
 624             " that is expected to return a non-null value";
 625
 626       reportBugIfInvariantHolds(OS.str(),
 627                                 ErrorKind::NullableReturnedToNonnull, N,
 628                                 Region, C);
 629     }
 630     return;
 631   }
 632   if (RequiredNullability == Nullability::Nullable) {
 633     State = State->set<NullabilityMap>(Region,
 634                                        NullabilityState(RequiredNullability,
 635                                                         S));
 636     C.addTransition(State);
 637   }
 638 }
 639
 640 /// This callback warns when a nullable pointer or a null value is passed to a
 641 /// function that expects its argument to be nonnull.
 642 void NullabilityChecker::checkPreCall(const CallEvent &Call,
 643                                       CheckerContext &C) const {
 644   if (!Call.getDecl())
 645     return;
 646
 647   ProgramStateRef State = C.getState();
 648   if (State->get<InvariantViolated>())
 649     return;
 650
 651   ProgramStateRef OrigState = State;
 652
 653   unsigned Idx = 0;
 654   for (const ParmVarDecl *Param : Call.parameters()) {
 655     if (Param->isParameterPack())
 656       break;
 657
 658     if (Idx >= Call.getNumArgs())
 659       break;
 660
 661     const Expr *ArgExpr = Call.getArgExpr(Idx);
 662     auto ArgSVal = Call.getArgSVal(Idx++).getAs<DefinedOrUnknownSVal>();
 663     if (!ArgSVal)
 664       continue;
 665
 666     if (!Param->getType()->isAnyPointerType() &&
 667         !Param->getType()->isReferenceType())
 668       continue;
 669
 670     NullConstraint Nullness = getNullConstraint(*ArgSVal, State);
 671
 672     Nullability RequiredNullability =
 673         getNullabilityAnnotation(Param->getType());
 674     Nullability ArgExprTypeLevelNullability =
 675         getNullabilityAnnotation(ArgExpr->getType());
 676
 677     unsigned ParamIdx = Param->getFunctionScopeIndex() + 1;
 678
 679     if (Filter.CheckNullPassedToNonnull && Nullness == NullConstraint::IsNull &&
 680         ArgExprTypeLevelNullability != Nullability::Nonnull &&
 681         RequiredNullability == Nullability::Nonnull &&
 682         isDiagnosableCall(Call)) {
 683       ExplodedNode *N = C.generateErrorNode(State);
 684       if (!N)
 685         return;
 686
 687       SmallString<256> SBuf;
 688       llvm::raw_svector_ostream OS(SBuf);
 689       OS << (Param->getType()->isObjCObjectPointerType() ? "nil" : "Null");
 690       OS << " passed to a callee that requires a non-null " << ParamIdx
 691          << llvm::getOrdinalSuffix(ParamIdx) << " parameter";
 692       reportBugIfInvariantHolds(OS.str(), ErrorKind::NilPassedToNonnull, N,
 693                                 nullptr, C,
 694                                 ArgExpr, /*SuppressPath=*/false);
 695       return;
 696     }
 697
 698     const MemRegion *Region = getTrackRegion(*ArgSVal);
 699     if (!Region)
 700       continue;
 701
 702     const NullabilityState *TrackedNullability =
 703         State->get<NullabilityMap>(Region);
 704
 705     if (TrackedNullability) {
 706       if (Nullness == NullConstraint::IsNotNull ||
 707           TrackedNullability->getValue() != Nullability::Nullable)
 708         continue;
 709
 710       if (Filter.CheckNullablePassedToNonnull &&
 711           RequiredNullability == Nullability::Nonnull &&
 712           isDiagnosableCall(Call)) {
 713         ExplodedNode *N = C.addTransition(State);
 714         SmallString<256> SBuf;
 715         llvm::raw_svector_ostream OS(SBuf);
 716         OS << "Nullable pointer is passed to a callee that requires a non-null "
 717            << ParamIdx << llvm::getOrdinalSuffix(ParamIdx) << " parameter";
 718         reportBugIfInvariantHolds(OS.str(),
 719                                   ErrorKind::NullablePassedToNonnull, N,
 720                                   Region, C, ArgExpr, /*SuppressPath=*/true);
 721         return;
 722       }
 723       if (Filter.CheckNullableDereferenced &&
 724           Param->getType()->isReferenceType()) {
 725         ExplodedNode *N = C.addTransition(State);
 726         reportBugIfInvariantHolds("Nullable pointer is dereferenced",
 727                                   ErrorKind::NullableDereferenced, N, Region,
 728                                   C, ArgExpr, /*SuppressPath=*/true);
 729         return;
 730       }
 731       continue;
 732     }
 733     // No tracked nullability yet.
 734     if (ArgExprTypeLevelNullability != Nullability::Nullable)
 735       continue;
 736     State = State->set<NullabilityMap>(
 737         Region, NullabilityState(ArgExprTypeLevelNullability, ArgExpr));
 738   }
 739   if (State != OrigState)
 740     C.addTransition(State);
 741 }
 742
 743 /// Suppress the nullability warnings for some functions.
 744 void NullabilityChecker::checkPostCall(const CallEvent &Call,
 745                                        CheckerContext &C) const {
 746   auto Decl = Call.getDecl();
 747   if (!Decl)
 748     return;
 749   // ObjC Messages handles in a different callback.
 750   if (Call.getKind() == CE_ObjCMessage)
 751     return;
 752   const FunctionType *FuncType = Decl->getFunctionType();
 753   if (!FuncType)
 754     return;
 755   QualType ReturnType = FuncType->getReturnType();
 756   if (!ReturnType->isAnyPointerType())
 757     return;
 758   ProgramStateRef State = C.getState();
 759   if (State->get<InvariantViolated>())
 760     return;
 761
 762   const MemRegion *Region = getTrackRegion(Call.getReturnValue());
 763   if (!Region)
 764     return;
 765
 766   // CG headers are misannotated. Do not warn for symbols that are the results
 767   // of CG calls.
 768   const SourceManager &SM = C.getSourceManager();
 769   StringRef FilePath = SM.getFilename(SM.getSpellingLoc(Decl->getLocStart()));
 770   if (llvm::sys::path::filename(FilePath).startswith("CG")) {
 771     State = State->set<NullabilityMap>(Region, Nullability::Contradicted);
 772     C.addTransition(State);
 773     return;
 774   }
 775
 776   const NullabilityState *TrackedNullability =
 777       State->get<NullabilityMap>(Region);
 778
 779   if (!TrackedNullability &&
 780       getNullabilityAnnotation(ReturnType) == Nullability::Nullable) {
 781     State = State->set<NullabilityMap>(Region, Nullability::Nullable);
 782     C.addTransition(State);
 783   }
 784 }
 785
 786 static Nullability getReceiverNullability(const ObjCMethodCall &M,
 787                                           ProgramStateRef State) {
 788   if (M.isReceiverSelfOrSuper()) {
 789     // For super and super class receivers we assume that the receiver is
 790     // nonnull.
 791     return Nullability::Nonnull;
 792   }
 793   // Otherwise look up nullability in the state.
 794   SVal Receiver = M.getReceiverSVal();
 795   if (auto DefOrUnknown = Receiver.getAs<DefinedOrUnknownSVal>()) {
 796     // If the receiver is constrained to be nonnull, assume that it is nonnull
 797     // regardless of its type.
 798     NullConstraint Nullness = getNullConstraint(*DefOrUnknown, State);
 799     if (Nullness == NullConstraint::IsNotNull)
 800       return Nullability::Nonnull;
 801   }
 802   auto ValueRegionSVal = Receiver.getAs<loc::MemRegionVal>();
 803   if (ValueRegionSVal) {
 804     const MemRegion *SelfRegion = ValueRegionSVal->getRegion();
 805     assert(SelfRegion);
 806
 807     const NullabilityState *TrackedSelfNullability =
 808         State->get<NullabilityMap>(SelfRegion);
 809     if (TrackedSelfNullability)
 810       return TrackedSelfNullability->getValue();
 811   }
 812   return Nullability::Unspecified;
 813 }
 814
 815 /// Calculate the nullability of the result of a message expr based on the
 816 /// nullability of the receiver, the nullability of the return value, and the
 817 /// constraints.
 818 void NullabilityChecker::checkPostObjCMessage(const ObjCMethodCall &M,
 819                                               CheckerContext &C) const {
 820   auto Decl = M.getDecl();
 821   if (!Decl)
 822     return;
 823   QualType RetType = Decl->getReturnType();
 824   if (!RetType->isAnyPointerType())
 825     return;
 826
 827   ProgramStateRef State = C.getState();
 828   if (State->get<InvariantViolated>())
 829     return;
 830
 831   const MemRegion *ReturnRegion = getTrackRegion(M.getReturnValue());
 832   if (!ReturnRegion)
 833     return;
 834
 835   auto Interface = Decl->getClassInterface();
 836   auto Name = Interface ? Interface->getName() : "";
 837   // In order to reduce the noise in the diagnostics generated by this checker,
 838   // some framework and programming style based heuristics are used. These
 839   // heuristics are for Cocoa APIs which have NS prefix.
 840   if (Name.startswith("NS")) {
 841     // Developers rely on dynamic invariants such as an item should be available
 842     // in a collection, or a collection is not empty often. Those invariants can
 843     // not be inferred by any static analysis tool. To not to bother the users
 844     // with too many false positives, every item retrieval function should be
 845     // ignored for collections. The instance methods of dictionaries in Cocoa
 846     // are either item retrieval related or not interesting nullability wise.
 847     // Using this fact, to keep the code easier to read just ignore the return
 848     // value of every instance method of dictionaries.
 849     if (M.isInstanceMessage() && Name.contains("Dictionary")) {
 850       State =
 851           State->set<NullabilityMap>(ReturnRegion, Nullability::Contradicted);
 852       C.addTransition(State);
 853       return;
 854     }
 855     // For similar reasons ignore some methods of Cocoa arrays.
 856     StringRef FirstSelectorSlot = M.getSelector().getNameForSlot(0);
 857     if (Name.contains("Array") &&
 858         (FirstSelectorSlot == "firstObject" ||
 859          FirstSelectorSlot == "lastObject")) {
 860       State =
 861           State->set<NullabilityMap>(ReturnRegion, Nullability::Contradicted);
 862       C.addTransition(State);
 863       return;
 864     }
 865
 866     // Encoding related methods of string should not fail when lossless
 867     // encodings are used. Using lossless encodings is so frequent that ignoring
 868     // this class of methods reduced the emitted diagnostics by about 30% on
 869     // some projects (and all of that was false positives).
 870     if (Name.contains("String")) {
 871       for (auto Param : M.parameters()) {
 872         if (Param->getName() == "encoding") {
 873           State = State->set<NullabilityMap>(ReturnRegion,
 874                                              Nullability::Contradicted);
 875           C.addTransition(State);
 876           return;
 877         }
 878       }
 879     }
 880   }
 881
 882   const ObjCMessageExpr *Message = M.getOriginExpr();
 883   Nullability SelfNullability = getReceiverNullability(M, State);
 884
 885   const NullabilityState *NullabilityOfReturn =
 886       State->get<NullabilityMap>(ReturnRegion);
 887
 888   if (NullabilityOfReturn) {
 889     // When we have a nullability tracked for the return value, the nullability
 890     // of the expression will be the most nullable of the receiver and the
 891     // return value.
 892     Nullability RetValTracked = NullabilityOfReturn->getValue();
 893     Nullability ComputedNullab =
 894         getMostNullable(RetValTracked, SelfNullability);
 895     if (ComputedNullab != RetValTracked &&
 896         ComputedNullab != Nullability::Unspecified) {
 897       const Stmt *NullabilitySource =
 898           ComputedNullab == RetValTracked
 899               ? NullabilityOfReturn->getNullabilitySource()
 900               : Message->getInstanceReceiver();
 901       State = State->set<NullabilityMap>(
 902           ReturnRegion, NullabilityState(ComputedNullab, NullabilitySource));
 903       C.addTransition(State);
 904     }
 905     return;
 906   }
 907
 908   // No tracked information. Use static type information for return value.
 909   Nullability RetNullability = getNullabilityAnnotation(RetType);
 910
 911   // Properties might be computed. For this reason the static analyzer creates a
 912   // new symbol each time an unknown property  is read. To avoid false pozitives
 913   // do not treat unknown properties as nullable, even when they explicitly
 914   // marked nullable.
 915   if (M.getMessageKind() == OCM_PropertyAccess && !C.wasInlined)
 916     RetNullability = Nullability::Nonnull;
 917
 918   Nullability ComputedNullab = getMostNullable(RetNullability, SelfNullability);
 919   if (ComputedNullab == Nullability::Nullable) {
 920     const Stmt *NullabilitySource = ComputedNullab == RetNullability
 921                                         ? Message
 922                                         : Message->getInstanceReceiver();
 923     State = State->set<NullabilityMap>(
 924         ReturnRegion, NullabilityState(ComputedNullab, NullabilitySource));
 925     C.addTransition(State);
 926   }
 927 }
 928
 929 /// Explicit casts are trusted. If there is a disagreement in the nullability
 930 /// annotations in the destination and the source or '0' is casted to nonnull
 931 /// track the value as having contraditory nullability. This will allow users to
 932 /// suppress warnings.
 933 void NullabilityChecker::checkPostStmt(const ExplicitCastExpr *CE,
 934                                        CheckerContext &C) const {
 935   QualType OriginType = CE->getSubExpr()->getType();
 936   QualType DestType = CE->getType();
 937   if (!OriginType->isAnyPointerType())
 938     return;
 939   if (!DestType->isAnyPointerType())
 940     return;
 941
 942   ProgramStateRef State = C.getState();
 943   if (State->get<InvariantViolated>())
 944     return;
 945
 946   Nullability DestNullability = getNullabilityAnnotation(DestType);
 947
 948   // No explicit nullability in the destination type, so this cast does not
 949   // change the nullability.
 950   if (DestNullability == Nullability::Unspecified)
 951     return;
 952
 953   auto RegionSVal = C.getSVal(CE).getAs<DefinedOrUnknownSVal>();
 954   const MemRegion *Region = getTrackRegion(*RegionSVal);
 955   if (!Region)
 956     return;
 957
 958   // When 0 is converted to nonnull mark it as contradicted.
 959   if (DestNullability == Nullability::Nonnull) {
 960     NullConstraint Nullness = getNullConstraint(*RegionSVal, State);
 961     if (Nullness == NullConstraint::IsNull) {
 962       State = State->set<NullabilityMap>(Region, Nullability::Contradicted);
 963       C.addTransition(State);
 964       return;
 965     }
 966   }
 967
 968   const NullabilityState *TrackedNullability =
 969       State->get<NullabilityMap>(Region);
 970
 971   if (!TrackedNullability) {
 972     if (DestNullability != Nullability::Nullable)
 973       return;
 974     State = State->set<NullabilityMap>(Region,
 975                                        NullabilityState(DestNullability, CE));
 976     C.addTransition(State);
 977     return;
 978   }
 979
 980   if (TrackedNullability->getValue() != DestNullability &&
 981       TrackedNullability->getValue() != Nullability::Contradicted) {
 982     State = State->set<NullabilityMap>(Region, Nullability::Contradicted);
 983     C.addTransition(State);
 984   }
 985 }
 986
 987 /// For a given statement performing a bind, attempt to syntactically
 988 /// match the expression resulting in the bound value.
 989 static const Expr * matchValueExprForBind(const Stmt *S) {
 990   // For `x = e` the value expression is the right-hand side.
 991   if (auto *BinOp = dyn_cast<BinaryOperator>(S)) {
 992     if (BinOp->getOpcode() == BO_Assign)
 993       return BinOp->getRHS();
 994   }
 995
 996   // For `int x = e` the value expression is the initializer.
 997   if (auto *DS = dyn_cast<DeclStmt>(S))  {
 998     if (DS->isSingleDecl()) {
 999       auto *VD = dyn_cast<VarDecl>(DS->getSingleDecl());
1000       if (!VD)
1001         return nullptr;
1002
1003       if (const Expr *Init = VD->getInit())
1004         return Init;
1005     }
1006   }
1007
1008   return nullptr;
1009 }
1010
1011 /// Returns true if \param S is a DeclStmt for a local variable that
1012 /// ObjC automated reference counting initialized with zero.
1013 static bool isARCNilInitializedLocal(CheckerContext &C, const Stmt *S) {
1014   // We suppress diagnostics for ARC zero-initialized _Nonnull locals. This
1015   // prevents false positives when a _Nonnull local variable cannot be
1016   // initialized with an initialization expression:
1017   //    NSString * _Nonnull s; // no-warning
1018   //    @autoreleasepool {
1019   //      s = ...
1020   //    }
1021   //
1022   // FIXME: We should treat implicitly zero-initialized _Nonnull locals as
1023   // uninitialized in Sema's UninitializedValues analysis to warn when a use of
1024   // the zero-initialized definition will unexpectedly yield nil.
1025
1026   // Locals are only zero-initialized when automated reference counting
1027   // is turned on.
1028   if (!C.getASTContext().getLangOpts().ObjCAutoRefCount)
1029     return false;
1030
1031   auto *DS = dyn_cast<DeclStmt>(S);
1032   if (!DS || !DS->isSingleDecl())
1033     return false;
1034
1035   auto *VD = dyn_cast<VarDecl>(DS->getSingleDecl());
1036   if (!VD)
1037     return false;
1038
1039   // Sema only zero-initializes locals with ObjCLifetimes.
1040   if(!VD->getType().getQualifiers().hasObjCLifetime())
1041     return false;
1042
1043   const Expr *Init = VD->getInit();
1044   assert(Init && "ObjC local under ARC without initializer");
1045
1046   // Return false if the local is explicitly initialized (e.g., with '= nil').
1047   if (!isa<ImplicitValueInitExpr>(Init))
1048     return false;
1049
1050   return true;
1051 }
1052
1053 /// Propagate the nullability information through binds and warn when nullable
1054 /// pointer or null symbol is assigned to a pointer with a nonnull type.
1055 void NullabilityChecker::checkBind(SVal L, SVal V, const Stmt *S,
1056                                    CheckerContext &C) const {
1057   const TypedValueRegion *TVR =
1058       dyn_cast_or_null<TypedValueRegion>(L.getAsRegion());
1059   if (!TVR)
1060     return;
1061
1062   QualType LocType = TVR->getValueType();
1063   if (!LocType->isAnyPointerType())
1064     return;
1065
1066   ProgramStateRef State = C.getState();
1067   if (State->get<InvariantViolated>())
1068     return;
1069
1070   auto ValDefOrUnknown = V.getAs<DefinedOrUnknownSVal>();
1071   if (!ValDefOrUnknown)
1072     return;
1073
1074   NullConstraint RhsNullness = getNullConstraint(*ValDefOrUnknown, State);
1075
1076   Nullability ValNullability = Nullability::Unspecified;
1077   if (SymbolRef Sym = ValDefOrUnknown->getAsSymbol())
1078     ValNullability = getNullabilityAnnotation(Sym->getType());
1079
1080   Nullability LocNullability = getNullabilityAnnotation(LocType);
1081
1082   // If the type of the RHS expression is nonnull, don't warn. This
1083   // enables explicit suppression with a cast to nonnull.
1084   Nullability ValueExprTypeLevelNullability = Nullability::Unspecified;
1085   const Expr *ValueExpr = matchValueExprForBind(S);
1086   if (ValueExpr) {
1087     ValueExprTypeLevelNullability =
1088       getNullabilityAnnotation(lookThroughImplicitCasts(ValueExpr)->getType());
1089   }
1090
1091   bool NullAssignedToNonNull = (LocNullability == Nullability::Nonnull &&
1092                                 RhsNullness == NullConstraint::IsNull);
1093   if (Filter.CheckNullPassedToNonnull &&
1094       NullAssignedToNonNull &&
1095       ValNullability != Nullability::Nonnull &&
1096       ValueExprTypeLevelNullability != Nullability::Nonnull &&
1097       !isARCNilInitializedLocal(C, S)) {
1098     static CheckerProgramPointTag Tag(this, "NullPassedToNonnull");
1099     ExplodedNode *N = C.generateErrorNode(State, &Tag);
1100     if (!N)
1101       return;
1102
1103
1104     const Stmt *ValueStmt = S;
1105     if (ValueExpr)
1106       ValueStmt = ValueExpr;
1107
1108     SmallString<256> SBuf;
1109     llvm::raw_svector_ostream OS(SBuf);
1110     OS << (LocType->isObjCObjectPointerType() ? "nil" : "Null");
1111     OS << " assigned to a pointer which is expected to have non-null value";
1112     reportBugIfInvariantHolds(OS.str(),
1113                               ErrorKind::NilAssignedToNonnull, N, nullptr, C,
1114                               ValueStmt);
1115     return;
1116   }
1117
1118   // If null was returned from a non-null function, mark the nullability
1119   // invariant as violated even if the diagnostic was suppressed.
1120   if (NullAssignedToNonNull) {
1121     State = State->set<InvariantViolated>(true);
1122     C.addTransition(State);
1123     return;
1124   }
1125
1126   // Intentionally missing case: '0' is bound to a reference. It is handled by
1127   // the DereferenceChecker.
1128
1129   const MemRegion *ValueRegion = getTrackRegion(*ValDefOrUnknown);
1130   if (!ValueRegion)
1131     return;
1132
1133   const NullabilityState *TrackedNullability =
1134       State->get<NullabilityMap>(ValueRegion);
1135
1136   if (TrackedNullability) {
1137     if (RhsNullness == NullConstraint::IsNotNull ||
1138         TrackedNullability->getValue() != Nullability::Nullable)
1139       return;
1140     if (Filter.CheckNullablePassedToNonnull &&
1141         LocNullability == Nullability::Nonnull) {
1142       static CheckerProgramPointTag Tag(this, "NullablePassedToNonnull");
1143       ExplodedNode *N = C.addTransition(State, C.getPredecessor(), &Tag);
1144       reportBugIfInvariantHolds("Nullable pointer is assigned to a pointer "
1145                                 "which is expected to have non-null value",
1146                                 ErrorKind::NullableAssignedToNonnull, N,
1147                                 ValueRegion, C);
1148     }
1149     return;
1150   }
1151
1152   const auto *BinOp = dyn_cast<BinaryOperator>(S);
1153
1154   if (ValNullability == Nullability::Nullable) {
1155     // Trust the static information of the value more than the static
1156     // information on the location.
1157     const Stmt *NullabilitySource = BinOp ? BinOp->getRHS() : S;
1158     State = State->set<NullabilityMap>(
1159         ValueRegion, NullabilityState(ValNullability, NullabilitySource));
1160     C.addTransition(State);
1161     return;
1162   }
1163
1164   if (LocNullability == Nullability::Nullable) {
1165     const Stmt *NullabilitySource = BinOp ? BinOp->getLHS() : S;
1166     State = State->set<NullabilityMap>(
1167         ValueRegion, NullabilityState(LocNullability, NullabilitySource));
1168     C.addTransition(State);
1169   }
1170 }
1171
1172 void NullabilityChecker::printState(raw_ostream &Out, ProgramStateRef State,
1173                                     const char *NL, const char *Sep) const {
1174
1175   NullabilityMapTy B = State->get<NullabilityMap>();
1176
1177   if (B.isEmpty())
1178     return;
1179
1180   Out << Sep << NL;
1181
1182   for (NullabilityMapTy::iterator I = B.begin(), E = B.end(); I != E; ++I) {
1183     Out << I->first << " : ";
1184     I->second.print(Out);
1185     Out << NL;
1186   }
1187 }
1188
1189 #define REGISTER_CHECKER(name, trackingRequired)                               \
1190   void ento::register##name##Checker(CheckerManager &mgr) {                    \
1191     NullabilityChecker *checker = mgr.registerChecker<NullabilityChecker>();   \
1192     checker->Filter.Check##name = true;                                        \
1193     checker->Filter.CheckName##name = mgr.getCurrentCheckName();               \
1194     checker->NeedTracking = checker->NeedTracking || trackingRequired;         \
1195     checker->NoDiagnoseCallsToSystemHeaders =                                  \
1196         checker->NoDiagnoseCallsToSystemHeaders ||                             \
1197         mgr.getAnalyzerOptions().getBooleanOption(                             \
1198                       "NoDiagnoseCallsToSystemHeaders", false, checker, true); \
1199   }
1200
1201 // The checks are likely to be turned on by default and it is possible to do
1202 // them without tracking any nullability related information. As an optimization
1203 // no nullability information will be tracked when only these two checks are
1204 // enables.
1205 REGISTER_CHECKER(NullPassedToNonnull, false)
1206 REGISTER_CHECKER(NullReturnedFromNonnull, false)
1207
1208 REGISTER_CHECKER(NullableDereferenced, true)
1209 REGISTER_CHECKER(NullablePassedToNonnull, true)
1210 REGISTER_CHECKER(NullableReturnedFromNonnull, true)