Fix the same problem in local propagation

Just one diff, missing null check elimination: we propagated a field
sequence for an array address (PtrToArrElem) that later wasn't recognized
as implying non-nullness of another PtrToArrElem to the same array.

Author: SingleAccretion

src/coreclr/jit/assertionprop.cpp

@@ -1062,6 +1062,11 @@ void Compiler::optPrintAssertion(AssertionDsc* curAssertion, AssertionIndex asse
                 {
                     printf(".%02u", curAssertion->op1.lcl.ssaNum);
                 }
+                if (curAssertion->op2.zeroOffsetFieldSeq != nullptr)
+                {
+                    printf(" Zero");
+                    gtDispFieldSeq(curAssertion->op2.zeroOffsetFieldSeq);
+                }
                 break;
 
             case O2K_CONST_INT:
@@ -1582,10 +1587,14 @@ AssertionIndex Compiler::optCreateAssertion(GenTree*         op1,
                         goto DONE_ASSERTION; // Don't make an assertion
                     }
 
-                    assertion.op2.kind       = O2K_LCLVAR_COPY;
-                    assertion.op2.lcl.lclNum = lclNum2;
-                    assertion.op2.vn         = vnStore->VNConservativeNormalValue(op2->gtVNPair);
-                    assertion.op2.lcl.ssaNum = op2->AsLclVarCommon()->GetSsaNum();
+                    FieldSeqNode* zeroOffsetFieldSeq = nullptr;
+                    GetZeroOffsetFieldMap()->Lookup(op2, &zeroOffsetFieldSeq);
+
+                    assertion.op2.kind               = O2K_LCLVAR_COPY;
+                    assertion.op2.vn                 = vnStore->VNConservativeNormalValue(op2->gtVNPair);
+                    assertion.op2.lcl.lclNum         = lclNum2;
+                    assertion.op2.lcl.ssaNum         = op2->AsLclVarCommon()->GetSsaNum();
+                    assertion.op2.zeroOffsetFieldSeq = zeroOffsetFieldSeq;
 
                     // Ok everything has been set and the assertion looks good
                     assertion.assertionKind = assertionKind;
@@ -3316,14 +3325,30 @@ GenTree* Compiler::optCopyAssertionProp(AssertionDsc*        curAssertion,
         return nullptr;
     }
 
-    // Extract the matching lclNum and ssaNum.
-    const unsigned copyLclNum = (op1.lcl.lclNum == lclNum) ? op2.lcl.lclNum : op1.lcl.lclNum;
-    unsigned       copySsaNum = SsaConfig::RESERVED_SSA_NUM;
+    // Extract the matching lclNum and ssaNum, as well as the field sequence.
+    unsigned      copyLclNum;
+    unsigned      copySsaNum;
+    FieldSeqNode* zeroOffsetFieldSeq;
+    if (op1.lcl.lclNum == lclNum)
+    {
+        copyLclNum         = op2.lcl.lclNum;
+        copySsaNum         = op2.lcl.ssaNum;
+        zeroOffsetFieldSeq = op2.zeroOffsetFieldSeq;
+    }
+    else
+    {
+        copyLclNum         = op1.lcl.lclNum;
+        copySsaNum         = op1.lcl.ssaNum;
+        zeroOffsetFieldSeq = nullptr;  // Only the RHS of an assignment can have a FldSeq.
+        assert(optLocalAssertionProp); // Were we to perform replacements in global propagation, that makes copy
+                                       // assertions for control flow ("if (a == b) { ... }"), where both operands
+                                       // could have a FldSeq, we'd need to save it for "op1" too.
+    }
+
     if (!optLocalAssertionProp)
     {
         // Extract the ssaNum of the matching lclNum.
         unsigned ssaNum = (op1.lcl.lclNum == lclNum) ? op1.lcl.ssaNum : op2.lcl.ssaNum;
-        copySsaNum      = (op1.lcl.lclNum == lclNum) ? op2.lcl.ssaNum : op1.lcl.ssaNum;
 
         if (ssaNum != tree->GetSsaNum())
         {
@@ -3349,12 +3374,25 @@ GenTree* Compiler::optCopyAssertionProp(AssertionDsc*        curAssertion,
     tree->SetLclNum(copyLclNum);
     tree->SetSsaNum(copySsaNum);
 
+    // The sequence we are propagating (if any) represents the inner fields.
+    if (zeroOffsetFieldSeq != nullptr)
+    {
+        FieldSeqNode* outerZeroOffsetFieldSeq = nullptr;
+        if (GetZeroOffsetFieldMap()->Lookup(tree, &outerZeroOffsetFieldSeq))
+        {
+            zeroOffsetFieldSeq = GetFieldSeqStore()->Append(zeroOffsetFieldSeq, outerZeroOffsetFieldSeq);
+            GetZeroOffsetFieldMap()->Remove(tree);
+        }
+
+        fgAddFieldSeqForZeroOffset(tree, zeroOffsetFieldSeq);
+    }
+
 #ifdef DEBUG
     if (verbose)
     {
         printf("\nAssertion prop in " FMT_BB ":\n", compCurBB->bbNum);
         optPrintAssertion(curAssertion, index);
-        gtDispTree(tree, nullptr, nullptr, true);
+        DISPNODE(tree);
     }
 #endif
 
@@ -4665,15 +4703,15 @@ GenTree* Compiler::optAssertionProp(ASSERT_VALARG_TP assertions, GenTree* tree,
 }
 
 //------------------------------------------------------------------------
-// optImpliedAssertions: Given a tree node that makes an assertion this
-//                       method computes the set of implied assertions
-//                       that are also true. The updated assertions are
-//                       maintained on the Compiler object.
+// optImpliedAssertions: Given an assertion this method computes the set
+//                       of implied assertions that are also true.
 //
 // Arguments:
 //      assertionIndex   : The id of the assertion.
 //      activeAssertions : The assertions that are already true at this point.
-
+//                         This method will add the discovered implied assertions
+//                         to this set.
+//
 void Compiler::optImpliedAssertions(AssertionIndex assertionIndex, ASSERT_TP& activeAssertions)
 {
     noway_assert(!optLocalAssertionProp);
@@ -4822,7 +4860,6 @@ void Compiler::optImpliedByTypeOfAssertions(ASSERT_TP& activeAssertions)
 // Return Value:
 //      The assertions we have about the value number.
 //
-
 ASSERT_VALRET_TP Compiler::optGetVnMappedAssertions(ValueNum vn)
 {
     ASSERT_TP set = BitVecOps::UninitVal();

src/coreclr/jit/compiler.h

@@ -7626,7 +7626,6 @@ class Compiler
         O2K_CONST_INT,
         O2K_CONST_LONG,
         O2K_CONST_DOUBLE,
-        O2K_ARR_LEN,
         O2K_SUBRANGE,
         O2K_COUNT
     };
@@ -7666,7 +7665,11 @@ class Compiler
                 GenTreeFlags iconFlags; // gtFlags
             };
             union {
-                SsaVar        lcl;
+                struct
+                {
+                    SsaVar        lcl;
+                    FieldSeqNode* zeroOffsetFieldSeq;
+                };
                 IntVal        u1;
                 __int64       lconVal;
                 double        dconVal;
@@ -7745,6 +7748,7 @@ class Compiler
             {
                 return false;
             }
+
             switch (op2.kind)
             {
                 case O2K_IND_CNS_INT:
@@ -7759,9 +7763,9 @@ class Compiler
                     return (memcmp(&op2.dconVal, &that->op2.dconVal, sizeof(double)) == 0);
 
                 case O2K_LCLVAR_COPY:
-                case O2K_ARR_LEN:
                     return (op2.lcl.lclNum == that->op2.lcl.lclNum) &&
-                           (!vnBased || op2.lcl.ssaNum == that->op2.lcl.ssaNum);
+                           (!vnBased || op2.lcl.ssaNum == that->op2.lcl.ssaNum) &&
+                           (op2.zeroOffsetFieldSeq == that->op2.zeroOffsetFieldSeq);
 
                 case O2K_SUBRANGE:
                     return op2.u2.Equals(that->op2.u2);
@@ -7774,6 +7778,7 @@ class Compiler
                     assert(!"Unexpected value for op2.kind in AssertionDsc.");
                     break;
             }
+
             return false;
         }