Rename to pending

Author: Your Name

lib/analyzer.h

@@ -156,13 +156,14 @@ struct Analyzer {
             Quiet = (1 << 0),
             Absolute = (1 << 1),
             ContainerEmpty = (1 << 2),
-            // Do not record the program state at the branch boundaries. Used when assuming a
-            // condition before the branch is traversed, where those states would be premature.
-            // When this is not set the branch has already been traversed and control is continuing
-            // past it, so the assumed state is anchored at the block's end (see the analyzer's
-            // assume()): this keeps assumptions on variables modified inside the block from being
-            // discarded as "modified" once control leaves it.
-            NoState = (1 << 3),
+            // The branch this condition guards is still pending traversal (it is walked by a
+            // separate path), so this assume must not record the program state at the branch
+            // boundaries - those states would be premature. When this is not set the branch has
+            // already been traversed and control is continuing past it, so the assumed state is
+            // anchored at the block's end (see the analyzer's assume()): this keeps assumptions on
+            // variables modified inside the block from being discarded as "modified" once control
+            // leaves it.
+            Pending = (1 << 3),
         };
     };
 

lib/forwardanalyzer.cpp

@@ -793,15 +793,15 @@ namespace {
                             // mode: the branch's effect is still tracked but nothing is reported in it.
                             ForwardTraversal ft = fork(!analyzer->updateScope(thenBranch.endBlock, false));
                             // The branch is traversed below, so don't record its boundary state here.
-                            ft.analyzer->assume(condTok, true, Analyzer::Assume::NoState);
+                            ft.analyzer->assume(condTok, true, Analyzer::Assume::Pending);
                             Progress pThen = ft.updateBranch(thenBranch, depth - 1);
 
                             // Only commit the condition as false on the main path when it actually
                             // matters. With an else the else block is traversed below (so suppress the
                             // boundary state); without one the false path continues past the closing
                             // brace and must record the assumed state there.
                             if (thenBranch.isDead())
-                                analyzer->assume(condTok, false, hasElse ? Analyzer::Assume::NoState : Analyzer::Assume::None);
+                                analyzer->assume(condTok, false, hasElse ? Analyzer::Assume::Pending : Analyzer::Assume::None);
                             // The else block is traversed on the main path. If it kills the value
                             // (modified) the main path stops, but the then-fork may still carry the
                             // value forward, so defer the break until after the fork continues.

lib/vf_analyzers.cpp

@@ -743,12 +743,12 @@ struct ValueFlowAnalyzer : Analyzer {
             endBlock = startBlock->link();
         }
 
-        // NoState is set only for the pre-traversal assume; without it the 'then' block has already
+        // Pending is set only for the pre-traversal assume; without it the 'then' block has already
         // been traversed and control is leaving it, so anchor the assumed state at the end of the
         // block rather than at the condition. Assumptions about variables modified inside the block
         // (e.g. an 'if' that narrows a value computed in the block) then survive past it, instead of
         // being discarded because the variable was "modified" since the condition was evaluated.
-        const bool scopeEnd = !(flags & Assume::NoState) && state && endBlock;
+        const bool scopeEnd = !(flags & Assume::Pending) && state && endBlock;
         const Token* anchor = scopeEnd ? endBlock : tok;
         const Token* origin = scopeEnd ? endBlock : nullptr;
 
@@ -760,7 +760,7 @@ struct ValueFlowAnalyzer : Analyzer {
         // On the false path the block was already traversed (the true path is handled by scopeEnd
         // above), so record the assumed state where control continues: past the else block, or past
         // the closing brace when there is no else, so it is available to the enclosing scope.
-        if (isCondBlock && !(flags & Assume::NoState) && !state) {
+        if (isCondBlock && !(flags & Assume::Pending) && !state) {
             if (Token::simpleMatch(endBlock, "} else {"))
                 pms.addState(endBlock->linkAt(2)->previous(), getProgramState());
             else