Disable warnings when indexing as a standalone action.

[sammccall]

Summary

• we don't record the warnings at all
• even when -Werror is set, we don't want to stop indexing for a warning
• this allows some analyses to be skipped which can save some CPU

https://github.com/clangd/clangd/issues/24

[hokein]

clangd/index/IndexAction.cpp

140 ↗

(On Diff #192636)

Can we add a unittest for this?

IIRC, IgnoreWarnings option must be set before CompilerInstance is created, otherwise it doesn't take affect, see https://github.com/llvm-mirror/clang-tools-extra/blob/master/clangd/CodeComplete.cpp#L1029

[sammccall]

Add tests, fix setting the flag too late.

[sammccall]

fix baseline

[sammccall]

clangd/index/IndexAction.cpp

140 ↗

(On Diff #192636)

Added test, thanks.

You're right, the flag has already been copied to the diagnostics client. It's too late to set it here.

Unfortunately we don't control where the CompilerInstance is created, but this is semantically the right layer to make the decision to suppress warnings. So I've just set it on the diagnostics client too :-/

[hokein]

clangd/index/IndexAction.cpp

138 ↗

(On Diff #192651)

I think -Werror is't set should be -Werror is set?

clang-tools-extra/trunk/clangd/index/IndexAction.cpp

if (IncludeGraphCallback != nullptr)
       CI.getPreprocessor().addPPCallbacks(
           llvm::make_unique<IncludeGraphCollector>(CI.getSourceManager(), IG));
     return WrapperFrontendAction::CreateASTConsumer(CI, InFile);
   }
 
   bool BeginInvocation(CompilerInstance &CI) override {
     // We want all comments, not just the doxygen ones.
     CI.getLangOpts().CommentOpts.ParseAllComments = true;
+    // Index the whole file even if there are warnings and -Werror is set.
+    // Avoids some analyses too. Set in two places as we're late to the party.
+    CI.getDiagnosticOpts().IgnoreWarnings = true;
+    CI.getDiagnostics().setIgnoreAllWarnings(true);
+
     return WrapperFrontendAction::BeginInvocation(CI);
   }
 
   void EndSourceFileAction() override {
     WrapperFrontendAction::EndSourceFileAction();
 
     const auto &CI = getCompilerInstance();
     if (CI.hasDiagnostics() &&

clang-tools-extra/trunk/unittests/clangd/IndexActionTests.cpp

 using ::testing::UnorderedPointwise;
 
 std::string toUri(llvm::StringRef Path) { return URI::create(Path).toString(); }
 
 MATCHER(IsTU, "") { return arg.IsTU; }
 
 MATCHER_P(HasDigest, Digest, "") { return arg.Digest == Digest; }
 
+MATCHER_P(HasName, Name, "") { return arg.Name == Name; }
+
 MATCHER(HasSameURI, "") {
   llvm::StringRef URI = testing::get<0>(arg);
   const std::string &Path = testing::get<1>(arg);
   return toUri(Path) == URI;
 }
 
 testing::Matcher<const IncludeGraphNode &>
 IncludesAre(const std::vector<std::string> &Includes) {
   return ::testing::Field(&IncludeGraphNode::DirectIncludes,
                           UnorderedPointwise(HasSameURI(), Includes));
 }
 
 void checkNodesAreInitialized(const IndexFileIn &IndexFile,
                               const std::vector<std::string> &Paths) {
+  ASSERT_TRUE(IndexFile.Sources);
   EXPECT_THAT(Paths.size(), IndexFile.Sources->size());
   for (llvm::StringRef Path : Paths) {
     auto URI = toUri(Path);
     const auto &Node = IndexFile.Sources->lookup(URI);
     // Uninitialized nodes will have an empty URI.
     EXPECT_EQ(Node.URI.data(), IndexFile.Sources->find(URI)->getKeyData());
   }
 }
EXPECT_THAT(
       UnorderedElementsAre(
           Pair(toUri(MainFilePath),
                AllOf(IsTU(), IncludesAre({MainFilePath, HeaderPath}),
                      HasDigest(digest(MainCode)))),
           Pair(toUri(HeaderPath), AllOf(Not(IsTU()), IncludesAre({}),
                                         HasDigest(digest(HeaderCode))))));
 }
 
+TEST_F(IndexActionTest, NoWarnings) {
+  std::string MainFilePath = testPath("main.cpp");
+  std::string MainCode = R"cpp(
+      void foo(int x) {
+        if (x = 1) // -Wparentheses
+          return;
+        if (x = 1) // -Wparentheses
+          return;
+      }
+      void bar() {}
+  )cpp";
+  addFile(MainFilePath, MainCode);
+  // We set -ferror-limit so the warning-promoted-to-error would be fatal.
+  // This would cause indexing to stop (if warnings weren't disabled).
+  IndexFileIn IndexFile = runIndexingAction(
+      MainFilePath, {"-ferror-limit=1", "-Wparentheses", "-Werror"});
+  ASSERT_TRUE(IndexFile.Sources);
+  ASSERT_NE(0u, IndexFile.Sources->size());
+  EXPECT_THAT(*IndexFile.Symbols, ElementsAre(HasName("foo"), HasName("bar")));
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang