Lebedeva Ksenia Lab 1 Var 4

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

@@ -104,6 +104,7 @@ jobs:
                 -DLLVM_ENABLE_ASSERTIONS=ON \
                 -DLLDB_INCLUDE_TESTS=OFF \
                 -DCMAKE_C_COMPILER_LAUNCHER=sccache \
+                -DLLVM_TARGETS_TO_BUILD=X86 \
                 -DCMAKE_CXX_COMPILER_LAUNCHER=sccache \
                 ${{ inputs.extra_cmake_args }}
           ninja -C "$builddir" all

.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/balyasov_ivan/CMakeLists.txt

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

clang/labs/lab1/balyasov_ivan/rename_identifiers.cpp

@@ -0,0 +1,194 @@
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/FrontendPluginRegistry.h"
+#include "clang/Rewrite/Core/Rewriter.h"
+
+enum class Types { Var, Func, Class };
+
+class RenameVisitor : public clang::RecursiveASTVisitor<RenameVisitor> {
+private:
+  clang::Rewriter rewriter;
+  Types type;
+  std::string oldName;
+  std::string newName;
+
+public:
+  explicit RenameVisitor(clang::Rewriter rewriter, Types type,
+                         clang::StringRef oldName, clang::StringRef newName)
+      : rewriter(rewriter), type(type), oldName(oldName), newName(newName) {}
+
+  bool VisitFunctionDecl(clang::FunctionDecl *func) {
+    if (type == Types::Func && func->getName() == oldName) {
+      rewriter.ReplaceText(func->getNameInfo().getSourceRange(), newName);
+    }
+    return true;
+  }
+
+  bool VisitCallExpr(clang::CallExpr *call) {
+    if (type == Types::Func) {
+      clang::FunctionDecl *callee = call->getDirectCallee();
+      if (callee && callee->getName() == oldName) {
+        rewriter.ReplaceText(call->getCallee()->getSourceRange(), newName);
+      }
+    }
+    return true;
+  }
+
+  bool VisitVarDecl(clang::VarDecl *var) {
+    if (type == Types::Var && var->getName() == oldName) {
+      rewriter.ReplaceText(var->getLocation(), oldName.size(), newName);
+    }
+    if (type == Types::Class &&
+        (var->getType().getAsString() == oldName + " *" ||
+         var->getType().getAsString() == oldName)) {
+      rewriter.ReplaceText(var->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
+                           oldName.size(), newName);
+    }
+    return true;
+  }
+
+  bool VisitDeclRefExpr(clang::DeclRefExpr *expr) {
+    clang::VarDecl *var = clang::dyn_cast<clang::VarDecl>(expr->getDecl());
+    if (type == Types::Var && var && var->getName() == oldName) {
+      rewriter.ReplaceText(expr->getSourceRange(), newName);
+    }
+    return true;
+  }
+
+  bool VisitCXXRecordDecl(clang::CXXRecordDecl *record) {
+    if (type == Types::Class && record->getName() == oldName) {
+      rewriter.ReplaceText(record->getLocation(), newName);
+      const auto *destructor = record->getDestructor();
+      if (destructor) {
+        rewriter.ReplaceText(destructor->getLocation(), oldName.size() + 1,
+                             '~' + newName);
+      }
+    }
+    return true;
+  }
+
+  bool VisitCXXConstructorDecl(clang::CXXConstructorDecl *constructor) {
+    if (type == Types::Class) {
+      if (constructor->getNameAsString() == oldName) {
+        rewriter.ReplaceText(constructor->getLocation(), oldName.size(),
+                             newName);
+      }
+    }
+    return true;
+  }
+
+  bool VisitCXXNewExpr(clang::CXXNewExpr *newExpr) {
+    if (type == Types::Class) {
+      if (newExpr->getConstructExpr()->getType().getAsString() == oldName) {
+        rewriter.ReplaceText(newExpr->getExprLoc(), oldName.size() + 4,
+                             "new " + newName);
+      }
+    }
+    return true;
+  }
+
+  bool save_changes() { return rewriter.overwriteChangedFiles(); }
+};
+
+class RenameConsumer : public clang::ASTConsumer {
+private:
+  RenameVisitor Visitor;
+
+public:
+  explicit RenameConsumer(clang::CompilerInstance &CI, Types type,
+                          clang::StringRef oldName, clang::StringRef newName)
+      : Visitor(clang::Rewriter(CI.getSourceManager(), CI.getLangOpts()), type,
+                oldName, newName) {}
+
+  void HandleTranslationUnit(clang::ASTContext &context) override {
+    Visitor.TraverseDecl(context.getTranslationUnitDecl());
+    Visitor.save_changes();
+  }
+};
+
+class RenamePlugin : public clang::PluginASTAction {
+private:
+  Types type;
+  std::string oldName;
+  std::string newName;
+
+protected:
+  bool ParseArgs(const clang::CompilerInstance &CI,
+                 const std::vector<std::string> &args) override {
+    std::vector<std::pair<std::string, std::string>> params = {
+        {"type=", ""}, {"cur-name=", ""}, {"new-name=", ""}};
+
+    if (!args.empty()) {
+      for (int i = 0; i < args.size(); i++) {
+        if (args[i] == "help") {
+          PrintHelp(llvm::errs());
+          return false;
+        }
+      }
+    }
+
+    if (args.size() < 3) {
+      PrintParamsError(CI);
+      return false;
+    }
+
+    for (const auto &arg : args) {
+      bool is_found = false;
+      for (auto &param : params) {
+        if (arg.find(param.first) == 0 && param.second.empty()) {
+          param.second = arg.substr(param.first.size());
+          is_found = true;
+          break;
+        }
+      }
+      if (!is_found) {
+        PrintParamsError(CI);
+        return false;
+      }
+    }
+
+    std::vector<std::pair<std::string, Types>> id_type = {
+        {"var", Types::Var}, {"func", Types::Func}, {"class", Types::Class}};
+    size_t i;
+    for (i = 0; i < id_type.size(); i++) {
+      if (params[0].second == id_type[i].first) {
+        type = id_type[i].second;
+        break;
+      }
+    }
+    if (i == id_type.size()) {
+      PrintParamsError(CI);
+      return false;
+    }
+    oldName = params[1].second;
+    newName = params[2].second;
+    return true;
+  }
+
+  void PrintHelp(llvm::raw_ostream &ros) {
+    ros << "Specify three required arguments:\n"
+           "-plugin-arg-renameIds type=[\"Var\", \"Func\", \"Class\"]\n"
+           "-plugin-arg-renameIds cur-name=\"Current identifier name\"\n"
+           "-plugin-arg-renameIds new-name=\"New identifier name\"\n";
+  }
+
+  void PrintParamsError(const clang::CompilerInstance &CI) {
+    clang::DiagnosticsEngine &D = CI.getDiagnostics();
+
+    D.Report(D.getCustomDiagID(
+        clang::DiagnosticsEngine::Error,
+        "Invalid arguments\n"
+        "Specify \"-plugin-arg-renameIds help\" for usage\n"));
+  }
+
+public:
+  std::unique_ptr<clang::ASTConsumer>
+  CreateASTConsumer(clang::CompilerInstance &CI,
+                    clang::StringRef InFile) override {
+    return std::make_unique<RenameConsumer>(CI, type, oldName, newName);
+  }
+};
+
+static clang::FrontendPluginRegistry::Add<RenamePlugin>
+    X("renameIds", "Rename Variable, Function or Class");

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)