[clangd] NFC: Rename DexIndex to Dex

[kbobyrev]

Summary

Also, cleanup some redundant includes.

[kbobyrev]

%s/DexIndex/Dex

[sammccall]

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

20 ↗

(On Diff #164368)

update header guards

clang-tools-extra/clangd/CMakeLists.txt

add_clang_library(clangDaemon
   SourceCode.cpp
   Threading.cpp
   Trace.cpp
   TUScheduler.cpp
   URI.cpp
   XRefs.cpp
 
   index/CanonicalIncludes.cpp
+  index/Dex.cpp
   index/FileIndex.cpp
   index/Index.cpp
+  index/Iterator.cpp
   index/MemIndex.cpp
   index/Merge.cpp
   index/Serialization.cpp
   index/SymbolCollector.cpp
   index/SymbolYAML.cpp
-
-  index/dex/DexIndex.cpp
-  index/dex/Iterator.cpp
-  index/dex/Trigram.cpp
+  index/Trigram.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangDriver
   clangFormat
   clangFrontend

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

-//===--- DexIndex.h - Dex Symbol Index Implementation -----------*- C++ -*-===//
+//===--- Dex.h - Efficient Symbol Index Implementation ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This defines Dex - a symbol index implementation based on query iterators
 // over symbol tokens, such as fuzzy matching trigrams, scopes, types, etc.
 // While consuming more memory and having longer build stage due to
 // preprocessing, Dex will have substantially lower latency. It will also allow
 // efficient symbol searching which is crucial for operations like code
 // completion, and can be very important for a number of different code
 // transformations which will be eventually supported by Clangd.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_DEXINDEX_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_DEXINDEX_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEXINDEX_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEXINDEX_H
 
-#include "../Index.h"
-#include "../MemIndex.h"
-#include "../SymbolCollector.h"
+#include "Index.h"
 #include "Iterator.h"
+#include "MemIndex.h"
+#include "SymbolCollector.h"
 #include "Token.h"
 #include "Trigram.h"
 
 namespace clang {
 namespace clangd {
-namespace dex {
 
 /// In-memory Dex trigram-based index implementation.
 // FIXME(kbobyrev): Introduce serialization and deserialization of the symbol
 // index so that it can be loaded from the disk. Since static index is not
 // changed frequently, it's safe to assume that it has to be built only once
 // (when the clangd process starts). Therefore, it can be easier to store built
 // index on disk and then load it if available.
 class DexIndex : public SymbolIndex {

 };
 
 /// Returns Search Token for a number of parent directories of given Path.
 /// Should be used within the index build process.
 ///
 /// This function is exposed for testing only.
 std::vector<std::string> generateProximityURIs(llvm::StringRef URIPath);
 
-} // namespace dex
 } // namespace clangd
 } // namespace clang
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_DEXINDEX_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEXINDEX_H

clang-tools-extra/clangd/index/Dex.cpp

-//===--- DexIndex.cpp - Dex Symbol Index Implementation ---------*- C++ -*-===//
+//===--- Dex.cpp - Efficient Symbol Index Implementation --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DexIndex.h"
-#include "../../FileDistance.h"
-#include "../../FuzzyMatch.h"
-#include "../../Logger.h"
-#include "../../Quality.h"
+#include "Dex.h"
+#include "../FileDistance.h"
+#include "../FuzzyMatch.h"
+#include "../Logger.h"
+#include "../Quality.h"
 #include "llvm/ADT/StringSet.h"
 #include <algorithm>
 #include <queue>
 
 namespace clang {
 namespace clangd {
-namespace dex {
 
 namespace {
 
 // Returns the tokens which are given symbol's characteristics. Currently, the
 // generated tokens only contain fuzzy matching trigrams and symbol's scope,
 // but in the future this will also return path proximity tokens and other
 // types of tokens such as symbol type (if applicable).
 // Returns the tokens which are given symbols's characteristics. For example,
while (!Body.empty() && --Limit > 0) {
     Body = llvm::sys::path::parent_path(Body, llvm::sys::path::Style::posix);
     URI TokenURI(ParsedURI->scheme(), ParsedURI->authority(), Body);
     if (!Body.empty())
       Result.emplace_back(TokenURI.toString());
   }
   return Result;
 }
 
-} // namespace dex
 } // namespace clangd
 } // namespace clang

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

 // the sorted order of IDs. Having the resulting IDs sorted is important,
 // because it allows receiving a certain number of the most valuable items (e.g.
 // symbols with highest quality which was the sorting key in the first place)
 // without processing all items with requested properties (this might not be
 // computationally effective if search request is not very restrictive).
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_ITERATOR_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_ITERATOR_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_ITERATOR_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_ITERATOR_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 namespace clang {
 namespace clangd {
-namespace dex {
 
 /// Symbol position in the list of all index symbols sorted by a pre-computed
 /// symbol quality.
 using DocID = uint32_t;
 /// Contains sorted sequence of DocIDs all of which belong to symbols matching
 /// certain criteria, i.e. containing a Search Token. PostingLists are values
 /// for the inverted index.
 // FIXME(kbobyrev): Posting lists for incomplete trigrams (one/two symbols) are

 }
 
 template <typename HeadT>
 void populateChildren(std::vector<std::unique_ptr<Iterator>> &Children,
                       HeadT &Head) {
   Children.push_back(move(Head));
 }
 
-} // namespace dex
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_DEX_ITERATOR_H

clang-tools-extra/clangd/index/Iterator.cpp

 //===--- Iterator.cpp - Query Symbol Retrieval ------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Iterator.h"
 #include <algorithm>
 #include <cassert>
 #include <numeric>
 
 namespace clang {
 namespace clangd {
-namespace dex {
 
 namespace {
 
 /// Implements Iterator over a PostingList. DocumentIterator is the most basic
 /// iterator: it doesn't have any children (hence it is the leaf of iterator
 /// tree) and is simply a wrapper around PostingList::const_iterator.
 class DocumentIterator : public Iterator {
 public:
std::unique_ptr<Iterator> createBoost(std::unique_ptr<Iterator> Child,
   return llvm::make_unique<BoostIterator>(move(Child), Factor);
 }
 
 std::unique_ptr<Iterator> createLimit(std::unique_ptr<Iterator> Child,
                                       size_t Limit) {
   return llvm::make_unique<LimitIterator>(move(Child), Limit);
 }
 
-} // namespace dex
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/index/SymbolYAML.cpp

 //===--- SymbolYAML.cpp ------------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolYAML.h"
 #include "../Trace.h"
 #include "Index.h"
 #include "Serialization.h"
-#include "dex/DexIndex.h"
+#include "Dex.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 
 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(clang::clangd::Symbol)
std::unique_ptr<SymbolIndex> loadIndex(llvm::StringRef SymbolFilename,
   } else {
     trace::Span Tracer("ParseYAML");
     Slab = symbolsFromYAML(Data);
   }
 
   if (!Slab)
     return nullptr;
   trace::Span Tracer("BuildIndex");
-  return UseDex ? dex::DexIndex::build(std::move(*Slab), URISchemes)
+  return UseDex ? DexIndex::build(std::move(*Slab), URISchemes)
                 : MemIndex::build(std::move(*Slab), RefSlab());
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/index/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_TOKEN_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_TOKEN_H
 
-#include "../Index.h"
+#include "Index.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
-namespace dex {
 
 /// A Token represents an attribute of a symbol, such as a particular trigram
 /// present in the name (used for fuzzy search).
 ///
 /// Tokens can be used to perform more sophisticated search queries by
 /// constructing complex iterator trees.
 struct Token {
   /// Kind specifies Token type which defines semantics for the internal
struct Token {
   }
 
 private:
   friend llvm::hash_code hash_value(const Token &Token) {
     return llvm::hash_combine(static_cast<int>(Token.TokenKind), Token.Data);
   }
 };
 
-} // namespace dex
 } // namespace clangd
 } // namespace clang
 
 namespace llvm {
 
 // Support Tokens as DenseMap keys.
-template <> struct DenseMapInfo<clang::clangd::dex::Token> {
-  static inline clang::clangd::dex::Token getEmptyKey() {
-    return {clang::clangd::dex::Token::Kind::Sentinel, "EmptyKey"};
+template <> struct DenseMapInfo<clang::clangd::Token> {
+  static inline clang::clangd::Token getEmptyKey() {
+    return {clang::clangd::Token::Kind::Sentinel, "EmptyKey"};
   }
 
-  static inline clang::clangd::dex::Token getTombstoneKey() {
-    return {clang::clangd::dex::Token::Kind::Sentinel, "TombstoneKey"};
+  static inline clang::clangd::Token getTombstoneKey() {
+    return {clang::clangd::Token::Kind::Sentinel, "TombstoneKey"};
   }
 
-  static unsigned getHashValue(const clang::clangd::dex::Token &Tag) {
+  static unsigned getHashValue(const clang::clangd::Token &Tag) {
     return hash_value(Tag);
   }
 
-  static bool isEqual(const clang::clangd::dex::Token &LHS,
-                      const clang::clangd::dex::Token &RHS) {
+  static bool isEqual(const clang::clangd::Token &LHS,
+                      const clang::clangd::Token &RHS) {
     return LHS == RHS;
   }
 };
 
 } // namespace llvm
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_DEX_TOKEN_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_TOKEN_H

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

 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_DEX_TRIGRAM_H
 
 #include "Token.h"
 
 #include <string>
 
 namespace clang {
 namespace clangd {
-namespace dex {
 
 /// Returns list of unique fuzzy-search trigrams from unqualified symbol.
 ///
 /// First, given Identifier (unqualified symbol name) is segmented using
 /// FuzzyMatch API and lowercased. After segmentation, the following technique
 /// is applied for generating trigrams: for each letter or digit in the input
 /// string the algorithms looks for the possible next and skip-1-next characters
 /// which can be jumped to during fuzzy matching. Each combination of such three

 /// the simplest trigrams - sequences of three consecutive letters and digits
 /// are extracted and returned after deduplication.
 ///
 /// For short queries (less than 3 characters with Head or Tail roles in Fuzzy
 /// Matching segmentation) this returns a single trigram with the first
 /// characters (up to 3) to perform prefix match.
 std::vector<Token> generateQueryTrigrams(llvm::StringRef Query);
 
-} // namespace dex
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_DEX_TRIGRAM_H

clang-tools-extra/clangd/index/Trigram.cpp

 //===--- Trigram.cpp - Trigram generation for Fuzzy Matching ----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Trigram.h"
-#include "../../FuzzyMatch.h"
+#include "../FuzzyMatch.h"
 #include "Token.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include <cctype>
 #include <queue>
 #include <string>
 
 using namespace llvm;
 
 namespace clang {
 namespace clangd {
-namespace dex {
 
 /// This is used to mark unigrams and bigrams and distinct them from complete
 /// trigrams. Since '$' is not present in valid identifier names, it is safe to
 /// use it as the special symbol.
 static const char END_MARKER = '$';
 
 std::vector<Token> generateIdentifierTrigrams(llvm::StringRef Identifier) {
   // Apply fuzzy matching text segmentation.
std::vector<Token> generateQueryTrigrams(llvm::StringRef Query) {
 
   std::vector<Token> Result;
   for (const auto &Trigram : UniqueTrigrams)
     Result.push_back(Trigram);
 
   return Result;
 }
 
-} // namespace dex
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/tool/ClangdMain.cpp

 //===--- ClangdMain.cpp - clangd server loop ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "JSONRPCDispatcher.h"
 #include "Path.h"
 #include "RIFF.h"
 #include "Trace.h"
 #include "index/SymbolYAML.h"
-#include "index/dex/DexIndex.h"
 #include "clang/Basic/Version.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>

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

 //===-- DexIndexTests.cpp  ----------------------------*- C++ -*-----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "FuzzyMatch.h"
 #include "TestFS.h"
 #include "TestIndex.h"
+#include "index/Dex.h"
 #include "index/Index.h"
+#include "index/Iterator.h"
 #include "index/Merge.h"
-#include "index/dex/DexIndex.h"
-#include "index/dex/Iterator.h"
-#include "index/dex/Token.h"
-#include "index/dex/Trigram.h"
+#include "index/Token.h"
+#include "index/Trigram.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <string>
 #include <vector>
 
 using ::testing::ElementsAre;
 using ::testing::UnorderedElementsAre;
 using namespace llvm;
 
 namespace clang {
 namespace clangd {
-namespace dex {
 namespace {
 
 std::vector<std::string> URISchemes = {"unittest"};
 
 //===----------------------------------------------------------------------===//
 // Query iterator tests.
 //===----------------------------------------------------------------------===//
 
TEST(DexIndexTest, ProximityPathsBoosting) {
 
   // FuzzyFind request comes from the file which is close to the root: expect
   // RootSymbol to come out.
   Req.ProximityPaths = {testPath("file.h")};
   EXPECT_THAT(match(I, Req), ElementsAre("root::abc"));
 }
 
 } // namespace
-} // namespace dex
 } // namespace clangd
 } // namespace clang

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

-//===-- IndexHelpers.h ------------------------------------------*- C++ -*-===//
+//===-- TestIndex.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_INDEXTESTCOMMON_H
 #define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_INDEXTESTCOMMON_H
 
 #include "index/Index.h"
 #include "index/Merge.h"
-#include "index/dex/DexIndex.h"
-#include "index/dex/Iterator.h"
-#include "index/dex/Token.h"
-#include "index/dex/Trigram.h"
 
 namespace clang {
 namespace clangd {
 
 // Creates Symbol instance and sets SymbolID to given QualifiedName.
 Symbol symbol(llvm::StringRef QName);
 
 // Create a slab of symbols with the given qualified names as IDs and names.

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

-//===-- IndexHelpers.cpp ----------------------------------------*- C++ -*-===//
+//===-- TestIndex.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//