clang-rename: add new -force option

[vmiklos]

Summary

The use-case is when renaming a widely used name, like a lower-level
class in a codebase and clang-rename is simply invoked for each
translation unit based on the compile database. In this case it's not
interesting to show errors: not finding the symbol means there is
simply nothing to do.

[vmiklos]

Forgot to include one hunk to fix the build of the check-clang-tools target; I'll fix in a moment.

[vmiklos]

Manuel, can you please review this one? Thanks.

[klimek]

clang-rename/USRFindingAction.cpp

186

Why do we want to set ErrorOccurred in this case?

[vmiklos]

clang-rename/USRFindingAction.cpp

186

Later in RenamingAction.cpp:48 we assume that the PrevNames vector is parallel to the NewNames one, but in the above case we return early, so that's not the case. An easy way to avoid violating that assumption was to keep setting the error, so we don't reach the problematic part of RenamingAction. (If we reach it, we'll crash.)

A perhaps more elegant way is to not set the flag, but instead check if the two vectors are parallel after checking for errors, I'll do that in a moment.

[vmiklos]

Manuel, do you have any further comments, please? Thanks.

[vmiklos]

@klimek ping, do you have any further comments, please?

[klimek]

lg; sorry for the delay in review

clang-rename/USRFindingAction.h

 class ASTConsumer;
 class CompilerInstance;
 class NamedDecl;
 
 namespace rename {
 
 struct USRFindingAction {
   USRFindingAction(ArrayRef<unsigned> SymbolOffsets,
-                   ArrayRef<std::string> QualifiedNames)
+                   ArrayRef<std::string> QualifiedNames, bool Force)
       : SymbolOffsets(SymbolOffsets), QualifiedNames(QualifiedNames),
-        ErrorOccurred(false) {}
+        ErrorOccurred(false), Force(Force) {}
   std::unique_ptr<ASTConsumer> newASTConsumer();
 
   ArrayRef<std::string> getUSRSpellings() { return SpellingNames; }
   ArrayRef<std::vector<std::string>> getUSRList() { return USRList; }
   bool errorOccurred() { return ErrorOccurred; }
 
 private:
   std::vector<unsigned> SymbolOffsets;
   std::vector<std::string> QualifiedNames;
   std::vector<std::string> SpellingNames;
   std::vector<std::vector<std::string>> USRList;
   bool ErrorOccurred;
+  bool Force;
 };
 
 } // namespace rename
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDING_ACTION_H

clang-rename/USRFindingAction.cpp

 } // namespace
 
 class NamedDeclFindingConsumer : public ASTConsumer {
 public:
   NamedDeclFindingConsumer(ArrayRef<unsigned> SymbolOffsets,
                            ArrayRef<std::string> QualifiedNames,
                            std::vector<std::string> &SpellingNames,
                            std::vector<std::vector<std::string>> &USRList,
-                           bool &ErrorOccurred)
+                           bool Force, bool &ErrorOccurred)
       : SymbolOffsets(SymbolOffsets), QualifiedNames(QualifiedNames),
-        SpellingNames(SpellingNames), USRList(USRList),
+        SpellingNames(SpellingNames), USRList(USRList), Force(Force),
         ErrorOccurred(ErrorOccurred) {}
 
 private:
   bool FindSymbol(ASTContext &Context, const SourceManager &SourceMgr,
                   unsigned SymbolOffset, const std::string &QualifiedName) {
     DiagnosticsEngine &Engine = Context.getDiagnostics();
     const FileID MainFileID = SourceMgr.getMainFileID();
 
if (FoundDecl == nullptr) {
         FullSourceLoc FullLoc(Point, SourceMgr);
         unsigned CouldNotFindSymbolAt = Engine.getCustomDiagID(
             DiagnosticsEngine::Error,
             "clang-rename could not find symbol (offset %0)");
         Engine.Report(Point, CouldNotFindSymbolAt) << SymbolOffset;
         ErrorOccurred = true;
         return false;
       }
+
+      ErrorOccurred = true;
+      if (Force) {
+        return true;
+      }
+
       unsigned CouldNotFindSymbolNamed = Engine.getCustomDiagID(
           DiagnosticsEngine::Error, "clang-rename could not find symbol %0");
       Engine.Report(CouldNotFindSymbolNamed) << QualifiedName;
-      ErrorOccurred = true;
       return false;
     }
 
     // If FoundDecl is a constructor or destructor, we want to instead take
     // the Decl of the corresponding class.
     if (const auto *CtorDecl = dyn_cast<CXXConstructorDecl>(FoundDecl))
       FoundDecl = CtorDecl->getParent();
     else if (const auto *DtorDecl = dyn_cast<CXXDestructorDecl>(FoundDecl))
for (const std::string &QualifiedName : QualifiedNames) {
         return;
     }
   }
 
   ArrayRef<unsigned> SymbolOffsets;
   ArrayRef<std::string> QualifiedNames;
   std::vector<std::string> &SpellingNames;
   std::vector<std::vector<std::string>> &USRList;
