[test] Split out Annotations from `TestingSupport`

[rupprecht]

Summary

The Annotations helper class does not have a gtest or gmock dependency, but because it's bundled with the rest of TestingSupport, it gets one. By splitting it out, a target can use it without being forced to use LLVM's copy of gtest.

[GMNGeoffrey]

It seems like the same logic would extend to the CMake build. Could we make the same change there?

[rupprecht]

• Move annotations to a separate package entirely

[rupprecht]

In D141175#4038017, @GMNGeoffrey wrote:

It seems like the same logic would extend to the CMake build. Could we make the same change there?

The simplest (only?) way to do that is to have it literally in a separate directory, so I did that. It's a bit large now but mechanical.

[GMNGeoffrey]

LGTM (+/- nits), but maybe good to get review from someone more closely associated with the TestingSupport library

utils/bazel/llvm-project-overlay/llvm/BUILD.bazel

4529

I think this comment is now a bit redundant

[rupprecht]

• Remove redundant comment

[sammccall]

This looks good, i think it also doesn't belong in Testing/Support because it's not a peer to anything in Support/.

I think you can use PARTIAL_SOURCES_INTENDED to partition directories, but it's unusual and a bit of a hassle. Either way seems fine to me.

clang-tools-extra/clangd/unittests/Annotations.h

 //===--- Annotations.h - Annotated source code for tests ---------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-// A clangd-specific version of llvm/Testing/Support/Annotations.h, replaces
