diff --git a/include/Basic/Location.h b/include/Basic/Location.h
index 7672cc25..d28f6cb9 100644
--- a/include/Basic/Location.h
+++ b/include/Basic/Location.h
@@ -29,6 +29,12 @@ struct Range {
     Position end;
 };
 
+struct Location {
+    DocumentUri uri;
+
+    Range range;
+};
+
 struct TextEdit {
     /// The range of the text document to be manipulated. To insert
     /// text into a document create a range where start === end.
@@ -39,10 +45,4 @@ struct TextEdit {
     string newText;
 };
 
-struct Location {
-    DocumentUri uri;
-
-    Range range;
-};
-
 }  // namespace clice::proto
diff --git a/include/Basic/SymbolKind.h b/include/Basic/SymbolKind.h
deleted file mode 100644
index 858b44ba..00000000
--- a/include/Basic/SymbolKind.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-
-#include "clang/AST/Decl.h"
-#include "Support/Support.h"
-
-namespace clice {
-
-/// In the LSP, there are several different kinds, such as `SemanticTokenType`,
-/// `CompletionItemKind`, and `SymbolKind`. Unfortunately, these kinds do not cover all the semantic
-/// information we need. It's also inconsistent that some kinds exist in one category but not in
-/// another, for example, `Namespace` is present in `SemanticTokenType` but not in
-/// `CompletionItemKind`. To address this, we define our own `SymbolKind`, which will be used
-/// consistently across our responses to the client and in the index. Users who prefer to stick to
-/// standard LSP kinds can map our `SymbolKind` to the corresponding LSP kinds through
-/// configuration.
-struct SymbolKind : support::Enum<SymbolKind, false, uint8_t> {
-    enum Kind : uint8_t {
-        Comment = 0,     ///< C/C++ comments.
-        Number,          ///< C/C++ number literal.
-        Character,       ///< C/C++ character literal.
-        String,          ///< C/C++ string literal.
-        Keyword,         ///< C/C++ keyword.
-        Directive,       ///< C/C++ preprocessor directive, e.g. `#include`.
-        Header,          ///< C/C++ header name, e.g. `<iostream>` and `"foo.h"`.
-        Module,          ///< C++20 module name.
-        Macro,           ///< C/C++ macro.
-        MacroParameter,  ///< C/C++ macro parameter.
-        Namespace,       ///> C++ namespace.
-        Class,           ///> C/C++ class.
-        Struct,          ///> C/C++ struct.
-        Union,           ///> C/C++ union.
-        Enum,            ///> C/C++ enum.
-        Type,            ///> C/C++ type alias and C++ template type parameter.
-        Field,           ///> C/C++ field.
-        EnumMember,      ///> C/C++ enum member.
-        Function,        ///> C/C++ function.
-        Method,          ///> C++ method.
-        Variable,        ///> C/C++ variable, includes C++17 structured bindings.
-        Parameter,       ///> C/C++ parameter.
-        Label,           ///> C/C++ label.
-        Concept,         ///> C++20 concept.
-        Attribute,       ///> GNU/MSVC/C++11/C23 attribute.
-        Operator,        ///> C/C++ operator.
-        Paren,           ///> `(` and `)`.
-        Bracket,         ///> `[` and `]`.
-        Brace,           ///> `{` and `}`.
-        Angle,           ///> `<` and `>`.
-        Invalid,
-    };
-
-    using Enum::Enum;
-
-    constexpr inline static auto InvalidEnum = Kind::Invalid;
-
-    static SymbolKind from(const clang::Decl* decl);
-
-    static SymbolKind from(const clang::tok::TokenKind kind);
-};
-
-}  // namespace clice
diff --git a/include/Compiler/Semantic.h b/include/Compiler/Semantic.h
index 5d0365d0..8d56f72d 100644
--- a/include/Compiler/Semantic.h
+++ b/include/Compiler/Semantic.h
@@ -1,46 +1,96 @@
 #include "Compiler.h"
 #include "Resolver.h"
-
-#include "Support/Enum.h"
-#include "Support/FileSystem.h"
 #include "Utility.h"
 
+#include "Support/Support.h"
+
 namespace clice {
 
-enum class RelationKind : uint32_t {
-    Invalid,
-    Declaration,
-    Definition,
-    Reference,
-    // Write Relation.
-    Read,
-    Write,
-    Interface,
-    Implementation,
-    /// When target is a type definition of source, source is possible type or constructor.
-    TypeDefinition,
+/// In the LSP, there are several different kinds, such as `SemanticTokenType`,
+/// `CompletionItemKind`, and `SymbolKind`. Unfortunately, these kinds do not cover all the semantic
+/// information we need. It's also inconsistent that some kinds exist in one category but not in
+/// another, for example, `Namespace` is present in `SemanticTokenType` but not in
+/// `CompletionItemKind`. To address this, we define our own `SymbolKind`, which will be used
+/// consistently across our responses to the client and in the index. Users who prefer to stick to
+/// standard LSP kinds can map our `SymbolKind` to the corresponding LSP kinds through
+/// configuration.
+struct SymbolKind : support::Enum<SymbolKind, false, uint8_t> {
+    enum Kind : uint8_t {
+        Comment = 0,     ///< C/C++ comments.
+        Number,          ///< C/C++ number literal.
+        Character,       ///< C/C++ character literal.
+        String,          ///< C/C++ string literal.
+        Keyword,         ///< C/C++ keyword.
+        Directive,       ///< C/C++ preprocessor directive, e.g. `#include`.
+        Header,          ///< C/C++ header name, e.g. `<iostream>` and `"foo.h"`.
+        Module,          ///< C++20 module name.
+        Macro,           ///< C/C++ macro.
+        MacroParameter,  ///< C/C++ macro parameter.
+        Namespace,       ///> C++ namespace.
+        Class,           ///> C/C++ class.
+        Struct,          ///> C/C++ struct.
+        Union,           ///> C/C++ union.
+        Enum,            ///> C/C++ enum.
+        Type,            ///> C/C++ type alias and C++ template type parameter.
+        Field,           ///> C/C++ field.
+        EnumMember,      ///> C/C++ enum member.
+        Function,        ///> C/C++ function.
+        Method,          ///> C++ method.
+        Variable,        ///> C/C++ variable, includes C++17 structured bindings.
+        Parameter,       ///> C/C++ parameter.
+        Label,           ///> C/C++ label.
+        Concept,         ///> C++20 concept.
+        Attribute,       ///> GNU/MSVC/C++11/C23 attribute.
+        Operator,        ///> C/C++ operator.
+        Paren,           ///> `(` and `)`.
+        Bracket,         ///> `[` and `]`.
+        Brace,           ///> `{` and `}`.
+        Angle,           ///> `<` and `>`.
+        Invalid,
+    };
 
-    /// When target is a base class of source.
-    Base,
-    /// When target is a derived class of source.
-    Derived,
+    using Enum::Enum;
 
-    /// When target is a constructor of source.
-    Constructor,
-    /// When target is a destructor of source.
-    Destructor,
+    constexpr inline static auto InvalidEnum = Kind::Invalid;
 
-    // When target is a caller of source.
-    Caller,
-    // When target is a callee of source.
-    Callee,
+    static SymbolKind from(const clang::Decl* decl);
+
+    static SymbolKind from(const clang::tok::TokenKind kind);
 };
 
-// struct RelationKind : enum_type<RelationKinds, true> {
-//     using enum RelationKinds;
-//     using enum_type::enum_type;
-//     using enum_type::operator=;
-// };
+/// A bit field enum to describe the kind of relation between two symbols.
+struct RelationKind : support::Enum<RelationKind, true, uint32_t> {
+    enum Kind : uint32_t {
+        Invalid,
+        Declaration,
+        Definition,
+        Reference,
+        // Write Relation.
+        Read,
+        Write,
+        Interface,
+        Implementation,
+        /// When target is a type definition of source, source is possible type or constructor.
+        TypeDefinition,
+
+        /// When target is a base class of source.
+        Base,
+        /// When target is a derived class of source.
+        Derived,
+
+        /// When target is a constructor of source.
+        Constructor,
+        /// When target is a destructor of source.
+        Destructor,
+
+        // When target is a caller of source.
+        Caller,
+        // When target is a callee of source.
+        Callee,
+    };
+
+    using Enum::Enum;
+};
 
 enum class OccurrenceKind {
     /// This occurrence directly corresponds to a unique source symbol.
@@ -53,10 +103,6 @@ enum class OccurrenceKind {
     Instantiation,
 };
 
-enum class SymbolKind {
-
-};
-
 template <typename Derived>
 class SemanticVisitor : public clang::RecursiveASTVisitor<SemanticVisitor<Derived>> {
 public:
@@ -97,7 +143,7 @@ public:
     /// Always uses spelling location if the original location is a macro location.
     void handleOccurrence(const clang::Decl* decl,
                           clang::SourceLocation location,
-                          OccurrenceKind kind = OccurrenceKind::Source) {}
+                          RelationKind kind = RelationKind::Invalid) {}
 
     /// Builtin type doesn't have corresponding decl. So we handle it separately.
     /// And it is possible that a builtin type is composed of multiple tokens.
@@ -106,12 +152,7 @@ public:
                           clang::SourceRange range,
                           OccurrenceKind kind = OccurrenceKind::Source) {}
 
-    void handleOccurrence(clang::Attr* attr, clang::SourceRange range) {}
-
-    /// Always uses expansion location if the original location is a macro location.
-    void handleRelation(const clang::Decl* decl, RelationKind kind, clang::SourceRange range) {
-        ///
-    }
+    void handleOccurrence(const clang::Attr* attr, clang::SourceRange range) {}
 
 public:
     /// ============================================================================
@@ -136,7 +177,7 @@ public:
     VISIT_DECL(NamespaceDecl) {
         /// `namespace Foo { }`
         ///             ^~~~ definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
         return true;
     }
 
@@ -144,72 +185,80 @@ public:
         /// `namespace Foo = Bar`
         ///             ^     ^~~~ reference
         ///             ^~~~ definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
-        getDerived().handleOccurrence(decl->getNamespace(), decl->getTargetNameLoc());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
+        getDerived().handleOccurrence(decl->getNamespace(),
+                                      decl->getTargetNameLoc(),
+                                      RelationKind::Reference);
         return true;
     }
 
     VISIT_DECL(UsingDirectiveDecl) {
         /// `using namespace Foo`
         ///                   ^~~~~~~ reference
-        getDerived().handleOccurrence(decl->getNominatedNamespace(), decl->getLocation());
+        getDerived().handleOccurrence(decl->getNominatedNamespace(),
+                                      decl->getLocation(),
+                                      RelationKind::Reference);
         return true;
     }
 
     VISIT_DECL(LabelDecl) {
         /// `label:`
         ///    ^~~~ definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
         return true;
     }
 
     VISIT_DECL(FieldDecl) {
         /// `int foo;`
         ///       ^~~~ definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
+        /// FIXME: add Type Definition
         return true;
     }
 
     VISIT_DECL(EnumConstantDecl) {
         /// `enum Foo { bar };`
         ///              ^~~~ definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
+        /// FIXME: add Type Definition
         return true;
     }
 
     VISIT_DECL(UsingDecl) {
         /// `using Foo::bar;`
         ///              ^~~~ reference
-        getDerived().handleOccurrence(decl, decl->getLocation());
-        /// FIXME:
+        for(auto shadow: decl->shadows()) {
+            getDerived().handleOccurrence(shadow, decl->getLocation(), RelationKind::Reference);
+        }
         return true;
     }
 
     VISIT_DECL(BindingDecl) {
         /// `auto [a, b] = std::make_tuple(1, 2);`
         ///        ^~~~ definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
+        /// FIXME: add Type Definition
         return true;
     }
 
     VISIT_DECL(TemplateTypeParmDecl) {
         /// `template <typename T>`
         ///                     ^~~~ definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
         return true;
     }
 
     VISIT_DECL(TemplateTemplateParmDecl) {
         /// `template <template <typename> class T>`
         ///                                      ^~~~ definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
         return true;
     }
 
     VISIT_DECL(NonTypeTemplateParmDecl) {
         /// `template <int N>`
         ///                ^~~~ definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
         return true;
     }
 
@@ -234,7 +283,11 @@ public:
 
         /// `struct/class/union/enum Foo { };`
         ///                           ^~~~ declaration/definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl,
+                                      decl->getLocation(),
+                                      decl->isThisDeclarationADefinition()
+                                          ? RelationKind::Definition
+                                          : RelationKind::Declaration);
         return true;
     }
 