+  bool Force;
   bool &ErrorOccurred;
 };
 
 std::unique_ptr<ASTConsumer> USRFindingAction::newASTConsumer() {
   return llvm::make_unique<NamedDeclFindingConsumer>(
-      SymbolOffsets, QualifiedNames, SpellingNames, USRList, ErrorOccurred);
+      SymbolOffsets, QualifiedNames, SpellingNames, USRList, Force,
+      ErrorOccurred);
 }
 
 } // namespace rename
 } // namespace clang

clang-rename/tool/ClangRename.cpp

static cl::opt<bool> PrintLocations(
     cl::cat(ClangRenameOptions));
 static cl::opt<std::string>
     ExportFixes("export-fixes",
                 cl::desc("YAML file to store suggested fixes in."),
                 cl::value_desc("filename"), cl::cat(ClangRenameOptions));
 static cl::opt<std::string>
     Input("input", cl::desc("YAML file to load oldname-newname pairs from."),
           cl::Optional, cl::cat(ClangRenameOptions));
+static cl::opt<bool> Force("force",
+                           cl::desc("Ignore nonexistent qualified names."),
+                           cl::cat(ClangRenameOptions));
 
 int main(int argc, const char **argv) {
   tooling::CommonOptionsParser OP(argc, argv, ClangRenameOptions);
 
   if (!Input.empty()) {
     // Populate QualifiedNames and NewNames from a YAML file.
     ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
         llvm::MemoryBuffer::getFile(Input);
errs() << "clang-rename: number of symbol offsets(" << SymbolOffsets.size()
            << ") must be equal to number of new names(" << NewNames.size()
            << ").\n\n";
     cl::PrintHelpMessage();
     exit(1);
   }
 
   auto Files = OP.getSourcePathList();
   tooling::RefactoringTool Tool(OP.getCompilations(), Files);
-  rename::USRFindingAction FindingAction(SymbolOffsets, QualifiedNames);
+  rename::USRFindingAction FindingAction(SymbolOffsets, QualifiedNames, Force);
   Tool.run(tooling::newFrontendActionFactory(&FindingAction).get());
   const std::vector<std::vector<std::string>> &USRList =
       FindingAction.getUSRList();
   const std::vector<std::string> &PrevNames = FindingAction.getUSRSpellings();
   if (PrintName) {
     for (const auto &PrevName : PrevNames) {
       outs() << "clang-rename found name: " << PrevName << '\n';
     }
   }
 
   if (FindingAction.errorOccurred()) {
+    if (Force)
+      exit(0);
+    else
       // Diagnostics are already issued at this point.
       exit(1);
   }
 
   // Perform the renaming.
   rename::RenamingAction RenameAction(NewNames, PrevNames, USRList,
                                       Tool.getReplacements(), PrintLocations);
   std::unique_ptr<tooling::FrontendActionFactory> Factory =
       tooling::newFrontendActionFactory(&RenameAction);
   int ExitCode;

docs/clang-rename.rst

Generic Options:
     -help-list                 - Display list of available options (-help-list-hidden for more)
     -version                   - Display the version of this program
 
   clang-rename common options:
 
     -export-fixes=<filename>   - YAML file to store suggested fixes in.
     -extra-arg=<string>        - Additional argument to append to the compiler command line
     -extra-arg-before=<string> - Additional argument to prepend to the compiler command line
+    -force                     - Ignore nonexistent qualified names.
     -i                         - Overwrite edited <file>s.
     -input=<string>            - YAML file to load oldname-newname pairs from.
     -new-name=<string>         - The new name to change the symbol to.
     -offset=<uint>             - Locates the symbol by offset as opposed to <line>:<column>.
     -p=<string>                - Build path
     -pl                        - Print the locations affected by renaming to stderr.
     -pn                        - Print the found symbol's name prior to renaming to stderr.
     -qualified-name=<string>   - The fully qualified name of the symbol.

test/clang-rename/InvalidQualifiedName.cpp

+struct S {
+};
+
+// RUN: clang-rename -force -qualified-name S2 -new-name=T %s --

unittests/clang-rename/ClangRenameTest.h

std::string runClangRenameOnCode(llvm::StringRef Code,
     llvm::raw_string_ostream(NewCode) << llvm::format(
         "#include \"%s\"\n%s", HeaderName.c_str(), Code.str().c_str());
     tooling::FileContentMappings FileContents = {{HeaderName, HeaderContent},
                                                  {CCName, NewCode}};
     clang::RewriterTestContext Context;
     Context.createInMemoryFile(HeaderName, HeaderContent);
     clang::FileID InputFileID = Context.createInMemoryFile(CCName, NewCode);
 
-    rename::USRFindingAction FindingAction({}, {OldName});
+    rename::USRFindingAction FindingAction({}, {OldName}, false);
     std::unique_ptr<tooling::FrontendActionFactory> USRFindingActionFactory =
         tooling::newFrontendActionFactory(&FindingAction);
 
     if (!tooling::runToolOnCodeWithArgs(
             USRFindingActionFactory->create(), NewCode, {"-std=c++11"}, CCName,
             "clang-rename", std::make_shared<PCHContainerOperations>(),
             FileContents))
       return "";