[clangd] cleanup of header guard names

[kuhnel]

Summary

Renaming header guards to match the LLVM convention.
This patch was created by automatically applying the fixes from
clang-tidy.

I've removed the [NFC] tag from the title, as we're adding header guards in some files and thus might trigger behavior changes.

[sammccall]

Mostly LG, just a few files are test inputs and one is empty

clang-tools-extra/clangd/test/Inputs/background-index/sub_dir/foo.h

1 ↗

(On Diff #387251)

Please don't modify tests, they don't need to follow LLVM style and should be as simple as possible

clang-tools-extra/clangd/test/index-serialization/Inputs/sample.h

1 ↗

(On Diff #387251)

In particular, adding header guards to test files without them isn't NFC

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

1

What's up with this change?
If this file is empty it should just be deleted instead

[kuhnel]

addresed Sam's comments

[kuhnel]

clang-tools-extra/clangd/PathMapping.h

9

Looks like the include guards were missing here. I suppose this is something we want to add.

clang-tools-extra/clangd/test/Inputs/background-index/sub_dir/foo.h

1 ↗

(On Diff #387251)

I was iterating over all .cpp and .h files, so the test data ended up in the changes as well.

I suppose the only way to avoid this is to use the run-clang-tidy.py wraper script instead

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

7

Same here. I suppose we want header guards in this one.

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

1

Deleting the file

[kbobyrev]

clang-tools-extra/clangd/PathMapping.h

8

Please move the header guard after the comment like we do in the other files.

73

Please add a closing comment (// LLVM_CLANG_TOOLS_EXTRA_CLANGD_PATHMAPPING_H)

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

6

Please move the header guard after the comment like we do in the other files.

87

Also needs a closing comment.

[kadircet]

LG apart from closing comments, some of the files have it and some don't (apart from the newly introduced ones, it didn't add it to the files that didn't have a closing comment, but updated the ones that had).
The code from the tidy check looks like it should be handling this case, can you check what's going on?

[kuhnel]

addressed review comments

[kuhnel]

@kadircet looks like clang-tidy does not detect missing comments in #endif. It does complain about missing comments for namespaces. E.g. in Serialization.h the #endif comment is missing, but without a finding.

[kbobyrev]

Also, please mention the

In D113896#3166732, @kuhnel wrote:

@kadircet looks like clang-tidy does not detect missing comments in #endif. It does complain about missing comments for namespaces. E.g. in Serialization.h the #endif comment is missing, but without a finding.

This looks to be a deliberate decision: https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/clang-tidy/llvm/HeaderGuardCheck.h#L32

Looking at the code under clang/include, it looks like most headers don't have the #endif // COMMENT, so this might be correct. However, the style guide is rather vague and doesn't mention this at all: https://llvm.org/docs/CodingStandards.html#header-guard

[kadircet]

This looks to be a deliberate decision: https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/clang-tidy/llvm/HeaderGuardCheck.h#L32

Looking at the code under clang/include, it looks like most headers don't have the #endif // COMMENT, so this might be correct. However, the style guide is rather vague and doesn't mention this at all: https://llvm.org/docs/CodingStandards.html#header-guard

ah right, I was looking at https://github.com/llvm/llvm-project/blob/main/clang-tools-extra/clang-tidy/utils/HeaderGuard.cpp#L289, which happens to be the base class. thanks!

clang-tools-extra/clangd/CollectMacros.h

 //===--- CollectMacros.h -----------------------------------------*- 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_COLLECTEDMACROS_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_COLLECTEDMACROS_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_COLLECTMACROS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_COLLECTMACROS_H
 
 #include "AST.h"
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "index/SymbolID.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "llvm/ADT/DenseMap.h"

 
 /// Collect all pragma marks from the main file.
 std::unique_ptr<PPCallbacks>
 collectPragmaMarksCallback(const SourceManager &, std::vector<PragmaMark> &Out);
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_COLLECTEDMACROS_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_COLLECTMACROS_H

clang-tools-extra/clangd/ExpectedTypes.h

 // without looking at the ASTs. Note that we don't aim to fully mimic the C++
 // conversion rules, merely try to have a model that gives useful improvements
 // to the code completion ranking.
 //
 // We define an encoding of AST types as opaque strings, which can be stored in
 // the index. Similar types (such as `int` and `long`) are folded together,
 // forming equivalence classes with the same encoding.
 //===----------------------------------------------------------------------===//
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_EXPECTED_TYPES_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_EXPECTED_TYPES_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_EXPECTEDTYPES_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_EXPECTEDTYPES_H
 
 #include "clang/AST/Type.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 class CodeCompletionResult;
 
 namespace clangd {

clang-tools-extra/clangd/FindTarget.h

 //
 // Historically, we have used libIndex (IndexDataConsumer) to tie source
 // locations to referenced declarations. This file defines a more decoupled
 // approach based around AST nodes (DynTypedNode), and can be combined with
 // SelectionTree or other traversals.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_FINDTARGET_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_FINDTARGET_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_FINDTARGET_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_FINDTARGET_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/Stmt.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
inline DeclRelationSet operator&(DeclRelation L, DeclRelation R) {
   return DeclRelationSet(L) & DeclRelationSet(R);
 }
 inline DeclRelationSet operator~(DeclRelation R) { return ~DeclRelationSet(R); }
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, DeclRelationSet);
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_FINDTARGET_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_FINDTARGET_H

clang-tools-extra/clangd/HeaderSourceSwitch.h

 //===--- HeaderSourceSwitch.h - ----------------------------------*- 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_UNITTESTS_CLANGD_HEADERSOURCESWITCH_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_HEADERSOURCESWITCH_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_HEADERSOURCESWITCH_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_HEADERSOURCESWITCH_H
 
 #include "ParsedAST.h"
 #include "llvm/ADT/Optional.h"
 
 namespace clang {
 namespace clangd {
 
 /// Given a header file, returns the best matching source file, and vice visa.

 
 /// Returns all indexable decls that are present in the main file of the AST.
 /// Exposed for unittests.
 std::vector<const Decl *> getIndexableLocalDecls(ParsedAST &AST);
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_HEADERSOURCESWITCH_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_HEADERSOURCESWITCH_H

clang-tools-extra/clangd/HeuristicResolver.h

 //===--- HeuristicResolver.h - Resolution of dependent names -----*- 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_HEURISTIC_RESOLVER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_HEURISTIC_RESOLVER_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_HEURISTICRESOLVER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_HEURISTICRESOLVER_H
 
 #include "clang/AST/Decl.h"
 #include "llvm/ADT/STLExtras.h"
 #include <vector>
 
 namespace clang {
 
 class ASTContext;

clang-tools-extra/clangd/IncludeCleaner.h

 /// to provide useful warnings in most popular scenarios but not 1:1 exact
 /// feature compatibility.
 ///
 /// FIXME(kirillbobyrev): Add support for IWYU pragmas.
 /// FIXME(kirillbobyrev): Add support for standard library headers.
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDE_CLEANER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDE_CLEANER_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDECLEANER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDECLEANER_H
 
 #include "Headers.h"
 #include "ParsedAST.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseSet.h"
 #include <vector>
 
 namespace clang {

 std::vector<const Inclusion *> computeUnusedIncludes(ParsedAST &AST);
 
 std::vector<Diag> issueUnusedIncludesDiagnostics(ParsedAST &AST,
                                                  llvm::StringRef Code);
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDE_CLEANER_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDECLEANER_H

clang-tools-extra/clangd/IncludeFixer.h

 //===--- IncludeFixer.h ------------------------------------------*- 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_INCLUDE_FIXER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDE_FIXER_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDEFIXER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDEFIXER_H
 
 #include "Diagnostics.h"
 #include "Headers.h"
 #include "index/Index.h"
 #include "index/Symbol.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceLocation.h"
private:
   llvm::Optional<const SymbolSlab *>
   fuzzyFindCached(const FuzzyFindRequest &Req) const;
   llvm::Optional<const SymbolSlab *> lookupCached(const SymbolID &ID) const;
 };
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDE_FIXER_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INCLUDEFIXER_H

clang-tools-extra/clangd/InlayHints.h

 //===--- InlayHints.h --------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Support for the proposed "inlay hints" LSP feature.
 // The version currently implemented is the one proposed here:
 // https://github.com/microsoft/vscode-languageserver-node/pull/609/.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INLAY_HINTS_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INLAY_HINTS_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INLAYHINTS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INLAYHINTS_H
 
 #include "Protocol.h"
 #include <vector>
 
 namespace clang {
 namespace clangd {
 class ParsedAST;
 
 // Compute and return all inlay hints for a file.
 std::vector<InlayHint> inlayHints(ParsedAST &AST);
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INLAY_HINTS_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INLAYHINTS_H

clang-tools-extra/clangd/PathMapping.h

 //===--- PathMapping.h - apply path mappings to LSP messages -===//
 //
 // 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_PATHMAPPING_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PATHMAPPING_H
+
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 #include <string>
 #include <vector>

 /// all inbound and outbound LSP messages. All calls are then delegated to the
 /// regular transport (e.g. XPC, JSON).
 std::unique_ptr<Transport>
 createPathMappingTransport(std::unique_ptr<Transport> Transp,
                            PathMappings Mappings);
 
 } // namespace clangd
 } // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_PATHMAPPING_H

clang-tools-extra/clangd/URI.h

 //===--- URI.h - File URIs with schemes --------------------------*- 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_PATHURI_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PATHURI_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_URI_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_URI_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Registry.h"
 
 namespace clang {
 namespace clangd {
 

 
 /// By default, a "file" scheme is supported where URI paths are always absolute
 /// in the file system.
 typedef llvm::Registry<URIScheme> URISchemeRegistry;
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_PATHURI_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_URI_H

clang-tools-extra/clangd/index/BackgroundIndexLoader.h

 //===--- BackgroundIndexLoader.h - Load shards from index storage-*- 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_INDEX_BACKGROUND_INDEX_LOADER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_BACKGROUND_INDEX_LOADER_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_BACKGROUNDINDEXLOADER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_BACKGROUNDINDEXLOADER_H
 
 #include "index/Background.h"
 #include "support/Path.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"

clang-tools-extra/clangd/index/BackgroundRebuild.h

 //===--- BackgroundIndexRebuild.h - when to rebuild the bg index--*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains an implementation detail of the background indexer
 // (Background.h), which is exposed for testing.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_BACKGROUND_INDEX_REBUILD_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_BACKGROUND_INDEX_REBUILD_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_BACKGROUNDREBUILD_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_BACKGROUNDREBUILD_H
 
 #include "index/FileIndex.h"
 #include "index/Index.h"
 #include "llvm/Support/Threading.h"
 #include <cstddef>
 
 namespace clang {
 namespace clangd {

clang-tools-extra/clangd/index/CanonicalIncludes.h

 ///   and affects behavior in a limited scope.
 /// - associated: extremely rare
 std::unique_ptr<CommentHandler>
 collectIWYUHeaderMaps(CanonicalIncludes *Includes);
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_HEADERMAPCOLLECTOR_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_CANONICALINCLUDES_H

clang-tools-extra/clangd/index/IndexAction.h

 //===--- IndexAction.h - Run the indexer as a frontend action ----*- 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_INDEX_INDEX_ACTION_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_INDEX_ACTION_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_INDEXACTION_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_INDEXACTION_H
 #include "Headers.h"
 #include "SymbolCollector.h"
 #include "clang/Frontend/FrontendActions.h"
 
 namespace clang {
 namespace clangd {
 
 // Creates an action that indexes translation units and delivers the results

clang-tools-extra/clangd/index/ProjectAware.h

 //===--- ProjectAware.h ------------------------------------------*- 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_INDEX_PROJECT_AWARE_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_PROJECT_AWARE_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_PROJECTAWARE_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_PROJECTAWARE_H
 
 #include "Config.h"
 #include "index/Index.h"
 #include "support/Threading.h"
 #include <functional>
 #include <memory>
 namespace clang {
 namespace clangd {

clang-tools-extra/clangd/index/Serialization.h

 // The format has a simple versioning scheme: the format version number is
 // written in the file and non-current versions are rejected when reading.
 //
 // Human-readable YAML serialization is also supported, and recommended for
 // debugging and experiments only.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_RIFF_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_RIFF_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SERIALIZATION_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SERIALIZATION_H
 
 #include "Headers.h"
 #include "Index.h"
 #include "index/Symbol.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/Support/Error.h"
 
 namespace clang {

clang-tools-extra/clangd/index/SymbolCollector.h

 //===--- SymbolCollector.h ---------------------------------------*- 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_INDEX_SYMBOL_COLLECTOR_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOL_COLLECTOR_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOLCOLLECTOR_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOLCOLLECTOR_H
 
 #include "CanonicalIncludes.h"
 #include "CollectMacros.h"
 #include "Index.h"
 #include "SymbolOrigin.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/Basic/SourceLocation.h"

clang-tools-extra/clangd/index/SymbolLocation.h

 //===--- SymbolLocation.h ----------------------------------------*- 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_INDEX_SYMBOL_LOCATION_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOL_LOCATION_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOLLOCATION_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOLLOCATION_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 
 namespace clang {
 namespace clangd {
 
inline bool operator<(const SymbolLocation &L, const SymbolLocation &R) {
   return std::tie(L.Start, L.End) < std::tie(R.Start, R.End);
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const SymbolLocation &);
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOL_LOCATION_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOLLOCATION_H

clang-tools-extra/clangd/index/SymbolOrigin.h

 //===--- SymbolOrigin.h ------------------------------------------*- 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_INDEX_SYMBOL_ORIGIN_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOL_ORIGIN_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOLORIGIN_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOLORIGIN_H
 
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 
 namespace clang {
 namespace clangd {
 
 // Describes the source of information about a symbol.
return static_cast<SymbolOrigin>(static_cast<uint8_t>(A) &
                                    static_cast<uint8_t>(B));
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, SymbolOrigin);
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOL_ORIGIN_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOLORIGIN_H

clang-tools-extra/clangd/index/dex/Token.h

 /// The symbol std::cout might have the tokens:
 /// * Scope "std::"
 /// * Trigram "cou"
 /// * Trigram "out"
 /// * Type "std::ostream"
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_DEX_TOKEN_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_DEX_TOKEN_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_TOKEN_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_TOKEN_H
 
 #include "index/Index.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 #include <vector>
 
 namespace clang {
template <> struct DenseMapInfo<clang::clangd::dex::Token> {
   static bool isEqual(const clang::clangd::dex::Token &LHS,
                       const clang::clangd::dex::Token &RHS) {
     return LHS == RHS;
   }
 };
 
 } // namespace llvm
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_DEX_TOKEN_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_TOKEN_H

clang-tools-extra/clangd/index/dex/Trigram.h

 ///
 /// Trigram sets extracted from unqualified name and from query are different:
 /// the set of query trigrams only contains consecutive sequences of three
 /// characters (which is only a subset of all trigrams generated for an
 /// identifier).
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_DEX_TRIGRAM_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_DEX_TRIGRAM_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_TRIGRAM_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_TRIGRAM_H
 
 #include "Token.h"
 #include "llvm/ADT/bit.h"
 
 #include <string>
 
 namespace clang {
 namespace clangd {
static unsigned getHashValue(Trigram V) {
     return X;
   }
   static bool isEqual(const Trigram &LHS, const Trigram &RHS) {
     return LHS == RHS;
   }
 };
 } // namespace llvm
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_DEX_TRIGRAM_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_TRIGRAM_H

clang-tools-extra/clangd/index/remote/Client.h

 //===--- Client.h - Connect to a remote index via gRPC -----------*- 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_INDEX_REMOTE_INDEX_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_REMOTE_INDEX_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_REMOTE_CLIENT_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_REMOTE_CLIENT_H
 
 #include "index/Index.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace clangd {
 namespace remote {
 

 /// if the project was compiled without Remote Index support.
 std::unique_ptr<clangd::SymbolIndex> getClient(llvm::StringRef Address,
                                                llvm::StringRef IndexRoot);
 
 } // namespace remote
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_REMOTE_INDEX_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_REMOTE_CLIENT_H

clang-tools-extra/clangd/refactor/Tweak.h

 // The actions are executed in two stages:
 //   - Stage 1 should check whether the action is available in a current
 //     context. It should be cheap and fast to compute as it is executed for all
 //     available actions on every client request, which happen quite frequently.
 //   - Stage 2 is performed after stage 1 and can be more expensive to compute.
 //     It is performed when the user actually chooses the action.
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_REFACTOR_ACTIONS_TWEAK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_REFACTOR_ACTIONS_TWEAK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_REFACTOR_TWEAK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_REFACTOR_TWEAK_H
 
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "Selection.h"
 #include "SourceCode.h"
 #include "index/Index.h"
 #include "support/Path.h"
 #include "clang/Tooling/Core/Replacement.h"

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
 // offsets and offset-based ranges with types from the LSP protocol.
 //===---------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_ANNOTATIONS_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_ANNOTATIONS_H
+#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"
 
 namespace clang {
 namespace clangd {
 
 /// Same as llvm::Annotations, but adjusts functions to LSP-specific types for
public:
 
   clangd::Range range(llvm::StringRef Name = "") const;
   std::vector<clangd::Range> ranges(llvm::StringRef Name = "") const;
 };
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_ANNOTATIONS_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_ANNOTATIONS_H

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

 //===-- LSPClient.h - Helper for ClangdLSPServer 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
 //
 //===----------------------------------------------------------------------===//
 
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_LSPCLIENT_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_LSPCLIENT_H
+
 #include <condition_variable>
 #include <deque>
 #include <llvm/ADT/Optional.h>
 #include <llvm/Support/Error.h>
 #include <llvm/Support/JSON.h>
 #include <mutex>
 
 namespace clang {
public:
   // Get the transport used to connect this client to a ClangdLSPServer.
   Transport &transport();
 
 private:
 };
 
 } // namespace clangd
 } // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_LSPCLIENT_H

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

 //===-- Matchers.h ----------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // GMock matchers that aren't specific to particular tests.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_MATCHERS_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_MATCHERS_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_MATCHERS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_MATCHERS_H
 #include "Protocol.h"
 #include "gmock/gmock.h"
 
 namespace clang {
 namespace clangd {
 using ::testing::Matcher;
 
 // EXPECT_IFF expects matcher if condition is true, and Not(matcher) if false.

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

 //===--- SyncAPI.h - Sync version of ClangdServer's API ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains synchronous versions of ClangdServer's async API. We
 // deliberately don't expose the sync API outside tests to encourage using the
 // async versions in clangd code.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_SYNCAPI_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_SYNCAPI_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_SYNCAPI_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_SYNCAPI_H
 
 #include "ClangdServer.h"
 #include "index/Index.h"
 
 namespace clang {
 namespace clangd {
 
 // Calls addDocument and then blockUntilIdleForTest.

 runSwitchHeaderSource(ClangdServer &Server, PathRef File);
 
 llvm::Error runCustomAction(ClangdServer &Server, PathRef File,
                             llvm::function_ref<void(InputsAndAST)>);
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_SYNCAPI_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_SYNCAPI_H

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

 //===-- TestFS.h ------------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Allows setting up fake filesystem environments for tests.
 //
 //===----------------------------------------------------------------------===//
-#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TESTFS_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TESTFS_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTFS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTFS_H
 #include "ClangdServer.h"
 #include "GlobalCompilationDatabase.h"
 #include "support/Path.h"
 #include "support/ThreadsafeFS.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Path.h"

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

 //===-- IndexHelpers.h ------------------------------------------*- 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_UNITTESTS_CLANGD_INDEXTESTCOMMON_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_INDEXTESTCOMMON_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTINDEX_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTINDEX_H
 
 #include "index/Index.h"
 #include "index/Merge.h"
 
 namespace clang {
 namespace clangd {
 
 // Creates Symbol instance and sets SymbolID to given QualifiedName.

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

 //===--- TestTU.h - Scratch source files for testing -------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Many tests for indexing, code completion etc are most naturally expressed
 // using code examples.
 // TestTU lets test define these examples in a common way without dealing with
 // the mechanics of VFS and compiler interactions, and then easily grab the
 // AST, particular symbols, etc.
 //
 //===---------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TESTTU_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TESTTU_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTTU_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTTU_H
 
 #include "../TidyProvider.h"
 #include "Compiler.h"
 #include "FeatureModule.h"
 #include "ParsedAST.h"
 #include "TestFS.h"
 #include "index/Index.h"
 #include "support/Path.h"

 const NamedDecl &findDecl(ParsedAST &AST,
                           std::function<bool(const NamedDecl &)> Filter);
 // Look up an AST symbol by unqualified name, which must be unique.
 const NamedDecl &findUnqualifiedDecl(ParsedAST &AST, llvm::StringRef Name);
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TESTTU_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTTU_H

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

 //===--- TestWorkspace.h - Utility for writing multi-file 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
 //
 //===----------------------------------------------------------------------===//
 //
 // TestWorkspace builds on TestTU to provide a way to write tests involving
 // several related files with inclusion relationships between them.
 //
 // The tests can exercise both index and AST based operations.
 //
 //===---------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TESTWORKSPACE_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TESTWORKSPACE_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTWORKSPACE_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTWORKSPACE_H
 
 #include "TestFS.h"
 #include "TestTU.h"
 #include "index/FileIndex.h"
 #include "index/Index.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 #include <vector>
private:
   TestTU TU;
 
   void addInput(llvm::StringRef Filename, const SourceFile &Input);
 };
 
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TESTWORKSPACE_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTWORKSPACE_H

clang-tools-extra/clangd/unittests/support/TestTracer.h

 //===-- TestTracer.h --------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Allows setting up a fake tracer for tests.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_SUPPORT_TESTTRACER_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_SUPPORT_TESTTRACER_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_SUPPORT_TESTTRACER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_SUPPORT_TESTTRACER_H
 
 #include "support/Trace.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <mutex>
 #include <string>
 #include <vector>
 

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_UNITTESTS_CLANGD_TWEAKTESTING_H
-#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TWEAKTESTING_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TWEAKS_TWEAKTESTING_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TWEAKS_TWEAKTESTING_H
 
 #include "TestTU.h"
 #include "index/Index.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <memory>