Introduce temporary bindings to BoundsCastExprs (#694)

Cherry-picked from commit 82f665e
Author: Katherine Kjeer <[email protected]>
Commit: GitHub <[email protected]>

    Introduce temporary bindings to BoundsCastExprs (#694)

    * Account for cast kind in StmtProfiler::VisitBoundsCastExpr and CanonBounds::CompareImpl

    * Don't treat dynamic and assume bounds casts as value preserving; don't compare types on bounds expressions

    * Introduce a temporary binding expression for all bounds cast expressions

    * Use the temporary bindings introduced in bounds cast expressions to infer bounds

    * Remove unused PruneTemporaryBindings

    * Treat e and the usage of a temporary binding of e as equal

    * Remove llvm_unreachable from CanonBounds::Compare

    * Account for bounds cast expressions in GetTempBinding

    * Treat bounds casts as value preserving in CheckBoundsDelarations::EqualValue (introducing the assumption that E1 and E2 have been evaluated)

    * Remove function call test from bounds-decl-challenges

    * Add AST dump tests for bounds cast expression temporaries

    * Fix indentation

    * More formatting fixes

    * Revert treating bounds casts as value preserving in EqualValue

    * Add comment about lack of bounds expression types

    * Prune temporary bindings from member expression bounds

    * Account for checked scope information in PruneTemporaryBindings

Author: kkjeer

clang/include/clang/AST/CanonBounds.h

@@ -62,7 +62,6 @@ namespace clang {
       const T *E1 = dyn_cast<T>(Raw1);
       const T *E2 = dyn_cast<T>(Raw2);
       if (!E1 || !E2) {
-        llvm_unreachable("dyn_cast failed");
         return Result::LessThan;
       }
       return Lexicographic::CompareImpl(E1, E2);

clang/include/clang/Sema/Sema.h

@@ -4951,7 +4951,7 @@ class Sema {
   /// InferLValueBounds - infer a bounds expression for an lvalue.
   /// The bounds determine whether the lvalue to which an
   /// expression evaluates in in range.
-  BoundsExpr *InferLValueBounds(Expr *E);
+  BoundsExpr *InferLValueBounds(Expr *E, bool InCheckedScope);
 
   /// CreateTypeBasedBounds: the bounds that can be inferred from
   /// the type alone.
@@ -4975,7 +4975,7 @@ class Sema {
 
   /// InferLValueTargetBounds - infer the bounds for the
   /// target of an lvalue.
-  BoundsExpr *InferLValueTargetBounds(Expr *E);
+  BoundsExpr *InferLValueTargetBounds(Expr *E, bool InCheckedScope);
 
   /// InferRValueBounds - infer a bounds expression for an rvalue.
   /// The bounds determine whether the rvalue to which an
@@ -4985,6 +4985,7 @@ class Sema {
   /// for an nt_array is included in the bounds (it gives
   /// us physical bounds, not logical bounds).
   BoundsExpr *InferRValueBounds(Expr *E,
+                                bool InCheckedScope,
                                 bool IncludeNullTerminator = false);
 
   BoundsExpr *ExpandToRange(Expr *Base, BoundsExpr *B);

clang/lib/AST/CanonBounds.cpp

@@ -36,8 +36,6 @@ namespace {
       case CK_ArrayToPointerDecay:
       case CK_FunctionToPointerDecay:
       case CK_NullToPointer:
-      case CK_AssumePtrBounds:
-      case CK_DynamicPtrBounds:
         return true;
       default:
         return false;
@@ -323,14 +321,26 @@ Result Lexicographic::CompareExpr(const Expr *Arg1, const Expr *Arg2) {
 
   // The use of an expression temporary is equal to the
   // value of the binding expression.
-  if (BoundsValueExpr *BV1 = dyn_cast<BoundsValueExpr>(E1))
-    if (BV1->getTemporaryBinding() == E2)
+  if (BoundsValueExpr *BV1 = dyn_cast<BoundsValueExpr>(E1)) {
+    CHKCBindTemporaryExpr *Binding = BV1->getTemporaryBinding();
+    if (Binding == E2)
       return Result::Equal;
 
-  if (BoundsValueExpr *BV2 = dyn_cast<BoundsValueExpr>(E2))
-    if (BV2->getTemporaryBinding() == E1)
+    if (Binding)
+      if (CompareExpr(Binding->getSubExpr(), E2) == Result::Equal)
+        return Result::Equal;
+  }
+  
+  if (BoundsValueExpr *BV2 = dyn_cast<BoundsValueExpr>(E2)) {
+    CHKCBindTemporaryExpr *Binding = BV2->getTemporaryBinding();
+    if (Binding == E1)
       return Result::Equal;
 
+    if (Binding)
+      if (CompareExpr(Binding->getSubExpr(), E1) == Result::Equal)
+        return Result::Equal;
+  }
+
    // Compare expressions structurally, recursively invoking
    // comparison for subcomponents.  If that fails, consult
    // EquivExprs to see if the expressions are considered
@@ -446,8 +456,11 @@ Result Lexicographic::CompareExpr(const Expr *Arg1, const Expr *Arg2) {
        // - Pointer arithmetic where the pointer referent types are the same
        //   size, checkedness is the same, and the integer types are the
        //    same size/signedness.
-       Cmp = CompareTypeIgnoreCheckedness(E1ChildExpr->getType(),
-                                          E2ChildExpr->getType());
+       
+       // Bounds expressions don't have types.
+       if (!isa<BoundsExpr>(E1ChildExpr))
+         Cmp = CompareTypeIgnoreCheckedness(E1ChildExpr->getType(), E2ChildExpr->getType());
+
        if (Cmp != Result::Equal)
          return CheckEquivExprs(Cmp, E1, E2);
      } else
@@ -754,9 +767,14 @@ Lexicographic::CompareImpl(const PositionalParameterExpr *E1,
 Result
 Lexicographic::CompareImpl(const BoundsCastExpr *E1,
                            const BoundsCastExpr *E2) {
-  Result Cmp = CompareExpr(E1->getBoundsExpr(), E2->getBoundsExpr());
+  Result Cmp = CompareInteger(E1->getCastKind(), E2->getCastKind());
   if (Cmp != Result::Equal)
     return Cmp;
+
+  Cmp = CompareExpr(E1->getBoundsExpr(), E2->getBoundsExpr());
+  if (Cmp != Result::Equal)
+    return Cmp;
+
   return CompareType(E1->getType(), E2->getType());
 }
 

clang/lib/AST/StmtProfile.cpp

@@ -1321,6 +1321,7 @@ void StmtProfiler::VisitInteropTypeExpr(
 
 void StmtProfiler::VisitBoundsCastExpr(const BoundsCastExpr *S) {
   VisitExplicitCastExpr(S);
+  ID.AddInteger(S->getCastKind());
 }
 
 void StmtProfiler::VisitPositionalParameterExpr(