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