[-WunsafeBufferUsage][WIP] Add PointerArithmeticFixable

[jkorous]

Summary

TODO - this is just a mock Fixable

clang/include/clang/Analysis/Analyses/UnsafeBufferUsageGadgets.def

 WARNING_GADGET(PointerArithmetic)
 WARNING_GADGET(UnsafeBufferUsageAttr)
 
 FIXABLE_GADGET(ULCArraySubscript)          // `DRE[any]` in an Unspecified Lvalue Context
 FIXABLE_GADGET(PointerDereference)
 FIXABLE_GADGET(UPCAddressofArraySubscript) // '&DRE[any]' in an Unspecified Pointer Context
 FIXABLE_GADGET(DerefSimplePtrArithFixable)
 FIXABLE_GADGET(PointerCtxAccess)
+FIXABLE_GADGET(PointerArithmeticFixable)
 
 #undef FIXABLE_GADGET
 #undef WARNING_GADGET
 #undef GADGET

clang/lib/Analysis/UnsafeBufferUsage.cpp

if (const auto *ArraySubst =
             dyn_cast<ArraySubscriptExpr>(Node->getSubExpr()))
       if (const auto *DRE =
               dyn_cast<DeclRefExpr>(ArraySubst->getBase()->IgnoreImpCasts())) {
         return {DRE};
       }
     return {};
   }
 };
+
+class PointerArithmeticFixableGadget : public FixableGadget {
+private:
+  static constexpr const char *const DRETag = "DRETag";
+  static constexpr const char *const RHSLiteralTag = "RHSLiteralTag";
+  const DeclRefExpr *DRE = nullptr;
+  const IntegerLiteral *RHSLiteral = nullptr;
+
+public:
+  PointerArithmeticFixableGadget(const MatchFinder::MatchResult &Result)
+      : FixableGadget(Kind::PointerCtxAccess),
+        DRE(Result.Nodes.getNodeAs<DeclRefExpr>(DRETag)),
+        RHSLiteral(Result.Nodes.getNodeAs<IntegerLiteral>(RHSLiteralTag)) {
+    assert(DRE != nullptr && "Expecting a non-null matching result");
+  }
+
+  static bool classof(const Gadget *G) {
+    return G->getKind() == Kind::PointerCtxAccess;
+  }
+
+  static Matcher matcher() {
+    auto ArrayOrPtr = anyOf(hasPointerType(), hasArrayType());
+    auto target = expr(
+        ignoringParenImpCasts(
+          binaryOperator(
+            hasOperatorName("+"),
+            hasLHS(
+              expr(
+                hasPointerType(),
+                ignoringImpCasts(
+                  declRefExpr().bind(DRETag)))),
+            hasRHS(
+              anyOf(
+                integerLiteral().bind(RHSLiteralTag),
+                expr(
+                  hasType(isUnsignedInteger())
+                )
+              )
+        ))));
+    return stmt(isInUnspecifiedPointerContext(target));
+  }
+
+  virtual std::optional<FixItList> getFixits(const Strategy &S) const override;
+
+  virtual const Stmt *getBaseStmt() const override { return DRE; }
+
+  virtual DeclUseList getClaimedVarUseSites() const override {
+    return {DRE};
+  }
+};
 } // namespace
 
 namespace {
 // An auxiliary tracking facility for the fixit analysis. It helps connect
 // declarations to its and make sure we've covered all uses with our analysis
 // before we try to fix the declaration.
 class DeclUseTracker {
   using UseSetTy = SmallSet<const DeclRefExpr *, 16>;
if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
       case Strategy::Kind::Array:
       case Strategy::Kind::Vector:
         llvm_unreachable("unsupported strategies for FixableGadgets");
       }
     }
   return std::nullopt;
 }
 
+std::optional<FixItList> PointerArithmeticFixableGadget::getFixits(const Strategy &S) const {
+  if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
+    if (S.lookup(VD) == Strategy::Kind::Span) {
+      ASTContext &Ctx = VD->getASTContext();
+      if (RHSLiteral && RHSLiteral->getIntegerConstantExpr(Ctx)->isNegative())
+        return std::nullopt;
+      SourceManager &SM = Ctx.getSourceManager();
+      std::optional<SourceLocation> endOfOperand =
+          getEndCharLoc(DRE, SM, Ctx.getLangOpts());
+
+      return FixItList{{FixItHint::CreateInsertion(
+          endOfOperand.value().getLocWithOffset(1), ".data()")}};
+    }
+  }
+  return std::nullopt;
+}
+
 // For a non-null initializer `Init` of `T *` type, this function returns
 // `FixItHint`s producing a list initializer `{Init,  S}` as a part of a fix-it
 // to output stream.
 // In many cases, this function cannot figure out the actual extent `S`.  It
 // then will use a place holder to replace `S` to ask users to fill `S` in.  The
 // initializer shall be used to initialize a variable of type `std::span<T>`.
 //
 // FIXME: Support multi-level pointers