refactor: Add a continuation verification function to

report errors for the "Generate Missing Function Definitions"
action that can be propagated back to SK

rdar://33403708

apple-llvm-split-commit: 414251c9711ba8fa6781f2f899d855a9579b91d5
apple-llvm-split-dir: clang/

Author: hyp

clang/include/clang-c/Refactor.h

@@ -1169,6 +1169,18 @@ CINDEX_LINKAGE
 CXIndexerQuery clang_RefactoringContinuation_getIndexerQuery(
     CXRefactoringContinuation Continuation, unsigned Index);
 
+/**
+ * \brief Verify that the all of the indexer queries are satisfied by the
+ * continuation.
+ *
+ * \returns Null if all of the queries are satisfied an no errors have been
+ * reported, or a set of diagnostics that describes why the continuation should
+ * not be run.
+ */
+CINDEX_LINKAGE
+CXDiagnosticSet clang_RefactoringContinuation_verifyBeforeFinalizing(
+    CXRefactoringContinuation Continuation);
+
 /**
  * \brief Terminate the connection between the initiation TU and the refactoring
  * continuation.

clang/include/clang/Basic/DiagnosticRefactoringKinds.td

@@ -24,4 +24,16 @@ def err_rename_external_source_symbol : Error<"%0 is declared in a %1 file; "
   "rename can be initiated in a %1 file only">;
 }
 
+let CategoryName = "Refactoring Continuation Issue" in {
+
+def err_ref_continuation_missing_implementation : Error<
+  "no %select{implementation file|@implementation declaration}0 for the "
+  "selected %select{declaration|@interface}0 %1; please add one and run the "
+  "refactoring action again">;
+
+def err_implement_declared_methods_all_implemented : Error<
+  "the selected methods are already implemented">;
+
+}
+
 } // end of Refactoring diagnostics

clang/include/clang/Tooling/Refactor/IndexerQuery.h

@@ -36,6 +36,10 @@ class IndexerQuery {
 
   virtual void invalidateTUSpecificState() = 0;
 
+  /// Checks if this query was satisfied. Returns true if it wasn't and reports
+  /// appropriate errors.
+  virtual bool verify(ASTContext &) { return false; }
+
   // Mainly used for testing.
   static llvm::Error loadResultsFromYAML(StringRef Source,
                                          ArrayRef<IndexerQuery *> Queries);
@@ -82,6 +86,8 @@ class ASTUnitForImplementationOfDeclarationQuery final
 
   void setResult(PersistentFileID File) { Result = std::move(File); }
 
+  bool verify(ASTContext &Context) override;
+
   const PersistentFileID &getResult() const { return Result; }
 
   static bool classof(const IndexerQuery *D) {
@@ -230,6 +236,8 @@ class DeclarationsQuery : public IndexerQuery {
 
   void invalidateTUSpecificState() override { Input.clear(); }
 
+  bool verify(ASTContext &Context) override;
+
   void setOutput(std::vector<Indexed<PersistentDeclRef<Decl>>> Output) {
     this->Output = Output;
   }

clang/lib/Tooling/Refactor/IndexerQueries.cpp

@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Tooling/Core/RefactoringDiagnostic.h"
 #include "clang/Tooling/Refactor/IndexerQuery.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
@@ -44,6 +45,40 @@ clang::tooling::indexer::fileThatShouldContainImplementationOf(const Decl *D) {
   return llvm::make_unique<ASTUnitForImplementationOfDeclarationQuery>(D);
 }
 
+bool ASTUnitForImplementationOfDeclarationQuery::verify(ASTContext &Context) {
+  if (!D) {
+    assert(false && "Query should be verified before persisting");
+    return false;
+  }
+  // Check if we've got the filename.
+  if (!Result.Filename.empty())
+    return false;
+  Context.getDiagnostics().Report(
+      D->getLocation(), diag::err_ref_continuation_missing_implementation)
+      << isa<ObjCContainerDecl>(D) << cast<NamedDecl>(D);
+  return true;
+}
+
+bool DeclarationsQuery::verify(ASTContext &Context) {
+  if (Input.empty()) {
+    assert(false && "Query should be verified before persisting");
+    return false;
+  }
+  if (!Output.empty()) {
+    // At least one output declaration must be valid.
+    for (const auto &Ref : Output) {
+      if (!Ref.Decl.USR.empty())
+        return false;
+    }
+  }
+  // FIXME: This is too specific, the new refactoring engine at llvm.org should
+  // generalize this.
+  Context.getDiagnostics().Report(
+      Input[0]->getLocation(),
+      diag::err_implement_declared_methods_all_implemented);
+  return true;
+}
+
 namespace {
 
 struct QueryPredicateNode {

clang/test/Refactor/ImplementDeclaredMethods/implement-declared-methods.cpp

@@ -85,6 +85,10 @@ struct }
 // query-mix-impl-header: [ { name: ast.producer.query, filenameResult: "%S/classInHeader.h" } , { name: decl.query , predicateResults: [{name: decl.isDefined, intValues: [0, 1, 0, 1] }] }]
 // RUN: clang-refactor-test perform -action implement-declared-methods -selected=class-in-header -continuation-file=%S/Inputs/classInHeader.cpp -query-results=query-mix-impl-header %s | FileCheck %S/Inputs/classInHeader.h
 
+// query-no-impl: [ { name: ast.producer.query, filenameResult: "%s" } , { name: decl.query , predicateResults: [{name: decl.isDefined, intValues: [1, 1, 1, 1] }] }]
+// RUN: not clang-refactor-test perform -action implement-declared-methods -selected=class-in-header -continuation-file=%S/Inputs/classInHeader.cpp -query-results=query-no-impl %s 2>&1 | FileCheck --check-prefix=ALL-IMPLEMENTED-ERROR %s
+// ALL-IMPLEMENTED-ERROR: error: continuation failed: the selected methods are already implemented
+
 // Ensure that the methods which are placed right after the record are placed
 // after the outermost record:
 namespace ns {

clang/test/Refactor/ImplementDeclaredMethods/implement-declared-methods.m

@@ -47,6 +47,10 @@ - (void)someOtherMethod { }
 // RUN: not clang-refactor-test perform -action implement-declared-methods -selected=all-methods -continuation-file=%s -query-results=query-all-impl %s -DNO_IMPL 2>&1 | FileCheck --check-prefix=CHECK-EMPTY-ERR %s
 // CHECK-EMPTY-ERR: failed to perform the refactoring continuation (the target @interface is not implemented in the continuation AST unit)!
 
+// query-no-file-all-impl: [ { name: ast.producer.query, filenameResult: "" } , { name: decl.query , predicateResults: [{name: decl.isDefined, intValues: [0, 0, 0, 0] }] }]
+// RUN: not clang-refactor-test perform -action implement-declared-methods -selected=all-methods -continuation-file=%s -query-results=query-no-file-all-impl %s -DNO_IMPL 2>&1 | FileCheck --check-prefix=CHECK-NO-IMPLEMENTATION-ERROR %s
+// CHECK-NO-IMPLEMENTATION-ERROR: error: continuation failed: no @implementation declaration for the selected @interface 'MyClass'; please add one and run the refactoring action again
+
 // RUN: clang-refactor-test perform -action implement-declared-methods -selected=all-methods -continuation-file=%S/Inputs/objcClass.m -query-results=query-all-impl %s -DNO_IMPL | FileCheck --check-prefix=CHECK1 %S/Inputs/objcClass.m
 // RUN: clang-refactor-test perform -action implement-declared-methods -selected=all-methods -continuation-file=%S/Inputs/objcClass.m -query-results=query-mix-impl %s -DNO_IMPL -DMIX_IMPL | FileCheck --check-prefix=CHECK2 %S/Inputs/objcClass.m
 

clang/tools/clang-refactor-test/ClangRefactorTest.cpp

@@ -1109,6 +1109,19 @@ bool performOperation(CXRefactoringAction Action, ArrayRef<const char *> Args,
       /*FileSubstitution=*/opts::initiateAndPerform::ContinuationFile);
   clang_RefactoringContinuation_loadSerializedIndexerQueryResults(
       Continuation, /*Source=*/QueryResults.c_str());
