[analyzer] Do not crash if the assumption added in TrustNonNullChecker is enough to make the state unfeasible

[george.karpenkov]

Summary

rdar://43541814

[george.karpenkov]

For the record, it's not particularly obvious that state->assume can return nullptr.

[NoQ]

Aha, yep, that should have been checked. Returning null state from evalAssume() is the correct thing to do when you want to generate a sink. But you should be careful not to put null state into C.addTransition(), because that won't generate a sink as you might expect.

[MaskRay]

This change appears to break test/Analysis/trustnonnullchecker_test.m in non-optimized (OPTIMIZE not defined) mode. Can you take a look?

lib/StaticAnalyzer/Checkers/TrustNonnullChecker.cpp

private:
 
 
   /// \return a state with an optional implication added (if exists)
   /// from a map of recorded implications.
   /// If \p Negated is true, checks NullImplicationMap, and assumes
   /// the negation of \p Antecedent.
   /// Checks NonNullImplicationMap and assumes \p Antecedent otherwise.
   ProgramStateRef addImplication(SymbolRef Antecedent,
-                                 ProgramStateRef State,
+                                 ProgramStateRef InputState,
                                  bool Negated) const {
-    SValBuilder &SVB = State->getStateManager().getSValBuilder();
+    if (!InputState)
+      return nullptr;
+    SValBuilder &SVB = InputState->getStateManager().getSValBuilder();
     const SymbolRef *Consequent =
-        Negated ? State->get<NonNullImplicationMap>(Antecedent)
-                : State->get<NullImplicationMap>(Antecedent);
+        Negated ? InputState->get<NonNullImplicationMap>(Antecedent)
+                : InputState->get<NullImplicationMap>(Antecedent);
     if (!Consequent)
-      return State;
+      return InputState;
 
     SVal AntecedentV = SVB.makeSymbolVal(Antecedent);
-    if ((Negated && State->isNonNull(AntecedentV).isConstrainedTrue())
-        || (!Negated && State->isNull(AntecedentV).isConstrainedTrue())) {
+    ProgramStateRef State = InputState;
+
+    if ((Negated && InputState->isNonNull(AntecedentV).isConstrainedTrue())
+        || (!Negated && InputState->isNull(AntecedentV).isConstrainedTrue())) {
       SVal ConsequentS = SVB.makeSymbolVal(*Consequent);
-      State = State->assume(ConsequentS.castAs<DefinedSVal>(), Negated);
+      State = InputState->assume(ConsequentS.castAs<DefinedSVal>(), Negated);
+      if (!State)
+        return nullptr;
 
       // Drop implications from the map.
       if (Negated) {
         State = State->remove<NonNullImplicationMap>(Antecedent);
         State = State->remove<NullImplicationMap>(*Consequent);
       } else {
         State = State->remove<NullImplicationMap>(Antecedent);
         State = State->remove<NonNullImplicationMap>(*Consequent);

test/Analysis/trustnonnullchecker_test.m

 
 NSString *_Nonnull checkAssumeOnMutableDictionaryOtherMethod(NSMutableDictionary *d,
                                                              NSString *k,
                                                              NSString *val) {
   [d setObject:val forKey:k];
   if (k) {}
   return k; // no-warning
 }
+
+// Check that we don't crash when the added assumption is enough
+// to make the state unfeasible.
+@class DummyClass;
+@interface DictionarySubclass : NSDictionary {
+  DummyClass *g;
+  DictionarySubclass *d;
+}
+@end
+@implementation DictionarySubclass
+- (id) objectForKey:(id)e {
+  if (e) {}
+  return d;
+}
+- (void) coder {
+  for (id e in g) {
+    id f = [self objectForKey:e];
+    if (f)
+      (void)e;
+  }
+}
+@end