@@ -249,7 +302,11 @@ public:
 
         /// `void foo();`
         ///         ^~~~ declaration/definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl,
+                                      decl->getLocation(),
+                                      decl->isThisDeclarationADefinition()
+                                          ? RelationKind::Definition
+                                          : RelationKind::Declaration);
         return true;
     }
 
@@ -286,7 +343,8 @@ public:
 
         /// `using Foo = int;`
         ///             ^~~~ declaration/definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
+        /// FIXME: add type definition
         return true;
     }
 
@@ -303,7 +361,11 @@ public:
 
         /// `int foo;`
         ///       ^~~~ declaration/definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl,
+                                      decl->getLocation(),
+                                      decl->isThisDeclarationADefinition()
+                                          ? RelationKind::Definition
+                                          : RelationKind::Declaration);
         return true;
     }
 
@@ -338,14 +400,16 @@ public:
     VISIT_DECL(ConceptDecl) {
         /// `template <typename T> concept Foo = ...;`
         ///                                 ^~~~ definition
-        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation(), RelationKind::Definition);
         return true;
     }
 
     bool TraverseConceptReference(clang::ConceptReference* reference) {
         /// `requires Foo<T>;`
         ///            ^~~~ reference
-        getDerived().handleOccurrence(reference->getNamedConcept(), reference->getConceptNameLoc());
+        getDerived().handleOccurrence(reference->getNamedConcept(),
+                                      reference->getConceptNameLoc(),
+                                      RelationKind::Reference);
 
         return Base::TraverseConceptReference(reference);
     }
@@ -382,28 +446,32 @@ public:
     VISIT_TYPELOC(TagTypeLoc) {
         /// `struct Foo { }; Foo foo`
         ///                   ^~~~ reference
-        getDerived().handleOccurrence(loc.getDecl(), loc.getNameLoc());
+        getDerived().handleOccurrence(loc.getDecl(), loc.getNameLoc(), RelationKind::Reference);
         return true;
     }
 
     VISIT_TYPELOC(TypedefTypeLoc) {
         /// `using Foo = int; Foo foo`
         ///                    ^~~~ reference
-        getDerived().handleOccurrence(loc.getTypedefNameDecl(), loc.getNameLoc());
+        getDerived().handleOccurrence(loc.getTypedefNameDecl(),
+                                      loc.getNameLoc(),
+                                      RelationKind::Reference);
         return true;
     }
 
     VISIT_TYPELOC(TemplateTypeParmTypeLoc) {
         /// `template <typename T> void foo(T t)`
         ///                                 ^~~~ reference
-        getDerived().handleOccurrence(loc.getDecl(), loc.getNameLoc());
+        getDerived().handleOccurrence(loc.getDecl(), loc.getNameLoc(), RelationKind::Reference);
         return true;
     }
 
     VISIT_TYPELOC(TemplateSpecializationTypeLoc) {
         /// `std::vector<int>`
         ///        ^~~~ reference
-        getDerived().handleOccurrence(declForType(loc.getType()), loc.getTemplateNameLoc());
+        getDerived().handleOccurrence(declForType(loc.getType()),
+                                      loc.getTemplateNameLoc(),
+                                      RelationKind::Reference);
         return true;
     }
 
@@ -411,7 +479,7 @@ public:
         /// `std::vector<T>::value_type`
         ///                      ^~~~ reference
         for(auto decl: resolver.lookup(loc.getTypePtr())) {
-            getDerived().handleOccurrence(decl, loc.getNameLoc());
+            getDerived().handleOccurrence(decl, loc.getNameLoc(), RelationKind::Reference);
         }
         return true;
     }
@@ -420,7 +488,7 @@ public:
         /// `std::allocator<T>::rebind<U>`
         ///                       ^~~~ reference
         for(auto decl: resolver.lookup(loc.getTypePtr())) {
-            getDerived().handleOccurrence(decl, loc.getTemplateNameLoc());
+            getDerived().handleOccurrence(decl, loc.getTemplateNameLoc(), RelationKind::Reference);
         }
         return true;
     }
@@ -470,11 +538,15 @@ public:
         auto NNS = loc.getNestedNameSpecifier();
         switch(NNS->getKind()) {
             case clang::NestedNameSpecifier::Namespace: {
-                getDerived().handleOccurrence(NNS->getAsNamespace(), loc.getLocalBeginLoc());
+                getDerived().handleOccurrence(NNS->getAsNamespace(),
+                                              loc.getLocalBeginLoc(),
+                                              RelationKind::Reference);
                 break;
             }
             case clang::NestedNameSpecifier::NamespaceAlias: {
-                getDerived().handleOccurrence(NNS->getAsNamespaceAlias(), loc.getLocalBeginLoc());
+                getDerived().handleOccurrence(NNS->getAsNamespaceAlias(),
+                                              loc.getLocalBeginLoc(),
+                                              RelationKind::Reference);
                 break;
             }
             case clang::NestedNameSpecifier::Identifier: {
@@ -511,20 +583,30 @@ public:
 
     VISIT_EXPR(CallExpr) {
         // TODO: consider lambda expression.
+        auto caller = decls.back();
+        auto callee = expr->getCalleeDecl();
+        if(callee) {
+            getDerived().handleOccurrence(caller, expr->getSourceRange(), RelationKind::Caller);
+            getDerived().handleOccurrence(callee, expr->getSourceRange(), RelationKind::Callee);
+        }
         return true;
     }
 
     VISIT_EXPR(DeclRefExpr) {
         /// `foo = 1`
         ///   ^~~~ reference
-        getDerived().handleOccurrence(expr->getDecl(), expr->getLocation());
+        getDerived().handleOccurrence(expr->getDecl(),
+                                      expr->getLocation(),
+                                      RelationKind::Reference);
         return true;
     }
 
     VISIT_EXPR(MemberExpr) {
         /// `foo.bar`
         ///       ^~~~ reference
-        getDerived().handleOccurrence(expr->getMemberDecl(), expr->getMemberLoc());
+        getDerived().handleOccurrence(expr->getMemberDecl(),
+                                      expr->getMemberLoc(),
+                                      RelationKind::Reference);
         return true;
     }
 
@@ -532,9 +614,7 @@ public:
         /// `std::is_same<T, U>::value`
         ///           ^~~~ reference
         for(auto decl: resolver.lookup(expr)) {
-            getDerived().handleOccurrence(decl,
-                                          expr->getNameLoc(),
-                                          OccurrenceKind::PseudoInstantiation);
+            getDerived().handleOccurrence(decl, expr->getNameLoc(), RelationKind::Reference);
         }
         return true;
     }
@@ -543,7 +623,9 @@ public:
         /// `std::is_same<T, U>::value`
         ///                        ^~~~ reference
         for(auto decl: resolver.lookup(expr)) {
-            getDerived().handleOccurrence(decl, expr->getNameInfo().getLoc());
+            getDerived().handleOccurrence(decl,
+                                          expr->getNameInfo().getLoc(),
+                                          RelationKind::Reference);
         }
         return true;
     }
