[analyzer][Nullability] Don't emit under the checker name NullabilityBase

[Szelethus]

Summary

Exactly what it says on the tin!

[Szelethus]

Its worth mentioning that the reason I went out of my way not to change the name associated with reports from CallAndMessage, but I changed all of them here is that NullabilityBase is not a user-facing checker.

[martong]

LGTM!

[NoQ]

We're observing a surprising disappearance of nullability reports today - like, they didn't just change the name, they disappeared completely. Investigating.

[Szelethus]

In D78122#2046450, @NoQ wrote:

We're observing a surprising disappearance of nullability reports today - like, they didn't just change the name, they disappeared completely. Investigating.

I landed a lot of patches in the middle of the night, that might be a factor. Say the word if I can help in any way!

[Szelethus]

@NoQ Have you unearthed anything on this matter? Do I need to step in/revert?

[NoQ]

Nope, false alarm! Our buildbot configuration change was at fault. Sorry for forgetting to follow up >.<

clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp

enum class ErrorKind : int {
   NullablePassedToNonnull
 };
 
 class NullabilityChecker
     : public Checker<check::Bind, check::PreCall, check::PreStmt<ReturnStmt>,
                      check::PostCall, check::PostStmt<ExplicitCastExpr>,
                      check::PostObjCMessage, check::DeadSymbols,
                      check::Location, check::Event<ImplicitNullDerefEvent>> {
-  mutable std::unique_ptr<BugType> BT;
 
 public:
   // If true, the checker will not diagnose nullabilility issues for calls
   // to system headers. This option is motivated by the observation that large
   // projects may have many nullability warnings. These projects may
   // find warnings about nullability annotations that they have explicitly
   // added themselves higher priority to fix than warnings on calls to system
   // libraries.
   DefaultBool NoDiagnoseCallsToSystemHeaders;
 
   void checkBind(SVal L, SVal V, const Stmt *S, CheckerContext &C) const;
   void checkPostStmt(const ExplicitCastExpr *CE, CheckerContext &C) const;
   void checkPreStmt(const ReturnStmt *S, CheckerContext &C) const;
   void checkPostObjCMessage(const ObjCMethodCall &M, CheckerContext &C) const;
   void checkPostCall(const CallEvent &Call, CheckerContext &C) const;
   void checkPreCall(const CallEvent &Call, CheckerContext &C) const;
   void checkDeadSymbols(SymbolReaper &SR, CheckerContext &C) const;
   void checkEvent(ImplicitNullDerefEvent Event) const;
   void checkLocation(SVal Location, bool IsLoad, const Stmt *S,
                      CheckerContext &C) const;
 
   void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
                   const char *Sep) const override;
 