+  CXDiagnosticSet Diags =
+      clang_RefactoringContinuation_verifyBeforeFinalizing(Continuation);
+  if (Diags) {
+    llvm::errs() << "error: continuation failed: ";
+    for (unsigned I = 0, E = clang_getNumDiagnosticsInSet(Diags); I != E; ++I) {
+      CXDiagnostic Diag = clang_getDiagnosticInSet(Diags, I);
+      CXString Spelling = clang_getDiagnosticSpelling(Diag);
+      errs() << clang_getCString(Spelling) << "\n";
+      clang_disposeString(Spelling);
+    }
+    clang_RefactoringContinuation_dispose(Continuation);
+    return true;
+  }
   clang_RefactoringContinuation_finalizeEvaluationInInitationTU(Continuation);
   // Load the continuation TU.
   CXTranslationUnit ContinuationTU;

clang/tools/libclang/CRefactor.cpp

@@ -1051,6 +1051,7 @@ class RefactoringDiagnosticConsumer : public DiagnosticConsumer {
   DiagnosticConsumer *PreviousClient;
   std::unique_ptr<DiagnosticConsumer> PreviousClientPtr;
   llvm::SmallVector<StoredDiagnostic, 2> RenameDiagnostics;
+  llvm::SmallVector<StoredDiagnostic, 1> ContinuationDiagnostics;
 
 public:
   RefactoringDiagnosticConsumer(ASTContext &Context) : Context(Context) {
@@ -1069,17 +1070,24 @@ class RefactoringDiagnosticConsumer : public DiagnosticConsumer {
 
   void HandleDiagnostic(DiagnosticsEngine::Level Level,
                         const Diagnostic &Info) override {
-    if (DiagnosticIDs::getCategoryNumberForDiag(Info.getID()) ==
-        diag::DiagCat_Rename_Issue)
+    unsigned Cat = DiagnosticIDs::getCategoryNumberForDiag(Info.getID());
+    if (Cat == diag::DiagCat_Rename_Issue)
       RenameDiagnostics.push_back(StoredDiagnostic(Level, Info));
+    else if (Cat == diag::DiagCat_Refactoring_Continuation_Issue)
+      ContinuationDiagnostics.push_back(StoredDiagnostic(Level, Info));
     else
       assert(false && "Unhandled refactoring category");
   }
 
   CXDiagnosticSetImpl *createDiags() const {
-    if (RenameDiagnostics.empty())
+    if (RenameDiagnostics.empty() && ContinuationDiagnostics.empty())
       return nullptr;
-    return cxdiag::createStoredDiags(RenameDiagnostics, Context.getLangOpts());
+    llvm::SmallVector<StoredDiagnostic, 2> AllDiagnostics;
+    for (const auto &D : RenameDiagnostics)
+      AllDiagnostics.push_back(D);
+    for (const auto &D : ContinuationDiagnostics)
+      AllDiagnostics.push_back(D);
+    return cxdiag::createStoredDiags(AllDiagnostics, Context.getLangOpts());
   }
 
   CXRefactoringActionSetWithDiagnostics createActionSet() const {
@@ -1771,6 +1779,24 @@ CXIndexerQuery clang_RefactoringContinuation_getIndexerQuery(
   return &Wrapper->Queries[Index];
 }
 
+CXDiagnosticSet clang_RefactoringContinuation_verifyBeforeFinalizing(
+    CXRefactoringContinuation Continuation) {
+  if (!Continuation)
+    return nullptr;
+  auto *Wrapper = static_cast<RefactoringContinuationWrapper *>(Continuation);
+  CXTranslationUnit TU = Wrapper->Queries[0].TU;
+  ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
+  if (!CXXUnit)
+    return nullptr;
+  ASTContext &Context = CXXUnit->getASTContext();
+  RefactoringDiagnosticConsumer DiagConsumer(Context);
+  for (const auto &Query : Wrapper->Queries) {
+    if (Query.Query->verify(Context))
+      break;
+  }
+  return DiagConsumer.createDiags();
+}
+
 void clang_RefactoringContinuation_finalizeEvaluationInInitationTU(
     CXRefactoringContinuation Continuation) {
   if (!Continuation)

clang/tools/libclang/libclang.exports

@@ -398,6 +398,7 @@ clang_RefactoringResult_dispose
 clang_RefactoringContinuation_loadSerializedIndexerQueryResults
 clang_RefactoringContinuation_getNumIndexerQueries
 clang_RefactoringContinuation_getIndexerQuery
+clang_RefactoringContinuation_verifyBeforeFinalizing
 clang_RefactoringContinuation_finalizeEvaluationInInitationTU
 clang_RefactoringContinuation_continueOperationInTU
 clang_RefactoringContinuation_dispose