diff --git a/include/Index/Binary.h b/include/Index/Binary.h
new file mode 100644
index 00000000..09c94b45
--- /dev/null
+++ b/include/Index/Binary.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Memory.h"
+
+namespace clice::index {
+
+namespace binary {
+
+template <typename T>
+struct Array {
+    /// Offset to base pointer.
+    std::uint32_t offset = 0;
+
+    /// Size of the array.
+    std::uint32_t size = 0;
+};
+
+using String = Array<char>;
+
+#define MAKE_CLANG_HAPPY
+#include "Index.inl"
+
+}  // namespace binary
+
+/// Convert `memory::Index` to `binary::Index`.
+binary::Index toBinary(const memory::Index& index);
+
+}  // namespace clice::index
diff --git a/include/Index/Index.h b/include/Index/Index.h
index a3262a24..7ff021d5 100644
--- a/include/Index/Index.h
+++ b/include/Index/Index.h
@@ -1,36 +1,42 @@
-#pragma once
-
-#include "Relation.h"
+#include "Basic/Location.h"
+#include "Compiler/Semantic.h"
+#include "Support/Support.h"
 
 namespace clice::index {
 
-/// Represent a position in the source code, the line and column are 1-based.
-struct Position {
-    /// The line of the position.
-    uint32_t line = 0;
+template <typename T>
+struct Ref {
+    std::uint32_t offset = std::numeric_limits<std::uint32_t>::max();
 
-    /// The column of the position.
-    uint32_t column = 0;
+    bool isValid() const {
+        return offset != std::numeric_limits<std::uint32_t>::max();
+    }
 
-    friend constexpr auto operator<=> (const Position& lhs, const Position& rhs) = default;
+    bool isInvalid() const {
+        return !isValid();
+    }
+
+    explicit operator bool () const {
+        return isValid();
+    }
 };
 
 struct FileRef : Ref<FileRef> {};
 
 struct SymbolRef : Ref<SymbolRef> {};
 
+struct LocationRef : Ref<LocationRef> {};
+
+struct SymOrLocRef : Ref<SymOrLocRef> {};
+
+/// Beacuse we decide to support header context, so just a file cannot represent a symbol location
+/// well. So we define a new struct `Location` to represent the location of a symbol.
 struct Location {
-    /// The index of the file in the `Index::files`. When the value of file is equal to MAX_UINT32
-    /// it means the location is invalid.
-    FileRef file = {};
+    /// The index of the file in the `Index::files`.
+    FileRef file;
 
-    /// Begin position of the location.
-    Position begin = {};
-
-    /// End position of the location.
-    Position end = {};
-
-    friend constexpr auto operator<=> (const Location& lhs, const Location& rhs) = default;
+    /// Source code range of the location.
+    proto::Range range;
 };
 
 struct Occurrence {
@@ -41,66 +47,18 @@ struct Occurrence {
     SymbolRef symbol;
 };
 
-template <typename String>
-struct File {
-    /// The path of the file.
-    String path;
+struct Relation {
+    /// The kind of the relation.
+    RelationKind kind;
 
-    /// FIXME: Add some flags.
+    /// The index of location in `Index::locations`.
+    LocationRef location;
 
-    /// The index of include location of this file if any.
-    LocationRef include;
+    /// Additional information based on the `Relation::kind`. For `Declaration` and `Definition`,
+    /// this is the source range of the whole entity(`Relation::location` is just the range of
+    /// symbol name). For kinds whose target symbol is different from the source symbol, e.g.
+    /// `TypeDefinition` and `Base`, this is the index of target symbol in `Index::symbols`.
+    SymOrLocRef symOrLoc;
 };
 
-template <typename String, template <typename...> typename Array>
-struct Symbol {
-    /// The hash of this symbol, used for quick lookup.
-    uint64_t id;
-
-    /// The unique identifier of this symbol.
-    String USR;
-
-    /// The name of this symbol.
-    String name;
-
-    /// The document of this symbol.
-    String document;
-
-    bool is_local;
-    // FIXME: ... more useful fields.
-
-    /// The relations of this symbol.
-    Array<Relation> relations;
-};
-
-template <typename String, template <typename...> typename Array>
-struct Index {
-    /// The version of the index format.
-    String version;
-
-    /// The language of the indexed code, currently only supports "C" and "C++".
-    String language;
-
-    /// The filepath of the source file.
-    String path;
-
-    /// The context of the source file.
-    String context;
-
-    /// The commands used to compile the source file.
-    Array<String> commands;
-
-    /// All files occurred in compilation.
-    Array<File<String>> files;
-
-    /// All the symbols in the source file, sorted by `Symbol::SymbolID`.
-    Array<Symbol<String, Array>> symbols;
-
-    /// All the occurrences in the source file, sorted by `Occurrence::Location`.
-    Array<Occurrence> occurrences;
-
-    /// Cache same locations to reduce the size of the index.
-    Array<Location> locations;
-};
-
-}  // namespace clice::index
+};  // namespace clice::index
diff --git a/include/Index/Index.inl b/include/Index/Index.inl
new file mode 100644
index 00000000..dd6dd6b6
--- /dev/null
+++ b/include/Index/Index.inl
@@ -0,0 +1,66 @@
+#ifndef MAKE_CLANG_HAPPY
+
+#include "Index.h"
+
+namespace clice::index {
+
+struct String {};
+
+template <typename T>
+struct Array {};
+
+}  // namespace clice::index
+
+using namespace clice::index;
+
+#undef MAKE_CLANG_HAPPY
+#endif
+
+struct File {
+    /// The path of the file.
+    String path;
+
+    /// The include location of this file if any.
+    LocationRef include;
+};
+
+struct Symbol {
+    /// The hash of this symbol, used for quick lookup.
+    uint64_t id;
+
+    /// The name of this symbol.
+    String name;
+
+    /// The relations of this symbol.
+    Array<Relation> relations;
+};
+
+struct Index {
+    /// The version of the index format.
+    String version;
+
+    /// The language of the indexed code, currently only supports "C" and "C++".
+    String language;
+
+    /// The filepath of the source file.
+    String path;
+
+    /// The context of the source file.
+    String context;
+
+    /// The commands used to compile the source file.
+    Array<String> commands;
+
+    /// All files occurred in compilation.
+    Array<File> files;
+
+    /// All the symbols in the source file, sorted by `Symbol::SymbolID`.
+    Array<Symbol> symbols;
+
+    /// All the occurrences in the source file, sorted by `Occurrence::Location`.
+    Array<Occurrence> occurrences;
+
+    /// Cache same locations to reduce the size of the index.
+    Array<Location> locations;
+};
+
diff --git a/include/Index/Indexer.h b/include/Index/Indexer.h
deleted file mode 100644
index ca237c8e..00000000
--- a/include/Index/Indexer.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <limits>
-#include <compare>
-#include <vector>
-#include <string>
-
-#include "Index.h"
-
-namespace clice {
-class ASTInfo;
-}
-
-namespace clice::index {
-
-/// This defines the structures that directly generated by the indexer.
-/// It could be used to serialized to other formats like binary or JSON.
-namespace memory {
-
-using string = std::string;
-
-template <typename T, typename A = std::allocator<T>>
-using array = std::vector<T, A>;
-
-using File = index::File<string>;
-
-using Symbol = index::Symbol<string, array>;
-
-using Index = index::Index<string, array>;
-
-}  // namespace memory
-
-/// index the given translation unit.
-memory::Index index(ASTInfo& compiler);
-
-}  // namespace clice::index
diff --git a/include/Index/Loader.h b/include/Index/Loader.h
deleted file mode 100644
index e9a830a0..00000000
--- a/include/Index/Loader.h
+++ /dev/null
@@ -1,187 +0,0 @@
-#pragma once
-
-#include "Serialize.h"
-
-namespace clice::index {
-
-struct FullLocation {
-    Position begin;
-    Position end;
-    FileRef file;
-    LocationRef include;
-    llvm::StringRef filepath;
-};
-
-/// A helper class to load the index from a binary file and provide some utility functions.
-class Loader {
-public:
-    Loader(std::vector<char>&& binary) :
-        binary(std::move(binary)),
-        index(*reinterpret_cast<const binary::Index*>(this->binary.data())) {}
-
-    template <typename T>
-    auto make_range(binary::array<T> array) const {
-        auto begin = reinterpret_cast<const T*>(binary.data() + array.offset);
-        return llvm::ArrayRef(begin, begin + array.size);
-    }
-
-    llvm::ArrayRef<binary::File> files() const {
-        return make_range(index.files);
-    }
-
-    llvm::ArrayRef<binary::Symbol> symbols() const {
-        return make_range(index.symbols);
-    }
-
-    llvm::ArrayRef<Relation> relations(const binary::Symbol& symbol) const {
-        return make_range(symbol.relations);
-    }
-
-    llvm::ArrayRef<Occurrence> occurrences() const {
-        return make_range(index.occurrences);
-    }
-
-    llvm::ArrayRef<Location> locations() const {
-        return make_range(index.locations);
-    }
-
-    const binary::File& file(FileRef file) const {
-        return files()[file.offset];
-    }
-
-    const binary::Symbol& symbol(SymbolRef sym) const {
-        return symbols()[sym.offset];
-    }
-
-    const Location& location(LocationRef loc) const {
-        return locations()[loc.offset];
-    }
-
-    llvm::StringRef string(binary::string str) const {
-        return llvm::StringRef(binary.data() + str.offset, str.size);
-    }
-
-    Position begin(LocationRef loc) const {
-        return location(loc).begin;
-    }
-
-    Position end(LocationRef loc) const {
-        return location(loc).end;
-    }
-
-    llvm::StringRef filepath(LocationRef loc) const {
-        return string(file(location(loc).file).path);
-    }
-
-    LocationRef includeLoc(FileRef file) const {
-        return this->file(file).include;
-    }
-
-    LocationRef includeLoc(LocationRef loc) const {
-        return includeLoc(location(loc).file);
-    }
-
-    /// Locate the symbol at the given position.
-    const binary::Symbol* locateSymbol(FileRef file, Position pos) const {
-        /// We use the default `<=>` operator when sorting the occurrences.
-        /// And file is the first key, so locations in the same file are contiguous.
-        /// Then we can use binary search to locate the file first, then search the occurrences in
-        /// the file.
-        auto fileStart = std::lower_bound(occurrences().begin(),
-                                          occurrences().end(),
-                                          file,
-                                          [&](Occurrence occurrence, FileRef file) {
-                                              return location(occurrence.location).file < file;
-                                          });
-
-        if(fileStart == occurrences().end() || location(fileStart->location).file != file) {
-            return nullptr;
-        }
-
-        auto occurrence = std::lower_bound(fileStart,
-                                           occurrences().end(),
-                                           pos,
-                                           [&](const Occurrence& occurrence, const Position& pos) {
-                                               return end(occurrence.location) < pos;
-                                           });
-
-        if(occurrence == occurrences().end() || begin(occurrence->location) > pos) {
-            return nullptr;
-        }
-
-        return &symbol(occurrence->symbol);
-    }
-
-    FullLocation decompose(LocationRef loc) const {
-        auto location = this->location(loc);
-        auto file = this->file(location.file);
-        return {
-            location.begin,
-            location.end,
-            location.file,
-            file.include,
-            string(file.path),
-        };
-    }
-
-    template <typename Callback>
-    bool lookupRelation(const binary::Symbol* symbol,
-                        RelationKind::Kind kind,
-                        const Callback& callback) {
-        if(symbol) {
-            for(auto& relation: relations(*symbol)) {
-                if(relation.kind & kind) {
-                    FullLocation location = decompose(relation.location);
-                    callback(location);
-                }
-            }
-            return true;
-        }
-
-        return false;
-    }
-
-    /// Locate the symbol with the given id.
-    llvm::ArrayRef<binary::Symbol> locateSymbol(uint64_t id) {
-        struct Compare {
-            bool operator() (const binary::Symbol& symbol, uint64_t id) const {
-                return symbol.id < id;
-            }
-
-            bool operator() (uint64_t id, const binary::Symbol& symbol) const {
-                return id < symbol.id;
-            }
-        };
-
-        auto range = std::equal_range(symbols().begin(), symbols().end(), id, Compare{});
-        return {range.first, range.second};
-    }
-
-    /// Locate the file with the given path.
-    llvm::ArrayRef<binary::File> locateFile(llvm::StringRef path) {
-        struct Compare {
-            Loader& loader;
-
-            bool operator() (const binary::File& file, llvm::StringRef path) const {
-                return loader.string(file.path) < path;
-            }
-
-            bool operator() (llvm::StringRef path, const binary::File& file) const {
-                return path < loader.string(file.path);
-            }
-        };
-
-        auto range = std::equal_range(files().begin(), files().end(), path, Compare{*this});
-        return {range.first, range.second};
-    }
-
-    const binary::Index& getIndex() const {
-        return index;
-    }
-
-private:
-    std::vector<char> binary;
-    const binary::Index& index;
-};
-
-}  // namespace clice::index
diff --git a/include/Index/Memory.h b/include/Index/Memory.h
new file mode 100644
index 00000000..17f60cec
--- /dev/null
+++ b/include/Index/Memory.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Index.h"
+
+namespace clice::index {
+
+namespace memory {
+
+using String = std::string;
+
+template <typename T>
+using Array = std::vector<T>;
+
+#define MAKE_CLANG_HAPPY
+#include "Index.inl"
+
+}  // namespace memory
+
+/// Index the AST information.
+memory::Index index(ASTInfo& info);
+
+/// Convert `memory::Index` to JSON.
+json::Value toJSON(const memory::Index& index);
+
+}  // namespace clice::index
diff --git a/include/Index/Relation.h b/include/Index/Relation.h
deleted file mode 100644
index ba0cca43..00000000
--- a/include/Index/Relation.h
+++ /dev/null
@@ -1,85 +0,0 @@
-#include <Support/Enum.h>
-
-namespace clice::index {
-
-/// A bit field enum to describe the kind of relation between two symbols.
-struct RelationKind : support::Enum<RelationKind, true, uint32_t> {
-    using Enum::Enum;
-
-    enum Kind : uint32_t {
-        Invalid,
-        Declaration,
-        Definition,
-        Reference,
-        // Write Relation.
-        Read,
-        Write,
-        Interface,
-        Implementation,
-        /// When target is a type definition of source, source is possible type or constructor.
-        TypeDefinition,
-
-        /// When target is a base class of source.
-        Base,
-        /// When target is a derived class of source.
-        Derived,
-
-        /// When target is a constructor of source.
-        Constructor,
-        /// When target is a destructor of source.
-        Destructor,
-
-        // When target is a caller of source.
-        Caller,
-        // When target is a callee of source.
-        Callee,
-    };
-};
-
-template <typename T>
-struct Ref {
-    std::uint32_t offset = std::numeric_limits<std::uint32_t>::max();
-
-    bool isValid() const {
-        return offset != std::numeric_limits<std::uint32_t>::max();
-    }
-
-    bool isInvalid() const {
-        return !isValid();
-    }
-
-    explicit operator bool () const {
-        return isValid();
-    }
-
-    friend constexpr auto operator<=> (const Ref& lhs, const Ref& rhs) = default;
-};
-
-struct LocationRef : Ref<LocationRef> {};
-
-struct SymOrLocRef : Ref<SymOrLocRef> {};
-
-struct Relation {
-    /// The kind of the relation.
-    RelationKind kind;
-
-    /// The index of location in `Index::locations`.
-    LocationRef location;
-
-    /// Additional information based on the `Relation::kind`. For `Declaration` and `Definition`,
-    /// this is the source range of the whole entity(`Relation::location` is just the range of
-    /// symbol name). For kinds whose target symbol is different from the source symbol, e.g.
-    /// `TypeDefinition` and `Base`, this is the index of target symbol in `Index::symbols`.
-    SymOrLocRef symOrLoc;
-
-    static bool isSymbol(const Relation& relation) {
-        auto kind = relation.kind;
-        return kind & RelationKind::Interface || kind & RelationKind::Implementation ||
-               kind & RelationKind::TypeDefinition || kind & RelationKind::Base ||
-               kind & RelationKind::Derived || kind & RelationKind::Constructor ||
-               kind & RelationKind::Destructor || kind & RelationKind::Caller ||
-               kind & RelationKind::Callee;
-    }
-};
-
-}  // namespace clice::index
diff --git a/include/Index/Serialize.h b/include/Index/Serialize.h
deleted file mode 100644
index ce4e3f9f..00000000
--- a/include/Index/Serialize.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#pragma once
-
-#include <Index/Indexer.h>
-#include <Support/JSON.h>
-
-namespace clice::index {
-
-/// Serialize the index to JSON format.
-json::Value toJson(const memory::Index& index);
-
-/// This defines the structures that used to serialize the index to binary format.
-/// All pointers are serialized as offsets to the beginning of the binary.
-namespace binary {
-
-template <typename T>
-struct array {
-    uint32_t offset;
-    uint32_t size;
-
-    using value_type = T;
-};
-
-using string = array<char>;
-
-using File = index::File<string>;
-
-using Symbol = index::Symbol<string, array>;
-
-using Index = index::Index<string, array>;
-
-}  // namespace binary
-
-/// Serialize the index to binary format. The binary format is a sequence of bytes.
-/// `binary::Index` is at the beginning of the binary.
-std::vector<char> toBinary(const memory::Index& index);
-
-/// TODO: ... support more serialization formats.
-
-}  // namespace clice::index
-
diff --git a/include/Server/Scheduler.h b/include/Server/Scheduler.h
index d7e8d300..5fc59f17 100644
--- a/include/Server/Scheduler.h
+++ b/include/Server/Scheduler.h
@@ -70,7 +70,7 @@ struct File {
 };
 
 class Scheduler {
-public:
+private:
     async::promise<void> updatePCH(llvm::StringRef path,
                                    llvm::StringRef content,
                                    llvm::ArrayRef<const char*> args);
@@ -81,10 +81,7 @@ public:
 
     async::promise<void> buildAST(llvm::StringRef path, llvm::StringRef content);
 
-    async::promise<proto::CompletionResult> codeComplete(llvm::StringRef path,
-                                                         unsigned int line,
-                                                         unsigned int column);
-
+public:
     async::promise<void> add(llvm::StringRef path, llvm::StringRef content);
 
     async::promise<void> update(llvm::StringRef path, llvm::StringRef content);
@@ -93,6 +90,10 @@ public:
 
     async::promise<void> close(llvm::StringRef path);
 
+    async::promise<proto::CompletionResult> codeComplete(llvm::StringRef path,
+                                                         unsigned int line,
+                                                         unsigned int column);
+
     /// Schedule a task for a file. If the file is building, the task will be
     /// appended to the task list of the file and wait for the building to finish.
     /// Otherwise, the task will be executed immediately.
diff --git a/src/Basic/SymbolKind.cpp b/src/Compiler/Semantic.cpp
similarity index 96%
rename from src/Basic/SymbolKind.cpp
rename to src/Compiler/Semantic.cpp
index f8e5e0da..3611ff17 100644
--- a/src/Basic/SymbolKind.cpp
+++ b/src/Compiler/Semantic.cpp
@@ -1,5 +1,4 @@
-#include "Basic/SymbolKind.h"
-#include "Compiler/Compiler.h"
+#include "Compiler/Semantic.h"
 
 namespace clice {
 
diff --git a/src/Feature/CodeCompletion.cpp b/src/Feature/CodeCompletion.cpp
index 96cc96cf..a4f5ee0c 100644
--- a/src/Feature/CodeCompletion.cpp
+++ b/src/Feature/CodeCompletion.cpp
@@ -1,7 +1,6 @@
 #include <Basic/URI.h>
 #include <Basic/SourceCode.h>
-#include <Basic/SymbolKind.h>
-#include <Compiler/Compiler.h>
+#include <Compiler/Semantic.h>
 #include <Feature/CodeCompletion.h>
 
 namespace clice::feature {
diff --git a/src/Feature/SemanticTokens.cpp b/src/Feature/SemanticTokens.cpp
index 1fb4b4a8..843faee3 100644
--- a/src/Feature/SemanticTokens.cpp
+++ b/src/Feature/SemanticTokens.cpp
@@ -23,9 +23,7 @@ class HighlightBuilder : public SemanticVisitor<HighlightBuilder> {
 public:
     HighlightBuilder(ASTInfo& compiler) : SemanticVisitor<HighlightBuilder>(compiler, true) {}
 
-    void handleOccurrence(const clang::Decl* decl,
-                          clang::SourceLocation location,
-                          OccurrenceKind kind = OccurrenceKind::Source) {
+    void handleOccurrence(const clang::Decl* decl, clang::SourceRange range, RelationKind kind) {
         proto::SemanticTokenType type = proto::SemanticTokenType::Invalid;
         if(llvm::isa<clang::NamespaceDecl, clang::NamespaceAliasDecl>(decl)) {
             type = proto::SemanticTokenType::Namespace;
@@ -59,7 +57,7 @@ public:
         }
 
         if(type != proto::SemanticTokenType::Invalid) {
-            addToken(location, type);
+            addToken(range.getBegin(), type);
         }
     }
 
diff --git a/src/Index/Binary.cpp b/src/Index/Binary.cpp
new file mode 100644
index 00000000..bd02ac4a
--- /dev/null
+++ b/src/Index/Binary.cpp
@@ -0,0 +1,10 @@
+#include "Index/Binary.h"
+
+namespace clice::index {
+
+binary::Index toBinary(const memory::Index& index) {
+    binary::Index binary = {};
+    return binary;
+}
+
+}  // namespace clice::index
diff --git a/src/Index/Memory.cpp b/src/Index/Memory.cpp
new file mode 100644
index 00000000..68690bfd
--- /dev/null
+++ b/src/Index/Memory.cpp
@@ -0,0 +1,145 @@
+#include "Index/Memory.h"
+
+namespace clice::index {
+
+namespace {
+
+class IndexBuilder : public SemanticVisitor<IndexBuilder> {
+public:
+    IndexBuilder(ASTInfo& info) : SemanticVisitor(info) {}
+
+    /// Add a file to the index.
+    FileRef addFile(clang::FileID id) {
+        auto& files = index->files;
+
+        /// Try to insert the file into the cache.
+        auto [iter, success] = fileCache.try_emplace(id, files.size());
+        uint32_t offset = iter->second;
+
+        /// If insertion is successful, add the file to the index.
+        if(success) {
+            files.emplace_back();
+
+            /// FIXME: handle error.
+            auto entry = srcMgr.getFileEntryRefForID(id);
+            if(!entry) {
+                llvm::errs() << "File entry not found\n";
+                std::terminate();
+            }
+
+            /// FIXME: resolve the real path(consider real path).
+            // llvm::SmallString<128> path;
+            // if(auto error = fs::real_path(entry->getName(), path)) {
+            //     llvm::errs() << error.message() << "\n";
+            //     std::terminate();
+            // }
+
+            auto include = addLocation(srcMgr.getIncludeLoc(id));
+
+            /// Note that addLocation may invalidate the reference to files.
+            /// So we use the offset to access the file.
+            files[offset].path = entry->getName();
+            files[offset].include = include;
+        }
+
+        return FileRef{offset};
+    }
+
+    /// Add a symbol to the index.
+    LocationRef addLocation(clang::SourceRange range) {
+        auto [begin, end] = range;
+
+        /// FIXME: handle macro locations.
+        if(begin.isInvalid() || end.isInvalid() || begin.isMacroID() || end.isMacroID()) {
+            return LocationRef{};
+        }
+
+        /// Try to insert the location into the cache.
+        auto [iter, success] = locationCache.try_emplace({begin, end}, index->locations.size());
+        uint32_t offset = iter->second;
+
+        /// If insertion is successful, add the location to the index.
+        if(success) {
+            auto& locations = index->locations;
+            locations.emplace_back();
+
+            auto beginLoc = srcMgr.getPresumedLoc(begin);
+            auto endTok = clang::Lexer::getLocForEndOfToken(end, 0, srcMgr, sema.getLangOpts());
+            auto endLoc = srcMgr.getPresumedLoc(endTok);
+
+            /// FIXME: position encoding.
+            locations[offset].range.start.line = beginLoc.getLine() - 1;
+            locations[offset].range.start.character = beginLoc.getColumn() - 1;
+            locations[offset].range.end.line = endLoc.getLine() - 1;
+            locations[offset].range.end.character = endLoc.getColumn() - 1;
+            locations[offset].file = addFile(srcMgr.getFileID(begin));
+        }
+
+        return LocationRef{offset};
+    }
+
+    /// Add a symbol to the index.
+    void addSymbol(const clang::NamedDecl* decl) {
+        if(!decl) {
+            llvm::errs() << "Invalid decl\n";
+            std::terminate();
+        }
+
+        if(auto instantiated = instantiatedFrom(decl)) {
+            decl = instantiated;
+        }
+
+        auto& symbols = index->symbols;
+        auto canonical = decl->getCanonicalDecl();
+
+        /// Try to insert the symbol into the cache.
+        auto [iter, success] = symbolCache.try_emplace(canonical, symbols.size());
+        uint32_t offset = iter->second;
+
+        /// If insertion is successful, add the symbol to the index.
+        if(success) {
+            memory::Symbol& symbol = symbols.emplace_back();
+            llvm::SmallString<128> USR;
+            /// clang::index::generateUSRForDecl(canonical, USR);
+            symbol.id = llvm::xxHash64(USR);
+            symbol.name = decl->getNameAsString();
+        }
+
+        /// return SymbolProxy(offset, *this);
+    }
+
+public:
+    using SemanticVisitor::handleOccurrence;
+
+    void handleOccurrence(const clang::Decl* decl,
+                          clang::SourceRange range,
+                          RelationKind kind = RelationKind::Invalid) {}
+
+private:
+    /// Index cache.
+    using SourceRange = std::pair<clang::SourceLocation, clang::SourceLocation>;
+    llvm::DenseMap<clang::FileID, std::size_t> fileCache;
+    llvm::DenseMap<const clang::Decl*, std::size_t> symbolCache;
+    llvm::DenseMap<SourceRange, std::size_t> locationCache;
+
+    /// Index result.
+    memory::Index* index = nullptr;
+};
+
+}  // namespace
+
+/// Index the AST information.
+memory::Index index(ASTInfo& info) {
+    memory::Index index = {};
+    IndexBuilder builder(info);
+    builder.TraverseAST(info.context());
+    return index;
+}
+
+/// Convert `memory::Index` to JSON.
+json::Value toJSON(const memory::Index& index) {
+    json::Value value = {};
+    return value;
+}
+
+}  // namespace clice::index
diff --git a/src/Index/Serialize.cpp b/src/Index/Serialize.cpp
index 97ba42f9..349416dc 100644
--- a/src/Index/Serialize.cpp
+++ b/src/Index/Serialize.cpp
@@ -1,123 +1,125 @@
-#include <Index/Serialize.h>
-#include <Support/Support.h>
-
-namespace clice::index {
-
-json::Value toJson(const memory::Index& index) {
-    return json::serialize(index);
-}
-
-namespace {
-
-class Packer {
-
-    template <typename T>
-    struct Section {
-        std::size_t offset;
-        std::size_t count;
-        std::vector<T> data;
-    };
-
-    template <typename... Ts>
-    struct Sections {
-        std::tuple<Section<Ts>...> sections;
-
-        /// FIXME: use more flexible way to initialize the layout.
-        void initLayout(std::size_t& offset, const memory::Index& index) {
-            get<binary::string>().count = index.commands.size();
-            get<binary::File>().count = index.files.size();
-            get<binary::Symbol>().count = index.symbols.size();
-            get<Occurrence>().count = index.occurrences.size();
-
-            for(auto& symbol: index.symbols) {
-                get<Relation>().count += symbol.relations.size();
-            }
-
-            get<Location>().count = index.locations.size();
-
-            auto foreach = [&]<typename T>() {
-                auto& section = std::get<Section<T>>(sections);
-                section.offset = offset;
-                section.data.reserve(section.count);
-                offset += section.count * sizeof(T);
-            };
-
-            (foreach.template operator()<Ts>(), ...);
-        }
-
-        template <typename T>
-        auto& get() {
-            return std::get<Section<T>>(sections);
-        }
-    };
-
-public:
-    template <typename In, typename Out>
-    void pack(const In& in, Out& out) {
-        if constexpr(requires { out = in; }) {
-            out = in;
-        } else {
-            support::foreach(in, out, [&]<typename U>(const auto& in, U& out) { pack(in, out); });
-        }
-    }
-
-    template <typename T, typename U>
-    void pack(const std::vector<T>& in, binary::array<U>& out) {
-        auto& section = sections.get<U>();
-        out.size = in.size();
-        out.offset = section.offset + sizeof(U) * section.data.size();
-
-        for(const auto& item: in) {
-            pack(item, section.data.emplace_back());
-        }
-    }
-
-    void pack(const memory::string& in, binary::string& out) {
-        out.size = in.size();
-        out.offset = stringOffset;
-
-        if(in.size() != 0) {
-            stringBuffer.insert(stringBuffer.end(), in.begin(), in.end());
-            stringBuffer.push_back('\0');
-            stringOffset += in.size() + 1;
-        }
-    }
-
-    std::vector<char> pack(const memory::Index& in) {
-        binary::Index out = {};
-        stringOffset = sizeof(binary::Index);
-        sections.initLayout(stringOffset, in);
-
-        pack(in, out);
-
-        std::vector<char> binary;
-        binary.reserve(stringOffset);
-        binary.insert(binary.end(),
-                      reinterpret_cast<char*>(&out),
-                      reinterpret_cast<char*>(&out + 1));
-        std::apply(
-            [&binary](auto&... section) {
-                (binary.insert(binary.end(),
-                               reinterpret_cast<char*>(section.data.data()),
-                               reinterpret_cast<char*>(section.data.data() + section.data.size())),
-                 ...);
-            },
-            sections.sections);
-
-        binary.insert(binary.end(), stringBuffer.begin(), stringBuffer.end());
-        return binary;
-    }
-
-private:
-    Sections<binary::string, binary::File, binary::Symbol, Occurrence, Relation, Location> sections;
-    std::size_t stringOffset;
-    std::vector<char> stringBuffer;
-};
-
-}  // namespace
-
-std::vector<char> toBinary(const memory::Index& index) {
-    return Packer().pack(index);
-}
-
-}  // namespace clice::index
+// #include <Index/Serialize.h>
+// #include <Support/Support.h>
+//
+// namespace clice::index {
+//
+// json::Value toJson(const memory::Index& index) {
+//     return json::serialize(index);
+// }
+//
+// namespace {
+//
+// class Packer {
+//
+//     template <typename T>
+//     struct Section {
+//         std::size_t offset;
+//         std::size_t count;
+//         std::vector<T> data;
+//     };
+//
+//     template <typename... Ts>
+//     struct Sections {
+//         std::tuple<Section<Ts>...> sections;
+//
+//         /// FIXME: use more flexible way to initialize the layout.
+//         void initLayout(std::size_t& offset, const memory::Index& index) {
+//             get<binary::string>().count = index.commands.size();
+//             get<binary::File>().count = index.files.size();
+//             get<binary::Symbol>().count = index.symbols.size();
+//             get<Occurrence>().count = index.occurrences.size();
+//
+//             for(auto& symbol: index.symbols) {
+//                 get<Relation>().count += symbol.relations.size();
+//             }
+//
+//             get<Location>().count = index.locations.size();
+//
+//             auto foreach = [&]<typename T>() {
+//                 auto& section = std::get<Section<T>>(sections);
+//                 section.offset = offset;
+//                 section.data.reserve(section.count);
+//                 offset += section.count * sizeof(T);
+//             };
+//
+//             (foreach.template operator()<Ts>(), ...);
+//         }
+//
+//         template <typename T>
+//         auto& get() {
+//             return std::get<Section<T>>(sections);
+//         }
+//     };
+//
+// public:
+//     template <typename In, typename Out>
+//     void pack(const In& in, Out& out) {
+//         if constexpr(requires { out = in; }) {
+//             out = in;
+//         } else {
+//             support::foreach(in, out, [&]<typename U>(const auto& in, U& out) { pack(in, out);
+//             });
+//         }
+//     }
+//
+//     template <typename T, typename U>
+//     void pack(const std::vector<T>& in, binary::array<U>& out) {
+//         auto& section = sections.get<U>();
+//         out.size = in.size();
+//         out.offset = section.offset + sizeof(U) * section.data.size();
+//
+//         for(const auto& item: in) {
+//             pack(item, section.data.emplace_back());
+//         }
+//     }
+//
+//     void pack(const memory::string& in, binary::string& out) {
+//         out.size = in.size();
+//         out.offset = stringOffset;
+//
+//         if(in.size() != 0) {
+//             stringBuffer.insert(stringBuffer.end(), in.begin(), in.end());
+//             stringBuffer.push_back('\0');
+//             stringOffset += in.size() + 1;
+//         }
+//     }
+//
+//     std::vector<char> pack(const memory::Index& in) {
+//         binary::Index out = {};
+//         stringOffset = sizeof(binary::Index);
+//         sections.initLayout(stringOffset, in);
+//
+//         pack(in, out);
+//
+//         std::vector<char> binary;
+//         binary.reserve(stringOffset);
+//         binary.insert(binary.end(),
+//                       reinterpret_cast<char*>(&out),
+//                       reinterpret_cast<char*>(&out + 1));
+//         std::apply(
+//             [&binary](auto&... section) {
+//                 (binary.insert(binary.end(),
+//                                reinterpret_cast<char*>(section.data.data()),
+//                                reinterpret_cast<char*>(section.data.data() +
+//                                section.data.size())),
+//                  ...);
+//             },
+//             sections.sections);
+//
+//         binary.insert(binary.end(), stringBuffer.begin(), stringBuffer.end());
+//         return binary;
+//     }
+//
+// private:
+//     Sections<binary::string, binary::File, binary::Symbol, Occurrence, Relation, Location>
+//     sections; std::size_t stringOffset; std::vector<char> stringBuffer;
+// };
+//
+// }  // namespace
+//
+// std::vector<char> toBinary(const memory::Index& index) {
+//     return Packer().pack(index);
+// }
+//
+// }  // namespace clice::index
+//
diff --git a/src/Index/SymbolBuilder.h b/src/Index/SymbolBuilder.h
deleted file mode 100644
index 03257771..00000000
--- a/src/Index/SymbolBuilder.h
+++ /dev/null
@@ -1,218 +0,0 @@
-#pragma once
-
-#include <clang/AST/DeclCXX.h>
-#include <clang/Index/USRGeneration.h>
-
-#include <Compiler/Utility.h>
-#include <Compiler/Compiler.h>
-#include <Index/Indexer.h>
-#include <Support/FileSystem.h>
-
-namespace clice::index {
-
-namespace {
-
-/// Responsible for building the symbol index.
-class SymbolBuilder {
-public:
-    SymbolBuilder(clang::Sema& sema, clang::syntax::TokenBuffer& tokBuf) :
-        sema(sema), context(sema.getASTContext()), srcMgr(context.getSourceManager()),
-        tokBuf(tokBuf) {}
-
-    /// Add a file to the index.
-    FileRef addFile(clang::FileID id) {
-        auto& files = index->files;
-
-        /// Try to insert the file into the cache.
-        auto [iter, success] = fileCache.try_emplace(id, files.size());
-        uint32_t offset = iter->second;
-
-        /// If insertion is successful, add the file to the index.
-        if(success) {
-            files.emplace_back();
-
-            /// FIXME: handle error.
-            auto entry = srcMgr.getFileEntryRefForID(id);
-            if(!entry) {
-                llvm::errs() << "File entry not found\n";
-                std::terminate();
-            }
-
-            /// FIXME: resolve the real path(consider real path).
-            // llvm::SmallString<128> path;
-            // if(auto error = fs::real_path(entry->getName(), path)) {
-            //     llvm::errs() << error.message() << "\n";
-            //     std::terminate();
-            // }
-
-            auto include = addLocation(srcMgr.getIncludeLoc(id));
-
-            /// Note that addLocation may invalidate the reference to files.
-            /// So we use the offset to access the file.
-            files[offset].path = entry->getName();
-            files[offset].include = include;
-        }
-
-        return FileRef{offset};
-    }
-
-    /// Add a symbol to the index.
-    LocationRef addLocation(clang::SourceRange range) {
-        auto [begin, end] = range;
-
-        /// FIXME: handle macro locations.
-        if(begin.isInvalid() || end.isInvalid() || begin.isMacroID() || end.isMacroID()) {
-            return LocationRef{};
-        }
-
-        /// Try to insert the location into the cache.
-        auto [iter, success] = locationCache.try_emplace({begin, end}, index->locations.size());
-        uint32_t offset = iter->second;
-
-        /// If insertion is successful, add the location to the index.
-        if(success) {
-            auto& locations = index->locations;
-            locations.emplace_back();
-
-            auto beginLoc = srcMgr.getPresumedLoc(begin);
-            auto endTok = clang::Lexer::getLocForEndOfToken(end, 0, srcMgr, sema.getLangOpts());
-            auto endLoc = srcMgr.getPresumedLoc(endTok);
-
-            /// FIXME: position encoding.
-            locations[offset].begin.line = beginLoc.getLine() - 1;
-            locations[offset].begin.column = beginLoc.getColumn() - 1;
-            locations[offset].end.line = endLoc.getLine() - 1;
-            locations[offset].end.column = endLoc.getColumn() - 1;
-            locations[offset].file = addFile(srcMgr.getFileID(begin));
-        }
-
-        return LocationRef{offset};
-    }
-
-    friend class SymbolProxy;
-
-    /// A proxy class for symbol reference for convenient usage.
-    class SymbolProxy {
-    public:
-        explicit SymbolProxy(uint32_t offset, SymbolBuilder& builder) :
-            offset(offset), builder(builder) {}
-
-        SymbolProxy addOccurrence(LocationRef location) {
-            assert(location.isValid() && "Invalid location");
-            auto& occurrences = builder.index->occurrences;
-            occurrences.emplace_back(location, SymbolRef{offset});
-            return *this;
-        }
-
-        SymbolProxy addRelation(RelationKind kind,
-                                LocationRef location,
-                                SymOrLocRef symOrLoc = {}) {
-            assert(location.isValid() && "Invalid location");
-            auto& relations = builder.index->symbols[offset].relations;
-            relations.emplace_back(kind, location, symOrLoc);
-            return *this;
-        }
-
-        SymbolProxy addReference(LocationRef location) {
-            RelationKind kind = RelationKind::Reference;
-            return addRelation(kind, location);
-        }
-
-        SymbolProxy addDeclaration(LocationRef location) {
-            RelationKind kind = RelationKind::Reference;
-            kind &= RelationKind::Declaration;
-            return addRelation(kind, location);
-        }
-
-        SymbolProxy addDefinition(LocationRef location) {
-            RelationKind kind = RelationKind::Reference;
-            kind &= RelationKind::Declaration;
-            kind &= RelationKind::Definition;
-            return addRelation(kind, location);
-        }
-
-        SymbolProxy addDeclarationOrDefinition(bool isDefinition, LocationRef location) {
-            return isDefinition ? addDefinition(location) : addDeclaration(location);
-        }
-
-        SymbolProxy addTypeDefinition(clang::QualType type) {
-            if(auto decl = declForType(type)) {
-                /// FIXME: figure out Symbol lookup.
-                if(auto location = builder.addLocation(decl->getLocation())) {
-                    auto symbol = builder.addSymbol(decl);
-                    return addRelation(RelationKind::TypeDefinition,
-                                       location,
-                                       SymOrLocRef{symbol.offset});
-                }
-            }
-            return *this;
-        }
-
-    private:
-        uint32_t offset;
-        SymbolBuilder& builder;
-    };
-
-    /// Add a symbol to the index.
-    SymbolProxy addSymbol(const clang::NamedDecl* decl) {
-        if(!decl) {
-            llvm::errs() << "Invalid decl\n";
-            std::terminate();
-        }
-
-        if(auto instantiated = instantiatedFrom(decl)) {
-            decl = instantiated;
-        }
-
-        auto& symbols = index->symbols;
-        auto canonical = decl->getCanonicalDecl();
-
-        /// Try to insert the symbol into the cache.
-        auto [iter, success] = symbolCache.try_emplace(canonical, symbols.size());
-        uint32_t offset = iter->second;
-
-        /// If insertion is successful, add the symbol to the index.
-        if(success) {
-            memory::Symbol& symbol = symbols.emplace_back();
-            llvm::SmallString<128> USR;
-            clang::index::generateUSRForDecl(canonical, USR);
-            symbol.id = llvm::xxHash64(USR);
-            symbol.name = decl->getNameAsString();
-        }
-
-        return SymbolProxy(offset, *this);
-    }
-
-    bool alreadyVisited(const clang::Decl* decl) {
-        return symbolCache.contains(decl);
-    }
-
-    void indexTU(memory::Index& result, ASTInfo& compiler);
-
-    ~SymbolBuilder() {
-        // for(auto [decl, _]: symbolCache) {
-        //     decl->dump();
-        //     llvm::outs() << "-----------------------------------------------------------\n";
-        // }
-    }
-
-private:
-    clang::Sema& sema;
-    clang::ASTContext& context;
-    clang::SourceManager& srcMgr;
-    clang::syntax::TokenBuffer& tokBuf;
-
-    /// Index cache.
-    using SourceRange = std::pair<clang::SourceLocation, clang::SourceLocation>;
-    llvm::DenseMap<clang::FileID, std::size_t> fileCache;
-    llvm::DenseMap<const clang::Decl*, std::size_t> symbolCache;
-    llvm::DenseMap<SourceRange, std::size_t> locationCache;
-
-    /// Index result.
-    memory::Index* index = nullptr;
-};
-
-}  // namespace
-
-}  // namespace clice::index
-
diff --git a/src/Index/SymbolCollector.cpp b/src/Index/SymbolCollector.cpp
deleted file mode 100644
index 4c0a5939..00000000
--- a/src/Index/SymbolCollector.cpp
+++ /dev/null
@@ -1,648 +0,0 @@
-#include "SymbolBuilder.h"
-
-namespace clice::index {
-
-namespace {
-
-class SymbolCollector : public clang::RecursiveASTVisitor<SymbolCollector> {
-public:
-    using Base = clang::RecursiveASTVisitor<SymbolCollector>;
-
-    SymbolCollector(SymbolBuilder& builder, clang::ASTContext& context) :
-        builder(builder), context(context), srcMgr(context.getSourceManager()) {}
-
-public:
-    /// ============================================================================
-    ///                                Declaration
-    /// ============================================================================
-
-    VISIT_DECL(NamespaceDecl) {
-        /// `namespace Foo { }`
-        ///             ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-        }
-        return true;
-    }
-
-    VISIT_DECL(NamespaceAliasDecl) {
-        /// `namespace Foo = Bar`
-        ///             ^     ^~~~ reference
-        ///             ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-        }
-        if(auto location = builder.addLocation(decl->getTargetNameLoc())) {
-            auto symbol = builder.addSymbol(decl->getNamespace());
-            symbol.addOccurrence(location);
-            symbol.addReference(location);
-        }
-        return true;
-    }
-
-    VISIT_DECL(UsingDirectiveDecl) {
-        /// `using namespace Foo`
-        ///                   ^~~~~~~ reference
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl->getNominatedNamespace());
-            symbol.addOccurrence(location);
-            symbol.addReference(location);
-        }
-        return true;
-    }
-
-    VISIT_DECL(LabelDecl) {
-        /// `label:`
-        ///    ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-        }
-        return true;
-    }
-
-    VISIT_DECL(FieldDecl) {
-        /// `struct Foo { int bar; };`
-        ///                    ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-            symbol.addTypeDefinition(decl->getType());
-        }
-        return true;
-    }
-
-    VISIT_DECL(EnumConstantDecl) {
-        /// `enum Foo { bar = 1 };`
-        ///              ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-            symbol.addTypeDefinition(decl->getType());
-        }
-        return true;
-    }
-
-    /// FIXME: how to resolve shadow decls? a name could refer to multiple decls.
-    /// Don't need to handle UsingEnumDecl, it's handled by VisitTypeLoc.
-    VISIT_DECL(UsingDecl) {
-        return true;
-    }
-
-    VISIT_DECL(BindingDecl) {
-        /// `auto [a, b] = std::make_tuple(1, 2);`
-        ///        ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-            symbol.addTypeDefinition(decl->getType());
-        }
-        return true;
-    }
-
-    VISIT_DECL(TemplateTypeParmDecl) {
-        /// `template <typename T> ...`
-        ///                     ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-        }
-        return true;
-    }
-
-    VISIT_DECL(TemplateTemplateParmDecl) {
-        /// `template <template <typename> class T> ...`
-        ///                                      ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-        }
-        return true;
-    }
-
-    VISIT_DECL(NonTypeTemplateParmDecl) {
-        /// `template <int N> ...`
-        ///                ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-            symbol.addTypeDefinition(decl->getType());
-        }
-        return true;
-    }
-
-    VISIT_DECL(TagDecl) {
-        /// `Base::TraverseClassTemplate...Decl` will also traverse it's templated class.
-        /// We already handled the template class in `VisitClassTemplate...Decl`. So we skip
-        /// them here.
-        if(decl->getDescribedTemplate() ||
-           llvm::isa<clang::ClassTemplateSpecializationDecl,
-                     clang::ClassTemplatePartialSpecializationDecl>(decl)) {
-            return true;
-        }
-
-        /// `struct/class/union/enum Foo { };`
-        ///                           ^~~~ declaration/definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDeclarationOrDefinition(decl->isThisDeclarationADefinition(), location);
-        }
-        return true;
-    }
-
-    VISIT_DECL(ClassTemplateDecl) {
-        /// `template <typename T> class Foo { };`
-        ///                               ^~~~ declaration/definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDeclarationOrDefinition(decl->isThisDeclarationADefinition(), location);
-        }
-        return true;
-    }
-
-    VISIT_DECL(ClassTemplateSpecializationDecl) {
-        /// It's possible that a class template specialization is a full specialization or a
-        /// explicit instantiation. And `ClassTemplatePartialSpecializationDecl` is the subclass of
-        /// `ClassTemplateSpecializationDecl`, it is also handled here.
-        ///
-        /// For full specialization:
-        /// `template <> class Foo<int> { };`
-        ///                     ^~~~ declaration/definition
-        ///
-        /// For explicit instantiation:
-        /// `template class Foo<int>;`
-        ///                  ^~~~ reference
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            assert(decl->getSpecializationKind() != clang::TSK_ImplicitInstantiation &&
-                   "Implicit instantiation should not be handled here");
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            if(decl->isExplicitSpecialization()) {
-                symbol.addDeclarationOrDefinition(decl->isThisDeclarationADefinition(), location);
-            } else {
-                symbol.addReference(location);
-            }
-        }
-        return true;
-    }
-
-    VISIT_DECL(FunctionDecl) {
-        /// Because `TraverseFunctionTemplateDecl` will also traverse it's templated function. We
-        /// already handled the template function in `VisitFunctionTemplateDecl`. So we skip them
-        /// here.
-        if(decl->getDescribedFunctionTemplate()) {
-            return true;
-        }
-
-        /// `void foo();`
-        ///         ^~~~ declaration/definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDeclarationOrDefinition(decl->isThisDeclarationADefinition(), location);
-
-            if(auto CMD = llvm::dyn_cast<clang::CXXMethodDecl>(decl)) {
-                // FIXME: virtual override const ...
-
-                if(auto CCD = llvm::dyn_cast<clang::CXXConstructorDecl>(CMD)) {
-                    symbol.addTypeDefinition(CCD->getThisType());
-                }
-
-                // FIXME: CXXConversionDecl, CXXDestructorDecl
-            }
-
-            // FIXME: CXXDeductionGuideDecl
-        }
-        currentFunction = decl;
-        return true;
-    }
-
-    VISIT_DECL(FunctionTemplateDecl) {
-        /// `template <typename T> void foo();`
-        ///                               ^~~~ declaration/definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDeclarationOrDefinition(decl->isThisDeclarationADefinition(), location);
-        }
-
-        /// FIXME: Clang currently doesn't record the information of explicit instantiation
-        /// correctly. See https://github.com/llvm/llvm-project/issues/115418. And it is not added
-        /// to its lexical context. So here we use a workaround to handle explicit instantiation of
-        /// function template.
-        if(builder.alreadyVisited(decl)) {
-            return true;
-        }
-
-        for(auto spec: decl->specializations()) {
-            /// `template void foo<int>();`
-            ///                  ^~~~ reference
-            auto kind = spec->getTemplateSpecializationKind();
-            if(kind == clang::TSK_ExplicitInstantiationDeclaration ||
-               kind == clang::TSK_ExplicitInstantiationDefinition) {
-                /// WORKAROUND: Clang currently doesn't record the location of explicit
-                /// instantiation. Use the location of the point of instantiation instead.
-                if(auto location = builder.addLocation(spec->getPointOfInstantiation())) {
-                    auto symbol = builder.addSymbol(decl);
-                    symbol.addOccurrence(location);
-                    symbol.addReference(location);
-                }
-            }
-        }
-
-        return true;
-    }
-
-    VISIT_DECL(TypedefNameDecl) {
-        /// Skip the typedef name declaration that is a type alias template.
-        if(decl->getDescribedTemplate()) {
-            return true;
-        }
-
-        /// `typedef int Foo;`
-        ///               ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-            symbol.addTypeDefinition(decl->getUnderlyingType());
-        }
-        return true;
-    }
-
-    VISIT_DECL(TypeAliasTemplateDecl) {
-        /// FIXME: the location of type alias template is not recorded correctly, actually
-        /// it is the location of using keyword. But location its templated type is correct.
-        /// Temporarily use the location of the templated type.
-
-        /// `template <typename T> using Foo = T;`
-        ///                               ^~~~ definition
-        if(auto location = builder.addLocation(decl->getTemplatedDecl()->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-        }
-        return true;
-    }
-
-    VISIT_DECL(VarDecl) {
-        /// Because `TraverseVarTemplateSpecializationDecl` will also traverse it's templated
-        /// variable. We already handled the template variable in `VisitVar...`.
-        /// So we skip them here.
-        if(decl->getDescribedVarTemplate() ||
-           llvm::isa<clang::VarTemplateSpecializationDecl,
-                     clang::VarTemplatePartialSpecializationDecl>(decl)) {
-            return true;
-        }
-
-        /// `int foo;`
-        ///       ^~~~ declaration/definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDeclarationOrDefinition(decl->isThisDeclarationADefinition(), location);
-            symbol.addTypeDefinition(decl->getType());
-        }
-        return true;
-    }
-
-    VISIT_DECL(VarTemplateDecl) {
-        /// `template <typename T> int foo;`
-        ///                             ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDeclarationOrDefinition(decl->isThisDeclarationADefinition(), location);
-        }
-        return true;
-    }
-
-    VISIT_DECL(VarTemplateSpecializationDecl) {
-        /// FIXME: it's strange that `VarTemplateSpecializationDecl` occurs in the lexical context.
-        /// This should be a bug of clang. Skip it here. And clang also doesn't record the
-        /// information about explicit instantiation of var template correctly. Skip them
-        /// temporarily.
-        auto kind = decl->getSpecializationKind();
-        if(kind == clang::TSK_ImplicitInstantiation ||
-           kind == clang::TSK_ExplicitInstantiationDeclaration ||
-           kind == clang::TSK_ExplicitInstantiationDefinition) {
-            return true;
-        }
-
-        /// It's possible that a var template specialization is a full specialization or a explicit
-        /// instantiation. And `VarTemplatePartialSpecializationDecl` is the subclass of
-        /// `VarTemplateSpecializationDecl`, it is also handled here.
-        ///
-        /// For full specialization:
-        /// `template <> int foo<int>;`
-        ///                    ^~~~ declaration/definition
-        ///
-        /// For explicit instantiation:
-        /// `template int foo<int>;`
-        ///                ^~~~ reference
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            if(decl->isExplicitSpecialization()) {
-                symbol.addDeclarationOrDefinition(decl->isThisDeclarationADefinition(), location);
-            } else {
-                symbol.addReference(location);
-            }
-        }
-        return true;
-    }
-
-    VISIT_DECL(ConceptDecl) {
-        /// `template <typename T> concept Foo = ...;`
-        ///                                 ^~~~ definition
-        if(auto location = builder.addLocation(decl->getLocation())) {
-            auto symbol = builder.addSymbol(decl);
-            symbol.addOccurrence(location);
-            symbol.addDefinition(location);
-        }
-        return true;
-    }
-
-    bool TraverseConceptReference(clang::ConceptReference* reference) {
-        /// `requires Foo<T>;`
-        ///            ^~~~ reference
-        if(auto location = builder.addLocation(reference->getConceptNameLoc())) {
-            auto symbol = builder.addSymbol(reference->getNamedConcept());
-            symbol.addOccurrence(location);
-            symbol.addReference(location);
-        }
-
-        return Base::TraverseConceptReference(reference);
-    }
-
-    /// ============================================================================
-    ///                                  TypeLoc
-    /// ============================================================================
-
-    /// We don't care about type without location information.
-    constexpr bool TraverseType [[gnu::const]] (clang::QualType) {
-        return true;
-    }
-
-    VISIT_TYPELOC(TagTypeLoc) {
-        /// `struct Foo { }; Foo foo`
-        ///                   ^~~~ reference
-        if(auto location = builder.addLocation(loc.getNameLoc())) {
-            auto symbol = builder.addSymbol(loc.getDecl());
-            symbol.addOccurrence(location);
-            symbol.addReference(location);
-        }
-        return true;
-    }
-
-    VISIT_TYPELOC(TypedefTypeLoc) {
-        /// `using Foo = int; Foo foo`
-        ///                    ^~~~ reference
-        if(auto location = builder.addLocation(loc.getNameLoc())) {
-            auto symbol = builder.addSymbol(loc.getTypedefNameDecl());
-            symbol.addOccurrence(location);
-            symbol.addReference(location);
-        }
-        return true;
-    }
-
-    VISIT_TYPELOC(TemplateTypeParmTypeLoc) {
-        /// `template <typename T> void foo(T t)`
-        ///                                 ^~~~ reference
-        if(auto location = builder.addLocation(loc.getNameLoc())) {
-            auto symbol = builder.addSymbol(loc.getDecl());
-            symbol.addOccurrence(location);
-            symbol.addReference(location);
-        }
-        return true;
-    }
-
-    VISIT_TYPELOC(TemplateSpecializationTypeLoc) {
-        /// `std::vector<int> foo`
-        ///        ^~~~ reference
-        if(auto location = builder.addLocation(loc.getTemplateNameLoc())) {
-            auto symbol = builder.addSymbol(declForType(loc.getType()));
-            symbol.addOccurrence(location);
-            symbol.addReference(location);
-        }
-        return true;
-    }
-
-    VISIT_TYPELOC(DependentNameTypeLoc) {
-        loc.getNameLoc().dump(srcMgr);
-        return true;
-    }
-
-    VISIT_TYPELOC(DependentTemplateSpecializationTypeLoc) {
-        return true;
-    }
-
-    /// ============================================================================
-    ///                                Specifier
-    /// ============================================================================
-
-    bool TraverseCXXBaseSpecifier(const clang::CXXBaseSpecifier& base) {
-        return Base::TraverseCXXBaseSpecifier(base);
-    }
-
-    /// We don't care about name specifier without location information.
-    constexpr bool TraverseNestedNameSpecifier [[gnu::const]] (clang::NestedNameSpecifier*) {
-        return true;
-    }
-
-    bool TraverseNestedNameSpecifierLoc(clang::NestedNameSpecifierLoc loc) {
-        if(auto location = builder.addLocation(loc.getLocalSourceRange())) {
-            auto NNS = loc.getNestedNameSpecifier();
-            switch(NNS->getKind()) {
-                case clang::NestedNameSpecifier::Namespace: {
-                    auto symbol = builder.addSymbol(NNS->getAsNamespace());
-                    symbol.addOccurrence(location);
-                    symbol.addReference(location);
-                    break;
-                }
-                case clang::NestedNameSpecifier::NamespaceAlias: {
-                    auto symbol = builder.addSymbol(NNS->getAsNamespaceAlias());
-                    symbol.addOccurrence(location);
-                    symbol.addReference(location);
-                    break;
-                }
-                case clang::NestedNameSpecifier::Identifier: {
-                    assert(NNS->isDependent() && "Identifier NNS should be dependent");
-                    // FIXME: use TemplateResolver here.
-                    break;
-                }
-                case clang::NestedNameSpecifier::TypeSpec:
-                case clang::NestedNameSpecifier::TypeSpecWithTemplate:
-                case clang::NestedNameSpecifier::Global:
-                case clang::NestedNameSpecifier::Super: {
-                    break;
-                };
-            }
-        }
-
-        return Base::TraverseNestedNameSpecifierLoc(loc);
-    }
-
-    /// ============================================================================
-    ///                                 Statement
-    /// ============================================================================
-
-    VISIT_EXPR(DeclRefExpr) {
-        /// `foo = 1`
-        ///   ^~~~ reference
-        if(auto location = builder.addLocation(expr->getLocation())) {
-            auto symbol = builder.addSymbol(expr->getDecl());
-            symbol.addOccurrence(location);
-            symbol.addReference(location);
-        }
-        return true;
-    }
-
-    VISIT_EXPR(MemberExpr) {
-        /// `foo.bar`
-        ///       ^~~~ reference
-        if(auto location = builder.addLocation(expr->getMemberLoc())) {
-            auto symbol = builder.addSymbol(expr->getMemberDecl());
-            symbol.addOccurrence(location);
-            symbol.addReference(location);
-        }
-        return true;
-    }
-
-    // FIXME: modify template resolver to cache recursively resolved results.
-    VISIT_EXPR(DependentScopeDeclRefExpr) {
-        return true;
-    }
-
-    VISIT_EXPR(CXXDependentScopeMemberExpr) {
-        return true;
-    }
-
-    VISIT_EXPR(CallExpr) {
-        // TODO: consider lambda expression.
-        return true;
-    }
-
-    bool TraverseConstructorInitializer(clang::CXXCtorInitializer* init) {
-        return Base::TraverseConstructorInitializer(init);
-    }
-
-private:
-    SymbolBuilder& builder;
-    clang::ASTContext& context;
-    clang::SourceManager& srcMgr;
-
-    const clang::FunctionDecl* currentFunction = nullptr;
-};
-
-void sortSymbols(std::vector<memory::Symbol>& symbols, std::vector<Occurrence>& occurrences) {
-    const auto size = symbols.size();
-    std::vector<uint32_t> indices;
-    indices.reserve(size);
-    for(std::size_t index = 0; index < size; index++) {
-        indices.emplace_back(index);
-    }
-
-    llvm::sort(indices,
-               [&](uint32_t lhs, uint32_t rhs) { return symbols[lhs].id < symbols[rhs].id; });
-
-    std::vector<uint32_t> map;
-    map.resize(size);
-    for(std::size_t index = 0; index < size; index++) {
-        /// original index -> new index
-        map[indices[index]] = index;
-    }
-
-    /// Adjust the index in occurrences and relations.
-    for(auto& occurrence: occurrences) {
-        occurrence.symbol.offset = map[occurrence.symbol.offset];
-    }
-
-    for(auto& symbol: symbols) {
-        for(auto& relation: symbol.relations) {
-            // if(Relation::isSymbol(relation)) {
-            //     relation.symOrLoc = map[relation.symOrLoc];
-            // }
-        }
-    }
-
-    /// Sort symbols.
-    llvm::sort(symbols, [](const memory::Symbol& lhs, const memory::Symbol& rhs) {
-        return lhs.id < rhs.id;
-    });
-}
-
-void sortFiles(std::vector<memory::File>& files, std::vector<Location>& locations) {
-    const auto size = files.size();
-    std::vector<uint32_t> indices;
-    indices.reserve(size);
-    for(std::size_t index = 0; index < size; index++) {
-        indices.emplace_back(index);
-    }
-
-    llvm::sort(indices,
-               [&](uint32_t lhs, uint32_t rhs) { return files[lhs].path < files[rhs].path; });
-
-    std::vector<uint32_t> map;
-    map.resize(size);
-    for(std::size_t index = 0; index < size; index++) {
-        /// original index -> new index
-        map[indices[index]] = index;
-    }
-
-    /// Adjust the index in files and .
-    for(auto& location: locations) {
-        if(location.file.isValid()) {
-            location.file = FileRef{map[location.file.offset]};
-        }
-    }
-
-    /// Sort files.
-    llvm::sort(files, [](const memory::File& lhs, const memory::File& rhs) {
-        return lhs.path < rhs.path;
-    });
-}
-
-void SymbolBuilder::indexTU(memory::Index& result, ASTInfo& compiler) {
-    index = &result;
-    SymbolCollector collector(*this, compiler.tu()->getASTContext());
-    collector.TraverseAST(compiler.context());
-
-    /// Beacuse we store the index of symbols in Occurrence and Relation, Sorting symbols will
-    /// invalidate the index. So we need to adjust the them. First, we need to obtain the index
-    /// mapping before and after sorting.
-
-    sortFiles(result.files, result.locations);
-    sortSymbols(result.symbols, result.occurrences);
-
-    llvm::sort(result.occurrences, [&](const Occurrence& lhs, const Occurrence& rhs) {
-        if(lhs.location.isInvalid() || rhs.location.isInvalid()) {
-            std::terminate();
-        }
-        return result.locations[lhs.location.offset] < result.locations[rhs.location.offset];
-    });
-}
-
-}  // namespace
-
-memory::Index index(ASTInfo& compiler) {
-    memory::Index result;
-    SymbolBuilder builder(compiler.sema(), compiler.tokBuf());
-    builder.indexTU(result, compiler);
-    return std::move(result);
-};  // namespace clice::index
-
-}  // namespace clice::index
diff --git a/unittests/Index/Annotation.h b/unittests/Index/Annotation.h
index d5efea60..4501dde7 100644
--- a/unittests/Index/Annotation.h
+++ b/unittests/Index/Annotation.h
@@ -5,7 +5,6 @@
 
 namespace clice {
 
-using index::Position;
 
 class Annotation {
 public:
@@ -52,13 +51,13 @@ public:
         return m_source;
     }
 
-    Position position(llvm::StringRef key) const {
+    proto::Position position(llvm::StringRef key) const {
         return locations.lookup(key);
     }
 
 private:
     std::string m_source;
-    llvm::StringMap<Position> locations;
+    llvm::StringMap<proto::Position> locations;
 };
 
 }  // namespace clice