-  struct NullabilityChecksFilter {
-    DefaultBool CheckNullPassedToNonnull;
-    DefaultBool CheckNullReturnedFromNonnull;
-    DefaultBool CheckNullableDereferenced;
-    DefaultBool CheckNullablePassedToNonnull;
-    DefaultBool CheckNullableReturnedFromNonnull;
-
-    CheckerNameRef CheckNameNullPassedToNonnull;
-    CheckerNameRef CheckNameNullReturnedFromNonnull;
-    CheckerNameRef CheckNameNullableDereferenced;
-    CheckerNameRef CheckNameNullablePassedToNonnull;
-    CheckerNameRef CheckNameNullableReturnedFromNonnull;
+  enum CheckKind {
+    CK_NullPassedToNonnull,
+    CK_NullReturnedFromNonnull,
+    CK_NullableDereferenced,
+    CK_NullablePassedToNonnull,
+    CK_NullableReturnedFromNonnull,
+    CK_NumCheckKinds
   };
 
-  NullabilityChecksFilter Filter;
+  DefaultBool ChecksEnabled[CK_NumCheckKinds];
+  CheckerNameRef CheckNames[CK_NumCheckKinds];
+  mutable std::unique_ptr<BugType> BTs[CK_NumCheckKinds];
+
+  const std::unique_ptr<BugType> &getBugType(CheckKind Kind) const {
+    if (!BTs[Kind])
+      BTs[Kind].reset(new BugType(CheckNames[Kind], "Nullability",
+                                  categories::MemoryError));
+    return BTs[Kind];
+  }
+
   // When set to false no nullability information will be tracked in
   // NullabilityMap. It is possible to catch errors like passing a null pointer
   // to a callee that expects nonnull argument without the information that is
   // stroed in the NullabilityMap. This is an optimization.
   DefaultBool NeedTracking;
 
 private:
   class NullabilityBugVisitor : public BugReporterVisitor {
private:
     const MemRegion *Region;
   };
 
   /// When any of the nonnull arguments of the analyzed function is null, do not
   /// report anything and turn off the check.
   ///
   /// When \p SuppressPath is set to true, no more bugs will be reported on this
   /// path by this checker.
-  void reportBugIfInvariantHolds(StringRef Msg, ErrorKind Error,
+  void reportBugIfInvariantHolds(StringRef Msg, ErrorKind Error, CheckKind CK,
                                  ExplodedNode *N, const MemRegion *Region,
                                  CheckerContext &C,
                                  const Stmt *ValueExpr = nullptr,
-                                  bool SuppressPath = false) const;
 
-  void reportBug(StringRef Msg, ErrorKind Error, ExplodedNode *N,
+  void reportBug(StringRef Msg, ErrorKind Error, CheckKind CK, ExplodedNode *N,
                  const MemRegion *Region, BugReporter &BR,
                  const Stmt *ValueExpr = nullptr) const {
-    if (!BT)
-      BT.reset(new BugType(this, "Nullability", categories::MemoryError));
-
+    const std::unique_ptr<BugType> &BT = getBugType(CK);
     auto R = std::make_unique<PathSensitiveBugReport>(*BT, Msg, N);
     if (Region) {
       R->markInteresting(Region);
       R->addVisitor(std::make_unique<NullabilityBugVisitor>(Region));
     }
     if (ValueExpr) {
       R->addRange(ValueExpr->getSourceRange());
       if (Error == ErrorKind::NilAssignedToNonnull ||
if (checkParamsForPreconditionViolation(Params, State, LocCtxt) ||
       checkSelfIvarsForInvariantViolation(State, LocCtxt)) {
     if (!N->isSink())
       C.addTransition(State->set<InvariantViolated>(true), N);
     return true;
   }
   return false;
 }
 
-void NullabilityChecker::reportBugIfInvariantHolds(StringRef Msg,
-    ErrorKind Error, ExplodedNode *N, const MemRegion *Region,
-    CheckerContext &C, const Stmt *ValueExpr, bool SuppressPath) const {
+void NullabilityChecker::reportBugIfInvariantHolds(
+    StringRef Msg, ErrorKind Error, CheckKind CK, ExplodedNode *N,
+    const MemRegion *Region, CheckerContext &C, const Stmt *ValueExpr,
+    bool SuppressPath) const {
   ProgramStateRef OriginalState = N->getState();
 
   if (checkInvariantViolation(OriginalState, N, C))
     return;
   if (SuppressPath) {
     OriginalState = OriginalState->set<InvariantViolated>(true);
     N = C.addTransition(OriginalState, N);
   }
 
-  reportBug(Msg, Error, N, Region, C.getBugReporter(), ValueExpr);
+  reportBug(Msg, Error, CK, N, Region, C.getBugReporter(), ValueExpr);
 }
 
 /// Cleaning up the program state.
 void NullabilityChecker::checkDeadSymbols(SymbolReaper &SR,
                                           CheckerContext &C) const {
   ProgramStateRef State = C.getState();
   NullabilityMapTy Nullabilities = State->get<NullabilityMap>();
   for (NullabilityMapTy::iterator I = Nullabilities.begin(),
void NullabilityChecker::checkEvent(ImplicitNullDerefEvent Event) const {
 
   ProgramStateRef State = Event.SinkNode->getState();
   const NullabilityState *TrackedNullability =
       State->get<NullabilityMap>(Region);
 
   if (!TrackedNullability)
     return;
 
-  if (Filter.CheckNullableDereferenced &&
+  if (ChecksEnabled[CK_NullableDereferenced] &&
       TrackedNullability->getValue() == Nullability::Nullable) {
     BugReporter &BR = *Event.BR;
     // Do not suppress errors on defensive code paths, because dereferencing
     // a nullable pointer is always an error.
     if (Event.IsDirectDereference)
       reportBug("Nullable pointer is dereferenced",
-                ErrorKind::NullableDereferenced, Event.SinkNode, Region, BR);
+                ErrorKind::NullableDereferenced, CK_NullableDereferenced,
+                Event.SinkNode, Region, BR);
     else {
       reportBug("Nullable pointer is passed to a callee that requires a "
-                "non-null", ErrorKind::NullablePassedToNonnull,
+                "non-null",
+                ErrorKind::NullablePassedToNonnull, CK_NullableDereferenced,
                 Event.SinkNode, Region, BR);
     }
   }
 }
 
 // Whenever we see a load from a typed memory region that's been annotated as
 // 'nonnull', we want to trust the user on that and assume that it is is indeed
 // non-null.
void NullabilityChecker::checkPreStmt(const ReturnStmt *S,
   // This enables explicit suppression when returning a nil literal in a
   // function with a _Nonnull return type:
   //    return (NSString * _Nonnull)0;
   Nullability RetExprTypeLevelNullability =
         getNullabilityAnnotation(lookThroughImplicitCasts(RetExpr)->getType());
 
   bool NullReturnedFromNonNull = (RequiredNullability == Nullability::Nonnull &&
                                   Nullness == NullConstraint::IsNull);
-  if (Filter.CheckNullReturnedFromNonnull &&
-      NullReturnedFromNonNull &&
+  if (ChecksEnabled[CK_NullReturnedFromNonnull] && NullReturnedFromNonNull &&
       RetExprTypeLevelNullability != Nullability::Nonnull &&
-      !InSuppressedMethodFamily &&
-      C.getLocationContext()->inTopFrame()) {
+      !InSuppressedMethodFamily && C.getLocationContext()->inTopFrame()) {
     static CheckerProgramPointTag Tag(this, "NullReturnedFromNonnull");
     ExplodedNode *N = C.generateErrorNode(State, &Tag);
     if (!N)
       return;
 
     SmallString<256> SBuf;
     llvm::raw_svector_ostream OS(SBuf);
     OS << (RetExpr->getType()->isObjCObjectPointerType() ? "nil" : "Null");
     OS << " returned from a " << C.getDeclDescription(D) <<
           " that is expected to return a non-null value";
-    reportBugIfInvariantHolds(OS.str(),
-                              ErrorKind::NilReturnedToNonnull, N, nullptr, C,
+    reportBugIfInvariantHolds(OS.str(), ErrorKind::NilReturnedToNonnull,
+                              CK_NullReturnedFromNonnull, N, nullptr, C,
                               RetExpr);
     return;
   }
 
   // If null was returned from a non-null function, mark the nullability
   // invariant as violated even if the diagnostic was suppressed.
   if (NullReturnedFromNonNull) {
     State = State->set<InvariantViolated>(true);
     C.addTransition(State);
     return;
   }
 
   const MemRegion *Region = getTrackRegion(*RetSVal);
   if (!Region)
     return;
 
   const NullabilityState *TrackedNullability =
       State->get<NullabilityMap>(Region);
   if (TrackedNullability) {
     Nullability TrackedNullabValue = TrackedNullability->getValue();
-    if (Filter.CheckNullableReturnedFromNonnull &&
+    if (ChecksEnabled[CK_NullableReturnedFromNonnull] &&
         Nullness != NullConstraint::IsNotNull &&
         TrackedNullabValue == Nullability::Nullable &&
         RequiredNullability == Nullability::Nonnull) {
       static CheckerProgramPointTag Tag(this, "NullableReturnedFromNonnull");
       ExplodedNode *N = C.addTransition(State, C.getPredecessor(), &Tag);
 
       SmallString<256> SBuf;
       llvm::raw_svector_ostream OS(SBuf);
       OS << "Nullable pointer is returned from a " << C.getDeclDescription(D) <<
             " that is expected to return a non-null value";
 
-      reportBugIfInvariantHolds(OS.str(),
-                                ErrorKind::NullableReturnedToNonnull, N,
-                                Region, C);
+      reportBugIfInvariantHolds(OS.str(), ErrorKind::NullableReturnedToNonnull,
+                                CK_NullableReturnedFromNonnull, N, Region, C);
     }
     return;
   }
   if (RequiredNullability == Nullability::Nullable) {
     State = State->set<NullabilityMap>(Region,
                                        NullabilityState(RequiredNullability,
                                                         S));
     C.addTransition(State);
for (const ParmVarDecl *Param : Call.parameters()) {
 
     Nullability RequiredNullability =
         getNullabilityAnnotation(Param->getType());
     Nullability ArgExprTypeLevelNullability =
         getNullabilityAnnotation(ArgExpr->getType());
 
     unsigned ParamIdx = Param->getFunctionScopeIndex() + 1;
 
-    if (Filter.CheckNullPassedToNonnull && Nullness == NullConstraint::IsNull &&
+    if (ChecksEnabled[CK_NullPassedToNonnull] &&
+        Nullness == NullConstraint::IsNull &&
         ArgExprTypeLevelNullability != Nullability::Nonnull &&
         RequiredNullability == Nullability::Nonnull &&
         isDiagnosableCall(Call)) {
       ExplodedNode *N = C.generateErrorNode(State);
       if (!N)
         return;
 
       SmallString<256> SBuf;
       llvm::raw_svector_ostream OS(SBuf);
       OS << (Param->getType()->isObjCObjectPointerType() ? "nil" : "Null");
       OS << " passed to a callee that requires a non-null " << ParamIdx
          << llvm::getOrdinalSuffix(ParamIdx) << " parameter";
-      reportBugIfInvariantHolds(OS.str(), ErrorKind::NilPassedToNonnull, N,
-                                nullptr, C,
-                                ArgExpr, /*SuppressPath=*/false);
+      reportBugIfInvariantHolds(OS.str(), ErrorKind::NilPassedToNonnull,
+                                CK_NullPassedToNonnull, N, nullptr, C, ArgExpr,
+                                /*SuppressPath=*/false);
       return;
     }
 
     const MemRegion *Region = getTrackRegion(*ArgSVal);
     if (!Region)
       continue;
 
     const NullabilityState *TrackedNullability =
         State->get<NullabilityMap>(Region);
 
     if (TrackedNullability) {
       if (Nullness == NullConstraint::IsNotNull ||
           TrackedNullability->getValue() != Nullability::Nullable)
         continue;
 
-      if (Filter.CheckNullablePassedToNonnull &&
+      if (ChecksEnabled[CK_NullablePassedToNonnull] &&
           RequiredNullability == Nullability::Nonnull &&
           isDiagnosableCall(Call)) {
         ExplodedNode *N = C.addTransition(State);
         SmallString<256> SBuf;
         llvm::raw_svector_ostream OS(SBuf);
         OS << "Nullable pointer is passed to a callee that requires a non-null "
            << ParamIdx << llvm::getOrdinalSuffix(ParamIdx) << " parameter";
-        reportBugIfInvariantHolds(OS.str(),
-                                  ErrorKind::NullablePassedToNonnull, N,
-                                  Region, C, ArgExpr, /*SuppressPath=*/true);
+        reportBugIfInvariantHolds(OS.str(), ErrorKind::NullablePassedToNonnull,
+                                  CK_NullablePassedToNonnull, N, Region, C,
+                                  ArgExpr, /*SuppressPath=*/true);
         return;
       }
-      if (Filter.CheckNullableDereferenced &&
+      if (ChecksEnabled[CK_NullableDereferenced] &&
           Param->getType()->isReferenceType()) {
         ExplodedNode *N = C.addTransition(State);
         reportBugIfInvariantHolds("Nullable pointer is dereferenced",
-                                  ErrorKind::NullableDereferenced, N, Region,
-                                  C, ArgExpr, /*SuppressPath=*/true);
+                                  ErrorKind::NullableDereferenced,
+                                  CK_NullableDereferenced, N, Region, C,
+                                  ArgExpr, /*SuppressPath=*/true);
         return;
       }
       continue;
     }
   }
   if (State != OrigState)
     C.addTransition(State);
 }
void NullabilityChecker::checkBind(SVal L, SVal V, const Stmt *S,
   const Expr *ValueExpr = matchValueExprForBind(S);
   if (ValueExpr) {
     ValueExprTypeLevelNullability =
       getNullabilityAnnotation(lookThroughImplicitCasts(ValueExpr)->getType());
   }
 
   bool NullAssignedToNonNull = (LocNullability == Nullability::Nonnull &&
                                 RhsNullness == NullConstraint::IsNull);
-  if (Filter.CheckNullPassedToNonnull &&
-      NullAssignedToNonNull &&
+  if (ChecksEnabled[CK_NullPassedToNonnull] && NullAssignedToNonNull &&
       ValNullability != Nullability::Nonnull &&
       ValueExprTypeLevelNullability != Nullability::Nonnull &&
       !isARCNilInitializedLocal(C, S)) {
     static CheckerProgramPointTag Tag(this, "NullPassedToNonnull");
     ExplodedNode *N = C.generateErrorNode(State, &Tag);
     if (!N)
       return;
 
 
     const Stmt *ValueStmt = S;
     if (ValueExpr)
       ValueStmt = ValueExpr;
 
     SmallString<256> SBuf;
     llvm::raw_svector_ostream OS(SBuf);
     OS << (LocType->isObjCObjectPointerType() ? "nil" : "Null");
     OS << " assigned to a pointer which is expected to have non-null value";
-    reportBugIfInvariantHolds(OS.str(),
-                              ErrorKind::NilAssignedToNonnull, N, nullptr, C,
-                              ValueStmt);
+    reportBugIfInvariantHolds(OS.str(), ErrorKind::NilAssignedToNonnull,
+                              CK_NullPassedToNonnull, N, nullptr, C, ValueStmt);
     return;
   }
 
   // If null was returned from a non-null function, mark the nullability
   // invariant as violated even if the diagnostic was suppressed.
   if (NullAssignedToNonNull) {
     State = State->set<InvariantViolated>(true);
     C.addTransition(State);
void NullabilityChecker::checkBind(SVal L, SVal V, const Stmt *S,
 
   const NullabilityState *TrackedNullability =
       State->get<NullabilityMap>(ValueRegion);
 
   if (TrackedNullability) {
     if (RhsNullness == NullConstraint::IsNotNull ||
         TrackedNullability->getValue() != Nullability::Nullable)
       return;
-    if (Filter.CheckNullablePassedToNonnull &&
+    if (ChecksEnabled[CK_NullablePassedToNonnull] &&
         LocNullability == Nullability::Nonnull) {
       static CheckerProgramPointTag Tag(this, "NullablePassedToNonnull");
       ExplodedNode *N = C.addTransition(State, C.getPredecessor(), &Tag);
       reportBugIfInvariantHolds("Nullable pointer is assigned to a pointer "
                                 "which is expected to have non-null value",
-                                ErrorKind::NullableAssignedToNonnull, N,
-                                ValueRegion, C);
+                                ErrorKind::NullableAssignedToNonnull,
+                                CK_NullablePassedToNonnull, N, ValueRegion, C);
     }
     return;
   }
 
   const auto *BinOp = dyn_cast<BinaryOperator>(S);
 
   if (ValNullability == Nullability::Nullable) {
     // Trust the static information of the value more than the static

 
 bool ento::shouldRegisterNullabilityBase(const CheckerManager &mgr) {
   return true;
 }
 
 #define REGISTER_CHECKER(name, trackingRequired)                               \
   void ento::register##name##Checker(CheckerManager &mgr) {                    \
     NullabilityChecker *checker = mgr.getChecker<NullabilityChecker>();        \
-    checker->Filter.Check##name = true;                                        \
-    checker->Filter.CheckName##name = mgr.getCurrentCheckerName();             \
+    checker->ChecksEnabled[NullabilityChecker::CK_##name] = true;              \
+    checker->CheckNames[NullabilityChecker::CK_##name] =                       \
+        mgr.getCurrentCheckerName();                                           \
     checker->NeedTracking = checker->NeedTracking || trackingRequired;         \
     checker->NoDiagnoseCallsToSystemHeaders =                                  \
         checker->NoDiagnoseCallsToSystemHeaders ||                             \
         mgr.getAnalyzerOptions().getCheckerBooleanOption(                      \
             checker, "NoDiagnoseCallsToSystemHeaders", true);                  \
   }                                                                            \
                                                                                \
-  bool ento::shouldRegister##name##Checker(const CheckerManager &mgr) {            \
+  bool ento::shouldRegister##name##Checker(const CheckerManager &mgr) {        \
     return true;                                                               \
   }
 
 // The checks are likely to be turned on by default and it is possible to do
 // them without tracking any nullability related information. As an optimization
 // no nullability information will be tracked when only these two checks are
 // enables.
 REGISTER_CHECKER(NullPassedToNonnull, false)
 REGISTER_CHECKER(NullReturnedFromNonnull, false)
 
 REGISTER_CHECKER(NullableDereferenced, true)
 REGISTER_CHECKER(NullablePassedToNonnull, true)
 REGISTER_CHECKER(NullableReturnedFromNonnull, true)

clang/test/Analysis/Inputs/expected-plists/nullability-notes.m.plist

<array>
      <string>Nullable pointer is passed to a callee that requires a non-null 1st parameter</string>
      <key>message</key>
      <string>Nullable pointer is passed to a callee that requires a non-null 1st parameter</string>
     </dict>
    </array>
    <key>description</key><string>Nullable pointer is passed to a callee that requires a non-null 1st parameter</string>
    <key>category</key><string>Memory error</string>
    <key>type</key><string>Nullability</string>
-   <key>check_name</key><string>nullability.NullabilityBase</string>
+   <key>check_name</key><string>nullability.NullablePassedToNonnull</string>
    <!-- This hash is experimental and going to change! -->
-   <key>issue_hash_content_of_line_in_context</key><string>ff735bea0eb12d4d172b139143c32365</string>
+   <key>issue_hash_content_of_line_in_context</key><string>cff860dfd96389c0fc88f9c04b609f87</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>method</string>
   <key>issue_hash_function_offset</key><string>6</string>
   <key>location</key>
   <dict>
    <key>line</key><integer>36</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>

clang/test/Analysis/incorrect-checker-names.mm

 
 void testBasicRules() {
   // FIXME: None of these should be tied to a modeling checker.
   Dummy *p = returnsNullable();
   int *ptr = returnsNullableInt();
   // Make every dereference a different path to avoid sinks after errors.
   switch (getRandom()) {
   case 0: {
-    Dummy &r = *p; // expected-warning {{Nullable pointer is dereferenced [nullability.NullabilityBase]}}
+    Dummy &r = *p; // expected-warning {{Nullable pointer is dereferenced [nullability.NullableDereferenced]}}
   } break;
   case 1: {
-    int b = p->val; // expected-warning {{Nullable pointer is dereferenced [nullability.NullabilityBase]}}
+    int b = p->val; // expected-warning {{Nullable pointer is dereferenced [nullability.NullableDereferenced]}}
   } break;
   case 2: {
-    int stuff = *ptr; // expected-warning {{Nullable pointer is dereferenced [nullability.NullabilityBase]}}
+    int stuff = *ptr; // expected-warning {{Nullable pointer is dereferenced [nullability.NullableDereferenced]}}
   } break;
   case 3:
-    takesNonnull(p); // expected-warning {{Nullable pointer is passed to a callee that requires a non-null 1st parameter [nullability.NullabilityBase]}}
+    takesNonnull(p); // expected-warning {{Nullable pointer is passed to a callee that requires a non-null 1st parameter [nullability.NullablePassedToNonnull]}}
     break;
   case 4: {
     Dummy d;
     takesNullable(&d);
     Dummy dd(d);
     break;
   }
-  case 5: takesAttrNonnull(p); break; // expected-warning {{Nullable pointer is passed to a callee that requires a non-null [nullability.NullabilityBase]}}
-  default: { Dummy d = *p; } break; // expected-warning {{Nullable pointer is dereferenced [nullability.NullabilityBase]}}
+  case 5:
+    takesAttrNonnull(p); // expected-warning {{Nullable pointer is passed to a callee that requires a non-null [nullability.NullableDereferenced]}}
+    break;
+  default: { Dummy d = *p; } break; // expected-warning {{Nullable pointer is dereferenced [nullability.NullableDereferenced]}}
   }
   if (p) {
     takesNonnull(p);
     if (getRandom()) {
       Dummy &r = *p;
     } else {
       int b = p->val;
     }
   }
   Dummy *q = 0;
   if (getRandom()) {
     takesNullable(q);
   // FIXME: This shouldn't be tied to a modeling checker.
-    takesNonnull(q); // expected-warning {{Null passed to a callee that requires a non-null 1st parameter [nullability.NullabilityBase]}}
+    takesNonnull(q); // expected-warning {{Null passed to a callee that requires a non-null 1st parameter [nullability.NullPassedToNonnull]}}
   }
   Dummy a;
   Dummy *_Nonnull nonnull = &a;
   // FIXME: This shouldn't be tied to a modeling checker.
-  nonnull = q; // expected-warning {{Null assigned to a pointer which is expected to have non-null value [nullability.NullabilityBase]}}
+  nonnull = q; // expected-warning {{Null assigned to a pointer which is expected to have non-null value [nullability.NullPassedToNonnull]}}
   q = &a;
   takesNullable(q);
   takesNonnull(q);
 }
 
 typedef int NSInteger;
 typedef struct _NSZone NSZone;
 @class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator;