Export clang-format16 via ydblib project

6e6be3a95868fde888d801b7590af4044049563f

1 files changed, 243 insertions, 0 deletions

diff --git a/contrib/libs/clang16/lib/Analysis/ProgramPoint.cpp b/contrib/libs/clang16/lib/Analysis/ProgramPoint.cpp
new file mode 100644
index 0000000000..2a91749aff
--- /dev/null
+++ b/contrib/libs/clang16/lib/Analysis/ProgramPoint.cpp
@@ -0,0 +1,243 @@
+//==- ProgramPoint.cpp - Program Points for Path-Sensitive Analysis -*- C++ -*-/
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the interface ProgramPoint, which identifies a
+//  distinct location in a function.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Analysis/ProgramPoint.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/Basic/JsonSupport.h"
+
+using namespace clang;
+
+ProgramPointTag::~ProgramPointTag() {}
+
+ProgramPoint ProgramPoint::getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
+                                           const LocationContext *LC,
+                                           const ProgramPointTag *tag){
+  switch (K) {
+    default:
+      llvm_unreachable("Unhandled ProgramPoint kind");
+    case ProgramPoint::PreStmtKind:
+      return PreStmt(S, LC, tag);
+    case ProgramPoint::PostStmtKind:
+      return PostStmt(S, LC, tag);
+    case ProgramPoint::PreLoadKind:
+      return PreLoad(S, LC, tag);
+    case ProgramPoint::PostLoadKind:
+      return PostLoad(S, LC, tag);
+    case ProgramPoint::PreStoreKind:
+      return PreStore(S, LC, tag);
+    case ProgramPoint::PostLValueKind:
+      return PostLValue(S, LC, tag);
+    case ProgramPoint::PostStmtPurgeDeadSymbolsKind:
+      return PostStmtPurgeDeadSymbols(S, LC, tag);
+    case ProgramPoint::PreStmtPurgeDeadSymbolsKind:
+      return PreStmtPurgeDeadSymbols(S, LC, tag);
+  }
+}
+
+LLVM_DUMP_METHOD void ProgramPoint::dump() const {
+  return printJson(llvm::errs());
+}
+
+void ProgramPoint::printJson(llvm::raw_ostream &Out, const char *NL) const {
+  const ASTContext &Context =
+      getLocationContext()->getAnalysisDeclContext()->getASTContext();
+  const SourceManager &SM = Context.getSourceManager();
+  const PrintingPolicy &PP = Context.getPrintingPolicy();
+  const bool AddQuotes = true;
+
+  Out << "\"kind\": \"";
+  switch (getKind()) {
+  case ProgramPoint::BlockEntranceKind:
+    Out << "BlockEntrance\""
+        << ", \"block_id\": "
+        << castAs<BlockEntrance>().getBlock()->getBlockID();
+    break;
+
+  case ProgramPoint::FunctionExitKind: {
+    auto FEP = getAs<FunctionExitPoint>();
+    Out << "FunctionExit\""
+        << ", \"block_id\": " << FEP->getBlock()->getBlockID()
+        << ", \"stmt_id\": ";
+
+    if (const ReturnStmt *RS = FEP->getStmt()) {
+      Out << RS->getID(Context) << ", \"stmt\": ";
+      RS->printJson(Out, nullptr, PP, AddQuotes);
+    } else {
+      Out << "null, \"stmt\": null";
+    }
+    break;
+  }
+  case ProgramPoint::BlockExitKind:
+    llvm_unreachable("BlockExitKind");
+    break;
+  case ProgramPoint::CallEnterKind:
+    Out << "CallEnter\"";
+    break;
+  case ProgramPoint::CallExitBeginKind:
+    Out << "CallExitBegin\"";
+    break;
+  case ProgramPoint::CallExitEndKind:
+    Out << "CallExitEnd\"";
+    break;
+  case ProgramPoint::EpsilonKind:
+    Out << "EpsilonPoint\"";
+    break;
+
+  case ProgramPoint::LoopExitKind:
+    Out << "LoopExit\", \"stmt\": \""
+        << castAs<LoopExit>().getLoopStmt()->getStmtClassName() << '\"';
+    break;
+
+  case ProgramPoint::PreImplicitCallKind: {
+    ImplicitCallPoint PC = castAs<ImplicitCallPoint>();
+    Out << "PreCall\", \"decl\": \""
+        << PC.getDecl()->getAsFunction()->getQualifiedNameAsString()
+        << "\", \"location\": ";
+    printSourceLocationAsJson(Out, PC.getLocation(), SM);
+    break;
+  }
+
+  case ProgramPoint::PostImplicitCallKind: {
+    ImplicitCallPoint PC = castAs<ImplicitCallPoint>();
+    Out << "PostCall\", \"decl\": \""
+        << PC.getDecl()->getAsFunction()->getQualifiedNameAsString()
+        << "\", \"location\": ";
+    printSourceLocationAsJson(Out, PC.getLocation(), SM);
+    break;
+  }
+
+  case ProgramPoint::PostInitializerKind: {
+    Out << "PostInitializer\", ";
+    const CXXCtorInitializer *Init = castAs<PostInitializer>().getInitializer();
+    if (const FieldDecl *FD = Init->getAnyMember()) {
+      Out << "\"field_decl\": \"" << *FD << '\"';
+    } else {
+      Out << "\"type\": \"";
+      QualType Ty = Init->getTypeSourceInfo()->getType();
+      Ty = Ty.getLocalUnqualifiedType();
+      Ty.print(Out, Context.getLangOpts());
+      Out << '\"';
+    }
+    break;
+  }
+
+  case ProgramPoint::BlockEdgeKind: {
+    const BlockEdge &E = castAs<BlockEdge>();
+    const Stmt *T = E.getSrc()->getTerminatorStmt();
+    Out << "Edge\", \"src_id\": " << E.getSrc()->getBlockID()
+        << ", \"dst_id\": " << E.getDst()->getBlockID() << ", \"terminator\": ";
+
+    if (!T) {
+      Out << "null, \"term_kind\": null";
+      break;
+    }
+
+    E.getSrc()->printTerminatorJson(Out, Context.getLangOpts(),
+                                    /*AddQuotes=*/true);
+    Out << ", \"location\": ";
+    printSourceLocationAsJson(Out, T->getBeginLoc(), SM);
+
+    Out << ", \"term_kind\": \"";
+    if (isa<SwitchStmt>(T)) {
+      Out << "SwitchStmt\", \"case\": ";
+      if (const Stmt *Label = E.getDst()->getLabel()) {
+        if (const auto *C = dyn_cast<CaseStmt>(Label)) {
+          Out << "{ \"lhs\": ";
+          if (const Stmt *LHS = C->getLHS()) {
+            LHS->printJson(Out, nullptr, PP, AddQuotes);
+          } else {
+            Out << "null";
+	  }
+
+          Out << ", \"rhs\": ";
+          if (const Stmt *RHS = C->getRHS()) {
+            RHS->printJson(Out, nullptr, PP, AddQuotes);
+          } else {
+            Out << "null";
+          }
+          Out << " }";
+        } else {
+          assert(isa<DefaultStmt>(Label));
+          Out << "\"default\"";
+        }
+      } else {
+        Out << "\"implicit default\"";
+      }
+    } else if (isa<IndirectGotoStmt>(T)) {
+      // FIXME: More info.
+      Out << "IndirectGotoStmt\"";
+    } else {
+      Out << "Condition\", \"value\": "
+          << (*E.getSrc()->succ_begin() == E.getDst() ? "true" : "false");
+    }
+    break;
+  }
+
+  default: {
+    const Stmt *S = castAs<StmtPoint>().getStmt();
+    assert(S != nullptr && "Expecting non-null Stmt");
+
+    Out << "Statement\", \"stmt_kind\": \"" << S->getStmtClassName()
+        << "\", \"stmt_id\": " << S->getID(Context)
+        << ", \"pointer\": \"" << (const void *)S << "\", ";
+    if (const auto *CS = dyn_cast<CastExpr>(S))
+      Out << "\"cast_kind\": \"" << CS->getCastKindName() << "\", ";
+
+    Out << "\"pretty\": ";
+
+    S->printJson(Out, nullptr, PP, AddQuotes);
+
+    Out << ", \"location\": ";
+    printSourceLocationAsJson(Out, S->getBeginLoc(), SM);
+
+    Out << ", \"stmt_point_kind\": \"";
+    if (getAs<PreLoad>())
+      Out << "PreLoad";
+    else if (getAs<PreStore>())
+      Out << "PreStore";
+    else if (getAs<PostAllocatorCall>())
+      Out << "PostAllocatorCall";
+    else if (getAs<PostCondition>())
+      Out << "PostCondition";
+    else if (getAs<PostLoad>())
+      Out << "PostLoad";
+    else if (getAs<PostLValue>())
+      Out << "PostLValue";
+    else if (getAs<PostStore>())
+      Out << "PostStore";
+    else if (getAs<PostStmt>())
+      Out << "PostStmt";
+    else if (getAs<PostStmtPurgeDeadSymbols>())
+      Out << "PostStmtPurgeDeadSymbols";
+    else if (getAs<PreStmtPurgeDeadSymbols>())
+      Out << "PreStmtPurgeDeadSymbols";
+    else if (getAs<PreStmt>())
+      Out << "PreStmt";
+    else {
+      Out << "\nKind: '" << getKind();
+      llvm_unreachable("' is unhandled StmtPoint kind!");
+    }
+
+    Out << '\"';
+    break;
+  }
+  }
+}
+
+SimpleProgramPointTag::SimpleProgramPointTag(StringRef MsgProvider,
+                                             StringRef Msg)
+  : Desc((MsgProvider + " : " + Msg).str()) {}
+
+StringRef SimpleProgramPointTag::getTagDescription() const {
+  return Desc;
+}