diff --git a/unittests/Index/Template.cpp b/unittests/Index/Template.cpp
index b2946474..de4acbda 100644
--- a/unittests/Index/Template.cpp
+++ b/unittests/Index/Template.cpp
@@ -1,8 +1,8 @@
 #include "Tester.h"
 
-namespace {
+namespace clice {
 
-using namespace clice;
+namespace {
 
 TEST(Index, ClassTemplate) {
     const char* code = R"cpp(
@@ -36,19 +36,19 @@ TEST(Index, ClassTemplate) {
     $(implicit_full)foo<int, int> a;
 )cpp";
 
-    IndexerTester tester(code);
-    tester.GotoDefinition("primary_decl", "primary");
-    tester.GotoDefinition("explicit_primary", "primary");
-    tester.GotoDefinition("implicit_primary_1", "primary");
-    tester.GotoDefinition("implicit_primary_2", "primary");
-
-    tester.GotoDefinition("partial_spec_decl", "partial_spec");
-    tester.GotoDefinition("explicit_partial", "partial_spec");
-    tester.GotoDefinition("implicit_partial", "partial_spec");
-
-    tester.GotoDefinition("forward_full", "full_spec");
-    tester.GotoDefinition("full_spec_decl", "full_spec");
-    tester.GotoDefinition("implicit_full", "full_spec");
+    // IndexerTester tester(code);
+    // tester.GotoDefinition("primary_decl", "primary");
+    // tester.GotoDefinition("explicit_primary", "primary");
+    // tester.GotoDefinition("implicit_primary_1", "primary");
+    // tester.GotoDefinition("implicit_primary_2", "primary");
+    //
+    // tester.GotoDefinition("partial_spec_decl", "partial_spec");
+    // tester.GotoDefinition("explicit_partial", "partial_spec");
+    // tester.GotoDefinition("implicit_partial", "partial_spec");
+    //
+    // tester.GotoDefinition("forward_full", "full_spec");
+    // tester.GotoDefinition("full_spec_decl", "full_spec");
+    // tester.GotoDefinition("implicit_full", "full_spec");
 
     /// TODO: add more tests, FunctionTemplate, VarTemplate, ..., Dependent Name, ..., etc.
     /// add tests for find references ..., !test symbol count.
@@ -73,13 +73,13 @@ TEST(Index, FunctionTemplate) {
     }
 )cpp";
 
-    IndexerTester tester(code, true);
-    tester.GotoDefinition("primary_decl", "primary");
-    tester.GotoDefinition("explicit_primary", "primary");
-    tester.GotoDefinition("implicit_primary", "primary");
-
-    tester.GotoDefinition("spec_decl", "spec");
-    tester.GotoDefinition("implicit_spec", "spec");
+    // IndexerTester tester(code, true);
+    // tester.GotoDefinition("primary_decl", "primary");
+    // tester.GotoDefinition("explicit_primary", "primary");
+    // tester.GotoDefinition("implicit_primary", "primary");
+    //
+    // tester.GotoDefinition("spec_decl", "spec");
+    // tester.GotoDefinition("implicit_spec", "spec");
 }
 
 TEST(Index, AliasTemplate) {
@@ -90,8 +90,8 @@ TEST(Index, AliasTemplate) {
     $(implicit_primary)foo<int> a;   
 )cpp";
 
-    IndexerTester tester(code, true);
-    tester.GotoDefinition("implicit_primary", "primary");
+    // IndexerTester tester(code, true);
+    // tester.GotoDefinition("implicit_primary", "primary");
 }
 
 TEST(Index, VarTemplate) {
@@ -124,17 +124,17 @@ TEST(Index, VarTemplate) {
     }
 )cpp";
 
-    IndexerTester tester(code);
-    tester.GotoDefinition("primary_decl", "primary");
-    // tester.GotoDefinition("explicit_primary", "primary");
-    tester.GotoDefinition("implicit_primary_1", "primary");
-    tester.GotoDefinition("implicit_primary_2", "primary");
-
-    tester.GotoDefinition("partial_spec_decl", "partial_spec");
-    // tester.GotoDefinition("explicit_partial", "partial_spec");
-    tester.GotoDefinition("implicit_partial", "partial_spec");
-
-    tester.GotoDefinition("implicit_full", "full_spec");
+    // IndexerTester tester(code);
+    // tester.GotoDefinition("primary_decl", "primary");
+    //// tester.GotoDefinition("explicit_primary", "primary");
+    // tester.GotoDefinition("implicit_primary_1", "primary");
+    // tester.GotoDefinition("implicit_primary_2", "primary");
+    //
+    // tester.GotoDefinition("partial_spec_decl", "partial_spec");
+    //// tester.GotoDefinition("explicit_partial", "partial_spec");
+    // tester.GotoDefinition("implicit_partial", "partial_spec");
+    //
+    // tester.GotoDefinition("implicit_full", "full_spec");
 }
 
 TEST(Index, Concept) {
@@ -147,11 +147,13 @@ TEST(Index, Concept) {
     $(implicit2)foo auto bar = 1;
 )cpp";
 
-    IndexerTester tester(code, true);
-    tester.GotoDefinition("primary", "primary");
-    tester.GotoDefinition("implicit", "primary");
-    tester.GotoDefinition("implicit2", "primary");
+    // IndexerTester tester(code, true);
+    // tester.GotoDefinition("primary", "primary");
+    // tester.GotoDefinition("implicit", "primary");
+    // tester.GotoDefinition("implicit2", "primary");
 }
 
 }  // namespace
 
