Kozyreva Ekaterina lab1 option 1

.github/workflows/nn-cmplr-tidy.yml

@@ -7,12 +7,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
     - name: Install clang-format
       run: |
         sudo apt-get install -y clang-format
     - name: Run clang-format
       run: |
-        git-clang-format --diff `git merge-base ${GITHUB_SHA} ${GITHUB_BASE_REF}`
+        git-clang-format --diff `git merge-base ${GITHUB_SHA} origin/${GITHUB_BASE_REF}` ${GITHUB_SHA} 2>&1 | tee log.txt
+        exit `grep -c diff log.txt`
   clang-tidy:
     runs-on: ubuntu-latest
     steps:

clang/CMakeLists.txt

@@ -472,6 +472,7 @@ add_subdirectory(runtime)
 
 option(CLANG_BUILD_EXAMPLES "Build CLANG example programs by default." OFF)
 add_subdirectory(examples)
+add_subdirectory(labs)
 
 if(APPLE)
   # this line is needed as a cleanup to ensure that any CMakeCaches with the old

clang/labs/CMakeLists.txt

@@ -0,0 +1,9 @@
+FILE(GLOB children RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
+FOREACH(child ${children})
+  IF(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${child})
+    add_subdirectory(${child})
+  ENDIF()
+ENDFOREACH()
+
+set(CLANG_TEST_DEPS ${CLANG_TEST_DEPS} PARENT_SCOPE)
+message("CLANG_TEST_DEPS ${CLANG_TEST_DEPS}")

clang/labs/lab1/CMakeLists.txt

@@ -0,0 +1,10 @@
+if(CLANG_PLUGIN_SUPPORT)
+  FILE(GLOB children RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
+  FOREACH(child ${children})
+    IF(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${child})
+      add_subdirectory(${child})
+    ENDIF()
+  ENDFOREACH()
+
+  set(CLANG_TEST_DEPS ${CLANG_TEST_DEPS} PARENT_SCOPE)
+endif()

clang/labs/lab1/alexseev_danila/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_llvm_library(depWarningPluginAlexseev MODULE deprecatedWarning.cpp PLUGIN_TOOL clang)
+
+if(WIN32 OR CYGWIN)
+  set(LLVM_LINK_COMPONENTS
+      Support
+  )
+  clang_target_link_libraries(depWarningPluginAlexseev PRIVATE
+    clangAST
+    clangBasic
+    clangFrontend
+    )
+endif()
+
+set(CLANG_TEST_DEPS "depWarningPluginAlexseev" ${CLANG_TEST_DEPS} PARENT_SCOPE)

clang/labs/lab1/alexseev_danila/deprecatedWarning.cpp

@@ -0,0 +1,66 @@
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/FrontendPluginRegistry.h"
+
+using namespace clang;
+
+class DepFuncVisitor : public RecursiveASTVisitor<DepFuncVisitor> {
+private:
+  ASTContext *Context;
+  std::string ExcludeFunc;
+
+public:
+  explicit DepFuncVisitor(ASTContext *Context, std::string ExcludeFunc)
+      : Context(Context), ExcludeFunc(ExcludeFunc) {}
+
+  bool VisitFunctionDecl(FunctionDecl *Func) {
+    if (Func->getNameInfo().getAsString().find("deprecated") !=
+            std::string::npos &&
+        Func->getNameInfo().getAsString() != ExcludeFunc) {
+      DiagnosticsEngine &Diags = Context->getDiagnostics();
+      size_t CustomDiagID =
+          Diags.getCustomDiagID(DiagnosticsEngine::Warning,
+                                "Function contains 'deprecated' in its name");
+      Diags.Report(Func->getLocation(), CustomDiagID)
+          << Func->getNameInfo().getAsString();
+    }
+    return true;
+  }
+};
+
+class DepFuncConsumer : public ASTConsumer {
+  std::string ExcludeFunc;
+
+public:
+  explicit DepFuncConsumer(std::string ExcludeFunc)
+      : ExcludeFunc(ExcludeFunc) {}
+
+  void HandleTranslationUnit(ASTContext &Context) override {
+    DepFuncVisitor Visitor(&Context, ExcludeFunc);
+    Visitor.TraverseDecl(Context.getTranslationUnitDecl());
+  }
+};
+
+class DepFuncPlugin : public PluginASTAction {
+protected:
+  std::string ExcludeFunc = "";
+
+  std::unique_ptr<ASTConsumer>
+  CreateASTConsumer(CompilerInstance &Compiler,
+                    llvm::StringRef InFile) override {
+    return std::make_unique<DepFuncConsumer>(ExcludeFunc);
+  }
+  bool ParseArgs(const CompilerInstance &Compiler,
+                 const std::vector<std::string> &Args) override {
+    for (unsigned i = 0, e = Args.size(); i != e; ++i) {
+      if (Args[i].substr(0, 9) == "-exclude=") {
+        ExcludeFunc = Args[i].substr(9);
+      }
+    }
+    return true;
+  }
+};
+
+static FrontendPluginRegistry::Add<DepFuncPlugin> X("deprecated-warning",
+                                                    "deprecated warning");

clang/labs/lab1/bend_tatiana/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_llvm_library(Myfirstplugin MODULE PrintFunctionNames.cpp PLUGIN_TOOL clang)
+
+if(WIN32 OR CYGWIN)
+  set(LLVM_LINK_COMPONENTS
+    Support
+  )
+  clang_target_link_libraries(Myfirstplugin PRIVATE
+    clangAST
+    clangBasic
+    clangFrontend
+    )
+endif()
+
+set(CLANG_TEST_DEPS "Myfirstplugin" ${CLANG_TEST_DEPS} PARENT_SCOPE)

clang/labs/lab1/bend_tatiana/PrintFunctionNames.cpp

@@ -0,0 +1,66 @@
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/FrontendAction.h"
+#include "clang/Frontend/FrontendPluginRegistry.h"
+#include "clang/Sema/Sema.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+#include <memory>
+#include <string>
+#include <vector>
+using namespace clang;
+
+namespace {
+
+class MyASTConsumer : public ASTConsumer {
+
+public:
+  void HandleTranslationUnit(ASTContext &Context) override {
+    struct Visitor : public RecursiveASTVisitor<Visitor> {
+
+      bool VisitCXXRecordDecl(CXXRecordDecl *CxxRDecl) {
+        if (CxxRDecl->isClass() || CxxRDecl->isStruct()) {
+          llvm::outs() << CxxRDecl->getNameAsString() << "\n";
+
+          for (auto It = CxxRDecl->decls_begin(); It != CxxRDecl->decls_end();
+               ++It)
+            if (FieldDecl *NDecl = dyn_cast<FieldDecl>(*It))
+              llvm::outs() << "|_ " << NDecl->getNameAsString() << "\n";
+            else if (VarDecl *NDecl = dyn_cast<VarDecl>(*It))
+              llvm::outs() << "|_ " << NDecl->getNameAsString() << "\n";
+
+          llvm::outs() << "\n";
+        }
+        return true;
+      }
+    } V;
+    V.TraverseDecl(Context.getTranslationUnitDecl());
+  }
+};
+
+class PrintFunctionNamesAction : public PluginASTAction {
+protected:
+  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
+                                                 llvm::StringRef) override {
+    return std::make_unique<MyASTConsumer>();
+  }
+
+  bool ParseArgs(const CompilerInstance &CI,
+                 const std::vector<std::string> &Args) override {
+    if (!Args.empty() && Args[0] == "help")
+      PrintHelp(llvm::errs());
+    return true;
+  }
+
+  void PrintHelp(llvm::raw_ostream &ros) {
+    ros << "Plugin prints names of classes and their fields\n";
+  }
+};
+
+} // namespace
+
+static FrontendPluginRegistry::Add<PrintFunctionNamesAction>
+    X("classprinter", "prints names of classes and their fields");

clang/labs/lab1/bodrov_daniil/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_llvm_library(ClassFieldPrinter MODULE ClassPrinter.cpp PLUGIN_TOOL clang)
+
+if(WIN32 OR CYGWIN)
+  set(LLVM_LINK_COMPONENTS
+    Support
+  )
+  clang_target_link_libraries(ClassFieldPrinter PRIVATE
+    clangAST
+    clangBasic
+    clangFrontend
+    )
+endif()
+
+set(CLANG_TEST_DEPS "ClassFieldPrinter" ${CLANG_TEST_DEPS} PARENT_SCOPE)

clang/labs/lab1/bodrov_daniil/ClassPrinter.cpp

@@ -0,0 +1,104 @@
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/FrontendPluginRegistry.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace {
+
+class MemberInfoPrinter {
+public:
+  void print(const clang::ValueDecl *Member, const std::string &MemberType) {
+    llvm::outs() << "|_ " << Member->getNameAsString() << ' ';
+    llvm::outs() << '(' << Member->getType().getAsString() << '|';
+    llvm::outs() << getAccessSpecifierAsString(Member)
+                 << (MemberType == "field" ? ")" : ("|" + MemberType + ")"))
+                 << "\n";
+  }
+
+private:
+  std::string getAccessSpecifierAsString(const clang::ValueDecl *Member) {
+    switch (Member->getAccess()) {
+    case clang::AS_public:
+      return "public";
+    case clang::AS_protected:
+      return "protected";
+    case clang::AS_private:
+      return "private";
+    default:
+      return "unknown";
+    }
+  }
+};
+
+class UserTypePrinter {
+public:
+  void print(clang::CXXRecordDecl *UserType) {
+    llvm::outs() << UserType->getNameAsString() << ' ';
+    llvm::outs() << (UserType->isStruct() ? "(struct" : "(class");
+    llvm::outs() << (UserType->isTemplated() ? "|template)" : ")") << '\n';
+  }
+};
+
+class ClassMembersPrinter final
+    : public clang::RecursiveASTVisitor<ClassMembersPrinter> {
+public:
+  explicit ClassMembersPrinter(clang::ASTContext *Context)
+      : ClassContext(Context) {}
+
+  bool VisitCXXRecordDecl(clang::CXXRecordDecl *Declaration) {
+    if (Declaration->isStruct() || Declaration->isClass()) {
+      UserPrinter.print(Declaration);
+
+      for (const auto &Decl : Declaration->decls()) {
+        if (auto Field = llvm::dyn_cast<clang::FieldDecl>(Decl)) {
+          MemberPrinter.print(Field, "field");
+        } else if (auto Var = llvm::dyn_cast<clang::VarDecl>(Decl)) {
+          if (Var->isStaticDataMember()) {
+            MemberPrinter.print(Var, "static");
+          }
+        } else if (auto Method = llvm::dyn_cast<clang::CXXMethodDecl>(Decl)) {
+          MemberPrinter.print(Method, "method");
+        }
+      }
+      llvm::outs() << '\n';
+    }
+    return true;
+  }
+
+private:
+  clang::ASTContext *ClassContext;
+  MemberInfoPrinter MemberPrinter;
+  UserTypePrinter UserPrinter;
+};
+
+class ClassMembersConsumer final : public clang::ASTConsumer {
+public:
+  explicit ClassMembersConsumer(clang::ASTContext *Context)
+      : Visitor(Context) {}
+
+  void HandleTranslationUnit(clang::ASTContext &Context) override {
+    Visitor.TraverseDecl(Context.getTranslationUnitDecl());
+  }
+
+private:
+  ClassMembersPrinter Visitor;
+};
+
+class ClassFieldPrinterAction final : public clang::PluginASTAction {
+public:
+  std::unique_ptr<clang::ASTConsumer>
+  CreateASTConsumer(clang::CompilerInstance &Ci, llvm::StringRef) override {
+    return std::make_unique<ClassMembersConsumer>(&Ci.getASTContext());
+  }
+
+  bool ParseArgs(const clang::CompilerInstance &Ci,
+                 const std::vector<std::string> &Args) override {
+    return true;
+  }
+};
+
+} // namespace
+
+static clang::FrontendPluginRegistry::Add<ClassFieldPrinterAction>
+    X("class-field-printer", "Prints all members of the class");