+// A clangd-specific version of llvm/Testing/Annotations/Annotations.h, replaces
 // offsets and offset-based ranges with types from the LSP protocol.
 //===---------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_ANNOTATIONS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_ANNOTATIONS_H
 
 #include "Protocol.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 
 namespace clang {
 namespace clangd {
 
 /// Same as llvm::Annotations, but adjusts functions to LSP-specific types for
 /// positions and ranges.
 class Annotations : public llvm::Annotations {
   using Base = llvm::Annotations;

clang-tools-extra/clangd/unittests/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   support
   AllTargetsInfos
   FrontendOpenMP
   )
 
 if(CLANG_BUILT_STANDALONE)
-  # LLVMTestingSupport library is needed for clangd tests.
+  # LLVMTestingSupport and LLVMTestingAnnotations are needed for clangd tests.
+  if (EXISTS ${LLVM_MAIN_SRC_DIR}/lib/Testing/Annotations
+      AND NOT TARGET LLVMTestingAnnotations)
+    add_subdirectory(${LLVM_MAIN_SRC_DIR}/lib/Testing/Annotations
+      lib/Testing/Annotations)
+  endif()
   if (EXISTS ${LLVM_MAIN_SRC_DIR}/lib/Testing/Support
       AND NOT TARGET LLVMTestingSupport)
     add_subdirectory(${LLVM_MAIN_SRC_DIR}/lib/Testing/Support
       lib/Testing/Support)
   endif()
 endif()
 
 if (CLANGD_ENABLE_REMOTE)
clang_target_link_libraries(ClangdTests
   clangToolingRefactoring
   clangToolingSyntax
   )
 target_link_libraries(ClangdTests
   PRIVATE
   clangDaemon
   clangdSupport
   clangTidy
+  LLVMTestingAnnotations
   LLVMTestingSupport
   )
 
 if (CLANGD_ENABLE_REMOTE)
   target_link_libraries(ClangdTests
     PRIVATE
     clangdRemoteMarshalling
     clangdRemoteIndexProto)

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

 #include "index/MemIndex.h"
 #include "index/SymbolOrigin.h"
 #include "support/Threading.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "llvm/Testing/Support/Error.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <condition_variable>
 #include <functional>
 #include <mutex>
 #include <vector>

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

 #include "Selection.h"
 #include "TestTU.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <initializer_list>
 
 namespace clang {
 namespace clangd {
 namespace {
 

clang-tools-extra/clangd/unittests/SourceCodeTests.cpp

 #include "SourceCode.h"
 #include "TestTU.h"
 #include "support/Context.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Format/Format.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <optional>
 #include <tuple>
 
 namespace clang {
 namespace clangd {

clang-tools-extra/clangd/unittests/tweaks/TweakTesting.h

 //===--- TweakTesting.h - Test helpers for refactoring actions ---*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TWEAKS_TWEAKTESTING_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TWEAKS_TWEAKTESTING_H
 
 #include "ParsedAST.h"
 #include "index/Index.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <memory>
 #include <string>
 
 namespace clang {
 namespace clangd {
 

clang-tools-extra/include-cleaner/unittests/AnalysisTest.cpp

 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Testing/TestAST.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ScopedPrinter.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstddef>
 
 namespace clang::include_cleaner {
 namespace {
 using testing::AllOf;
 using testing::Contains;

clang-tools-extra/include-cleaner/unittests/CMakeLists.txt

clang_target_link_libraries(ClangIncludeCleanerTests
   clangLex
   clangToolingInclusionsStdlib
   )
 
 target_link_libraries(ClangIncludeCleanerTests
   PRIVATE
   clangIncludeCleaner
   clangTesting
+  LLVMTestingAnnotations
   LLVMTestingSupport
   )
 

clang-tools-extra/include-cleaner/unittests/FindHeadersTest.cpp

 #include "clang-include-cleaner/Types.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/FileEntry.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Testing/TestAST.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <memory>
 
 namespace clang::include_cleaner {
 namespace {
 using testing::UnorderedElementsAre;
 

clang-tools-extra/include-cleaner/unittests/LocateSymbolTest.cpp

 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Testing/TestAST.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstddef>
 #include <memory>
 #include <unordered_map>
 #include <utility>
 #include <variant>
 #include <vector>

clang-tools-extra/include-cleaner/unittests/RecordTest.cpp

 //===-- RecordTest.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-include-cleaner/Record.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Testing/TestAST.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang::include_cleaner {
 namespace {
 using testing::ElementsAreArray;
 using testing::IsEmpty;
 

clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Frontend/TextDiagnostic.h"
 #include "clang/Testing/TestAST.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ScopedPrinter.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gtest/gtest.h"
 #include <cstddef>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 namespace clang::include_cleaner {
 namespace {

clang-tools-extra/pseudo/unittests/BracketTest.cpp

 //===--- BracketTest.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-pseudo/Bracket.h"
 #include "clang-pseudo/Token.h"
 #include "clang/Basic/LangOptions.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace pseudo {
 
 // Return a version of Code with each paired bracket marked with ^.
 std::string decorate(llvm::StringRef Code, const TokenStream &Stream) {

clang-tools-extra/pseudo/unittests/CMakeLists.txt

clang_target_link_libraries(ClangPseudoTests
   clangLex
   )
 
 target_link_libraries(ClangPseudoTests
   PRIVATE
   clangPseudo
   clangPseudoCXX
   clangPseudoGrammar
+  LLVMTestingAnnotations
   LLVMTestingSupport
   )

clang-tools-extra/unittests/clang-tidy/CMakeLists.txt

target_link_libraries(ClangTidyTests
   clangTidy
   clangTidyAndroidModule
   clangTidyGoogleModule
   clangTidyLLVMModule
   clangTidyModernizeModule
   clangTidyObjCModule
   clangTidyReadabilityModule
   clangTidyUtils
+  LLVMTestingAnnotations
   LLVMTestingSupport
   )

clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp

 #include "ClangTidyOptions.h"
 #include "ClangTidyCheck.h"
 #include "ClangTidyDiagnosticConsumer.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/ScopedPrinter.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <optional>
 
 namespace clang {
 namespace tidy {
 
 enum class Colours { Red, Orange, Yellow, Green, Blue, Indigo, Violet };

clang/docs/tools/clang-formatted-files.txt

 llvm/include/llvm/Support/WithColor.h
 llvm/include/llvm/Support/FileSystem/UniqueID.h
 llvm/include/llvm/Support/Solaris/sys/regset.h
 llvm/include/llvm/TableGen/DirectiveEmitter.h
 llvm/include/llvm/TableGen/Parser.h
 llvm/include/llvm/TableGen/StringToOffsetTable.h
 llvm/include/llvm/Target/CGPassBuilderOption.h
 llvm/include/llvm/Target/CodeGenCWrappers.h
-llvm/include/llvm/Testing/Support/Annotations.h
+llvm/include/llvm/Testing/Annotations/Annotations.h
 llvm/include/llvm/Testing/Support/SupportHelpers.h
 llvm/include/llvm/TextAPI/Architecture.h
 llvm/include/llvm/TextAPI/ArchitectureSet.h
 llvm/include/llvm/TextAPI/InterfaceFile.h
 llvm/include/llvm/TextAPI/PackedVersion.h
 llvm/include/llvm/TextAPI/Platform.h
 llvm/include/llvm/TextAPI/Symbol.h
 llvm/include/llvm/TextAPI/Target.h

 llvm/lib/Target/X86/MCTargetDesc/X86TargetStreamer.h
 llvm/lib/Target/X86/TargetInfo/X86TargetInfo.cpp
 llvm/lib/Target/XCore/XCoreTargetMachine.h
 llvm/lib/Target/XCore/XCoreTargetTransformInfo.h
 llvm/lib/Target/XCore/MCTargetDesc/XCoreMCAsmInfo.h
 llvm/lib/Target/XCore/MCTargetDesc/XCoreMCTargetDesc.cpp
 llvm/lib/Target/XCore/MCTargetDesc/XCoreMCTargetDesc.h
 llvm/lib/Target/XCore/TargetInfo/XCoreTargetInfo.cpp
-llvm/lib/Testing/Support/Annotations.cpp
+llvm/lib/Testing/Annotations/Annotations.cpp
 llvm/lib/Testing/Support/Error.cpp
 llvm/lib/Testing/Support/SupportHelpers.cpp
 llvm/lib/TextAPI/ArchitectureSet.cpp
 llvm/lib/TextAPI/InterfaceFile.cpp
 llvm/lib/TextAPI/PackedVersion.cpp
 llvm/lib/TextAPI/Platform.cpp
 llvm/lib/TextAPI/Symbol.cpp
 llvm/lib/TextAPI/Target.cpp

clang/unittests/AST/CMakeLists.txt

clang_target_link_libraries(ASTTests
   clangLex
   clangSerialization
   clangTooling
   )
 
 target_link_libraries(ASTTests
   PRIVATE
   clangTesting
+  LLVMTestingAnnotations
   LLVMTestingSupport
 )

clang/unittests/AST/DeclTest.cpp

 #include "clang/AST/Mangle.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/IR/DataLayout.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gtest/gtest.h"
 
 using namespace clang::ast_matchers;
 using namespace clang::tooling;
 using namespace clang;
 
 TEST(Decl, CleansUpAPValues) {
   MatchFinder Finder;

clang/unittests/AST/SourceLocationTest.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "MatchVerifier.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Tooling/Tooling.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace clang::ast_matchers;
 
 namespace {
 
 // FIXME: Pull the *Verifier tests into their own test file.

clang/unittests/Analysis/FlowSensitive/CMakeLists.txt

clang_target_link_libraries(ClangAnalysisFlowSensitiveTests
   clangLex
   clangSerialization
   clangTooling
   )
 
 target_link_libraries(ClangAnalysisFlowSensitiveTests
   PRIVATE
   clangTesting
+  LLVMTestingAnnotations
   LLVMTestingSupport
   )

clang/unittests/Analysis/FlowSensitive/SignAnalysisTest.cpp

 
 #include "TestingSupport.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Analysis/FlowSensitive/CFGMatchSwitch.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
 #include "clang/Analysis/FlowSensitive/NoopLattice.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 #include <memory>
 
 namespace {
 
 using namespace clang;
 using namespace dataflow;

clang/unittests/Analysis/FlowSensitive/SingleVarConstantPropagationTest.cpp

 #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
 #include "clang/Analysis/FlowSensitive/DataflowLattice.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/ADT/StringMapEntry.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 
 namespace clang {
 namespace dataflow {
 
 // Requires a `<<` operator for the `Lattice` type.
 // FIXME: move to a non-test utility library.
 template <typename Lattice>
 std::ostream &operator<<(std::ostream &OS,

clang/unittests/Analysis/FlowSensitive/TestingSupport.cpp

 #include "TestingSupport.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/Stmt.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include <cassert>
 #include <functional>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
 

clang/unittests/Analysis/FlowSensitive/TransferBranchTest.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "TestingSupport.h"
 #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 namespace clang::dataflow::test {
 namespace {
 
 using namespace ast_matchers;
 

clang/unittests/Sema/CMakeLists.txt

clang_target_link_libraries(SemaTests
   clangSema
   clangSerialization
   clangTooling
   )
 
 target_link_libraries(SemaTests
   PRIVATE
   clangTesting
+  LLVMTestingAnnotations
   LLVMTestingSupport
 )

clang/unittests/Sema/CodeCompleteTest.cpp

 //=== unittests/Sema/CodeCompleteTest.cpp - Code Complete tests ==============//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Parse/ParseAST.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "clang/Tooling/Tooling.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstddef>
 #include <string>
 
 namespace {
 
 using namespace clang;

clang/unittests/Tooling/CMakeLists.txt

clang_target_link_libraries(ToolingTests
   clangToolingInclusions
   clangToolingInclusionsStdlib
   clangToolingRefactoring
   clangTransformer
   )
 
 target_link_libraries(ToolingTests
   PRIVATE
+  LLVMTestingAnnotations
   LLVMTestingSupport
   clangTesting
 )
 
 add_subdirectory(Syntax)

clang/unittests/Tooling/SourceCodeTest.cpp

 //===- unittest/Tooling/SourceCodeTest.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/Transformer/SourceCode.h"
 #include "TestVisitor.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/Lexer.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "llvm/Testing/Support/Error.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 using namespace clang;
 
 using llvm::Failed;

clang/unittests/Tooling/Syntax/CMakeLists.txt

clang_target_link_libraries(SyntaxTests
   clangTooling
   clangToolingCore
   clangToolingSyntax
   )
 
 target_link_libraries(SyntaxTests
   PRIVATE
   clangTesting
+  LLVMTestingAnnotations
   LLVMTestingSupport
 )

clang/unittests/Tooling/Syntax/TokensTest.cpp

 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_os_ostream.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
 #include <cassert>
 #include <cstdlib>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <memory>
 #include <ostream>
 #include <string>

clang/unittests/Tooling/Syntax/TreeTestBase.h

 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Testing/TestClangConfig.h"
 #include "clang/Tooling/Syntax/Nodes.h"
 #include "clang/Tooling/Syntax/TokenBufferTokenManager.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "clang/Tooling/Syntax/Tree.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ScopedPrinter.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace syntax {
 class SyntaxTreeTest : public ::testing::Test,
                        public ::testing::WithParamInterface<TestClangConfig> {
 protected:

clang/unittests/Tooling/Syntax/TreeTestBase.cpp

 #include "clang/Tooling/Syntax/BuildTree.h"
 #include "clang/Tooling/Syntax/Nodes.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "clang/Tooling/Syntax/Tree.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace clang::syntax;
 
 namespace {
 ArrayRef<syntax::Token> tokens(syntax::Node *N,
                                const TokenBufferTokenManager &STM) {

llvm/lib/Testing/Annotations/Annotations.cpp

 //===--- Annotations.cpp - Annotated source code for unit tests --*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 // Crash if the assertion fails, printing the message and testcase.

llvm/lib/Testing/Annotations/CMakeLists.txt

+# Do not build unittest libraries automatically, they will be pulled in
+# by unittests if these are built.
+set(EXCLUDE_FROM_ALL ON)
+
+add_llvm_library(LLVMTestingAnnotations
+  Annotations.cpp
+
+  BUILDTREE_ONLY
+
+  ADDITIONAL_HEADER_DIRS
+  ${LLVM_MAIN_INCLUDE_DIR}/llvm/Testing/Support
+
+  LINK_COMPONENTS
+  Support
+  )

llvm/lib/Testing/CMakeLists.txt

+add_subdirectory(Annotations)
 add_subdirectory(Support)

llvm/lib/Testing/Support/CMakeLists.txt

 # Do not build unittest libraries automatically, they will be pulled in
 # by unittests if these are built.
 set(EXCLUDE_FROM_ALL ON)
 
 add_llvm_library(LLVMTestingSupport
-  Annotations.cpp
   Error.cpp
   SupportHelpers.cpp
 
   BUILDTREE_ONLY
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Testing/Support
 

llvm/unittests/Support/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   TargetParser
   )
 
 add_llvm_unittest(SupportTests
   AddressRangeTest.cpp
   AlignmentTest.cpp
   AlignOfTest.cpp
   AllocatorTest.cpp
-  AnnotationsTest.cpp
   ARMAttributeParser.cpp
   ArrayRecyclerTest.cpp
   Base64Test.cpp
   BinaryStreamTest.cpp
   BLAKE3Test.cpp
   BlockFrequencyTest.cpp
   BranchProbabilityTest.cpp
   CachePruningTest.cpp

llvm/unittests/Testing/Annotations/AnnotationsTest.cpp

 //===----- unittests/AnnotationsTest.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-#include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using ::testing::AllOf;
 using ::testing::ElementsAre;
 using ::testing::IsEmpty;
 using ::testing::Pair;
 using ::testing::ResultOf;

llvm/unittests/Testing/Annotations/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  Support
+  TestingAnnotations
+  )
+
+add_llvm_unittest(TestingAnnotationTests
+  AnnotationsTest.cpp
+  )
+
+target_link_libraries(TestingAnnotationTests PRIVATE LLVMTestingAnnotations)

llvm/unittests/Testing/CMakeLists.txt

 add_subdirectory(ADT)
+add_subdirectory(Annotations)
 add_subdirectory(Support)

utils/bazel/llvm-project-overlay/clang/unittests/BUILD.bazel

deps = [
         "//clang:ast_matchers",
         "//clang:basic",
         "//clang:frontend",
         "//clang:lex",
         "//clang:testing",
         "//clang:tooling",
         "//llvm:Core",
         "//llvm:Support",
+        "//llvm:TestingAnnotations",
         "//llvm:TestingSupport",
         "//third-party/unittest:gmock",
         "//third-party/unittest:gtest",
         "//third-party/unittest:gtest_main",
     ],
 )
 
 cc_library(
deps = [
         "//clang:ast",
         "//clang:ast_matchers",
         "//clang:basic",
         "//clang:lex",
         "//clang:serialization",
         "//clang:tooling",
         "//llvm:Support",
         "//llvm:TestingADT",
+        "//llvm:TestingAnnotations",
         "//llvm:TestingSupport",
         "//third-party/unittest:gmock",
         "//third-party/unittest:gtest",
         "//third-party/unittest:gtest_main",
     ],
 )
 
 cc_test(
deps = [
         ":ast_matchers_tests_hdrs",
         "//clang:ast",
         "//clang:ast_matchers",
         "//clang:frontend",
         "//clang:lex",
         "//clang:parse",
         "//clang:sema",
         "//clang:tooling",
+        "//llvm:TestingAnnotations",
         "//llvm:TestingSupport",
         "//third-party/unittest:gmock",
         "//third-party/unittest:gtest",
         "//third-party/unittest:gtest_main",
     ],
 )
 
 cc_library(
deps = [
         "//clang:testing",
         "//clang:tooling",
         "//clang:tooling_core",
         "//clang:tooling_dependency_scanning",
         "//clang:tooling_inclusions",
         "//clang:tooling_refactoring",
         "//clang:transformer",
         "//llvm:Support",
+        "//llvm:TestingAnnotations",
         "//llvm:TestingSupport",
         "//third-party/unittest:gmock",
         "//third-party/unittest:gtest",
         "//third-party/unittest:gtest_main",
     ],
 )
 
 # A library to carefully expose the tooling headers using the include prefix
deps = [
         "//clang:basic",
         "//clang:frontend",
         "//clang:lex",
         "//clang:testing",
         "//clang:tooling",
         "//clang:tooling_core",
         "//clang:tooling_syntax",
         "//llvm:Support",
+        "//llvm:TestingAnnotations",
         "//llvm:TestingSupport",
         "//third-party/unittest:gmock",
         "//third-party/unittest:gtest",
         "//third-party/unittest:gtest_main",
     ],
 )
 
 cc_test(

utils/bazel/llvm-project-overlay/llvm/BUILD.bazel

 
 cc_library(
     name = "TestingSupport",
     testonly = True,
     srcs = glob([
         "lib/Testing/Support/*.cpp",
         "lib/Testing/Support/*.h",
     ]),
-    hdrs = glob([
-        "include/llvm/Testing/Support/*.h",
-    ]),
+    hdrs = glob(["include/llvm/Testing/Support/*.h"]),
     copts = llvm_copts,
     deps = [
         ":Support",
         ":config",
         "//third-party/unittest:gmock",
         "//third-party/unittest:gtest",
     ],
 )
 
+cc_library(
+    name = "TestingAnnotations",
+    testonly = True,
+    srcs = ["lib/Testing/Annotations/Annotations.cpp"],
+    hdrs = ["include/llvm/Testing/Annotations/Annotations.h"],
+    copts = llvm_copts,
+    deps = [":Support"],
+)
+
 ################################################################################
 # Begin testonly binary utilities
 
 cc_binary(
     name = "FileCheck",
     testonly = True,
     srcs = glob([
         "utils/FileCheck/*.cpp",