+}  // namespace clice
+
diff --git a/unittests/Index/Tester.h b/unittests/Index/Tester.h
index f5723597..0fcdc095 100644
--- a/unittests/Index/Tester.h
+++ b/unittests/Index/Tester.h
@@ -4,7 +4,7 @@
 #include "Annotation.h"
 
 #include "Compiler/Compiler.h"
-#include "Index/Loader.h"
+// #include "Index/Loader.h"
 #include "Support/Support.h"
 
 namespace clice {
@@ -13,28 +13,28 @@ using namespace index;
 
 /// Recursively test the binary index has the totally same content
 /// with the original index.
-template <typename In, typename Out>
-void testEqual(const Loader& loader, const In& in, const Out& out) {
-    if constexpr(requires { in == out; }) {
-        EXPECT_TRUE(in == out);
-    } else if constexpr(std::is_same_v<Out, binary::string>) {
-        EXPECT_EQ(in, loader.string(out));
-    } else if constexpr(is_specialization_of<Out, binary::array>) {
-        using value_type = typename Out::value_type;
-        auto array = loader.make_range(out);
-        for(std::size_t i = 0; i < in.size(); i++) {
-            testEqual(loader, in[i], array[i]);
-        }
-    } else {
-        support::foreach(in, out, [&](const auto& lhs, const auto& rhs) {
-            testEqual(loader, lhs, rhs);
-        });
-    }
-}
+// template <typename In, typename Out>
+// void testEqual(const Loader& loader, const In& in, const Out& out) {
+//     if constexpr(requires { in == out; }) {
+//         EXPECT_TRUE(in == out);
+//     } else if constexpr(std::is_same_v<Out, binary::string>) {
+//         EXPECT_EQ(in, loader.string(out));
+//     } else if constexpr(is_specialization_of<Out, binary::array>) {
+//         using value_type = typename Out::value_type;
+//         auto array = loader.make_range(out);
+//         for(std::size_t i = 0; i < in.size(); i++) {
+//             testEqual(loader, in[i], array[i]);
+//         }
+//     } else {
+//         support::foreach(in, out, [&](const auto& lhs, const auto& rhs) {
+//             testEqual(loader, lhs, rhs);
+//         });
+//     }
+// }
 
 struct IndexerTester {
     Annotation annotation;
-    std::unique_ptr<Loader> loader;
+    /// std::unique_ptr<Loader> loader;
     std::unique_ptr<ASTInfo> compiler;
     FileRef mainFile;
 
@@ -51,48 +51,22 @@ struct IndexerTester {
         // compiler = std::make_unique<Compiler>("main.cpp", annotation.source(), args);
         // compiler->buildAST();
 
-        auto index = index::index(*compiler);
+        /// auto index = index::index(*compiler);
 
-        if(json) {
-            std::error_code error;
-            llvm::raw_fd_ostream file("index.json", error);
-            file << index::toJson(index);
-        }
+        // if(json) {
+        //     std::error_code error;
+        //     llvm::raw_fd_ostream file("index.json", error);
+        //     file << index::toJson(index);
+        // }
 
-        loader = std::make_unique<Loader>(index::toBinary(index));
+        /// loader = std::make_unique<Loader>(index::toBinary(index));
 
         /// Test equal here.
-        testEqual(*loader, index, loader->getIndex());
+        /// testEqual(*loader, index, loader->getIndex());
 
-        auto files = loader->locateFile("main.cpp");
-        assert(files.size() == 1);
-        mainFile = {static_cast<uint32_t>(files.begin() - loader->files().begin())};
-    }
-
-    void GotoDefinition(llvm::StringRef position) {
-        auto loc = annotation.position(position);
-        auto sym = loader->locateSymbol(mainFile, loc);
-        bool success = loader->lookupRelation(sym,
-                                              RelationKind::Definition,
-                                              [&](const FullLocation& location) {
-                                                  llvm::outs() << json::serialize(location) << "\n";
-                                              });
-        EXPECT_TRUE(success);
-    }
-
-    IndexerTester& GotoDefinition(llvm::StringRef position,
-                                  llvm::StringRef target,
-                                  std::source_location info = std::source_location::current()) {
-        auto loc = annotation.position(position);
-        auto sym = loader->locateSymbol(mainFile, loc);
-        bool success =
-            loader->lookupRelation(sym,
-                                   RelationKind::Definition,
-                                   [&](const FullLocation& location) {
-                                       EXPECT_EQ(location.begin, annotation.position(target));
-                                   });
-        EXPECT_TRUE(success);
-        return *this;
+        // auto files = loader->locateFile("main.cpp");
+        // assert(files.size() == 1);
+        // mainFile = {static_cast<uint32_t>(files.begin() - loader->files().begin())};
     }
 };